protected override void Execute(CodeActivityContext executionContext)
{
ITracingService tracer = executionContext.GetExtension <ITracingService>();
IWorkflowContext context = executionContext.GetExtension <IWorkflowContext>();
IOrganizationServiceFactory serviceFactory = executionContext.GetExtension <IOrganizationServiceFactory>();
IOrganizationService service = serviceFactory.CreateOrganizationService(context.UserId);
try
{
DateTime dateToCheck = DateToCheck.Get(executionContext);
string dateOnly = dateToCheck.ToString("dd-MM-yyyy");
//Use the adapter pattern to create a wrapper for the standard HttpClient
//Calls the underlying functionality but provides a testable interface
HttpClientAdapter adapter = new HttpClientAdapter();
var callWebServiceTask = Task.Run(async() => await CallWebService(adapter, dateOnly));
Task.WaitAll(callWebServiceTask);
bool isValid = callWebServiceTask.Result;
IsPublicHoliday.Set(executionContext, isValid);
}
catch (Exception e)
{
throw new InvalidPluginExecutionException(e.Message);
}
}
public async Task SendWithHeaders_MustWithHeadersSend(string method)
{
var ada = new HttpClientAdapter(new HttpClient());
using (var ser = new EngineService())
{
var url = "http://localhost:" + (port++) + "/";
ser.Listener.Prefixes.Add(url);
ser.Listen();
var req = new RequestSettings
{
Address = url,
Accept = "application/json",
Headers = new Dictionary <string, string>
{
["A"] = "a",
["B"] = "b"
},
Host = "www.localhost.com",
Method = method,
Referrer = "http://www.referrer.com",
Timeout = 1000
};
var rep = await ada.GetMessageAsync(req);
if (!string.Equals(rep.RequestMessage.Method.Method, req.Method, StringComparison.InvariantCulture))
{
Assert.Fail();
}
Assert.AreEqual(req.Host, rep.RequestMessage.Headers.GetValues("host").First());
Assert.AreEqual(req.Headers["A"], rep.RequestMessage.Headers.GetValues("A").First());
Assert.AreEqual(req.Headers["B"], rep.RequestMessage.Headers.GetValues("B").First());
Assert.AreEqual(req.Accept, rep.RequestMessage.Headers.GetValues("Accept").First());
}
}
static async Task <int> runAsync(string roadName, IConfigurationSettings configuration)
{
httpClient.BaseAddress = configuration.BaseUri;
var httpClientAdapter = new HttpClientAdapter(httpClient);
// Construct the api Uri to pass
var uri = $"/road/{roadName}?app_id={configuration.AppId}&app_key={configuration.AppKey}";
IResponseInterpreter <RoadCorridor> responseInterpreter = new ResponseInterpreter <RoadCorridor>(r => new CurrentRoadStatus
{
DisplayName = r.DisplayName,
StatusSeverity = r.StatusSeverity,
StatusSeverityDescription = r.StatusSeverityDescription
});
// Construct the api requestor passing in the httpClient and the class that interprets the response
var apiRequestor = new ApiRequestor <RoadCorridor>(httpClientAdapter, responseInterpreter);
// Make the request and format the response into the CurrentRoadStatus entity
var interpretedResponse = await apiRequestor.GetApiResult(uri);
// Deconstruct the response tuple
var responseCode = interpretedResponse.Item1;
var currentRoadStatus = interpretedResponse.Item2;
// Write out the appropriate message
FormattedOutputFactory formattedOutputFactory = new FormattedOutputFactory(Console.Out);
var formattedOutput = formattedOutputFactory.GenerateFormattedOutput(responseCode);
formattedOutput.WriteOutput(roadName, currentRoadStatus);
// Return an integer result to return back to the console
return((int)responseCode);
}
public void InitWithNotNullValue_MustCreated()
{
var client = new HttpClient();
var ada = new HttpClientAdapter(client);
Assert.AreEqual(ada.HttpClient, client);
}
public void Initialize()
{
_httpMessageHandler = new Mock <HttpMessageHandler>();
_httpClientFactory = new Mock <IHttpClientFactory>();
_httpClientAdapter = new HttpClientAdapter(_httpClientFactory.Object);
}
/// <summary>
/// Construct a <see cref="GitHubClientFactory"/>
/// </summary>
/// <param name="gitHubConfigurationOptions">The <see cref="IOptions{TOptions}"/> containing the value of <see cref="gitHubConfiguration"/></param>
/// <param name="webRequestManager">The value of <see cref="webRequestManager"/></param>
/// <param name="logger">The value of <see cref="logger"/></param>
public GitHubClientFactory(IOptions <GitHubConfiguration> gitHubConfigurationOptions, IWebRequestManager webRequestManager, ILogger <GitHubClientFactory> logger)
{
gitHubConfiguration = gitHubConfigurationOptions?.Value ?? throw new ArgumentNullException(nameof(gitHubConfigurationOptions));
this.webRequestManager = webRequestManager ?? throw new ArgumentNullException(nameof(webRequestManager));
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
httpClientAdapter = new HttpClientAdapter(HttpMessageHandlerFactory.CreateDefault);
}
public async Task OkStatusShouldPassThrough()
{
var handler = CreateMockHttpHandler(new HttpResponseMessage(HttpStatusCode.OK));
var adapter = new HttpClientAdapter(handler);
var httpRequestMessage = CreateRequest(HttpMethod.Get);
var response = await adapter.SendAsync(httpRequestMessage, new CancellationToken());
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Same(response.RequestMessage, httpRequestMessage);
}
public void SendAsync_WhenCalled_ShouldReturnHttpResponseMessage(
HttpRequestMessage requestMessage)
{
// Arrange
var sut = new HttpClientAdapter();
// Act
var actual = sut.SendAsync(requestMessage);
// Assert
actual.Should().NotBeNull();
}
/// <summary>The get compute api client.</summary>
/// <param name="geoKey">The geo Key.</param>
/// <param name="credentials">The User credentials</param>
/// <param name="logFile">The Log File Path</param>
/// <param name="connectionName">The Connection Name</param>
/// <returns>The <see cref="IComputeApiClient"/>.</returns>
private IComputeApiClient GetComputeApiClient(Uri baseUri, ApiMessageHandler messageHandler)
{
// Handle disposing the message handler
var httpClient = new HttpClientAdapter(
new HttpClient(messageHandler, disposeHandler: true)
{
BaseAddress = baseUri,
Timeout = TimeSpan.FromMinutes(5),
});
// we will not try to login again, assuming the clientId remains the same accross the regions
return(new ComputeApiClient(httpClient));
}
public static GitHubClient Build()
{
var credentialStore = new InMemoryCredentialStore(Helper.Credentials);
var httpClient = new HttpClientAdapter(HttpMessageHandlerFactory.CreateDefault);
var connection = new Connection(
new ProductHeaderValue("ReleaseNotesCompiler"),
GitHubClient.GitHubApiUrl,
credentialStore,
httpClient,
new SimpleJsonSerializer());
return(new GitHubClient(connection));
}
public ApplicationService(IAccountsService accountsService)
{
_accountsService = accountsService;
accountsService.WhenAnyObservable(x => x.ActiveAccountChanged)
.StartWith(accountsService.ActiveAccount)
.Subscribe(account =>
{
if (account == null)
{
Client = null;
GitHubClient = null;
}
else
{
var githubAccount = account;
var domain = githubAccount.Domain ?? Client.DefaultApi;
Credentials credentials;
if (!string.IsNullOrEmpty(githubAccount.OAuth))
{
Client = Client.BasicOAuth(githubAccount.OAuth, domain);
credentials = new Credentials(githubAccount.OAuth);
}
else if (githubAccount.IsEnterprise || !string.IsNullOrEmpty(githubAccount.Password))
{
Client = Client.Basic(githubAccount.Username, githubAccount.Password, domain);
credentials = new Credentials(githubAccount.Username, githubAccount.Password);
}
else
{
Debugger.Break();
return;
}
// Decorate the HttpClient
IHttpClient httpClient = new HttpClientAdapter();
//httpClient = new OctokitCacheClient(httpClient);
httpClient = new OctokitNetworkClient(httpClient, Locator.Current.GetService <INetworkActivityService>());
var connection = new Connection(
new ProductHeaderValue("CodeHub"),
new Uri(domain),
new InMemoryCredentialStore(credentials),
httpClient,
new Octokit.Internal.SimpleJsonSerializer());
GitHubClient = new GitHubClient(connection);
}
});
}
public static GitHubClient Create(Uri domain, Credentials credentials)
{
var networkActivityService = Locator.Current.GetService <INetworkActivityService>();
var client = new HttpClientAdapter(CreateMessageHandler);
var httpClient = new OctokitNetworkClient(client, networkActivityService);
var connection = new Connection(
UserAgent,
domain,
new InMemoryCredentialStore(credentials),
httpClient,
new SimpleJsonSerializer());
return(new GitHubClient(connection));
}
public static GitHubClient Build()
{
var credentialStore = new InMemoryCredentialStore(GitHubHelper.Credentials);
var httpClient = new HttpClientAdapter(null);
var connection = new Connection(
new ProductHeaderValue("ReleaseStats"),
GitHubClient.GitHubApiUrl,
credentialStore,
httpClient,
new SimpleJsonSerializer());
return(new GitHubClient(connection));
}
protected IHttpResponse ExecutePostRequest <T>(IApiRequest apiRequest)
{
Ensure.ArgumentNotNull(nameof(apiRequest), apiRequest);
try
{
using (var client = new HttpClientAdapter())
{
var response = client.PostData(apiRequest);
return(GetResponseData <T>(response, CRUD.CrudTypes.Create));
}
}
catch (Exception exception)
{
return(HandleHttpResponseExceptions(exception));
}
}
public async Task Status303ShouldRedirectChangeMethod()
{
var redirectResponse = new HttpResponseMessage(HttpStatusCode.SeeOther);
redirectResponse.Headers.Location = new Uri("http://example.org/bar");
var handler = CreateMockHttpHandler(redirectResponse, new HttpResponseMessage(HttpStatusCode.OK));
var adapter = new HttpClientAdapter(handler);
var httpRequestMessage = CreateRequest(HttpMethod.Post);
var response = await adapter.SendAsync(httpRequestMessage, new CancellationToken());
Assert.Equal(HttpMethod.Get, response.RequestMessage.Method);
Assert.NotSame(response.RequestMessage, httpRequestMessage);
}
public async Task <IActionResult> Test(string firstName)
{
var newModel = new UserLoginModel()
{
firstName = firstName
};
var content = new StringContent(JsonConvert.SerializeObject(newModel), Encoding.UTF8, "application/json");
var url = "User/Test";
var post = await HttpClientAdapter.Post(BaseUri + url, content);
var data = await HttpClientAdapter.GetAsync <UserLoginModel>(BaseUri + "User");
return(Content($"Hello {data.firstName}"));
}
/// <summary>
/// Initializes a new instance of the <see cref="GoogleMapsApiClient"/> class.
/// </summary>
/// <param name="apiKey">
/// The api key.
/// </param>
public GoogleMapsApiClient(string apiKey)
{
var url = EndPointUris.GetBaseUri();
var httpClientHandler = new HttpClientHandler();
var httpClient = new HttpClientAdapter(
new HttpClient(httpClientHandler, true)
{
BaseAddress = url
});
var webApi = new WebApi(httpClient, apiKey);
PlaceSearch = new PlaceSearch(webApi);
GeocodingService = new GeocodingService(webApi);
DirectionsService = new DirectionsService(webApi);
}
public async Task CanCancelARequest()
{
var httpClient = new HttpClientAdapter(HttpMessageHandlerFactory.CreateDefault);
var request = new Request
{
BaseAddress = new Uri("https://github.global.ssl.fastly.net/", UriKind.Absolute),
Endpoint = new Uri("/images/icons/emoji/poop.png?v=5", UriKind.RelativeOrAbsolute),
Method = HttpMethod.Get,
Timeout = TimeSpan.FromMilliseconds(10)
};
var response = httpClient.Send(request, CancellationToken.None);
await Task.Delay(TimeSpan.FromSeconds(2));
Assert.True(response.IsCanceled);
}
protected async Task <IHttpResponse> ExecuteGetRequestAsync <T>(IApiRequest apiRequest)
{
Ensure.ArgumentNotNull(nameof(apiRequest), apiRequest);
try
{
using (var client = new HttpClientAdapter())
{
var response = await client.GetDataAsync(apiRequest, CancellationToken.None);
return(GetResponseData <T>(response, CRUD.CrudTypes.Read));
}
}
catch (Exception exception)
{
return(HandleHttpResponseExceptions(exception));
}
}
public static GitHubClient Create(Uri domain, Credentials credentials)
{
// Decorate the HttpClient
//IHttpClient httpClient = new HttpClientAdapter();
//httpClient = new OctokitCacheClient(httpClient);
var client = new HttpClientAdapter(CreateMessageHandler);
var httpClient = new OctokitNetworkClient(client, Locator.Current.GetService <INetworkActivityService>());
var connection = new Connection(
new ProductHeaderValue("CodeHub"),
domain,
new InMemoryCredentialStore(credentials),
httpClient,
new SimpleJsonSerializer());
return(new GitHubClient(connection));
}
private void Button_Click(object sender, RoutedEventArgs e)
{
HttpButton.IsEnabled = false;
try
{
using (var client = new HttpClientAdapter())
using (var response = client.GetAsync("https://www.thinktecture.com").GetAwaiter().GetResult())
{
Output.Text += $"HTTP GET https://www.thinktecture.com returned {response.StatusCode}";
}
}
finally
{
HttpButton.IsEnabled = true;
}
}
[InlineData(HttpStatusCode.TemporaryRedirect)] // 307
public async Task RedirectWithDifferentHostShouldLoseAuthHeader(HttpStatusCode statusCode)
{
var redirectResponse = new HttpResponseMessage(statusCode);
redirectResponse.Headers.Location = new Uri("http://example.net/bar");
var handler = CreateMockHttpHandler(redirectResponse, new HttpResponseMessage(HttpStatusCode.OK));
var adapter = new HttpClientAdapter(handler);
var httpRequestMessage = CreateRequest(HttpMethod.Get);
httpRequestMessage.Headers.Authorization = new AuthenticationHeaderValue("fooAuth", "aparam");
var response = await adapter.SendAsync(httpRequestMessage, new CancellationToken());
Assert.NotSame(response.RequestMessage, httpRequestMessage);
Assert.Null(response.RequestMessage.Headers.Authorization);
}
[InlineData(HttpStatusCode.TemporaryRedirect)] // 307
public async Task Status301ShouldRedirectPOSTWithBody(HttpStatusCode statusCode)
{
var redirectResponse = new HttpResponseMessage(statusCode);
redirectResponse.Headers.Location = new Uri("http://example.org/bar");
var handler = CreateMockHttpHandler(redirectResponse, new HttpResponseMessage(HttpStatusCode.OK));
var adapter = new HttpClientAdapter(handler);
var httpRequestMessage = CreateRequest(HttpMethod.Post);
httpRequestMessage.Content = new StringContent("Hello World");
var response = await adapter.SendAsync(httpRequestMessage, new CancellationToken());
Assert.Equal(response.RequestMessage.Method, httpRequestMessage.Method);
Assert.NotSame(response.RequestMessage, httpRequestMessage);
}
public async Task Exceed3RedirectsShouldReturn()
{
var redirectResponse = new HttpResponseMessage(HttpStatusCode.Found);
redirectResponse.Headers.Location = new Uri("http://example.org/bar");
var redirectResponse2 = new HttpResponseMessage(HttpStatusCode.Found);
redirectResponse2.Headers.Location = new Uri("http://example.org/foo");
var handler = CreateMockHttpHandler(redirectResponse, redirectResponse2);
var adapter = new HttpClientAdapter(handler);
var httpRequestMessage = CreateRequest(HttpMethod.Get);
await Assert.ThrowsAsync <InvalidOperationException>(
() => adapter.SendAsync(httpRequestMessage, new CancellationToken()));
}
/// <summary>
/// Gets the <c>HttpClientAdapter</c> instance from the config settings.
/// </summary>
/// <returns>Returns the <c>HttpClientAdapter</c> instance.</returns>
private IHttpClient GetHttpClientAdapter()
{
var proxy = this._settings.Proxy;
var url = proxy.Url;
var domain = proxy.Domain;
var username = proxy.Username;
var password = proxy.Password;
var useDefaultCredentials = proxy.UseDefaultCredentials;
var credentials = useDefaultCredentials ? CredentialCache.DefaultNetworkCredentials : new NetworkCredential(username, password, domain);
var webProxy = new WebProxy(url)
{
UseDefaultCredentials = useDefaultCredentials, Credentials = credentials
};
var httpClient = new HttpClientAdapter(webProxy);
return(httpClient);
}
public async Task CanDownloadImage()
{
var httpClient = new HttpClientAdapter();
var request = new Request
{
BaseAddress = new Uri("https://github.global.ssl.fastly.net/", UriKind.Absolute),
Endpoint = new Uri("/images/icons/emoji/poop.png?v=5", UriKind.RelativeOrAbsolute),
AllowAutoRedirect = true,
Method = HttpMethod.Get
};
var imageBytes = await httpClient.Send<byte[]>(request, CancellationToken.None);
// Spot check some of dem bytes.
Assert.Equal(137, imageBytes.BodyAsObject[0]);
Assert.Equal(80, imageBytes.BodyAsObject[1]);
Assert.Equal(78, imageBytes.BodyAsObject[2]);
Assert.Equal(130, imageBytes.BodyAsObject.Last());
}
public async Task <bool> CallWebService(HttpClientAdapter httpClient, string dateOnly)
{
using (httpClient)
{
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get,
new Uri($"https://kayaposoft.com/enrico/json/v1.0/?action=isPublicHoliday&date={dateOnly}&country=usa"));
request.Headers.Add("Connection", "close");
HttpResponseMessage response = await httpClient.SendAsync(request);
if (response.StatusCode != HttpStatusCode.OK)
{
return(false);
}
EnricoResponse enricoResponse = DeserializeResponse <EnricoResponse>(await response.Content.ReadAsStringAsync());
return(enricoResponse.isPublicHoliday);
}
}
public async Task CanDownloadImage()
{
var httpClient = new HttpClientAdapter(HttpMessageHandlerFactory.CreateDefault);
var request = new Request
{
BaseAddress = new Uri("https://github.global.ssl.fastly.net/", UriKind.Absolute),
Endpoint = new Uri("/images/icons/emoji/poop.png?v=5", UriKind.RelativeOrAbsolute),
Method = HttpMethod.Get
};
var response = await httpClient.Send(request, CancellationToken.None);
// Spot check some of dem bytes.
var imageBytes = (byte[])response.Body;
Assert.Equal(137, imageBytes[0]);
Assert.Equal(80, imageBytes[1]);
Assert.Equal(78, imageBytes[2]);
Assert.Equal(130, imageBytes.Last());
}
/// <summary>
/// Creates and returns a <see cref="IHttpClient"/> using the given options,
/// which may share an internal <see cref="HttpClient"/> with other instances.
/// </summary>
/// <param name="handlerOptions"></param>
/// <returns></returns>
public IHttpClient Create(HttpClientHandlerOptions handlerOptions)
{
// You're not supposed to create an HttpClient for each request:
// * https://github.com/mspnp/performance-optimization/blob/master/ImproperInstantiation/docs/ImproperInstantiation.md
// * https://aspnetmonsters.com/2016/08/2016-08-27-httpclientwrong/
// But an HttpClient maybe never updates its DNS cache, so you
// don't necessarily want to keep one open forever:
// * https://github.com/dotnet/corefx/issues/11224
// * http://byterot.blogspot.co.uk/2016/07/singleton-httpclient-dns.html
// * http://www.nimaara.com/2016/11/01/beware-of-the-net-httpclient/
// So for now we're going to keep a shared HttpClient alive, but
// only for an hour or so before we recreate it.
if (handlerOptions == null)
{
handlerOptions = CreateDefaultHttpClientHandlerOptions();
}
HttpClientNode httpClientNode;
HttpClientNode oldHttpClientNode = null;
if (cachedHttpClientDictionary.TryGetValue(handlerOptions, out httpClientNode))
{
if (httpClientNode.ExpirationTimeUtc < DateTime.UtcNow)
{
cachedHttpClientDictionary.TryRemove(handlerOptions, out oldHttpClientNode);
httpClientNode = null;
}
}
if (httpClientNode == null)
{
httpClientNode = cachedHttpClientDictionary.GetOrAdd(handlerOptions, CreateHttpClientNode);
}
var result = new HttpClientAdapter(httpClientNode.HttpClient);
return(result);
}
public ComputeApiClient(string targetRegionName)
{
if (string.IsNullOrWhiteSpace(targetRegionName))
throw new ArgumentException(
"Argument cannot be null, empty, or composed entirely of whitespace: 'targetRegionName'.", "targetRegionName");
KnownApiRegion region;
if (!KnownApiRegion.TryParse(targetRegionName, true, out region))
throw new ArgumentException("targetRegionName doesnt map to a valid region", "targetRegionName");
Uri baseUri = KnownApiUri.Instance.GetBaseUri(KnownApiVendor.DimensionData, region);
_httpClientHandler = new HttpClientHandler();
var httpClient = new HttpClientAdapter(
new HttpClient(
_httpClientHandler, disposeHandler: true)
{
BaseAddress = baseUri
});
InitializeProperties(httpClient);
}
public static GitHubClient Create(
Uri domain,
Credentials credentials,
TimeSpan?requestTimeout = null)
{
var networkActivityService = Locator.Current.GetService <INetworkActivityService>();
var client = new HttpClientAdapter(CreateMessageHandler);
var httpClient = new OctokitNetworkClient(client, networkActivityService);
var connection = new Connection(
UserAgent,
domain,
new InMemoryCredentialStore(credentials),
httpClient,
new SimpleJsonSerializer());
var gitHubClient = new GitHubClient(connection);
gitHubClient.SetRequestTimeout(requestTimeout ?? TimeSpan.FromSeconds(20));
return(gitHubClient);
}
public ComputeApiClient(KnownApiRegion region)
{
Uri baseUri = KnownApiUri.Instance.GetBaseUri(KnownApiVendor.DimensionData, region);
_httpClientHandler = new HttpClientHandler();
var httpClient = new HttpClientAdapter(
new HttpClient(
_httpClientHandler, disposeHandler: true)
{
BaseAddress = baseUri
});
InitializeProperties(httpClient);
}
/// <summary>
/// The get compute api client.
/// </summary>
/// <param name="baseUri">
/// The base uri.
/// </param>
/// <param name="credentials">
/// The credentials.
/// </param>
/// <param name="organizationId">
/// The organization id.
/// </param>
/// <returns>
/// The <see cref="ComputeApiClient"/>.
/// </returns>
/// <exception cref="ArgumentNullException">
/// </exception>
/// <exception cref="ArgumentException">
/// </exception>
public static ComputeApiClient GetComputeApiClient(Uri baseUri, ICredentials credentials, Guid organizationId = default(Guid))
{
if (baseUri == null)
throw new ArgumentNullException("baseUri", "baseUri cannot be null");
if (!baseUri.IsAbsoluteUri)
throw new ArgumentException("Base URI supplied is not an absolute URI", "baseUri");
if (credentials == null)
throw new ArgumentNullException("credentials", "credentials cannot be null");
var messageHandler = new HttpClientHandler
{
Credentials = credentials,
PreAuthenticate = true
};
// Handle disposing the message handler
var httpClient = new HttpClientAdapter(
new HttpClient(
messageHandler, disposeHandler: true)
{
BaseAddress = baseUri
});
return new ComputeApiClient(httpClient, organizationId);
}
public ComputeApiClient(Uri baseUri)
{
if (baseUri == null)
throw new ArgumentNullException("baseUri", "Argument cannot be null");
if (!baseUri.IsAbsoluteUri)
throw new ArgumentException("Base URI supplied is not an absolute URI", "baseUri");
_httpClientHandler = new HttpClientHandler();
var httpClient = new HttpClientAdapter(
new HttpClient(
_httpClientHandler, disposeHandler: true)
{
BaseAddress = baseUri
});
InitializeProperties(httpClient);
}
public StubAdapterFactory(HttpClientAdapter adapter)
{
_adapter = adapter;
}