Changeset 2110


Ignore:
Timestamp:
5/15/2010 5:27:05 AM (4 years ago)
Author:
lowjoel
Message:

Partially implemented the copying of directories. Addresses #60: Eraser Secure Cut.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/SecureMoveErasureTarget.cs

    r2108 r2110  
    147147        private void CopyDirectory(DirectoryInfo info) 
    148148        { 
    149             throw new NotImplementedException(); 
     149            //We need to get the files from the list of streams 
     150            List<StreamInfo> streams = GetPaths(); 
     151            List<FileInfo> files = new List<FileInfo>( 
     152                streams.Distinct(new StreamInfoFileEqualityComparer()). 
     153                Select(x => x.File)); 
     154            long totalSize = streams.Sum(x => x.Length); 
     155 
     156            foreach (FileInfo file in files) 
     157            { 
     158                //Compute the total size of the file on the disk (including ADSes) 
     159                List<StreamInfo> fileStreams = new List<StreamInfo>( 
     160                    file.GetADSes().Select(x => new StreamInfo(info.FullName, x))); 
     161                fileStreams.Add(new StreamInfo(info.FullName)); 
     162                long fileSize = fileStreams.Sum(x => x.Length); 
     163 
     164                SteppedProgressManager fileProgress = new SteppedProgressManager(); 
     165                Progress.Steps.Add(new SteppedProgressManagerStep(fileProgress, 
     166                    fileSize / (float)totalSize, S._("Securely moving files and folders..."))); 
     167 
     168                //Add the copying step to the file progress. 
     169                ProgressManager copyProgress = new ProgressManager(); 
     170                int totalPasses = 1 + EffectiveMethod.Passes; 
     171                fileProgress.Steps.Add(new SteppedProgressManagerStep(copyProgress, 
     172                    1f / totalPasses)); 
     173 
     174                try 
     175                { 
     176                    //Compute the path to the new file. 
     177                    Uri sourceDir = new Uri(Path); 
     178                    Uri currentDir = new Uri(file.FullName).MakeRelativeUri(sourceDir); 
     179 
     180                    file.CopyTo(Destination, delegate(long TotalFileSize, long TotalBytesTransferred) 
     181                        { 
     182                            return CopyProgress(copyProgress, file, TotalFileSize, 
     183                                TotalBytesTransferred); 
     184                        }); 
     185                } 
     186                catch (OperationCanceledException) 
     187                { 
     188                    //The copy was cancelled: Complete the copy part. 
     189                    copyProgress.MarkComplete(); 
     190 
     191                    //We need to erase the partially copied copy of the file. 
     192                    SteppedProgressManager destroyProgress = new SteppedProgressManager(); 
     193                    Progress.Steps.Add(new SteppedProgressManagerStep(destroyProgress, 0.5f, 
     194                        S._("Erasing incomplete destination file"))); 
     195                    EraseFile(file, destroyProgress); 
     196 
     197                    //Rethrow the exception. 
     198                    throw; 
     199                } 
     200 
     201                //We copied the file over; erase the source file 
     202                SteppedProgressManager eraseProgress = new SteppedProgressManager(); 
     203                fileProgress.Steps.Add(new SteppedProgressManagerStep(eraseProgress, 
     204                    (totalPasses - 1) / totalPasses)); 
     205                EraseFile(file, eraseProgress); 
     206            } 
    150207        } 
    151208 
     
    154211            ProgressManager copyProgress = new ProgressManager(); 
    155212            Progress.Steps.Add(new SteppedProgressManagerStep(copyProgress, 0.5f, 
    156                 S._("Copying source file to destination"))); 
     213                S._("Copying source files to destination"))); 
    157214 
    158215            try 
     
    160217                info.CopyTo(Destination, delegate(long TotalFileSize, long TotalBytesTransferred) 
    161218                    { 
    162                         copyProgress.Completed = TotalBytesTransferred; 
    163                         copyProgress.Total = TotalFileSize; 
    164                         OnProgressChanged(this, new ProgressChangedEventArgs(Progress,  
    165                             new TaskProgressChangedEventArgs(info.FullName, 1, 1))); 
    166  
    167                         if (Task.Canceled) 
    168                             return IO.CopyProgressFunctionResult.Stop; 
    169                         return IO.CopyProgressFunctionResult.Continue; 
     219                        return CopyProgress(copyProgress, info, TotalFileSize, 
     220                            TotalBytesTransferred); 
    170221                    }); 
    171222            } 
     
    176227 
    177228                //We need to erase the partially copied copy of the file. 
    178                 FileInfo copiedFile = new FileInfo(Destination); 
    179                 List<StreamInfo> streams = new List<StreamInfo>( 
    180                     copiedFile.GetADSes().Select(x => new StreamInfo(copiedFile.FullName, x)); 
    181                 streams.Add(new StreamInfo(copiedFile.FullName)); 
    182                 long totalSize = streams.Sum(x => x.Length); 
    183  
    184                 foreach (StreamInfo stream in streams) 
    185                 { 
    186                     ProgressManager destroyProgress = new ProgressManager(); 
    187                     Progress.Steps.Add(new SteppedProgressManagerStep(destroyProgress, 
    188                         0.5f * stream.Length / totalSize, 
    189                         S._("Erasing incomplete destination file"))); 
    190                     EraseStream(stream, destroyProgress); 
    191                 } 
     229                SteppedProgressManager destroyProgress = new SteppedProgressManager(); 
     230                Progress.Steps.Add(new SteppedProgressManagerStep(destroyProgress, 0.5f, 
     231                    S._("Erasing incomplete destination file"))); 
     232                EraseFile(new FileInfo(Destination), destroyProgress); 
    192233 
    193234                //Rethrow the exception. 
    194235                throw; 
    195236            } 
     237 
     238            base.Execute(); 
     239        } 
     240 
     241        /// <summary> 
     242        /// Wrapper around <see cref="FileSystemObjectErasureTarget.EraseStream"/> 
     243        /// that will erase every stream in the provided file. 
     244        /// </summary> 
     245        /// <param name="info">The file to erase.</param> 
     246        /// <param name="eraseProgress">The progress manager for the entire 
     247        /// erasure of the file.</param> 
     248        private void EraseFile(FileInfo info, SteppedProgressManager eraseProgress) 
     249        { 
     250            List<StreamInfo> streams = new List<StreamInfo>( 
     251                info.GetADSes().Select(x => new StreamInfo(info.FullName, x))); 
     252            streams.Add(new StreamInfo(info.FullName)); 
     253            long fileSize = streams.Sum(x => x.Length); 
     254 
     255            foreach (StreamInfo stream in streams) 
     256            { 
     257                ProgressManager progress = new ProgressManager(); 
     258                eraseProgress.Steps.Add(new SteppedProgressManagerStep(progress, 
     259                    stream.Length / (float)fileSize, 
     260                    S._("Erasing incomplete destination file"))); 
     261                EraseStream(stream, progress); 
     262            } 
     263        } 
     264 
     265        private IO.CopyProgressFunctionResult CopyProgress(ProgressManager progress, 
     266            FileInfo file, long TotalFileSize, long TotalBytesTransferred)   
     267        { 
     268            progress.Completed = TotalBytesTransferred; 
     269            progress.Total = TotalFileSize; 
     270            OnProgressChanged(this, new ProgressChangedEventArgs(Progress, 
     271                new TaskProgressChangedEventArgs(file.FullName, 1, 1))); 
     272 
     273            if (Task.Canceled) 
     274                return IO.CopyProgressFunctionResult.Stop; 
     275            return IO.CopyProgressFunctionResult.Continue; 
     276        } 
     277 
     278        private class StreamInfoFileEqualityComparer : IEqualityComparer<StreamInfo> 
     279        { 
     280            #region IEqualityComparer<StreamInfo> Members 
     281 
     282            public bool Equals(StreamInfo x, StreamInfo y) 
     283            { 
     284                return x.FileName == y.FileName; 
     285            } 
     286 
     287            public int GetHashCode(StreamInfo obj) 
     288            { 
     289                return obj.FileName.GetHashCode(); 
     290            } 
     291 
     292            #endregion 
    196293        } 
    197294    } 
Note: See TracChangeset for help on using the changeset viewer.