private void OnBlobTransferProgressChanged(object sender, BlobTransferProgressChangedEventArgs e)
{
if (this.onProgress != null)
{
this.onProgress.Invoke(e.ProgressPercentage);
}
}
protected virtual void OnTaskProgressChanged(BlobTransferProgressChangedEventArgs e)
{
if (TransferProgressChanged != null)
{
TransferProgressChanged(this, e);
}
}
static void blobTransferClient_TransferProgressChanged(object sender, BlobTransferProgressChangedEventArgs e)
{
if (e.ProgressPercentage > 4) // Avoid startup jitter, as the upload tasks are added.
{
Console.WriteLine("{0}% upload competed for {1}.", e.ProgressPercentage, e.LocalFile);
}
}
static void UploadProgress(object sender, BlobTransferProgressChangedEventArgs e)
{
for (int i = 0; i < 70; i++)
{
Console.Write("\b");
}
Console.Write($"Progress {e.ProgressPercentage.ToString()} %");
}
private void pstream_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
BlobTransferProgressChangedEventArgs eArgs = null;
int progress = (int)((double)e.BytesRead / e.TotalLength * 100);
// raise the progress changed event on the asyncop thread
eArgs = new BlobTransferProgressChangedEventArgs(e.BytesRead, e.TotalLength, progress, CalculateSpeed(e.BytesRead), null);
asyncOp.Post(delegate(object e2) { OnTaskProgressChanged((BlobTransferProgressChangedEventArgs)e2); }, eArgs);
}
private void OnTaskProgressChanged(BlobTransferProgressChangedEventArgs e)
{
// only fire if the % change is a multiple of 5% or has surpassed the next 5%
if (((e.ProgressPercentage % 5 == 0) && e.ProgressPercentage > lastProgress) ||
e.ProgressPercentage > lastProgress + 5)
{
lastProgress = e.ProgressPercentage;
if (TransferProgressChanged != null)
{
TransferProgressChanged(this, e);
}
}
}
public WamsUploadProgressInfo(Guid assetMoniker, BlobTransferProgressChangedEventArgs data)
{
AssetMoniker = assetMoniker;
Data = data;
}
public void WhenBlobTransferProgressChangedEventIsRaisedThenProgressCallbackIsCalled()
{
const int Percentage = 10;
var progressCalled = false;
var providedPercentage = -1;
EventHandler <BlobTransferProgressChangedEventArgs> blobTransferProgressHandler = null;
var stubAsset = new StubIAsset {
NameGet = () => "test"
};
var stubAssetFile = new StubIAssetFile();
var stubAccessPolicy = new StubIAccessPolicy();
var stubLocator = new StubILocator();
using (ShimsContext.Create())
{
var stubAssets = new StubAssetBaseCollection
{
CreateStringAssetCreationOptions =
(name, options) => stubAsset
};
var stubAssetsFiles = new StubAssetFileBaseCollection {
CreateString = path => stubAssetFile
};
stubAsset.AssetFilesGet = () => stubAssetsFiles;
var accessPolicies = new ShimAccessPolicyBaseCollection
{
CreateStringTimeSpanAccessPermissions
=
(name,
timesSpan,
accessPermissions) =>
stubAccessPolicy
};
var locators = new ShimLocatorBaseCollection
{
CreateSasLocatorIAssetIAccessPolicy =
(asset, acccessPolicy) => stubLocator
};
ShimPath.GetFileNameString = fileName => string.Empty;
ShimBlobTransferClient.Constructor = client => { };
stubAssetFile.UploadAsyncStringBlobTransferClientILocatorCancellationToken =
(filePath, blobTransferClient, locator, cancellationToken) => Task.Delay(0);
var context = new ShimCloudMediaContext
{
AssetsGet = () => stubAssets,
AccessPoliciesGet = () => accessPolicies,
LocatorsGet = () => locators,
};
Func <CloudMediaContext> createContext = () => context;
ShimBlobTransferClient.AllInstances.TransferProgressChangedAddEventHandlerOfBlobTransferProgressChangedEventArgs = (client, handler) =>
{
blobTransferProgressHandler = handler;
};
var uploader = new AzureMediaServicesUploader("myVideo", @"C:\videos\myvideo.mp4", createContext);
Action <int> onProgress = progressPercentage =>
{
progressCalled = true;
providedPercentage = progressPercentage;
};
uploader.On(progress: onProgress);
uploader.Start();
}
var args = new BlobTransferProgressChangedEventArgs(0, 0, 0, Percentage, 0, new Uri("http://myvideo"), @"C:\videos\myvideo.mp4", null);
blobTransferProgressHandler.Invoke(null, args);
Assert.IsTrue(progressCalled);
Assert.AreEqual(Percentage, providedPercentage);
}
private void ParallelUploadFile(MyAsyncContext asyncContext, AsyncOperation asyncOp)
{
BlobTransferProgressChangedEventArgs eArgs = null;
object AsyncUpdateLock = new object();
// stats from azurescope show 10 to be an optimal number of transfer threads
int numThreads = 10;
var file = new FileInfo(m_FileName);
long fileSize = file.Length;
int maxBlockSize = GetBlockSize(fileSize);
long bytesUploaded = 0;
int blockLength = 0;
// Prepare a queue of blocks to be uploaded. Each queue item is a key-value pair where
// the 'key' is block id and 'value' is the block length.
Queue <KeyValuePair <int, int> > queue = new Queue <KeyValuePair <int, int> >();
List <string> blockList = new List <string>();
int blockId = 0;
while (fileSize > 0)
{
blockLength = (int)Math.Min(maxBlockSize, fileSize);
string blockIdString = Convert.ToBase64String(ASCIIEncoding.ASCII.GetBytes(string.Format("BlockId{0}", blockId.ToString("0000000"))));
KeyValuePair <int, int> kvp = new KeyValuePair <int, int>(blockId++, blockLength);
queue.Enqueue(kvp);
blockList.Add(blockIdString);
fileSize -= blockLength;
}
m_Blob.DeleteIfExists();
BlobRequestOptions options = new BlobRequestOptions()
{
//RetryPolicy = RetryPolicies.RetryExponential(RetryPolicies.DefaultClientRetryCount, RetryPolicies.DefaultMaxBackoff),
//Timeout = TimeSpan.FromSeconds(90)
};
// Launch threads to upload blocks.
List <Thread> threads = new List <Thread>();
for (int idxThread = 0; idxThread < numThreads; idxThread++)
{
Thread t = new Thread(new ThreadStart(() =>
{
KeyValuePair <int, int> blockIdAndLength;
using (FileStream fs = new FileStream(file.FullName, FileMode.Open, FileAccess.Read))
{
while (true)
{
// Dequeue block details.
lock (queue)
{
if (asyncContext.IsCancelling)
{
break;
}
if (queue.Count == 0)
{
break;
}
blockIdAndLength = queue.Dequeue();
}
byte[] buff = new byte[blockIdAndLength.Value];
BinaryReader br = new BinaryReader(fs);
// move the file system reader to the proper position
fs.Seek(blockIdAndLength.Key * (long)maxBlockSize, SeekOrigin.Begin);
br.Read(buff, 0, blockIdAndLength.Value);
// Upload block.
string blockName = Convert.ToBase64String(BitConverter.GetBytes(
blockIdAndLength.Key));
using (MemoryStream ms = new MemoryStream(buff, 0, blockIdAndLength.Value))
{
string blockIdString = Convert.ToBase64String(ASCIIEncoding.ASCII.GetBytes(string.Format("BlockId{0}", blockIdAndLength.Key.ToString("0000000"))));
string blockHash = GetMD5HashFromStream(buff);
m_Blob.PutBlock(blockIdString, ms, blockHash, options: options);
}
lock (AsyncUpdateLock)
{
bytesUploaded += blockIdAndLength.Value;
int progress = (int)((double)bytesUploaded / file.Length * 100);
// raise the progress changed event
eArgs = new BlobTransferProgressChangedEventArgs(bytesUploaded, file.Length, progress, CalculateSpeed(bytesUploaded), null);
asyncOp.Post(delegate(object e) { OnTaskProgressChanged((BlobTransferProgressChangedEventArgs)e); }, eArgs);
}
}
}
}));
t.Start();
threads.Add(t);
}
// Wait for all threads to complete uploading data.
foreach (Thread t in threads)
{
t.Join();
}
if (!asyncContext.IsCancelling)
{
// Commit the blocklist.
m_Blob.PutBlockList(blockList, options: options);
}
}
static void blobTransferClient_TransferProgressChanged(object sender, BlobTransferProgressChangedEventArgs e)
{
Console.WriteLine("{0}% upload competed for {1}.", e.ProgressPercentage, e.SourceName);
}
private void pstream_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
BlobTransferProgressChangedEventArgs eArgs = null;
int progress = (int)((double)e.BytesRead / e.TotalLength * 100);
// raise the progress changed event on the asyncop thread
eArgs = new BlobTransferProgressChangedEventArgs(e.BytesRead, e.TotalLength, progress, CalculateSpeed(e.BytesRead), null);
asyncOp.Post(delegate(object e2) { OnTaskProgressChanged((BlobTransferProgressChangedEventArgs)e2); }, eArgs);
}
// Helper function to only raise the event if the client has subscribed to it.
protected virtual void OnTaskProgressChanged(BlobTransferProgressChangedEventArgs e)
{
if (TransferProgressChanged != null)
TransferProgressChanged(this, e);
}
private void ParallelUploadFile(MyAsyncContext asyncContext, AsyncOperation asyncOp)
{
BlobTransferProgressChangedEventArgs eArgs = null;
object AsyncUpdateLock = new object();
// stats from azurescope show 10 to be an optimal number of transfer threads
int numThreads = 10;
var file = new FileInfo(m_FileName);
long fileSize = file.Length;
int maxBlockSize = GetBlockSize(fileSize);
long bytesUploaded = 0;
int blockLength = 0;
// Prepare a queue of blocks to be uploaded. Each queue item is a key-value pair where
// the 'key' is block id and 'value' is the block length.
Queue<KeyValuePair<int, int>> queue = new Queue<KeyValuePair<int, int>>();
List<string> blockList = new List<string>();
int blockId = 0;
while (fileSize > 0)
{
blockLength = (int)Math.Min(maxBlockSize, fileSize);
string blockIdString = Convert.ToBase64String(ASCIIEncoding.ASCII.GetBytes(string.Format("BlockId{0}", blockId.ToString("0000000"))));
KeyValuePair<int, int> kvp = new KeyValuePair<int, int>(blockId++, blockLength);
queue.Enqueue(kvp);
blockList.Add(blockIdString);
fileSize -= blockLength;
}
m_Blob.DeleteIfExists();
BlobRequestOptions options = new BlobRequestOptions()
{
//RetryPolicy = RetryPolicies.RetryExponential(RetryPolicies.DefaultClientRetryCount, RetryPolicies.DefaultMaxBackoff),
//Timeout = TimeSpan.FromSeconds(90)
};
// Launch threads to upload blocks.
List<Thread> threads = new List<Thread>();
for (int idxThread = 0; idxThread < numThreads; idxThread++)
{
Thread t = new Thread(new ThreadStart(() =>
{
KeyValuePair<int, int> blockIdAndLength;
using (FileStream fs = new FileStream(file.FullName, FileMode.Open, FileAccess.Read))
{
while (true)
{
// Dequeue block details.
lock (queue)
{
if (asyncContext.IsCancelling)
break;
if (queue.Count == 0)
break;
blockIdAndLength = queue.Dequeue();
}
byte[] buff = new byte[blockIdAndLength.Value];
BinaryReader br = new BinaryReader(fs);
// move the file system reader to the proper position
fs.Seek(blockIdAndLength.Key * (long)maxBlockSize, SeekOrigin.Begin);
br.Read(buff, 0, blockIdAndLength.Value);
// Upload block.
string blockName = Convert.ToBase64String(BitConverter.GetBytes(
blockIdAndLength.Key));
using (MemoryStream ms = new MemoryStream(buff, 0, blockIdAndLength.Value))
{
string blockIdString = Convert.ToBase64String(ASCIIEncoding.ASCII.GetBytes(string.Format("BlockId{0}", blockIdAndLength.Key.ToString("0000000"))));
string blockHash = GetMD5HashFromStream(buff);
m_Blob.PutBlock(blockIdString, ms, blockHash, options: options);
}
lock (AsyncUpdateLock)
{
bytesUploaded += blockIdAndLength.Value;
int progress = (int)((double)bytesUploaded / file.Length * 100);
// raise the progress changed event
eArgs = new BlobTransferProgressChangedEventArgs(bytesUploaded, file.Length, progress, CalculateSpeed(bytesUploaded), null);
asyncOp.Post(delegate(object e) { OnTaskProgressChanged((BlobTransferProgressChangedEventArgs)e); }, eArgs);
}
}
}
}));
t.Start();
threads.Add(t);
}
// Wait for all threads to complete uploading data.
foreach (Thread t in threads)
{
t.Join();
}
if (!asyncContext.IsCancelling)
{
// Commit the blocklist.
m_Blob.PutBlockList(blockList, options: options);
}
}
private void OnTaskProgressChanged(BlobTransferProgressChangedEventArgs e)
{
// only fire if the % change is a multiple of 5% or has surpassed the next 5%
if (((e.ProgressPercentage % 5 == 0) && e.ProgressPercentage > lastProgress)
|| e.ProgressPercentage > lastProgress + 5)
{
lastProgress = e.ProgressPercentage;
if (TransferProgressChanged != null)
TransferProgressChanged(this, e);
}
}
