public SharedContainerCmdExecContext(
String installerSourceDir,
String installerTargetDir,
IContainerFile containerFile)
: base(installerSourceDir, installerTargetDir)
{
this.ContainerFile = containerFile;
}
protected ContentFileType ResolveFileType(IContainerFile container)
{
foreach (var pair in containerTypeToFileTypeMap)
{
if (pair.Key.IsInstanceOfType(container))
{
return(pair.Value);
}
}
return(ContentFileType.Unknown);
}
/// <summary>
///
/// </summary>
/// <param name="containerFile"></param>
/// <param name="token"></param>
public void WriteFile(IContainerFile containerFile, CancellationToken token)
{
if (containerFile == null)
{
throw new ArgumentNullException("containerFile");
}
var fileType = ResolveFileType(containerFile);
var writeFunc = writeFileFuncsMap[fileType];
writeFunc(containerFile, token);
}
protected ContentFileType ResolveFileType(IContainerFile file)
{
//To powinno wywnioskować na podstawie typu ownera, a nie samego pliku przekazanego
//poki co wspeiramy tylkoe data wiec ejst ok, ale ne dłuższ mete zle
foreach (var typeFileTypePair in ContainerFileTypes)
{
if (typeFileTypePair.Key.IsInstanceOfType(file))
{
return(typeFileTypePair.Value);
}
}
return(ContentFileType.Unknown);
}
/// <summary>
///
/// </summary>
/// <param name="containerFile"></param>
/// <param name="token"></param>
/// <returns></returns>
public byte[] WriteRaw(IContainerFile containerFile, CancellationToken token)
{
if (containerFile == null)
{
throw new ArgumentNullException("containerFile");
}
var fileType = ResolveFileType(containerFile);
var writeFunc = writeRawFuncsMap[fileType];
byte[] rawFileData = writeFunc(containerFile, token);
return(rawFileData);
}
private void UnrollContainers(
String targetPath,
out List <String> tempContainers,
out Stack <ContainerHierarchyEntity> containersHierarchy)
{
tempContainers = new List <String>();
containersHierarchy = new Stack <ContainerHierarchyEntity>();
IContentFileWriter contentWriter = new ContentFileWriter();
IContainerFile topContainer = ContainerReaderService.ReadFile(targetPath, false);
containersHierarchy.Push(new ContainerHierarchyEntity(topContainer));
foreach (var containerPath in CommandGroup.NestedTargetPath.Parts)
{
var containerFile = containersHierarchy.Peek().ContainerFile;
var contentFile = containerFile.GetContentFileByPath(containerPath);
//if (contentFile.FileType == ContentFileType.Edata)
//{
ContainerReaderService.LoadContent(contentFile);
byte[] content = contentFile.Content;
//Czytamy z pamięci żeby szybciej było, ale nie łądujemy zawartości żeby oszczedzić miejsce.
var virtualContainer = ContainerReaderService.ReadRaw(content, false);
//Tutaj mieć na uwadze, że ten sposób pozyskiwania ścieżki jest bardzo podatny na problemy, miejsce wolne itd.
String lastPath = Path.Combine(Path.GetDirectoryName(targetPath), Path.GetFileName(contentFile.Path));
contentWriter.Write(lastPath, content);
virtualContainer.Path = lastPath;
//Tutaj brakuje jakiejś możliwosci zmiany ścieżki dla kontenera
//i zmiany stanu z wirtualnego do przechowywanego na dysku.
containersHierarchy.Push(new ContainerHierarchyEntity(virtualContainer, containerPath));
tempContainers.Add(lastPath);
//}
}
}
protected IEnumerable <IContentFile> GetContentFiles(IContainerFile owner, IEnumerable <String> paths)
{
var resultContentFiles = new List <IContentFile>();
foreach (var path in paths)
{
if (owner.ContainsContentFileWithPath(path))
{
var contentFile = owner.GetContentFileByPath(path);
resultContentFiles.Add(contentFile);
}
else
{
//Wygląda na to że nie można tu chyba użyć wyjątku na tym etapie, jako że niektóre ścieżki,
//które trafia do tej metody mogą pochodzić od komend które dopiero tworzą content,
//więc wystąpił by wyjatek w teoretycznie poprawnej sytuacji.
var warning = String.Format("The following content file: \"{0}\"" +
"cannot be get from the specified container file.", path);
Common.Logging.LoggerFactory.Create(this.GetType()).Warn(warning);
}
}
return(resultContentFiles);
}
public ContainerFileLoadManager(IContainerFile containerFile, long maxLoadInBytes)
: this(containerFile.ContentFiles, maxLoadInBytes)
{
}
public ContainerFileLoadManager(IContainerFile containerFile)
: this(containerFile.ContentFiles)
{
}
/// <summary>
///
/// </summary>
/// <param name="containerFile"></param>
/// <returns></returns>
public byte[] WriteRaw(IContainerFile containerFile)
{
return(WriteRaw(containerFile, CancellationToken.None));
}
/// <summary>
///
/// </summary>
/// <param name="containerFile"></param>
public void WriteFile(IContainerFile containerFile)
{
WriteFile(containerFile, CancellationToken.None);
}
public ContainerHierarchyEntity(IContainerFile file, String ownerPath)
{
this.ContainerFile = file;
this.OwnerPath = ownerPath;
this.IsRoot = false;
}
public ContainerHierarchyEntity(IContainerFile file)
{
this.ContainerFile = file;
this.IsRoot = true;
}
