/// <summary> /// Bond-serializes a given <typeparamref name="T"/> and stores the result to the content cache. /// The returned content hash can be used to later deserialize the structure with <see cref="TryLoadAndDeserializeContent{T}"/>. /// </summary> public static Task <Possible <ContentHash> > TrySerializeAndStoreContent <T>( this IArtifactContentCache contentCache, T valueToSerialize, BoxRef <long> contentSize = null, StoreArtifactOptions options = default) { return(BondExtensions.TrySerializeAndStoreContent( valueToSerialize, async(valueHash, valueBuffer) => { using (var entryStream = new MemoryStream( valueBuffer.Array, valueBuffer.Offset, valueBuffer.Count, writable: false)) { Possible <Unit, Failure> maybeStored = await contentCache.TryStoreAsync( entryStream, contentHash: valueHash, options: options); return maybeStored.WithGenericFailure(); } }, contentSize)); }
/// <inheritdoc /> public Task <Possible <ContentHash, Failure> > TryStoreAsync( FileRealizationMode fileRealizationModes, ExpandedAbsolutePath path, StoreArtifactOptions options = default) { return(TryStoreInternalAsync( path, fileRealizationModes, knownContentHash: null)); }
/// <inheritdoc /> public async Task <Possible <Unit, Failure> > TryStoreAsync( FileRealizationMode fileRealizationModes, ExpandedAbsolutePath path, ContentHash contentHash, StoreArtifactOptions options = default) { Possible <ContentHash, Failure> maybeStored = await TryStoreInternalAsync( path, fileRealizationModes, knownContentHash : contentHash); return(maybeStored.Then(hash => Unit.Void)); }
/// <inheritdoc /> public Task <Possible <Unit, Failure> > TryStoreAsync(Stream content, ContentHash contentHash, StoreArtifactOptions options) { return(m_innerCache.TryStoreAsync(content, contentHash, options)); }
/// <inheritdoc /> public Task <Possible <ContentHash, Failure> > TryStoreAsync(FileRealizationMode fileRealizationModes, ExpandedAbsolutePath path, StoreArtifactOptions options) { return(m_innerCache.TryStoreAsync(fileRealizationModes, path, options)); }
public async Task <Possible <Unit, Failure> > TryStoreAsync(Stream content, ContentHash contentHash, StoreArtifactOptions options = default) { Possible <ContentHash, Failure> maybeStored = await TryStoreInternalAsync(content, knownContentHash : null); return(maybeStored.Then(hash => Unit.Void)); }
private Task <Possible <ContentHash, Failure> > TryStoreInternalAsync( ExpandedAbsolutePath path, FileRealizationMode fileRealizationModes, ContentHash?knownContentHash, StoreArtifactOptions options = default) { return(Task.Run <Possible <ContentHash, Failure> >( () => { lock (m_lock) { try { byte[] contentBytes = ExceptionUtilities.HandleRecoverableIOException( () => { var expandedPath = path.ExpandedPath; using (FileStream fileStream = new FileStream(expandedPath, FileMode.Open, FileAccess.Read, FileShare.Read)) using (BinaryReader binaryReader = new BinaryReader(fileStream)) { // This will work with files up to 2GB in length, due to the 'int' API signature return binaryReader.ReadBytes((int)new FileInfo(expandedPath).Length); } }, ex => { throw new BuildXLException("Failed to store content (couldn't read new content from disk)", ex); }); ContentHash contentHash = ContentHashingUtilities.HashBytes(contentBytes); if (knownContentHash.HasValue && contentHash != knownContentHash.Value) { return new Failure <string>(I($"Stored content had an unexpected hash. (expected: {knownContentHash.Value}; actual: {contentHash})")); } CacheEntry entry; if (m_content.TryGetValue(contentHash, out entry)) { // We assume that stores of content already present somewhere still cause replication // to both the local and remote sites. See class remarks. entry.Sites |= CacheSites.LocalAndRemote; return contentHash; } else { try { if (m_pathRealizationModes != null) { m_pathRealizationModes[path.ExpandedPath] = fileRealizationModes; } // We assume that stored content is instantly and magically replicated to some remote place. // See class remarks. m_content[contentHash] = new CacheEntry(contentBytes, CacheSites.LocalAndRemote); return contentHash; } catch (BuildXLException ex) { return new RecoverableExceptionFailure(ex); } } } catch (BuildXLException ex) { return new RecoverableExceptionFailure(ex); } } })); }