package cli import ( "encoding/json" "fmt" "os" "path/filepath" "regexp" "strings" "github.com/satisfactorymodding/ficsit-cli/utils" "github.com/pkg/errors" "github.com/rs/zerolog/log" "github.com/spf13/viper" ) type InstallationsVersion int const ( InitialInstallationsVersion = InstallationsVersion(iota) // Always last nextInstallationsVersion ) type Installations struct { Version InstallationsVersion `json:"version"` Installations []*Installation `json:"installations"` SelectedInstallation string `json:"selected_installation"` } type Installation struct { Path string `json:"path"` Profile string `json:"profile"` } func InitInstallations() (*Installations, error) { localDir := viper.GetString("local-dir") installationsFile := filepath.Join(localDir, viper.GetString("installations-file")) _, err := os.Stat(installationsFile) if err != nil { if !os.IsNotExist(err) { return nil, errors.Wrap(err, "failed to stat installations file") } _, err := os.Stat(localDir) if err != nil { if !os.IsNotExist(err) { return nil, errors.Wrap(err, "failed to read cache directory") } err = os.MkdirAll(localDir, 0755) if err != nil { return nil, errors.Wrap(err, "failed to create cache directory") } } emptyInstallations := Installations{ Version: nextInstallationsVersion - 1, } if err := emptyInstallations.Save(); err != nil { return nil, errors.Wrap(err, "failed to save empty installations") } } installationsData, err := os.ReadFile(installationsFile) if err != nil { return nil, errors.Wrap(err, "failed to read installations") } var installations Installations if err := json.Unmarshal(installationsData, &installations); err != nil { return nil, errors.Wrap(err, "failed to unmarshal installations") } if installations.Version >= nextInstallationsVersion { return nil, fmt.Errorf("unknown installations version: %d", installations.Version) } return &installations, nil } func (i *Installations) Save() error { if viper.GetBool("dry-run") { log.Info().Msg("dry-run: skipping installation saving") return nil } installationsFile := filepath.Join(viper.GetString("local-dir"), viper.GetString("installations-file")) log.Info().Str("path", installationsFile).Msg("saving installations") installationsJSON, err := json.MarshalIndent(i, "", " ") if err != nil { return errors.Wrap(err, "failed to marshal installations") } if err := os.WriteFile(installationsFile, installationsJSON, 0755); err != nil { return errors.Wrap(err, "failed to write installations") } return nil } func (i *Installations) AddInstallation(ctx *GlobalContext, installPath string, profile string) (*Installation, error) { absolutePath, err := filepath.Abs(installPath) if err != nil { return nil, errors.Wrap(err, "could not resolve absolute path of: "+installPath) } installation := &Installation{ Path: absolutePath, Profile: profile, } if err := installation.Validate(ctx); err != nil { return nil, errors.Wrap(err, "failed to validate installation") } newStat, err := os.Stat(installation.Path) if err != nil { return nil, errors.Wrap(err, "failed to stat installation directory") } found := false for _, install := range i.Installations { stat, err := os.Stat(install.Path) if err != nil { continue } found = os.SameFile(newStat, stat) if found { break } } if found { return nil, errors.New("installation already present") } i.Installations = append(i.Installations, installation) return installation, nil } func (i *Installations) GetInstallation(installPath string) *Installation { for _, install := range i.Installations { if install.Path == installPath { return install } } return nil } func (i *Installations) DeleteInstallation(installPath string) error { found := -1 for j, install := range i.Installations { if install.Path == installPath { found = j break } } if found == -1 { return errors.New("installation not found") } i.Installations = append(i.Installations[:found], i.Installations[found+1:]...) return nil } func (i *Installation) Validate(ctx *GlobalContext) error { found := false for _, p := range ctx.Profiles.Profiles { if p.Name == i.Profile { found = true break } } if !found { return errors.New("profile not found") } foundExecutable := false _, err := os.Stat(filepath.Join(i.Path, "FactoryGame.exe")) if err != nil { if !os.IsNotExist(err) { return errors.Wrap(err, "failed reading FactoryGame.exe") } } else { foundExecutable = true } _, err = os.Stat(filepath.Join(i.Path, "FactoryServer.sh")) if err != nil { if !os.IsNotExist(err) { return errors.Wrap(err, "failed reading FactoryServer.sh") } } else { foundExecutable = true } _, err = os.Stat(filepath.Join(i.Path, "FactoryServer.exe")) if err != nil { if !os.IsNotExist(err) { return errors.Wrap(err, "failed reading FactoryServer.exe") } } else { foundExecutable = true } if !foundExecutable { return errors.New("did not find game executable in " + i.Path) } return nil } var ( lockFileCleaner = regexp.MustCompile(`[^a-zA-Z\d]]`) matchFirstCap = regexp.MustCompile(`(.)([A-Z][a-z]+)`) matchAllCap = regexp.MustCompile(`([a-z\d])([A-Z])`) ) func (i *Installation) LockFilePath(ctx *GlobalContext) (string, error) { platform, err := i.GetPlatform(ctx) if err != nil { return "", err } lockFileName := ctx.Profiles.Profiles[i.Profile].Name lockFileName = matchFirstCap.ReplaceAllString(lockFileName, "${1}_${2}") lockFileName = matchAllCap.ReplaceAllString(lockFileName, "${1}_${2}") lockFileName = lockFileCleaner.ReplaceAllLiteralString(lockFileName, "-") lockFileName = strings.ToLower(lockFileName) + "-lock.json" return filepath.Join(i.Path, platform.LockfilePath, lockFileName), nil } func (i *Installation) LockFile(ctx *GlobalContext) (*LockFile, error) { lockfilePath, err := i.LockFilePath(ctx) if err != nil { return nil, err } var lockFile *LockFile lockFileJSON, err := os.ReadFile(lockfilePath) if err != nil { if !os.IsNotExist(err) { return nil, errors.Wrap(err, "failed reading lockfile") } } else { if err := json.Unmarshal(lockFileJSON, &lockFile); err != nil { return nil, errors.Wrap(err, "failed parsing lockfile") } } return lockFile, nil } func (i *Installation) WriteLockFile(ctx *GlobalContext, lockfile LockFile) error { lockfilePath, err := i.LockFilePath(ctx) if err != nil { return err } marshaledLockfile, err := json.MarshalIndent(lockfile, "", " ") if err != nil { return errors.Wrap(err, "failed to serialize lockfile json") } if err := os.WriteFile(lockfilePath, marshaledLockfile, 0777); err != nil { return errors.Wrap(err, "failed writing lockfile") } return nil } type InstallUpdate struct { ModName string OverallProgress float64 DownloadProgress float64 ExtractProgress float64 } func (i *Installation) Install(ctx *GlobalContext, updates chan InstallUpdate) error { if err := i.Validate(ctx); err != nil { return errors.Wrap(err, "failed to validate installation") } lockFile, err := i.LockFile(ctx) if err != nil { return err } resolver := NewDependencyResolver(ctx.APIClient) gameVersion, err := i.GetGameVersion(ctx) if err != nil { return errors.Wrap(err, "failed to detect game version") } lockfile, err := ctx.Profiles.Profiles[i.Profile].Resolve(resolver, lockFile, gameVersion) if err != nil { return errors.Wrap(err, "could not resolve mods") } modsDirectory := filepath.Join(i.Path, "FactoryGame", "Mods") if err := os.MkdirAll(modsDirectory, 0777); err != nil { return errors.Wrap(err, "failed creating Mods directory") } dir, err := os.ReadDir(modsDirectory) if err != nil { return errors.Wrap(err, "failed to read mods directory") } for _, entry := range dir { if entry.IsDir() { if _, ok := lockfile[entry.Name()]; !ok { modDir := filepath.Join(modsDirectory, entry.Name()) _, err := os.Stat(filepath.Join(modDir, ".smm")) if err == nil { log.Info().Str("mod_reference", entry.Name()).Msg("deleting mod") if err := os.RemoveAll(modDir); err != nil { return errors.Wrap(err, "failed to delete mod directory") } } } } } completed := 0 for modReference, version := range lockfile { // Only install if a link is provided, otherwise assume mod is already installed if version.Link != "" { downloading := true var genericUpdates chan utils.GenericUpdate if updates != nil { genericUpdates = make(chan utils.GenericUpdate) go func() { update := InstallUpdate{ ModName: modReference, OverallProgress: float64(completed) / float64(len(lockfile)), DownloadProgress: 0, ExtractProgress: 0, } select { case updates <- update: default: } for up := range genericUpdates { if downloading { update.DownloadProgress = up.Progress } else { update.DownloadProgress = 1 update.ExtractProgress = up.Progress } select { case updates <- update: default: } } }() } log.Info().Str("mod_reference", modReference).Str("version", version.Version).Str("link", version.Link).Msg("downloading mod") reader, size, err := utils.DownloadOrCache(modReference+"_"+version.Version+".zip", version.Hash, version.Link, genericUpdates) if err != nil { return errors.Wrap(err, "failed to download "+modReference+" from: "+version.Link) } downloading = false log.Info().Str("mod_reference", modReference).Str("version", version.Version).Str("link", version.Link).Msg("extracting mod") if err := utils.ExtractMod(reader, size, filepath.Join(modsDirectory, modReference), version.Hash, genericUpdates); err != nil { return errors.Wrap(err, "could not extract "+modReference) } if genericUpdates != nil { close(genericUpdates) } } completed++ } if err := i.WriteLockFile(ctx, lockfile); err != nil { return err } return nil } func (i *Installation) SetProfile(ctx *GlobalContext, profile string) error { found := false for _, p := range ctx.Profiles.Profiles { if p.Name == profile { found = true break } } if !found { return errors.New("could not find profile: " + profile) } i.Profile = profile return nil } type gameVersionFile struct { MajorVersion int `json:"MajorVersion"` MinorVersion int `json:"MinorVersion"` PatchVersion int `json:"PatchVersion"` Changelist int `json:"Changelist"` CompatibleChangelist int `json:"CompatibleChangelist"` IsLicenseeVersion int `json:"IsLicenseeVersion"` IsPromotedBuild int `json:"IsPromotedBuild"` BranchName string `json:"BranchName"` BuildID string `json:"BuildId"` } func (i *Installation) GetGameVersion(ctx *GlobalContext) (int, error) { if err := i.Validate(ctx); err != nil { return 0, errors.Wrap(err, "failed to validate installation") } platform, err := i.GetPlatform(ctx) if err != nil { return 0, err } fullPath := filepath.Join(i.Path, platform.VersionPath) file, err := os.ReadFile(fullPath) if err != nil { if os.IsNotExist(err) { return 0, errors.Wrap(err, "could not find game version file") } return 0, errors.Wrap(err, "failed reading version file") } var versionData gameVersionFile if err := json.Unmarshal(file, &versionData); err != nil { return 0, errors.Wrap(err, "failed to parse version file json") } return versionData.Changelist, nil } func (i *Installation) GetPlatform(ctx *GlobalContext) (*Platform, error) { if err := i.Validate(ctx); err != nil { return nil, errors.Wrap(err, "failed to validate installation") } for _, platform := range platforms { fullPath := filepath.Join(i.Path, platform.VersionPath) _, err := os.Stat(fullPath) if err != nil { if os.IsNotExist(err) { continue } else { return nil, errors.Wrap(err, "failed detecting version file") } } return &platform, nil } return nil, errors.New("no platform detected") }