From c867792535928ba6104985d7660be705ab3888c1 Mon Sep 17 00:00:00 2001 From: NGnius Date: Wed, 18 Sep 2019 20:47:18 -0400 Subject: [PATCH] Add command line parameter support --- .gitignore | 2 + rxsm-updater/rxsm-updater.go | 175 +++++++++++++++++++++++++++++++---- 2 files changed, 157 insertions(+), 20 deletions(-) diff --git a/.gitignore b/.gitignore index 9a3a8d8..e6a889b 100644 --- a/.gitignore +++ b/.gitignore @@ -12,3 +12,5 @@ # Output of the go coverage tool, specifically when used with LiteIDE *.out +# binary +rxsm-updater/rxsm-updater diff --git a/rxsm-updater/rxsm-updater.go b/rxsm-updater/rxsm-updater.go index 7db57e7..feb507f 100644 --- a/rxsm-updater/rxsm-updater.go +++ b/rxsm-updater/rxsm-updater.go @@ -6,52 +6,186 @@ import ( "runtime" "os" "io" - "log" + "fmt" + "errors" "archive/zip" "path/filepath" + "flag" ) const ( - DownloadTempFile string = "rxsm-update.zip" + DefaultZipFile string = "rxsm-update.zip" + RXSMUpdaterVersion string = "v0.0.1" + DefaultUpdateServer string = "https://rxsm-update.exmods.org" ) +var ( + // command line flag arguments + Zipfile string = DefaultZipFile + Target string + Unattended bool + PlatformStream string + UpdateServer string + TargetBinary string +) + +func init() { + fmt.Println("RXSM Updater version", RXSMUpdaterVersion) + fmt.Println("This program updates RXSM headlessly. Use rxsm-updater --help to view advanced features") + fmt.Println(os.Args) + flag.StringVar(&Zipfile, "zip", DefaultZipFile, "The zipfile to extract from (and download to, in unattended mode)") + flag.StringVar(&Target, "target", "", "The directory to target for the update (the directory containing RXSM)") + flag.BoolVar(&Unattended, "unattended", false, "Download & extract the RXSM update (WIP)") + flag.StringVar(&PlatformStream, "stream", "release", "The update stream to use when retrieving updates in unattended mode") + flag.StringVar(&UpdateServer, "server", DefaultUpdateServer, "The web server to use for retrieving update information") +} + func main() { - InstallRXSMUpdate(func(int, string){}) + flag.Parse() + if Unattended { + fmt.Println("Attempting WIP Unattended update") + fmt.Println("This is not advised, and will fail if an updater update is necessary") + URL, isUpdatable, ok := CheckForUpdate(UpdateServer, "", runtime.GOOS+"/"+runtime.GOARCH+"/"+PlatformStream) + if !(ok && isUpdatable && URL != "") { + fmt.Println("No update found") + return + } + downloadErr := DownloadRXSMUpdate(URL, func(int, string){}) + if downloadErr != nil { + fmt.Println(downloadErr) + return + } + proc, forkErr := ForkRXSMUpdate() + if forkErr != nil { + fmt.Println(forkErr) + return + } + fmt.Println("Extraction forked to", proc.Pid) + } else { + fmt.Println("Installing from", Zipfile) + installErr := InstallRXSMUpdate(func(int, string){}) + if installErr != nil { + fmt.Println(installErr) + return + } + } + fmt.Println("Operation complete") // TODO: implement callback for Qt window } -func InstallRXSMUpdate(statusCallback func(progress int, description string)) { - f, openErr := os.Open(DownloadTempFile) +func DownloadRXSMUpdateQuiet(URL string) { + DownloadRXSMUpdate(URL, func(int, string){}) +} + +func DownloadRXSMUpdate(URL string, statusCallback func(progress int, description string)) (error){ + // progress is out of 100 + statusCallback(25, "Downloading") + fmt.Println("Downloading update from "+URL) + f, createErr := os.Create(Zipfile) + if createErr != nil { + fmt.Println("Error creating temporary update file") + statusCallback(-1, "Error creating update temporary file") + return createErr + } + defer f.Close() + ok := DownloadUpdate(URL, f) + if !ok { + fmt.Println("Error downloading update") + statusCallback(-1, "Download failed") + return errors.New("download failed in update API") + } + statusCallback(50, "Installing Updater") + f.Sync() + f.Seek(0,0) + fStat, statErr := f.Stat() + if statErr != nil { + fmt.Println("Error getting download temp file stat") + return statErr + } + fmt.Println("Downloaded", fStat.Size(), "bytes") + statusCallback(75, "Extracting Updater") + // TODO: implement way to have this actually work + zipFile, zipErr := zip.NewReader(f, fStat.Size()) + if zipErr != nil { + fmt.Println("Error creating zip reader") + fmt.Println(zipErr) + return zipErr + } + for _, f := range zipFile.File { + if !f.FileHeader.Mode().IsDir() { + filename := filepath.Clean(f.FileHeader.Name) + var updaterFilename string + if runtime.GOOS == "windows" { + updaterFilename = "rxsm-updater.exe" + TargetBinary = "rxsm-updater2.exe" + } else { + updaterFilename = "rxsm-updater" + TargetBinary = "rxsm-updater2" + } + if len(filename) >= len(updaterFilename) && filename[:len(updaterFilename)] == updaterFilename { + fileReadCloser, openErr := f.Open() + if openErr != nil { + fmt.Println("Error opening updater in zip archive") + return openErr + } + defer fileReadCloser.Close() + destFile, createErr := os.Create(TargetBinary) + if createErr != nil { + fmt.Println("Error creating updater file") + return createErr + } + defer destFile.Close() + _, copyErr := io.Copy(destFile, fileReadCloser) + if copyErr != nil { + fmt.Println("Error copying/extracting updater") + return copyErr + } + } + } + } + statusCallback(100, "Complete") + return nil +} + +func ForkRXSMUpdate() (process *os.Process, err error) { + if runtime.GOOS == "windows" { + return os.StartProcess(TargetBinary, []string{TargetBinary, "--zip", Zipfile, "--target", Target}, nil) + } else { + return os.StartProcess(TargetBinary, []string{TargetBinary, "--zip", Zipfile, "--target", Target}, nil) + } +} + +func InstallRXSMUpdate(statusCallback func(progress int, description string)) (error){ + f, openErr := os.Open(Zipfile) if openErr != nil { - log.Println("Error opening zip file") - log.Println(openErr) - return + fmt.Println("Error opening zip file") + statusCallback(-1, "Opening zip file failed") + return openErr } statusCallback(1, "Extracting") f.Sync() f.Seek(0,0) fStat, statErr := f.Stat() if statErr != nil { - log.Println("Error retrieving file stats") - log.Println(statErr) - statusCallback(-1, "Extracting failed") + fmt.Println("Error retrieving file stats") + statusCallback(-1, "Extracting zip file failed") + return statErr } unpackErr := unpackRXSMInstall(f, fStat.Size(), func(p int, d string){statusCallback(1, d)}) if unpackErr != nil { - log.Println("Error extracting update") - log.Println(unpackErr) - statusCallback(-1, "Extracting failed") - return + fmt.Println("Error extracting update") + statusCallback(-1, "Unpacking failed") + return unpackErr } statusCallback(2, "Installing") // TODO: is there installation required? - rmErr := os.Remove(DownloadTempFile) + rmErr := os.Remove(Zipfile) if rmErr != nil { - log.Println("Error removing download file") - log.Println(rmErr) + fmt.Println("Error removing download file") statusCallback(-1, "Installing failed") - return + return rmErr } + return nil } func unpackRXSMInstallPath(path string) (error) { @@ -93,9 +227,10 @@ func unpackRXSMInstall(reader io.ReaderAt, size int64, statusCallback func(progr filename = filename[len(runtime.GOOS)+1:] } } + filename = filepath.Join(Target, filename) dirErr := os.MkdirAll(filepath.Dir(filename), os.ModeDir | os.ModePerm) if dirErr != nil { - log.Println("Dir err "+filepath.Dir(filename)) + fmt.Println("Dir err "+filepath.Dir(filename)) return dirErr } newFile, createErr := os.Create(filename)