private void beginRequestOutput()
{
try
{
using (Stream requestStream = request.GetRequestStream())
{
reportForwardProgress();
requestBody.Position = 0;
byte[] buff = new byte[buffer_size];
int read;
int totalRead = 0;
while ((read = requestBody.Read(buff, 0, buffer_size)) > 0)
{
reportForwardProgress();
requestStream.Write(buff, 0, read);
requestStream.Flush();
totalRead += read;
UploadProgress?.Invoke(this, totalRead, request.ContentLength);
}
}
beginResponse();
}
catch (Exception e)
{
Complete(e);
}
}
private void UploadData(byte[] data)
{
SerialPort.ReadTimeout = 2000;
try
{
Message?.Invoke(this, "Starting upload");
for (var i = 0; i < Math.Ceiling((double)data.Length / 4096d); i++)
{
SerialPort.Write(data, i * 4096, Math.Min(4096, data.Length - i * 4096));
SerialPort.BaseStream.Flush();
int d = 0;
try
{
d = SerialPort.ReadByte();
}
catch { }
if (d != 5)
{
Message?.Invoke(this, "Upload error");
return;
}
UploadProgress?.Invoke(this, (double)i / Math.Ceiling((double)data.Length / 4096d));
}
}
catch
{
Message?.Invoke(this, "Upload error");
return;
}
Message?.Invoke(this, "Upload successfull");
}
/// <summary>
/// upload blob; will continue from where it left off if a previous upload was already in progress
/// </summary>
/// <param name="uploadUrl">blob upload url</param>
/// <param name="blobStream">blob stream to be uploaded; must allow Length, ReadAsync operations. Seek operation must be available for resumed uploads.</param>
/// <param name="state"></param>
/// <param name="cancellationToken">cancellation token to stop the asynchronous action</param>
/// <returns>Returns true if upload is complete; false otherwise</returns>
public async Task <bool> Upload(Uri uploadUrl, Stream blobStream, object state, CancellationToken cancellationToken = default)
{
var headResult = await _tusCore.Head(uploadUrl, cancellationToken);
long offset = long.Parse(headResult["Upload-Offset"]);
long length = blobStream.Length;
var tusUploadFileContext = new TusUploadContext(length, offset, uploadUrl, state);
while (!cancellationToken.IsCancellationRequested)
{
if (offset == length)
{
UploadFinish?.Invoke(this, tusUploadFileContext);
return(true);
}
if (blobStream.Position != offset)
{
blobStream.Seek(offset, SeekOrigin.Begin);
}
int chunkSize = _tusClientOptions.GetChunkUploadSize(this, tusUploadFileContext);
chunkSize = (int)Math.Min(chunkSize, length - offset);
byte[] buffer = new byte[chunkSize];
var readCount = await blobStream.ReadAsync(buffer, 0, chunkSize);
var uploadResult = await _tusCore.Patch(uploadUrl, buffer, offset, cancellationToken);
offset = long.Parse(uploadResult["Upload-Offset"]);
tusUploadFileContext.UploadedSize = offset;
UploadProgress?.Invoke(this, tusUploadFileContext);
}
return(false);
}
public void DoSomeUpload()
{
if (UploadProgress != null)
{
UploadEventArgs e = new UploadEventArgs();
e.BytesSoFar = 123f;
e.TotalToUpload = 100000f;
UploadProgress.Invoke(this, e);
}
}
public void UploadFile(Stream bodyStream, string relativePath, int bufferSize = RECOMMENDED_BUFFER_SIZE)
{
//var request = NewRequest(WebRequestMethods.Ftp.UploadFile);
var request = NewRequest(relativePath, FtpVerb.STOR);
request.ContentLength = bodyStream.Length;
using (var stream = request.GetRequestStream())
{
bodyStream.ScanAndWriteTo(stream, bufferSize, (writeTarget, buffer, totalWrittenLength) =>
{
UploadProgress?.Invoke(this, totalWrittenLength, bodyStream.Length);
});
}
}
public void Upload(string ComPort, byte[] data, int uploadBaudrate = 115200)
{
UploadProgress?.Invoke(this, 0);
this.SerialPort = new SerialPort(ComPort);
try
{
try
{
this.SerialPort.Open();
}
catch (Exception ex)
{
Message?.Invoke(this, "Unable to open Serial Port " + ComPort);
return;
}
NextionInfos model = null;
try
{
model = DetectNextion();
}
catch
{
}
if (model != null)
{
Message?.Invoke(this, "Nextion found " + model.Model);
SwitchToUploadMode(data, uploadBaudrate);
UploadData(data);
}
else
{
Message?.Invoke(this, "Nextion not found");
}
}
finally
{
try
{
SerialPort.Close();
}
catch
{
}
}
}
private UploadStatus UploadData(byte[] data)
{
SerialPort.ReadTimeout = 2000;
SerialPort.WriteTimeout = 5000;
try
{
if (CancelRequested)
{
return(UploadStatus.Cancel);
}
Message?.Invoke(this, "Starting upload");
for (var i = 0; i < Math.Ceiling((double)data.Length / 4096d); i++)
{
if (CancelRequested)
{
return(UploadStatus.Cancel);
}
SerialPort.Write(data, i * 4096, Math.Min(4096, data.Length - i * 4096));
SerialPort.BaseStream.Flush();
int d = 0;
try
{
d = SerialPort.ReadByte();
}
catch { }
if (d != 5)
{
Message?.Invoke(this, "Upload error");
return(UploadStatus.Error);
}
UploadProgress?.Invoke(this, (double)i / Math.Ceiling((double)data.Length / 4096d));
}
}
catch
{
Message?.Invoke(this, "Upload error");
return(UploadStatus.Error);
}
Message?.Invoke(this, "Upload finished");
return(UploadStatus.Ok);
}
private void perform()
{
Aborted = false;
abortRequest();
PrePerform();
try
{
reportForwardProgress();
threadPool.QueueWorkItem(checkTimeoutLoop);
requestBody = new MemoryStream();
switch (Method)
{
case HttpMethod.GET:
Debug.Assert(Files.Count == 0);
StringBuilder requestParameters = new StringBuilder();
foreach (var p in Parameters)
{
requestParameters.Append($@"{p.Key}={p.Value}&");
}
request = CreateWebRequest(requestParameters.ToString().TrimEnd('&'));
request.Method = @"GET";
break;
case HttpMethod.POST:
request = CreateWebRequest();
request.Method = @"POST";
if (Parameters.Count + Files.Count == 0)
{
rawContent?.WriteTo(requestBody);
request.ContentType = ContentType;
requestBody.Flush();
break;
}
const string boundary = @"-----------------------------28947758029299";
request.ContentType = $@"multipart/form-data; boundary={boundary}";
foreach (KeyValuePair <string, string> p in Parameters)
{
requestBody.WriteLineExplicit($@"--{boundary}");
requestBody.WriteLineExplicit($@"Content-Disposition: form-data; name=""{p.Key}""");
requestBody.WriteLineExplicit();
requestBody.WriteLineExplicit(p.Value);
}
foreach (KeyValuePair <string, byte[]> p in Files)
{
requestBody.WriteLineExplicit($@"--{boundary}");
requestBody.WriteLineExplicit($@"Content-Disposition: form-data; name=""{p.Key}""; filename=""{p.Key}""");
requestBody.WriteLineExplicit(@"Content-Type: application/octet-stream");
requestBody.WriteLineExplicit();
requestBody.Write(p.Value, 0, p.Value.Length);
requestBody.WriteLineExplicit();
}
requestBody.WriteLineExplicit($@"--{boundary}--");
requestBody.Flush();
break;
}
request.UserAgent = @"osu!";
request.KeepAlive = useFallbackPath != true;
request.Host = Url.Split('/')[2];
request.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
request.ReadWriteTimeout = System.Threading.Timeout.Infinite;
request.Timeout = Timeout; //todo: make sure this works correctly for long-lasting transfers.
foreach (KeyValuePair <string, string> h in Headers)
{
request.Headers.Add(h.Key, h.Value);
}
ResponseStream = CreateOutputStream();
switch (Method)
{
case HttpMethod.GET:
//GETs are easy
beginResponse();
break;
case HttpMethod.POST:
request.ContentLength = requestBody.Length;
UploadProgress?.Invoke(this, 0, request.ContentLength);
reportForwardProgress();
beginRequestOutput();
break;
}
}
catch (Exception e)
{
Complete(e);
}
}
private void MessageHandler_HttpSendProgress(object sender, HttpProgressEventArgs e) => UploadProgress?.Invoke(e.ProgressPercentage);
protected virtual void perform()
{
Aborted = false;
abortRequest();
try
{
reportForwardProgress();
threadPool.QueueWorkItem(checkTimeoutLoop);
Request = CreateWebRequest();
ResponseStream = CreateOutputStream();
Request.UserAgent = @"osu!";
Request.KeepAlive = useFallbackPath != true;
Request.Host = Url.Split('/')[2];
Request.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
Request.ReadWriteTimeout = System.Threading.Timeout.Infinite;
Request.Timeout = System.Threading.Timeout.Infinite;
foreach (KeyValuePair <string, string> h in Headers)
{
Request.Headers.Add(h.Key, h.Value);
}
if (Parameters.Count + Files.Count > 0)
{
const string boundary = @"-----------------------------28947758029299";
Request.ContentType = $@"multipart/form-data; boundary={boundary}";
foreach (KeyValuePair <string, string> p in Parameters)
{
requestBody.WriteLineExplicit($@"--{boundary}");
requestBody.WriteLineExplicit($@"Content-Disposition: form-data; name=""{p.Key}""");
requestBody.WriteLineExplicit();
requestBody.WriteLineExplicit(p.Value);
}
foreach (KeyValuePair <string, byte[]> p in Files)
{
requestBody.WriteLineExplicit($@"--{boundary}");
requestBody.WriteLineExplicit($@"Content-Disposition: form-data; name=""{p.Key}""; filename=""{p.Key}""");
requestBody.WriteLineExplicit(@"Content-Type: application/octet-stream");
requestBody.WriteLineExplicit();
requestBody.Write(p.Value, 0, p.Value.Length);
requestBody.WriteLineExplicit();
}
requestBody.WriteLineExplicit($@"--{boundary}--");
requestBody.Flush();
}
if (requestBody.Length != 0)
{
Request.Method = @"POST";
Request.ContentLength = requestBody.Length;
UploadProgress?.Invoke(this, 0, Request.ContentLength);
reportForwardProgress();
beginRequestOutput();
}
else
{
//GETs are easy
beginResponse();
}
}
catch (Exception e)
{
Complete(e);
}
}
private void internalPerform()
{
using (abortToken = new CancellationTokenSource())
using (timeoutToken = new CancellationTokenSource())
using (var linkedToken = CancellationTokenSource.CreateLinkedTokenSource(abortToken.Token, timeoutToken.Token))
{
try
{
PrePerform();
HttpRequestMessage request;
switch (Method)
{
default:
throw new InvalidOperationException($"HTTP method {Method} is currently not supported");
case HttpMethod.GET:
if (files.Count > 0)
{
throw new InvalidOperationException($"Cannot use {nameof(AddFile)} in a GET request. Please set the {nameof(Method)} to POST.");
}
StringBuilder requestParameters = new StringBuilder();
foreach (var p in parameters)
{
requestParameters.Append($@"{p.Key}={p.Value}&");
}
string requestString = requestParameters.ToString().TrimEnd('&');
request = new HttpRequestMessage(System.Net.Http.HttpMethod.Get, string.IsNullOrEmpty(requestString) ? Url : $"{Url}?{requestString}");
break;
case HttpMethod.POST:
request = new HttpRequestMessage(System.Net.Http.HttpMethod.Post, Url);
Stream postContent;
if (rawContent != null)
{
if (parameters.Count > 0)
{
throw new InvalidOperationException($"Cannot use {nameof(AddRaw)} in conjunction with {nameof(AddParameter)}");
}
if (files.Count > 0)
{
throw new InvalidOperationException($"Cannot use {nameof(AddRaw)} in conjunction with {nameof(AddFile)}");
}
postContent = new MemoryStream();
rawContent.Position = 0;
rawContent.CopyTo(postContent);
postContent.Position = 0;
}
else
{
if (!string.IsNullOrEmpty(ContentType) && ContentType != form_content_type)
{
throw new InvalidOperationException($"Cannot use custom {nameof(ContentType)} in a POST request.");
}
ContentType = form_content_type;
var formData = new MultipartFormDataContent(form_boundary);
foreach (var p in parameters)
{
formData.Add(new StringContent(p.Value), p.Key);
}
foreach (var p in files)
{
var byteContent = new ByteArrayContent(p.Value);
byteContent.Headers.Add("Content-Type", "application/octet-stream");
formData.Add(byteContent, p.Key, p.Key);
}
postContent = formData.ReadAsStreamAsync().Result;
}
requestStream = new LengthTrackingStream(postContent);
requestStream.BytesRead.ValueChanged += v =>
{
reportForwardProgress();
UploadProgress?.Invoke(v, contentLength);
};
request.Content = new StreamContent(requestStream);
if (!string.IsNullOrEmpty(ContentType))
{
request.Content.Headers.ContentType = MediaTypeHeaderValue.Parse(ContentType);
}
break;
}
if (!string.IsNullOrEmpty(Accept))
{
request.Headers.Accept.TryParseAdd(Accept);
}
foreach (var kvp in headers)
{
request.Headers.Add(kvp.Key, kvp.Value);
}
reportForwardProgress();
using (request)
response = client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, linkedToken.Token).Result;
ResponseStream = CreateOutputStream();
switch (Method)
{
case HttpMethod.GET:
//GETs are easy
beginResponse(linkedToken.Token);
break;
case HttpMethod.POST:
reportForwardProgress();
UploadProgress?.Invoke(0, contentLength);
beginResponse(linkedToken.Token);
break;
}
}
catch (Exception) when(timeoutToken.IsCancellationRequested)
{
Complete(new WebException($"Request to {Url} timed out after {timeSinceLastAction / 1000} seconds idle (read {responseBytesRead} bytes).", WebExceptionStatus.Timeout));
}
catch (Exception) when(abortToken.IsCancellationRequested)
{
Complete(new WebException($"Request to {Url} aborted by user.", WebExceptionStatus.RequestCanceled));
}
catch (Exception e)
{
Complete(e);
throw;
}
}
}
void DoUploadProgress(string title, long sent, long total)
{
UploadProgress?.Invoke(this, new UploadProgressEventArgs(title, sent, total));
}
/// <summary>
/// Main entry point for uploading data to Cycles.
/// </summary>
protected bool UploadData()
{
if (CancelRender)
{
return(false);
}
Database.CalculateClippingObjects();
UploadProgress?.Invoke(this, new UploadProgressEventArgs(0.1f, "Start data upload"));
if (CancelRender)
{
return(false);
}
// linear workflow & gamma changes
Database.UploadGammaChanges();
UploadProgress?.Invoke(this, new UploadProgressEventArgs(0.2f, "Linear workflow (gamma changes) uploaded"));
if (CancelRender)
{
return(false);
}
// environment changes
Database.UploadEnvironmentChanges();
UploadProgress?.Invoke(this, new UploadProgressEventArgs(0.3f, "Environments uploaded"));
if (CancelRender)
{
return(false);
}
// transforms on objects, no geometry changes
Database.UploadDynamicObjectTransforms();
UploadProgress?.Invoke(this, new UploadProgressEventArgs(0.4f, "Dynamic object transforms uploaded"));
if (CancelRender)
{
return(false);
}
// viewport changes
Database.UploadCameraChanges();
UploadProgress?.Invoke(this, new UploadProgressEventArgs(0.5f, "Viewport uploaded"));
if (CancelRender)
{
return(false);
}
// new shaders we've got
Database.UploadShaderChanges();
UploadProgress?.Invoke(this, new UploadProgressEventArgs(0.6f, "Shaders uploaded"));
if (CancelRender)
{
return(false);
}
// light changes
Database.UploadLightChanges();
UploadProgress?.Invoke(this, new UploadProgressEventArgs(0.7f, "Lights uploaded"));
if (CancelRender)
{
return(false);
}
// mesh changes (new ones, updated ones)
Database.UploadMeshChanges();
UploadProgress?.Invoke(this, new UploadProgressEventArgs(0.8f, "Mesh data uploaded"));
if (CancelRender)
{
return(false);
}
// shader changes on objects (replacement)
Database.UploadObjectShaderChanges();
UploadProgress?.Invoke(this, new UploadProgressEventArgs(0.9f, "Shader assignments uploaded"));
if (CancelRender)
{
return(false);
}
// object changes (new ones, deleted ones)
Database.UploadObjectChanges();
UploadProgress?.Invoke(this, new UploadProgressEventArgs(1.0f, "Object changes uploaded"));
if (CancelRender)
{
return(false);
}
// done, now clear out our change queue stuff so we're ready for the next time around :)
Database.ResetChangeQueue();
if (CancelRender)
{
return(false);
}
return(true);
}
public void Upload(string ComPort, byte[] data, int uploadBaudrate = 115200, bool reset = false)
{
UploadProgress?.Invoke(this, 0);
this.SerialPort = new SerialPort(ComPort);
UploadStatus res = UploadStatus.Ok;
try
{
try
{
this.SerialPort.Open();
}
catch (Exception ex)
{
Message?.Invoke(this, "Unable to open Serial Port " + ComPort);
return;
}
NextionInfos model = null;
try
{
model = DetectNextion();
}
catch
{
}
if (model != null)
{
var firmwareVersion = int.Parse(model.FirmwareVersion);
Message?.Invoke(this, "Nextion found " + model.Model + " (Firmware version : " + model.FirmwareVersion + ")");
if (reset)
{
Message?.Invoke(this, "Resetting nextion");
SendInstruction(SerialPort, "rest");
Message?.Invoke(this, "Waiting 4 seconds ...");
for (int i = 0; i < 8; i++)
{
if (CancelRequested)
{
return;
}
Thread.Sleep(500);
}
SerialPort.ReadExisting();
}
if (firmwareVersion < 130 && uploadBaudrate > 115200)
{
Message?.Invoke(this, "Nextion firmware does not supports high speed upload, forcing 115200bauds");
SwitchToUploadMode(data, 115200);
}
else if (model.Model[6] == 'T' && uploadBaudrate > 115200)
{
Message?.Invoke(this, "Basic model does not supports high speed upload, forcing 115200bauds");
SwitchToUploadMode(data, 115200);
}
else
{
SwitchToUploadMode(data, uploadBaudrate);
}
res = UploadData(data);
}
else
{
if (!CancelRequested)
{
Message?.Invoke(this, "Nextion not found");
}
}
}
finally
{
try
{
if (CancelRequested)
{
Message?.Invoke(this, "Upload canceled");
}
SerialPort.Close();
Message?.Invoke(this, "Resetting arduino micro if required");
ResetMicro(ComPort);
if (res == UploadStatus.Ok)
{
Message?.Invoke(this, "Upload finished successfully.");
}
}
catch
{
}
}
}
/// <summary>
/// Uploads a file
/// </summary>
/// <param name="filename">The filename we want to upload</param>
/// <param name="MD5Checksum">The MD5 checksum of a file</param>
/// <returns>An Image object that describes the image we uploaded</returns>
public async Task UploadImageAsync(string filename, string MD5Checksum, CancellationToken token)
{
const string url = "https://upload.smugmug.com/";
try
{
var file = new FileInfo(filename);
var myWebRequest = (HttpWebRequest)WebRequest.Create(url);
myWebRequest.Method = WebRequestMethods.Http.Post;
myWebRequest.ContentLength = file.Length;
myWebRequest.UserAgent = "KHainePhotography PhotoStudioManager v1.0";
switch (file.Extension.ToLower())
{
case "mp4":
myWebRequest.ContentType = "video/mp4";
break;
case "jpg":
myWebRequest.ContentType = "image/jpeg";
break;
default:
myWebRequest.ContentType = "binary/octet-stream";
break;
}
// Add the authorization header
myWebRequest.Headers.Add("Authorization", oAuthUtility.GetAuthorizationHeader(Album.Token, myWebRequest.RequestUri.AbsoluteUri));
myWebRequest.Headers.Add("Content-MD5", MD5Checksum);
myWebRequest.Headers.Add("X-Smug-ResponseType", "JSON");
myWebRequest.Headers.Add("X-Smug-Version", "v2");
myWebRequest.Headers.Add("X-Smug-AlbumUri", Album.Uri);
myWebRequest.Headers.Add("X-Smug-FileName", file.Name);
myWebRequest.Headers.Add("X-Smug-Title", Path.GetFileNameWithoutExtension(file.FullName));
myWebRequest.Headers.Add("X-Smug-Caption", Path.GetFileNameWithoutExtension(file.FullName));
myWebRequest.Headers.Add("X-Smug-Latitude", "53.457920");
myWebRequest.Headers.Add("X-Smug-Longitude", "-1.464252");
myWebRequest.Headers.Add("X-Smug-Altitude", "86");
myWebRequest.Headers.Add("X-Smug-Pretty", "true");
//we start reading from the file...
//we have some elements to set
//- request time out (compute this for 10 kb/sec speed)
//- the chunk size to use when uploading (how much data to report after)
UploadStarted?.Invoke(this, new UploadEventArgs()
{
FileName = file.FullName, PercentComplete = 0
});
int timeOut = ((int)file.Length / 1024) * 1000;
myWebRequest.Timeout = timeOut;
myWebRequest.ReadWriteTimeout = timeOut;
myWebRequest.AllowWriteStreamBuffering = true;
long howMuchRead = 0;
byte[] buffer = new byte[chunkSize];
int readSoFar = 0;
using (FileStream sr = new FileStream(file.FullName, FileMode.Open, FileAccess.Read))
{
using (var stream = await myWebRequest.GetRequestStreamAsync())
{
while (howMuchRead < file.Length)
{
//we try to read a chunk from the file
readSoFar = sr.Read(buffer, 0, chunkSize);
howMuchRead += readSoFar;
//we now write those files to the web.
await stream.WriteAsync(buffer, 0, readSoFar, token);
UploadProgress?.Invoke(this, new UploadEventArgs()
{
FileName = file.FullName, PercentComplete = (float)howMuchRead / (float)file.Length
});
}
}
}
var resp = await myWebRequest.GetResponseAsync();
string rez = string.Empty;
using (StreamReader ns = new StreamReader(resp.GetResponseStream()))
{
rez = await ns.ReadToEndAsync();
}
UploadCompleted?.Invoke(this, new UploadEventArgs()
{
FileName = file.FullName, PercentComplete = (float)howMuchRead / (float)file.Length
});
//we deserialize the image
var response = JsonConvert.DeserializeObject <UploadReponse>(System.Uri.UnescapeDataString(rez));
if (response.stat != "ok")
{
throw new ApplicationException(response.stat);
}
}
catch (Exception e)
{
Debug.Fail(e.Message);
throw;
}
}
private HttpWebResponse GetPureResponse(
string method, string enctype, string url,
Dictionary <string, object> updata,
Dictionary <string, object> upfiles)
{
if (!Ready(method, enctype, url, updata, upfiles))
{
throw new WebException("Instance is not ready to request.");
}
method = method.ToUpper();
enctype = enctype.ToLower();
if (updata is null)
{
updata = new Dictionary <string, object>();
}
if (upfiles is null)
{
upfiles = new Dictionary <string, object>();
}
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
var encoding = Encoding.GetEncoding(StateContainer.Encoding);
Stream bodyStream = null;
switch (enctype)
{
default:
case MimeMap.APPLICATION_X_WWW_FORM_URLENCODED:
var query = new List <string>();
foreach (var data in updata.Where(x => x.Value != null))
{
var values = NormalizeStringValues(data.Value);
query.AddRange(values.Select(value => $"{data.Key}={WebUtility.UrlEncode(value)}"));
}
var queryString = query.Join("&");
if (new[] { HttpVerb.GET, HttpVerb.DELETE }.Contains(method))
{
if (!url.Contains("?"))
{
url = $"{url}?{queryString}";
}
else
{
url = $"{url}&{queryString}";
}
}
else if (new[] { HttpVerb.POST, HttpVerb.PUT }.Contains(method))
{
bodyStream = new MemoryStream(queryString.Bytes(encoding));
}
break;
case MimeMap.MULTIPART_FORM_DATA:
var formData = new HttpFormData(encoding);
foreach (var data in updata.Where(x => x.Value != null))
{
var values = NormalizeStringValues(data.Value);
foreach (var value in values)
{
formData.AddData(data.Key, value.Bytes(encoding));
}
}
foreach (var file in upfiles)
{
var values = NormalizeStringValues(file.Value);
foreach (var value in values)
{
formData.AddFile(file.Key, Path.GetFileName(value), new FileStream(value, FileMode.Open, FileAccess.Read));
}
}
bodyStream = formData.GetStream();
enctype = formData.ContentType;
break;
case MimeMap.APPLICATION_JSON:
bodyStream = new MemoryStream(JsonConvert.SerializeObject(updata).Bytes(encoding));
break;
}
var request = (HttpWebRequest)WebRequest.Create(new Uri(url));
{
StateContainer.Headers.Then(headers =>
{
if (!(headers is null))
{
foreach (var header in StateContainer.Headers)
{
request.Headers.Add(header.Key, header.Value);
}
}
});
request.UserAgent = StateContainer.UserAgent;
request.Method = method;
request.Timeout = -1;
request.UseDefaultCredentials = StateContainer.SystemLogin;
if (StateContainer.UseProxy)
{
if (!string.IsNullOrEmpty(StateContainer.ProxyAddress))
{
request.Proxy = new WebProxy
{
Address = new Uri(StateContainer.ProxyAddress),
Credentials = new NetworkCredential
{
UserName = StateContainer.ProxyUsername,
Password = StateContainer.ProxyPassword,
}
};
}
}
request.CookieContainer = StateContainer.Cookies;
}
if (method == HttpVerb.POST)
{
if (!request.Headers.AllKeys.Any(x => x == "Content-Type"))
{
request.ContentType = enctype;
}
request.ContentLength = bodyStream.Length;
using (var stream = request.GetRequestStream())
{
bodyStream.ScanAndWriteTo(stream, RECOMMENDED_BUFFER_SIZE, (writeTarget, buffer, totalWrittenLength) =>
{
UploadProgress?.Invoke(this, url, totalWrittenLength, bodyStream.Length);
});
}
}
HttpWebResponse response = null;
try
{
response = request.GetResponse() as HttpWebResponse;
}
catch (WebException ex)
{
response = ex.Response as HttpWebResponse;
if (response is null)
{
throw;
}
}
return(response);
}
