public void TestPermissions()
{
Assert.AreEqual(FilePermissions.FromOctalString("644"), FilePermissions.DefaultFilePermissions);
Assert.AreEqual(FilePermissions.FromOctalString("755"), FilePermissions.DefaultFolderPermissions);
LayerEntriesDo(
(layerName, layerEntry) =>
{
if (layerEntry.IsFile())
{
const PosixFilePermissions expectedFilePermissions = PosixFilePermissions.OwnerRead
| PosixFilePermissions.OwnerWrite
| PosixFilePermissions.GroupRead
| PosixFilePermissions.OthersRead;
Assert.AreEqual(
expectedFilePermissions,
layerEntry.GetMode() & PosixFilePermissions.All,
layerName + ": " + layerEntry.Name);
}
else if (layerEntry.IsDirectory)
{
const PosixFilePermissions expectedDirectoryPermissions = PosixFilePermissions.OwnerAll
| PosixFilePermissions.GroupReadExecute
| PosixFilePermissions.OthersReadExecute;
Assert.AreEqual(
expectedDirectoryPermissions,
layerEntry.GetMode() & PosixFilePermissions.All,
layerName + ": " + layerEntry.Name);
}
});
}
public async Task TestBuild_permissionsAsync()
{
SystemPath testRoot = temporaryFolder.GetRoot().ToPath();
SystemPath folder = Files.CreateDirectories(testRoot.Resolve("files1"));
SystemPath fileA = CreateFile(testRoot, "fileA", "abc", 54321);
SystemPath fileB = CreateFile(testRoot, "fileB", "def", 54321);
IBlob blob =
new ReproducibleLayerBuilder(
ImmutableArray.Create(
DefaultLayerEntry(fileA, AbsoluteUnixPath.Get("/somewhere/fileA")),
new LayerEntry(
fileB,
AbsoluteUnixPath.Get("/somewhere/fileB"),
FilePermissions.FromOctalString("123"),
LayerConfiguration.DefaultModifiedTime),
new LayerEntry(
folder,
AbsoluteUnixPath.Get("/somewhere/folder"),
FilePermissions.FromOctalString("456"),
LayerConfiguration.DefaultModifiedTime)))
.Build();
SystemPath tarFile = temporaryFolder.NewFile().ToPath();
using (Stream @out = new BufferedStream(Files.NewOutputStream(tarFile)))
{
await blob.WriteToAsync(@out).ConfigureAwait(false);
}
using (TarInputStream @in = new TarInputStream(Files.NewInputStream(tarFile)))
{
// Root folder (default folder permissions)
TarEntry rootEntry = @in.GetNextEntry();
// fileA (default file permissions)
TarEntry fileAEntry = @in.GetNextEntry();
// fileB (custom file permissions)
TarEntry fileBEntry = @in.GetNextEntry();
// folder (custom folder permissions)
TarEntry folderEntry = @in.GetNextEntry();
Assert.AreEqual("755", rootEntry.GetMode().ToOctalString());
Assert.AreEqual("644", fileAEntry.GetMode().ToOctalString());
Assert.AreEqual("123", fileBEntry.GetMode().ToOctalString());
Assert.AreEqual("456", folderEntry.GetMode().ToOctalString());
}
}
public void TestFromOctalString()
{
Assert.AreEqual(
new FilePermissions(
PosixFilePermissions.OwnerAll | PosixFilePermissions.GroupAll | PosixFilePermissions.OthersAll),
FilePermissions.FromOctalString("777"));
Assert.AreEqual(
new FilePermissions(PosixFilePermissions.None),
FilePermissions.FromOctalString("000"));
Assert.AreEqual(
new FilePermissions(
PosixFilePermissions.OwnerExecute |
PosixFilePermissions.GroupWrite |
PosixFilePermissions.OthersRead),
FilePermissions.FromOctalString("124"));
Assert.AreEqual(
new FilePermissions(
PosixFilePermissions.OwnerAll |
PosixFilePermissions.GroupRead |
PosixFilePermissions.GroupExecute |
PosixFilePermissions.OthersRead |
PosixFilePermissions.OthersExecute),
FilePermissions.FromOctalString("755"));
Assert.AreEqual(
new FilePermissions((PosixFilePermissions)0b110_100_100),
FilePermissions.FromOctalString("644"));
ImmutableArray <string> badStrings = ImmutableArray.Create("abc", "-123", "777444333", "987", "3");
foreach (string badString in badStrings)
{
try
{
FilePermissions.FromOctalString(badString);
Assert.Fail();
}
catch (ArgumentException ex)
{
Assert.AreEqual(
"octalPermissions must be a 3-digit octal number (000-777)", ex.Message);
}
}
}
public void SetUp()
{
SystemPath folder = temporaryFolder.NewFolder().ToPath();
SystemPath file1 = Files.CreateDirectory(folder.Resolve("files"));
SystemPath file2 = Files.CreateFile(folder.Resolve("files").Resolve("two"));
SystemPath file3 = Files.CreateFile(folder.Resolve("gile"));
LayerEntry testLayerEntry1 = DefaultLayerEntry(file1, AbsoluteUnixPath.Get("/extraction/path"));
LayerEntry testLayerEntry2 = DefaultLayerEntry(file2, AbsoluteUnixPath.Get("/extraction/path"));
LayerEntry testLayerEntry3 = DefaultLayerEntry(file3, AbsoluteUnixPath.Get("/extraction/path"));
LayerEntry testLayerEntry4 =
new LayerEntry(
file3,
AbsoluteUnixPath.Get("/extraction/path"),
FilePermissions.FromOctalString("755"),
LayerConfiguration.DefaultModifiedTime);
LayerEntry testLayerEntry5 =
DefaultLayerEntry(file3, AbsoluteUnixPath.Get("/extraction/patha"));
LayerEntry testLayerEntry6 =
new LayerEntry(
file3,
AbsoluteUnixPath.Get("/extraction/patha"),
FilePermissions.FromOctalString("755"),
LayerConfiguration.DefaultModifiedTime);
outOfOrderLayerEntries =
ImmutableArray.Create(
testLayerEntry4,
testLayerEntry2,
testLayerEntry6,
testLayerEntry3,
testLayerEntry1,
testLayerEntry5);
inOrderLayerEntries =
ImmutableArray.Create(
testLayerEntry1,
testLayerEntry2,
testLayerEntry3,
testLayerEntry4,
testLayerEntry5,
testLayerEntry6);
}
public void TestGenerateSelector_permissionsModified()
{
SystemPath layerFile = temporaryFolder.NewFolder("testFolder").ToPath().Resolve("file");
Files.Write(layerFile, Encoding.UTF8.GetBytes("hello"));
LayerEntry layerEntry111 =
new LayerEntry(
layerFile,
AbsoluteUnixPath.Get("/extraction/path"),
FilePermissions.FromOctalString("111"),
LayerConfiguration.DefaultModifiedTime);
LayerEntry layerEntry222 =
new LayerEntry(
layerFile,
AbsoluteUnixPath.Get("/extraction/path"),
FilePermissions.FromOctalString("222"),
LayerConfiguration.DefaultModifiedTime);
// Verify that changing permissions generates a different selector
Assert.AreNotEqual(
GenerateSelectorAsync(ImmutableArray.Create(layerEntry111)),
GenerateSelectorAsync(ImmutableArray.Create(layerEntry222)));
}
public void TestAddEntryRecursive_permissionsAndTimestamps()
{
SystemPath testDirectory = TestResources.GetResource("core/layer");
SystemPath testFile = TestResources.GetResource("core/fileA");
FilePermissions permissions1 = FilePermissions.FromOctalString("111");
FilePermissions permissions2 = FilePermissions.FromOctalString("777");
Instant timestamp1 = Instant.FromUnixTimeSeconds(123);
Instant timestamp2 = Instant.FromUnixTimeSeconds(987);
FilePermissions permissionsProvider(SystemPath _, AbsoluteUnixPath destination) =>
destination.ToString().StartsWith("/app/layer/a", StringComparison.Ordinal) ? permissions1 : permissions2;
Instant timestampProvider(SystemPath _, AbsoluteUnixPath destination) =>
destination.ToString().StartsWith("/app/layer/a", StringComparison.Ordinal) ? timestamp1 : timestamp2;
ILayerConfiguration layerConfiguration =
LayerConfiguration.CreateBuilder()
.AddEntryRecursive(
testDirectory,
AbsoluteUnixPath.Get("/app/layer/"),
permissionsProvider,
timestampProvider)
.AddEntryRecursive(
testFile,
AbsoluteUnixPath.Get("/app/fileA"),
permissionsProvider,
timestampProvider)
.Build();
ImmutableHashSet <LayerEntry> expectedLayerEntries =
ImmutableHashSet.Create(
new LayerEntry(
testDirectory, AbsoluteUnixPath.Get("/app/layer/"), permissions2, timestamp2),
new LayerEntry(
testDirectory.Resolve("a"),
AbsoluteUnixPath.Get("/app/layer/a/"),
permissions1,
timestamp1),
new LayerEntry(
testDirectory.Resolve("a/b"),
AbsoluteUnixPath.Get("/app/layer/a/b/"),
permissions1,
timestamp1),
new LayerEntry(
testDirectory.Resolve("a/b/bar"),
AbsoluteUnixPath.Get("/app/layer/a/b/bar/"),
permissions1,
timestamp1),
new LayerEntry(
testDirectory.Resolve("c/"),
AbsoluteUnixPath.Get("/app/layer/c"),
permissions2,
timestamp2),
new LayerEntry(
testDirectory.Resolve("c/cat/"),
AbsoluteUnixPath.Get("/app/layer/c/cat"),
permissions2,
timestamp2),
new LayerEntry(
testDirectory.Resolve("foo"),
AbsoluteUnixPath.Get("/app/layer/foo"),
permissions2,
timestamp2),
new LayerEntry(testFile, AbsoluteUnixPath.Get("/app/fileA"), permissions2, timestamp2));
CollectionAssert.AreEquivalent(
expectedLayerEntries, ImmutableHashSet.CreateRange(layerConfiguration.LayerEntries));
}
public async Task TestBuild_parentDirBehaviorAsync()
{
SystemPath testRoot = temporaryFolder.GetRoot().ToPath();
// the path doesn't really matter on source files, but these are structured
SystemPath parent = Files.CreateDirectories(testRoot.Resolve("aaa"));
SystemPath fileA = Files.CreateFile(parent.Resolve("fileA"));
SystemPath ignoredParent = Files.CreateDirectories(testRoot.Resolve("bbb-ignored"));
SystemPath fileB = Files.CreateFile(ignoredParent.Resolve("fileB"));
SystemPath fileC =
Files.CreateFile(Files.CreateDirectories(testRoot.Resolve("ccc-absent")).Resolve("fileC"));
IBlob layer =
new ReproducibleLayerBuilder(
ImmutableArray.Create(
new LayerEntry(
parent,
AbsoluteUnixPath.Get("/root/aaa"),
FilePermissions.FromOctalString("111"),
Instant.FromUnixTimeSeconds(10)),
new LayerEntry(
fileA,
AbsoluteUnixPath.Get("/root/aaa/fileA"),
FilePermissions.FromOctalString("222"),
Instant.FromUnixTimeSeconds(20)),
new LayerEntry(
fileB,
AbsoluteUnixPath.Get("/root/bbb-ignored/fileB"),
FilePermissions.FromOctalString("333"),
Instant.FromUnixTimeSeconds(30)),
new LayerEntry(
ignoredParent,
AbsoluteUnixPath.Get("/root/bbb-ignored"),
FilePermissions.FromOctalString("444"),
Instant.FromUnixTimeSeconds(40)),
new LayerEntry(
fileC,
AbsoluteUnixPath.Get("/root/ccc-absent/file3"),
FilePermissions.FromOctalString("555"),
Instant.FromUnixTimeSeconds(50))))
.Build();
SystemPath tarFile = temporaryFolder.NewFile().ToPath();
using (Stream @out = new BufferedStream(Files.NewOutputStream(tarFile)))
{
await layer.WriteToAsync(@out).ConfigureAwait(false);
}
using (TarInputStream @in = new TarInputStream(Files.NewInputStream(tarFile)))
{
// root (default folder permissions)
TarEntry root = @in.GetNextEntry();
Assert.AreEqual("755", root.GetMode().ToOctalString());
Assert.AreEqual(Instant.FromUnixTimeSeconds(1), Instant.FromDateTimeUtc(DateTime.SpecifyKind(root.ModTime, DateTimeKind.Utc)));
// parentAAA (custom permissions, custom timestamp)
TarEntry rootParentAAA = @in.GetNextEntry();
Assert.AreEqual("111", rootParentAAA.GetMode().ToOctalString());
Assert.AreEqual(Instant.FromUnixTimeSeconds(10), Instant.FromDateTimeUtc(DateTime.SpecifyKind(rootParentAAA.ModTime, DateTimeKind.Utc)));
// skip over fileA
@in.GetNextEntry();
// parentBBB (default permissions - ignored custom permissions, since fileB added first)
TarEntry rootParentBBB = @in.GetNextEntry();
// TODO (#1650): we want 040444 here.
Assert.AreEqual("755", rootParentBBB.GetMode().ToOctalString());
// TODO (#1650): we want Instant.ofEpochSecond(40) here.
Assert.AreEqual(Instant.FromUnixTimeSeconds(1), Instant.FromDateTimeUtc(DateTime.SpecifyKind(root.ModTime, DateTimeKind.Utc)));
// skip over fileB
@in.GetNextEntry();
// parentCCC (default permissions - no entry provided)
TarEntry rootParentCCC = @in.GetNextEntry();
Assert.AreEqual("755", rootParentCCC.GetMode().ToOctalString());
Assert.AreEqual(Instant.FromUnixTimeSeconds(1), Instant.FromDateTimeUtc(DateTime.SpecifyKind(root.ModTime, DateTimeKind.Utc)));
// we don't care about fileC
}
}