|
public CheckForUpdate ( bool ignoreDeltaUpdates = false, Action |
||
| ignoreDeltaUpdates | bool | |
| progress | Action |
|
| return | Task |
|
/// <summary>
/// Squirrel check and update.
/// </summary>
private async Task CheckAndUpdate(bool checkOnly = false)
{
// 6/27/15 - Task.Wait always times out. Seems to be an issue with the return of Squirrel's async methods.
try
{
AddMessage("Start of CheckAndUpdate");
using (var updateManager = new UpdateManager(Program.PackageUrl, Program.PackageId))
{
// Check
AddMessage(String.Format("UpdateManager: {0}", JsonConvert.SerializeObject(updateManager, Formatting.Indented)));
AddMessage("Calling UpdateManager.CheckForUpdate");
var updateInfo = await updateManager.CheckForUpdate();
AddMessage(String.Format(
"UpdateManager.CheckForUpdate returned UpdateInfo: {0}",
JsonConvert.SerializeObject(updateInfo, Formatting.Indented)));
if (checkOnly) { return; }
// Update
if (updateInfo.ReleasesToApply.Count > 0)
{
AddMessage("Calling UpdateManager.UpdateApp");
var releaseEntry = await updateManager.UpdateApp();
AddMessage(String.Format(
"UpdateManager.UpdateApp returned ReleaseEntry: {0}",
JsonConvert.SerializeObject(releaseEntry, Formatting.Indented)));
}
else { AddMessage("No updates to apply"); }
}
}
catch (Exception exception)
{
Log.Error("Exception in CheckAndUpdate", exception);
throw;
}
}
private static async void Update(Task<string> result)
{
if (result.Result == null || result.Result != "1")
return;
try
{
using (var mgr = new UpdateManager(@"https://releases.noelpush.com/", "NoelPush"))
{
var updates = await mgr.CheckForUpdate();
if (updates.ReleasesToApply.Any())
{
var lastVersion = updates.ReleasesToApply.OrderBy(x => x.Version).Last();
await mgr.DownloadReleases(updates.ReleasesToApply);
await mgr.ApplyReleases(updates);
var latestExe = Path.Combine(mgr.RootAppDirectory, string.Concat("app-", lastVersion.Version), "NoelPush.exe");
mgr.Dispose();
RestartAppEvent();
UpdateManager.RestartApp(latestExe);
}
mgr.Dispose();
}
}
catch (Exception e)
{
LogManager.GetCurrentClassLogger().Error(e.Message);
}
}
private static async Task Update()
{
try
{
using (var mgr = new UpdateManager("http://lunyx.net/CasualMeter"))
{
Logger.Info("Checking for updates.");
if (mgr.IsInstalledApp)
{
Logger.Info($"Current Version: v{mgr.CurrentlyInstalledVersion()}");
var updates = await mgr.CheckForUpdate();
if (updates.ReleasesToApply.Any())
{
Logger.Info("Updates found. Applying updates.");
var release = await mgr.UpdateApp();
MessageBox.Show(CleanReleaseNotes(release.GetReleaseNotes(Path.Combine(mgr.RootAppDirectory, "packages"))),
$"Casual Meter Update - v{release.Version}");
Logger.Info("Updates applied. Restarting app.");
UpdateManager.RestartApp();
}
}
}
}
catch (Exception e)
{ //log exception and move on
HandleException(e);
}
}
private async void ScheduleApplicationUpdates(Object o)
{
var location = UpdateHelper.AppUpdateCheckLocation;
var appName = Assembly.GetExecutingAssembly().GetName().Name;
using (var mgr = new UpdateManager(location, appName, FrameworkVersion.Net45))
{
try
{
UpdateInfo updateInfo = await mgr.CheckForUpdate();
if (updateInfo.FutureReleaseEntry != null)
{
if (updateInfo.CurrentlyInstalledVersion.Version == updateInfo.FutureReleaseEntry.Version) return;
await mgr.UpdateApp();
// This will show a button that will let the user restart the app
Dispatcher.Invoke(ShowUpdateIsAvailable);
// This will restart the app automatically
//Dispatcher.InvokeAsync<Task>(ShutdownApp);
}
}
catch (Exception ex)
{
var a = ex;
}
}
}
private static ThreadStart UpdateOpenLiveWriter(string downloadUrl, bool checkNow)
{
return(async() =>
{
if (checkNow)
{
try
{
using (var manager = new Squirrel.UpdateManager(downloadUrl))
{
var update = await manager.CheckForUpdate();
if (update != null &&
update.ReleasesToApply.Count > 0 &&
update.FutureReleaseEntry.Version < update.CurrentlyInstalledVersion.Version)
{
Trace.WriteLine("Update is older than currently running version, not installing.");
Trace.WriteLine($"Current: {update.CurrentlyInstalledVersion.Version} Update: {update.FutureReleaseEntry.Version}");
return;
}
await manager.UpdateApp();
}
}
catch (Exception ex)
{
Trace.WriteLine("Unexpected error while updating Open Live Writer. " + ex);
}
}
});
}
private async void ButtonUpdateQuestion_OnClick(object sender, RoutedEventArgs e)
{
try
{
using (var mgr = new UpdateManager(ConfigurationManager.AppSettings["UpdatePath"]))
{
var release = await mgr.CheckForUpdate();
this.UpdateQuestionResult.Text = "Possible Update: " + release.FutureReleaseEntry.Version.ToString();
}
}
catch (Exception test)
{
this.UpdateQuestionResult.Text = test.Message;
}
}
private static void Main()
{
Task.Run(async () =>
{
var upgraded = false;
while (!upgraded)
{
await Task.Delay(TimeSpan.FromSeconds(5));
using (
var mgr = new UpdateManager(@"http://distribute.klonmaschine.de/metrothing/", "metrothing",
FrameworkVersion.Net45))
{
SquirrelAwareApp.HandleEvents(
v => mgr.CreateShortcutForThisExe(),
v => mgr.CreateShortcutForThisExe(),
onAppUninstall: v => mgr.RemoveShortcutForThisExe());
// Try the update
try
{
var updateInfo = await mgr.CheckForUpdate();
if (updateInfo != null && updateInfo.ReleasesToApply.Count > 0)
{
#if !DEBUG
await mgr.UpdateApp();
#endif
upgraded = true;
Singleton<InstallationManager>.Instance.Updated(
updateInfo.FutureReleaseEntry.Version.ToString(),
String.Join("", updateInfo.FetchReleaseNotes().Values));
}
}
catch (Exception e)
{
Trace.WriteLine("Squirrel update failed: " + e.Message);
}
}
if (!upgraded)
await Task.Delay(TimeSpan.FromHours(12));
}
});
MetroThing.Program.Main();
}
async void bw_DoWork(object sender, DoWorkEventArgs e) {
do {
try {
using (var mgr = new UpdateManager(@"C:\dev\helloworld\HelloWorld\Releases", "HelloWorldSquirrel")) {
var updateInfo = await mgr.CheckForUpdate(false, progress => { });
if (updateInfo != null && updateInfo.ReleasesToApply.Count != 0) {
await mgr.UpdateApp();
Restart = true;
}
}
} catch (Exception ex) {
Console.WriteLine(ex.StackTrace);
}
Console.WriteLine("I am running");
Thread.Sleep(2000);
} while (true);
}
public async Task UpdateApp()
{
var updatePath = ConfigurationManager.AppSettings["UpdatePathFolder"];
var packageId = ConfigurationManager.AppSettings["PackageID"];
using (var mgr = new UpdateManager(updatePath, packageId, FrameworkVersion.Net45))
{
var updates = await mgr.CheckForUpdate();
if (updates.ReleasesToApply.Any())
{
var lastVersion = updates.ReleasesToApply.OrderBy(x => x.Version).Last();
await mgr.DownloadReleases(new[] { lastVersion });
await mgr.ApplyReleases(updates);
await mgr.UpdateApp();
MessageBox.Show("The application has been updated - please close and restart.");
}
else
{
MessageBox.Show("No Updates are available at this time.");
}
}
}
/// <summary>
/// Check for updates using Squirrel UpdateManager and return the UpdateInfo result.
/// </summary>
/// <returns></returns>
public static async Task <UpdateInfo> CheckForUpdateAsync()
{
var appName = GetAppName();
var updateLocation = GetUpdateLocation();
object ret = null;
_log.Debug("Checking for update. Called " + Utilities.GetCallerName() + " with UpdateLocation = \"" + updateLocation + "\" and AppName = " + appName + "\".");
using (var mgr = new Squirrel.UpdateManager(updateLocation, appName, Squirrel.FrameworkVersion.Net45))
{
try
{
var updateInfo = await mgr.CheckForUpdate().ConfigureAwait(false);
ret = updateInfo;
}
catch (Exception)
{
throw;
}
return((UpdateInfo)ret);
}
}
private async Task<string> SquirrelUpdate(bool showInfo)
{
try
{
using (UpdateManager _manager = new UpdateManager(ConfigurationManager.AppSettings["CurrentReleaseURL"]))
{
UpdateInfo _update = await _manager.CheckForUpdate();
if (_update.ReleasesToApply.Any())
{
Version _newVersion = _update.ReleasesToApply.OrderByDescending(r => r.Version).First().Version.Version;
Update _updateWindow = new Update();
_updateWindow.Show();
await _manager.UpdateApp((p) => _updateWindow.SetProgress(p));
_updateWindow.Close();
return Utilities.Paths.Exe(_newVersion);
}
else if (showInfo)
{
MessageBox.Show(Framework.Resources.UpdateSuccessText, Framework.Resources.AppName, MessageBoxButton.OK, MessageBoxImage.Information, MessageBoxResult.OK, MessageBoxOptions.DefaultDesktopOnly);
}
}
}
catch (WebException)
{
if (showInfo)
{
MessageBox.Show(Framework.Resources.UpdateErrorText, Framework.Resources.UpdateErrorTitle, MessageBoxButton.OK, MessageBoxImage.Error, MessageBoxResult.OK, MessageBoxOptions.DefaultDesktopOnly);
}
}
catch (Exception e)
{
Framework.Settings.Instance.AutoUpdate = false;
Framework.Settings.Instance.Save();
using (EventLog _log = new EventLog("Application"))
{
_log.Source = Framework.Resources.AppName;
_log.WriteEntry(e.ToString(), EventLogEntryType.Error, 100, 1);
}
MessageBox.Show(Framework.Resources.UpdateErrorFatalText, Framework.Resources.UpdateErrorTitle, MessageBoxButton.OK, MessageBoxImage.Error, MessageBoxResult.OK, MessageBoxOptions.DefaultDesktopOnly);
}
return null;
}
/// <summary>
/// Update the program
/// </summary>
/// <returns></returns>
private async Task Squirrel_UpdateAppAsync(bool showMessages = false)
{
Debug.WriteLine("Checking for updates...");
try
{
using (var mgr = new UpdateManager("https://s3.amazonaws.com/steamdesktopauthenticator/releases"))
{
UpdateInfo update = await mgr.CheckForUpdate();
if(update.ReleasesToApply.Count > 0)
{
await mgr.UpdateApp();
MessageBox.Show("A new version has been installed. Restart to apply.", "Updater", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
if (showMessages)
{
MessageBox.Show("You are using the latest version.", "Updater", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
}
}
catch (Exception err)
{
Debug.WriteLine("Failed");
if (showMessages)
{
MessageBox.Show(err.ToString(), "Update Failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
/// <summary>
/// Check for updates using Squirrel UpdateManager and return the UpdateInfo result.
/// </summary>
/// <returns></returns>
public static async Task<UpdateInfo> CheckForUpdateAsync()
{
var appName = GetAppName();
var updateLocation = GetUpdateLocation();
object ret = null;
_log.Debug("Checking for update. Called " + Utilities.GetCallerName() + " with UpdateLocation = \"" + updateLocation + "\" and AppName = " + appName + "\".");
using (var mgr = new Squirrel.UpdateManager(updateLocation, appName, Squirrel.FrameworkVersion.Net45))
{
try
{
var updateInfo = await mgr.CheckForUpdate().ConfigureAwait(false);
ret = updateInfo;
}
catch (Exception)
{
throw;
}
return (UpdateInfo)ret;
}
}
public async Task<string> Download(string updateUrl, string appName = null)
{
appName = appName ?? getAppNameFromDirectory();
// NB: Always basing the rootAppDirectory relative to ours allows us to create Portable
// Applications
var ourDir = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "..");
this.Log().Info("Fetching update information, downloading from " + updateUrl);
using (var mgr = new UpdateManager(updateUrl, appName, FrameworkVersion.Net45, ourDir)) {
var updateInfo = await mgr.CheckForUpdate(progress: x => Console.WriteLine(x / 3));
await mgr.DownloadReleases(updateInfo.ReleasesToApply, x => Console.WriteLine(33 + x / 3));
var releaseNotes = updateInfo.FetchReleaseNotes();
var sanitizedUpdateInfo = new {
currentVersion = updateInfo.CurrentlyInstalledVersion.Version.ToString(),
futureVersion = updateInfo.FutureReleaseEntry.Version.ToString(),
releasesToApply = updateInfo.ReleasesToApply.Select(x => new {
version = x.Version.ToString(),
releaseNotes = releaseNotes.ContainsKey(x) ? releaseNotes[x] : "",
}).ToArray(),
};
return SimpleJson.SerializeObject(sanitizedUpdateInfo);
}
}
public async Task WhenUrlResultsInWebExceptionReturnNull()
{
// This should result in a WebException (which gets caught) unless you can actually access http://lol
using (var fixture = new UpdateManager("http://lol", "theApp", FrameworkVersion.Net45)) {
var updateInfo = await fixture.CheckForUpdate();
Assert.Null(updateInfo);
}
}
public async Task WhenReleasesFileIsBlankReturnNull()
{
string tempDir;
using (Utility.WithTempDirectory(out tempDir)) {
var fixture = new UpdateManager(tempDir, "MyAppName", FrameworkVersion.Net40);
File.WriteAllText(Path.Combine(tempDir, "RELEASES"), "");
using (fixture) {
Assert.Null(await fixture.CheckForUpdate());
}
}
}
private async Task SquirrelUpdate(bool showInfo)
{
try
{
using (UpdateManager _manager = new UpdateManager(ConfigurationManager.AppSettings["CurrentReleaseURL"]))
{
UpdateInfo _update = await _manager.CheckForUpdate();
if (_update.ReleasesToApply.Any())
{
Version _newVersion = _update.ReleasesToApply.OrderByDescending(r => r.Version).First().Version.Version;
Update _updateWindow = new Update();
_updateWindow.Show();
await _manager.UpdateApp((p) => _updateWindow.SetProgress(p));
_updateWindow.Close();
string _newExePath = Utilities.Paths.Exe(_newVersion);
if (Framework.Settings.Instance.RunAtStartup)
{
Utilities.Startup.EnableStartupTask(_newExePath);
}
Process.Start(_newExePath);
Shutdown();
}
else if (showInfo)
{
MessageBox.Show(Constants.Generic.UPDATEMSG, Constants.Generic.PROGRAMNAME, MessageBoxButton.OK, MessageBoxImage.Information, MessageBoxResult.OK, MessageBoxOptions.DefaultDesktopOnly);
}
}
}
catch (WebException)
{
if (showInfo)
{
MessageBox.Show(Constants.Generic.UPDATEERROR, Constants.Generic.UPDATEERRORTITLE, MessageBoxButton.OK, MessageBoxImage.Error, MessageBoxResult.OK, MessageBoxOptions.DefaultDesktopOnly);
}
}
}
public async Task Update(string updateUrl, string appName = null)
{
appName = appName ?? getAppNameFromDirectory();
this.Log().Info("Starting update, downloading from " + updateUrl);
// NB: Always basing the rootAppDirectory relative to ours allows us to create Portable
// Applications
var ourDir = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "..");
using (var mgr = new UpdateManager(updateUrl, appName, FrameworkVersion.Net45, ourDir)) {
bool ignoreDeltaUpdates = false;
retry:
try {
var updateInfo = await mgr.CheckForUpdate(ignoreDeltaUpdates: ignoreDeltaUpdates, progress: x => Console.WriteLine(x / 3));
await mgr.DownloadReleases(updateInfo.ReleasesToApply, x => Console.WriteLine(33 + x / 3));
await mgr.ApplyReleases(updateInfo, x => Console.WriteLine(66 + x / 3));
} catch (Exception ex) {
if (ignoreDeltaUpdates) {
this.Log().ErrorException("Really couldn't apply updates!", ex);
throw;
}
this.Log().WarnException("Failed to apply updates, falling back to full updates", ex);
ignoreDeltaUpdates = true;
goto retry;
}
var updateTarget = Path.Combine(mgr.RootAppDirectory, "Update.exe");
await this.ErrorIfThrows(() =>
mgr.CreateUninstallerRegistryEntry(),
"Failed to create uninstaller registry entry");
}
}
private async void ShowAboutWindow()
{
using (var mgr = new UpdateManager("http://arkmanager.teamitf.co.uk/iNGen/Releases/", "iNGen"))
{
try
{
UpdateInfo updateInfo = await mgr.CheckForUpdate();
if (updateInfo.FutureReleaseEntry != null)
{
if (updateInfo.CurrentlyInstalledVersion != null)
{
XElement xelement = XElement.Load("http://arkmanager.teamitf.co.uk/iNGen/version.xml");
StringReader reader = new StringReader(xelement.ToString());
System.Xml.Serialization.XmlSerializer xmlSerializer = new System.Xml.Serialization.XmlSerializer(typeof(Models.AppUpdates));
Models.AppUpdates appUpdates = (Models.AppUpdates)xmlSerializer.Deserialize(reader);
string changes = MakeChangeLog(appUpdates);
var updateDialog = new Views.AboutApp(updateInfo, changes) { Owner = this };
var result = updateDialog.ShowDialog();
if (result == false) return;
CheckForUpdates();
}
}
}
catch (Exception ex)
{ }
}
}
private static async Task<bool> SquirrelUpdate(SplashScreenWindow splashScreenWindow, UpdateManager mgr, bool ignoreDelta = false)
{
try
{
Log.Info($"Checking for updates (ignoreDelta={ignoreDelta})");
splashScreenWindow.StartSkipTimer();
var updateInfo = await mgr.CheckForUpdate(ignoreDelta);
if(!updateInfo.ReleasesToApply.Any())
{
Log.Info("No new updated available");
return false;
}
var latest = updateInfo.ReleasesToApply.LastOrDefault()?.Version;
var current = mgr.CurrentlyInstalledVersion();
if(latest <= current)
{
Log.Info($"Installed version ({current}) is greater than latest release found ({latest}). Not downloading updates.");
return false;
}
if(IsRevisionIncrement(current?.Version, latest?.Version))
{
Log.Info($"Latest update ({latest}) is revision increment. Updating in background.");
splashScreenWindow.SkipUpdate = true;
}
Log.Info($"Downloading {updateInfo.ReleasesToApply.Count} {(ignoreDelta ? "" : "delta ")}releases, latest={latest?.Version}");
await mgr.DownloadReleases(updateInfo.ReleasesToApply, splashScreenWindow.Updating);
Log.Info("Applying releases");
await mgr.ApplyReleases(updateInfo, splashScreenWindow.Installing);
await mgr.CreateUninstallerRegistryEntry();
Log.Info("Done");
return true;
}
catch(Exception ex)
{
if(ignoreDelta)
return false;
if(ex is Win32Exception)
Log.Info("Not able to apply deltas, downloading full release");
return await SquirrelUpdate(splashScreenWindow, mgr, true);
}
}
private async void CheckForUpdates()
{
using (var mgr = new UpdateManager("http://arkmanager.teamitf.co.uk/iNGen/Releases/", "iNGen"))
{
SquirrelAwareApp.HandleEvents(
onInitialInstall: v => mgr.CreateShortcutForThisExe(),
onAppUpdate: v => mgr.CreateShortcutForThisExe(),
onAppUninstall: v => mgr.RemoveShortcutForThisExe());
try
{
UpdateInfo updateInfo = await mgr.CheckForUpdate();
if (updateInfo.FutureReleaseEntry != null)
{
if (updateInfo.CurrentlyInstalledVersion != null)
{
XElement xelement = XElement.Load("http://arkmanager.teamitf.co.uk/iNGen/version.xml");
StringReader reader = new StringReader(xelement.ToString());
System.Xml.Serialization.XmlSerializer xmlSerializer = new System.Xml.Serialization.XmlSerializer(typeof(Models.AppUpdates));
Models.AppUpdates appUpdates = (Models.AppUpdates)xmlSerializer.Deserialize(reader);
string changes = MakeChangeLog(appUpdates);
if (updateInfo.CurrentlyInstalledVersion.Version == updateInfo.FutureReleaseEntry.Version) return;
var updateDialog = new Views.AppUpdate(updateInfo, changes) { Owner = this };
var result = updateDialog.ShowDialog();
if (result == false) return;
await mgr.UpdateApp();
var oldPath = System.IO.Path.Combine(mgr.RootAppDirectory, "app-" + updateInfo.CurrentlyInstalledVersion.Version.ToString(), "UserData");
var newPath = System.IO.Path.Combine(mgr.RootAppDirectory, "app-" + updateInfo.FutureReleaseEntry.Version.ToString(), "UserData");
DirectoryInfo d = new DirectoryInfo(oldPath);
var files = d.GetFiles();
foreach (var file in files)
{
file.CopyTo(System.IO.Path.Combine(newPath, file.Name), true);
}
MessageBox.Show("iNGen Has been Updated. Please Re-Launch It.");
Application.Current.Shutdown(0);
}
else
{
await mgr.UpdateApp();
MessageBox.Show("iNGen Has been Updated. Please Re-Launch It.");
Application.Current.Shutdown(0);
}
}
}
catch (Exception ex)
{
Console.WriteLine("Checking for Updates Failed: " + ex.Message);
}
}
}
public async Task WhenUrlResultsInWebExceptionWeShouldThrow()
{
// This should result in a WebException (which gets caught) unless you can actually access http://lol
using (var fixture = new UpdateManager("http://lol", "theApp")) {
await Assert.ThrowsAsync(typeof(WebException), () => fixture.CheckForUpdate());
}
}
private IObservable<UpdateAvailableNotification> CheckForUpdates()
{
return Observable.Create<UpdateAvailableNotification>(async obs =>
{
string updateUrl = AppModel.GetRegistrySetting("UpdateUrl");
Log.DebugFormat("UpdateUrl = {0}", updateUrl);
using (var updateManager = new UpdateManager(updateUrl ?? @"http://bradleygrainger.com/GitBlame/download", "GitBlame", FrameworkVersion.Net45))
{
try
{
UpdateInfo updateInfo = await updateManager.CheckForUpdate();
var releases = updateInfo == null ? new List<ReleaseEntry>() : updateInfo.ReleasesToApply.ToList();
if (updateInfo == null)
Log.Info("CheckForUpdate returned (null)");
else
Log.InfoFormat("CheckForUpdate: Current=({0}), Future=({1}), {2} ReleasesToApply", ToLog(updateInfo.CurrentlyInstalledVersion), ToLog(updateInfo.FutureReleaseEntry), releases.Count);
if (releases.Count != 0)
{
await updateManager.DownloadReleases(releases);
Log.Info("Downloaded releases");
var newDirectory = await updateManager.ApplyReleases(updateInfo);
Log.InfoFormat("ApplyReleases: {0}", newDirectory);
if (!string.IsNullOrEmpty(newDirectory))
{
var newPath = Path.Combine(newDirectory, "GitBlame.exe");
VisualStudioIntegration.ReintegrateWithVisualStudio(newPath);
obs.OnNext(new UpdateAvailableNotification(newPath));
}
}
}
catch (TimeoutException ex)
{
// Failed to check for updates; try again the next time the app is run
Log.ErrorFormat("CheckForUpdates timed out: {0}", ex, ex.Message);
}
catch (Exception ex)
{
// Squirrel throws a new Exception in many failure scenarios
Log.ErrorFormat("CheckForUpdates failed: {0}", ex, ex.Message);
if (ex.InnerException != null)
Log.ErrorFormat("CheckForUpdates inner exception: {0}", ex.InnerException, ex.InnerException.Message);
}
}
obs.OnCompleted();
});
}
public async Task WhenReleasesFileDoesntExistThrowACustomError()
{
string tempDir;
using (Utility.WithTempDirectory(out tempDir)) {
var fixture = new UpdateManager(tempDir, "MyAppName");
using (fixture) {
await Assert.ThrowsAsync<Exception>(() => fixture.CheckForUpdate());
}
}
}
public async Task WhenReleasesFileIsBlankThrowAnException()
{
string tempDir;
using (Utility.WithTempDirectory(out tempDir)) {
var fixture = new UpdateManager(tempDir, "MyAppName");
File.WriteAllText(Path.Combine(tempDir, "RELEASES"), "");
using (fixture) {
await Assert.ThrowsAsync(typeof(Exception), () => fixture.CheckForUpdate());
}
}
}
public async Task WhenTwoRemoteUpdatesAreAvailableChoosesDeltaVersion()
{
string tempDir;
using (Utility.WithTempDirectory(out tempDir))
{
var appDir = Path.Combine(tempDir, "theApp");
var localPackages = Path.Combine(appDir, "packages");
var remotePackages = Path.Combine(tempDir, "releases");
Directory.CreateDirectory(localPackages);
Directory.CreateDirectory(remotePackages);
new[] { "Squirrel.Core.1.0.0.0-full.nupkg", }.ForEach(x => {
var path = IntegrationTestHelper.GetPath("fixtures", x);
File.Copy(path, Path.Combine(localPackages, x));
});
new[] {
"Squirrel.Core.1.0.0.0-full.nupkg",
"Squirrel.Core.1.1.0.0-delta.nupkg",
"Squirrel.Core.1.1.0.0-full.nupkg",
}.ForEach(x => {
var path = IntegrationTestHelper.GetPath("fixtures", x);
File.Copy(path, Path.Combine(remotePackages, x));
});
var fixture = new UpdateManager.ApplyReleasesImpl(appDir);
// sync both release files
await fixture.updateLocalReleasesFile();
ReleaseEntry.BuildReleasesFile(remotePackages);
using (var mgr = new UpdateManager(remotePackages, "theApp", tempDir, new FakeUrlDownloader())) {
UpdateInfo updateInfo;
updateInfo = await mgr.CheckForUpdate();
Assert.True(updateInfo.ReleasesToApply.First().IsDelta);
updateInfo = await mgr.CheckForUpdate(ignoreDeltaUpdates: true);
Assert.False(updateInfo.ReleasesToApply.First().IsDelta);
}
}
}
public async Task WhenFolderDoesNotExistThrowHelpfulError()
{
string tempDir;
using (Utility.WithTempDirectory(out tempDir)) {
var directory = Path.Combine(tempDir, "missing-folder");
var fixture = new UpdateManager(directory, "MyAppName");
using (fixture) {
await Assert.ThrowsAsync<Exception>(() => fixture.CheckForUpdate());
}
}
}
public async Task WhenRemoteReleasesDoNotHaveDeltasNoUpdatesAreApplied()
{
string tempDir;
using (Utility.WithTempDirectory(out tempDir))
{
var appDir = Path.Combine(tempDir, "theApp");
var localPackages = Path.Combine(appDir, "packages");
var remotePackages = Path.Combine(tempDir, "releases");
Directory.CreateDirectory(localPackages);
Directory.CreateDirectory(remotePackages);
new[] {
"Squirrel.Core.1.0.0.0-full.nupkg",
"Squirrel.Core.1.1.0.0-delta.nupkg",
"Squirrel.Core.1.1.0.0-full.nupkg",
}.ForEach(x => {
var path = IntegrationTestHelper.GetPath("fixtures", x);
File.Copy(path, Path.Combine(localPackages, x));
});
new[] {
"Squirrel.Core.1.0.0.0-full.nupkg",
"Squirrel.Core.1.1.0.0-full.nupkg",
}.ForEach(x => {
var path = IntegrationTestHelper.GetPath("fixtures", x);
File.Copy(path, Path.Combine(remotePackages, x));
});
var fixture = new UpdateManager.ApplyReleasesImpl(appDir);
// sync both release files
await fixture.updateLocalReleasesFile();
ReleaseEntry.BuildReleasesFile(remotePackages);
UpdateInfo updateInfo;
using (var mgr = new UpdateManager(remotePackages, "theApp", tempDir, new FakeUrlDownloader())) {
updateInfo = await mgr.CheckForUpdate();
}
Assert.NotNull(updateInfo);
Assert.Empty(updateInfo.ReleasesToApply);
}
}
public async Task<string> Download(string updateUrl, string appName = null)
{
appName = appName ?? getAppNameFromDirectory();
this.Log().Info("Fetching update information, downloading from " + updateUrl);
using (var mgr = new UpdateManager(updateUrl, appName)) {
var updateInfo = await mgr.CheckForUpdate(progress: x => Console.WriteLine(x / 3));
await mgr.DownloadReleases(updateInfo.ReleasesToApply, x => Console.WriteLine(33 + x / 3));
var releaseNotes = updateInfo.FetchReleaseNotes();
var sanitizedUpdateInfo = new {
currentVersion = updateInfo.CurrentlyInstalledVersion.Version.ToString(),
futureVersion = updateInfo.FutureReleaseEntry.Version.ToString(),
releasesToApply = updateInfo.ReleasesToApply.Select(x => new {
version = x.Version.ToString(),
releaseNotes = releaseNotes.ContainsKey(x) ? releaseNotes[x] : "",
}).ToArray(),
};
return SimpleJson.SerializeObject(sanitizedUpdateInfo);
}
}
public async Task Update(string updateUrl, string appName = null)
{
appName = appName ?? getAppNameFromDirectory();
this.Log().Info("Starting update, downloading from " + updateUrl);
using (var mgr = new UpdateManager(updateUrl, appName)) {
bool ignoreDeltaUpdates = false;
this.Log().Info("About to update to: " + mgr.RootAppDirectory);
retry:
try {
var updateInfo = await mgr.CheckForUpdate(ignoreDeltaUpdates: ignoreDeltaUpdates, progress: x => Console.WriteLine(x / 3));
await mgr.DownloadReleases(updateInfo.ReleasesToApply, x => Console.WriteLine(33 + x / 3));
await mgr.ApplyReleases(updateInfo, x => Console.WriteLine(66 + x / 3));
} catch (Exception ex) {
if (ignoreDeltaUpdates) {
this.Log().ErrorException("Really couldn't apply updates!", ex);
throw;
}
this.Log().WarnException("Failed to apply updates, falling back to full updates", ex);
ignoreDeltaUpdates = true;
goto retry;
}
var updateTarget = Path.Combine(mgr.RootAppDirectory, "Update.exe");
await this.ErrorIfThrows(() =>
mgr.CreateUninstallerRegistryEntry(),
"Failed to create uninstaller registry entry");
}
}
/// <summary>
/// Handles the Click event of the buttonUpdate control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
private async void ButtonUpdate_Click(object sender, EventArgs e)
{
string updateUrl = @"http://journaley.s3.amazonaws.com/stable";
string updateSrcFile = Path.Combine(
Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),
"UpdateSource");
if (File.Exists(updateSrcFile))
{
updateUrl = File.ReadAllText(updateSrcFile, System.Text.Encoding.UTF8).Trim();
}
// Update Check
if (this.Owner is MainForm)
{
++((MainForm)this.Owner).UpdateProcessCount;
}
try
{
using (var mgr = new UpdateManager(updateUrl))
{
// Disable update check when in develop mode.
if (!mgr.IsInstalledApp)
{
MessageBox.Show("Checking for update is disabled in develop mode.", "Update Journaley");
return;
}
var updateInfo = await mgr.CheckForUpdate();
if (updateInfo == null)
{
MessageBox.Show("Failed to check for update.", "Update Journaley");
return;
}
if (updateInfo.ReleasesToApply.Any())
{
await mgr.DownloadReleases(updateInfo.ReleasesToApply);
await mgr.ApplyReleases(updateInfo);
MessageBox.Show(
"Journaley has been updated to v" +
updateInfo.ReleasesToApply.Max(x => x.Version) + ".\n" +
"Restart Journaley to use the new version.",
"Update Journaley");
this.UpdateAvailable = false;
if (this.Owner is MainForm)
{
((MainForm)this.Owner).UpdateAvailable = false;
}
}
else
{
MessageBox.Show("Journaley is already up to date!", "Update Journaley");
}
}
}
catch (Exception ex)
{
MessageBox.Show("Error occurred while updating.", "Update Journaley");
Logger.Log(ex.Message);
Logger.Log(ex.StackTrace);
}
finally
{
if (this.Owner is MainForm)
{
--((MainForm)this.Owner).UpdateProcessCount;
}
}
}
static void Main(string[] args)
{
Console.WriteLine("Starting application...");
var pathToUpdateFolder = @"\\mindelo\KohortClientRelease\" + ConfigurationManager.AppSettings["AppName"];
using (var mgr = new UpdateManager(pathToUpdateFolder))
{
var updateInfo = mgr.CheckForUpdate().Result;
if (updateInfo.ReleasesToApply.Count > 0)
{
Console.WriteLine("Updating...");
var result = mgr.UpdateApp().Result;
Console.WriteLine("Update complete, press enter to exit and then you can start the application anew!");
Console.ReadLine();
return;
}
}
Console.WriteLine("MyTestApplication has started (version {0}).", Assembly.GetEntryAssembly().GetName().Version);
Console.WriteLine();
Console.WriteLine("My sample app setting key has currently \"{0}\" as value.", ConfigurationManager.AppSettings["MySampleSetting"]);
Console.WriteLine();
Console.WriteLine("Press enter to exit...");
Console.ReadLine();
}
