public void Start()
{
if (!_deployment.IsNetworkDeployed)
{
return;
}
var updateAvailable = Observable.FromEventPattern <CheckForUpdateCompletedEventArgs>(_deployment,
"CheckForUpdateCompleted")
.Where(e => e.EventArgs.UpdateAvailable)
.Select(_ => new AppUpdateAvailableMessage()).Take(1);
_disposables.Add(_bus.RegisterMessageSource(updateAvailable));
_disposables.Add(Observable.Interval(Properties.Settings.Default.UpdateCheckInterval)
.TakeUntil(updateAvailable)
.Subscribe(_ => _deployment.CheckForUpdateAsync()));
_disposables.Add(_bus.Listen <RequestAppUpdateMessage>()
.SkipUntil(updateAvailable)
.Take(1)
.ObserveOn(RxApp.TaskpoolScheduler).
Subscribe(_ => _deployment.UpdateAsync()));
_disposables.Add(Observable.FromEventPattern <AsyncCompletedEventArgs>(_deployment, "UpdateCompleted")
.ObserveOn(RxApp.TaskpoolScheduler).Subscribe(e =>
{
if (e.EventArgs.Error != null)
{
_bus.SendMessage(new ExceptionMessage(e.EventArgs.Error));
}
else
{
_bus.SendMessage(new RequestApplicationRestartMessage());
}
}));
_disposables.Add(_bus.RegisterMessageSource(
Observable.FromEventPattern <DeploymentProgressChangedEventArgs>(_deployment, "UpdateProgressChanged")
.Select(e => new AppUpdateProgressMessage(e.EventArgs.ProgressPercentage))));
}
private void Initialise(IApplicationDeployment deployment, IApplicationContainer appContainer)
{
CheckForUpdate = new ReactiveCommand(this.ObservableForProperty(vm => vm.NetworkDeployed).Select(e => e.Value), false, null);
CheckForUpdate.Subscribe(x => deployment.CheckForUpdateAsync());
CheckForUpdate.ThrownExceptions.Subscribe();
var checkForUpdateObservable = Observable.FromEventPattern <CheckForUpdateCompletedEventHandler, CheckForUpdateCompletedEventArgs>
(h => deployment.CheckForUpdateCompleted += h,
h => deployment.CheckForUpdateCompleted -= h);
var checkForUpdateProgressObservable = Observable.FromEventPattern <DeploymentProgressChangedEventHandler, DeploymentProgressChangedEventArgs>
(h => deployment.CheckForUpdateProgressChanged += h,
h => deployment.CheckForUpdateProgressChanged -= h);
_availableVersion = checkForUpdateObservable.Select(e => e.EventArgs.AvailableVersion).ToProperty(this, vm => vm.AvailableVersion);
_updateSizeBytes = checkForUpdateObservable.Select(e => e.EventArgs.UpdateSizeBytes).ToProperty(this, vm => vm.UpdateSizeBytes);
_minimumRequiredVersion = checkForUpdateObservable.Select(e => e.EventArgs.MinimumRequiredVersion).ToProperty(this, vm => vm.MinimumRequiredVersion);
_isUpdateRequired = checkForUpdateObservable.Select(e => e.EventArgs.IsUpdateRequired).ToProperty(this, vm => vm.IsUpdateRequired);
Update = new ReactiveCommand(checkForUpdateObservable.Select(e => e.EventArgs.UpdateAvailable), false, null);
Update.Subscribe(x => deployment.UpdateAsync());
Update.ThrownExceptions.Subscribe();
var updateProgressObservable = Observable.Merge(Observable.FromEventPattern <DeploymentProgressChangedEventHandler, DeploymentProgressChangedEventArgs>
(h => deployment.UpdateProgressChanged += h,
h => deployment.UpdateProgressChanged -= h),
Observable.FromEventPattern <DeploymentProgressChangedEventHandler, DeploymentProgressChangedEventArgs>
(h => deployment.DownloadFileGroupProgressChanged += h,
h => deployment.DownloadFileGroupProgressChanged -= h));
_deploymentProgressState = updateProgressObservable.Select(e => e.EventArgs.State).ToProperty(this, vm => vm.DeploymentProgressState);
_progressPercentage = updateProgressObservable.Select(e => e.EventArgs.ProgressPercentage).ToProperty(this, vm => vm.ProgressPercentage);
_bytesCompleted = updateProgressObservable.Select(e => e.EventArgs.BytesCompleted).ToProperty(this, vm => vm.BytesCompleted);
_bytesTotal = updateProgressObservable.Select(e => e.EventArgs.BytesTotal).ToProperty(this, vm => vm.BytesTotal);
_group = updateProgressObservable.Select(e => e.EventArgs.Group).ToProperty(this, vm => vm.Group);
var updateCompleteObservable = Observable.FromEventPattern <AsyncCompletedEventHandler, AsyncCompletedEventArgs>
(h => deployment.UpdateCompleted += h,
h => deployment.UpdateCompleted -= h);
_updateAvailable = Observable.Merge(checkForUpdateObservable.Select(e => e.EventArgs.UpdateAvailable),
updateCompleteObservable.Select(e => false))
.ToProperty(this, vm => vm.UpdateAvailable);
_updateCompleted = updateCompleteObservable.Select(e => true)
.ToProperty(this, vm => vm.UpdateCompleted, false);
//make sure the current version is kept up-to-date
_currentVersion = updateCompleteObservable.Select(e => deployment.CurrentVersion)
.ToProperty(this, vm => vm.CurrentVersion, deployment.CurrentVersion);
//build the in progress flags from all of our observables
_checkInProgress = Observable.Merge(checkForUpdateObservable.Select(e => false),
checkForUpdateProgressObservable.Select(e => true),
CheckForUpdate.Select(e => true),
Update.Select(e => false))
.ToProperty(this, vm => vm.CheckInProgress, false);
_updateInProgress = Observable.Merge(updateProgressObservable.Select(e => true),
updateCompleteObservable.Select(e => false),
Update.Select(e => true))
.ToProperty(this, vm => vm.UpdateInProgress, false);
Restart = new ReactiveCommand(updateCompleteObservable.Select(e => true), false, null);
Restart.Subscribe(x => appContainer.Restart());
Restart.ThrownExceptions.Subscribe();
}
