We need some rollback system that will restore to previous version in case of an error or user cancel.

If anybody knows how to setup coveralls.io using

• Travis CI / AppVeyor
• Opencoverage
• NUnit

Uploading the results fail with: 422 - Couldn't find a repository matching this job.

The script we use to run our tests is currently included in appveyor.yml.
Take a look at the build log for more information.

The original version/idea of this updater used the Dropbox public feature as a way of storing the updates.
As of 15/03/2017 Dropbox will remove this feature [see https://www.dropbox.com/help/16].

We can still use Dropbox if we are going to implement the Dropbox V2 API.

As far as I know we have 2 options:

Use the .Net Dropbox API Library

    pros:
    - will be maintained for us
    - .NET Standard 2.0 support
    
    cons:
    - Extra library in output
    - Overhead (we won't be using most of the features)

Write our own API implementation/wrapper around the Dropbox HTTP API

    pros:
    - Less overhead (we just implement the features we need)
    - No extra library in the output
    - We can use lower .Net version to support more systems
    
    cons:
    - Will take more time
    - If Dropbox upgrades changes his API we need to change our wrapper/impl as well

Implementation details

We do not want to limit ourself to Dropbox so we should not depend on it. We should have an abstract pattern that would allow us to use any provider.

• New repository needed UpdateLib.Extensions.Dropbox
• Dropbox registration with extension method UpdateLib.UseDropbox(Func<IOptions<DropboxOptions>> options)

Note: This might be put into its own repo to not bloat the UpdateLib Package.

History

Up until now we used a CLI to create new updates. We used files to communicate between the server and the client.

Future

We should use an Web API that our users can set-up to use to make and manage updates.
This API should expose some Endpoints to allow that

Endpoints

GET /api/updates

Gets a list of all available updates

GET /api/updates/{id}

Gets an update info that contains all the versions that can update to this version with patches

POST /api/updates/{id}

Used to manage the specified update

GET /api/updates/from/{version}

Gets an list with all available version from the specified version

GET /api/updates/from/{version}/{latest or stable}

Gets the latest stable or unstable version from the specified version

GET /api/updates/patch/{id}

Downloads the patch file

POST /api/updates/patch/create

Creates a new patch based on the specified info. This will probably return a task id that can be checked to see if it is completed.

Dashboard

• Create new patches
• View and manage patches
• See update statistics and information
• See failed updates and rollbacks

Make the command line functions more generic.

TODO

• - Keep old files so we can rollback at a later stage (if needed)
• - Rollback to any previous version

Edits

15 Aug 2018

Removed the rollback UI, if you want to show an UI to your end-user you will have to implement this yourself. After v1.0 we could make a package UpdateLib.UI for example that contains some UI.

I am thinking something along the lines of the MySQL Community Installer.

Consider an option to allow the user to set an option in the updater to use shared or local storage.
Storing the cache files in Roaming AppData might not always be the best option.
In this case the local AppData folder should be considered.

Allow modification of the registry in the updates.

If we have any registry update we need to have admin permission.
Developer needs to configure those updates in the UpdateGenerator (new page).

Needs to be added to the updater GUI.
We need to provide a way of rolling back the registry updates in case of error.
Registry updates need to be encapsulated into the UpdateFile.

In the application entry point we should add logic to allow updating using startup arguments.

Default behaviour: no?

Arguments:

• /update (update program instantly before the rest of the app is loaded)
• /silent or /s or /quiet (disable updating UI)

What to do in case of error/exception?

The original version did not include a way of extracting zip files.
For this version I would like to implement this without adding too much overhead.

Some options:

• DotNetZip
• ZipStorer

ZipStorer looks like the best one for our use case at this point in time.

Patching system with delta compression

To create smaller updates and reduce the time, UpdateLib should start using patches.
These patches will be created using the VCDIFF/RFC3284 algorithm.
All the patches for a version will be bundled together with metadata into a single compressed zip archive.

Existing software

• For VCDiff we can use the XDelta3 project.
• For the compressed zip we can use the SharpZipLib project.

Current zip idea/layout

• patch.zip/
  • delta/
    • delta files
  • new/
    • newly added files
  • metdata file

Metdata file

Metdata file contains pointers more information. This should also contain information about deleted files etc.

Other

The highest compression settings are currently used, might change to find a better compression/time ratio.

xdelta3 -e -f -9 -S -s original.exe updated.exe original.exe.delta
For the zip inflate/deflate using level 9 will be used.

TODO list

• Update .NET Standard 2.0+
• Remove our own AsyncTask system and using the built in Task.
• Remove winforms
• Only use CLI for v1.0
• Update example project
• Use CommandLineParser.Core

Consider using SynchronizationContext for AsyncTasks.

When testing the speed of updates I noticed a little bug with the cache.

Case: A file has been added in the cache. Next update the file gets removed but not from the cache.

Cons:

• Cache file will grow indefinitely
• Could trick the updater into thinking a file exists while it doesn't exist locally

Create UI for windows using .NET Core 3.0 Winforms

Using drop-in package: MatthiWare.UpdateLib.Windows

GUI to generate the UpdateFile.

• Version of the update
• Folders/Files to include in the update
  • option for custom action for each file
• Registry updater
• Generation of the file