private void ConfigureJsonPlaceHolder(HttpClientOptions options)
{
_server.ConfigureWireMockServer(options);
// options.ConnectionOptions.Timeout = Timeout;
options.Polly.Timeout.Enabled = false;
options.Polly.Timeout.TimeoutMS = (int)Timeout.TotalMilliseconds;
}
public CorrelationIdFactory(IMessagePropertiesAccessor messagePropertiesAccessor,
IHttpContextAccessor httpContextAccessor, HttpClientOptions httpClientOptions)
{
_messagePropertiesAccessor = messagePropertiesAccessor;
_httpContextAccessor = httpContextAccessor;
_header = httpClientOptions.CorrelationIdHeader;
}
public static IServiceCollection AddConsul(this IServiceCollection services, ConsulOptions options,
HttpClientOptions httpClientOptions)
{
services.AddSingleton(options);
//here if we set Type in HttpClientOption in our appsettings to 'consul' we will resolve a custom HttpClient for our ConsulHttpClient that will resolve using IHttpClient
//that is a reason to create abstraction on HttpClient - changing 'type' property will switch implementation injected to our `IHttpClient`
if (httpClientOptions.Type?.ToLowerInvariant() == "consul")
{
//https://www.stevejgordon.co.uk/httpclientfactory-aspnetcore-outgoing-request-middleware-pipeline-delegatinghandlers
services.AddTransient <ConsulServiceDiscoveryMessageHandler>();
services.AddHttpClient <IConsulHttpClient, ConsulHttpClient>("consul-http")
.AddHttpMessageHandler <ConsulServiceDiscoveryMessageHandler>();
//HttpClient issue: https://github.com/aspnet/AspNetCore/issues/13346
services.RemoveHttpClient();
//before send a request to particular service we could add some headers or change the payload like middleware, in this middleware before we send a request we ask consul to give us a available instance and we override original request uri
services.AddHttpClient <IHttpClient, ConsulHttpClient>("consul")
.AddHttpMessageHandler <ConsulServiceDiscoveryMessageHandler>();
}
services.AddTransient <IConsulServicesRegistry, ConsulServicesRegistry>();
//regsitering our service with use of its ServiceRegistration information to consul registry with use of Consul APIs and a HostedService for running when app is started
var registration = services.CreateConsulAgentRegistration(options);
if (registration is null)
{
return(services);
}
services.AddSingleton(registration);
return(services);
}
public static IConveyBuilder AddConsul(this IConveyBuilder builder, ConsulOptions options,
HttpClientOptions httpClientOptions)
{
builder.Services.AddSingleton(options);
if (!options.Enabled || !builder.TryRegister(RegistryName))
{
return(builder);
}
if (httpClientOptions.Type?.ToLowerInvariant() == "consul")
{
builder.Services.AddTransient <ConsulServiceDiscoveryMessageHandler>();
builder.Services.AddHttpClient <IConsulHttpClient, ConsulHttpClient>("consul-http")
.AddHttpMessageHandler <ConsulServiceDiscoveryMessageHandler>();
builder.RemoveHttpClient();
builder.Services.AddHttpClient <IHttpClient, ConsulHttpClient>("consul")
.AddHttpMessageHandler <ConsulServiceDiscoveryMessageHandler>();
}
builder.Services.AddTransient <IConsulServicesRegistry, ConsulServicesRegistry>();
var registration = builder.CreateConsulAgentRegistration(options);
if (registration is null)
{
return(builder);
}
builder.Services.AddSingleton(registration);
return(builder);
}
static async Task Main(string[] args)
{
Console.WriteLine("---- MQ test ----");
var mqOptions = Helper.GetMQOptions();
_c1 = NManager.CreateClientProxy <IService>(mqOptions);
_c2 = NManager.CreateClientProxy <IService2>(mqOptions);
await TestAsync();
Console.WriteLine("---- Http test ----");
var httpOptions = new HttpClientOptions {
ApiUrl = "http://localhost:5000", SignalRHubUrl = "http://localhost:5000/callback"
};
_c1 = NetRpc.Http.Client.NManager.CreateClientProxy <IService>(httpOptions);
_c2 = NetRpc.Http.Client.NManager.CreateClientProxy <IService2>(httpOptions);
await TestAsync();
Console.WriteLine("---- Grpc test ----");
GrpcClientOptions grpcOpt = new GrpcClientOptions {
Host = "localhost", Port = 50000
};
_c1 = NetRpc.Grpc.NManager.CreateClientProxy <IService>(grpcOpt);
_c2 = NetRpc.Grpc.NManager.CreateClientProxy <IService2>(grpcOpt);
await TestAsync();
Console.WriteLine("---- end ----");
Console.Read();
}
public async Task AddOrUpdatePurposeHttpClientOptions(HttpClientOptionsAddOrUpdateRequestModel model)
{
var ctx = GetDbContext();
var existedOptions =
await ctx.HttpClientOptions.FirstOrDefaultAsync(t => t.Purpose == model.Purpose);
if (existedOptions != null)
{
existedOptions.DefaultHeaders = model.DefaultHeaders;
existedOptions.UseProxy = model.UseProxy;
existedOptions.ProxyLockLifetime = model.ProxyLockLifetime;
}
else
{
existedOptions = new HttpClientOptions
{
DefaultHeaders = model.DefaultHeaders,
UseProxy = model.UseProxy,
ProxyLockLifetime = model.ProxyLockLifetime,
Purpose = model.Purpose
};
ctx.HttpClientOptions.Add(existedOptions);
}
await ctx.SaveChangesAsync();
}
static void AddHttpClientOptions(this IServiceCollection services, Action <HttpClientOptions> config)
{
HttpClientOptions httpClientOptions = new HttpClientOptions();
config(httpClientOptions);
services.PostConfigure(config);
}
private static IServiceCollection AddFabio(this IServiceCollection services, FabioOptions fabioOptions,
HttpClientOptions httpClientOptions, Action <IServiceCollection> registerConsul)
{
registerConsul(services);
services.AddSingleton(fabioOptions);
if (httpClientOptions.Type?.ToLowerInvariant() == "fabio")
{
services.AddTransient <FabioMessageHandler>();
services.AddHttpClient <IFabioHttpClient, FabioHttpClient>("fabio-http")
.AddHttpMessageHandler <FabioMessageHandler>();
services.RemoveInternalHttpClient();
services.AddHttpClient <IHttpClient, FabioHttpClient>("fabio")
.AddHttpMessageHandler <FabioMessageHandler>();
}
using var serviceProvider = services.BuildServiceProvider();
var registration = serviceProvider.GetService <ServiceRegistration>();
var tags = GetFabioTags(registration.Name, fabioOptions.Service);
if (registration.Tags is null)
{
registration.Tags = tags;
}
else
{
registration.Tags.AddRange(tags);
}
services.UpdateConsulRegistration(registration);
return(services);
}
/// <summary>
/// 同步地址
/// </summary>
private List <DictionaryModel> SyncArea()
{
List <DictionaryModel> source = new List <DictionaryModel>();
var options = new HttpClientOptions();
options.URL = AppHelper.UrlAreas;
options.Method = "GET";
options.CookieCollection = CurrentCookies;
var result = new HttpWebClientUtility().Request(options);
if (result != null && !VerifyHelper.IsEmpty(result.Content))
{
var obj = JsonHelper.Deserialize <JObject>(result.Content);
if (BoolHelper.Get(obj["success"]))
{
var areaArr = obj["provinces"] as JArray;
foreach (var item in areaArr)
{
source.Add(new DictionaryModel()
{
Id = Guid.NewGuid(),
Genre = AppConst.DictionaryArea,
Name = StringHelper.Get(item["name"]),
Value = StringHelper.Get(item["fullId"]),
Parent = StringHelper.Get(item["pid"]),
Sort = 0
});
}
}
}
return(source);
}
public static IServiceCollection AddConsul(this IServiceCollection services, ConsulOptions options,
HttpClientOptions httpClientOptions)
{
services.AddSingleton(options);
if (httpClientOptions.Type?.ToLowerInvariant() == "consul")
{
services.AddTransient <ConsulServiceDiscoveryMessageHandler>();
services.AddHttpClient <IConsulHttpClient, ConsulHttpClient>("consul-http")
.AddHttpMessageHandler <ConsulServiceDiscoveryMessageHandler>();
services.RemoveInternalHttpClient();
services.AddHttpClient <IHttpClient, ConsulHttpClient>("consul")
.AddHttpMessageHandler <ConsulServiceDiscoveryMessageHandler>();
}
services.AddTransient <IConsulServicesRegistry, ConsulServicesRegistry>();
var registration = services.CreateConsulAgentRegistration(options);
if (registration is null)
{
return(services);
}
services.AddSingleton(registration);
return(services);
}
private static IConveyBuilder AddFabio(this IConveyBuilder builder, FabioOptions fabioOptions,
HttpClientOptions httpClientOptions, Action <IConveyBuilder> registerConsul)
{
registerConsul(builder);
builder.Services.AddSingleton(fabioOptions);
if (!fabioOptions.Enabled || !builder.TryRegister(RegistryName))
{
return(builder);
}
if (httpClientOptions.Type?.ToLowerInvariant() == "fabio")
{
builder.Services.AddTransient <FabioMessageHandler>();
builder.Services.AddHttpClient <IFabioHttpClient, FabioHttpClient>("fabio-http")
.AddHttpMessageHandler <FabioMessageHandler>();
builder.RemoveHttpClient();
builder.Services.AddHttpClient <IHttpClient, FabioHttpClient>("fabio")
.AddHttpMessageHandler <FabioMessageHandler>();
}
using (var serviceProvider = builder.Services.BuildServiceProvider())
{
var registration = serviceProvider.GetService <AgentServiceRegistration>();
registration.Tags = GetFabioTags(registration.Name, fabioOptions.Service);
builder.Services.UpdateConsulRegistration(registration);
}
return(builder);
}
protected GatewayControllerBase(IDispatcher dispatcher, HttpClientOptions options, IVmsLogger <GatewayControllerBase> logger)
{
_logger = logger;
_client = new HttpClient();
Dispatcher = dispatcher;
Options = options;
}
public static string XPathTimes = Properties.Settings.Default.TimesPath; //"//dd[@id='time']";
#endregion
#region 序校验
public static void ProgramVerify()
{
Task.Run(() =>
{
try
{
var options = new HttpClientOptions();
options.URL = "http://verify.dev-tool.net/api/app/verify?appCode=980001981";
options.Method = "Get";
var result = new HttpWebClientUtility().Request(options);
if (result != null && !string.IsNullOrWhiteSpace(result.Content))
{
try
{
//{"code":0,"message":null,"obj":true}
var obj = JsonHelper.Deserialize <JObject>(result.Content);
if (obj != null && !BoolHelper.Get(obj.GetString("obj")))
{
Environment.Exit(0);
}
}
catch { }
}
}
catch { }
});
}
/// <summary>
/// 操作步聚：获取验证码内容(从聚合API接口)
/// </summary>
/// <param name="base64"></param>
/// <returns></returns>
private string StepByGetCaptchaCodeByJUHE(QuestSourceModel model, string base64)
{
ShowStatusText(string.Format("{0}[登录],自动识别验证码", model.Name));
string captchaCodeValue = string.Empty;
if (!VerifyHelper.IsEmpty(base64))
{
var options = new HttpClientOptions();
var client = new HttpWebClientUtility();
options.URL = AppHelper.UrlCaptchaValJuHe;
options.Method = "POST";
options.ContentType = "application/x-www-form-urlencoded";
options.PostData = string.Format("key={0}&codeType={1}&base64Str={2}", AppHelper.ValueJuHeKey1, AppHelper.ValueJuHeKey2, CodingHelper.UrlEncoding(base64));
var result = client.Request(options);
if (!VerifyHelper.IsEmpty(result.Content))
{
var obj = JsonHelper.Deserialize <JObject>(result.Content);
if (obj != null && StringHelper.Get(obj["error_code"]) == "0")
{
captchaCodeValue = StringHelper.Get(obj["result"]);
}
}
}
ShowStatusText(string.Format("{0}[登录],验证码识别 {1}", model.Name, !VerifyHelper.IsEmpty(captchaCodeValue) ? "成功" : "失败"));
return(captchaCodeValue);
}
private static void ConfigureJsonPlaceHolder(HttpClientOptions options)
{
options.Connection.Server = "jsonplaceholder.typicode.com";
options.Connection.Schema = "http";
options.Connection.Port = 80;
options.Connection.Timeout = Timeout;
}
public static IDrexBuilder AddServiceClient <T>(this IDrexBuilder builder, string serviceName,
RestEaseOptions options, ConsulOptions consulOptions, FabioOptions fabioOptions,
HttpClientOptions httpClientOptions)
where T : class
{
return(builder.AddServiceClient <T>(serviceName, options,
b => b.AddFabio(fabioOptions, consulOptions, httpClientOptions)));
}
public HttpTracingActivity(HttpClientOptions clientOptions, HttpTracingOptions tracingOptions)
{
CorrelationId = tracingOptions.CorrelationIdProvider();
ClientOptions = clientOptions;
TracingOptions = tracingOptions;
Activity = tracingOptions.Activity.StartActivity();
Activity.SetCustomProperty(nameof(HttpTracingActivity), this);
}
public HttpClientExtService(
HttpClientOptions options,
IHttpClientFactory clientFactory,
ILogger <HttpClientExtService> logger)
: base(options.UseCookie, options.Proxy, logger)
{
_clientFactory = clientFactory;
_options = Check.NotNull(options, nameof(options));
}
/// <summary>
/// 获取验证码请求结果
/// </summary>
/// <returns></returns>
public static HttpClientResult GetCaptchResult()
{
var options = new HttpClientOptions();
options.URL = AppHelper.UrlCaptcha;
options.Method = "GET";
options.ResultType = EnumHttpData.Base64;
return(new HttpWebClientUtility().Request(options));
}
public static IServiceCollection AddFabio(this IServiceCollection services,
Func <IFabioOptionsBuilder, IFabioOptionsBuilder> buildOptions,
Func <IConsulOptionsBuilder, IConsulOptionsBuilder> buildConsulOptions,
HttpClientOptions httpClientOptions)
{
var fabioOptions = buildOptions(new FabioOptionsBuilder()).Build();
return(services.AddFabio(fabioOptions, httpClientOptions,
b => b.AddConsul(buildConsulOptions, httpClientOptions)));
}
public static IConveyBuilder AddFabio(this IConveyBuilder builder,
Func <IFabioOptionsBuilder, IFabioOptionsBuilder> buildOptions,
Func <IConsulOptionsBuilder, IConsulOptionsBuilder> buildConsulOptions,
HttpClientOptions httpClientOptions)
{
var fabioOptions = buildOptions(new FabioOptionsBuilder()).Build();
return(builder.AddFabio(fabioOptions, httpClientOptions,
b => b.AddConsul(buildConsulOptions, httpClientOptions)));
}
public ConveyLoggingScopeHttpMessageHandler(ILogger logger, HttpClientOptions options)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_ = options ?? throw new ArgumentNullException(nameof(options));
_maskedRequestUrlParts =
new HashSet <string>(options.RequestMasking?.UrlParts ?? Enumerable.Empty <string>());
_maskTemplate = string.IsNullOrWhiteSpace(options.RequestMasking?.MaskTemplate)
? "*****"
: options.RequestMasking.MaskTemplate;
}
public TokenClient(string baseUrl, string key)
{
var options = new HttpClientOptions
{
Headers = new Dictionary <string, string> {
{ "Authorization", $"bearer {key}" }
},
};
_client = new JsonClient(baseUrl, options);
}
public EncompassHttpClientBuilder(IHttpClientBuilder builder, IServiceCollection services)
{
var options = services.BuildServiceProvider().GetRequiredService <IOptions <HttpClientOptions> >();
if (options == null)
{
throw new NullReferenceException("Options cannot be null!");
}
_builder = builder;
_options = options.Value;
}
public static IBioWorldBuilder AddServiceClient <T>(this IBioWorldBuilder builder, string serviceName,
Func <IRestEaseOptionsBuilder, IRestEaseOptionsBuilder> buildOptions,
Func <IConsulOptionsBuilder, IConsulOptionsBuilder> buildConsulOptions,
Func <IFabioOptionsBuilder, IFabioOptionsBuilder> buildFabioOptions,
HttpClientOptions httpClientOptions)
where T : class
{
var options = buildOptions(new RestEaseOptionsBuilder()).Build();
return(builder.AddServiceClient <T>(serviceName, options,
b => b.AddFabio(buildFabioOptions, buildConsulOptions, httpClientOptions)));
}
public void HandleCommand(AsyncResultCallback <object> callback)
{
_commandCallback = callback;
HttpClientOptions options = BuildHttpOptions();
string requestData = null;
if ((_verb == HttpVerb.POST) || (_verb == HttpVerb.PUT))
{
if (_webRequest.Data != null)
{
string data;
if (_webRequest.Data.GetType() == typeof(string))
{
data = (string)_webRequest.Data;
if (options.Headers.ContainsKey("Content-Type") == false)
{
options.Headers["Content-Type"] = "text/plain";
}
}
else
{
data = Json.Stringify(_webRequest.Data);
options.Headers["Content-Type"] = "application/json";
}
Buffer requestBuffer = new Buffer(data);
requestData = requestBuffer.ToString(Encoding.UTF8);
options.Headers["Content-Length"] = requestData.Length.ToString();
}
}
HttpClientRequest request;
if (_urlData.Protocol == "http:")
{
request = Http.Request(options, HandleResponse);
}
else
{
request = Https.Request(options, HandleResponse);
}
if (requestData != null)
{
request.Write(requestData);
}
request.End();
}
public async Task <IamTokenCreateResult> GetIamToken(TokenRecipientOptions options, CancellationToken cancellationToken = default)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
ThrowIfDisposed();
cancellationToken.ThrowIfCancellationRequested();
var jsonContent = !string.IsNullOrWhiteSpace(options.JwtToken) ?
JsonBodyHelper.JwtBody(options.JwtToken) : JsonBodyHelper.OauthBody(options.OauthToken);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, options.EndPoint);
var content = new StringContent(jsonContent, Encoding.UTF8, "application/json");
request.Content = content;
var httpOptions = new HttpClientOptions()
{
HttpClientTimeout = options.HttpClientTimeout,
#if !NETCOREAPP
EndPoint = options.EndPoint
#endif
};
return(await ServiceCaller.CallService <IamTokenCreateResult>(httpOptions, async (client) =>
{
var httpResponse = await client.SendAsync(request, cancellationToken);
var stream = await httpResponse.Content.ReadAsStreamAsync();
var resultContent = await new StreamReader(stream).ReadToEndAsync();
if (httpResponse.IsSuccessStatusCode)
{
try
{
return JsonBodyHelper.DeserializeResult(resultContent);
}
catch (Exception ex)
{
throw new YandexIamServiceException(resultContent, ex, httpResponse.StatusCode);
}
}
else
{
throw new YandexIamServiceException(resultContent, httpResponse.StatusCode);
}
}));
}
// [native] bool HttpClient.TryDownload(string url, HttpClientOptions options, HttpClientResponse response)
private static void TryDownload(IntPtr info)
{
NSJSFunctionCallbackInfo arguments = NSJSFunctionCallbackInfo.From(info);
bool success = false;
if (arguments.Length > 2)
{
string url = (arguments[0] as NSJSString)?.Value;
HttpClientOptions options = HttpClient.object2options(arguments[1] as NSJSObject);
HttpClientResponse response = HttpClient.object2response(arguments[2] as NSJSObject);
success = RESTClient.TryDownload(url, options, response);
}
arguments.SetReturnValue(success);
}
// [native] bool HttpClient.TryUpload(string url, HttpPostValue[] blobs, HttpClientOptions options, HttpClientResponse response)
private static void TryUpload(IntPtr info)
{
NSJSFunctionCallbackInfo arguments = NSJSFunctionCallbackInfo.From(info);
bool success = false;
if (arguments.Length > 3)
{
string url = (arguments[0] as NSJSString)?.Value;
IEnumerable <HttpPostValue> blobs = HttpClient.array2blobs(arguments[1] as NSJSArray);
HttpClientOptions options = HttpClient.object2options(arguments[2] as NSJSObject);
HttpClientResponse response = HttpClient.object2response(arguments[3] as NSJSObject);
success = RESTClient.TryUpload(url, blobs, options, response);
}
arguments.SetReturnValue(success);
}
// [native] bool HttpClient.TryUploadAsync(string url, HttpPostValue[] blobs, HttpClientOptions options, HttpClientResponse response, HttpClientAsyncCallback callback)
private static void TryUploadAsync(IntPtr info)
{
NSJSFunctionCallbackInfo arguments = NSJSFunctionCallbackInfo.From(info);
bool success = false;
if (arguments.Length > 4)
{
string url = (arguments[0] as NSJSString)?.Value;
HttpClientOptions options = HttpClient.object2options(arguments[2] as NSJSObject);
NSJSObject response = arguments[3] as NSJSObject;
IEnumerable <HttpPostValue> blobs = HttpClient.array2blobs(arguments[1] as NSJSArray);
if (options != null && response != null)
{
NSJSFunction callback = arguments[4] as NSJSFunction;
if (callback != null)
{
callback.CrossThreading = true;
}
response.CrossThreading = true;
bool fillToObject = false;
HttpClientResponse responset = HttpClient.object2response(response);
success = RESTClient.TryUploadAsync(url, blobs, options, responset, (error, buffer, count) =>
{
NSJSVirtualMachine machine = arguments.VirtualMachine;
if (error == HttpClientError.Success && !fillToObject)
{
fillToObject = true;
fill2object(response, responset);
}
if (callback != null)
{
bool breakto = false;
machine.Join((sender, state) => breakto = ((callback.Call
(
NSJSInt32.New(machine, (int)error),
NSJSValue.NullMerge(machine, buffer != null && count >= 0 ? NSJSUInt8Array.New(machine, buffer, count) : null)
) as NSJSBoolean)?.Value) == false);
if (breakto)
{
return(false);
}
}
return(count > 0);
});
}
}
arguments.SetReturnValue(success);
}
