示例#1
0
        //private string _RootDir;
        //public string RootDir
        //{
        //	get
        //	{
        //		if (_RootDir == null)
        //			_RootDir = string.Format("backup-{0}", Plan.Id);
        //		return _RootDir;
        //	}
        //}

        #endregion

        #region Constructors

        public SyncOperation(SyncOperationOptions options)
        {
            Options = options;
        }
示例#2
0
        protected async void DoSynchronization(CustomSynchronizationAgent agent, Models.Synchronization sync, SyncOperationOptions options)
        {
            try
            {
                CurrentState = SyncOperationState.STARTING;
                OnStart(agent, sync);

                //
                // Synchronization
                //

                CurrentState = SyncOperationState.SYNCHRONIZING_FILES;
                {
                    Task syncTask = agent.Start(TransferAgent.RemoteRootDir, true);

                    {
                        var message = string.Format("Synchronizing files started.");
                        Info(message);
                        //StatusInfo.Update(SyncStatusLevel.INFO, message);
                        OnUpdate(new SyncOperationEvent {
                            Status = SyncOperationStatus.Started, Message = message
                        });
                    }

                    try
                    {
                        await syncTask;
                    }
                    catch (Exception ex)
                    {
                        if (ex.IsCancellation())
                        {
                            logger.Warn("Synchronizing files was canceled.");
                        }
                        else
                        {
                            logger.Log(LogLevel.Error, ex, "Caught exception during synchronizing files");
                        }

                        if (syncTask.IsFaulted || syncTask.IsCanceled)
                        {
                            if (syncTask.IsCanceled)
                            {
                                OnCancelation(agent, sync, ex);                                 // syncTask.Exception
                            }
                            else
                            {
                                OnFailure(agent, sync, ex);                                 // syncTask.Exception
                            }
                            return;
                        }
                    }

                    {
                        var message = string.Format("Synchronizing files finished.");
                        Info(message);
                        //StatusInfo.Update(SyncStatusLevel.INFO, message);
                        //OnUpdate(new SyncOperationEvent { Status = SyncOperationStatus.Finished, Message = message });
                    }

                    {
                        var message = string.Format("Estimated synchronization size: {0} files, {1}",
                                                    RemoteObjects.Count(), FileSizeUtils.FileSizeToString(agent.Results.Stats.TotalSize));
                        Info(message);
                    }
                }

                //
                // Database files saving
                //

                CurrentState = SyncOperationState.SAVING_TO_DATABASE;
                {
                    Task saveTask = ExecuteOnBackround(() =>
                    {
                        // Save everything.
                        Save(CancellationTokenSource.Token);
                    }, CancellationTokenSource.Token);

                    {
                        var message = string.Format("Database files saving started.");
                        Info(message);
                    }

                    try
                    {
                        await saveTask;
                    }
                    catch (Exception ex)
                    {
                        if (ex.IsCancellation())
                        {
                            logger.Warn("Database files saving was canceled.");
                        }
                        else
                        {
                            logger.Log(LogLevel.Error, ex, "Caught exception during database files saving");
                        }

                        if (saveTask.IsFaulted || saveTask.IsCanceled)
                        {
                            if (saveTask.IsCanceled)
                            {
                                OnCancelation(agent, sync, ex);                                 // saveTask.Exception
                            }
                            else
                            {
                                OnFailure(agent, sync, ex);                                 // saveTask.Exception
                            }
                            return;
                        }
                    }

                    {
                        var message = string.Format("Database files saving finished.");
                        Info(message);
                    }
                }

                CurrentState = SyncOperationState.FINISHING;
                OnFinish(agent, sync);
            }
            catch (Exception ex)
            {
                OnFinish(agent, sync, ex);
            }
        }
示例#3
0
 public NewSyncOperation(Models.Synchronization sync, SyncOperationOptions options)
     : base(options)
 {
     Synchronization = sync;
 }