public static async Task CopyToAsync(
this Stream istream,
Stream ostream,
IBufferProvider bufferProvider,
CancellationToken token,
Action <long> progressIncreased)
{
var buffer = await bufferProvider.AllocBufferAsync();
try
{
while (!token.IsCancellationRequested)
{
int readLen = await istream.ReadAsync(buffer, 0, buffer.Length, token);
if (readLen <= 0)
{
break;
}
await ostream.WriteAsync(buffer, 0, readLen, token);
progressIncreased(readLen);
}
}
catch (TaskCanceledException) { }
finally
{
bufferProvider.ReleaseBuffer(buffer);
}
}
/// <summary>
/// Construct a HttpParallelDownloader.
/// </summary>
/// <param name="task">Download task, must with HttpRangedTarget.</param>
/// <param name="folderProvider">Folder provider must not be null.</param>
/// <param name="cacheProvider">Cache provider must not be null.</param>
/// <param name="bufferProvider">Buffer provider must not be null.</param>
/// <param name="checkPoint">Set the downloader to start at given checkPoint.</param>
/// <param name="threadNum">Number of threads used.</param>
/// <param name="threadSegmentSize">Downloading task is divided as segments
/// before assigned to each thread. Segment size defines the approximate
/// size of each segment.</param>
public HttpParallelDownloader(
DownloadTask task,
IFolderProvider folderProvider,
ICacheStorageProvider cacheProvider,
IBufferProvider bufferProvider,
byte[] checkPoint = null,
int threadNum = 8,
long threadSegmentSize = 8 * 1024 * 1024
) : base(task)
{
Ensure.That(task.Target is HttpRangableTarget, null, opts => opts.WithMessage(
$"type of {nameof(task.Target)} must be {nameof(HttpRangableTarget)}")
).IsTrue();
Ensure.That(folderProvider, nameof(folderProvider)).IsNotNull();
Ensure.That(cacheProvider, nameof(cacheProvider)).IsNotNull();
Ensure.That(bufferProvider, nameof(bufferProvider)).IsNotNull();
Ensure.That(threadNum, nameof(threadNum)).IsGte(1);
Ensure.That(threadSegmentSize, nameof(threadSegmentSize)).IsGt(1024 * 1024);
this.folderProvider = folderProvider;
this.cacheProvider = cacheProvider;
this.bufferProvider = bufferProvider;
this.threadNum = threadNum;
this.threadSegmentSize = threadSegmentSize;
Progress = new CompositeProgress((task.Target as HttpRangableTarget).DataLength);
Speed = SharedSpeedCalculatorFactory.NewSpeedCalculator();
Progress.ProgressChanged += (sender, arg) => Speed.CurrentValue = Progress.DownloadedSize;
if (checkPoint != null)
{
ApplyCheckPoint(checkPoint);
}
}
bool IBufferProvider.Compare(IBufferProvider Other)
{
if (Other == null)
return false;
if (object.ReferenceEquals(this, Other))
return true;
BufferWrapper autre = Other as BufferWrapper;
if (autre == null)
return false;
if (object.ReferenceEquals(_IPP, autre._IPP))
return true;
using (Stream st = _IPP.GetBuffer())
{
using (Stream st2 = autre._IPP.GetBuffer())
{
if ((st2 == null) || (st == null))
return object.ReferenceEquals(st2, st);
return st.Compare(st2);
}
}
}
/// <summary>
/// Changes a old bond wrapper for a new bond type to represent its new bond value
/// as blob data
/// </summary>
/// <typeparam name="TWrapper">the wrapper (an old bond type)</typeparam>
/// <typeparam name="TValue">the wrapped value type (an new bond type)</typeparam>
/// <param name="wrapper">the wrapper for the new bond type</param>
/// <param name="bufferProvider">the buffer provider which provides buffers used during serialization</param>
public static void Adapt <TWrapper, TValue>(TWrapper wrapper, IBufferProvider bufferProvider)
where TWrapper : DataWrapper, IBondWrapper <TValue>
{
if (wrapper != null && wrapper.Value != null && (wrapper.Data == null || wrapper.Data.Count == 0))
{
wrapper.Data = ToBlob(wrapper.Value, bufferProvider);
}
}
/// <summary>
/// Serializes a new bond value to an old bond blob
/// </summary>
/// <typeparam name="T">the type of the value</typeparam>
/// <param name="value">the new bond value</param>
/// <param name="bufferProvider">the buffer provider which provides buffers used during serialization</param>
/// <returns>the old bond blow representing the new bond value</returns>
public static Microsoft.Bond.BondBlob ToBlob <T>(T value, IBufferProvider bufferProvider)
{
OutputBuffer buffer = bufferProvider.GetOutputBuffer();
var startPosition = buffer.Position;
CompactBinaryWriter <OutputBuffer> writer = new CompactBinaryWriter <OutputBuffer>(buffer);
Serialize.To(writer, value);
bufferProvider.ReleaseOutputBuffer();
return(new Microsoft.Bond.BondBlob(buffer.Data.Array, (int)startPosition, (int)(buffer.Position - startPosition)));
}
/// <summary>
/// Changes a list of old bond wrappers for an new bond type to represent their new bond values
/// as blob data
/// </summary>
/// <typeparam name="TWrapper">the wrapper (an old bond type)</typeparam>
/// <typeparam name="TValue">the wrapped value type (an new bond type)</typeparam>
/// <param name="list">the list of wrappers for the new bond type</param>
/// <param name="bufferProvider">the buffer provider which provides buffers used during serialization</param>
public static void Adapt <TWrapper, TValue>(List <TWrapper> list, IBufferProvider bufferProvider)
where TWrapper : DataWrapper, IBondWrapper <TValue>
{
if (list != null)
{
foreach (var item in list)
{
Adapt <TWrapper, TValue>(item, bufferProvider);
}
}
}
/// <summary>
/// Changes a list of old bond wrappers for a new bond type to represent their new bond values
/// as blob data
/// </summary>
/// <typeparam name="TAdaptable">the wrapper (an old bond type)</typeparam>
/// <param name="list">the list of wrappers for the new bond type</param>
/// <param name="bufferProvider">the buffer provider which provides buffers used during serialization</param>
public static void Adapt <TAdaptable>(List <TAdaptable> list, IBufferProvider bufferProvider)
where TAdaptable : IBondAdaptable
{
if (list != null)
{
foreach (var item in list)
{
item.Adapt(bufferProvider);
}
}
}
/// <summary>
/// Construct a HttpDownloader with given task and configurations.
/// </summary>
/// <param name="task">Download task, must with HttpTarget.</param>
/// <param name="folderProvider">Folder provider must not be null.</param>
/// <param name="cacheProvider">Cache provider must not be null.</param>
/// <param name="bufferProvider">Buffer provider must not be null.</param>
public HttpDownloader(
DownloadTask task,
IFolderProvider folderProvider,
ICacheStorageProvider cacheProvider,
IBufferProvider bufferProvider
) : base(task)
{
Ensure.That(task.Target is HttpTarget, null,
opts => opts.WithMessage($"type of {nameof(task.Target)} must be {nameof(HttpTarget)}")
).IsTrue();
Ensure.That(folderProvider, nameof(folderProvider)).IsNotNull();
Ensure.That(cacheProvider, nameof(cacheProvider)).IsNotNull();
Ensure.That(bufferProvider, nameof(bufferProvider)).IsNotNull();
this.folderProvider = folderProvider;
this.cacheProvider = cacheProvider;
this.bufferProvider = bufferProvider;
Progress = new BaseProgress();
Speed = SharedSpeedCalculatorFactory.NewSpeedCalculator();
Progress.ProgressChanged += (sender, arg) => Speed.CurrentValue = Progress.DownloadedSize;
}
/// <nodoc/>
public virtual void Adapt(IBufferProvider bufferProvider)
{
}
//internal void AfterLoad()
//{
// CachedImage.AfterLoad(false);
//}
private ImageCache InitFromBuffer(IBufferProvider ibp)
{
if (_ImageCache != null)
return _ImageCache; //check buffer equality
_ImageCache = new ImageCache(this, ibp);
return _ImageCache;
}
internal AImage(IBufferProvider ImageBuffer, int iid)
{
_Buffer = ImageBuffer;
_ID = iid;
}
/// <nodoc/>
public void Adapt(IBufferProvider bufferProvider)
{
DistributionTypeExtension.Adapt <DistributionPipGraphCacheDescriptor, PipGraphCacheDescriptor>(CachedGraphDescriptor, bufferProvider);
DistributionTypeExtension.Adapt <DistributionContentHash, BondContentHash>(SymlinkFileContentHash, bufferProvider);
}
/// <nodoc/>
public void Adapt(IBufferProvider bufferProvider)
{
DistributionTypeExtension.Adapt(CompletedPips, bufferProvider);
}
/// <nodoc/>
public void Adapt(IBufferProvider bufferProvider)
{
}
/// <nodoc/>
public void Adapt(IBufferProvider bufferProvider)
{
DistributionTypeExtension.Adapt <DistributionContentHash, BondContentHash>(ContentHash, bufferProvider);
}
/// <nodoc/>
public void Adapt(IBufferProvider bufferProvider)
{
DistributionTypeExtension.Adapt <DistributionCacheFingerprint, BondFingerprint>(Fingerprint, bufferProvider);
}
/// <nodoc/>
public void Adapt(IBufferProvider bufferProvider)
{
DistributionTypeExtension.Adapt(Pips, bufferProvider);
DistributionTypeExtension.Adapt(Hashes, bufferProvider);
}
/// <nodoc/>
public override void Adapt(IBufferProvider bufferProvider)
{
DistributionTypeExtension.Adapt <DistributionPipGraphCacheDescriptor, PipGraphCacheDescriptor>(this, bufferProvider);
}
internal void Update(bool force=false)
{
AlbumImage newim = _Father.RawFrontImage;
if (!force && (object.ReferenceEquals(_ImageCached, newim)))
return;
IPersistentBufferProvider ibp = newim == null ? null : newim.CreateJpgThumbnail(Dimension);
_Buffer = ibp;
if (ibp != null)
{
ibp.DefaultExtension = ".jpg";
//ibp.Save(Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString()));
}
CachedImage = null;
_ImageCached = newim;
}
internal ImageCache(Album Father, IBufferProvider iBp)
{
_Father = Father;
_Buffer = iBp;
}
