1 files changed, 309 insertions, 0 deletions

@@ -0,0 +1,309 @@
+#include "updater.h"
+
+#include <fmt/core.h>
+#include <openssl/evp.h>
+#include <openssl/sha.h>
+#include <wx/evtloop.h>
+#include <wx/progdlg.h>
+#include <wx/webrequest.h>
+#include <wx/wfstream.h>
+#include <wx/zipstrm.h>
+#include <yaml-cpp/yaml.h>
+
+#include <cstdio>
+#include <deque>
+#include <filesystem>
+#include <fstream>
+
+#include "global.h"
+#include "logger.h"
+#include "version.h"
+
+constexpr const char* kVersionFileUrl =
+    "https://code.fourisland.com/lingo-ap-tracker/plain/VERSION.yaml";
+constexpr const char* kChangelogUrl =
+    "https://code.fourisland.com/lingo-ap-tracker/about/CHANGELOG.md";
+
+namespace {
+
+std::string CalculateStringSha256(const wxString& data) {
+  unsigned char hash[SHA256_DIGEST_LENGTH];
+  EVP_MD_CTX* sha256 = EVP_MD_CTX_new();
+  EVP_DigestInit(sha256, EVP_sha256());
+  EVP_DigestUpdate(sha256, data.c_str(), data.length());
+  EVP_DigestFinal_ex(sha256, hash, nullptr);
+  EVP_MD_CTX_free(sha256);
+
+  char output[65] = {0};
+  for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
+    snprintf(output + (i * 2), 3, "%02x", hash[i]);
+  }
+
+  return std::string(output);
+}
+
+}  // namespace
+
+Updater::Updater(wxFrame* parent) : parent_(parent) {
+  Bind(wxEVT_WEBREQUEST_STATE, &Updater::OnWebRequestState, this);
+}
+
+void Updater::Cleanup() {
+  std::filesystem::path oldDir = GetExecutableDirectory() / "old";
+  if (std::filesystem::is_directory(oldDir)) {
+    std::filesystem::remove_all(oldDir);
+  }
+}
+
+void Updater::CheckForUpdates(bool invisible) {
+  wxWebRequest versionRequest =
+      wxWebSession::GetDefault().CreateRequest(this, kVersionFileUrl);
+
+  if (invisible) {
+    update_state_ = UpdateState::GetVersionInvisible;
+
+    versionRequest.Start();
+  } else {
+    update_state_ = UpdateState::GetVersionManual;
+
+    if (DownloadWithProgress(versionRequest)) {
+      if (versionRequest.GetState() == wxWebRequest::State_Failed) {
+        wxMessageBox("Could not check for updates.", "Error",
+                     wxOK | wxICON_ERROR);
+      } else if (versionRequest.GetState() == wxWebRequest::State_Completed) {
+        ProcessVersionFile(
+            versionRequest.GetResponse().AsString().utf8_string());
+      }
+    }
+  }
+}
+
+void Updater::OnWebRequestState(wxWebRequestEvent& evt) {
+  if (update_state_ == UpdateState::GetVersionInvisible) {
+    if (evt.GetState() == wxWebRequest::State_Completed) {
+      ProcessVersionFile(evt.GetResponse().AsString().utf8_string());
+    } else if (evt.GetState() == wxWebRequest::State_Failed) {
+      parent_->SetStatusText("Could not check for updates.");
+    }
+  }
+}
+
+void Updater::ProcessVersionFile(std::string data) {
+  try {
+    YAML::Node versionInfo = YAML::Load(data);
+    Version latestVersion(versionInfo["version"].as<std::string>());
+
+    if (kTrackerVersion < latestVersion) {
+      if (versionInfo["packages"]) {
+        std::string platformIdentifier;
+
+        if (wxPlatformInfo::Get().GetOperatingSystemId() == wxOS_WINDOWS_NT) {
+          platformIdentifier = "win64";
+        }
+
+        if (!platformIdentifier.empty() &&
+            versionInfo["packages"][platformIdentifier]) {
+          wxMessageDialog dialog(
+              nullptr,
+              fmt::format("There is a newer version of Lingo AP Tracker "
+                          "available. You have {}, and the latest version is "
+                          "{}. Would you like to update?",
+                          kTrackerVersion.ToString(), latestVersion.ToString()),
+              "Update available", wxYES_NO | wxCANCEL);
+          dialog.SetYesNoLabels("Install update", "Open changelog");
+
+          int dlgResult = dialog.ShowModal();
+          if (dlgResult == wxID_YES) {
+            const YAML::Node& packageInfo =
+                versionInfo["packages"][platformIdentifier];
+            std::string packageUrl = packageInfo["url"].as<std::string>();
+            std::string packageChecksum =
+                packageInfo["checksum"].as<std::string>();
+
+            std::vector<std::filesystem::path> packageFiles;
+            if (packageInfo["files"]) {
+              for (const YAML::Node& filename : packageInfo["files"]) {
+                packageFiles.push_back(filename.as<std::string>());
+              }
+            }
+
+            std::vector<std::filesystem::path> deletedFiles;
+            if (packageInfo["deleted_files"]) {
+              for (const YAML::Node& filename : packageInfo["deleted_files"]) {
+                deletedFiles.push_back(filename.as<std::string>());
+              }
+            }
+
+            InstallUpdate(packageUrl, packageChecksum, packageFiles,
+                          deletedFiles);
+          } else if (dlgResult == wxID_NO) {
+            wxLaunchDefaultBrowser(kChangelogUrl);
+          }
+
+          return;
+        }
+      }
+
+      if (wxMessageBox(
+              fmt::format("There is a newer version of Lingo AP Tracker "
+                          "available. You have {}, and the latest version is "
+                          "{}. Would you like to update?",
+                          kTrackerVersion.ToString(), latestVersion.ToString()),
+              "Update available", wxYES_NO) == wxYES) {
+        wxLaunchDefaultBrowser(kChangelogUrl);
+      }
+    } else if (update_state_ == UpdateState::GetVersionManual) {
+      wxMessageBox("Lingo AP Tracker is up to date!", "Lingo AP Tracker", wxOK);
+    }
+  } catch (const std::exception& ex) {
+    wxMessageBox("Could not check for updates.", "Error", wxOK | wxICON_ERROR);
+  }
+}
+
+void Updater::InstallUpdate(std::string url, std::string checksum,
+                            std::vector<std::filesystem::path> files,
+                            std::vector<std::filesystem::path> deletedFiles) {
+  update_state_ = UpdateState::GetPackage;
+
+  wxWebRequest packageRequest =
+      wxWebSession::GetDefault().CreateRequest(this, url);
+
+  if (!DownloadWithProgress(packageRequest)) {
+    return;
+  }
+
+  bool download_issue = false;
+
+  wxFileName package_path;
+  package_path.AssignTempFileName("");
+
+  if (!package_path.IsOk()) {
+    download_issue = true;
+  } else {
+    wxFileOutputStream writeOut(package_path.GetFullPath());
+    wxString fileData = packageRequest.GetResponse().AsString();
+    writeOut.WriteAll(fileData.c_str(), fileData.length());
+
+    std::string downloadedChecksum = CalculateStringSha256(fileData);
+    if (downloadedChecksum != checksum) {
+      download_issue = true;
+    }
+  }
+
+  if (download_issue) {
+    if (wxMessageBox("There was an issue downloading the update. Would you "
+                     "like to manually download it instead?",
+                     "Error", wxYES_NO | wxICON_ERROR) == wxID_YES) {
+      wxLaunchDefaultBrowser(kChangelogUrl);
+    }
+    return;
+  }
+
+  std::filesystem::path newArea = GetExecutableDirectory();
+  std::filesystem::path oldArea = newArea / "old";
+  std::set<std::filesystem::path> folders;
+  std::set<std::filesystem::path> filesToMove;
+  for (const std::filesystem::path& existingFile : files) {
+    std::filesystem::path movedPath = oldArea / existingFile;
+    std::filesystem::path movedDir = movedPath;
+    movedDir.remove_filename();
+    folders.insert(movedDir);
+    filesToMove.insert(existingFile);
+  }
+  for (const std::filesystem::path& existingFile : deletedFiles) {
+    std::filesystem::path movedPath = oldArea / existingFile;
+    std::filesystem::path movedDir = movedPath;
+    movedDir.remove_filename();
+    folders.insert(movedDir);
+  }
+
+  for (const std::filesystem::path& newFolder : folders) {
+    TrackerLog(fmt::format("Creating directory {}", newFolder.string()));
+
+    std::filesystem::create_directories(newFolder);
+  }
+
+  for (const std::filesystem::path& existingFile : files) {
+    std::filesystem::path existingPath = newArea / existingFile;
+
+    if (std::filesystem::is_regular_file(existingPath)) {
+      std::filesystem::path movedPath = oldArea / existingFile;
+
+      TrackerLog(fmt::format("Moving {} -> {}", existingPath.string(),
+                             movedPath.string()));
+
+      std::filesystem::rename(existingPath, movedPath);
+    }
+  }
+  for (const std::filesystem::path& existingFile : deletedFiles) {
+    std::filesystem::path existingPath = newArea / existingFile;
+
+    if (std::filesystem::is_regular_file(existingPath)) {
+      std::filesystem::path movedPath = oldArea / existingFile;
+
+      TrackerLog(fmt::format("Moving {} -> {}", existingPath.string(),
+                             movedPath.string()));
+
+      std::filesystem::rename(existingPath, movedPath);
+    }
+  }
+
+  wxFileInputStream fileInputStream(package_path.GetFullPath());
+  wxZipInputStream zipStream(fileInputStream);
+  std::unique_ptr<wxZipEntry> zipEntry;
+  while ((zipEntry = std::unique_ptr<wxZipEntry>(zipStream.GetNextEntry())) !=
+         nullptr) {
+    if (zipEntry->IsDir()) {
+      continue;
+    }
+
+    std::filesystem::path archivePath = zipEntry->GetName().utf8_string();
+
+    TrackerLog(fmt::format("Found {} in archive", archivePath.string()));
+
+    // Cut off the root folder name
+    std::filesystem::path subPath;
+    for (auto it = std::next(archivePath.begin()); it != archivePath.end();
+         it++) {
+      subPath /= *it;
+    }
+
+    std::filesystem::path pastePath = newArea / subPath;
+
+    wxFileOutputStream fileOutput(pastePath.string());
+    zipStream.Read(fileOutput);
+  }
+
+  if (wxMessageBox(
+      "Update installed! The tracker must be restarted for the changes to take "
+      "effect. Do you want to close the tracker?",
+                   "Update installed", wxYES_NO) == wxYES) {
+    wxExit();
+  }
+}
+
+bool Updater::DownloadWithProgress(wxWebRequest& request) {
+  request.Start();
+
+  wxProgressDialog dialog("Checking for updates...", "Checking for updates...",
+                          100, nullptr,
+                          wxPD_APP_MODAL | wxPD_AUTO_HIDE | wxPD_CAN_ABORT |
+                              wxPD_ELAPSED_TIME | wxPD_REMAINING_TIME);
+  while (request.GetState() != wxWebRequest::State_Completed &&
+         request.GetState() != wxWebRequest::State_Failed) {
+    if (request.GetBytesExpectedToReceive() == -1) {
+      if (!dialog.Pulse()) {
+        request.Cancel();
+        return false;
+      }
+    } else {
+      dialog.SetRange(request.GetBytesExpectedToReceive());
+      if (!dialog.Update(request.GetBytesReceived())) {
+        request.Cancel();
+        return false;
+      }
+    }
+  }
+
+  return true;
+}