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