public override async Task <Stream> OpenStreamAsync(IEntryModel entryModel, FileExplorer.Defines.FileAccess access, CancellationToken ct) { //SevenZipWrapper wrapper = (Profile as SzsProfile).Wrapper; ISzsItemModel entryItemModel = entryModel as ISzsItemModel; //IEntryModel rootReferenceModel = itemModel.Root.ReferencedFile; //return new CompressMemoryStream(wrapper, rootReferenceModel, itemModel.RelativePath, access, ct); //To-DO: save to Profile.DiskIO.Mapper[itemModel].IOPath if (entryItemModel.Root.Equals(entryItemModel)) { IEntryModel referencedFile = entryItemModel.Root.ReferencedFile; return(await(referencedFile.Profile as IDiskProfile).DiskIO.OpenStreamAsync(referencedFile, access, ct)); } switch (access) { case FileExplorer.Defines.FileAccess.Read: return(await SzsFileStream.OpenReadAsync(entryModel, ct)); case FileExplorer.Defines.FileAccess.Write: return(SzsFileStream.OpenWrite(entryModel)); case FileExplorer.Defines.FileAccess.ReadWrite: return(await SzsFileStream.OpenReadWriteAsync(entryModel, ct)); } throw new NotSupportedException(); }
public override async Task <IEntryModel> RenameAsync(IEntryModel entryModel, string newName, CancellationToken ct) { SevenZipWrapper wrapper = (Profile as SzsProfile).Wrapper; string destPath = Profile.Path.Combine(Profile.Path.GetDirectoryName(entryModel.FullPath), newName); SzsProfile profile = Profile as SzsProfile; ISzsItemModel szsEntryModel = entryModel as ISzsItemModel; string type = profile.Path.GetExtension(szsEntryModel.Root.Name); using (var releaser = await profile.WorkingLock.LockAsync()) using (var stream = await profile.DiskIO.OpenStreamAsync(szsEntryModel.Root, Defines.FileAccess.ReadWrite, ct)) wrapper.Modify(type, stream, (entryModel as ISzsItemModel).RelativePath, newName, entryModel.IsDirectory && !(entryModel is SzsRootModel)); lock (profile.VirtualModels) { if (profile.VirtualModels.Contains(szsEntryModel)) { profile.VirtualModels.Remove(szsEntryModel); } } Profile.NotifyEntryChanges(this, destPath, Defines.ChangeType.Moved, entryModel.FullPath); return(await Profile.ParseAsync(destPath)); }
public override async Task DeleteAsync(IEntryModel entryModel, CancellationToken ct) { SzsProfile profile = Profile as SzsProfile; ISzsItemModel szsEntryModel = entryModel as ISzsItemModel; if (szsEntryModel is SzsRootModel) { IEntryModel rootFile = (szsEntryModel as SzsRootModel).ReferencedFile; await(rootFile.Profile as IDiskProfile) .DiskIO.DeleteAsync(rootFile, ct); return; } using (var releaser = await profile.WorkingLock.LockAsync()) using (var stream = await profile.DiskIO.OpenStreamAsync(szsEntryModel.Root, Defines.FileAccess.ReadWrite, ct)) { string type = profile.Path.GetExtension(szsEntryModel.Root.Name); profile.Wrapper.Delete(type, stream, szsEntryModel.RelativePath + (szsEntryModel.IsDirectory ? "\\*" : "")); lock (profile.VirtualModels) if (profile.VirtualModels.Contains(szsEntryModel)) { profile.VirtualModels.Remove(szsEntryModel); } } }
/// <summary> /// Not Serializable, transfer source entry to destentry. /// For transfer to ISzsItemModel only, if unsure destination use DiskTransfer with allowCustom on. /// </summary> /// <param name="srcModel"></param> /// <param name="destDirModel"></param> /// <param name="removeOriginal"></param> /// <param name="allowCustomImplementation"></param> /// <param name="nextCommand"></param> /// <returns></returns> public static IScriptCommand SzsDiskTransfer(IEntryModel[] srcModels, ISzsItemModel destDirModel, bool removeOriginal = false, IScriptCommand nextCommand = null) { return(ScriptCommands.Assign("{SourceDiskTransferEntry}", srcModels, false, ScriptCommands.Assign("{DestinationDiskTransferEntry}", destDirModel, false, SzsDiskTransfer("{SourceDiskTransferEntry}", "{DestinationDiskTransferEntry}", removeOriginal, nextCommand)))); }
public SzsDiskIOHelper(SzsProfile profile) : base(profile) { this.Mapper = new FileBasedDiskPathMapper(m => { ISzsItemModel model = m as ISzsItemModel; return(model.Profile.Path.Combine(model.Root.FullPath, model.RelativePath)); }); }
public override async Task <IEntryModel> CreateAsync(string fullPath, bool isDirectory, CancellationToken ct) { string parentPath = Profile.Path.GetDirectoryName(fullPath); string name = Profile.Path.GetFileName(fullPath); ISzsItemModel parentDir = await Profile.ParseAsync(parentPath) as ISzsItemModel; if (parentDir == null) { throw new Exception(String.Format("Parent dir {0} not exists.", parentPath)); } string relativePath = Profile.Path.Combine(parentDir.RelativePath, name); ISzsItemModel retEntryModel = new SzsChildModel(parentDir.Root, relativePath, isDirectory); (Profile as SzsProfile).VirtualModels.Add(retEntryModel); return(retEntryModel); }
public static async Task <WebFileStream> OpenReadAsync(IEntryModel entryModel, CancellationToken ct) { var profile = entryModel.Profile as SzsProfile; ISzsItemModel entryItemModel = entryModel as ISzsItemModel; IEntryModel rootModel = entryItemModel.Root.ReferencedFile; byte[] bytes = new byte[] { }; using (Stream stream = await(rootModel.Profile as IDiskProfile).DiskIO.OpenStreamAsync(rootModel, Defines.FileAccess.Read, ct)) { MemoryStream ms = new MemoryStream(); if (profile.Wrapper.ExtractOne(stream, entryItemModel.RelativePath, null, ms)) { bytes = ms.ToByteArray(); } } return(new WebFileStream(entryModel, bytes, null)); }
public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm) { Dictionary <string, Stream> compressDic = new Dictionary <string, Stream>(); try { IEntryModel[] srcEntries = await pm.GetValueAsEntryModelArrayAsync(SourceEntryKey); ISzsItemModel destEntry = await pm.GetValueAsEntryModelAsync(DestinationDirectoryEntryKey, null) as ISzsItemModel; //If destination is not SzsRoot, use DiskTransfer instead. SzsProfile destProfile = destEntry.Profile as SzsProfile; if (destProfile == null) { logger.Warn(String.Format("{0} isn't Szs based entry, DiskTransfer is used instead.", destEntry.Name)); return(IOScriptCommands.DiskTransfer(SourceEntryKey, DestinationDirectoryEntryKey, null, RemoveOriginal, false, NextCommand)); } if (!destEntry.IsDirectory) { return(ResultCommand.Error(new ArgumentException(DestinationDirectoryEntryKey + " is not a folder."))); } Func <IEntryModel, bool> fileAndArchiveOnly = em => !em.IsDirectory || (em is SzsRootModel); Func <IEntryModel, bool> lookupDirectoryNotArchiveFilter = em => em.IsDirectory && !(em is SzsRootModel); IProgress <TransferProgress> progress = pm.GetProgress(); string archiveType = destProfile.Path.GetExtension((destEntry as ISzsItemModel).Root.Name); logger.Info(String.Format("Compressing {0} -> {1} using SzsDiskTransfer", srcEntries.GetDescription(), destEntry.Name)); await Task.Run(async() => { #region OpenStream of files foreach (var srcEntry in srcEntries) { IDiskProfile srcProfile = srcEntry.Profile as IDiskProfile; if (srcProfile == null) { break; } if (fileAndArchiveOnly(srcEntry)) { logger.Debug(String.Format("Added to Dictionary : {0} -> {1}", srcEntry.FullPath, srcEntry.Name)); progress.Report(TransferProgress.SetMessage(ProgressType.Running, srcEntry.Name)); compressDic.Add(srcEntry.Name, await srcProfile.DiskIO .OpenStreamAsync(srcEntry, Defines.FileAccess.Read, pm.CancellationToken)); } else { IList <IEntryModel> srcSubEntries = await srcProfile.ListRecursiveAsync(srcEntry, pm.CancellationToken, fileAndArchiveOnly, lookupDirectoryNotArchiveFilter, false); foreach (var srcSubEntry in srcSubEntries) { string relativePath = destProfile.Path.Combine( destEntry.RelativePath, srcSubEntry.FullPath.Replace(srcEntry.Parent.FullPath, "").TrimStart('\\') ); logger.Debug(String.Format("Added to Dictionary : {0} -> {1}", srcSubEntry.FullPath, relativePath)); progress.Report(TransferProgress.SetMessage(ProgressType.Running, relativePath)); compressDic.Add(relativePath, await srcProfile.DiskIO .OpenStreamAsync(srcSubEntry, Defines.FileAccess.Read, pm.CancellationToken)); } } } #endregion Progress <Defines.ProgressEventArgs> progress1 = new Progress <Defines.ProgressEventArgs>( (pea) => { if (!String.IsNullOrEmpty(pea.Message)) { progress.Report(TransferProgress.SetMessage(Defines.ProgressType.Running, pea.Message)); } if (!String.IsNullOrEmpty(pea.File)) { progress.Report(TransferProgress.From(pea.File)); } if (pea.CurrentProgress != -1 && pea.TotalProgress != -1) { progress.Report(TransferProgress.UpdateCurrentProgress((short)((float)pea.CurrentProgress / (float)pea.TotalProgress * 100.0))); } } ); progress.Report(TransferProgress.To(destEntry.Name)); using (await destProfile.WorkingLock.LockAsync()) using (var stream = await destProfile.DiskIO.OpenStreamAsync(destEntry, Defines.FileAccess.ReadWrite, pm.CancellationToken)) destProfile.Wrapper.CompressMultiple(archiveType, stream, compressDic, progress1); logger.Info(String.Format("{0} items transfered", compressDic.Count())); return(CoreScriptCommands.NotifyEntryChanged(ChangeType.Changed, destEntry, NextCommand)); }); return(NextCommand); } finally { #region Dispose Streams if (compressDic != null) { foreach (var stream in compressDic.Values) { stream.Dispose(); } } #endregion } }