public async Task PublishZipDeploy(Site functionApp, Func <Task <Stream> > zipFileFactory)
{
await RetryHelper.Retry(async() =>
{
using (var handler = new ProgressMessageHandler(new HttpClientHandler()))
using (var client = GetRemoteZipClient(new Uri($"https://{functionApp.ScmUri}"), handler))
using (var request = new HttpRequestMessage(HttpMethod.Post, new Uri("api/zipdeploy", UriKind.Relative)))
{
request.Headers.IfMatch.Add(EntityTagHeaderValue.Any);
ColoredConsole.WriteLine("Creating archive for current directory...");
(var content, var length) = CreateStreamContentZip(await zipFileFactory());
request.Content = content;
HttpResponseMessage response = null;
using (var pb = new SimpleProgressBar($"Uploading {Utilities.BytesToHumanReadable(length)}"))
{
handler.HttpSendProgress += (s, e) => pb.Report(e.ProgressPercentage);
response = await client.SendAsync(request);
}
if (response == null || !response.IsSuccessStatusCode)
{
throw new CliException($"Error uploading archive ({response.StatusCode}).");
}
ColoredConsole.WriteLine("Upload completed successfully.");
}
}, 2);
}
/// <summary>
/// 打开选定的文件
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void OpenFile_PreviewMouseLeftButtonUpAsync(object sender, System.Windows.Input.MouseButtonEventArgs e)
{
e.Handled = true;
TextBlock curTextBlock = sender as TextBlock;
Lib.MemberFile SelectFile = curTextBlock.DataContext as Lib.MemberFile;
if (SelectFile == null)
{
AppFuns.ShowMessage("未读到选取文件信息！", Caption: "错误", isErr: true);
return;
}
ProgressMessageHandler progress = new ProgressMessageHandler();
progress.HttpReceiveProgress += (object sender, HttpProgressEventArgs e) =>
{
SelectFile.DownIntProgress = e.ProgressPercentage;
};
string theDownFileName = await DataMemberFileRepository.DownloadFile(SelectFile, false, progress);
if (theDownFileName != null)
{
SelectFile.DownIntProgress = 100;
FileOperation.UseDefaultAppOpenFile(theDownFileName);
}
else
{
AppFuns.ShowMessage("文件下载失败，可能该文件已被删除！", Caption: "警告");
}
curTextBlock.IsEnabled = true;
}
/// <summary>
/// Upload file from target path asynchronous
/// </summary>
/// <param name="url">URL for upload</param>
/// <param name="sourceFileName">Target file name for upload</param>
/// <param name="progress">Function for display progress upload</param>
/// <returns>True if upload complete successful</returns>
internal static async Task <bool> UploadFileAsync(string url, string sourceFileName, IProgress <double> progress = null)
{
bool success = false;
ProgressMessageHandler progressHandler = new ProgressMessageHandler();
HttpClient client = HttpClientFactory.Create(progressHandler);
try
{
using (StreamContent streamContent = new StreamContent(new FileStream(sourceFileName, FileMode.Open, FileAccess.Read)))
{
progressHandler.HttpSendProgress += (send, value) => progress?.Report(value.ProgressPercentage);
HttpResponseMessage response = await client.PutAsync(url, streamContent);
if (response.StatusCode == System.Net.HttpStatusCode.Created)
{
success = true;
}
}
}
catch (Exception)
{
return(success);
}
return(success);
}
public HttpNetwork(string useragent = "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.116")
{
_httpClientHandler = new HttpClientHandler {
ClientCertificateOptions = ClientCertificateOption.Automatic,
AllowAutoRedirect = true,
MaxAutomaticRedirections = 3,
UseCookies = true,
CookieContainer = new CookieContainer(),
Credentials = CredentialCache.DefaultCredentials,
UseDefaultCredentials = true
};
ProgressMessageHandler = new ProgressMessageHandler();
_httpClient = HttpClientFactory.Create(_httpClientHandler, ProgressMessageHandler);
_httpClient.DefaultRequestHeaders.UserAgent.ParseAdd(useragent);
_httpClient.Timeout = TimeSpan.FromMinutes(1);
_httpClient.DefaultRequestHeaders.Accept.Clear();
_httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("*/*"));
_httpClient.DefaultRequestHeaders.ExpectContinue = false;
RecivedData = string.Empty;
RecivedHttpCode = HttpStatusCode.Forbidden;
RecivedUri = new Uri("http://localhost/");
}
private static async Task UploadPackage(PushOptions options, PackageHelper packageHelper)
{
try
{
// HttpClient will use this event handler to give us
// Reporting on how its progress the file upload
var processMsgHandler = new ProgressMessageHandler(new HttpClientHandler());
processMsgHandler.HttpSendProgress += (sender, e) =>
{
// Could try to reimplement progressbar - but that library did not work in GH Actions :(
var percent = e.ProgressPercentage;
};
var keyParts = packageHelper.SplitKey(options.ApiKey);
var packageFileName = Path.GetFileName(options.Package);
Console.WriteLine(Resources.Push_Uploading, packageFileName);
var url = "/Umbraco/Api/ProjectUpload/UpdatePackage";
using (var client = packageHelper.GetClientBase(url, keyParts.Token, keyParts.MemberId, keyParts.ProjectId))
{
MultipartFormDataContent form = new MultipartFormDataContent();
var fileInfo = new FileInfo(options.Package);
var content = new StreamContent(fileInfo.OpenRead());
content.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "file",
FileName = fileInfo.Name
};
form.Add(content);
form.Add(new StringContent(ParsePublishFlag(options.Publish)), "isCurrent");
form.Add(new StringContent(options.DotNetVersion), "dotNetVersion");
form.Add(new StringContent("package"), "fileType");
form.Add(GetVersionCompatibility(options.WorksWith), "umbracoVersions");
var httpResponse = await client.PostAsync(url, form);
if (httpResponse.StatusCode == HttpStatusCode.Unauthorized)
{
packageHelper.WriteError(Resources.Push_ApiKeyInvalid);
Environment.Exit(5); // ERROR_ACCESS_DENIED
}
else if (httpResponse.IsSuccessStatusCode)
{
Console.WriteLine(Resources.Push_Complete, packageFileName);
// Response is not reported (at the moment)
// var apiReponse = await httpResponse.Content.ReadAsStringAsync();
// Console.WriteLine(apiReponse);
}
}
}
catch (HttpRequestException ex)
{
// Could get network error or our.umb down
Console.WriteLine(Resources.Error, ex);
throw;
}
}
public Networker(string useragent)
{
_cookies = new CookieContainer();
_handler = new HttpClientHandler {
ClientCertificateOptions = ClientCertificateOption.Automatic,
AllowAutoRedirect = true,
MaxAutomaticRedirections = 3,
UseCookies = true,
CookieContainer = _cookies,
Credentials = CredentialCache.DefaultCredentials,
UseDefaultCredentials = true
};
ProgressHandler = new ProgressMessageHandler();
ProgressHandler.HttpSendProgress += SendProgress;
ProgressHandler.HttpReceiveProgress += RecvProgress;
_client = HttpClientFactory.Create(_handler, ProgressHandler);
_client.DefaultRequestHeaders.UserAgent.ParseAdd(useragent);
_client.Timeout = TimeSpan.FromMinutes(30);
_client.DefaultRequestHeaders.Accept.Clear();
_client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("*/*"));
_client.DefaultRequestHeaders.ExpectContinue = false;
}
public async Task <DeployStatus> PerformServerSideBuild(Site functionApp, Func <Task <Stream> > zipFileFactory, Func <HttpClient, Task <DeployStatus> > deploymentStatusPollTask)
{
using (var handler = new ProgressMessageHandler(new HttpClientHandler()))
using (var client = GetRemoteZipClient(new Uri($"https://{functionApp.ScmUri}"), handler))
using (var request = new HttpRequestMessage(HttpMethod.Post, new Uri(
$"api/zipdeploy?isAsync=true&author={Environment.MachineName}", UriKind.Relative)))
{
ColoredConsole.WriteLine("Creating archive for current directory...");
request.Headers.IfMatch.Add(EntityTagHeaderValue.Any);
(var content, var length) = CreateStreamContentZip(await zipFileFactory());
request.Content = content;
HttpResponseMessage response = await PublishHelper.InvokeLongRunningRequest(client, handler, request, length, "Uploading");
await PublishHelper.CheckResponseStatusAsync(response, "Uploading archive...");
// Streaming deployment status for Linux Server Side Build
DeployStatus status = await deploymentStatusPollTask(client);
if (status == DeployStatus.Success)
{
ColoredConsole.WriteLine(Green("Remote build succeeded!"));
}
else if (status == DeployStatus.Failed)
{
throw new CliException("Remote build failed!");
}
else if (status == DeployStatus.Unknown)
{
ColoredConsole.WriteLine(Yellow($"Failed to retrieve remote build status, please visit https://{functionApp.ScmUri}/api/deployments"));
}
return(status);
}
}
public async Task <string> MakePostRequest(string id, string apiName,
ProgressMessageHandler progressMessageHandler, bool save = false)
{
return(await Task.Run(async() =>
{
var makeParams = new MakeParams();
makeParams.AddSignatureParam(id, apiName);
HttpContent httpContent = new StringContent(makeParams.GetParam());
httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded")
{
CharSet = "utf-8"
};
using (var client = new HttpClient(progressMessageHandler)
{
BaseAddress = new Uri(Define.BaseUrl)
})
{
client.DefaultRequestHeaders.Add("Expect", "100-continue");
client.DefaultRequestHeaders.Add("X-Unity-Version", "2018.2.6f1");
client.DefaultRequestHeaders.Add("UserAgent",
"Dalvik/2.1.0 (Linux; U; Android 5.1.1; xiaomi 8 Build/LMY49I)");
client.DefaultRequestHeaders.Add("Host", "api.t7s.jp");
client.DefaultRequestHeaders.Add("Connection", "Keep-Alive");
client.DefaultRequestHeaders.Add("Accept-Encoding", "gzip");
var httpResponse = client.PostAsync(Define.GetApiName(Define.APINAME_TYPE.result)
, httpContent).Result;
httpResponse.EnsureSuccessStatusCode();
//ManualResetEvent.WaitOne(100);
return await httpResponse.Content.ReadAsStringAsync();
}
}));
}
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);
//await response.Content.ReadAsAsync();
//Console.WriteLine("{0}Result:{0} Filename: {1}{0} Submitter: {2}", Environment.NewLine, result.FileNames.FirstOrDefault(), result.Submitter);
}
}
public GitHubClient GetClient(Action <HttpProgressEventArgs> action = null)
{
var progress = new ProgressMessageHandler();
if (action != null)
{
progress.HttpSendProgress += (object sender, HttpProgressEventArgs e) => action(e);
}
progress.InnerHandler = HttpMessageHandlerFactory.CreateDefault();
var connection = new Connection
(
productInformation: new ProductHeaderValue(repositoryName),
baseAddress: new Uri(Url),
credentialStore: new InMemoryCredentialStore(new Credentials(userName, password)),
httpClient: new HttpClientAdapter(() => progress),
serializer: new SimpleJsonSerializer()
);
var client = new GitHubClient(connection);
client.Connection.SetRequestTimeout(Timeout);
return(client);
}
/// <summary>
/// 下载文件
/// </summary>
/// <param name="downFileName">将下载的文件名</param>
/// <param name="showDownProgress">显示下载进度的委托方法,可为空</param>
/// <returns>返回下载成功的文件目录（包括路径）</returns>
public static async void DownloadFile(string downFileName, ProgressMessageHandler showDownProgress = null)
{
HttpResponseMessage httpResponseMessage = await DataApiRepository.GetApiUri <HttpResponseMessage>("http://172.16.0.9/Api/FileDown/Update/" + downFileName, showDownProgress);
Stream responseStream = await httpResponseMessage.Content.ReadAsStreamAsync();
//以上两句代码不能用下一句代替，否则进度报告出现卡顿。
if (httpResponseMessage.Content.Headers.ContentLength > 0 && responseStream != null)
{
string needUpDateFile = System.IO.Path.Combine(Application.StartupPath, downFileName);
//创建一个文件流
FileStream fileStream = new FileStream(needUpDateFile, FileMode.Create);
//await responseStream.CopyToAsync(fileStream);
byte[] buffer = new byte[2048];
int readLength;
while ((readLength = await responseStream.ReadAsync(buffer, 0, buffer.Length)) != 0)
{
// 写入到文件
fileStream.Write(buffer, 0, readLength);
}
responseStream.Close();
fileStream.Close();
}
else
{
MessageBox.Show("下载失败，可能该文件已被从服务器上删除", "不存在", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
private async Task <double> GetUploadBytesPerSecond(string uploadUrl, byte[] data, int timeout)
{
var cancellationTokenSource = new CancellationTokenSource();
//cancellationTokenSource.CancelAfter(timeout);
CancellationToken cancellationToken = cancellationTokenSource.Token;
var sw = Stopwatch.StartNew();
var progresshandler = new ProgressMessageHandler();
var client = HttpClientFactory.Create(progresshandler);
var transfared = 0D;
progresshandler.HttpSendProgress += (s, e) =>
{
transfared = e.BytesTransferred;
};
try
{
using (HttpResponseMessage response = await client.PostAsync(uploadUrl, new ByteArrayContent(data), cancellationToken))
{
sw.Stop();
response.EnsureSuccessStatusCode();
return(transfared / sw.Elapsed.TotalSeconds);
}
}
catch (Exception ex)
{
sw.Stop();
return(transfared / sw.Elapsed.TotalSeconds);
}
}
private ProgressMessageHandler BuildProgressHandle()
{
var result = new ProgressMessageHandler();
result.HttpReceiveProgress += (s, e) => this.HttpReceiveProgress?.Invoke(this, e);
result.HttpSendProgress += (s, e) => this.HttpSendProgress?.Invoke(this, e);
return(result);
}
public HttpClient RasHttp()
{
var handler = new HttpClientHandler();
var progress = new ProgressMessageHandler();
var ras = new RasHandler(EntryName);
return(HttpClientFactory.Create(handler, ras, progress));
}
public async Task DownloadAsZip(Uri publiclink, string FileSaveDir, IProgress <ReportStatus> ReportCls = null, CancellationToken token = default)
{
string FileName = $"pCloudPublicLink_{Utilitiez.RandomString(3)}.zip";
ReportCls = ReportCls ?? new Progress <ReportStatus>();
ReportCls.Report(new ReportStatus {
Finished = false, TextStatus = "Initializing..."
});
try
{
var progressHandler = new ProgressMessageHandler(new HCHandler());
progressHandler.HttpReceiveProgress += (sender, e) => { ReportCls.Report(new ReportStatus {
ProgressPercentage = e.ProgressPercentage, BytesTransferred = e.BytesTransferred, TotalBytes = e.TotalBytes ?? 0, TextStatus = "Downloading..."
}); };
var localHttpClient = new HtpClient(progressHandler);
HttpRequestMessage HtpReqMessage = new HttpRequestMessage(HttpMethod.Get, new pUri("/getpubzip", new AuthDictionary()
{
{ "code", publiclink.GetParameterInUrl("code") }, { "filename", FileName }
}));
using (HttpResponseMessage ResPonse = await localHttpClient.SendAsync(HtpReqMessage, HttpCompletionOption.ResponseContentRead, token).ConfigureAwait(false))
{
if (ResPonse.IsSuccessStatusCode)
{
ReportCls.Report(new ReportStatus {
Finished = true, TextStatus = $"[{FileName}] Downloaded successfully."
});
}
else
{
ReportCls.Report(new ReportStatus {
Finished = true, TextStatus = $"Error code: {ResPonse.StatusCode}"
});
}
ResPonse.EnsureSuccessStatusCode();
Stream stream_ = await ResPonse.Content.ReadAsStreamAsync();
var FPathname = Path.Combine(FileSaveDir, FileName);
using (FileStream fileStream = new FileStream(FPathname, FileMode.Append, FileAccess.Write))
{
stream_.CopyTo(fileStream);
}
}
}
catch (Exception ex)
{
ReportCls.Report(new ReportStatus {
Finished = true
});
if (!ex.Message.ToString().ToLower().Contains("a task was canceled"))
{
throw new pCloudException(ex.Message, 1001);
}
ReportCls.Report(new ReportStatus {
TextStatus = ex.Message
});
}
}
public async Task OpenAsync(string userName, CancellationToken cancellationToken)
{
_cookieContainer = new CookieContainer();
_httpClientHandler = new HttpClientHandler {
CookieContainer = _cookieContainer
};
_progressMessageHandler = new ProgressMessageHandler(_httpClientHandler);
_progressMessageHandler.HttpSendProgress += MessageHandler_HttpSendProgress;
_client = new HttpClient(_progressMessageHandler)
{
Timeout = TimeSpan.FromMinutes(PackageUploadTimelimitInMinutes)
};
_client.DefaultRequestHeaders.Add("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36");
var token = await AuthenticateUserAsync(userName, "", cancellationToken);
_login = userName;
_connection = new HubConnectionBuilder()
.WithUrl($"{ServerAddress}/sionline?token={token}", options =>
{
options.AccessTokenProvider = () => Task.FromResult(Convert.ToBase64String(Encoding.UTF8.GetBytes(_login)));
})
.WithAutomaticReconnect()
.AddMessagePackProtocol()
.Build();
_connection.Reconnecting += async e =>
{
if (Reconnecting != null)
{
await Reconnecting(e);
}
};
_connection.Reconnected += async s =>
{
if (Reconnected != null)
{
await Reconnected(s);
}
};
_connection.Closed += OnConnectionClosed;
_connection.HandshakeTimeout = TimeSpan.FromMinutes(1);
_connection.On <string, string>("Say", (user, text) => OnUI(() => Receieve?.Invoke(user, text)));
_connection.On <SI.GameServer.Contract.GameInfo>("GameCreated", (gameInfo) => OnUI(() => GameCreated?.Invoke(ToSICoreGame(gameInfo))));
_connection.On <int>("GameDeleted", (gameId) => OnUI(() => GameDeleted?.Invoke(gameId)));
_connection.On <SI.GameServer.Contract.GameInfo>("GameChanged", (gameInfo) => OnUI(() => GameChanged?.Invoke(ToSICoreGame(gameInfo))));
_connection.On <string>("Joined", (user) => OnUI(() => Joined?.Invoke(user)));
_connection.On <string>("Leaved", (user) => OnUI(() => Leaved?.Invoke(user)));
await _connection.StartAsync(cancellationToken);
}
protected virtual void OnProgressMessageEvent(TarEntry entry, string message)
{
ProgressMessageHandler progressMessageEvent = this.ProgressMessageEvent;
if (progressMessageEvent != null)
{
progressMessageEvent(this, entry, message);
}
}
/// <summary>
/// Raises the ProgressMessage event
/// </summary>
/// <param name="entry">The <see cref="TarEntry">TarEntry</see> for this event</param>
/// <param name="message">message for this event. Null is no message</param>
protected virtual void OnProgressMessageEvent(TarEntry entry, string message)
{
ProgressMessageHandler handler = ProgressMessageEvent;
if (handler != null)
{
handler(this, entry, message);
}
}
public Uri ConfigureHttp()
{
try {
if (errorMap.Count == 0)
{
return(Client.BaseAddress);
}
ProgressMessageHandler progress = null;
HttpClientHandler handler = null;
//нужен еще один клиент тк BaseAddress после первого запроса менять нельзя
using (var client = Settings.GetHttpClient(Config, ref progress, ref handler)) {
var minErrorCount = errorMap.Values.Min();
var urls = errorMap.Where(x => x.Value == minErrorCount).Select(x => x.Key).ToArray();
Log.Info($"Поиск доступного хоста, выбор из {urls.Implode()}");
var requests = urls.Select(x => Tuple.Create(x, Check(client, x))).ToArray();
Task.WaitAll(requests.Select(x => x.Item2).ToArray(), 10 * 1000, Token);
var responded = requests
.Where(x => x.Item2.IsCompleted && x.Item2.Result is Version)
.ToArray();
var faulted = requests
.Where(x => x.Item2.IsCompleted && x.Item2.Result is Exception)
.ToArray();
var cancelled = requests.Except(responded).Except(faulted).ToArray();
if (responded.Length > 0)
{
Log.Info($"Ответили {responded.Implode(x => x.Item1)}");
}
if (faulted.Length > 0)
{
Log.Info($"Недоступны {faulted.Implode(x => x.Item1)}");
}
if (cancelled.Length > 0)
{
Log.Info($"Нет ответа {cancelled.Implode(x => x.Item1)}");
}
if (responded.Length > 0)
{
//для тестирования в тестах мы всегда должны брать первый из доступных
#if DEBUG
var host = new Uri(responded[0].Item1);
#else
var host = new Uri(responded[new Random().Next(responded.Length)].Item1);
#endif
Log.Info($"Выбран для обмена данными {host}");
return(host);
}
}
}
catch (Exception e) {
Log.Error("Не удалось определить хост для обмена данными", e);
}
return(Client.BaseAddress);
}
public ImageDownloader(IClipboardService clipboardService)
{
_clipboardService = clipboardService;
var progressHandler = new ProgressMessageHandler();
progressHandler.HttpReceiveProgress += (sender, args) =>
{
OnReceiveProgress(args);
};
_httpClient = HttpClientFactory.Create(progressHandler);
_cancellationSource = new CancellationTokenSource();
}
/// <summary>
/// Create an authenticated HttpClient
/// </summary>
/// <returns></returns>
private async Task <HttpClient> CreateAuthenticatedHttpClientAsync(ProgressMessageHandler handler = null)
{
var data = new FormUrlEncodedContent(new List <KeyValuePair <String, String> >
{
new KeyValuePair <String, String>("username", _username),
new KeyValuePair <String, String>("password", _password),
});
var client = handler != null ? new HttpClient(handler) : new HttpClient();
await client.PostAsync("https://openmobile.ipass.com/moservices/rest/api/login", data);
return(client);
}
public virtual HttpClient GetHttpClient(Config.Config config,
ref ProgressMessageHandler progress,
ref HttpClientHandler handler)
{
var version = typeof(AppBootstrapper).Assembly.GetName().Version;
handler = new HttpClientHandler {
Credentials = GetCredential(),
PreAuthenticate = true,
Proxy = GetProxy()
};
if (handler.Credentials == null)
{
handler.UseDefaultCredentials = true;
}
progress = new ProgressMessageHandler();
var handlers = Handlers().Concat(new[] { progress }).ToArray();
var client = HttpClientFactory.Create(handler, handlers);
client.DefaultRequestHeaders.Add("Version", version.ToString());
client.DefaultRequestHeaders.Add("Client-Token", GetClientToken());
var exe = Path.GetFileNameWithoutExtension(Assembly.GetExecutingAssembly().Location);
if (exe.Match("AnalitF.Net.Client"))
{
client.DefaultRequestHeaders.Add("Branch", "master");
}
else if (exe.Match("AnalitF"))
{
client.DefaultRequestHeaders.Add("Branch", "migration");
}
//признак по которому запросы можно объединить, нужно что бы в интерфейсе связать лог и запрос
client.DefaultRequestHeaders.Add("Request-Token", Guid.NewGuid().ToString());
try {
client.DefaultRequestHeaders.Add("OS-Version", Environment.OSVersion.VersionString);
} catch (Exception) { }
#if DEBUG
client.DefaultRequestHeaders.Add("Debug-UserName", UserName);
if (DebugTimeout > 0)
{
client.DefaultRequestHeaders.Add("debug-timeout", DebugTimeout.ToString());
}
if (DebugFault)
{
client.DefaultRequestHeaders.Add("debug-fault", "true");
}
#endif
client.BaseAddress = config.BaseUrl;
return(client);
}
public static ProgressMessageHandler CreateProgressMessageHandler(out MockProgressEventHandler progressEventHandler, bool sendProgress)
{
ProgressMessageHandler progressHandler = new ProgressMessageHandler();
progressEventHandler = new MockProgressEventHandler();
if (sendProgress)
{
progressHandler.HttpSendProgress += progressEventHandler.Handler;
}
else
{
progressHandler.HttpReceiveProgress += progressEventHandler.Handler;
}
return progressHandler;
}
/// <summary>
/// Download file from target url asynchronous
/// </summary>
/// <param name="url">URL for download</param>
/// <param name="destFileName">Destination file name</param>
/// <param name="progress">Function for display progress download</param>
/// <returns>True if download complete successful</returns>
internal static async Task <bool> DownloadFileAsync(string url, string destFileName, IProgress <double> progress = null)
{
bool success = false;
ProgressMessageHandler progressHandler = new ProgressMessageHandler();
HttpClient client = HttpClientFactory.Create(progressHandler);
try
{
//Delete if exist
using (FileStream file = new FileStream(destFileName, FileMode.Create, FileAccess.Write))
{
file.Close();
}
progressHandler.HttpReceiveProgress += (send, value) => progress?.Report(value.ProgressPercentage);
HttpResponseMessage response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead);
using (Stream stream = await response.Content.ReadAsStreamAsync())
{
byte[] buf = new byte[4096];
bool isMoreToRead = true;
do
{
int read = await stream.ReadAsync(buf, 0, buf.Length);
if (read != 0)
{
byte[] write = new byte[read];
buf.ToList().CopyTo(0, write, 0, read);
using (FileStream file = new FileStream(destFileName, FileMode.Append, FileAccess.Write))
{
file.Write(write, 0, read);
}
}
else
{
isMoreToRead = false;
}
} while (isMoreToRead);
}
success = true;
}
catch (Exception)
{
return(success);
}
return(success);
}
private static HttpClient CreateHttpClient(ProgressMessageHandler processMessageHander = null)
{
HttpClient _Client;
if (processMessageHander != null)
{
_Client = HttpClientFactory.Create(processMessageHander);
}
else
{
_Client = HttpClientFactory.Create();
}
_Client.Timeout = TimeSpan.FromSeconds(60);
return(_Client);
}
public static ProgressMessageHandler CreateProgressMessageHandler(out MockProgressEventHandler progressEventHandler, bool sendProgress)
{
ProgressMessageHandler progressHandler = new ProgressMessageHandler();
progressEventHandler = new MockProgressEventHandler();
if (sendProgress)
{
progressHandler.HttpSendProgress += progressEventHandler.Handler;
}
else
{
progressHandler.HttpReceiveProgress += progressEventHandler.Handler;
}
return(progressHandler);
}
private async void BtnUploadFile_ClickAsync(object sender, RoutedEventArgs e)
{
try
{
ExcuteResult JsonResult = new ExcuteResult();
if (_CurWinViewModel.EntityFile.ContentType == null)
{
AppFuns.ShowMessage("请选择文件内容类型！", Caption: "警告");
return;
}
_CurWinViewModel.EntityFile.CanReadUserIds = _CurWinViewModel.GetSelectUserIds();
if (!_CurWinViewModel.EntityFile.CanReadUserIds.Contains(AppSet.LoginUser.Id))
{
if (!AppFuns.ShowMessage("你本人没有读取该文件的权限？", Caption: "确认", showYesNo: true))
{
return;
}
}
BtnUpFile.IsEnabled = false;
ProgressMessageHandler progress = new ProgressMessageHandler();
progress.HttpSendProgress += (object sender, HttpProgressEventArgs e) =>
{
_CurWinViewModel.EntityFile.UpIntProgress = e.ProgressPercentage;
};
JsonResult = await DataPlanFileRepository.UpLoadFileInfo(_CurWinViewModel.EntityFile, _CurWinViewModel.UpFileInfo.OpenRead(), "upfilekey", "upfilename", progress);
if (JsonResult != null && JsonResult.State == 0)
{
_CurWinViewModel.EntityFile.Id = JsonResult.Tag;
_CurWinViewModel.EntityFile.UpIntProgress = 100;
_CurWinViewModel.EntityFile.DownIntProgress = 0;
_CallBackFunc(_CurWinViewModel.EntityFile);
this.Close();
}
else
{
AppFuns.ShowMessage(JsonResult.Msg, Caption: "错误", isErr: true);
BtnUpFile.IsEnabled = true;
}
}
catch (Exception ex)
{
AppFuns.ShowMessage(ex.Message, Caption: "错误", isErr: true);
}
}
private async Task DownloadAsync(Uri uri, string localFullName)
{
HttpClientHandler httpClientHandler = new HttpClientHandler();
ProgressMessageHandler progressMessageHandler = new ProgressMessageHandler(httpClientHandler);
HttpClient httpClient = new HttpClient(progressMessageHandler);
progressMessageHandler.HttpReceiveProgress += (object sender, HttpProgressEventArgs e) => Reportor.Report(e.ProgressPercentage);//捕获下载进度，向外汇报
FileStream fileStream = File.Create(localFullName, 1024, FileOptions.Asynchronous);
byte[] bytes = await httpClient.GetByteArrayAsync(uri);
fileStream.Write(bytes, 0, bytes.Length);
fileStream.Flush();
fileStream.Close();
}
public HttpDownloader(EventHandler <HttpProgressEventArgs> progressHandler, bool noCache = false)
{
var handler = new ProgressMessageHandler()
{
InnerHandler = new HttpClientHandler()
};
handler.HttpReceiveProgress += progressHandler;
_client = new HttpClient(handler);
_client.DefaultRequestHeaders.CacheControl = new CacheControlHeaderValue
{
NoCache = noCache
};
}
public NetSwap(Settings settings, string cookieurl = null)
{
Settings = settings;
HttpClientHandler = new HttpClientHandler {
Proxy = settings.Proxy
};
if (cookieurl != null)
{
var cookie = new CookieContainer();
var cookies = cookie.GetCookies(new Uri(cookieurl));
HttpClientHandler.CookieContainer.Add(cookies);
}
ProgressMessageHandler = new ProgressMessageHandler(HttpClientHandler);
Client = new HttpClient(ProgressMessageHandler);
Client.DefaultRequestHeaders.UserAgent.ParseAdd("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.92 Safari/537.36");
Client.Timeout = TimeSpan.FromSeconds(20);
}
//private static ManualResetEvent ManualResetEvent = new ManualResetEvent(true);
public void HttpClientTest(ProgressMessageHandler progressMessageHandler)
{
_getClient = new HttpClient(progressMessageHandler)
{
BaseAddress = new Uri(Define.Domin),
Timeout = new TimeSpan(0, 0, 10)
};
Task.Run(() =>
{
_getClient.SendAsync(new HttpRequestMessage
{
Method = new HttpMethod("POST"),
RequestUri = new Uri(Define.BaseUrl + Define.GetApiName(Define.APINAME_TYPE.inspection))
});
});
}
