private RestResult CallMethod(ArraySegment <byte> content, RestMethod method, IAccount account, IUsers users)
{
switch (method.Method)
{
case RestMethods.GetServerVersion:
return(GetServerVersion());
case RestMethods.GetRole:
return(GetRole());
case RestMethods.GetServerOptions:
return(GetServerOptions());
case RestMethods.PutServerOptions:
return(PutServerOptions(content));
case RestMethods.ValidateServerOptions:
return(ValidateServerOptions(content));
case RestMethods.GetAccountsForSuper:
return(GetAccounts());
case RestMethods.PostAccount:
return(PostAccount(content));
case RestMethods.GetAccount:
return(GetAccount());
case RestMethods.PutAccount:
return(PutAccount(content));
case RestMethods.DeleteAccount:
return(DeleteAccount());
}
if (account == null)
{
throw new Exception(@"Account not found");
}
switch (method.Method)
{
case RestMethods.GetUserz:
return(GetUserz(account));
case RestMethods.GetUsers:
return(GetUsers(account, users));
case RestMethods.PostUser:
return(PostUser(account, users, content));
case RestMethods.PutUser:
return(PutUser(account, users, content));
case RestMethods.DeleteUser:
return(DeleteUser(account, users));
}
throw new NotImplementedException(@"Restapi.CallMethod for " + method.Method.ToString() + " is not implemeted");
}
public static async Task <string> CallRestServiceAsync(Format restType, RestMethod restConstant, string authorizationHeader, Uri requestUri, Guid identityWorkID,
Guid instanceID, params object[] parameters)
{
var jsonObject = GetParameters(parameters);
return(await CallServiceAsync(restType, restConstant, authorizationHeader, requestUri, jsonObject.ToString(), "", identityWorkID, instanceID));
}
public IRouteTreeBranch AddBranch(string endpoint, RestMethod logic)
{
IRouteTreeBranch branch = new Branch(this)
{
Logic = logic
};
if (endpoint.Equals("*"))
{
_wildcardBranch = branch;
}
else if (endpoint.Equals("**"))
{
_greedyBranch = new GreedyBranch(this)
{
Logic = logic
};
branch = _greedyBranch;
}
else if (endpoint.StartsWith("{"))
{
endpoint = String.Format("^{0}$", endpoint.Trim('{', '}'));
_regexBranches[new Regex(endpoint)] = branch;
}
else
{
_literalBranches[endpoint] = branch;
}
return(branch);
}
public static RestServiceException Unavailable(
RestMethod method, string baseUrl, string resource, Exception ex)
{
return new RestServiceException($"Currently unavailable: {baseUrl}",
HttpStatusCode.ServiceUnavailable,
method, baseUrl, resource, ex);
}
/// <summary>
/// Add a stream handler for the designated HTTP method and path prefix.
/// If the handler is not enabled, the request is ignored. If the path
/// does not start with the REST prefix, it is added. If method-qualified
/// path has not already been registered, the method is added to the active
/// handler table.
/// </summary>
public void AddStreamHandler(string httpMethod, string path, RestMethod method)
{
if (!IsEnabled)
{
return;
}
if (!path.StartsWith(Rest.Prefix))
{
path = String.Format("{0}{1}", Rest.Prefix, path);
}
path = String.Format("{0}{1}{2}", httpMethod, Rest.UrlMethodSeparator, path);
// Conditionally add to the list
if (!streamHandlers.ContainsKey(path))
{
streamHandlers.Add(path, new RestStreamHandler(httpMethod, path, method));
Rest.Log.DebugFormat("{0} Added handler for {1}", MsgId, path);
}
else
{
Rest.Log.WarnFormat("{0} Ignoring duplicate handler for {1}", MsgId, path);
}
}
public void RegisterCaps(IRegionClientCapsService service)
{
m_service = service;
m_gridService = service.Registry.RequestModuleInterface <IGridService>();
IConfig config =
service.ClientCaps.Registry.RequestModuleInterface <ISimulationBase>().ConfigSource.Configs["MapCaps"];
if (config != null)
{
m_allowCapsMessage = config.GetBoolean("AllowCapsMessage", m_allowCapsMessage);
}
#if (!ISWIN)
RestMethod method = delegate(string request, string path, string param,
OSHttpRequest httpRequest, OSHttpResponse httpResponse)
{
return(MapLayerRequest(request, path, param, httpRequest, httpResponse, m_service.AgentID));
};
#else
RestMethod method =
(request, path, param, httpRequest, httpResponse) =>
MapLayerRequest(request, path, param, httpRequest, httpResponse,
m_service.AgentID);
#endif
m_service.AddStreamHandler("MapLayer",
new RestStreamHandler("POST", m_service.CreateCAPS("MapLayer", m_mapLayerPath),
method));
m_service.AddStreamHandler("MapLayerGod",
new RestStreamHandler("POST", m_service.CreateCAPS("MapLayerGod", m_mapLayerPath),
method));
}
public async Task <RestResponse <T> > SendAsync <T>(RestMethod method, string url, string value = null)
{
RestResponse <T> response = new RestResponse <T>(await SendAsync(method, url, value));
response.Data = JsonConvert.DeserializeObject <T>(response.Body);
return(response);
}
private RestResponse DoRequest(RestMethod method, string resource, object requestData = null, bool json = true)
{
var request = new RestRequest
{
IsJson = json,
Method = Enum.GetName(typeof(RestMethod), method),
Url = string.Format("{0}{1}", _endpointUri, resource)
};
request.Headers = new Dictionary <string, string>
{
{ "api-expires", Expires.ToString() },
{ "api-key", ApiKey },
{ "api-signature", HttpHelper.CalculateSignature(_endpointUri, Expires, ApiSecret, request.Method, resource, requestData) }
};
if (method != RestMethod.GET)
{
if (requestData != null)
{
var queryDataString = request.IsJson ? JsonConvert.SerializeObject(requestData) : BuildQueryData(requestData.ToStringDicrionary());
var queryDataBytes = Encoding.UTF8.GetBytes(queryDataString);
request.Data = queryDataBytes;
}
}
return(HttpHelper.RawHttpRestQuery(request));
}
public static RestServiceException Unauthorized(
RestMethod method, string baseUrl, string resource, Exception ex)
{
return new RestServiceException("Attempted to authenticate, but failed.",
HttpStatusCode.Unauthorized,
method, baseUrl, resource, ex);
}
public RestRequestHandler GetRestRequestHandler(RestDigestibleUri uri, RestMethod method, RestRequestParameters parameters)
{
HandleParameters(uri, parameters);
if (uri.IsLastNode || this is WildCardUriRequestHandlerNode)
{
switch (method)
{
case RestMethod.GET:
return(HttpGetRequestHandler);
case RestMethod.POST:
return(HttpPostRequestHandler);
default:
throw new ApplicationException("Unknown REST method.");
}
}
uri.NextNode();
foreach (var childNode in ChildNodes)
{
if (childNode.MatchesUriPattern(uri))
{
return(childNode.GetRestRequestHandler(uri, method, parameters));
}
}
return(null);
}
public static RestServiceException BadRequest(
string specificMsg, RestMethod method, string baseUrl, string resource, Exception ex)
{
return(new RestServiceException(specificMsg,
HttpStatusCode.BadRequest,
method, baseUrl, resource, ex));
}
public static RestServiceException Unresolvable(
RestMethod method, string baseUrl, string resource, Exception ex)
{
return new RestServiceException($"Unresolvable: “{baseUrl}”",
HttpStatusCode.ServiceUnavailable, //this should be WebExceptionStatus.NameResolutionFailure
method, baseUrl, resource, ex);
}
public static RestServiceException Unavailable(
RestMethod method, string baseUrl, string resource, Exception ex)
{
return(new RestServiceException($"Currently unavailable: {baseUrl}",
HttpStatusCode.ServiceUnavailable,
method, baseUrl, resource, ex));
}
public static RestServiceException Unauthorized(
RestMethod method, string baseUrl, string resource, Exception ex)
{
return(new RestServiceException("Attempted to authenticate, but failed.",
HttpStatusCode.Unauthorized,
method, baseUrl, resource, ex));
}
public static RestServiceException Unresolvable(
RestMethod method, string baseUrl, string resource, Exception ex)
{
return(new RestServiceException($"Unresolvable: “{baseUrl}”",
HttpStatusCode.ServiceUnavailable, //this should be WebExceptionStatus.NameResolutionFailure
method, baseUrl, resource, ex));
}
public static InvalidSslRestException InvalidSsl(
RestMethod method, string baseUrl, string resource, Exception ex)
{
return(new InvalidSslRestException("SSL certificate is invalid.",
HttpStatusCode.Forbidden,
method, baseUrl, resource, ex));
}
public static RestServiceException InternalServer(
string shortMsg, RestMethod method, string baseUrl, string resource, Exception ex)
{
return(new RestServiceException(shortMsg,
HttpStatusCode.InternalServerError,
method, baseUrl, resource, ex));
}
public static RestServiceException NotFound(
RestMethod method, string baseUrl, string resource, Exception ex)
{
return(new RestServiceException("Requested resource does not exist on the server.",
HttpStatusCode.NotFound,
method, baseUrl, resource, ex));
}
public RequestShim(string resource, RestMethod method)
{
this.Method = method;
this.Resource = resource;
this.Cookies = new Dictionary <string, string>();
this.Parameters = new Dictionary <string, object>();
}
public static InvalidSslRestException InvalidSsl(
RestMethod method, string baseUrl, string resource, Exception ex)
{
return new InvalidSslRestException("SSL certificate is invalid.",
HttpStatusCode.Forbidden,
method, baseUrl, resource, ex);
}
public RequestShim(string resource, RestMethod method)
{
this.Method = method;
this.Resource = resource;
this.Cookies = new Dictionary<string, string>();
this.Parameters = new Dictionary<string, object>();
}
public static async Task <InvokeResult <T> > Invoke <T>(RestMethod method, string uri, string data)
{
SetXAPIKey();
switch (method)
{
case RestMethod.GET:
string content = await InvokeGet(uri);
InvokeResult <T> res = null;
try
{
res = JsonConvert.DeserializeObject <InvokeResult <T> >(content);
return(res);
}
catch (Exception e)
{
SubsystemUtils.Instance.Err("Json deserialization is failed, " + e.Message);
SubsystemUtils.Instance.Err("------------------------------------------------------------------");
SubsystemUtils.Instance.Err(content);
SubsystemUtils.Instance.Err("------------------------------------------------------------------");
res = null;
}
return(res);
}
return(null);
}
public async Task <Concert> GetConcertsDetailsAsync(RestMethod restMethod)
{
string result = await HttpRequestWithToken(restMethod.Route,
restMethod.MethodType.ToHttpMethod());
return(JsonConvert.DeserializeObject <Concert>(result));
}
private static Method TranslateRestMethod(RestMethod method)
{
switch (method)
{
case RestMethod.POST:
return(Method.POST);
case RestMethod.PUT:
return(Method.PUT);
case RestMethod.DELETE:
return(Method.DELETE);
case RestMethod.GET:
return(Method.GET);
case RestMethod.HEAD:
return(Method.HEAD);
case RestMethod.OPTIONS:
return(Method.OPTIONS);
default:
throw new Exception("Unrecognized REST method");
}
}
public ParameterUriRequestHandlerNode(RestDigestibleUri uri, RestMethod method, RestRequestHandler handler)
{
m_parameterPattern = uri.GetCurrentNode();
m_parameterName = m_parameterPattern.Replace("]", string.Empty).Replace("[", string.Empty);
AddRestRequestHandler(uri, method, handler);
}
public byte[] RestCallRaw(string urlBase, string url, RestMethod method, IEnumerable <RestParam> parameters = null, object body = null)
{
var response = GetRestResponse(urlBase, url, method, parameters, body);
CheckStatusCode(response);
return(response.RawBytes);
}
public IRestResponse GetRestResponse(string urlBase, string url, RestMethod method, IEnumerable <RestParam> parameters = null, object body = null)
{
var client = new RestClient(urlBase);
var request = BuildRestRequest(url, method, parameters, body);
return(client.Execute(request));
}
public static RestServiceException Conflict(
string conflictMsg, RestMethod method, string baseUrl, string resource, Exception ex)
{
return(new RestServiceException(conflictMsg,
HttpStatusCode.Conflict,
method, baseUrl, resource, ex));
}
protected virtual string ParseREST(string request, string path, string method)
{
string response;
string requestKey = String.Format("{0}: {1}", method, path);
string bestMatch = String.Empty;
foreach (string currentKey in m_restHandlers.Keys)
{
if (requestKey.StartsWith(currentKey))
{
if (currentKey.Length > bestMatch.Length)
{
bestMatch = currentKey;
}
}
}
RestMethodEntry restMethodEntry;
if (m_restHandlers.TryGetValue(bestMatch, out restMethodEntry))
{
RestMethod restMethod = restMethodEntry.RestMethod;
string param = path.Substring(restMethodEntry.Path.Length);
response = restMethod(request, path, param);
}
else
{
response = String.Empty;
}
return(response);
}
public static RestServiceException Forbidden(
RestMethod method, string baseUrl, string resource, Exception ex)
{
var msg = $"Forbidden [{method}] {resource}";
return new RestServiceException(msg,
HttpStatusCode.Forbidden,
method, baseUrl, resource, ex);
}
public RestRequest(RestMethod method, string path, string requestBody, ContentType contentType, Dictionary <string, string> additionalHeaders)
{
_method = method;
_path = path;
_requestBody = requestBody;
_contentType = contentType;
_additionalHeaders = additionalHeaders;
}
public VerbNotSupportedProtocolException(RestMethod calledMethod, ReadOnlyCollection <RestMethod> allowedMethods, Exception innerException) : base(string.Format(CultureInfo.InvariantCulture, "The method {0} is not supported for the specified resource. Refer to 'Allow' response header for the list of supported methods.", new object[] { calledMethod }), innerException)
{
NephosAssertionException.Assert(calledMethod != RestMethod.Unknown);
NephosAssertionException.Assert(allowedMethods != null);
NephosAssertionException.Assert(allowedMethods.Count > 0);
this.calledMethod = calledMethod;
this.allowedMethods = allowedMethods;
}
public void Register(RestMethod method, string uri, Action <Request, Response> handler)
{
//check if running
// if (IsListening)
// throw new ApplicationException("RestService is listening, cannot register new methods");
this.server.m_requestTree.AddRequestHandler(uri, method, handler);
}
/// <summary>
/// Constructor for HttpCall
/// </summary>
/// <param name="method"></param>
/// <param name="headers"></param>
/// <param name="url"></param>
/// <param name="requestBody"></param>
/// <param name="contentType"></param>
public HttpCall(RestMethod method, Dictionary <string, string> headers, string url, string requestBody, ContentType contentType)
{
_method = method;
_headers = headers;
_url = url;
_requestBody = requestBody;
_contentType = contentType;
}
/// <summary>
/// On View loaded event of caliburn
/// </summary>
/// <param name="view"></param>
protected override void OnViewLoaded(object view)
{
base.OnViewLoaded(view);
//Load rest API table
SelectedRestMethod = new RestMethod();
SelectedContentItem = SelectedRestMethod.ContentType;
RestMethodList = Test.TestPackage.RestMethods;
}
private static async Task <string> CallServiceAsync(Format restType, RestMethod restConstant, string authorizationHeader, Uri requestUri, string serializedParameters, string TransactionKey = "",
Guid?identityWorkID = null, Guid?instanceID = null)
{
HttpClient client = new HttpClient();
client.Timeout = TimeSpan.FromMinutes(40);
string result = string.Empty;
ConfigureEndPoints(requestUri);
HttpRequestMessage reqmsg = new HttpRequestMessage();
reqmsg.RequestUri = requestUri;
reqmsg.Method = new HttpMethod(restConstant.ToString("g"));
reqmsg.Headers.TryAddWithoutValidation(ServiceHelperConstants.authorizationHeaderTitle, authorizationHeader);
reqmsg.Headers.TryAddWithoutValidation(ServiceHelperConstants.transactionHeaderTitle, TransactionKey);
if (identityWorkID != null)
{
reqmsg.Headers.TryAddWithoutValidation("companyid", identityWorkID.ToString());
}
if (instanceID != null)
{
reqmsg.Headers.TryAddWithoutValidation("instanceid", instanceID.ToString());
}
if (reqmsg.Method == HttpMethod.Post || reqmsg.Method == HttpMethod.Put)
{
reqmsg.Content = new StringContent(serializedParameters, Encoding.UTF8, resolveContentType(restType));
}
var response = await client.SendAsync(reqmsg, HttpCompletionOption.ResponseContentRead);
result = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
if (!String.IsNullOrEmpty(result))
{
try
{
var contentHelper = Newtonsoft.Json.JsonConvert.DeserializeObject <ContentHelper>(result);
manageWebException(contentHelper);
}
catch (Newtonsoft.Json.JsonReaderException ex)
{
throw new CallRestException().getDefault(ex.TargetSite, result, (int)response.StatusCode);
}
}
else
{
throw new CallRestException().getDefault(MethodBase.GetCurrentMethod(), "No se pudo conectar al servicio.", (int)response.StatusCode);
}
}
else
{
result = await response.Content.ReadAsStringAsync();
}
return(result);
}
internal static IRequestShim Make(string resource, RestMethod method, D7UserSession sess, string usr, string pwd)
{
var req = new RequestShim(resource, method);
req.UserName = usr;
req.Password = pwd;
req.CsrfToken = sess.token;
req.Cookies.Add(sess.session_name, sess.sessid);
return req;
}
/// <summary>
/// Registers the given method for the given endpoint
/// </summary>
/// <param name="endpoint">The endpoint to register with the logic</param>
/// <param name="logic">The logic to use for the endpoint</param>
public void AddRoute(string endpoint, RestMethod logic)
{
var branch = _routeTree.Trunk;
var components = endpoint.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var component in components) {
branch = branch.GetChild(component, true);
}
branch.Logic = logic;
}
public static RestServiceException Unknown(string clue,
RestMethod method, string baseUrl, string resource, Exception inr)
{
var msg = "Unknown REST Service exception."
+ L.f + "clue :" + clue
+ L.f + "type :" + inr.GetType().Name;
return new RestServiceException(msg,
HttpStatusCode.InternalServerError,
method, baseUrl, resource, inr);
}
private RestSharp.Portable.Method Unshim(RestMethod restMethod)
{
switch (restMethod)
{
case RestMethod.Get : return RestSharp.Portable.Method.GET;
case RestMethod.Post : return RestSharp.Portable.Method.POST;
case RestMethod.Put : return RestSharp.Portable.Method.PUT;
case RestMethod.Delete : return RestSharp.Portable.Method.DELETE;
default:
throw Error.Unsupported(restMethod, "RestMethod");
}
}
public bool AddRestHandler(string method, string path, RestMethod handler)
{
string methodKey = String.Format("{0}: {1}", method, path);
if (!this.m_restHandlers.ContainsKey(methodKey))
{
this.m_restHandlers.Add(methodKey, new RestMethodEntry( path, handler ));
return true;
}
//must already have a handler for that path so return false
return false;
}
public RestServiceException(string msg,
HttpStatusCode code,
RestMethod method,
string baseUrl,
string resource,
Exception inr = null)
: base(msg, inr)
{
this.Code = code;
this.Method = method;
this.BaseUrl = baseUrl;
this.Resource = resource;
}
private RestRequest CreateRequest(RestMethod method, string endpoint, object data = null, QueryParamList parameters = null, string factoryId = null)
{
var access = _apiAccess;
var request = new RestRequest();
request.Method = method;
request.Endpoint = endpoint;
request.TimeStamp = DateTime.Now;
request.FactoryId = factoryId;
request.Data = data;
request.Params = parameters;
request.ApiHost = access.Host;
request.ApiVersion = access.Version;
request.ApiPort = access.Port;
request.AccessKey = access.AccessKey;
request.SecretKey = access.SecretKey;
return request;
}
/// <summary>
/// On View loaded event of caliburn
/// </summary>
/// <param name="view"></param>
protected override void OnViewLoaded(object view)
{
base.OnViewLoaded(view);
//Load rest API table
SelectedRestMethod = new RestMethod();
SelectedContentItem = SelectedRestMethod.ContentType;
RestMethodList = Test.TestPackage.RestMethods;
}
private void ResetView()
{
IsExisting = false;
//_isExisting = false;
_existingGuid = string.Empty;
SelectedRestMethod = new RestMethod();
SelectedContentItem = SelectedRestMethod.ContentType;
NotifyOfPropertyChange(() => RestMethodList);
}
/// <summary>
/// Add a stream handler for the designated HTTP method and path prefix.
/// If the handler is not enabled, the request is ignored. If the path
/// does not start with the REST prefix, it is added. If method-qualified
/// path has not already been registered, the method is added to the active
/// handler table.
/// </summary>
public void AddStreamHandler(string httpMethod, string path, RestMethod method)
{
if (!IsEnabled)
{
return;
}
if (!path.StartsWith(Rest.Prefix))
{
path = String.Format("{0}{1}", Rest.Prefix, path);
}
path = String.Format("{0}{1}{2}", httpMethod, Rest.UrlMethodSeparator, path);
// Conditionally add to the list
if (!streamHandlers.ContainsKey(path))
{
streamHandlers.Add(path, new RestStreamHandler(httpMethod, path, method));
Rest.Log.DebugFormat("{0} Added handler for {1}", MsgId, path);
}
else
{
Rest.Log.WarnFormat("{0} Ignoring duplicate handler for {1}", MsgId, path);
}
}
public IRouteTreeBranch AddBranch(string endpoint, RestMethod logic)
{
throw new NotSupportedException(); // It doesn't make sense to add a child to a greedy branch
}
public IRouteTreeBranch AddBranch(string endpoint, RestMethod logic)
{
IRouteTreeBranch branch = new Branch(this) { Logic = logic };
if (endpoint.Equals("*")) {
_wildcardBranch = branch;
} else if (endpoint.Equals("**")) {
_greedyBranch = new GreedyBranch(this) { Logic = logic };
branch = _greedyBranch;
} else if (endpoint.StartsWith("{")) {
endpoint = String.Format("^{0}$", endpoint.Trim('{', '}'));
_regexBranches[new Regex(endpoint)] = branch;
} else {
_literalBranches[endpoint] = branch;
}
return branch;
}
/// <summary>
/// Add a REST stream handler to the underlying HTTP server.
/// </summary>
/// <param name="httpMethod">GET/PUT/POST/DELETE or
/// similar</param>
/// <param name="path">URL prefix</param>
/// <param name="method">RestMethod handler doing the actual work</param>
public virtual void AddRestStreamHandler(string httpMethod, string path, RestMethod method)
{
if (!IsEnabled) return;
if (!path.StartsWith(_prefix))
{
path = String.Format("{0}{1}", _prefix, path);
}
RestStreamHandler h = new RestStreamHandler(httpMethod, path, method);
_httpd.AddStreamHandler(h);
_handlers.Add(h);
m_log.DebugFormat("{0} Added REST handler {1} {2}", MsgID, httpMethod, path);
}
public static RestMethodResponse InvokeRestApi(RestMethod r, bool trackTime)
{
bool isMethodAdded = false;
string token = Guid.NewGuid().ToString();
RestMethodResponse webResponse = new RestMethodResponse();
try
{
var webRequest = (HttpWebRequest)WebRequest.Create(r.Url);
webRequest.ContentType = r.ContentType;
webRequest.ContentLength = 0;
webRequest.Method = r.Type.ToString().ToUpper();
webRequest.AllowAutoRedirect = true;
//set headers
if (r.SelectedHeaderTab == 0)
{
foreach (var kv in r.Headers)
{
webRequest.Headers.Add(string.Format("{0}:{1}", kv.Key, kv.Value));
}
}
else
{
if (!string.IsNullOrEmpty(r.HeaderText))
{
var headers = r.HeaderText.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
foreach (var h in headers.Where(h => h.IndexOf(":", StringComparison.Ordinal) > -1))
{
webRequest.Headers.Add(h);
}
}
}
//set post data
var postData = r.SelectedPayloadTab == 0
? string.Join("&", r.PayloadValues.Select(kv => string.Format("{0}={1}", kv.Key, kv.Value)).ToArray())
: r.PayloadText.Replace(Environment.NewLine, " ");
if (!string.IsNullOrEmpty(postData) && (r.Type == RequestType.Post || r.Type == RequestType.Put))
{
var bytes = Encoding.GetEncoding("iso-8859-1").GetBytes(postData);
webRequest.ContentLength = bytes.Length;
using (var writeStream = webRequest.GetRequestStream())
{
writeStream.Write(bytes, 0, bytes.Length);
}
}
if (trackTime)
InsertNewMethodLog(r.Url, token);
isMethodAdded = true;
if (trackTime)
UpdateMethodLog(token, r.Url, MethodStatus.Started);
var sw = new Stopwatch();
sw.Start();
try
{
using (var response = (HttpWebResponse)webRequest.GetResponse())
{
if (response.StatusCode != HttpStatusCode.OK)
{
webResponse.StatusCode = response.StatusCode;
var ellapsedTime2 = sw.ElapsedMilliseconds;
if (trackTime)
UpdateMethodLog(token, r.Url, MethodStatus.Fail, ellapsedTime2,
string.Format("Status Code returned : {0}", response.StatusCode));
return webResponse;
}
// grab the response
webResponse.StatusCode = response.StatusCode;
using (var responseStream = response.GetResponseStream())
{
if (responseStream == null) return webResponse;
using (var reader = new StreamReader(responseStream))
{
webResponse.Response = reader.ReadToEnd();
}
}
var ellapsedTime = sw.ElapsedMilliseconds;
if (trackTime)
UpdateMethodLog(token, r.Url, MethodStatus.Pass, ellapsedTime);
return webResponse;
}
}
catch (Exception ex)
{
var ellapsedTime1 = sw.ElapsedMilliseconds;
if (trackTime)
UpdateMethodLog(token, r.Url, MethodStatus.Fail, ellapsedTime1, ex.Message + " -- " + ex.StackTrace);
webResponse.Response = ex.Message;
webResponse.StatusCode = HttpStatusCode.InternalServerError;
}
}
catch (Exception er)
{
if (isMethodAdded && trackTime)
{
UpdateMethodLog(token, r.Url, MethodStatus.Error, null, er.Message + " -- " + er.StackTrace);
}
webResponse.Response = er.Message;
webResponse.StatusCode = HttpStatusCode.InternalServerError;
}
return webResponse;
}
public static RestServiceException InternalServer(
string shortMsg, RestMethod method, string baseUrl, string resource, Exception ex)
{
return new RestServiceException(shortMsg,
HttpStatusCode.InternalServerError,
method, baseUrl, resource, ex);
}
public static RestServiceException Conflict(
string conflictMsg, RestMethod method, string baseUrl, string resource, Exception ex)
{
return new RestServiceException(conflictMsg,
HttpStatusCode.Conflict,
method, baseUrl, resource, ex);
}
public static RestServiceException BadRequest(
string specificMsg, RestMethod method, string baseUrl, string resource, Exception ex)
{
return new RestServiceException(specificMsg,
HttpStatusCode.BadRequest,
method, baseUrl, resource, ex);
}
public RestStreamHandler(string httpMethod, string path, RestMethod restMethod)
: this(httpMethod, path, restMethod, null, null) {}
public RestStreamHandler(string httpMethod, string path, RestMethod restMethod) : base(httpMethod, path)
{
m_restMethod = restMethod;
}
public static RestServiceException NotFound(
RestMethod method, string baseUrl, string resource, Exception ex)
{
return new RestServiceException("Requested resource does not exist on the server.",
HttpStatusCode.NotFound,
method, baseUrl, resource, ex);
}
public static RestServiceException NotAcceptable(
RestMethod method, string baseUrl, string resource, Exception ex)
{
var msg = ex.Message.Between("406 (Not Acceptable : ", ").", true);
return new RestServiceException(msg,
HttpStatusCode.NotAcceptable,
method, baseUrl, resource, ex);
}
public XmlDocument Custom(string resourceKey, int? id, string action, RestMethod method, XmlDocument changedResource,
Dictionary<string, string> queryParameters)
{
Resource resource = FindValidResource(resourceKey);
string relativeUrl = resource.RelativeUri;
if (id != null) relativeUrl += "/" + id;
if (action != null) relativeUrl += "/" + action;
relativeUrl += ".xml";
var uriBuilder = new UriBuilder("http", uri.Host, uri.Port, AddQueryParametersTo(relativeUrl, queryParameters));
if (UserName.Length != 0)
{
uriBuilder.UserName = UserName;
}
if (Password.Length != 0)
{
uriBuilder.Password = Password;
}
Uri serviceUri = uriBuilder.Uri;
HttpWebRequest request = null;
switch (method)
{
case RestMethod.GET:
request = ConstructRequest(serviceUri, "GET", null, null);
break;
case RestMethod.POST:
request = ConstructRequest(serviceUri, "POST", null, changedResource);
break;
case RestMethod.PUT:
request = ConstructRequest(serviceUri, "POST", "PUT", changedResource);
break;
case RestMethod.DELETE:
request = ConstructRequest(serviceUri, "POST", "DELETE", changedResource);
break;
}
return PerformAction(request);
}
public static void LoadTest(string loadTestFilePath = null)
{
if (string.IsNullOrEmpty(loadTestFilePath))
{
loadTestFilePath = Environment.CurrentDirectory + "\\" + ConfigurationManager.AppSettings["loadTestFile"];
}
_testConfigurationFile = loadTestFilePath;
var sr = new StreamReader(_testConfigurationFile);
var testXml = sr.ReadToEnd();
sr.Close();
TestPackage = new Package();
var xDoc = XDocument.Parse(testXml);
if (xDoc.Root != null)
{
TestPackage.ResultFileName = Convert.ToString(xDoc.Root.Attribute("resultFileName").Value);
if (xDoc.Root.Attributes("intervalBetweenScenarios").Any())
{
TestPackage.IntervalBetweenScenarios =
Convert.ToInt32(xDoc.Root.Attribute("intervalBetweenScenarios").Value);
}
TestPackage.Duration = Convert.ToInt32(xDoc.Root.Attribute("duration").Value);
TestPackage.Clients = Convert.ToInt32(xDoc.Root.Attribute("clients").Value);
TestPackage.DelayRangeStart = Convert.ToInt32(xDoc.Root.Attribute("delayRangeStart").Value);
TestPackage.DelayRangeEnd = Convert.ToInt32(xDoc.Root.Attribute("delayRangeEnd").Value);
TestPackage.ResultFileName = Convert.ToString(xDoc.Root.Attribute("resultFileName").Value);
if (string.IsNullOrEmpty(TestPackage.ResultFileName))
{
TestPackage.ResultFileName = "PerfResults.txt";
}
if (File.Exists(TestPackage.ResultFileName))
{
File.Delete(TestPackage.ResultFileName);
}
if (xDoc.Root.Elements("nodes").Any())
{
TestPackage.Nodes = new Nodes { NodeList = new List<string>() };
XElement nsE = xDoc.Root.Elements("nodes").ElementAt(0);
if (nsE.Attributes("noOfClientsPerNode").Any())
{
TestPackage.Nodes.NoOfClientsPerNode = Convert.ToInt32(nsE.Attribute("noOfClientsPerNode").Value);
}
foreach (XElement nE in nsE.Elements("node"))
{
TestPackage.Nodes.NodeList.Add(nE.Attribute("name").Value);
}
}
if (xDoc.Root.Elements("scenarios").Any())
{
TestPackage.Scenarios = new List<Scenario>();
XElement scenariosE = xDoc.Root.Elements("scenarios").ElementAt(0);
foreach (XElement scenarioE in scenariosE.Elements("scenario"))
{
Scenario scen = new Scenario();
foreach (XElement sOrderE in scenarioE.Elements("order"))
{
ScenarioOrder sorder = new ScenarioOrder
{
MethodName = Convert.ToString(sOrderE.Attribute("methodName").Value),
Order = Convert.ToInt32(sOrderE.Attribute("order").Value),
MethodGuid =
sOrderE.Attributes("methodGuid").Any()
? Convert.ToString(sOrderE.Attribute("methodGuid").Value)
: string.Empty,
AssemblyGuid = sOrderE.Attributes("assemblyGuid").Any()
? Convert.ToString(sOrderE.Attribute("assemblyGuid").Value)
: string.Empty,
IsRest = sOrderE.Attributes("isRest").Any() && Convert.ToBoolean(sOrderE.Attribute("isRest").Value)
};
scen.ScenarioOrder.Add(sorder);
}
TestPackage.Scenarios.Add(scen);
}
}
foreach (var suite in xDoc.Root.Elements("testSuite"))
{
var newSuite = new TestSuite();
TestPackage.Suites.Add(newSuite);
newSuite.Guid = Convert.ToString(suite.Attribute("__guid__").Value);
newSuite.ServiceUrl = Convert.ToString(suite.Attribute("serviceUrl").Value);
newSuite.BaseUrl = newSuite.ServiceUrl;
newSuite.Wsdl = newSuite.ServiceUrl + "?wsdl";
if (suite.Attributes("bindingToTest").Any())
newSuite.BindingToTest = Convert.ToString(suite.Attribute("bindingToTest").Value);
if (suite.Attributes("configuration").Any())
newSuite.Configuration = Convert.ToString(suite.Attribute("configuration").Value);
foreach (XElement test in suite.Elements("test"))
{
LoadServiceElement(test, newSuite.Tests, false);
}
foreach (XElement test in suite.Elements("functionalTest"))
{
LoadServiceElement(test, newSuite.FunctionalTests, true);
}
GenerateProxyAssembly(newSuite.Wsdl, newSuite.Guid);
}
#region rest api
foreach (var restNodeX in xDoc.Root.Elements("restApis"))
{
foreach (XElement restMethodX in restNodeX.Elements("restMethod"))
{
RestMethod restMethod = new RestMethod()
{
Guid = Convert.ToString(restMethodX.Attribute("__guid__").Value),
Url = Convert.ToString(restMethodX.Attribute("url").Value),
SelectedHeaderTab = Convert.ToInt32(restMethodX.Attribute("selectedHeaderTab").Value),
SelectedPayloadTab = Convert.ToInt32(restMethodX.Attribute("selectedPayloadTab").Value),
Headers = (List<KeyValue>)TestHelper.Deserialize(restMethodX.Attribute("headers").Value, typeof(List<KeyValue>)),
HeaderText = Convert.ToString(restMethodX.Attribute("headerText").Value),
PayloadValues = (List<KeyValue>)TestHelper.Deserialize(restMethodX.Attribute("payload").Value, typeof(List<KeyValue>)),
PayloadText = Convert.ToString(restMethodX.Attribute("payloadText").Value),
ContentType = Convert.ToString(restMethodX.Attribute("contentType").Value),
Type = (RequestType)Enum.Parse(typeof(RequestType), Convert.ToString(restMethodX.Attribute("type").Value)),
IsAddedToFunctional = restMethodX.Attributes("isAddedToFunctional").Any() && Convert.ToBoolean(restMethodX.Attribute("isAddedToFunctional").Value),
MethodOutput = restMethodX.Attributes("methodOutput").Any() ?
Convert.ToString(restMethodX.Attribute("methodOutput").Value)
: string.Empty
};
TestPackage.RestMethods.Add(restMethod);
}
}
#endregion
}
}
public RestStreamHandler(string httpMethod, string path, RestMethod restMethod, string name, string description)
: base(httpMethod, path, name, description)
{
m_restMethod = restMethod;
}