/// <summary>
/// Sends a json request.
/// </summary>
/// <typeparam name="T">The type of response we expect.</typeparam>
/// <param name="verb">The http verb to use.</param>
/// <param name="url">The url to send the request to.</param>
/// <param name="payload">The object that will be serialized into json.</param>
/// <param name="service">Optional parameter which uses headers for a specific service instead of defaults.</param>
/// <returns>An IAsyncToken to listen to.</returns>
/// <exception cref="NullReferenceException"></exception>
protected IAsyncToken <HttpResponse <T> > SendJsonRequest <T>(
HttpVerb verb,
string url,
object payload)
{
var token = new AsyncToken <HttpResponse <T> >();
var request = new UnityWebRequest(
url,
verb.ToString().ToUpperInvariant())
{
downloadHandler = new DownloadHandlerBuffer(),
disposeDownloadHandlerOnDispose = true,
disposeUploadHandlerOnDispose = true
};
var service = Services.Process(request);
ApplyJsonPayload(payload, request);
// Log after Processing
Log(verb.ToString(), request.url, service, payload);
_bootstrapper.BootstrapCoroutine(Wait(request, token));
return(token);
}
/// <summary>
/// 发送405响应（不接受请求类型）到客户端
/// </summary>
/// <param name="Response"></param>
/// <param name="allow"></param>
public static void Send405(this HttpResponseBase Response, HttpVerb allow)
{
Response.Clear();
Response.StatusCode = 405;
Response.StatusDescription = "Method Not Allowed";
Response.AppendHeader("Allow", allow.ToString());
Response.Write(string.Format("Method Not Allowed, Except: {0}", allow.ToString()));
Response.End();
}
/// <summary>
/// 发送405响应（不接受请求类型）到客户端
/// </summary>
/// <param name="Response"></param>
/// <param name="allow"></param>
public static void Send405(this HttpResponseBase Response, HttpVerb allow)
{
Response.Clear();
Response.StatusCode = 405;
Response.StatusDescription = "Method Not Allowed";
Response.AppendHeader("Allow", allow.ToString());
Response.Write(string.Format("Method Not Allowed, Except: {0}", allow.ToString()));
Response.End();
}
public void MakeReguestPut()
{
this.httpMethod = HttpVerb.Put;
this.strResponseValue = string.Empty;
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(endPoint);
request.Method = httpMethod.ToString();
HttpWebResponse response;
try{
response = (HttpWebResponse)request.GetResponse();
if (response.StatusCode != HttpStatusCode.OK)
{
throw new ApplicationException("Error code: " + response.StatusCode);
}
else
{
Stream responseStream = response.GetResponseStream();
if (responseStream != null)
{
StreamReader reader = new StreamReader(responseStream);
this.strResponseValue = reader.ReadToEnd();
reader.Close();
}
}
}
catch (Exception e) {
Console.WriteLine("No connection to server");
}
}
/// <summary>
/// Makes RESTful HTTP request
/// </summary>
/// <returns>Response of the request (could be JSON, XML or HTML etc. serialized into string)</returns>
public async Task <string> MakeRequestAsync()
{
HttpWebRequest webRequest = null;
// Create a HttpWebRequest instance for web request
try
{
webRequest = (HttpWebRequest)WebRequest.Create(_endPoint);
webRequest.Method = _httpMethod.ToString();
webRequest.ContentType = _contentType;
if (_headers?.Count > 0)
{
foreach (KeyValuePair <string, string> header in _headers)
{
webRequest.Headers[header.Key] = header.Value;
}
}
}
catch (Exception ex)
{
throw new Exception("Unable to create HttpWebRequest handler. " + ex.Message);
}
if (webRequest != null)
{
return(await ProcessWebRequestAsync(webRequest));
}
return(null);
}
/// <summary>
/// Sends a file!
/// </summary>
/// <typeparam name="T">The type of response we expect.</typeparam>
/// <param name="verb">The http verb to use.</param>
/// <param name="url">The url to send the request to.</param>
/// <param name="fields">Optional fields that will _precede_ the file.</param>
/// <param name="file">The file, which will be named "file".</param>
/// <returns></returns>
private IAsyncToken <HttpResponse <T> > SendFile <T>(
HttpVerb verb,
string url,
IEnumerable <Tuple <string, string> > fields,
ref byte[] file)
{
var token = new AsyncToken <HttpResponse <T> >();
var form = new WWWForm();
foreach (var tuple in fields)
{
form.AddField(tuple.Item1, tuple.Item2);
}
form.AddBinaryData("file", file);
var request = UnityWebRequest.Post(
url,
form);
request.method = verb.ToString().ToUpperInvariant();
request.useHttpContinue = false;
request.downloadHandler = new DownloadHandlerBuffer();
request.disposeDownloadHandlerOnDispose = true;
request.disposeUploadHandlerOnDispose = true;
ApplyHeaders(Headers, request);
_bootstrapper.BootstrapCoroutine(Wait(request, token));
return(token);
}
/// <summary>
/// Set the HTTP verb (or method)
/// </summary>
public RequestFluent Verb(HttpVerb verb)
{
// set the verb
this._verb = verb.ToString();
return(this);
}
public string makeRequest(HttpVerb httpMethod)
{
string strResponseValue = string.Empty;
HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(endpoint);
request.Method = httpMethod.ToString();
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
if (response.StatusCode != HttpStatusCode.OK)
{
throw new ApplicationException($"Error Code: {response.StatusCode}");
}
using (Stream responseStream = response.GetResponseStream())
{
if (responseStream != null)
{
using (StreamReader reader = new StreamReader(responseStream))
{
strResponseValue = reader.ReadToEnd();
}
}
}
}
return(strResponseValue);
}
/// <summary>
/// Sends a JSON request.
/// </summary>
/// <typeparam name="T">Type of response.</typeparam>
/// <param name="verb">HTTP verb.</param>
/// <param name="url">Complete endpoint url.</param>
/// <param name="payload">Object to send.</param>
/// <returns></returns>
private IAsyncToken <HttpResponse <T> > SendRequest <T>(
HttpVerb verb,
string url,
object payload)
{
Log.Info(this,
"{0} {1}",
verb.ToString().ToUpperInvariant(),
url);
var token = new AsyncToken <HttpResponse <T> >();
byte[] bytes = null;
if (null != payload)
{
_serializer.Serialize(payload, out bytes);
}
var request = new WWW(
url,
bytes,
HeaderDictionary());
_bootstrapper.BootstrapCoroutine(Wait(request, token));
return(token);
}
public string MakeRequest()
{
string stringResponseValue = string.Empty;
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(EndPoint);
HttpMethod = HttpVerb.GET;
request.Method = HttpMethod.ToString();
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
if (response.StatusCode != HttpStatusCode.OK)
{
throw new ApplicationException($"Error code: {response.StatusCode}");
}
//Precess the response stream
using (Stream responseStream = response.GetResponseStream())
{
if (responseStream != null)
{
using (StreamReader reader = new StreamReader(responseStream))
{
stringResponseValue = reader.ReadToEnd();
} //End of StreamReader
}
} //End of using ResponseStream
} //End of using Response
return(stringResponseValue);
}
private void MockResponse(HttpVerb verb, HttpStatusCode status, string response)
{
HttpResponseMessage responseMessage = new HttpResponseMessage(status);
responseMessage.Content = new StringContent(response);
switch (verb)
{
case HttpVerb.DELETE:
_mockHttpClient.Setup(x => x.DeleteAsync(It.IsAny <string>()))
.ReturnsAsync(responseMessage);
break;
case HttpVerb.GET:
_mockHttpClient.Setup(x => x.GetAsync(It.IsAny <string>()))
.ReturnsAsync(responseMessage);
break;
case HttpVerb.POST:
_mockHttpClient.Setup(x => x.PostAsync(It.IsAny <string>(), It.IsAny <HttpContent>()))
.ReturnsAsync(responseMessage);
break;
case HttpVerb.PUT:
_mockHttpClient.Setup(x => x.PutAsync(It.IsAny <string>(), It.IsAny <HttpContent>()))
.ReturnsAsync(responseMessage);
break;
default:
throw new NotImplementedException($"HTTP Verb '{verb.ToString()}' not implemented");
}
}
/// <summary>
/// HTTP Web Request
/// </summary>
/// <param name="url"></param>
/// <param name="webMethod">webMethod</param>
/// <param name="cookies"></param>
/// <param name="postDataValue"></param>
/// <returns></returns>
private static HttpWebResult PrepareInkWebRequest(HP.DeviceAutomation.IDevice device, Uri url, HttpVerb webMethod, string cookies, string postDataValue)
{
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(url);
webRequest.Accept = "*/*";
if (device is SiriusUIv3Device)
{
webRequest.Headers.Add("Accept-Language", "en-US");
webRequest.ContentType = "text/xml";
}
else
{
webRequest.Headers.Add("Accept-Language", "en-US,en;q=0.5");
webRequest.ContentType = "text/xml; charset=UTF-8";
}
webRequest.Headers.Add("Accept-Encoding", "gzip, deflate");
if (!string.IsNullOrEmpty(cookies))
{
webRequest.Headers.Add("Cookie", cookies);
}
webRequest.ServicePoint.Expect100Continue = false;
webRequest.Method = webMethod.ToString();
if (webMethod == HttpVerb.GET)
{
return(HttpWebEngine.Get(webRequest));
}
if (webMethod == HttpVerb.PUT)
{
return(HttpWebEngine.Put(webRequest, postDataValue));
}
return(null);
}
internal static void AddAuthenticationHeaders(HttpPipelineRequest request, Uri uri, HttpVerb method, ReadOnlyMemory <byte> content, byte[] secret, string credential)
{
string contentHash = null;
using (var alg = SHA256.Create())
{
// TODO (pri 3): ToArray should nopt be called here. Instead, TryGetArray, or PipelineContent should do hashing on the fly
contentHash = Convert.ToBase64String(alg.ComputeHash(content.ToArray()));
}
using (var hmac = new HMACSHA256(secret))
{
var host = uri.Host;
var pathAndQuery = uri.PathAndQuery;
string verb = method.ToString().ToUpper();
DateTimeOffset utcNow = DateTimeOffset.UtcNow;
var utcNowString = utcNow.ToString("r");
var stringToSign = $"{verb}\n{pathAndQuery}\n{utcNowString};{host};{contentHash}";
var signature = Convert.ToBase64String(hmac.ComputeHash(Encoding.ASCII.GetBytes(stringToSign))); // Calculate the signature
string signedHeaders = "date;host;x-ms-content-sha256"; // Semicolon separated header names
// TODO (pri 3): should date header writing be moved out from here?
request.AddHeader("Date", utcNowString);
request.AddHeader("x-ms-content-sha256", contentHash);
request.AddHeader("Authorization", $"HMAC-SHA256 Credential={credential}, SignedHeaders={signedHeaders}, Signature={signature}");
}
}
/// <summary>
/// Sends a JSON request.
/// </summary>
/// <typeparam name="T">Type of response.</typeparam>
/// <param name="verb">HTTP verb.</param>
/// <param name="url">Complete endpoint url.</param>
/// <param name="payload">Object to send.</param>
/// <returns></returns>
private IAsyncToken <HttpResponse <T> > SendRequest <T>(
HttpVerb verb,
string url,
object payload)
{
var data = Services.ResolveServiceData(url);
var service = data.Item1;
var resolvedUrl = data.Item2;
var headers = data.Item3;
Log(verb.ToString(), resolvedUrl, service, payload);
var token = new AsyncToken <HttpResponse <T> >();
byte[] bytes = null;
if (null != payload)
{
_serializer.Serialize(payload, out bytes);
}
var request = new WWW(
resolvedUrl,
bytes,
HeaderDictionary(headers));
_bootstrapper.BootstrapCoroutine(Wait(request, token));
return(token);
}
private string MakeRequestStream(Uri url, HttpVerb httpVerb, byte[] arr)
{
HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
request.Method = httpVerb.ToString();
if (httpVerb == HttpVerb.POST)
{
request.ContentType = "octect/stream";
request.ContentLength = arr.Length;
Stream requestStream = request.GetRequestStream();
requestStream.Write(arr, 0, arr.Length);
//requestStream.Close();
}
try
{
using (HttpWebResponse response
= request.GetResponse() as HttpWebResponse)
{
StreamReader reader
= new StreamReader(response.GetResponseStream());
return(reader.ReadToEnd());
}
}
catch
{
throw;
}
}
/// <summary>
/// Makes a restful call using supplied information.
/// </summary>
/// <typeparam name="TResult">Return type to convert response to (if you provide VoidResultType then null will be returned - basically a void call).</typeparam>
/// <param name="uri">Uri to make the request against.</param>
/// <param name="httpVerb">HTTP verb to use.</param>
/// <param name="body">Optional body object to send (use null if not needed).</param>
/// <param name="cookieJar">Optional cookie to use (use null if not needed).</param>
/// <param name="headerJar">Optional headers to use (use null if not needed).</param>
/// <param name="saveResponseHeadersAction">Optional action to use to save response headers (use null if not needed).</param>
/// <param name="contentType">Content type to use for request.</param>
/// <param name="acceptType">Content type to use for response.</param>
/// <param name="timeout">Timeout to use.</param>
/// <param name="serializer">Serializer to use.</param>
/// <returns>Converted response to the specified type.</returns>
public static TResult Call <TResult>(
Uri uri,
HttpVerb httpVerb,
object body,
CookieJar cookieJar,
HeaderJar headerJar,
Action <KeyValuePair <string, string>[]> saveResponseHeadersAction,
ContentType contentType,
ContentType acceptType,
TimeSpan timeout,
IStringSerializeAndDeserialize serializer)
where TResult : class
{
var httpVerbAsString = httpVerb.ToString().ToUpperInvariant();
return(Call <TResult>(
uri,
httpVerbAsString,
body,
cookieJar,
headerJar,
saveResponseHeadersAction,
contentType,
acceptType,
timeout,
serializer));
}
/// <summary>
/// 发送请求方法
/// </summary>
protected void MakeRequest()
{
if (string.IsNullOrWhiteSpace(url))
{
throw new ArgumentNullException("url is empty");
}
try
{
HttpWebRequest request = this.GetWebRequest(url);
request.CookieContainer = Cookies.Container;
request.Method = method.ToString().ToUpper();
request.AllowAutoRedirect = false;
if (method == HttpVerb.Get || method == HttpVerb.Head)
{
ExecuteRequestWithoutBody(request);
}
else
{
request.ContentType = body.GetContentType();
ExecuteRequestWithBody(request);
}
}
catch (WebException webEx)
{
action.Fail(webEx);
}
}
/// <summary>
/// Create a webrequest according to Endpoint
/// </summary>
/// <param name="EndPoint">It is url of object location</param>
/// <returns>Return a web request</returns>
protected WebRequest RequestBase(string EndPoint)
{
WebRequest request = WebRequest.Create(EndPoint);
request.Method = httpMethod.ToString();
return(request);
}
/// <summary>
/// Send Request with given class to serialized data into json format.
/// </summary>
/// <param name="EndPoint">URL To the web server</param>
/// <param name="httpMethod">HTTP Method of web request</param>
/// <param name="serializedClass">class of data for json serialization</param>
/// <returns></returns>
public ResponseMessage Request(string EndPoint, HttpVerb httpMethod, string serializedClass)
{
WebRequest request = RequestBase(EndPoint, httpMethod.ToString());
this.httpMethod = httpMethod;
string response = SendRequest(request, serializedClass).Result;
return(JsonConvert.DeserializeObject <ResponseMessage>(response));
}
public static HttpWebRequest CreateJsonHttpWebRequest(Uri uri, HttpVerb verb, string username, string password)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri.AbsoluteUri);
JSONSerializer.SetBasicAuthHeader(request, username, password);
request.Method = verb.ToString();
request.ContentType = "application/json; charset=utf-8";
return(request);
}
/// <summary>
/// 根据Url获取http响应
/// </summary>
/// <param name="url">url地址</param>
/// <param name="method">Http方法</param>
/// <returns>Http响应消息</returns>
public static HttpWebResponse GetUrlResponse(string url, HttpVerb method)
{
HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);
req.Method = method.ToString();
req.ContentType = "application/json;charset=UTF-8";//text/plain; charset=utf-8
HttpWebResponse res = (HttpWebResponse)req.GetResponse();
return(res);
}
/// <summary>
/// Configurations the HTTP request message.
/// </summary>
/// <param name="httpRequestMessage">The HTTP request message.</param>
/// <param name="serviceUri">The service URI.</param>
/// <param name="httpVerb">The HTTP verb.</param>
/// <param name="httpContentType">Type of the HTTP content.</param>
/// <param name="content">The content.</param>
/// <returns></returns>
public static HttpRequestMessage ConfigHttpRequestMessage(this HttpRequestMessage httpRequestMessage, Uri serviceUri, HttpVerb httpVerb, string httpContentType, StringContent content)
{
content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse(httpContentType);
httpRequestMessage.Content = content;
httpRequestMessage.Method = new HttpMethod(httpVerb.ToString());
httpRequestMessage.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse(httpContentType));
httpRequestMessage.RequestUri = serviceUri;
return(httpRequestMessage);
}
private HttpWebRequest CreateRequest(HttpVerb verb)
{
HttpWebRequest req = (HttpWebRequest)HttpWebRequest.Create(apiUri);
req.Method = verb.ToString();
req.ContentType = "text/json";
SetRequestHeaders(req);
return(req);
}
private string MakeResponse(string sessionToken, HttpVerb method, string parameters, string postData)
{
string _apiUrlBase = Settings.ApiUrlBase;
var requestedUrl = _apiUrlBase + parameters;
var webRequest = (HttpWebRequest)WebRequest.Create(requestedUrl);
webRequest.Method = method.ToString();
webRequest.ContentType = "application/json";
// webRequest.ContentLength = 0;
webRequest.Accept = "application/json; charset=utf-8";
if (!string.IsNullOrEmpty(sessionToken))
{
webRequest.Headers.Add("X-SessionToken", sessionToken);
}
byte[] byteArray = Encoding.UTF8.GetBytes(postData);
Stream dataStream = webRequest.GetRequestStream();
dataStream.Write(byteArray, 0, byteArray.Length);
dataStream.Close();
HttpWebResponse response;
try
{
response = (HttpWebResponse)webRequest.GetResponse();
}
catch (Exception ex)
{
return(null);
}
if (response.StatusCode != HttpStatusCode.OK)
{
throw new ApplicationException($"Request failed. Received HTTP {response.StatusCode}");
}
using (var responseStream = response.GetResponseStream())
{
if (responseStream != null)
{
using (var reader = new StreamReader(responseStream))
{
var respone = reader.ReadToEnd();
Console.Write(respone);
return(respone);
}
}
}
return("");
}
/// <summary>
/// Sends an HTTP request to the server and handles the response.
/// </summary>
/// <param name="verb">The HTTP verb to use for the request.</param>
/// <param name="urlParameter">Any URL parameters to send.</param>
/// <param name="bodyParameter">Any body parameters to send.</param>
/// <returns>The HTTP Response information.</returns>
/// <exception cref="System.NotImplementedException">Thrown when the HTTP verb given has not been
/// implemented yet.</exception>
/// <exception cref="System.InvalidOperationException">Thrown when the request was already sent by
/// the client instance or the URI is invalid.</exception>
public async Task <HttpResponse> Send(HttpVerb verb, IHttpRequestParameter urlParameter = null, IHttpRequestParameter bodyParameter = null)
{
string fullRequestUrl = $"{_requestUrl}{ConstructParameterString(urlParameter)}";
HttpContent content = new StringContent(ConstructParameterString(bodyParameter));
HttpResponseMessage responseMessage = null;
try
{
switch (verb)
{
case HttpVerb.DELETE:
responseMessage = await _httpClient.DeleteAsync(fullRequestUrl);
break;
case HttpVerb.GET:
responseMessage = await _httpClient.GetAsync(fullRequestUrl);
break;
case HttpVerb.POST:
responseMessage = await _httpClient.PostAsync(fullRequestUrl, content);
break;
case HttpVerb.PUT:
responseMessage = await _httpClient.PutAsync(fullRequestUrl, content);
break;
default:
throw new NotImplementedException($"HTTP Verb not implemented: {verb.ToString()}");
}
}
catch (HttpRequestException ex)
{
string error = ExceptionUtilities.GetAllExceptionMessages(ex);
return(new HttpResponse(
fullRequestUrl,
System.Net.HttpStatusCode.InternalServerError,
error,
verb
));
}
string responseBody = await responseMessage.Content.ReadAsStringAsync();
return(new HttpResponse(
fullRequestUrl,
responseMessage.StatusCode,
responseBody,
verb
));
}
/// <summary>
/// 记录确认状态时候的信息
/// </summary>
/// <param name="exception"></param>
/// <param name="url"></param>
/// <param name="httpVerb"></param>
/// <returns></returns>
public static ExceptionData LogEnsureSuccessed(Exception exception, string url, HttpVerb httpVerb)
{
var ed = new ExceptionData {
Exception = exception, Message = "确认Http状态码时异常"
};
ed.Data.Add("url", url);
ed.Data.Add("httpverb", httpVerb.ToString());
ed.Data.Add("type", "ensuresuccessed");
return(ed);
}
public static void RegisterRoute(string route, HttpVerb verb)
{
if (routes.ContainsKey(route))
{
return;
}
Console.WriteLine("Added route " + route + " for verb " + verb.ToString());
routes.Add(route, verb);
}
/// <summary>
/// 记录确认状态时候的信息
/// </summary>
/// <param name="exception"></param>
/// <param name="url"></param>
/// <param name="httpVerb"></param>
/// <returns></returns>
public static ExceptionData LogRequestTimeout(Exception exception, string url, HttpVerb httpVerb)
{
var ed = new ExceptionData {
Exception = exception, Message = "请求时候的超时异常"
};
ed.Data.Add("url", url);
ed.Data.Add("httpverb", httpVerb.ToString());
ed.Data.Add("type", "request");
ed.Data.Add("errorType", "timeout");
return(ed);
}
public HttpWebRequest CreateRequest(HttpVerb verb, string action, bool needsAuthentication = true)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Host + action);
request.Method = verb.ToString().ToUpper();
if (needsAuthentication)
{
request.Headers[HttpRequestHeader.Authorization] = "Bearer " + AccessToken;
}
return(request);
}
private static void MakeRequest(string contentType, HttpVerb method, string url, object parameters, Action <WebHeaderCollection, Stream> successCallback, Action <WebException> failCallback)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters object cannot be null");
}
if (string.IsNullOrWhiteSpace(url))
{
throw new ArgumentException("url is empty");
}
try
{
var request = (HttpWebRequest)WebRequest.Create(new Uri(url));
request.CookieContainer = cookies;
request.Method = method.ToString();
switch (method)
{
case HttpVerb.Delete:
case HttpVerb.Post:
case HttpVerb.Put:
case HttpVerb.Patch:
request.ContentType = contentType;
request.BeginGetRequestStream(callbackResult =>
{
var tmprequest = (HttpWebRequest)callbackResult.AsyncState;
var postStream = tmprequest.EndGetRequestStream(callbackResult);
var postbody = Utils.SerializeQueryString(parameters);
var byteArray = System.Text.Encoding.UTF8.GetBytes(postbody);
postStream.Write(byteArray, 0, byteArray.Length);
postStream.Flush();
postStream.Dispose();
tmprequest.BeginGetResponse(ProcessCallback(successCallback, failCallback), tmprequest);
}, request);
break;
case HttpVerb.Get:
case HttpVerb.Head:
request.BeginGetResponse(ProcessCallback(successCallback, failCallback), request);
break;
default:
throw new ArgumentOutOfRangeException(nameof(method), method, null);
}
}
catch (WebException webEx)
{
failCallback(webEx);
}
}
private void AddMethod(Effect effect, HttpVerb verb, string resource, ICollection <Condition> conditions = null)
{
if (verb == null)
{
throw new ArgumentNullException(nameof(verb));
}
if (resource == null)
{
throw new ArgumentNullException(nameof(resource));
}
if (!_pathRegex.IsMatch(resource))
{
throw new Exception($"Invalid resource path: {resource}. Path should match {_pathRegex}");
}
var cleanedResource = resource.First() == '/' ? resource.Substring(1) : resource;
ApiGatewayArn arn = new ApiGatewayArn
{
RestApiId = _restApiId,
Region = _region,
Stage = _stage,
AwsAccountId = AwsAccountId,
Verb = verb.ToString(),
Resource = cleanedResource
};
switch (effect)
{
case Effect.Deny:
_denyMethods.Add(new Method
{
ArnResource = arn.ToString(),
Conditions = ConditionsToDictionary(conditions)
});
return;
case Effect.Allow:
_allowMethods.Add(new Method
{
ArnResource = arn.ToString(),
Conditions = ConditionsToDictionary(conditions)
});
return;
}
}
/// <summary>
/// Sets up the HttpContext objects to simulate a request.
/// </summary>
/// <param name="url"></param>
/// <param name="httpVerb"></param>
/// <param name="formVariables"></param>
/// <param name="headers"></param>
protected virtual HttpSimulator SimulateRequest(Uri url, HttpVerb httpVerb, NameValueCollection formVariables, NameValueCollection headers)
{
HttpContext.Current = null;
ParseRequestUrl(url);
if (this.responseWriter == null)
{
this.builder = new StringBuilder();
this.responseWriter = new StringWriter(builder);
}
SetHttpRuntimeInternals();
string query = ExtractQueryStringPart(url);
if (formVariables != null)
_formVars.Add(formVariables);
if (_formVars.Count > 0)
httpVerb = HttpVerb.POST; //Need to enforce this.
if (headers != null)
_headers.Add(headers);
this.workerRequest = new SimulatedHttpRequest(ApplicationPath, PhysicalApplicationPath, PhysicalPath, Page, query, this.responseWriter, host, port, httpVerb.ToString());
this.workerRequest.Form.Add(_formVars);
this.workerRequest.Headers.Add(_headers);
if (_referer != null)
this.workerRequest.SetReferer(_referer);
InitializeSession();
InitializeApplication();
#region Console Debug INfo
Console.WriteLine("host: " + host);
Console.WriteLine("virtualDir: " + applicationPath);
Console.WriteLine("page: " + localPath);
Console.WriteLine("pathPartAfterApplicationPart: " + _page);
Console.WriteLine("appPhysicalDir: " + physicalApplicationPath);
Console.WriteLine("Request.Url.LocalPath: " + HttpContext.Current.Request.Url.LocalPath);
Console.WriteLine("Request.Url.Host: " + HttpContext.Current.Request.Url.Host);
Console.WriteLine("Request.FilePath: " + HttpContext.Current.Request.FilePath);
Console.WriteLine("Request.Path: " + HttpContext.Current.Request.Path);
Console.WriteLine("Request.RawUrl: " + HttpContext.Current.Request.RawUrl);
Console.WriteLine("Request.Url: " + HttpContext.Current.Request.Url);
Console.WriteLine("Request.Url.Port: " + HttpContext.Current.Request.Url.Port);
Console.WriteLine("Request.ApplicationPath: " + HttpContext.Current.Request.ApplicationPath);
Console.WriteLine("Request.PhysicalPath: " + HttpContext.Current.Request.PhysicalPath);
Console.WriteLine("HttpRuntime.AppDomainAppPath: " + HttpRuntime.AppDomainAppPath);
Console.WriteLine("HttpRuntime.AppDomainAppVirtualPath: " + HttpRuntime.AppDomainAppVirtualPath);
Console.WriteLine("HostingEnvironment.ApplicationPhysicalPath: " + HostingEnvironment.ApplicationPhysicalPath);
Console.WriteLine("HostingEnvironment.ApplicationVirtualPath: " + HostingEnvironment.ApplicationVirtualPath);
#endregion
return this;
}
private static string GenerateSignature(bool multipart, Dictionary<string, object> parameters, Uri requestUri, AccessTokens tokens, HttpVerb verb )
{
IEnumerable<KeyValuePair<string, object>> nonSecretParameters = null;
if (multipart)
{
nonSecretParameters = (from p in parameters
where (!Common.SecretParameters.Contains(p.Key) && p.Key.StartsWith("oauth_"))
select p);
}
else
{
nonSecretParameters = (from p in parameters
where (!Common.SecretParameters.Contains(p.Key))
select p);
}
Uri urlForSigning = requestUri;
// Create the base string. This is the string that will be hashed for the signature.
string signatureBaseString = string.Format(
CultureInfo.InvariantCulture,
"{0}&{1}&{2}",
verb.ToString().ToUpper(CultureInfo.InvariantCulture),
UrlUtility.UrlEncode(UrlUtility.NormalizeUrl(urlForSigning)),
UrlUtility.UrlEncode(nonSecretParameters));
// Create our hash key (you might say this is a password)
string key = string.Format(
CultureInfo.InvariantCulture,
"{0}&{1}",
UrlUtility.UrlEncode(tokens.ConsumerSecret),
UrlUtility.UrlEncode(tokens.AccessTokenSecret));
// Generate the hash
HMACSHA1 hmacsha1 = new HMACSHA1(Encoding.UTF8.GetBytes(key));
byte[] signatureBytes = hmacsha1.ComputeHash(Encoding.UTF8.GetBytes(signatureBaseString));
return Convert.ToBase64String(signatureBytes);
}
