public Stream Upload(string url, string filename, Stream fileStream) { HttpContent stringContent = new StringContent(filename); HttpContent fileStreamContent = new StreamContent(fileStream); using (var handler = new ProgressMessageHandler()) using (var client = HttpClientFactory.Create(handler)) using (var formData = new MultipartFormDataContent()) { client.Timeout = new TimeSpan(1, 0, 0); // 1 hour should be enough probably formData.Add(fileStreamContent, "file", filename); handler.HttpSendProgress += (s, e) => { float prog = (float)e.BytesTransferred / (float)fileStream.Length; prog = prog > 1 ? 1 : prog; if (FileProgress != null) FileProgress(filename, prog); }; var response_raw = client.PostAsync(url, formData); var response = response_raw.Result; if (!response.IsSuccessStatusCode) { return null; } return response.Content.ReadAsStreamAsync().Result; } }
/// <summary> /// Runs an HttpClient uploading files using MIME multipart to the controller. /// The client uses a progress notification message handler to report progress. /// </summary> static async void RunClient() { // Create a progress notification handler ProgressMessageHandler progress = new ProgressMessageHandler(); progress.HttpSendProgress += ProgressEventHandler; // Create an HttpClient and wire up the progress handler HttpClient client = HttpClientFactory.Create(progress); // Set the request timeout as large uploads can take longer than the default 2 minute timeout client.Timeout = TimeSpan.FromMinutes(20); // Open the file we want to upload and submit it using (FileStream fileStream = new FileStream(_filename, FileMode.Open, FileAccess.Read, FileShare.Read, BufferSize, useAsync: true)) { // Create a stream content for the file StreamContent content = new StreamContent(fileStream, BufferSize); // Create Multipart form data content, add our submitter data and our stream content MultipartFormDataContent formData = new MultipartFormDataContent(); formData.Add(new StringContent("Me"), "submitter"); formData.Add(content, "filename", _filename); // Post the MIME multipart form data upload with the file Uri address = new Uri(_baseAddress, "/api/fileupload"); HttpResponseMessage response = await client.PostAsync(address, formData); FileResult result = await response.Content.ReadAsAsync<FileResult>(); Console.WriteLine("{0}Result:{0} Filename: {1}{0} Submitter: {2}", Environment.NewLine, result.FileNames.FirstOrDefault(), result.Submitter); } }
public void Dispose_DisposesInnerContent() { // Arrange StringContent innerContent = new StringContent("HelloWorld!"); HttpRequestMessage request = new HttpRequestMessage(); ProgressMessageHandler progressHandler = new ProgressMessageHandler(); ProgressContent progressContent = new ProgressContent(innerContent, progressHandler, request); // Act progressContent.Dispose(); // Assert Assert.ThrowsObjectDisposed(() => innerContent.LoadIntoBufferAsync(), typeof(StringContent).FullName); }
private async void btnUpdate_Click(object sender, EventArgs e) { string localFileName = Path.Combine(Application.StartupPath, "LocalUpdate.zgk"); List <string> NeedUpdateFiles = DataRWLocalFileRepository.ReadObjFromFile <List <string> >(localFileName); if (NeedUpdateFiles != null && NeedUpdateFiles.Count > 0) { await Task.Run(() => { foreach (string item in NeedUpdateFiles) { ProgressMessageHandler progress = new System.Net.Http.Handlers.ProgressMessageHandler(); progress.HttpReceiveProgress += (object sender, System.Net.Http.Handlers.HttpProgressEventArgs e) => { this.prgBar.Value = e.ProgressPercentage;// (double)(e.BytesTransferred / e.TotalBytes) * 100; }; DataFileRepository.DownloadFile(item, progress); } }); if (MessageBox.Show("升级完毕,要运行主程序吗?", "完成", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes) { string updateProgram = Path.Combine(Application.StartupPath, "Office.Work.Platform.exe"); if (File.Exists(updateProgram)) { System.Diagnostics.Process.Start(updateProgram); } Application.Exit(); } } else { MessageBox.Show("未找到要升级的列表文件?", "警告", MessageBoxButtons.YesNo, MessageBoxIcon.Warning); } }
public async Task ReadByte_ReportsBytesRead() { // Arrange HttpResponseMessage response = CreateResponse(); Stream innerStream = await response.Content.ReadAsStreamAsync(); long?expectedLength = response.Content.Headers.ContentLength; MockProgressEventHandler mockProgressEventHandler; ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressEventHandler, sendProgress: false); ProgressStream progressStream = CreateProgressStream(innerStream: innerStream, progressMessageHandler: progressMessageHandler, response: response); // Act/Assert int totalBytesRead = 0; while (progressStream.ReadByte() != -1) { totalBytesRead += 1; Assert.Equal(totalBytesRead, mockProgressEventHandler.EventArgs.BytesTransferred); Assert.Equal((100L * totalBytesRead) / expectedLength, mockProgressEventHandler.EventArgs.ProgressPercentage); } Assert.Equal(expectedLength, mockProgressEventHandler.EventArgs.TotalBytes); Assert.Equal(100, mockProgressEventHandler.EventArgs.ProgressPercentage); }
public void WriteByte_ReportsBytesWritten() { // Arrange HttpRequestMessage request = CreateRequest(); Stream innerStream = new MemoryStream(); byte[] buffer = CreateBufferContent(); long? expectedLength = request.Content.Headers.ContentLength; MockProgressEventHandler mockProgressEventHandler; ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressEventHandler, sendProgress: true); ProgressStream progressStream = CreateProgressStream(innerStream: innerStream, progressMessageHandler: progressMessageHandler, request: request); // Act/Assert int totalBytesWritten = 0; while (totalBytesWritten < expectedLength) { progressStream.WriteByte(buffer[totalBytesWritten]); totalBytesWritten += 1; Assert.Equal(totalBytesWritten, mockProgressEventHandler.EventArgs.BytesTransferred); Assert.Equal((100L * totalBytesWritten) / expectedLength, mockProgressEventHandler.EventArgs.ProgressPercentage); } Assert.Equal(expectedLength, mockProgressEventHandler.EventArgs.TotalBytes); Assert.Equal(100, mockProgressEventHandler.EventArgs.ProgressPercentage); }
public async Task BeginEndRead_ReportsBytesRead() { // Arrange HttpResponseMessage response = CreateResponse(); Stream innerStream = await response.Content.ReadAsStreamAsync(); long?expectedLength = response.Content.Headers.ContentLength; MockProgressEventHandler mockProgressEventHandler; ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressEventHandler, sendProgress: false); ProgressStream progressStream = CreateProgressStream(innerStream: innerStream, progressMessageHandler: progressMessageHandler, response: response); object userState = new object(); // Act/Assert int totalBytesRead = 0; int bytesRead = 0; do { byte[] buffer = new byte[8]; IAsyncResult result = progressStream.BeginRead(buffer, 0, buffer.Length, null, userState); bytesRead = progressStream.EndRead(result); totalBytesRead += bytesRead; Assert.Same(userState, mockProgressEventHandler.EventArgs.UserState); Assert.Equal(totalBytesRead, mockProgressEventHandler.EventArgs.BytesTransferred); Assert.Equal((100L * totalBytesRead) / expectedLength, mockProgressEventHandler.EventArgs.ProgressPercentage); }while (bytesRead > 0); Assert.Equal(expectedLength, mockProgressEventHandler.EventArgs.TotalBytes); Assert.Equal(100, mockProgressEventHandler.EventArgs.ProgressPercentage); }
public async Task SerializeToStreamAsync_InsertsProgressStream() { // Arrange HttpRequestMessage request = new HttpRequestMessage(); request.Content = new StringContent("HelloWorld!"); MockProgressEventHandler progressEventHandler = new MockProgressEventHandler(); ProgressMessageHandler progressHandler = MockProgressEventHandler.CreateProgressMessageHandler( out progressEventHandler, sendProgress: true ); ProgressContent progressContent = new ProgressContent( request.Content, progressHandler, request ); MemoryStream memStream = new MemoryStream(); // Act await progressContent.CopyToAsync(memStream); // Assert Assert.True(progressEventHandler.WasInvoked); Assert.Equal(request, progressEventHandler.Sender); Assert.Equal( request.Content.Headers.ContentLength, progressEventHandler.EventArgs.TotalBytes ); }
public async Task WriteAsync_ReportsBytesWritten() { // Arrange using (ManualResetEvent writeComplete = new ManualResetEvent(false)) { HttpRequestMessage request = CreateRequest(); Stream innerStream = new MemoryStream(); byte[] buffer = CreateBufferContent(); long?expectedLength = request.Content.Headers.ContentLength; MockProgressEventHandler mockProgressEventHandler; ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressEventHandler, sendProgress: true); ProgressStream progressStream = CreateProgressStream(innerStream: innerStream, progressMessageHandler: progressMessageHandler, request: request); object userState = new object(); // Act/Assert int totalBytesWritten = 0; int bytesWritten = 0; while (totalBytesWritten < expectedLength) { bytesWritten = Math.Min(8, (int)expectedLength - totalBytesWritten); await progressStream.WriteAsync(buffer, totalBytesWritten, bytesWritten); totalBytesWritten += bytesWritten; Assert.Equal(totalBytesWritten, mockProgressEventHandler.EventArgs.BytesTransferred); Assert.Equal((100L * totalBytesWritten) / expectedLength, mockProgressEventHandler.EventArgs.ProgressPercentage); } Assert.Equal(expectedLength, mockProgressEventHandler.EventArgs.TotalBytes); Assert.Equal(100, mockProgressEventHandler.EventArgs.ProgressPercentage); } }
public void Constructor_ReportsBytesWritten(int offset, int count) { // Arrange Mock <Stream> mockInnerStream = new Mock <Stream>(); object userState = new object(); IAsyncResult mockIAsyncResult = CreateMockCompletedAsyncResult(true, userState); mockInnerStream.Setup(s => s.BeginWrite(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <AsyncCallback>(), It.IsAny <object>())) .Returns(mockIAsyncResult); MockProgressEventHandler mockProgressHandler; ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressHandler, sendProgress: true); HttpRequestMessage request = new HttpRequestMessage(); ProgressStream progressStream = ProgressStreamTest.CreateProgressStream(progressMessageHandler: progressMessageHandler, request: request); // Act IAsyncResult result = new ProgressWriteAsyncResult( mockInnerStream.Object, progressStream, sampleData, offset, count, null, userState); // Assert Assert.True(mockProgressHandler.WasInvoked); Assert.Same(request, mockProgressHandler.Sender); Assert.Equal(count, mockProgressHandler.EventArgs.BytesTransferred); Assert.Same(userState, mockProgressHandler.EventArgs.UserState); }
public void BeginEndWrite_ReportsBytesWritten() { // Arrange HttpRequestMessage request = CreateRequest(); Stream innerStream = new MemoryStream(); byte[] buffer = CreateBufferContent(); long? expectedLength = request.Content.Headers.ContentLength; MockProgressEventHandler mockProgressEventHandler; ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressEventHandler, sendProgress: true); ProgressStream progressStream = CreateProgressStream(innerStream: innerStream, progressMessageHandler: progressMessageHandler, request: request); object userState = new object(); // Act/Assert int totalBytesWritten = 0; int bytesWritten = 0; while (totalBytesWritten < expectedLength) { bytesWritten = Math.Min(8, (int)expectedLength - totalBytesWritten); IAsyncResult result = progressStream.BeginWrite(buffer, totalBytesWritten, bytesWritten, null, userState); progressStream.EndWrite(result); totalBytesWritten += bytesWritten; Assert.Same(userState, mockProgressEventHandler.EventArgs.UserState); Assert.Equal(totalBytesWritten, mockProgressEventHandler.EventArgs.BytesTransferred); Assert.Equal((100L * totalBytesWritten) / expectedLength, mockProgressEventHandler.EventArgs.ProgressPercentage); } Assert.Equal(expectedLength, mockProgressEventHandler.EventArgs.TotalBytes); Assert.Equal(100, mockProgressEventHandler.EventArgs.ProgressPercentage); }
public ProgressContent(HttpContent innerContent, ProgressMessageHandler handler, HttpRequestMessage request) { Contract.Assert(innerContent != null); Contract.Assert(handler != null); Contract.Assert(request != null); _innerContent = innerContent; _handler = handler; _request = request; innerContent.Headers.CopyTo(Headers); }
internal static ProgressStream CreateProgressStream( Stream innerStream = null, ProgressMessageHandler progressMessageHandler = null, HttpRequestMessage request = null, HttpResponseMessage response = null) { Stream iStream = innerStream ?? new Mock <Stream>().Object; ProgressMessageHandler pHandler = progressMessageHandler ?? new ProgressMessageHandler(); HttpRequestMessage req = request ?? new HttpRequestMessage(); HttpResponseMessage rsp = response ?? new HttpResponseMessage(); return(new ProgressStream(iStream, pHandler, req, rsp)); }
public void Constructor_CopyHeadersFromInnerContent() { // Arrange StringContent innerContent = new StringContent("HelloWorld!"); innerContent.Headers.Add(TestHeader, TestValue); HttpRequestMessage request = new HttpRequestMessage(); ProgressMessageHandler progressHandler = new ProgressMessageHandler(); // Act ProgressContent progressContent = new ProgressContent(innerContent, progressHandler, request); // Assert ValidateContentHeader(progressContent); Assert.Equal(innerContent.Headers.ContentType, progressContent.Headers.ContentType); Assert.Equal(innerContent.Headers.ContentLength, progressContent.Headers.ContentLength); }
private static HttpMessageInvoker CreateMessageInvoker(bool includeResponseEntity, bool addSendProgressHandler, bool addReceiveProgressHandler) { ShortCircuitMessageHandler innerHandler = new ShortCircuitMessageHandler(includeResponseEntity); ProgressMessageHandler progress = new ProgressMessageHandler(innerHandler); if (addSendProgressHandler) { progress.HttpSendProgress += new MockProgressEventHandler().Handler; } if (addReceiveProgressHandler) { progress.HttpReceiveProgress += new MockProgressEventHandler().Handler; } return(new HttpMessageInvoker(progress)); }
public ProgressStream(Stream innerStream, ProgressMessageHandler handler, HttpRequestMessage request, HttpResponseMessage response) : base(innerStream) { Contract.Assert(handler != null); Contract.Assert(request != null); if (request.Content != null) { _totalBytesToSend = request.Content.Headers.ContentLength; } if (response != null && response.Content != null) { _totalBytesToReceive = response.Content.Headers.ContentLength; } _handler = handler; _request = request; }
private static async Task UploadToServer(ProgressMessageHandler progress) { using (HttpClient client = HttpClientFactory.Create(progress)) { client.Timeout = TimeSpan.FromMinutes(20); using (fileStream = new FileStream(_filename, FileMode.Open, FileAccess.Read, FileShare.Read, BufferSize, useAsync: true)) { var content = new StreamContent(fileStream, BufferSize); var formData = new MultipartFormDataContent(); formData.Add(new StringContent("Me"), "submitter"); formData.Add(content, "filename", _filename); var address = new Uri(_baseAddress, "api/upload/uploadfile"); HttpResponseMessage response = await client.PostAsync(address, formData); var result = await response.Content.ReadAsAsync<FileResult>(); Console.WriteLine("{0}Result:{0} Filename: {1}{0} Submitter: {2}", Environment.NewLine, result.FileNames.FirstOrDefault(), result.Submitter); } } }
public async override Task Upload(string filename, Model.UserConfiguration uc, EventHandler<HttpProgressEventArgs> progressHandler, CancellationToken cancelToken) { Dictionary<string, string> values = new Dictionary<string, string>(); values.Add("notes", _appInfo.Notes); values.Add("notes_type", "0"); values.Add("status", _appInfo.Status.ToString()); values.Add("notify", _appInfo.Notify.ToString()); values.Add("release_type", _appInfo.ReleaseType.ToString()); values.Add("mandatory", _appInfo.Mandatory.ToString()); FileStream fs = new FileStream(filename, FileMode.Open); HttpContent formContent = new FormUrlEncodedContent(values); HttpContent fileContent = new StreamContent(fs); MultipartFormDataContent multipartContent = new MultipartFormDataContent(); multipartContent.Add(formContent); multipartContent.Add(fileContent, "ipa", Path.GetFileName(filename)); ProgressMessageHandler progress = new ProgressMessageHandler(); progress.HttpSendProgress += progressHandler; HttpClient client = HttpClientFactory.Create(progress); client.Timeout = TimeSpan.FromMinutes(10); client.DefaultRequestHeaders.Add("X-HockeyAppToken", uc.UserToken); HttpResponseMessage response = null; response = await client.PostAsync(uc.ApiBase + "apps", multipartContent, cancelToken); if (response != null && !response.IsSuccessStatusCode) { throw new Exception(response.ReasonPhrase); } fs.Close(); }
private async Task<string> DownloadInstallation(string loadPath) { string filePath = Path.ChangeExtension(Path.GetTempFileName(), "exe"); using (HttpClientHandler handler = new HttpClientHandler()) using (ProgressMessageHandler progressMessageHandler = new ProgressMessageHandler(handler)) { progressMessageHandler.HttpReceiveProgress += UpdateProgress; using (HttpClient client = new HttpClient(progressMessageHandler)) using (HttpResponseMessage response = await client.GetAsync(loadPath, cancellationToken.Token)) { response.EnsureSuccessStatusCode(); using (Stream stream = await response.Content.ReadAsStreamAsync()) using (FileStream file = File.OpenWrite(filePath)) { await stream.CopyToAsync(file); } } } return filePath; }
internal static async void RunClient() { var progress = new ProgressMessageHandler(); progress.HttpSendProgress += (sender, eventArgs) => { var request = sender as HttpRequestMessage; string message; if (eventArgs.TotalBytes != null) { message = String.Format(" Request {0} uploaded {1} of {2} bytes ({3}%)", request.RequestUri, eventArgs.BytesTransferred, eventArgs.TotalBytes, eventArgs.ProgressPercentage); } else { message = String.Format(" Request {0} uploaded {1} bytes", request.RequestUri, eventArgs.BytesTransferred, eventArgs.TotalBytes, eventArgs.ProgressPercentage); } Console.WriteLine(message); }; await UploadToServer(progress); }
/// <summary> /// 打开该文件,如本地不存在则下载之。 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private async void btn_OpenFileAsync(object sender, RoutedEventArgs e) { Button V_Button = sender as Button; V_Button.IsEnabled = false; ProgressMessageHandler progress = new System.Net.Http.Handlers.ProgressMessageHandler(); progress.HttpReceiveProgress += (object sender, System.Net.Http.Handlers.HttpProgressEventArgs e) => { _CurUCViewModel.CurFile.DownIntProgress = e.ProgressPercentage;// (double)(e.BytesTransferred / e.TotalBytes) * 100; }; string theDownFileName = await DataPlanFileRepository.DownloadFile(_CurUCViewModel.CurFile, false, progress); if (theDownFileName == null) { AppFuns.ShowMessage("文件下载失败,可能已被删除!", "警告"); V_Button.IsEnabled = true; return; } _CurUCViewModel.CurFile.DownIntProgress = 100; DataPlanFileRepository.OpenFileInfo(theDownFileName); V_Button.IsEnabled = true; }
public async Task <JSON_Upload> Upload(object FileToUpload, UploadTypes UploadType, string DestinationFolderID, string FileName, IProgress <ReportStatus> ReportCls = null, CancellationToken token = default) { var uploadUrl = await GetUploadUrl(DestinationFolderID); ReportCls = ReportCls ?? new Progress <ReportStatus>(); ReportCls.Report(new ReportStatus() { Finished = false, TextStatus = "Initializing..." }); try { System.Net.Http.Handlers.ProgressMessageHandler progressHandler = new System.Net.Http.Handlers.ProgressMessageHandler(new HCHandler()); progressHandler.HttpSendProgress += (sender, e) => { ReportCls.Report(new ReportStatus() { ProgressPercentage = e.ProgressPercentage, BytesTransferred = e.BytesTransferred, TotalBytes = e.TotalBytes ?? 0, TextStatus = "Uploading..." }); }; HttpClient localHttpClient = new HtpClient(progressHandler); HttpRequestMessage HtpReqMessage = new HttpRequestMessage(HttpMethod.Post, new Uri(uploadUrl.form_action)); MultipartFormDataContent MultipartsformData = new MultipartFormDataContent(); HttpContent streamContent = null; switch (UploadType) { case UploadTypes.FilePath: streamContent = new StreamContent(new FileStream(FileToUpload.ToString(), FileMode.Open, FileAccess.Read)); break; case UploadTypes.Stream: streamContent = new StreamContent((Stream)FileToUpload); break; case UploadTypes.BytesArry: streamContent = new StreamContent(new MemoryStream((byte[])FileToUpload)); break; } streamContent.Headers.Clear(); streamContent.Headers.ContentDisposition = new System.Net.Http.Headers.ContentDispositionHeaderValue("form-data") { Name = "file", FileName = FileName }; streamContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/octet-stream"); MultipartsformData.Add(streamContent); // ''''''''''''''''''''''''' MultipartsformData.Add(new StringContent(uploadUrl.form_data.ajax.ToString()), "ajax"); MultipartsformData.Add(new StringContent(uploadUrl.form_data.@params), "params"); MultipartsformData.Add(new StringContent(uploadUrl.form_data.signature), "signature"); HtpReqMessage.Content = MultipartsformData; // ''''''''''''''''will write the whole content to H.D WHEN download completed''''''''''''''''''''''''''''' using (HttpResponseMessage ResPonse = await localHttpClient.SendAsync(HtpReqMessage, HttpCompletionOption.ResponseHeadersRead, token).ConfigureAwait(false)) { string result = await ResPonse.Content.ReadAsStringAsync(); token.ThrowIfCancellationRequested(); ResPonse.EnsureSuccessStatusCode(); if (JObject.Parse(result).SelectToken("status").ToString() == "success") { ReportCls.Report(new ReportStatus() { Finished = true, TextStatus = $"[{FileName}] Uploaded successfully" }); var userInfo = JsonConvert.DeserializeObject <JSON_Upload>(result, JSONhandler); return(userInfo); } else { var errorInfo = JsonConvert.DeserializeObject <JSON_Error>(result, JSONhandler); ReportCls.Report(new ReportStatus() { Finished = true, TextStatus = $"The request returned with HTTP status code {errorInfo.ErrorMessage}" }); return(null); } } } catch (Exception ex) { ReportCls.Report(new ReportStatus() { Finished = true }); if (ex.Message.ToString().ToLower().Contains("a task was canceled")) { ReportCls.Report(new ReportStatus() { TextStatus = ex.Message }); } else { throw new keep2shareException(ex.Message, 1001); } return(null); } }
public async Task<MultipartUploadResult> MultipartUpload(MultiUploadRequestData multiUploadObject, Action<HttpProcessData> uploadProcessCallback = null, CancellationToken? cancellationToken = null) { MultipartUploadResult result = null; HttpClientHandler hand = null; ProgressMessageHandler processMessageHander = null; HttpClient localHttpClient = null; OssHttpRequestMessage httpRequestMessage = null; HttpResponseMessage response = null; try { hand = new HttpClientHandler(); processMessageHander = new ProgressMessageHandler(hand); localHttpClient = new HttpClient(processMessageHander); localHttpClient.Timeout += new TimeSpan(2 * TimeSpan.TicksPerHour); Dictionary<string, string> parameters = new Dictionary<string, string>(); parameters.Add("partNumber", multiUploadObject.PartNumber); parameters.Add("uploadId", multiUploadObject.UploadId); httpRequestMessage = new OssHttpRequestMessage(multiUploadObject.Bucket, multiUploadObject.Key, parameters); httpRequestMessage.Method = HttpMethod.Put; httpRequestMessage.Headers.Date = DateTime.UtcNow; httpRequestMessage.Content = new StreamContent(multiUploadObject.Content); if (uploadProcessCallback != null) { processMessageHander.HttpSendProgress += (sender, e) => { uploadProcessCallback(new HttpProcessData() { TotalBytes = e.TotalBytes, BytesTransferred = e.BytesTransferred, ProgressPercentage = e.ProgressPercentage }); }; } OssRequestSigner.Sign(httpRequestMessage, networkCredential); if (cancellationToken != null) response = await localHttpClient.SendAsync(httpRequestMessage, (CancellationToken)cancellationToken); else response = await localHttpClient.SendAsync(httpRequestMessage); if (response.IsSuccessStatusCode == false) { await ErrorResponseHandler.Handle(response); } var deseserializer = DeserializerFactory.GetFactory().CreateMultipartUploadDeserializer(); result = deseserializer.Deserialize(response); } catch (Exception ex) { throw ex; } finally { if (hand != null) hand.Dispose(); if (processMessageHander != null) processMessageHander.Dispose(); if (localHttpClient != null) localHttpClient.Dispose(); if (httpRequestMessage != null) httpRequestMessage.Dispose(); if (response != null) response.Dispose(); } return result; }
private async void uploadButton_Click(object sender, EventArgs eventArgs) { if (selectMediaFileDialog.ShowDialog() == DialogResult.OK) { string fileName = selectMediaFileDialog.FileName; using (var channel = ChannelManager.CreateChannel()) { try { if (MediaConfigFile.Id == Guid.Empty) { MediaConfigFile = await taskPool.AddTask(channel.Service.EditMediaConfigFile(MediaConfigFile)); } CancellationTokenSource uploadOperation = new CancellationTokenSource(); var progress = new ProgressMessageHandler(); progress.HttpSendProgress += new EventHandler<HttpProgressEventArgs>((s, e) => { try { Invoke(new MethodInvoker(() => { uploadMediaFileProgressBar.Value = e.ProgressPercentage; })); } catch (ObjectDisposedException) { uploadOperation.Cancel(); } }); Uri uri = new Uri(string.Format("{0}/media-config/files/{1}/upload", mediaConfig.ServiceUrl, mediaConfigFile.Id)); var message = new HttpRequestMessage() { Method = HttpMethod.Post, Content = new StreamContent(File.OpenRead(selectMediaFileDialog.FileName)), RequestUri = uri }; var client = HttpClientFactory.Create(progress); await taskPool.AddTask(client.SendAsync(message, uploadOperation.Token)); } catch (OperationCanceledException) { } catch (CommunicationObjectAbortedException) { } catch (ObjectDisposedException) { } catch (InvalidOperationException) { } catch (FaultException exception) { UIHelper.Warning(exception.Reason.ToString()); } catch (Exception exception) { UIHelper.Warning(exception.Message); } } } }
public async Task Analyze(Action<long, long?, int> progressCallback) { //this cts signals that pooling need to be terminated CancellationTokenSource cts = new CancellationTokenSource(); //results polling task var pollingTask = Task.Run(async () => { await Task.Delay(TimeSpan.FromMilliseconds(options.ResultFirstDelayMsec)); while (!cts.IsCancellationRequested) { try { await ReadAnalysisAsync(cts.Token); await Task.Delay(TimeSpan.FromMilliseconds(options.ResultPollingPeriodMsec), cts.Token); } catch (OperationCanceledException ox) { Debug.WriteLine(ox.Message); } } }); //up-streaming block using (Stream stream = new ReadStreamWithRateControl(File.OpenRead(options.SoundFile), options.BytePerSecRate)) { //progress callback var processMessageHander = new ProgressMessageHandler(new HttpClientHandler()); processMessageHander.HttpSendProgress += (_, args) => Always(() => progressCallback(args.BytesTransferred, args.TotalBytes, args.ProgressPercentage)); using (var client = new HttpClient(processMessageHander)) { client.Timeout = TimeSpan.FromMilliseconds(Timeout.Infinite); client.DefaultRequestHeaders.TransferEncodingChunked = true; try { var responce = await client.PostAsync(UpstreamUrl, new StreamContent(stream));//upstream post var content = await responce.Content.ReadAsStringAsync();//wait for result cts.CancelAfter(TimeSpan.FromSeconds(1));//signal cancel to polling task if (responce.IsSuccessStatusCode) { dynamic responceContent = JsonConvert.DeserializeObject(content, jsonSerializerSettings); dynamic result = responceContent.result; RaiseSessionEvent(SessionEventType.Complete, result); } else { RaiseSessionEvent(SessionEventType.Error, responce.ToString() + "\r\n" + content); throw new Exception(responce.ToString() + "\r\n" + content); } } catch (Exception e) { Debug.WriteLine(e.Message); throw; } } } await pollingTask; }
/// <summary> /// Calls b2_download_file_by_id /// /// https://www.backblaze.com/b2/docs/b2_download_file_by_id.html /// </summary> public async Task<B2DownloadResult> DownloadFileContent(string fileId, string overrideAuthToken = null, NotifyProgress notifyProgress = null) { HttpRequestMessage msg = new HttpRequestMessage(HttpMethod.Get, new Uri(DownloadUri, "/b2api/v1/b2_download_file_by_id?fileId=" + fileId)); if (!string.IsNullOrEmpty(overrideAuthToken) || !string.IsNullOrEmpty(AuthToken)) msg.Headers.Authorization = new AuthenticationHeaderValue(overrideAuthToken ?? AuthToken); ProgressMessageHandler progressMessageHandler = new ProgressMessageHandler(new HttpClientHandler()); EventHandler<HttpProgressEventArgs> progress = null; if (notifyProgress != null) { progress = (sender, args) => { notifyProgress(args.TotalBytes ?? 0, args.TotalBytes ?? 0); }; progressMessageHandler.HttpSendProgress += progress; } HttpResponseMessage resp = GetHttpClient(true, progressMessageHandler).SendAsync(msg, HttpCompletionOption.ResponseHeadersRead).Result; if (resp.StatusCode != HttpStatusCode.OK) HandleErrorResponse(resp).Wait(); B2FileDownloadResult info = new B2FileDownloadResult(); info.FileId = resp.Headers.GetValues("X-Bz-File-Id").First(); info.FileName = resp.Headers.GetValues("X-Bz-File-Name").First(); info.ContentSha1 = resp.Headers.GetValues("X-Bz-Content-Sha1").First(); Debug.Assert(resp.Content.Headers.ContentLength != null, "resp.Content.Headers.ContentLength != null"); info.ContentLength = resp.Content.Headers.ContentLength.Value; info.ContentType = resp.Content.Headers.ContentType.MediaType; info.FileInfo = new Dictionary<string, string>(); foreach (KeyValuePair<string, IEnumerable<string>> pair in resp.Headers) { if (!pair.Key.StartsWith("X-Bz-Info-")) continue; info.FileInfo[pair.Key.Substring("X-Bz-Info-".Length)] = pair.Value.First(); } B2DownloadResult result = new B2DownloadResult(); result.Info = info; result.Stream = await resp.Content.ReadAsStreamAsync(); return result; }
/// <summary> /// Calls b2_upload_file /// Needs an Upload Url /// /// https://www.backblaze.com/b2/docs/b2_upload_file.html /// </summary> public async Task<B2FileInfo> UploadFile(Uri uploadUri, string uploadToken, Stream inputStream, string sha1, string fileName, string contentType, Dictionary<string, string> fileInfo, NotifyProgress notifyDelegate) { // Pre-checks if (inputStream == null) throw new ArgumentNullException("Stream must be set"); if (string.IsNullOrEmpty(sha1) || sha1.Length != 40) throw new ArgumentException("SHA1 must be set or computed"); if (string.IsNullOrEmpty(fileName)) throw new ArgumentException("Filename must be set"); if (string.IsNullOrEmpty(contentType)) contentType = B2Constants.AutoContenType; // Prepare HttpRequestMessage msg = new HttpRequestMessage(HttpMethod.Post, uploadUri); msg.Headers.Authorization = new AuthenticationHeaderValue(uploadToken); msg.Headers.Add("X-Bz-File-Name", WebUtility.UrlEncode(fileName)); msg.Headers.Add("X-Bz-Content-Sha1", sha1); // Upload if (fileInfo != null) { foreach (KeyValuePair<string, string> info in fileInfo) msg.Headers.Add("X-Bz-Info-" + info.Key, WebUtility.UrlEncode(info.Value)); } msg.Content = new StreamContent(inputStream); msg.Content.Headers.ContentType = new MediaTypeHeaderValue(contentType); ProgressMessageHandler progressMessageHandler = new ProgressMessageHandler(new HttpClientHandler()); EventHandler<HttpProgressEventArgs> progress = null; if (notifyDelegate != null) { progress = (sender, args) => { notifyDelegate(args.TotalBytes ?? 0, args.TotalBytes ?? 0); }; progressMessageHandler.HttpSendProgress += progress; } try { using (HttpClient http = GetHttpClient(true, progressMessageHandler)) { HttpResponseMessage resp = await http.SendAsync(msg).ConfigureAwait(false); if (resp.StatusCode != HttpStatusCode.OK) await HandleErrorResponse(resp); return JsonConvert.DeserializeObject<B2FileInfo>(await resp.Content.ReadAsStringAsync().ConfigureAwait(false)); } } finally { if (progress != null) progressMessageHandler.HttpSendProgress -= progress; } }
private static HttpMessageInvoker CreateMessageInvoker(bool includeResponseEntity, bool addSendProgressHandler, bool addReceiveProgressHandler) { ShortCircuitMessageHandler innerHandler = new ShortCircuitMessageHandler(includeResponseEntity); ProgressMessageHandler progress = new ProgressMessageHandler(innerHandler); if (addSendProgressHandler) { progress.HttpSendProgress += new MockProgressEventHandler().Handler; } if (addReceiveProgressHandler) { progress.HttpReceiveProgress += new MockProgressEventHandler().Handler; } return new HttpMessageInvoker(progress); }
public async Task<OssObject> GetObject(GetObjectRequest getObjectRequest, Action<HttpProcessData> downloadProcessCallback = null, CancellationToken? cancellationToken = null) { OssObject result = null; HttpClientHandler hand = null; ProgressMessageHandler processMessageHander = null; HttpClient localHttpClient = null; OssHttpRequestMessage httpRequestMessage = null; HttpResponseMessage response = null; try { hand = new HttpClientHandler(); processMessageHander = new ProgressMessageHandler(hand); localHttpClient = new HttpClient(processMessageHander); localHttpClient.Timeout += new TimeSpan(2 * TimeSpan.TicksPerHour); httpRequestMessage = new OssHttpRequestMessage(getObjectRequest.BucketName, getObjectRequest.Key); getObjectRequest.ResponseHeaders.Populate(httpRequestMessage.Headers); getObjectRequest.Populate(httpRequestMessage.Headers); httpRequestMessage.Method = HttpMethod.Get; httpRequestMessage.Headers.Date = DateTime.UtcNow; OssRequestSigner.Sign(httpRequestMessage, networkCredential); if (downloadProcessCallback != null) { processMessageHander.HttpReceiveProgress += (sender, e) => { downloadProcessCallback(new HttpProcessData() { TotalBytes = e.TotalBytes, BytesTransferred = e.BytesTransferred, ProgressPercentage = e.ProgressPercentage }); ; }; } if (cancellationToken != null) response = await localHttpClient.SendAsync(httpRequestMessage, (CancellationToken)cancellationToken); else response = await localHttpClient.SendAsync(httpRequestMessage); if (response.IsSuccessStatusCode == false) { await ErrorResponseHandler.Handle(response); } var temp = DeserializerFactory.GetFactory().CreateGetObjectResultDeserializer(getObjectRequest); result = await temp.Deserialize(response); } catch (Exception ex) { throw ex; } finally { if (hand != null) hand.Dispose(); if (processMessageHander != null) processMessageHander.Dispose(); if (localHttpClient != null) localHttpClient.Dispose(); if (httpRequestMessage != null) httpRequestMessage.Dispose(); } return result; }
private void UploadFiles(string[] files) { ProgressMessageHandler progress = new ProgressMessageHandler(); progress.HttpSendProgress += new EventHandler<HttpProgressEventArgs>(HttpSendProgress); HttpRequestMessage message = new HttpRequestMessage(); MultipartFormDataContent content = new MultipartFormDataContent(); try { foreach (var file in files) { FileStream filestream = new FileStream(file, FileMode.Open); string fileName = System.IO.Path.GetFileName(file); content.Add(new StreamContent(filestream), "file", fileName); } message.Method = HttpMethod.Post; message.Content = content; message.RequestUri = new Uri("http://localhost:51884/api/uploading/"); ThreadSafeUpdateStatus(String.Format("Uploading {0} files", files.Count())); var client = HttpClientFactory.Create(progress); client.SendAsync(message).ContinueWith(task => { if (task.Result.IsSuccessStatusCode) { ThreadSafeUpdateStatus(String.Format("Uploaded {0} files", files.Count())); var response = task.Result.Content.ReadAsStringAsync(); dynamic json = JsonConvert.DeserializeObject<List<FileDesc>>(response.Result); foreach (var item in json) { var listitem = _files.FirstOrDefault(i => i.Contains(item.name)); Application.Current.Dispatcher.Invoke( DispatcherPriority.Normal, (Action)delegate() { _files.Remove(listitem); }); listitem += String.Format(" - successfully uploaded. Size: {0}", item.size); Application.Current.Dispatcher.Invoke( DispatcherPriority.Normal,(Action)delegate() { _files.Add(listitem); }); } } else { ThreadSafeUpdateStatus("Sorry there has been an error"); } }); } catch (Exception e) { //Handle exceptions - file not found, access denied, no internet connection, threading issues etc etc } }
public static void RegisterHttpClientProgressMessageHandler ( Action<HttpClient> onHttpClientSendReceiveProcessAction , Action < HttpClient , bool , HttpProgressEventArgs > onProgressProcessAction = null , bool reThrowException = false , Func<Exception, Exception, string, bool> onCaughtExceptionProcessFunc = null , Action<bool, Exception, Exception, string> onFinallyProcessAction = null ) { HttpClientHandler httpClientHandler = null; HttpClient httpClient = null; ProgressMessageHandler progressMessageHandler = null; EventHandler<HttpProgressEventArgs> httpSendProgress = null; EventHandler<HttpProgressEventArgs> httpReceiveProgress = null; var needProgress = false; try { if (onProgressProcessAction != null) { needProgress = true; httpClientHandler = new HttpClientHandler(); progressMessageHandler = new ProgressMessageHandler(httpClientHandler); httpSendProgress = new EventHandler<HttpProgressEventArgs> ( (sender, httpProgressEventArgs) => { onProgressProcessAction ( httpClient , true , httpProgressEventArgs ); } ); httpReceiveProgress = new EventHandler<HttpProgressEventArgs> ( (sender, httpProgressEventArgs) => { onProgressProcessAction ( httpClient , false , httpProgressEventArgs ); } ); progressMessageHandler.HttpSendProgress += httpSendProgress; progressMessageHandler.HttpReceiveProgress += httpReceiveProgress; } using ( httpClient = (needProgress ? new HttpClient(progressMessageHandler) : new HttpClient()) ) { TryCatchFinallyProcessHelper .TryProcessCatchFinally ( true , () => { onHttpClientSendReceiveProcessAction(httpClient); } , false , (exception, newException, message) => { if (onCaughtExceptionProcessFunc != null) { reThrowException = onCaughtExceptionProcessFunc ( exception , newException , message ); } if (reThrowException) { throw newException; } return false; } , (caughtException, Exception, newException, message) => { onFinallyProcessAction? .Invoke ( caughtException , Exception , newException , message ); } ); } } finally { if (progressMessageHandler != null) { progressMessageHandler.HttpSendProgress -= httpSendProgress; progressMessageHandler.HttpReceiveProgress -= httpReceiveProgress; progressMessageHandler.Dispose(); } if (httpClientHandler != null) { httpClientHandler.Dispose(); } } }
internal static ProgressStream CreateProgressStream( Stream innerStream = null, ProgressMessageHandler progressMessageHandler = null, HttpRequestMessage request = null, HttpResponseMessage response = null) { Stream iStream = innerStream ?? new Mock<Stream>().Object; ProgressMessageHandler pHandler = progressMessageHandler ?? new ProgressMessageHandler(); HttpRequestMessage req = request ?? new HttpRequestMessage(); HttpResponseMessage rsp = response ?? new HttpResponseMessage(); return new ProgressStream(iStream, pHandler, req, rsp); }
public async Task<PutObjectResult> PutObject(string bucketName, string key, Stream content, ObjectMetadata metadata, Action<HttpProcessData> uploadProcessCallback = null, CancellationToken? cancellationToken = null) { PutObjectResult result = null; HttpClientHandler hand = null; ProgressMessageHandler processMessageHander = null; HttpClient localHttpClient = null; OssHttpRequestMessage httpRequestMessage = null; HttpResponseMessage response = null; try { hand = new HttpClientHandler(); processMessageHander = new ProgressMessageHandler(hand); localHttpClient = new HttpClient(processMessageHander); localHttpClient.Timeout += new TimeSpan(2 * TimeSpan.TicksPerHour); httpRequestMessage = new OssHttpRequestMessage(bucketName, key); httpRequestMessage.Method = HttpMethod.Put; httpRequestMessage.Headers.Date = DateTime.UtcNow; httpRequestMessage.Content = new StreamContent(content); OssClientHelper.initialHttpRequestMessage(httpRequestMessage, metadata); OssRequestSigner.Sign(httpRequestMessage, networkCredential); if (uploadProcessCallback != null) { processMessageHander.HttpSendProgress += (sender, e) => { uploadProcessCallback(new HttpProcessData() { TotalBytes = e.TotalBytes, BytesTransferred = e.BytesTransferred, ProgressPercentage = e.ProgressPercentage }); }; } if(cancellationToken != null) response = await localHttpClient.SendAsync(httpRequestMessage, (CancellationToken)cancellationToken); else response = await localHttpClient.SendAsync(httpRequestMessage); if (response.IsSuccessStatusCode == false) { await ErrorResponseHandler.Handle(response); } var temp = DeserializerFactory.GetFactory().CreatePutObjectReusltDeserializer(); result = temp.Deserialize(response); //localHttpClient.Dispose(); } catch (Exception ex) { throw ex; } finally { if (hand != null) hand.Dispose(); if (processMessageHander != null) processMessageHander.Dispose(); if (localHttpClient != null) localHttpClient.Dispose(); if (httpRequestMessage != null) httpRequestMessage.Dispose(); if (response != null) response.Dispose(); } return result; }