private void CreateFolderStructure(string gameName, string archivePath)
{
_notifier.CreateFolderStructure(gameName);
using (IZipFile zip = _zipFileProcessor.Read(archivePath))
{
var directories = zip.GetDirectories();
foreach (var zipEntry in directories)
{
XboxDirectoryCreateRequest request = new XboxDirectoryCreateRequest()
{
Path = zipEntry.FileName
};
_xboxDirectoryCreateRequests.Add(request);
}
}
XboxDirectoryStructureWorker folderWorker = new XboxDirectoryStructureWorker(_xboxGameRepositoryFactory, gameName, _xboxDirectoryCreateRequests);
folderWorker.Start();
WaitForDirectoryRequestsToComplete();
_notifier.FinishedCreatingFolderStructure(gameName);
folderWorker.Stop();
}
public void FixtureSetup()
{
Monitor.Enter(monitorObject);
var assembly = Assembly.GetAssembly(typeof(ZipArchiveWrap));
var CurrentDirectory = Path.GetDirectoryName(assembly.Location);
ArchiveDirectory = assembly.CodeBase.Substring(8); //remove the "file://" from the front
ArchiveDirectory = $@"{Path.GetDirectoryName(ArchiveDirectory)}\ZipArchiveEntryWrapTestsSource";
if (!Directory.Exists(ArchiveDirectory))
{
Directory.CreateDirectory(ArchiveDirectory);
}
File.WriteAllText($@"{ArchiveDirectory}\ZipArchiveEntryWrapTests.txt", "ZipArchiveEntryWrapTests");
File.WriteAllText($@"{ArchiveDirectory}\AnotherFile.txt", "Another File!");
ArchiveFileName = $@"{CurrentDirectory}\ZipArchiveEntryWrapTests.zip";
ArchiveFileInfo = new FileInfo(ArchiveFileName);
UnarchiveDirectory = $@"{CurrentDirectory}\ZipArchiveEntryWrapTests\";
if (File.Exists(ArchiveFileName))
{
File.Delete(ArchiveFileName);
}
zipfile = new ZipFileWrap();
zipfile.CreateFromDirectory(ArchiveDirectory, ArchiveFileName);
if (Directory.Exists(UnarchiveDirectory))
{
Directory.Delete(UnarchiveDirectory, true);
}
zipfile.ExtractToDirectory(ArchiveFileName, UnarchiveDirectory);
}
public Stream Open(Resource resource)
{
if (resource == null)
{
throw new ArgumentNullException("resource");
}
if (resource.IsFolder)
{
throw new InvalidOperationException("Cannot open stream for a folder.");
}
var zipPath = resource.LogicalPath.Trim('/');
Stream zipStream = null;
IZipFile zip = null;
Stream fileStream = null;
bool attached = false;
try
{
zipStream = new MemoryStream(_zipData);
#if FX4
zip = new IonicZipFile(zipStream);
#else
zip = new FXZipFile(zipStream);
#endif
var hit = zip.Entries.FirstOrDefault(entry =>
{
return(string.Equals(entry.FullPath, zipPath, StringComparison.OrdinalIgnoreCase));
});
if (hit != null && !hit.IsFolder)
{
fileStream = hit.Open();
attached = true;
return(new AttachedDisposableStream(fileStream, zip, zipStream));
}
}
finally
{
if (!attached)
{
if (fileStream != null)
{
fileStream.Dispose();
}
if (zip != null)
{
zip.Dispose();
}
if (zipStream != null)
{
zipStream.Dispose();
}
}
}
return(null);
}
public void AddConfigFiles(CreatePackageInput input, IZipFile zipFile, PackageManifest manifest)
{
zipFile.AddFiles(new ZipFolderRequest(){
FileSet = manifest.ConfigFileSet,
RootDirectory = input.PackageFolder,
ZipDirectory = BottleFiles.ConfigFolder
});
}
public void AddDataFiles(CreateBottleInput input, IZipFile zipFile, PackageManifest manifest)
{
zipFile.AddFiles(new ZipFolderRequest()
{
FileSet = FileSet.Deep("*"),
ZipDirectory = BottleFiles.DataFolder,
RootDirectory = Path.Combine(input.PackageFolder, BottleFiles.DataFolder)
});
}
private IList <IZipEntry> GetAllFilesInArchive(string gameName, string archivePath)
{
using (IZipFile zip = _zipFileProcessor.Read(archivePath))
{
// Order files alphabetically to ensure we can resume interrupted uploads
List <IZipEntry> files = zip.ReadAllFiles();
return(files);
}
}
public void WriteToZipFile(IZipFile zipFile)
{
var cache = new Cache<string, string>(file => Path.Combine(ZipDirectory, file.PathRelativeTo(RootDirectory)));
FileSet.IncludedFilesFor(RootDirectory).Each(cache.FillDefault);
FileSet.ExcludedFilesFor(RootDirectory).Each(cache.Remove);
cache.Each((file, name) => zipFile.AddFile(file, Path.GetDirectoryName(name)));
}
public void AddConfigFiles(CreatePackageInput input, IZipFile zipFile, PackageManifest manifest)
{
zipFile.AddFiles(new ZipFolderRequest()
{
FileSet = manifest.ConfigFileSet,
RootDirectory = input.PackageFolder,
ZipDirectory = BottleFiles.ConfigFolder
});
}
public void AddDataFiles(CreatePackageInput input, IZipFile zipFile, PackageManifest manifest)
{
zipFile.AddFiles(new ZipFolderRequest()
{
FileSet = manifest.DataFileSet,
ZipDirectory = PackageInfo.DataFolder,
RootDirectory = Path.Combine(input.PackageFolder, PackageInfo.DataFolder)
});
}
public void AddDataFiles(CreateBottleInput input, IZipFile zipFile, PackageManifest manifest)
{
zipFile.AddFiles(new ZipFolderRequest()
{
FileSet = FileSet.Deep("*"),
ZipDirectory = BottleFiles.DataFolder,
RootDirectory = Path.Combine(input.PackageFolder, BottleFiles.DataFolder)
});
}
public void AddConfigFiles(CreateBottleInput input, IZipFile zipFile, PackageManifest manifest)
{
ConsoleWriter.Write(" Adding Config folder for " + BottleFiles.ConfigFiles);
zipFile.AddFiles(new ZipFolderRequest(){
FileSet = BottleFiles.ConfigFiles,
RootDirectory = input.PackageFolder,
ZipDirectory = BottleFiles.ConfigFolder
});
}
public void AddDataFiles(CreatePackageInput input, IZipFile zipFile, PackageManifest manifest)
{
zipFile.AddFiles(new ZipFolderRequest()
{
FileSet = manifest.DataFileSet,
ZipDirectory = FubuMvcPackages.DataFolder,
RootDirectory = Path.Combine(input.PackageFolder, FubuMvcPackages.DataFolder)
});
}
public void WriteToZipFile(IZipFile zipFile)
{
var cache = new Cache <string, string>(file => Path.Combine(ZipDirectory, file.PathRelativeTo(RootDirectory)));
FileSet.IncludedFilesFor(RootDirectory).Each(cache.FillDefault);
FileSet.ExcludedFilesFor(RootDirectory).Each(cache.Remove);
cache.Each((file, name) => zipFile.AddFile(file, Path.GetDirectoryName(name)));
}
public Guid WriteVersion(IZipFile zipFile)
{
var versionFile = Path.Combine(Path.GetTempPath(), FubuMvcPackages.VersionFile);
var guid = Guid.NewGuid();
_fileSystem.WriteStringToFile(versionFile, guid.ToString());
zipFile.AddFile(versionFile);
return guid;
}
public void AddConfigFiles(CreateBottleInput input, IZipFile zipFile, PackageManifest manifest)
{
ConsoleWriter.Write(" Adding Config folder for " + BottleFiles.ConfigFiles);
zipFile.AddFiles(new ZipFolderRequest()
{
FileSet = FileSet.Deep("*"),
ZipDirectory = BottleFiles.ConfigFolder,
RootDirectory = Path.Combine(input.PackageFolder, BottleFiles.ConfigFolder)
});
}
public Guid WriteVersion(IZipFile zipFile)
{
var versionFile = Path.Combine(Path.GetTempPath(), FubuMvcPackages.VersionFile);
var guid = Guid.NewGuid();
_fileSystem.WriteStringToFile(versionFile, guid.ToString());
zipFile.AddFile(versionFile);
return(guid);
}
public void AddContentFiles(CreatePackageInput input, IZipFile zipFile, PackageManifest manifest)
{
manifest.ContentFileSet.AppendExclude(FileSystem.Combine("bin","*.*"));
zipFile.AddFiles(new ZipFolderRequest()
{
FileSet = manifest.ContentFileSet,
ZipDirectory = FubuMvcPackages.WebContentFolder,
RootDirectory = input.PackageFolder
});
}
public void AddContentFiles(CreatePackageInput input, IZipFile zipFile, PackageManifest manifest)
{
manifest.ContentFileSet.AppendExclude(FileSystem.Combine("bin", "*.*"));
zipFile.AddFiles(new ZipFolderRequest()
{
FileSet = manifest.ContentFileSet,
ZipDirectory = FubuMvcPackages.WebContentFolder,
RootDirectory = input.PackageFolder
});
}
public static void Compress(DetailedLogFile logFile, IZipFile zipWrapper)
{
if (logFile.ArchiveFolderExist)
{
AddEntry(logFile);
}
else
{
zipWrapper.CreateFromDirectory(logFile.LogFileDirectory, logFile.ArchiveFolder);
}
}
public Dev2JsonStateLogger(IDSFDataObject dsfDataObject, IFile fileWrapper, IZipFile zipWrapper)
{
_dsfDataObject = dsfDataObject;
_fileWrapper = fileWrapper;
_zipWrapper = zipWrapper;
_detailedLogFile = new DetailedLogFile(_dsfDataObject, _fileWrapper);
_writer = GetDetailedLogWriter();
_jsonTextWriter = new JsonTextWriter(_writer.SynchronizedTextWriter)
{
CloseOutput = false,
};
}
public void AddConfigFiles(CreateBottleInput input, IZipFile zipFile, PackageManifest manifest)
{
if (manifest.ConfigFileSet == null)
{
ConsoleWriter.Write(" No config files");
return;
}
ConsoleWriter.Write(" Adding Config folder for " + manifest.ConfigFileSet);
zipFile.AddFiles(new ZipFolderRequest(){
FileSet = manifest.ConfigFileSet,
RootDirectory = input.PackageFolder,
ZipDirectory = BottleFiles.ConfigFolder
});
}
public void AddDataFiles(CreateBottleInput input, IZipFile zipFile, PackageManifest manifest)
{
if (manifest.DataFileSet == null)
{
ConsoleWriter.Write(" No data files");
return;
}
ConsoleWriter.Write(" Adding Data folder for " + manifest.DataFileSet);
zipFile.AddFiles(new ZipFolderRequest()
{
FileSet = manifest.DataFileSet,
ZipDirectory = BottleFiles.DataFolder,
RootDirectory = Path.Combine(input.PackageFolder, BottleFiles.DataFolder)
});
}
public void AddDataFiles(CreatePackageInput input, IZipFile zipFile, PackageManifest manifest)
{
if (manifest.DataFileSet == null)
{
ConsoleWriter.Write(" No data files");
return;
}
ConsoleWriter.Write(" Adding Data folder for " + manifest.DataFileSet);
zipFile.AddFiles(new ZipFolderRequest()
{
FileSet = manifest.DataFileSet,
ZipDirectory = BottleFiles.DataFolder,
RootDirectory = Path.Combine(input.PackageFolder, BottleFiles.DataFolder)
});
}
public void AddConfigFiles(CreatePackageInput input, IZipFile zipFile, PackageManifest manifest)
{
if (manifest.ConfigFileSet == null)
{
ConsoleWriter.Write(" No config files");
return;
}
ConsoleWriter.Write(" Adding Config folder for " + manifest.ConfigFileSet);
zipFile.AddFiles(new ZipFolderRequest()
{
FileSet = manifest.ConfigFileSet,
RootDirectory = input.PackageFolder,
ZipDirectory = BottleFiles.ConfigFolder
});
}
public void SetUp()
{
mFileSystem = A.Fake <IFileSystem>();
mZipFile = A.Fake <IFile>();
A.CallTo(() => mFileSystem.GetFile("zip file name")).Returns(mZipFile);
mZip = A.Fake <IZipFile>();
A.CallTo(() => mZipFile.ReadZip()).Returns(mZip);
mZipEntry = A.Fake <IZipEntry>();
IEnumerator <IZipEntry> enumerator = new List <IZipEntry>()
{
mZipEntry
}.GetEnumerator();
A.CallTo(() => mZip.GetEnumerator()).Returns(enumerator);
mFileExistenceChecker = A.Fake <IFileExistenceChecker>();
mUnderTest = new DbUnzipper(mFileSystem, mFileExistenceChecker);
Settings.Default.TemporaryTxtDbPath = "unpack directory";
}
public void AddContentFiles(CreatePackageInput input, IZipFile zipFile, PackageManifest manifest)
{
if (manifest.ContentFileSet == null)
{
ConsoleWriter.Write(" No WebContent files");
return;
}
ConsoleWriter.Write(" Adding WebContent folder for " + manifest.ContentFileSet);
manifest.ContentFileSet.AppendExclude(FileSystem.Combine("bin", "*.*"));
zipFile.AddFiles(new ZipFolderRequest()
{
FileSet = manifest.ContentFileSet,
ZipDirectory = BottleFiles.WebContentFolder,
RootDirectory = input.PackageFolder
});
}
public void AddContentFiles(CreateBottleInput input, IZipFile zipFile, PackageManifest manifest)
{
if (manifest.ContentFileSet == null)
{
ConsoleWriter.Write(" No WebContent files");
return;
}
ConsoleWriter.Write(" Adding WebContent folder for " + manifest.ContentFileSet);
manifest.ContentFileSet.AppendExclude(FileSystem.Combine("bin","*.*"));
zipFile.AddFiles(new ZipFolderRequest()
{
FileSet = manifest.ContentFileSet,
ZipDirectory = BottleFiles.WebContentFolder,
RootDirectory = input.PackageFolder
});
}
private UploadResumeReport CheckForResumeUpload(string gameName, string archivePath)
{
IXboxGameRepository xboxGameRepository = _xboxGameRepositoryFactory.Create();
xboxGameRepository.Connect();
UploadResumeReport uploadResumeReport = null;
using (IZipFile zip = _zipFileProcessor.Read(archivePath))
{
// Order files alphabetically to ensure we can resume interrupted uploads
List <IZipEntry> files = zip.ReadAllFiles();
_notifier.CheckingForUploadedFiles(gameName);
IUploadResumeStrategy uploadResumeStrategy = new BinarySearchUploadResumeStrategy(files, _notifier, gameName, xboxGameRepository);
uploadResumeReport = uploadResumeStrategy.GetRemainingFiles();
}
xboxGameRepository.Disconnect();
return(uploadResumeReport);
}
/// <summary>
/// Opens the book asynchronously without reading its content. Holds the handle to the EPUB file.
/// </summary>
/// <param name="filePath">path to the EPUB file</param>
/// <returns></returns>
public static async Task <EpubBookRef> OpenBookAsync(string filePath)
{
IFiler filer = DependencyService.Get <IFiler>();
IZipFile zipFile = DependencyService.Get <IZipFile>();
if (!await filer.DoesFileExistAsync(filePath).ConfigureAwait(false))
{
throw new FileNotFoundException("Specified epub file not found.", filePath);
}
IZipArchive epubArchive = await zipFile.OpenReadAsync(filePath).ConfigureAwait(false);
EpubBookRef bookRef = new EpubBookRef(epubArchive);
bookRef.FilePath = filePath;
bookRef.Schema = await SchemaReader.ReadSchemaAsync(epubArchive).ConfigureAwait(false);
bookRef.Title = bookRef.Schema.Package.Metadata.Titles.FirstOrDefault() ?? String.Empty;
bookRef.AuthorList = bookRef.Schema.Package.Metadata.Creators.Select(creator => creator.Creator).ToList();
bookRef.Author = string.Join(", ", bookRef.AuthorList);
bookRef.Content = await Task.Run(() => ContentReader.ParseContentMap(bookRef)).ConfigureAwait(false);
return(bookRef);
}
private static Dev2JsonStateLogger GetDev2JsonStateLogger(IFile fileWrapper, Mock <IDSFDataObject> mockedDataObject, IZipFile zipWrapper = null)
{
return(new Dev2JsonStateLogger(mockedDataObject.Object, fileWrapper, zipWrapper));
}
public void SetZipFile(IZipFile zipFile)
{
_zipFile = zipFile;
}
public ToolFolder(IZipFile zipFile)
{
this.zipFile = zipFile;
}
public void SetUp()
{
mZipFile = new ZipFileWrap();
}
public SiGamePack(IZipFile zipFile)
{
_zipFile = zipFile;
}
public async Task ExecuteInstallation(int id)
{
var zipTmp = _fs.GetTempPath();
var tempDir = _fs.GetTempPath();
IZipFile zip = null;
var progress = new Progress <int>(i => SetProgress(_currentProgressState, i));
_revisionMgr.OnFileExists += (s, e) => OnFileExists?.Invoke(s, e);
if (!_fs.DirectoryExists(tempDir))
{
_fs.CreateDirectory(tempDir);
}
LogInstallation("Installing revision " + id + "\n");
_currentProgressState = ProgressState.Download;
LogInstallation("Downloading file...\n");
Action cleanup = delegate
{
if (zip != null)
{
if (zip is MockZipFile)
{
_fs.DeleteDirectory(zipTmp);
}
else
{
_fs.DeleteFile(zipTmp);
}
}
_fs.DeleteDirectory(tempDir);
};
try
{
await _api.DownloadRevisionZip(id, zipTmp, progress);
}
catch (WebException e)
{
MessageBox.Show("Failed to download: " + e.Message);
cleanup();
return;
}
_currentProgressState = ProgressState.Extraction;
LogInstallation("Extracting zip file...\n");
zip = _fs.OpenZip(zipTmp);
await zip.Extract(tempDir, progress);
var parser = new TempRevisionParser(tempDir, _fs);
var modDir = parser.FindModFolder();
if (string.IsNullOrWhiteSpace(modDir))
{
const string s = "This mod cannot be installed because it does not have the appropriate file-structure.";
LogInstallation(s);
MessageBox.Show(s);
cleanup();
return;
}
_currentProgressState = ProgressState.Installation;
LogInstallation("Installing files to SFM...\n");
var tmpRev = Revision.CreateTemporaryRevisionFromFolder(id, modDir, _fs);
await _api.FetchMetadata(tmpRev);
var result = await _revisionMgr.InstallRevision(tmpRev, modDir, progress, CancellationSource.Token);
/* If we don't do this the directory deletion crashes because the handle created in zip.Extract is not released properly? */
GC.Collect();
GC.WaitForPendingFinalizers();
LogInstallation("Cleaning up...\n");
cleanup();
switch (result)
{
case InstallationResult.Success:
LogInstallation("Installation cancelled by user\n");
break;
case InstallationResult.Cancelled:
LogInstallation("Installation successful\n");
break;
default:
throw new ArgumentOutOfRangeException();
}
LogInstallation("Done!\n");
}
