public virtual PubgPlayerSeason GetPlayerSeason(PubgRegion region, string playerId, string seasonId, string apiKey = null)
{
var url = Api.Players.PlayerSeasonsEndpoint(region, playerId, seasonId);
apiKey = string.IsNullOrEmpty(apiKey) ? ApiKey : apiKey;
var seasonJson = HttpRequestor.GetString(url, apiKey);
return(JsonConvert.DeserializeObject <PubgPlayerSeason>(seasonJson, new JsonApiSerializerSettings()));
}
public virtual PubgStatus GetStatus(string apiKey = null)
{
var url = Api.Status.StatusEndpoint();
apiKey = string.IsNullOrEmpty(apiKey) ? ApiKey : apiKey;
var objectJson = HttpRequestor.GetString(url, apiKey);
return(JsonConvert.DeserializeObject <PubgStatus>(objectJson, new JsonApiSerializerSettings()));
}
public virtual async Task <PubgPlayer> GetPlayerAsync(PubgRegion region, string playerId, string apiKey = null, CancellationToken cancellationToken = default(CancellationToken))
{
var url = string.Format(Api.Players.PlayersEndpoint + "/{1}", region.Serialize(), playerId);
apiKey = string.IsNullOrEmpty(apiKey) ? ApiKey : apiKey;
var playerJson = await HttpRequestor.GetStringAsync(url, cancellationToken, apiKey);
return(JsonConvert.DeserializeObject <PubgPlayer>(playerJson, new JsonApiSerializerSettings()));
}
public virtual PubgPlayer GetPlayer(PubgRegion region, string playerId, string apiKey = null)
{
var url = string.Format(Api.Players.PlayersEndpoint + "/{1}", region.Serialize(), playerId);
apiKey = string.IsNullOrEmpty(apiKey) ? ApiKey : apiKey;
var playerJson = HttpRequestor.GetString(url, apiKey);
return(JsonConvert.DeserializeObject <PubgPlayer>(playerJson, new JsonApiSerializerSettings()));
}
public async virtual Task <PubgTournament> GetTournamentAsync(string tournamentId, string apiKey = null, CancellationToken cancellationToken = default(CancellationToken))
{
var url = Api.Tournaments.TournamentsEndpoint(tournamentId);
apiKey = string.IsNullOrEmpty(apiKey) ? ApiKey : apiKey;
var matchJson = await HttpRequestor.GetStringAsync(url, cancellationToken, apiKey).ConfigureAwait(false);
return(JsonConvert.DeserializeObject <PubgTournament>(matchJson, new JsonApiSerializerSettings()));
}
public virtual IEnumerable <PubgSeason> GetSeasons(PubgRegion region, string apiKey = null)
{
var url = Api.Seasons.SeasonsEndpoint(region);
apiKey = string.IsNullOrEmpty(apiKey) ? ApiKey : apiKey;
var seasonJson = HttpRequestor.GetString(url, apiKey);
return(JsonConvert.DeserializeObject <IEnumerable <PubgSeason> >(seasonJson, new JsonApiSerializerSettings()));
}
public async virtual Task <IEnumerable <PubgSeason> > GetSeasonsAsync(PubgRegion region, string apiKey = null, CancellationToken cancellationToken = default(CancellationToken))
{
var url = Api.Seasons.SeasonsEndpoint(region);
apiKey = string.IsNullOrEmpty(apiKey) ? ApiKey : apiKey;
var seasonJson = await HttpRequestor.GetStringAsync(url, cancellationToken, apiKey).ConfigureAwait(false);
return(JsonConvert.DeserializeObject <IEnumerable <PubgSeason> >(seasonJson, new JsonApiSerializerSettings()));
}
public virtual async Task <PubgStatus> GetStatusAsync(string apiKey = null, CancellationToken cancellationToken = default(CancellationToken))
{
var url = Api.Status.StatusEndpoint();
apiKey = string.IsNullOrEmpty(apiKey) ? ApiKey : apiKey;
var objectJson = await HttpRequestor.GetStringAsync(url, cancellationToken, apiKey).ConfigureAwait(false);
return(JsonConvert.DeserializeObject <PubgStatus>(objectJson, new JsonApiSerializerSettings()));
}
public virtual PubgTournament GetTournament(string tournamentId, string apiKey = null)
{
var url = Api.Tournaments.TournamentsEndpoint(tournamentId);
apiKey = string.IsNullOrEmpty(apiKey) ? ApiKey : apiKey;
var matchJson = HttpRequestor.GetString(url, apiKey);
return(JsonConvert.DeserializeObject <PubgTournament>(matchJson, new JsonApiSerializerSettings()));
}
public bool TryDownloadPrefetchPacks(long latestTimestamp)
{
EventMetadata metadata = CreateEventMetadata();
metadata.Add("latestTimestamp", latestTimestamp);
using (ITracer activity = this.Tracer.StartActivity("TryDownloadPrefetchPacks", EventLevel.Informational, Keywords.Telemetry, metadata))
{
long bytesDownloaded = 0;
long requestId = HttpRequestor.GetNewRequestId();
RetryWrapper <GitObjectsHttpRequestor.GitObjectTaskResult> .InvocationResult result = this.GitObjectRequestor.TrySendProtocolRequest(
requestId: requestId,
onSuccess: (tryCount, response) => this.DeserializePrefetchPacks(response, ref latestTimestamp, ref bytesDownloaded),
onFailure: RetryWrapper <GitObjectsHttpRequestor.GitObjectTaskResult> .StandardErrorHandler(activity, requestId, "TryDownloadPrefetchPacks"),
method: HttpMethod.Get,
endPointGenerator: () => new Uri(
string.Format(
"{0}?lastPackTimestamp={1}",
this.GitObjectRequestor.CacheServer.PrefetchEndpointUrl,
latestTimestamp)),
requestBodyGenerator: () => null,
cancellationToken: CancellationToken.None,
acceptType: new MediaTypeWithQualityHeaderValue(GVFSConstants.MediaTypes.PrefetchPackFilesAndIndexesMediaType));
if (!result.Succeeded)
{
if (result.Result != null && result.Result.HttpStatusCodeResult == HttpStatusCode.NotFound)
{
EventMetadata warning = CreateEventMetadata();
warning.Add(TracingConstants.MessageKey.WarningMessage, "The server does not support " + GVFSConstants.Endpoints.GVFSPrefetch);
warning.Add(nameof(this.GitObjectRequestor.CacheServer.PrefetchEndpointUrl), this.GitObjectRequestor.CacheServer.PrefetchEndpointUrl);
activity.RelatedEvent(EventLevel.Warning, "CommandNotSupported", warning);
}
else
{
EventMetadata error = CreateEventMetadata();
error.Add("latestTimestamp", latestTimestamp);
error.Add("Exception", result.Error);
error.Add(nameof(this.GitObjectRequestor.CacheServer.PrefetchEndpointUrl), this.GitObjectRequestor.CacheServer.PrefetchEndpointUrl);
activity.RelatedWarning(error, "DownloadPrefetchPacks failed.", Keywords.Telemetry);
}
}
activity.Stop(new EventMetadata
{
{ "Area", EtwArea },
{ "Success", result.Succeeded },
{ "Attempts", result.Attempts },
{ "BytesDownloaded", bytesDownloaded },
});
return(result.Succeeded);
}
}
public void HttpRequestor_Requests_CorrectMediaType()
{
var mockHttp = new MockHttpMessageHandler();
mockHttp.Fallback.Throw(new InvalidOperationException("No gzip header was found"));
mockHttp.Expect(HttpMethod.Get, "*").WithHeaders("Accept", "application/vnd.api+json").Respond("application/json", "test string");
MockHttpClient(mockHttp);
var result = HttpRequestor.GetString("http://www.random.url", "token");
}
public void HttpRequestor_Attaches_ApiKey_To_Request()
{
var mockHttp = new MockHttpMessageHandler();
mockHttp.Fallback.Throw(new InvalidOperationException("No token attached to request"));
var apiToken = "token";
mockHttp.Expect(HttpMethod.Get, "*").WithHeaders("Authorization", $"Bearer {apiToken}").Respond("application/json", "test string");
MockHttpClient(mockHttp);
var result = HttpRequestor.GetString("http://www.random.url", apiToken);
}
private static string GetBlkHash(string rpcAddress, string height)
{
var reqhttp = new HttpRequestor(rpcAddress);
var cmdargs = new CmdParseResult {
Args = new List <string>()
{
height
}
};
var resp = reqhttp.DoRequest(new GetBlockInfoCmd().BuildRequest(cmdargs).ToString());
var jObj = JObject.Parse(resp);
return(jObj["result"]["result"]["Blockhash"].ToString());
}
public void HttpRequestor_Throws_CorrectErrorForHttpStatus(HttpStatusCode statusCode, Type errorType)
{
var mockHttp = new MockHttpMessageHandler();
mockHttp
.When("*")
.Respond(statusCode, new List <KeyValuePair <string, string> >()
{
new KeyValuePair <string, string>("X-RateLimit-Reset", "1000")
}, new StringContent("{\"errors\" : []}"));
MockHttpClient(mockHttp);
Assert.Throws(errorType, () => HttpRequestor.GetString("http://random.url"));
}
public bool TryDownloadPrefetchPacks(long latestTimestamp)
{
EventMetadata metadata = new EventMetadata();
metadata.Add("latestTimestamp", latestTimestamp);
using (ITracer activity = this.Tracer.StartActivity(nameof(this.TryDownloadPrefetchPacks), EventLevel.Informational, metadata))
{
long requestId = HttpRequestor.GetNewRequestId();
RetryWrapper <GitObjectsHttpRequestor.GitObjectTaskResult> .InvocationResult result = this.GitObjectRequestor.TrySendProtocolRequest(
requestId: requestId,
onSuccess: (tryCount, response) => this.DeserializePrefetchPacks(response, ref latestTimestamp),
onFailure: RetryWrapper <GitObjectsHttpRequestor.GitObjectTaskResult> .StandardErrorHandler(activity, requestId, nameof(this.TryDownloadPrefetchPacks)),
method: HttpMethod.Get,
endPointGenerator: () => new Uri(
string.Format(
"{0}?lastPackTimestamp={1}",
this.Enlistment.PrefetchEndpointUrl,
latestTimestamp)),
requestBodyGenerator: () => null,
acceptType: new MediaTypeWithQualityHeaderValue(GVFSConstants.MediaTypes.PrefetchPackFilesAndIndexesMediaType));
if (!result.Succeeded)
{
if (result.Result != null && result.Result.HttpStatusCodeResult == HttpStatusCode.NotFound)
{
EventMetadata warning = new EventMetadata();
warning.Add("ErrorMessage", "The server does not support " + GVFSConstants.Endpoints.GVFSPrefetch);
warning.Add(nameof(this.Enlistment.PrefetchEndpointUrl), this.Enlistment.PrefetchEndpointUrl);
activity.RelatedEvent(EventLevel.Warning, "CommandNotSupported", warning);
}
else
{
EventMetadata error = new EventMetadata();
error.Add("latestTimestamp", latestTimestamp);
error.Add("Exception", result.Error);
error.Add("ErrorMessage", "DownloadPrefetchPacks failed.");
error.Add(nameof(this.Enlistment.PrefetchEndpointUrl), this.Enlistment.PrefetchEndpointUrl);
activity.RelatedError(error);
}
}
return(result.Succeeded);
}
}
private void ExposeHttpRequestorToContext()
{
_context.ServiceNode.GetService <IJSValueConverterService>()
.RegisterProxyConverter <HttpRequestor>( //register the object converter
(binding, instance, serviceNode) => { binding.SetFunction <JSValue, JSValue>("send", instance.Send); });
try
{
RunScript("_requestor = null;");
_requestor = new HttpRequestor(_option.Endpoint, _context);
_context.GlobalObject.WriteProperty("_requestor", _requestor);
RunScript("aelf = new Aelf(_requestor);");
RunScript(File.ReadAllText(Path.Combine(DefaultScriptsPath, "requestor.js")));
}
catch (Exception)
{
//Ignore
}
}
public void BuildsRequestMessage()
{
var url = $"{Urls.SignatureDocuments}/{Guid.NewGuid()}";
var token = "access-token";
var request = HttpRequestor.GetRequestMessage(url, HttpMethod.Get, token);
Assert.IsNotNull(request);
Assert.AreEqual(new Uri(url), request.RequestUri);
Assert.AreEqual($"Bearer {token}", request.Headers.GetValues("Authorization").FirstOrDefault());
Assert.AreEqual($".NET {SignicatConfiguration.SdkVersion}",
request.Headers.GetValues("X-Signicat-Express-SDK").FirstOrDefault());
Assert.AreEqual(HttpMethod.Get, request.Method);
}
private string CallTransaction(Transaction tx)
{
MemoryStream ms = new MemoryStream();
Serializer.Serialize(ms, tx);
byte[] b = ms.ToArray();
string payload = b.ToHex();
var reqParams = new JObject {
["rawtx"] = payload
};
var req = JsonRpcHelpers.CreateRequest(reqParams, "call", 1);
// todo send raw tx
HttpRequestor reqhttp = new HttpRequestor(_rpcAddress);
string resp = reqhttp.DoRequest(req.ToString());
return(resp);
}
public void PubgErrors_Have_ApiErrors_MappedCorrectly()
{
var mockHttp = new MockHttpMessageHandler();
var errors = new Fixture().CreateMany <PubgError>();
var errorsJson = JsonConvert.SerializeObject(errors);
mockHttp
.When("*")
.Respond(HttpStatusCode.BadRequest, "application/json", $"{{ \"errors\": {errorsJson} }}");
MockHttpClient(mockHttp);
try
{
HttpRequestor.GetString("http://random.url");
}
catch (PubgException ex)
{
ex.Errors.Count().Should().Equals(errors.Count());
Assert.All(ex.Errors, err => errors.Contains(err));
}
}
public void PubgErrors_Have_Correct_HttpStatus(HttpStatusCode statusCode)
{
var mockHttp = new MockHttpMessageHandler();
mockHttp
.When("*")
.Respond(statusCode, new List <KeyValuePair <string, string> >()
{
new KeyValuePair <string, string>("X-RateLimit-Reset", "1000")
}, new StringContent("{\"errors\" : []}"));
MockHttpClient(mockHttp);
try
{
HttpRequestor.GetString("http://random.url");
}
catch (PubgException ex)
{
ex.HttpStatusCode.Should().Equals(statusCode);
}
}
protected void PostFormContentData(string url, MultipartFormDataContent requestObject = null)
{
HttpRequestor.PostContentFormData(url, requestObject, GetToken());
}
public virtual async Task <IEnumerable <PubgTelemetryEvent> > GetTelemetryAsync(PubgRegion region, string url, CancellationToken cancellationToken = default(CancellationToken))
{
var collectionJson = await HttpRequestor.GetStringAsync(url, cancellationToken);
return(JsonConvert.DeserializeObject <IEnumerable <PubgTelemetryEvent> >(collectionJson));
}
public virtual IEnumerable <PubgTelemetryEvent> GetTelemetry(PubgRegion region, string url)
{
var collectionJson = HttpRequestor.GetString(url);
return(JsonConvert.DeserializeObject <IEnumerable <PubgTelemetryEvent> >(collectionJson));
}
protected T Put <T>(string url, object requestObject = null)
{
return(Mapper.MapFromJson <T>(
HttpRequestor.Put(url, Mapper.MapToJson(requestObject), GetToken())));
}
protected async Task <T> PatchAsync <T>(string url, object requestObject = null)
{
return(Mapper.MapFromJson <T>(
await HttpRequestor.PatchAsync(url, Mapper.MapToJson(requestObject), GetToken())));
}
protected async Task PostFormContentDataAsync(string url, MultipartFormDataContent requestObject = null)
{
await HttpRequestor.PostContentFormDataAsync(url, requestObject, GetToken());
}
protected async Task PostAsync(string url, object requestObject = null)
{
await HttpRequestor.PostAsync(url, Mapper.MapToJson(requestObject), GetToken());
}
protected void Post(string url, object requestObject = null)
{
HttpRequestor.Post(url, Mapper.MapToJson(requestObject), token: GetToken());
}
protected async Task <Stream> GetFileAsync(string url)
{
return(await HttpRequestor.GetStreamAsync(url, GetToken()));
}
protected Stream GetFile(string url)
{
return(HttpRequestor.GetStream(url, GetToken()));
}
