private static void ConfigureFlurlHttp()
{
var modernHttpClientFactory = new ModernHttpClientFactory
{
OnSessionTimeOut = App.OnSessionTimeout,
OnAccessTokenRefresh = App.OnAccessTokenRefresh
};
FlurlHttp.Configure(c =>
{
c.HttpClientFactory = modernHttpClientFactory;
});
}
public IntegrationTests()
{
Directory.SetCurrentDirectory(Path.GetDirectoryName(typeof(IntegrationTests).Assembly.Location));
ReadSecrets();
var webProxy = new WebProxy("http://localhost.:8888", BypassOnLocal: false);
FlurlHttp.Configure(settings =>
{
settings.HttpClientFactory = new ProxyFactory(webProxy);
});
}
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
var call = HttpCall.Get(request);
var stringContent = request.Content as CapturedStringContent;
if (stringContent != null)
{
call.RequestBody = stringContent.Content;
}
await FlurlHttp.RaiseEventAsync(request, FlurlEventType.BeforeCall).ConfigureAwait(false);
call.StartedUtc = DateTime.UtcNow;
try {
call.Response = await base.SendAsync(request, cancellationToken).ConfigureAwait(false);
call.EndedUtc = DateTime.UtcNow;
}
catch (Exception ex) {
call.Exception = (ex is TaskCanceledException && !cancellationToken.IsCancellationRequested) ?
new FlurlHttpTimeoutException(call, ex) :
new FlurlHttpException(call, ex);
}
if (call.Response != null && !call.Succeeded)
{
if (call.Response.Content != null)
{
call.ErrorResponseBody = await call.Response.Content.ReadAsStringAsync().ConfigureAwait(false);
}
call.Exception = new FlurlHttpException(call, null);
}
if (call.Exception != null)
{
await FlurlHttp.RaiseEventAsync(request, FlurlEventType.OnError).ConfigureAwait(false);
}
await FlurlHttp.RaiseEventAsync(request, FlurlEventType.AfterCall).ConfigureAwait(false);
if (call.Exception != null && !call.ExceptionHandled)
{
throw call.Exception;
}
call.Response.RequestMessage = request;
return(call.Response);
}
private static void ConfigureFlurl(Action <FlurlHttpConfigurationOptions> configureFlurl = null)
{
FlurlHttp.Configure(c =>
{
// Apply the application's default settings
if (configureFlurl != null)
{
configureFlurl(c);
}
//
// Apply our default settings
//
if (c.HttpClientFactory is DefaultHttpClientFactory)
{
c.HttpClientFactory = new AuthenticatedHttpClientFactory();
}
// Apply our event handling without clobbering any application level handlers
var applicationBeforeCall = c.BeforeCall;
c.BeforeCall = call =>
{
SetUserAgentHeader(call);
if (applicationBeforeCall != null)
{
applicationBeforeCall(call);
}
};
var applicationAfterCall = c.AfterCall;
c.AfterCall = call =>
{
Tracing.TraceHttpCall(call);
if (applicationAfterCall != null)
{
applicationAfterCall(call);
}
};
var applicationOnError = c.OnError;
c.OnError = call =>
{
Tracing.TraceFailedHttpCall(call);
if (applicationOnError != null)
{
applicationOnError(call);
}
};
});
}
static void GeneralConfiguration()
{
FlurlHttp.Configure(settings => {
var jsonSettings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
ObjectCreationHandling = ObjectCreationHandling.Replace
};
settings.JsonSerializer = new NewtonsoftJsonSerializer(jsonSettings);
});
Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US");
Thread.CurrentThread.CurrentUICulture = new System.Globalization.CultureInfo("en-US");
}
public async Task SendXmlToModelAsync(HttpMethodTypes methodType)
{
FlurlHttp.Configure(c => c.HttpClientFactory = new EchoHttpClientFactory());
var method = HttpMethodByType[methodType];
var result = await new Url("https://some.url")
.AllowAnyHttpStatus()
.SendXmlAsync(method, new TestModel {
Number = 3, Text = "Test"
})
.ReceiveXml <TestModel>();
AssertTestModel(result, 3, "Test");
}
public Form1()
{
FlurlHttp.Configure(settings => settings.AllowedHttpStatusRange = "400-404,415,421,423,500,503");
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
ServicePointManager.ServerCertificateValidationCallback = delegate { return(true); };
ServicePointManager.DefaultConnectionLimit = 5000;
InitializeComponent();
InitializeSettings();
_instance = this;
if (!Properties.Settings.Default.HideClientToggle)
{
DeleteLockFile();
}
}
public async Task SendXmlToXDocumentAsync(HttpMethodTypes methodType)
{
FlurlHttp.Configure(c => c.HttpClientFactory = new EchoHttpClientFactory());
var method = HttpMethodByType[methodType];
var result = await new Url("https://some.url")
.SendXmlAsync(method, new TestModel {
Number = 3, Text = "Test"
})
.ReceiveXDocument()
.ConfigureAwait(false);
AssertXDocument(result, 3, "Test");
}
static async Task Main(string[] args)
{
var mongoHost = Environment.GetEnvironmentVariable("MONGO_HOST") ?? "localhost";
var interfaceHost = Environment.GetEnvironmentVariable("INTERFACE_HOST") ?? "localhost";
//wait for mongo to be available
await CheckMongoAvailibility(mongoHost);
await CheckWebServerAvailibility(interfaceHost);
FlurlHttp.Configure(settings => {
var jsonSettings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
ObjectCreationHandling = ObjectCreationHandling.Replace
};
settings.JsonSerializer = new NewtonsoftJsonSerializer(jsonSettings);
});
Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US");
Thread.CurrentThread.CurrentUICulture = new System.Globalization.CultureInfo("en-US");
Console.WriteLine("Starting daemon");
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
var cancellationToken = cancellationTokenSource.Token;
SerialThread serialThread = new SerialThread(mongoHost, interfaceHost);
serialThread.PlayBeep();
WebSocketThread webSocketThread = new WebSocketThread($"ws://{interfaceHost}:3001", serialThread);
ProcessingThread processingThread = new ProcessingThread(serialThread, webSocketThread, mongoHost, interfaceHost);
var serialPort = Environment.GetEnvironmentVariable("SERIAL_PORT");
if (string.IsNullOrEmpty(serialPort))
{
serialThread.SetPortName();
}
else
{
serialThread.SetPortName(serialPort);
}
var webSocketTask = webSocketThread.Start(cancellationToken);
var serialTask = serialThread.Start(cancellationToken);
var processingTask = processingThread.Start(cancellationToken);
Task.WaitAll(webSocketTask, serialTask, processingTask);
Console.WriteLine("Daemon finished");
}
public static void AddTokenClient(this IServiceCollection services, IReadOnlyCollection <TokenSource> wellKnownTokenSources)
{
services.AddTransient <ITokenClient, TokenClient>();
services.AddTransient <IAssertionService, AssertionService>();
foreach (var source in wellKnownTokenSources)
{
FlurlHttp.ConfigureClient(source.BaseUri.ToString(), settings =>
{
settings.Settings.HttpClientFactory = new BypassCertificateValidation(source.Thumbprint);
settings.AllowAnyHttpStatus();
});
}
}
public static IServiceCollection AddNugetServiceIntegrations(this IServiceCollection services, IConfiguration configuration)
{
services.TryAddSingleton <IFlurlClient>((s) => new FlurlClient());
FlurlHttp.Configure(c =>
{
c.Timeout = TimeSpan.FromSeconds(30);
});
services.Configure <ConfigurationOptions>(configuration.GetSection(nameof(ConfigurationOptions)).BindWithReload);
services.AddScoped <INugetService, NugetService>();
return(services);
}
internal MtgServiceProvider(
IHeaderManager headerManager,
IModelMapper modelMapper,
IRateLimit rateLimit)
{
_headerManager = headerManager;
_modelMapper = modelMapper;
_rateLimit = rateLimit;
_apiVersion = ApiVersion.V1;
FlurlHttp.Configure(settings =>
{
settings.JsonSerializer = new SystemTextJsonSerializer();
});
}
static void SendAppLogToServer(AppLog appLog)
{
var serverUrl = "http://localhost:9090";
FlurlHttp.Configure(settings => settings.OnErrorAsync = HandleFlurlErrorAsync);
var entry = new RawLogData()
{
Type = StoredLogType.AppLog, Data = JsonUtils.Serialize(appLog), ReceiveDate = DateTime.UtcNow
};
var result = (serverUrl + ControllerConstants.AddAppLogUrl.AddFirstChar('/'))
.WithHeader(HeaderContants.AppId, "APPID_1")
.PostJsonAsync(entry).Result;
}
public VstsRestClient(string organization, string token)
{
_organization = organization ?? throw new ArgumentNullException(nameof(organization));
_token = token ?? throw new ArgumentNullException(nameof(token));
FlurlHttp.Configure(settings =>
{
var jsonSettings = new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
Converters = { new PolicyConverter() }
};
settings.JsonSerializer = new NewtonsoftJsonSerializer(jsonSettings);
settings.HttpClientFactory = new HttpClientFactory();
});
}
/// <summary>
/// Configures the application services that require configuration.
/// </summary>
/// <param name="jenkinsSettings">The settings required to configure Jenkins requests.</param>
private static void ConfigureAppServices(JenkinsSettings jenkinsSettings)
{
var jsonSettings = new JsonSerializerSettings {
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
FlurlHttp.Configure(s => s.JsonSerializer = new NewtonsoftJsonSerializer(jsonSettings));
if (!string.IsNullOrWhiteSpace(jenkinsSettings.User) || !string.IsNullOrWhiteSpace(jenkinsSettings.Password))
{
FlurlHttp.ConfigureClient(jenkinsSettings.BaseEndpoint, cl =>
cl.WithBasicAuth(jenkinsSettings.User, jenkinsSettings.Password)
);
}
jenkinsSettings.Password = null;
}
private static void Main()
{
Application.SetHighDpiMode(HighDpiMode.SystemAware);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
var services = new ServiceCollection();
DependencyInjectionConfig.Register(services);
// FlurlHttp.Configure(settings => settings.ConnectionLeaseTimeout = TimeSpan.FromMinutes(2));
FlurlHttp.Configure(settings => settings.HttpClientFactory = new ConnectionLifetimeHttpClientFactory());
using (var provider = services.BuildServiceProvider())
{
var mainForm = provider.GetService <Form1>();
Application.Run(mainForm);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseHttp" /> class.
/// </summary>
/// <param name="host">The host</param>
protected BaseHttp(string host)
{
Guard.NotNullOrEmpty(host, nameof(host), "Host could not be null or empty");
BasePath = host;
FlurlHttp.Configure(settings =>
{
var jsonSettings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
ObjectCreationHandling = ObjectCreationHandling.Replace
};
settings.JsonSerializer = new NewtonsoftJsonSerializer(jsonSettings);
});
}
public AssistantClient(IOptions <HomeAssistantOptions> options, ILogger <AssistantClient> logger)
{
BaseUrl = (options.Value.Address.StartsWith("http") ? options.Value.Address : $"http://{options.Value.Address}").Trim('"', '\'').AppendPathSegment("api");
// DefaultRequestHeaders.Accept
// .Add(new MediaTypeWithQualityHeaderValue("application/json"));
FlurlHttp.Configure(settings => {
var jsonSettings = new JsonSerializerSettings {
NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore,
Formatting = Formatting.None,
StringEscapeHandling = StringEscapeHandling.Default
};
settings.JsonSerializer = new NewtonsoftJsonSerializer(jsonSettings);
});
_logger = logger;
_logger.LogInformation($"Initialized AssistantClient for '{BaseUrl}'");
}
public async Task SendProtobufAsync_Put_SimpleObject()
{
var obj = new SimpleModel
{
Age = 26,
Id = Guid.NewGuid(),
BirthDate = DateTime.Now,
Name = "Foo da Silva"
};
FlurlHttp.Configure(c => c.HttpClientFactory = new VerifyObjectHttpClientFactory(obj));
var result = await new Url("https://some.url").SendProtobufAsync(HttpMethod.Put, obj);
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
}
public void BeforeAllTests()
{
if (!Environment.OSVersion.IsAppVeyor() && Process.GetProcessesByName("Fiddler").Any())
{
var webProxy = new WebProxy("http://localhost.:8888", BypassOnLocal: false);
FlurlHttp.Configure(settings =>
{
settings.HttpClientFactory = new ProxyFactory(webProxy);
});
}
#if NETFRAMEWORK
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
#endif
}
Action <dynamic> _responseCallback; // Used to notify of multi-response calls
public ApiHelper(string account, string token, string endpointUri = "https://localhost:30063/api/1.1", Dictionary <string, string> accountProps = null, Action <dynamic> responseCallback = null)
{
_responseCallback = responseCallback;
if (string.IsNullOrEmpty(token))
{
throw (new ArgumentNullException(nameof(token)));
}
this._token = token;
if (string.IsNullOrEmpty(account))
{
throw (new ArgumentNullException(nameof(account)));
}
this._account = account;
if (string.IsNullOrEmpty(endpointUri))
{
Console.WriteLine($"No api endpoint uri passed using {_endpointUri}");
}
else if (IsValidUri(endpointUri))
{
_endpointUri = endpointUri;
}
else
{
throw (new ArgumentException($"Uri {endpointUri} is not valid"));
}
var idx = endpointUri.IndexOf("/api/");
if (idx < 0)
{
throw (new ArgumentException($"Uri {endpointUri} is not valid"));
}
_baseUri = _endpointUri.Substring(0, idx);
// TODO: remove this later
// Configure to ignore bad certificates for this endpoint
FlurlHttp.ConfigureClient(_endpointUri, cli =>
{
cli.Settings.HttpClientFactory = new UntrustedCertClientFactory();
cli.Settings.Timeout = new TimeSpan(0, 30, 0); // 30 minutes timeout
});
// Configure account properties if any
if (accountProps != null && accountProps.Count > 0)
{
var response = SetAccountProps(account, accountProps);
}
}
public static async Task Main(string[] args)
{
var username = args[0];
var password = args[1];
var hostname = args[2];
FlurlHttp.Configure(settings => settings.HttpClientFactory = new HttpClientRedirectFactory());
using (var client = new FlurlClient($"https://{hostname}/api/v1"))
{
var accessToken = (await client.Request("login")
.PostJsonAsync(new { username, password })
.ReceiveJson()).accessToken;
client.Headers.Add("Authorization", $"Bearer {accessToken}");
// Let's exercise the API
var networkDevices = await client.Request("networkDevices").GetJsonAsync();
Console.WriteLine($"Total number of network devices: {networkDevices.total}");
// Get objects from the first network device
var firstNetworkDevice = networkDevices.items[0];
var objects = await client.Request($"networkDevices/{firstNetworkDevice.id}/objects").GetJsonAsync();
Console.Write($"Item Reference of first object on first device: {objects.items[0].itemReference}");
// Get alarms, but exclude acknowledged and discarded alarms. Also only in the priority
// range 0-70
var alarms = await client.Request("alarms")
.SetQueryParams(new
{
excludePending = true,
excludeAcknowledged = true,
priorityRange = "0,70"
})
.GetJsonAsync();
// Do the same thing but manually construct the URL
alarms = await client.Request("alarms?excludePending=true&excludeAcknowledged=true&priorityRange=0,70")
.GetJsonAsync();
Console.WriteLine(JsonConvert.SerializeObject(alarms.items[0], Formatting.Indented));
}
}
protected IntegrationTest()
{
DataFixture = new Fixture();
Server = new TestServer(new WebHostBuilder().UseStartup <InProcessStartUp>());
FlurlHttp.Configure(c =>
{
c.HttpClientFactory = new HttpClientFactory(Server);
});
Client = new FlurlClient(Server.BaseAddress.AbsoluteUri);
DeserializeWithPrivateSetters = new JsonSerializerSettings
{
ContractResolver = new JsonPrivateResolver()
};
}
public IntegrationTests()
{
Directory.SetCurrentDirectory(Path.GetDirectoryName(typeof(IntegrationTests).Assembly.Location));
ReadSecrets();
#if NETFRAMEWORK
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
#endif
var webProxy = new WebProxy("http://localhost.:8888", BypassOnLocal: false);
FlurlHttp.Configure(settings =>
{
settings.HttpClientFactory = new ProxyFactory(webProxy);
});
}
public IntegrationTests()
{
Directory.SetCurrentDirectory(Path.GetDirectoryName(typeof(IntegrationTests).Assembly.Location));
var lines = File.ReadAllLines("../../.secrets.txt");
var apiKey = lines[0].GetAfter(":");
webhookSecret = lines[1].GetAfter(":");
var webProxy = new WebProxy("http://localhost.:8888", BypassOnLocal: false);
FlurlHttp.Configure(settings =>
{
settings.HttpClientFactory = new ProxyFactory(webProxy);
});
commerceApi = new CommerceApi(apiKey);
}
public static void Configure(Configuration config)
{
Func <FlurlCall, Task> beforeCallAsync = (FlurlCall call) =>
{
Log.Verbose("HTTP Request: {@HttpMethod} - {@Uri} - {@Headers} - {@Content}", call.HttpRequestMessage.Method, call.HttpRequestMessage.RequestUri, call.HttpRequestMessage.Headers.ToString(), call.HttpRequestMessage.Content);
return(Task.CompletedTask);
};
Func <FlurlCall, Task> afterCallAsync = async(FlurlCall call) =>
{
Log.Verbose("HTTP Response: {@HttpStatusCode} - {@HttpMethod} - {@Uri} - {@Headers} - {@Content}", call.HttpResponseMessage?.StatusCode, call.HttpRequestMessage?.Method, call.HttpRequestMessage?.RequestUri, call.HttpResponseMessage.Headers.ToString(), await call.HttpResponseMessage?.Content?.ReadAsStringAsync());
if (config.Observability.Prometheus.Enabled)
{
HttpRequestHistogram
.WithLabels(
call.HttpRequestMessage.Method.ToString(),
call.HttpRequestMessage.RequestUri.Host,
call.HttpRequestMessage.RequestUri.AbsolutePath,
call.HttpRequestMessage.RequestUri.Query,
((int)call.HttpResponseMessage.StatusCode).ToString(),
call.HttpResponseMessage.ReasonPhrase
).Observe(call.Duration.GetValueOrDefault().TotalSeconds);
}
};
Func <FlurlCall, Task> onErrorAsync = async(FlurlCall call) =>
{
var response = string.Empty;
if (call.HttpResponseMessage is object)
{
response = await call.HttpResponseMessage?.Content?.ReadAsStringAsync();
}
Log.Error("Http Call Failed. {@HttpStatusCode} {@Content}", call.HttpResponseMessage?.StatusCode, response);
};
FlurlHttp.Configure(settings =>
{
settings.Timeout = new TimeSpan(0, 0, 10);
settings.BeforeCallAsync = beforeCallAsync;
settings.AfterCallAsync = afterCallAsync;
settings.OnErrorAsync = onErrorAsync;
settings.Redirects.ForwardHeaders = true;
});
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="apiKey"> Your OneSignal API key </param>
/// <param name="apiUri"> API uri </param>
protected ResourceBase(string apiKey, string apiUri = "https://onesignal.com/api/v1")
{
ApiKey = apiKey;
ApiUri = apiUri;
FlurlHttp.Configure(config =>
{
config.JsonSerializer = new NewtonsoftJsonSerializer(
new JsonSerializerSettings
{
MissingMemberHandling = MissingMemberHandling.Ignore,
NullValueHandling = NullValueHandling.Ignore,
DefaultValueHandling = DefaultValueHandling.Include
}
);
});
}
private void ConfigureFlurlHttpClient()
{
FlurlHttp.Configure(settings =>
{
var contractResolver = new DefaultContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
};
var jsonSettings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = contractResolver
};
settings.JsonSerializer = new NewtonsoftJsonSerializer(jsonSettings);
});
}
public Proxy()
{
PropertyChanged += (s, e) => e.Case <object>(a =>
{
try
{
FlurlHttp.ConfigureClient(BaseUrl, cli =>
{
cli.Settings.Timeout = TimeSpan.FromMinutes(30);
if (cli.HttpMessageHandler is HttpClientHandler hch)
{
hch.ServerCertificateCustomValidationCallback += (_, __, ___, ____) => true;
}
});
}
catch (Exception ex) { }
}, nameof(Host), nameof(Port), nameof(UseHttps));
}
public static void Configure()
{
FlurlHttp.Configure(settings => {
var jsonSettings = new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
NullValueHandling = NullValueHandling.Ignore,
Converters = new List <Newtonsoft.Json.JsonConverter>
{
new Newtonsoft.Json.Converters.StringEnumConverter()
}
};
var serializer = new NewtonsoftJsonSerializer(jsonSettings);
settings.JsonSerializer = serializer;
});
}
