public static async Task <string> UploadFileAsync(this HttpClient httpClient, string url,
IDictionary <string, string> formData,
IList <string> filePaths,
FileUploadCallback callback = null)
{
return(await UploadFileAsync(httpClient, url, formData, DefaultEncoding, filePaths, callback).ConfigureAwait(false));
}
public static async Task <string> UploadFileAsync(this HttpClient httpClient, string url,
IDictionary <string, string> formData,
FileUploadCallback callback = null,
params string[] filePaths)
{
return(await UploadFileAsync(httpClient, url, formData, filePaths, callback).ConfigureAwait(false));
}
private static async Task WriteFileAsync(Encoding encoding, string key, string filePath, Stream stream,
int i, FileUploadCallback callback)
{
const string headerTemplate =
"Content-Disposition: form-data; name=\"{0}\"; filename=\"{1}\"\r\nContent-Type: application/octet-stream\r\n\r\n";
string header = string.Format(headerTemplate, key, Path.GetFileName(filePath));
byte[] headerBytes = encoding.GetBytes(header);
await stream.WriteAsync(headerBytes, 0, headerBytes.Length).ConfigureAwait(false);
byte[] buffer = new byte[4096];
using (var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
var total = fileStream.Length;
int bytesRead;
while ((bytesRead = fileStream.Read(buffer, 0, buffer.Length)) != 0)
{
await stream.WriteAsync(buffer, 0, bytesRead).ConfigureAwait(false);
callback?.Invoke(i, total, fileStream.Position);
buffer = new byte[4096];
}
}
}
public static async Task <string> UploadFileAsync(this HttpClient httpClient, string url,
FileUploadCallback callback = null,
CancellationTokenSource cts = null,
params string[] filePaths)
{
return(await UploadFileAsync(httpClient, url, null, filePaths, callback, cts).ConfigureAwait(false));
}
public static async Task <string> UploadFileAsync(this HttpClient httpClient,
string url,
IDictionary <string, string> formData,
Encoding encoding,
IList <string> filePaths,
FileUploadCallback callback = null)
{
var headerData = httpClient?.DefaultRequestHeaders.ToDictionary(
k => k.Key, k => k.Value.LastOrDefault());
return(await UploadFileAsync(url, headerData, formData, encoding, filePaths, callback).ConfigureAwait(false));
}
public void SendFile(Client client, string path, Packet packet, FileUploadCallback sent = null, FileUploadCallback success = null, FileUploadCallback fail = null)
{
client.SendingPackets.Add(DownloadPacketCreator.AskDownload((int)new FileInfo(path).Length, "test", packet));
Tasks.Add(new DownloadTask()
{
MainClient = client,
FileStream = File.OpenRead(path),
Hash = "test",
Sent = sent,
Success = success,
Fail = fail
});
}
public static async Task <string> UploadFileAsync(this HttpClient httpClient,
string url,
IDictionary <string, string> formData,
Encoding encoding,
IList <string> filePaths,
FileUploadCallback callback = null,
CancellationTokenSource cts = null)
{
var headerData = httpClient?.DefaultRequestHeaders.ToDictionary(
k => k.Key, k => k.Value.LastOrDefault());
using (var client = new MultipartUploadClient())
{
return(await client.UploadFileAsync(url, headerData, formData, encoding, filePaths, callback, cts)
.ConfigureAwait(false));
}
}
public static async Task <string> UploadFileAsync(
string url,
IDictionary <string, string> headerData,
IDictionary <string, string> formData,
Encoding encoding,
IList <string> filePaths,
FileUploadCallback callback)
{
string boundary = $"---------------------------{DateTime.Now.Ticks:x}";
byte[] boundaryBytes = Encoding.ASCII.GetBytes($"\r\n--{boundary}\r\n");
byte[] endBytes = Encoding.ASCII.GetBytes($"\r\n--{boundary}--\r\n");
var request = (HttpWebRequest)WebRequest.Create(url);
request.SendChunked = true;
request.AllowWriteStreamBuffering = false;
request.ContentType = "multipart/form-data; boundary=" + boundary;
request.Method = "POST";
request.KeepAlive = true;
request.Credentials = CredentialCache.DefaultCredentials;
var keys = request.Headers.AllKeys;
if (headerData != null)
{
foreach (var kvp in headerData)
{
var key = kvp.Key;
var value = kvp.Value;
if (keys.Contains(key))
{
request.Headers[key] = value;
}
else
{
request.Headers.Add(key, value);
}
}
}
using (var stream = await request.GetRequestStreamAsync().ConfigureAwait(false))
{
//1.1 key/value
if (formData != null)
{
foreach (var key in formData.Keys)
{
await WriteBoundaryAsync(stream, boundaryBytes).ConfigureAwait(false);
await WriteRegularAsync(encoding, key, formData[key], stream).ConfigureAwait(false);
}
}
//1.2 file
for (int i = 0; i < filePaths.Count; i++)
{
var filePath = filePaths[i];
await WriteBoundaryAsync(stream, boundaryBytes).ConfigureAwait(false);
await WriteFileAsync(encoding, $"file{i}", filePath, stream, i, callback).ConfigureAwait(false);
}
//1.3 form end
await stream.WriteAsync(endBytes, 0, endBytes.Length).ConfigureAwait(false);
}
//2.WebResponse
try
{
using (var response = (HttpWebResponse)await request.GetResponseAsync().ConfigureAwait(false))
using (var responseStream = response.GetResponseStream())
{
if (responseStream == null)
{
return(null);
}
using (var sr = new StreamReader(responseStream))
return(await sr.ReadToEndAsync().ConfigureAwait(false));
}
}
catch (WebException e)
{
using (WebResponse response = e.Response)
{
var httpResponse = (HttpWebResponse)response;
if (httpResponse.StatusCode != HttpStatusCode.BadRequest)
{
throw;
}
using (var responseStream = httpResponse.GetResponseStream())
{
if (responseStream == null)
{
throw;
}
using (var sr = new StreamReader(responseStream))
{
var text = await sr.ReadToEndAsync();
throw new Exception("response: " + text);
}
}
}
}
}
public async Task <string> UploadFileAsync(
string url,
IDictionary <string, string> headerData,
IDictionary <string, string> formData,
Encoding encoding,
IList <string> filePaths,
FileUploadCallback callback,
CancellationTokenSource cts)
{
if (!File.Exists(ExecutablePath))
{
throw new FileNotFoundException("The executable client was not found in: " + ExecutablePath);
}
var sb = new StringBuilder();
sb.Append($"--uri {url} ");
foreach (var kvp in formData)
{
var key = kvp.Key;
var value = kvp.Value;
sb.Append($"--header {key}:{value} ");
}
foreach (var kvp in formData)
{
var key = kvp.Key;
var value = kvp.Value;
sb.Append($"--form {key}:{value} ");
}
foreach (var filePath in filePaths)
{
var fixedFilePath = filePath.Contains(" ")
? $"\"{filePath}\""
: filePath;
sb.Append($"--file {fixedFilePath} ");
}
string arguments = sb.ToString();
CancelPreviousTask();
_proc = new Process
{
EnableRaisingEvents = true,
StartInfo = new ProcessStartInfo
{
FileName = ExecutablePath,
Arguments = arguments,
CreateNoWindow = true,
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardError = true,
WindowStyle = ProcessWindowStyle.Hidden,
}
};
string errMsg = null;
bool isResultReady = false;
var resultSb = new StringBuilder();
_proc.OutputDataReceived += Proc_OutputDataReceived;
_proc.ErrorDataReceived += Proc_ErrorDataReceived;
_proc.Start();
_proc.BeginErrorReadLine();
_proc.BeginOutputReadLine();
try
{
await _proc.WaitForExitAsync(cts.Token);
}
catch (TaskCanceledException ex)
{
Console.WriteLine("Canceled task: " + ex.Message);
CancelPreviousTask();
throw;
}
if (errMsg != null)
{
throw new Exception(errMsg);
}
void Proc_OutputDataReceived(object obj, DataReceivedEventArgs args)
{
var uploadingFlag = "uploading: ";
if (args.Data?.StartsWith(uploadingFlag) == true)
{
var len = uploadingFlag.Length;
var data = args.Data.Substring(len);
var split = data.Split(';')
.Select(k => k.Split('=')[1])
.ToArray();
var current = long.Parse(split[0]);
var total = long.Parse(split[1]);
var floatPercent = double.Parse(split[2].TrimEnd('%', ' ')) / 100;
callback?.Invoke(total, current);
}
else if (args.Data == "finished")
{
isResultReady = true;
}
else if (isResultReady)
{
resultSb.AppendLine(args.Data);
}
Console.WriteLine(args.Data);
}
void Proc_ErrorDataReceived(object obj, DataReceivedEventArgs args)
{
if (errMsg == null)
{
var errorFlag = "error: ";
var responseFlag = "response: ";
if (args.Data?.StartsWith(errorFlag) == true)
{
var data = args.Data.Substring(errorFlag.Length);
if (data?.StartsWith(responseFlag) == true)
{
var data2 = data.Substring(responseFlag.Length);
var jsonc = JsonConvert.DeserializeObject <ResponseDataBase <object> >(data2);
errMsg = jsonc.Message;
}
else
{
errMsg = data;
}
}
}
}
return(resultSb.ToString());
}
