private static ManifestEntry BuildEntry(XElement element)
{
RuntimeHelpers.EnsureSufficientExecutionStack();
if (element.NodeType != XmlNodeType.Element)
{
throw new InvalidOperationException($"Invalid manifest format. Expected a 'File' or a 'Directory' node:" +
$" '{element}'");
}
if (string.Equals(element.Name.LocalName, "File", StringComparison.Ordinal))
{
var entryName = EnsureName(element);
var path = EnsureElement(element, "ResourcePath");
var pathValue = EnsureText(path);
return(new ManifestFile(entryName, pathValue));
}
if (string.Equals(element.Name.LocalName, "Directory", StringComparison.Ordinal))
{
var directoryName = EnsureName(element);
var children = new List <ManifestEntry>();
foreach (var child in element.Elements())
{
children.Add(BuildEntry(child));
}
ValidateEntries(children);
return(ManifestDirectory.CreateDirectory(directoryName, children.ToArray()));
}
throw new InvalidOperationException($"Invalid manifest format.Expected a 'File' or a 'Directory' node. " +
$"Got '{element.Name.LocalName}' instead.");
}
internal EmbeddedFilesManifest(ManifestDirectory rootDirectory)
{
if (rootDirectory == null)
{
throw new ArgumentNullException(nameof(rootDirectory));
}
_rootDirectory = rootDirectory;
}
protected internal virtual void SetParent(ManifestDirectory directory)
{
if (Parent != null)
{
throw new InvalidOperationException("Directory already has a parent.");
}
Parent = directory;
}
public ManifestDirectoryInfo(ManifestDirectory directory, DateTimeOffset lastModified)
{
if (directory == null)
{
throw new ArgumentNullException(nameof(directory));
}
Directory = directory;
LastModified = lastModified;
}
public void TraversingRootDirectoryWithDotDot_ReturnsSinkDirectory()
{
// Arrange
var directory = ManifestDirectory.CreateRootDirectory(Array.Empty <ManifestEntry>());
// Act
var result = directory.Traverse("..");
// Assert
Assert.Equal(ManifestEntry.UnknownPath, result);
}
public void TraversingWithDot_ReturnsSelf()
{
// Arrange
var directory = ManifestDirectory.CreateDirectory("a", Array.Empty <ManifestEntry>());
// Act
var result = directory.Traverse(".");
// Assert
Assert.Same(directory, result);
}
public void TraversingANonExistingFile_ReturnsUnknownPath()
{
// Arrange
var directory = ManifestDirectory.CreateDirectory("a", Array.Empty <ManifestEntry>());
// Act
var result = directory.Traverse("missing.txt");
// Assert
Assert.Equal(ManifestEntry.UnknownPath, result);
}
public void TraversingWithDotDot_ReturnsParent()
{
// Arrange
var childDirectory = ManifestDirectory.CreateDirectory("b", Array.Empty <ManifestEntry>());
var directory = ManifestDirectory.CreateDirectory("a", new[] { childDirectory });
// Act
var result = childDirectory.Traverse("..");
// Assert
Assert.Equal(directory, result);
}
public static EmbeddedFilesManifest Parse(Assembly assembly, string name)
{
if (assembly == null)
{
throw new ArgumentNullException(nameof(assembly));
}
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
var stream = assembly.GetManifestResourceStream(name);
if (stream == null)
{
throw new InvalidOperationException($"Could not load the embedded file manifest " +
$"'{name}' for assembly '{assembly.GetName().Name}'.");
}
var document = XDocument.Load(stream);
var manifest = EnsureElement(document, "Manifest");
var manifestVersion = EnsureElement(manifest, "ManifestVersion");
var version = EnsureText(manifestVersion);
if (!string.Equals("1.0", version, StringComparison.Ordinal))
{
throw new InvalidOperationException($"The embedded file manifest '{name}' for " +
$"assembly '{assembly.GetName().Name}' specifies an unsupported file format" +
$" version: '{version}'.");
}
var fileSystem = EnsureElement(manifest, "FileSystem");
var entries = fileSystem.Elements();
var entriesList = new List <ManifestEntry>();
foreach (var element in entries)
{
var entry = BuildEntry(element);
entriesList.Add(entry);
}
ValidateEntries(entriesList);
var rootDirectory = ManifestDirectory.CreateRootDirectory(entriesList.ToArray());
return(new EmbeddedFilesManifest(rootDirectory));
}
public ManifestDirectoryContents(Assembly assembly, ManifestDirectory directory, DateTimeOffset lastModified)
{
if (assembly == null)
{
throw new ArgumentNullException(nameof(assembly));
}
if (directory == null)
{
throw new ArgumentNullException(nameof(directory));
}
Assembly = assembly;
Directory = directory;
_lastModified = lastModified;
}
internal static void ValidateChildrenAndSetParent(ManifestEntry[] children, ManifestDirectory parent)
{
foreach (var child in children)
{
if (child == UnknownPath)
{
throw new InvalidOperationException($"Invalid entry type '{nameof(ManifestSinkDirectory)}'");
}
if (child is ManifestRootDirectory)
{
throw new InvalidOperationException($"Can't add a root folder as a child");
}
child.SetParent(parent);
}
}
public static ManifestDirectory CreateDirectory(string name, ManifestEntry[] children)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentException($"'{nameof(name)}' must not be null, empty or whitespace.", nameof(name));
}
if (children == null)
{
throw new ArgumentNullException(nameof(children));
}
var result = new ManifestDirectory(name, children);
ValidateChildrenAndSetParent(children, result);
return(result);
}
public void ScopingAFolderAndTryingToGetAScopedFile_ReturnsSinkDirectory()
{
// Arrange
var directory = ManifestDirectory.CreateRootDirectory(new[] {
ManifestDirectory.CreateDirectory("a",
new[] { new ManifestFile("test1.txt", "text.txt") }),
ManifestDirectory.CreateDirectory("b",
new[] { new ManifestFile("test2.txt", "test2.txt") })
});
var newRoot = ((ManifestDirectory)directory.Traverse("a")).ToRootDirectory();
// Act
var result = newRoot.Traverse("../b/test.txt");
// Assert
Assert.Same(ManifestEntry.UnknownPath, result);
}
public void ResolveEntry_AllowsSingleDirectorySeparator(string path)
{
// Arrange
var manifest = new EmbeddedFilesManifest(
ManifestDirectory.CreateRootDirectory(
new[]
{
ManifestDirectory.CreateDirectory("wwwroot",
new[]
{
new ManifestFile("jquery.validate.js", "wwwroot.jquery.validate.js")
})
}));
// Act
var entry = manifest.ResolveEntry(path);
// Assert
Assert.NotNull(entry);
}
public void Create(List <string> InFiles, string BaseFolder)
{
BaseFolder = CombinePaths(BaseFolder, "/");
if (!BaseFolder.EndsWith("/") && !BaseFolder.EndsWith("\\"))
{
throw new AutomationException("base folder {0} should end with a separator", BaseFolder);
}
foreach (string InFilename in InFiles)
{
var Filename = CombinePaths(InFilename);
Robust_FileExists_NoExceptions(true, Filename, "Could not add {0} to manifest because it does not exist");
FileInfo Info = new FileInfo(Filename);
Filename = Info.FullName;
Robust_FileExists_NoExceptions(true, Filename, "Could not add {0} to manifest because it does not exist2");
if (!Filename.StartsWith(BaseFolder, StringComparison.InvariantCultureIgnoreCase))
{
throw new AutomationException("Could not add {0} to manifest because it does not start with the base folder {1}", Filename, BaseFolder);
}
var RelativeFile = Filename.Substring(BaseFolder.Length);
List <TempStorageFileInfo> ManifestDirectory;
string DirectoryName = CombinePaths(Path.GetDirectoryName(Filename), "/");
if (!DirectoryName.StartsWith(BaseFolder, StringComparison.InvariantCultureIgnoreCase))
{
throw new AutomationException("Could not add directory {0} to manifest because it does not start with the base folder {1}", DirectoryName, BaseFolder);
}
var RelativeDir = DirectoryName.Substring(BaseFolder.Length).Replace("\\", "/");
if (Directories.TryGetValue(RelativeDir, out ManifestDirectory) == false)
{
ManifestDirectory = new List <TempStorageFileInfo>();
Directories.Add(RelativeDir, ManifestDirectory);
}
ManifestDirectory.Add(new TempStorageFileInfo(Filename, RelativeFile));
}
Stats("Created manifest");
}
public void TestListPaths()
{
var normalFile = new ManifestNormalFile("123", new DateTime(), 10, "normal");
var dir1 = new ManifestDirectory("/dir1");
var executableFile = new ManifestExecutableFile("123", new DateTime(), 10, "executable");
var dir2 = new ManifestDirectory("/dir2");
var symlink = new ManifestSymlink("123", 10, "symlink");
var manifest = new Manifest(ManifestFormat.Sha256New, normalFile, dir1, executableFile, dir2, symlink);
manifest.ListPaths().Should().Equal(
new KeyValuePair<string, ManifestNode>("normal", normalFile),
new KeyValuePair<string, ManifestNode>("dir1", dir1),
new KeyValuePair<string, ManifestNode>(Path.Combine("dir1", "executable"), executableFile),
new KeyValuePair<string, ManifestNode>("dir2", dir2),
new KeyValuePair<string, ManifestNode>(Path.Combine("dir2", "symlink"), symlink));
}
internal void LinkToParent(ManifestDirectory parent)
{
parent.Files.Add(this);
FullName = Path.Combine(parent.FullName, FullName);
}
private static void DirectoryMustExistInDirectory(ManifestDirectory node, string packageRoot)
{
string fullPath = Path.Combine(packageRoot, node.FullPath.Replace('/', Path.DirectorySeparatorChar).Substring(1));
Assert.IsTrue(Directory.Exists(fullPath), "Directory " + fullPath + " does not exist.");
}
