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); } }