Example #1
0
        private void OnDestinationPreviewChange(object x, ApplyingChangeEventArgs y)
        {
            //todo: at the moment, this is never true, there's never a current file, even if the file does exist.
            //Not sure when that is supposed to be available

            if (y.CurrentFileData != null)
            {
                _currentSource.NetChangeInBytes -= y.CurrentFileData.Size;
                PredictedSpaceInKiloBytes       -= y.CurrentFileData.Size / 1024;
                //next the new size will be added back, below
            }
            switch (y.ChangeType)
            {
            case ChangeType.Create:
                _currentSource.NewFileCount++;
                _currentSource.NetChangeInBytes += y.NewFileData.Size;
                PredictedSpaceInKiloBytes       += y.NewFileData.Size / 1024;
                break;

            case ChangeType.Update:
                _currentSource.UpdateFileCount++;
                _currentSource.NetChangeInBytes += y.NewFileData.Size;
                PredictedSpaceInKiloBytes       += y.NewFileData.Size / 1024;
                break;

            case ChangeType.Delete:
                _currentSource.DeleteFileCount++;
                break;
            }
            InvokeProgress();
        }
        private string GetPathFromArgs(EventArgs args)
        {
            FileData newFileData      = null;
            FileData currentFileData  = null;
            ApplyingChangeEventArgs a = args as ApplyingChangeEventArgs;

            if (a != null)
            {
                newFileData     = a.NewFileData;
                currentFileData = a.CurrentFileData;
            }

            //enhance: when updating a file, both new and current have the same file path contents
            //this algorithm my by simpler: if current isn't null, use it, else new.

            string path = string.Empty;

            if (newFileData != null)
            {
                path = newFileData.RelativePath;
            }
            else if (currentFileData != null)
            {
                path = currentFileData.RelativePath;
            }
            return(path);
        }
Example #3
0
 private void SyncDestination_ApplyingChange(object sender, ApplyingChangeEventArgs e)
 {
     // Skip synchronization for deletes and renames.
     if (e.ChangeType == ChangeType.Delete || e.ChangeType == ChangeType.Rename)
     {
         e.SkipChange = true;
     }
 }
        private bool ShouldSkip(string mode, FileSyncProvider provider, ApplyingChangeEventArgs args)
        {
            //the built-in directory system is lame, you can't just specify the name of the directory
            //this changes the behavior to do just that
            if (args.NewFileData != null && args.NewFileData.IsDirectory)
            {
                if (_currentGroup.ShouldSkipSubDirectory(args.NewFileData))
                {
                    _progress.WriteVerbose("{0} [{1}] Skipping Folder {2}", mode, _currentGroup.Name, GetPathFromArgs(args));
                    return(true);
                }
                return(false);
            }

            if (args.CurrentFileData != null && args.CurrentFileData.IsDirectory)
            {
                if (_currentGroup.ShouldSkipSubDirectory(args.CurrentFileData))
                {
                    _progress.WriteVerbose("{0} [{1}] Skipping Folder {2}", mode, _currentGroup.Name, GetPathFromArgs(args));
                    return(true);
                }
                return(false);
            }

            if (args.NewFileData != null)
            {
                if (_alreadyAccountedFor.Contains(args.NewFileData.RelativePath))
                {
                    _progress.WriteVerbose("[{0}] Skipping new file because it was already backed up by a previous group:  {1}", _currentGroup.NewFileCount, GetPathFromArgs(args));
                    return(true);
                }
                if (_currentGroup.ShouldSkipFile(args.NewFileData.RelativePath))
                {
                    _progress.WriteVerbose("[{0}] Skipping new file: {1}", _currentGroup.Name, GetPathFromArgs(args));
                    return(true);
                }
                return(false);
            }

            if (args.CurrentFileData != null)
            {
                if (_alreadyAccountedFor.Contains(args.CurrentFileData.RelativePath))
                {
                    _progress.WriteVerbose("Skipping current file because it was already backed up by a previous group: " + args.CurrentFileData.RelativePath + "  " +
                                           args.CurrentFileData.Name);
                    return(true);
                }
                if (_currentGroup.ShouldSkipFile(args.CurrentFileData.RelativePath))
                {
                    _progress.WriteVerbose("Skipping current file: " + args.CurrentFileData.RelativePath + "  " +
                                           args.CurrentFileData.Name);
                    return(true);
                }
            }

            return(false);
        }
Example #5
0
 /// <summary>
 /// This method is called when changes are going to be done to a file
 /// <para>Counts the number of changes to be made later during synchronization</para>
 /// <para>Counts the amount of disk space needed later during synchronization</para>
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="args"></param>
 private void OnApplyingChange(object sender, ApplyingChangeEventArgs args)
 {
     countChanges++;
     if (!isCheckForLeftDone)
     {
         diskSpaceNeededForLeft += (ulong)args.NewFileData.Size;
     }
     else
     {
         diskSpaceNeededForRight += (ulong)args.NewFileData.Size;
     }
 }
Example #6
0
        private void OnDestinationChange(object x, ApplyingChangeEventArgs y)
        {
            _files++;
            InvokeProgress();

            switch (y.ChangeType)
            {
            case ChangeType.Create:
                break;

            case ChangeType.Update:
                break;

            case ChangeType.Delete:
                break;
            }
        }
        private void OnDestinationPreviewChange(object provider, ApplyingChangeEventArgs args)
        {
            if (ShouldSkip("Preview", (FileSyncProvider)provider, args))
            {
                args.SkipChange = true;
                return;
            }
            if (args.CurrentFileData != null)
            {
                _currentGroup.NetChangeInBytes -= args.CurrentFileData.Size;
                //below, we'll add back the new size, giving us the correct net change
            }
            string rootDirectoryPath = ((FileSyncProvider)provider).RootDirectoryPath;

            switch (args.ChangeType)
            {
            case ChangeType.Create:
                _progress.WriteVerbose("[{0}] Preview Create {1}", _currentGroup.Name, GetPathFromArgs(args));
                _currentGroup.NewFileCount++;
                _currentGroup.NetChangeInBytes += args.NewFileData.Size;
                _alreadyAccountedFor.Add(args.NewFileData.RelativePath);
                break;

            case ChangeType.Update:
                _progress.WriteVerbose("[{0}] Preview Update {1}", _currentGroup.Name, GetPathFromArgs(args));
                _currentGroup.UpdateFileCount++;
                _currentGroup.NetChangeInBytes += args.NewFileData.Size;
                _alreadyAccountedFor.Add(args.CurrentFileData.RelativePath);
                break;

            case ChangeType.Delete:
                if (!_currentGroup.NormallyPropogateDeletions)
                {
                    args.SkipChange = true;
                    _progress.WriteVerbose("[{0}] Because of group policy, would not propagate deletion of {1}", _currentGroup.Name, GetPathFromArgs(args));
                }
                else
                {
                    _progress.WriteVerbose("[{0}] Preview Delete {1}", _currentGroup.Name, GetPathFromArgs(args));
                    _currentGroup.DeleteFileCount++;
                }
                break;
            }
            InvokeProgress(args);
        }
        private void OnDestinationApplyingChange(object provider, ApplyingChangeEventArgs args)
        {
            if (ShouldSkip("Backup", (FileSyncProvider)provider, args))
            {
                args.SkipChange = true;
                return;
            }

            Debug.Assert(args == null || args.NewFileData == null || !args.NewFileData.Name.Contains("extensions"));

            _files++;
            InvokeProgress(args);

            switch (args.ChangeType)
            {
            case ChangeType.Create:
                _progress.WriteVerbose("[{0}] Creating {1}", _currentGroup.Name, GetPathFromArgs(args));
                _alreadyAccountedFor.Add(GetPathFromArgs(args));
                break;

            case ChangeType.Update:
                _progress.WriteVerbose("[{0}] Updating {1}", _currentGroup.Name, GetPathFromArgs(args));
                _alreadyAccountedFor.Add(GetPathFromArgs(args));
                break;

            //NB: the following doesn't work, as it's never called
            case ChangeType.Delete:
                Debug.Fail("A miracle!");
                if (!_currentGroup.NormallyPropogateDeletions &&
                    !GetPathFromArgs(args).Contains(".hg"))                                //always propogate deletions inside the mercurial folder
                {
                    args.SkipChange = true;
                    _progress.WriteVerbose("[{0}] Because of group policy, will not propagate deletion of {1}", _currentGroup.Name, GetPathFromArgs(args));
                }
                else
                {
                    _progress.WriteVerbose("[{0}] Deleting {1}", _currentGroup.Name, GetPathFromArgs(args));
                }
                break;
            }

            //review: does this really mean success?
            _errorCountSinceLastSuccess = 0;
        }
        private void DestinationProvider_ApplyingChange(object sender, ApplyingChangeEventArgs args)
        {
            switch (args.ChangeType)
            {
            case ChangeType.Create:
                Logger.Log("Detect 'ApplyingChange' CREATE on file: {0}", LogInfo.Info, VerbosityInfoLevel.V2, args.NewFileData.RelativePath);
                break;

            case ChangeType.Delete:
                Logger.Log("Detect 'ApplyingChange' DELETE on file: {0}", LogInfo.Info, VerbosityInfoLevel.V2, args.CurrentFileData.RelativePath);
                break;

            case ChangeType.Rename:
                Logger.Log("Detect 'ApplyingChange' RENAME on file: {0} to {1}", LogInfo.Info, VerbosityInfoLevel.V2, args.CurrentFileData.RelativePath, args.NewFileData.RelativePath);
                break;

            case ChangeType.Update:
                Logger.Log("Detect 'ApplyingChange' UPDATE on file: {0} to {1}", LogInfo.Info, VerbosityInfoLevel.V2, args.CurrentFileData.RelativePath, args.NewFileData.RelativePath);
                break;
            }
        }
        public static void DownloadingFile(object sender, ApplyingChangeEventArgs args)
        {
            switch (args.ChangeType)
            {
            case ChangeType.Create:
                Console.WriteLine("Creating File: {0}...", args.NewFileData.Name);
                break;

            case ChangeType.Delete:
                Console.WriteLine("Deleting File: {0}...", args.CurrentFileData.Name);
                break;

            case ChangeType.Rename:
                Console.WriteLine("Renaming File: {0} to {1}...", args.CurrentFileData.Name, args.NewFileData.Name);
                break;

            case ChangeType.Update:
                Console.WriteLine("Updating File: {0}...", args.NewFileData.Name);
                break;
            }
        }
Example #11
0
        /// <summary>
        /// This method is called when changes are going to be done to a file
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private void OnApplyingChange(object sender, ApplyingChangeEventArgs args)
        {
            FileSyncProvider provider = null;
            string           rootPath = null;

            try
            {
                provider = (FileSyncProvider)sender;
                rootPath = provider.RootDirectoryPath;
                switch (args.ChangeType)
                {
                case ChangeType.Delete:
                    fileData.Add(new FileData(rootPath, args.CurrentFileData.Name, args.CurrentFileData.RelativePath, Changes.Delete,
                                              args.CurrentFileData.IsDirectory));
                    break;

                case ChangeType.Create:
                    fileData.Add(new FileData(rootPath, args.NewFileData.Name, args.NewFileData.RelativePath, Changes.Create,
                                              args.NewFileData.IsDirectory));
                    break;

                case ChangeType.Update:
                    fileData.Add(new FileData(rootPath, args.NewFileData.Name, args.NewFileData.RelativePath, Changes.Update,
                                              args.NewFileData.IsDirectory));
                    break;

                case ChangeType.Rename:
                    fileData.Add(new FileData(rootPath, args.NewFileData.Name, args.NewFileData.RelativePath, Changes.Rename,
                                              args.NewFileData.IsDirectory));
                    break;
                }
            }
            finally
            {
                provider.Dispose();
            }
        }
Example #12
0
        private void OnApplyingChange(object sender, ApplyingChangeEventArgs args)
        {
            //throw new NotImplementedException();
            switch (args.ChangeType)
            {
                case ChangeType.Create:

                    Console.WriteLine("Change type: CREATE");
                    break;
                case ChangeType.Delete:

                    Console.WriteLine("Change type: DELETE");
                    break;
                case ChangeType.Update:

                    Console.WriteLine("Change type: UPDATE");
                    break;
                case ChangeType.Rename:

                    Console.WriteLine("Change type: RENAME");
                    break;
            }
        }
        /// <summary>
        /// This method is called when changes are going to be done to a file
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private void OnApplyingChange(object sender, ApplyingChangeEventArgs args)
        {
            FileSyncProvider provider = null;
            string rootPath = null;
            try
            {
                provider = (FileSyncProvider)sender;
                rootPath = provider.RootDirectoryPath;
                switch (args.ChangeType)
                {
                    case ChangeType.Delete:
                        fileData.Add(new FileData(rootPath, args.CurrentFileData.Name, args.CurrentFileData.RelativePath, Changes.Delete,
                            args.CurrentFileData.IsDirectory));
                        break;

                    case ChangeType.Create:
                        fileData.Add(new FileData(rootPath, args.NewFileData.Name, args.NewFileData.RelativePath, Changes.Create,
                            args.NewFileData.IsDirectory));
                        break;

                    case ChangeType.Update:
                        fileData.Add(new FileData(rootPath, args.NewFileData.Name, args.NewFileData.RelativePath, Changes.Update,
                            args.NewFileData.IsDirectory));
                        break;
                    case ChangeType.Rename:
                        fileData.Add(new FileData(rootPath, args.NewFileData.Name, args.NewFileData.RelativePath, Changes.Rename,
                            args.NewFileData.IsDirectory));
                        break;
                }
            }
            finally
            {
                provider.Dispose();
            }
        }
Example #14
0
 private void SyncDestination_ApplyingChange(object sender, ApplyingChangeEventArgs e)
 {
     // Skip synchronization for deletes and renames.
     if (e.ChangeType == ChangeType.Delete || e.ChangeType == ChangeType.Rename)
         e.SkipChange = true;
 }
 private void ApplyinLocalChange(object sender, ApplyingChangeEventArgs args)
 {
     switch (args.ChangeType) {
         case ChangeType.Create:
             Console.WriteLine("Creating File: {0} ",args.NewFileData.Name);
             break;
         case ChangeType.Delete:
             Console.WriteLine("Deleting File: {0}...", args.CurrentFileData.Name);
             break;
         case ChangeType.Rename:
             Console.WriteLine("Renaming File: {0} to {1}...", args.CurrentFileData.Name, args.NewFileData.Name);
             break;
         case ChangeType.Update:
             Console.WriteLine("Updating File: {0}...", args.NewFileData.Name);
             break;
     }
 }
Example #16
0
 public static void DownloadingFile(object sender, ApplyingChangeEventArgs args)
 {
 }
 public static void DownloadingFile(object sender, ApplyingChangeEventArgs args)
 {
 }
        /// <summary>
        /// This method is called when changes are going to be done to a file
        /// <para>Counts the number of changes to be made later during synchronization</para>
        /// <para>Counts the amount of disk space needed later during synchronization</para>
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private void OnApplyingChange(object sender, ApplyingChangeEventArgs args)
        {
            countChanges++;

            if (args.ChangeType != ChangeType.Delete)
            {
                if (!isCheckForLeftDone)
                    diskSpaceNeededForLeft += (ulong)args.NewFileData.Size;
                else
                    diskSpaceNeededForRight += (ulong)args.NewFileData.Size;
            }
        }
Example #19
0
 private void ProviderEvent_ApplyingChange(object sender, ApplyingChangeEventArgs e)
 {
     e.SkipChange = (e.ChangeType == ChangeType.Delete);
 }