/**
* Verifies that {@code cachedLayer} corresponds to the second fake layer in {@link #setUp}.
*
* @param cachedLayer the {@link CachedLayer} to verify
* @throws IOException if an I/O exception occurs
*/
private async Task VerifyIsLayer2Async(CachedLayer cachedLayer)
{
Assert.AreEqual("layerBlob2", await Blobs.WriteToStringAsync(await DecompressAsync(cachedLayer.GetBlob()).ConfigureAwait(false)).ConfigureAwait(false));
Assert.AreEqual(layerDigest2, cachedLayer.GetDigest());
Assert.AreEqual(layerDiffId2, cachedLayer.GetDiffId());
Assert.AreEqual(layerSize2, cachedLayer.GetSize());
}
public async Task <ICachedLayer> CallAsync()
{
string description = "Building " + layerType + " layer";
buildConfiguration.GetEventHandlers().Dispatch(LogEvent.Progress(description + "..."));
using (ProgressEventDispatcher ignored =
progressEventDispatcherFactory.Create("building " + layerType + " layer", 1))
using (TimerEventDispatcher ignored2 =
new TimerEventDispatcher(buildConfiguration.GetEventHandlers(), description))
{
LayersCache cache = buildConfiguration.GetApplicationLayersCache();
// Don't build the layer if it exists already.
Maybe <CachedLayer> optionalCachedLayer =
await cache.RetrieveAsync(layerConfiguration.LayerEntries).ConfigureAwait(false);
if (optionalCachedLayer.IsPresent())
{
return(new CachedLayerWithType(optionalCachedLayer.Get(), GetLayerType()));
}
IBlob layerBlob = new ReproducibleLayerBuilder(layerConfiguration.LayerEntries).Build();
CachedLayer cachedLayer =
await cache.WriteUncompressedLayerAsync(layerBlob, layerConfiguration.LayerEntries).ConfigureAwait(false);
buildConfiguration
.GetEventHandlers()
.Dispatch(LogEvent.Debug(description + " built " + cachedLayer.GetDigest()));
return(new CachedLayerWithType(cachedLayer, GetLayerType()));
}
}
public void TestBuilder_fail()
{
try
{
CachedLayer.CreateBuilder().Build();
Assert.Fail("missing required");
}
catch (ArgumentNullException ex)
{
Assert.That(ex.Message, Does.Contain("layerDigest"));
}
try
{
CachedLayer.CreateBuilder().SetLayerDigest(mockLayerDigest).Build();
Assert.Fail("missing required");
}
catch (ArgumentNullException ex)
{
Assert.That(ex.Message, Does.Contain("layerDiffId"));
}
try
{
CachedLayer.CreateBuilder().SetLayerDigest(mockLayerDigest).SetLayerDiffId(mockLayerDiffId).Build();
Assert.Fail("missing required");
}
catch (ArgumentNullException ex)
{
Assert.That(ex.Message, Does.Contain("layerBlob"));
}
}
public async Task TestWrite_compressedAsync()
{
IBlob uncompressedLayerBlob = Blobs.From("uncompressedLayerBlob");
CachedLayer cachedLayer =
await new CacheStorageWriter(cacheStorageFiles).WriteCompressedAsync(Compress(uncompressedLayerBlob)).ConfigureAwait(false);
await VerifyCachedLayerAsync(cachedLayer, uncompressedLayerBlob).ConfigureAwait(false);
}
public async Task TestRun_emptyLayersIgnoredAsync()
{
ImmutableArray <ILayerConfiguration> fakeLayerConfigurations =
ImmutableArray.Create(
fakeDependenciesLayerConfiguration,
emptyLayerConfiguration,
fakeResourcesLayerConfiguration,
fakeClassesLayerConfiguration,
emptyLayerConfiguration);
Mock.Get(mockBuildConfiguration).Setup(m => m.GetLayerConfigurations()).Returns(fakeLayerConfigurations);
// Populates the cache.
ImageLayers applicationLayers = await BuildFakeLayersToCacheAsync().ConfigureAwait(false);
Assert.AreEqual(3, applicationLayers.Size());
ImmutableArray <LayerEntry> dependenciesLayerEntries =
fakeLayerConfigurations[0].LayerEntries;
ImmutableArray <LayerEntry> resourcesLayerEntries =
fakeLayerConfigurations[2].LayerEntries;
ImmutableArray <LayerEntry> classesLayerEntries =
fakeLayerConfigurations[3].LayerEntries;
CachedLayer dependenciesCachedLayer =
await cache.RetrieveAsync(dependenciesLayerEntries).OrElseThrowAsync(() => new AssertionException("")).ConfigureAwait(false);
CachedLayer resourcesCachedLayer =
await cache.RetrieveAsync(resourcesLayerEntries).OrElseThrowAsync(() => new AssertionException("")).ConfigureAwait(false);
CachedLayer classesCachedLayer =
await cache.RetrieveAsync(classesLayerEntries).OrElseThrowAsync(() => new AssertionException("")).ConfigureAwait(false);
// Verifies that the cached layers are up-to-date.
Assert.AreEqual(
applicationLayers.Get(0).GetBlobDescriptor().GetDigest(),
dependenciesCachedLayer.GetDigest());
Assert.AreEqual(
applicationLayers.Get(1).GetBlobDescriptor().GetDigest(), resourcesCachedLayer.GetDigest());
Assert.AreEqual(
applicationLayers.Get(2).GetBlobDescriptor().GetDigest(), classesCachedLayer.GetDigest());
// Verifies that the cache reader gets the same layers as the newest application layers.
await AssertBlobsEqualAsync(applicationLayers.Get(0).GetBlob(), dependenciesCachedLayer.GetBlob()).ConfigureAwait(false);
await AssertBlobsEqualAsync(applicationLayers.Get(1).GetBlob(), resourcesCachedLayer.GetBlob()).ConfigureAwait(false);
await AssertBlobsEqualAsync(applicationLayers.Get(2).GetBlob(), classesCachedLayer.GetBlob()).ConfigureAwait(false);
}
public async Task TestBuilder_passAsync()
{
CachedLayer.Builder cachedLayerBuilder =
CachedLayer.CreateBuilder()
.SetLayerDigest(mockLayerDigest)
.SetLayerDiffId(mockLayerDiffId)
.SetLayerSize(1337);
Assert.IsFalse(cachedLayerBuilder.HasLayerBlob());
cachedLayerBuilder.SetLayerBlob(Blobs.From("layerBlob"));
Assert.IsTrue(cachedLayerBuilder.HasLayerBlob());
CachedLayer cachedLayer = cachedLayerBuilder.Build();
Assert.AreEqual(mockLayerDigest, cachedLayer.GetDigest());
Assert.AreEqual(mockLayerDiffId, cachedLayer.GetDiffId());
Assert.AreEqual(1337, cachedLayer.GetSize());
Assert.AreEqual("layerBlob", await Blobs.WriteToStringAsync(cachedLayer.GetBlob()).ConfigureAwait(false));
}
private async Task VerifyCachedLayerAsync(CachedLayer cachedLayer, IBlob uncompressedLayerBlob)
{
BlobDescriptor layerBlobDescriptor = await GetDigestAsync(Compress(uncompressedLayerBlob)).ConfigureAwait(false);
BlobDescriptor layerDiffDescriptor = await GetDigestAsync(uncompressedLayerBlob).ConfigureAwait(false);
DescriptorDigest layerDiffId = layerDiffDescriptor.GetDigest();
// Verifies cachedLayer is correct.
Assert.AreEqual(layerBlobDescriptor.GetDigest(), cachedLayer.GetDigest());
Assert.AreEqual(layerDiffId, cachedLayer.GetDiffId());
Assert.AreEqual(layerBlobDescriptor.GetSize(), cachedLayer.GetSize());
CollectionAssert.AreEqual(
await Blobs.WriteToByteArrayAsync(uncompressedLayerBlob).ConfigureAwait(false),
await Blobs.WriteToByteArrayAsync(await DecompressAsync(cachedLayer.GetBlob()).ConfigureAwait(false)).ConfigureAwait(false));
// Verifies that the files are present.
Assert.IsTrue(
Files.Exists(
cacheStorageFiles.GetLayerFile(cachedLayer.GetDigest(), cachedLayer.GetDiffId())));
}
public async Task TestWrite_uncompressedAsync()
{
IBlob uncompressedLayerBlob = Blobs.From("uncompressedLayerBlob");
BlobDescriptor layerDigestDescriptor = await GetDigestAsync(Compress(uncompressedLayerBlob)).ConfigureAwait(false);
DescriptorDigest layerDigest = layerDigestDescriptor.GetDigest();
BlobDescriptor selectorDescriptor = await GetDigestAsync(Blobs.From("selector")).ConfigureAwait(false);
DescriptorDigest selector = selectorDescriptor.GetDigest();
CachedLayer cachedLayer =
await new CacheStorageWriter(cacheStorageFiles)
.WriteUncompressedAsync(uncompressedLayerBlob, selector).ConfigureAwait(false);
await VerifyCachedLayerAsync(cachedLayer, uncompressedLayerBlob).ConfigureAwait(false);
// Verifies that the files are present.
SystemPath selectorFile = cacheStorageFiles.GetSelectorFile(selector);
Assert.IsTrue(Files.Exists(selectorFile));
Assert.AreEqual(layerDigest.GetHash(), await Blobs.WriteToStringAsync(Blobs.From(selectorFile)).ConfigureAwait(false));
}
