BedrockFetch/main.go

package main

import (
	"encoding/json"
	"fmt"
	"os"
	"strings"

	"sirherobrine23.com.br/go-bds/go-bds/bedrock"
	"sirherobrine23.com.br/go-bds/go-bds/utils/semver"
	"sirherobrine23.com.br/go-bds/request/gitea"
	gitea_api "sirherobrine23.com.br/go-bds/request/gitea/structs"
)

var (
	RootURL        = "https://sirherobrine23.com.br/api"
	Token   string = (func() string {
		if giteaToken := os.Getenv("GITEA_TOKEN"); len(giteaToken) > 0 {
			return giteaToken
		} else if ghToken := os.Getenv("GH_TOKEN"); len(ghToken) > 0 {
			return ghToken
		} else if githubToken := os.Getenv("GITHUB_TOKEN"); len(githubToken) > 0 {
			return githubToken
		}
		return ""
	})()
)

func processVersion() error {
	var versions, localVersions bedrock.Versions
	localFile, err := os.OpenFile("./versions.json", os.O_RDWR, 0)
	if err != nil {
		return err
	}
	defer localFile.Close()

	// Load versions to slice
	if err := json.NewDecoder(localFile).Decode(&localVersions); err != nil {
		return err
	}
	fmt.Printf("Loaded %d versions\n", len(localVersions))

	fmt.Println("Fetcing versions from minecraft.net")
	if err := versions.FetchFromMinecraftDotNet(); err != nil {
		return err
	}

	fmt.Printf("Versions located: %d\n", len(versions))
	if len(versions) == 0 {
		return fmt.Errorf("no versions found")
	}

	teaClient, err := gitea.NewClient(RootURL, "go-bds", "BedrockFetch", Token)
	if err != nil {
		return err
	}

	for _, version := range versions {
		if localVersions.HasVersion(version.Version) {
			fmt.Printf("Version aredy published: %s\n", version.Version)
			continue
		}
		fmt.Printf("Publishing version %s to Releaser\n", version.Version)

		release, err := teaClient.ReleaseTag(version.Version)
		if err != nil {
			release, err = teaClient.CreateRelease(&gitea_api.CreateReleaseOption{
				TagName:      version.Version,
				IsPrerelease: version.IsPreview,
				Title:        fmt.Sprintf("Bedrock server %s", version.Version),
			})
		}

		if err != nil {
			fmt.Printf("cannot make release to %s, error: %s\n", version.Version, err.Error())
			return err
		}

		newVersion := &bedrock.Version{
			Version:   version.Version,
			IsPreview: version.IsPreview,
			Docker:    nil,
			Plaforms:  map[string]*bedrock.PlatformVersion{},
		}
		localVersions = append(localVersions, newVersion)

		for platform, info := range version.Plaforms {
			fmt.Printf("Uploading server from %s\n", platform)
			name := strings.ReplaceAll(platform, "/", "_") + ".tgz"

			f, err := os.CreateTemp("", name)
			if err != nil {
				return fmt.Errorf("cannot create temp file: %w", err)
			}
			defer os.Remove(f.Name())
			defer f.Close()
			fmt.Printf("Converting %s %s to tar.gz...\n", version.Version, platform)

			sha1, err := info.ConvertTar(f)
			if err != nil {
				f.Close()
				os.Remove(f.Name())
				return err
			}
			f.Seek(0, 0)

			fileInfo, err := teaClient.UploadAsset(int(release.ID), name, f)
			if err != nil {
				f.Close()
				os.Remove(f.Name())
				return fmt.Errorf("cannot upload server tar.gz: %w", err)
			}
			f.Close()
			os.Remove(f.Name())
			
			fmt.Printf("Server (%s %s) release, Sha1: %s\n", version.Version, platform, sha1)
			newVersion.Plaforms[platform] = &bedrock.PlatformVersion{
				ReleaseDate: info.ReleaseDate,
				ZipSHA1:     info.ZipSHA1,
				ZipFile:     info.ZipFile,
				TarSHA1:     sha1,
				TarFile:     fileInfo.DownloadURL,
			}
		}
	}

	semver.Sort(localVersions)
	if _, err = localFile.Seek(0, 0); err != nil {
		return err
	} else if err = localFile.Truncate(0); err != nil {
		return err
	}

	enc := json.NewEncoder(localFile)
	enc.SetIndent("", "  ")
	return enc.Encode(localVersions)
}

func main() {
	if err := processVersion(); err != nil {
		fmt.Println(err.Error())
		os.Exit(1)
	}
}