protected override async Task <(string Dump, Exception Exception)> ExecuteJobAsync(WebhookJob job)
{
var requestBody = job.Body;
var requestMessage = BuildRequest(job, requestBody);
HttpResponseMessage response = null;
try
{
response = await HttpClientPool.GetHttpClient().SendAsync(requestMessage);
var responseString = await response.Content.ReadAsStringAsync();
var requestDump = DumpFormatter.BuildDump(requestMessage, response, requestBody, responseString, TimeSpan.Zero, false);
Exception ex = null;
if (!response.IsSuccessStatusCode)
{
ex = new HttpRequestException($"Response code does not indicate success: {(int)response.StatusCode} ({response.StatusCode}).");
}
return(requestDump, ex);
}
catch (Exception ex)
{
var requestDump = DumpFormatter.BuildDump(requestMessage, response, requestBody, ex.ToString(), TimeSpan.Zero, false);
return(requestDump, ex);
}
}
// http://www.tugberkugurlu.com/archive/efficiently-streaming-large-http-responses-with-httpclient
protected async Task DownloadToStream(string path, Stream target)
{
using (var pool = new HttpClientPool())
{
try
{
var client = pool.NewClient();
var result = await client.GetAsync(new Uri(ChainEndPoint, path), HttpCompletionOption.ResponseHeadersRead);
result.EnsureSuccessStatusCode();
using (var source = await result.Content.ReadAsStreamAsync())
{
await source.CopyToAsync(target);
return;
}
throw new DownloadInvalidContentTypeException(ChainEndPoint, path);
}
catch (TaskCanceledException)
{
throw new DownloadTimeoutException(ChainEndPoint, path);
}
catch (Exception)
{
throw new DownloadNotFoundException(ChainEndPoint, path);
}
}
}
public void MultiThreadProxy()
{
IHttpClientPool pool = new HttpClientPool();
var spider = new DefaultSpider();
var downloader = new HttpClientDownloader();
ConcurrentDictionary <HttpClientEntry, int> tonggi = new ConcurrentDictionary <HttpClientEntry, int>();
Parallel.For(0, 1000, new ParallelOptions {
MaxDegreeOfParallelism = 1
}, (i) =>
{
var port = i % 10;
var proxy = new UseSpecifiedUriWebProxy(new Uri($"http://192.168.10.1:{port}"));
var item = pool.GetHttpClient(proxy.Hash);
if (tonggi.ContainsKey(item))
{
tonggi[item] = tonggi[item] + 1;
}
else
{
tonggi.TryAdd(item, 1);
}
});
Assert.Equal(10, tonggi.Count);
foreach (var pair in tonggi)
{
Assert.Equal(100, pair.Value);
}
}
public async Task HttpClientPoolAllocatesOneHandlerPerUriAndCredentialSet()
{
var uri = new Uri("http://localhost/platibus");
var clientPool = new HttpClientPool();
var credentialSet = new IEndpointCredentials[]
{
new BasicAuthCredentials("user1", "pw1"),
new BearerCredentials("eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ"),
new DefaultCredentials()
};
var initialSize = clientPool.Size;
foreach (var credentials in credentialSet)
{
await clientPool.GetClient(uri, credentials);
}
var finalSize = clientPool.Size;
clientPool.Dispose();
Assert.Equal(3, finalSize - initialSize);
}
protected override async Task <(string Dump, Exception Exception)> ExecuteJobAsync(FastlyJob job)
{
if (string.IsNullOrWhiteSpace(job.Key))
{
return(null, new InvalidOperationException("The action cannot handle this event."));
}
var requestMsg = BuildRequest(job);
HttpResponseMessage response = null;
try
{
response = await HttpClientPool.GetHttpClient().SendAsync(requestMsg);
var responseString = await response.Content.ReadAsStringAsync();
var requestDump = DumpFormatter.BuildDump(requestMsg, response, null, responseString, TimeSpan.Zero, false);
return(requestDump, null);
}
catch (Exception ex)
{
var requestDump = DumpFormatter.BuildDump(requestMsg, response, null, ex.ToString(), TimeSpan.Zero, false);
return(requestDump, ex);
}
}
protected async Task <string> DownloadText(string path, bool checkMediaType = true)
{
using (var pool = new HttpClientPool())
{
try
{
var client = pool.NewClient();
var result = await client.GetAsync(new Uri(ChainEndPoint, path));
result.EnsureSuccessStatusCode();
if (!checkMediaType || result.Content.Headers.ContentType.MediaType == "text/plain")
{
return(await result.Content.ReadAsStringAsync());
}
throw new DownloadInvalidContentTypeException(ChainEndPoint, path);
}
catch (TaskCanceledException)
{
throw new DownloadTimeoutException(ChainEndPoint, path);
}
catch (Exception)
{
throw new DownloadNotFoundException(ChainEndPoint, path);
}
}
}
public override async Task <(string Dump, Exception Exception)> ExecuteJobAsync(RuleJobData job)
{
var requestBody = job["RequestBody"].ToString(Formatting.Indented);
var requestMsg = BuildRequest(job, requestBody);
HttpResponseMessage response = null;
try
{
response = await HttpClientPool.GetHttpClient().SendAsync(requestMsg);
var responseString = await response.Content.ReadAsStringAsync();
var requestDump = DumpFormatter.BuildDump(requestMsg, response, requestBody, responseString, TimeSpan.Zero, false);
return(requestDump, null);
}
catch (Exception ex)
{
if (requestMsg != null)
{
var requestDump = DumpFormatter.BuildDump(requestMsg, response, requestBody, ex.ToString(), TimeSpan.Zero, false);
return(requestDump, ex);
}
else
{
var requestDump = ex.ToString();
return(requestDump, ex);
}
}
}
protected async Task <byte[]> DownloadBinary(string path, bool checkMediaType = true)
{
using (var pool = new HttpClientPool())
{
try
{
var client = pool.NewClient();
var uri = new Uri(ChainEndPoint, path);
var result = await client.GetAsync(uri);
result.EnsureSuccessStatusCode();
if (!checkMediaType || result.Content.Headers.ContentType.MediaType == "application/octet-stream")
{
return(await result.Content.ReadAsByteArrayAsync());
}
throw new DownloadInvalidContentTypeException(ChainEndPoint, path);
}
catch (TaskCanceledException)
{
throw new DownloadTimeoutException(ChainEndPoint, path);
}
catch (Exception)
{
throw new DownloadNotFoundException(ChainEndPoint, path);
}
}
}
public static async Task <DebugTokenData> GetFacebookAccessTokenDebugInfo(string inputToken)
{
using (var response =
await HttpClientPool.GetHttpClient().GetAsync(FacebookApi.GetDebugTokenUrl(inputToken)))
{
if (response.IsSuccessStatusCode)
{
var responseJson = await response.Content.ReadAsStringAsync();
var debugTokenData = JsonConvert.DeserializeObject <DebugTokenDataRoot>(responseJson).data;
return(debugTokenData);
}
throw new Exception("Could not verify login with facebook. Please try again in some time.");
}
}
public static async Task <string> ExchangeTokenForLongLivedToken(string tokenToExchange)
{
using (var response = await HttpClientPool.GetHttpClient()
.GetAsync(FacebookApi.GetExchangeTokenUrl(tokenToExchange)))
{
if (response.IsSuccessStatusCode)
{
var responseJson = await response.Content.ReadAsStringAsync();
var exchangeTokenData = JsonConvert.DeserializeObject <ExchangeTokenData>(responseJson);
return(exchangeTokenData.access_token);
}
throw new Exception("Could not exchange token for a long lived one.");
}
}
public static async Task <UserProfileInfo> GetUserProfileInfo(string userId, string userAccessToken)
{
using (var response = await HttpClientPool.GetHttpClient()
.GetAsync(FacebookApi.GetBasicUserInfoUrl(userId, userAccessToken)))
{
if (response.IsSuccessStatusCode)
{
var responseJson = await response.Content.ReadAsStringAsync();
var userProfileInfo = JsonConvert.DeserializeObject <UserProfileInfo>(responseJson);
return(userProfileInfo);
}
throw new Exception("Error fetching user profile info.");
}
}
public async Task HttpClientPoolAllocatesOneHandlerPerUriAndManyOfTheSameCredential()
{
var uri = new Uri("http://localhost/platibus");
var clientPool = new HttpClientPool();
var credentialSet = Enumerable.Range(0, 100)
.Select(_ => new BasicAuthCredentials("user", "pw"));
var initialSize = clientPool.Size;
foreach (var credentials in credentialSet)
{
await clientPool.GetClient(uri, credentials);
}
var finalSize = clientPool.Size;
clientPool.Dispose();
Assert.Equal(1, finalSize - initialSize);
}
public override async Task <(string Dump, Exception Exception)> ExecuteJobAsync(RuleJobData job)
{
var requestBody = job["RequestBody"].ToString(Formatting.Indented);
var requestMsg = BuildRequest(job, requestBody);
HttpResponseMessage response = null;
try
{
response = await HttpClientPool.GetHttpClient().SendAsync(requestMsg);
var responseString = await response.Content.ReadAsStringAsync();
var requestDump = DumpFormatter.BuildDump(requestMsg, response, requestBody, responseString, TimeSpan.Zero, false);
Exception ex = null;
if (!response.IsSuccessStatusCode)
{
ex = new HttpRequestException($"Response code does not indicate success: {(int)response.StatusCode} ({response.StatusCode}).");
}
return(requestDump, ex);
}
catch (Exception ex)
{
if (requestMsg != null)
{
var requestDump = DumpFormatter.BuildDump(requestMsg, response, requestBody, ex.ToString(), TimeSpan.Zero, false);
return(requestDump, ex);
}
else
{
throw;
}
}
}
public override async Task <(string Dump, Exception Exception)> ExecuteJobAsync(RuleJobData job)
{
if (!job.TryGetValue("Key", out var keyToken))
{
return(null, new InvalidOperationException("The action cannot handle this event."));
}
var requestMsg = BuildRequest(job, keyToken.Value <string>());
HttpResponseMessage response = null;
try
{
response = await HttpClientPool.GetHttpClient().SendAsync(requestMsg);
var responseString = await response.Content.ReadAsStringAsync();
var requestDump = DumpFormatter.BuildDump(requestMsg, response, null, responseString, TimeSpan.Zero, false);
return(requestDump, null);
}
catch (Exception ex)
{
if (requestMsg != null)
{
var requestDump = DumpFormatter.BuildDump(requestMsg, response, null, ex.ToString(), TimeSpan.Zero, false);
return(requestDump, ex);
}
else
{
var requestDump = ex.ToString();
return(requestDump, ex);
}
}
}
protected override async Task <(string Dump, Exception Exception)> ExecuteJobAsync(SlackJob job)
{
var requestBody = job.Body;
var requestMessage = BuildRequest(job, requestBody);
HttpResponseMessage response = null;
try
{
response = await HttpClientPool.GetHttpClient().SendAsync(requestMessage);
var responseString = await response.Content.ReadAsStringAsync();
var requestDump = DumpFormatter.BuildDump(requestMessage, response, requestBody, responseString, TimeSpan.Zero, false);
return(requestDump, null);
}
catch (Exception ex)
{
var requestDump = DumpFormatter.BuildDump(requestMessage, response, requestBody, ex.ToString(), TimeSpan.Zero, false);
return(requestDump, ex);
}
}
public CrestronHttpClient(int poolSize)
{
pool = new HttpClientPool(poolSize);
}
public static void MainWithAssembly(Assembly resourceAssembly, IntPtr resourcePointer, IntPtr corePointer, string dllName)
{
DllName = dllName;
var library = new Library(DllName, true);
var logger = new Logger(library, corePointer);
Alt.Logger = logger;
Alt.Log("Library initialized");
unsafe
{
if (library.Shared.Core_GetEventEnumSize() != (byte)EventType.SIZE)
{
throw new Exception("Event type enum size doesn't match. Please, update the nuget");
}
}
AppDomain.CurrentDomain.UnhandledException += OnUnhandledException;
_resourcePointer = resourcePointer;
_corePointer = corePointer;
var type = typeof(IResource);
var resource = resourceAssembly.GetTypes().FirstOrDefault(t => t.IsClass && !t.IsAbstract && type.IsAssignableFrom(t));
if (resource is null)
{
throw new Exception("Cannot find resource");
return;
}
_resource = (IResource)Activator.CreateInstance(resource) !;
Alt.Log("Resource created");
Alt.Logger = _resource.GetLogger(library, corePointer);
var playerPool = new PlayerPool(_resource.GetPlayerFactory());
Alt.Log("Player pool created");
var vehiclePool = new VehiclePool(_resource.GetVehicleFactory());
Alt.Log("Vehicle pool created");
var blipPool = new BlipPool(_resource.GetBlipFactory());
Alt.Log("Blip pool created");
var checkpointPool = new CheckpointPool(_resource.GetCheckpointFactory());
Alt.Log("Checkpoint pool created");
var audioPool = new AudioPool(_resource.GetAudioFactory());
Alt.Log("Audio pool created");
var httpClientPool = new HttpClientPool(_resource.GetHttpClientFactory());
Alt.Log("Http client pool created");
var webSocketClientPool = new WebSocketClientPool(_resource.GetWebSocketClientFactory());
Alt.Log("WebSocket client pool created");
var webViewPool = new WebViewPool(_resource.GetWebViewFactory());
Alt.Log("Webview pool created");
var rmlDocumentPool = new RmlDocumentPool(new RmlDocumentFactory());
var rmlElementPool = new RmlElementPool(new RmlElementFactory());
Alt.Log("Rml pools created");
var nativeResourcePool = new NativeResourcePool(_resource.GetResourceFactory());
Alt.Log("Native resource pool created");
var baseBaseObjectPool = new BaseBaseObjectPool(playerPool, vehiclePool, blipPool, checkpointPool, audioPool, httpClientPool, webSocketClientPool, webViewPool, rmlElementPool, rmlDocumentPool);
var baseEntityPool = new BaseEntityPool(playerPool, vehiclePool);
var timerPool = new TimerPool();
var natives = _resource.GetNatives(DllName);
var client = new Core(
library,
corePointer,
resourcePointer,
playerPool,
vehiclePool,
blipPool,
checkpointPool,
audioPool,
httpClientPool,
webSocketClientPool,
webViewPool,
rmlDocumentPool,
rmlElementPool,
baseBaseObjectPool,
baseEntityPool,
nativeResourcePool,
timerPool,
logger,
natives
);
_core = client;
Alt.CoreImpl = client;
AltShared.Core = client;
Alt.Log("Core initialized");
_core.GetPlayers();
_core.GetVehicles();
_core.GetBlips();
playerPool.InitLocalPlayer(_core);
_core.Resource.CSharpResourceImpl.SetDelegates();
Alt.Log("Delegates set");
_resource.OnStart();
Alt.Log("Startup finished");
}
public async Task MultipleRequestsToSameEndpointWithNtlmShouldNotFail()
{
var uri = new Uri("http://localhost:52179/platibus/");
var clientPool = new HttpClientPool();
var testCompletionSource = new TaskCompletionSource <int>();
var testComplete = testCompletionSource.Task;
var httpListener = new HttpListener
{
AuthenticationSchemes = AuthenticationSchemes.Ntlm,
Prefixes = { uri.ToString() }
};
Task httpListenerLoop = null;
try
{
httpListener.Start();
httpListenerLoop = Task.Run(async() =>
{
while (httpListener.IsListening)
{
var contextReceipt = httpListener.GetContextAsync();
if (await Task.WhenAny(testComplete, contextReceipt) == testComplete)
{
break;
}
var context = await contextReceipt;
await context.Request.InputStream.CopyToAsync(context.Response.OutputStream);
context.Response.StatusCode = 200;
context.Response.Close();
}
});
var clientTasks = Enumerable.Range(1, 10)
.Select(i => Task.Run(async() =>
{
// ReSharper disable once AccessToDisposedClosure
using (var client = await clientPool.GetClient(uri, new DefaultCredentials()))
{
var content = "test" + (i + 1);
var response = await client.PostAsync("test", new StringContent(content));
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(content, await response.Content.ReadAsStringAsync());
return(response);
}
}));
var responses = await Task.WhenAll(clientTasks);
Assert.Equal(10, responses.Length);
}
finally
{
if (httpListenerLoop != null)
{
testCompletionSource.TrySetResult(0);
httpListenerLoop.Wait(TimeSpan.FromSeconds(5));
}
if (httpListener.IsListening)
{
httpListener.Stop();
}
httpListener.Close();
clientPool.Dispose();
}
}
