private void Test(string expected, string sampleContent)
{
var fingerprint = FingerprintUtilities.Hash(sampleContent);
var actual = FingerprintUtilities.FingerprintToFileName(fingerprint.ToByteArray());
Assert.Equal(expected, actual);
}
/// <summary>
/// Create a fingerprint from a content hash.
/// </summary>
public static Hash ToFingerprint(this CasHash casHash)
{
var hex = casHash.ToString();
var fingerprint = FingerprintUtilities.Hash(hex);
return(new Hash(fingerprint));
}
private static ContentFingerprint CreateDownloadFingerprint(string baseText)
{
// In case something in the cached Bond data becomes incompatible, we must not match.
const string VersionText = ", BondDataVersion=2;FingerprintVersion=1";
var fingerprint = FingerprintUtilities.Hash(baseText + VersionText);
return(new ContentFingerprint(fingerprint));
}
private Tuple <Fingerprint, string> ComputeTimestampBasedHashInternal(bool skipManifestCheckTestHook)
{
Stopwatch sw = Stopwatch.StartNew();
// Computes a hash based on the paths and timestamps of all of the referenced files
using (var wrapper = Pools.StringBuilderPool.GetInstance())
{
StringBuilder sb = wrapper.Instance;
foreach (var file in GetRelevantRelativePaths(forServerDeployment: true))
{
try
{
FileInfo fi = new FileInfo(Path.Combine(BaseDirectory, file));
sb.Append(fi.Name);
sb.Append(':');
sb.Append(fi.LastWriteTimeUtc.ToBinary());
sb.AppendLine();
}
#pragma warning disable ERP022 // TODO: This should really handle specific errors
catch
{
// noop for files that cannot be found. The manifest will include exteraneous files
}
#pragma warning restore ERP022 // Unobserved exception in generic exception handler
}
if (!skipManifestCheckTestHook)
{
ContentHashingUtilities.SetDefaultHashType();
AddHashForManifestFile(sb);
}
if (sb.Length == 0)
{
throw new BuildXLException("App Deployment hash could not be computed because no files from the deployment manifest could be accessed.");
}
string text = sb.ToString();
Fingerprint fingerprint = FingerprintUtilities.Hash(text);
ComputeTimestampBasedHashTime = sw.Elapsed;
return(new Tuple <Fingerprint, string>(fingerprint, text));
}
}
/// <summary>
/// This will do a build into the session with a given name
/// and output count.
/// </summary>
/// <param name="session">The cache session to work with</param>
/// <param name="pipName">Some text that acts as a base element in the output</param>
/// <param name="pipSize">Number of elements in the output. Must be enough to cover the variants</param>
/// <param name="weakIndex">Variant with different weak index - defaults to 1</param>
/// <param name="hashIndex">Variant with different hash index - defaults to 0</param>
/// <param name="accessMethod">Method (File or stream) for how files are materialized from the cache</param>
/// <param name="determinism">Determinism to provide for new build records</param>
/// <returns>The FullCacheRecord of the build</returns>
/// <remarks>
/// This will do a "fake build" including a cache lookup via weak fingerprints
/// and then return either the existing FullCacheRecord or add the build as a new
/// one. A new FullCacheRecord will have the StrongFingerprint.CacheId set to NewRecordCacheId
/// </remarks>
public static Task <FullCacheRecord> DoPipAsync(
ICacheSession session,
string pipName,
int pipSize = DefaultFakeBuildSize,
int weakIndex = 1,
int hashIndex = 0,
CacheDeterminism determinism = default(CacheDeterminism),
CasAccessMethod accessMethod = CasAccessMethod.Stream)
{
Contract.Requires(session != null);
Contract.Requires(pipName != null);
Contract.Requires(pipSize > 0);
Contract.Requires(weakIndex >= 0 && weakIndex < pipSize);
Contract.Requires(hashIndex >= 0 && hashIndex < pipSize);
FakeBuild fake = new FakeBuild(pipName, pipSize);
WeakFingerprintHash weak = new WeakFingerprintHash(FingerprintUtilities.Hash(fake.OutputHashes[weakIndex].ToString()).ToByteArray());
Hash simpleHash = new Hash(FingerprintUtilities.Hash(fake.OutputHashes[hashIndex].ToString()));
return(DoPipAsyncImpl(session, weak, simpleHash, fake, determinism, accessMethod));
}
private static string Hash(string content)
{
var hashedBlob = FingerprintUtilities.Hash(content);
return(FingerprintUtilities.FingerprintToFileName(hashedBlob));
}
private static StrongContentFingerprint CreateStrongFingerprint(string content)
{
return(new StrongContentFingerprint(FingerprintUtilities.Hash(content)));
}
private static WeakContentFingerprint CreateWeakFingerprint(string content)
{
return(new WeakContentFingerprint(FingerprintUtilities.Hash(content)));
}
public async Task DisconnectedCacheNotQueriedForStrongFingerprints()
{
string testCacheId = "Disconnected";
ICache testCache = await InitializeCacheAsync(NewCache(testCacheId, false)).SuccessAsync();
PoisonAllRemoteSessions(testCache);
ICacheReadOnlySession roSession = await testCache.CreateReadOnlySessionAsync().SuccessAsync();
DisconnectRemoteCache(testCache);
FakeBuild fb = new FakeBuild("test", 1);
foreach (var fingerprint in roSession.EnumerateStrongFingerprints(new WeakFingerprintHash(FingerprintUtilities.Hash("fingerprint").ToByteArray())))
{
// Just run the enumerator, should all return.
}
}
private static Fingerprint GetHashForString(string target)
{
return(FingerprintUtilities.Hash(target));
}
private const int GetBuildManifestHashFromLocalFileRetryLimit = 5; // Starts from 0, retry multiplier is applied upto (GetBuildManifestHashFromLocalFileRetryLimit - 1)
/// <summary>
/// EngineEnviromentSettings.BuildManifestHashCacheSalt is used to create a salted weak fingerprint for [VSO:SHA] cache entries using the file's VSO hash as input.
/// </summary>
private WeakContentFingerprint GenerateSaltedWeakFingerprint(ContentHash hash) => new WeakContentFingerprint(FingerprintUtilities.Hash($"Hash: '{hash.ToHex()}' Salt: '{m_buildManifestHashCacheSalt}'")); // Changes to this string will invalidate all existing cache entries
