protected SipResponse CreateOkResponse()
{
var r = ReceivedRequest.CreateResponse(SipResponseCodes.x200_Ok);
r.To.Tag = _toTag;
return(r);
}
private async Task <bool> SaveMockRelationInDB(Response response,
ReceivedRequest receivedRequest,
string requestMethodType)
{
try{
var outcome = false;
if (response != null &&
receivedRequest != null &&
requestMethodType != null)
{
var request = new Request(receivedRequest.Url, receivedRequest.Data)
{
Type = requestMethodType
};
var mockRelationToSave = new MockRelation(request, response);
_dataManager.AddMockRelation(mockRelationToSave);
outcome = true;
}
return(outcome);
}
catch (Exception ex) {
_logger.LogError(ex, "SaveMockRelationInDB");
return(false);
}
}
protected SipResponse CreateBusyHereResponse()
{
var r = ReceivedRequest.CreateResponse(SipResponseCodes.x486_Busy_Here);
r.To.Tag = _toTag;
return(r);
}
protected SipResponse CreateRingingResponse()
{
var r = ReceivedRequest.CreateResponse(SipResponseCodes.x180_Ringing);
r.To.Tag = _toTag;
AddContactHeader(r);
return(r);
}
public static Response CreateResponseFailure(ReceivedRequest req, string failureMessage)
{
return(new Response
{
RequestId = req.RequestId,
Payload = null,
FailureMessage = failureMessage,
});
}
public static Response CreateResponse(ReceivedRequest req, global::Improbable.Gdk.Tests.NonblittableTypes.SecondCommandResponse payload)
{
return(new Response
{
RequestId = req.RequestId,
Payload = payload,
FailureMessage = null,
});
}
public static Response CreateResponse(ReceivedRequest req, global::Improbable.Gdk.Tests.ComponentsWithNoFields.Empty payload)
{
return(new Response
{
RequestId = req.RequestId,
Payload = payload,
FailureMessage = null,
});
}
private async Task <MockRelation> GetMockRelationOfReceivedRequest(ReceivedRequest receivedRequest, string requestType)
{
try{
MockRelation outcome = null;
var mockRelations = await this._dataManager.LoadMockRelations();
var mockRelationsOfType = this._dataManager.GetMockRelations(mockRelations, requestType);
if (receivedRequest != null &&
!string.IsNullOrEmpty(receivedRequest.Url) &&
mockRelationsOfType != null)
{
foreach (var mockRelation in mockRelationsOfType)
{
if (mockRelation?.Request != null)
{
var matchedRoute = _routeMatcher.MatchRoute(receivedRequest.Url, mockRelation.Request.Url);
var urlIsEqual = false;
var dataIsEqual = false;
var hasData = false;
if (matchedRoute != null && matchedRoute.IsMatch)
{
urlIsEqual = true;
}
if (receivedRequest.Data != null)
{
hasData = true;
}
if (hasData && urlIsEqual)
{
var jsonEscaped = JsonConvert.ToString(receivedRequest.Data);
if (mockRelation.Request.Data == jsonEscaped)
{
dataIsEqual = true;
}
}
if ((urlIsEqual && !hasData) || (urlIsEqual && dataIsEqual))
{
outcome = mockRelation;
break;
}
}
}
}
return(outcome);
}
catch (Exception ex) {
_logger.LogError(ex, "GetMockRelationOfReceivedRequest");
return(null);
}
}
public async Task <Response> GetResponseFromRequest(ReceivedRequest receivedRequest, string requestMethodType)
{
try{
Response outcome = null;
if (receivedRequest != null && requestMethodType != null)
{
MockRelation _mockRelationOfReceivedRequest = null;
_mockRelationOfReceivedRequest = await GetMockRelationOfReceivedRequest(receivedRequest, requestMethodType);
if (_mockRelationOfReceivedRequest != null)
{
outcome = _mockRelationOfReceivedRequest.Response;
}
}
return(outcome);
}
catch (Exception ex) {
_logger.LogError(ex, "GetResponseFromRequest");
return(null);
}
}
private async Task <IActionResult> GetActionResultOfRequestType(string url,
object data,
string requestType)
{
try{
IActionResult outcome = null;
var queryString = HttpContext.Request.QueryString.Value;
var completeUrl = $"{url}{queryString}";
var receivedRequest = new ReceivedRequest(completeUrl, data);
var response = await _requestManager.GetResponseFromRequest(receivedRequest, requestType);
if (response == null)
{
response = await _proxyManager.GetResponse(receivedRequest, requestType);
}
outcome = _responseManager.GetActionResultFromResponse(response);
return(outcome);
}
catch (Exception ex) {
_logger.LogError(ex, "GetActionResultOfRequestType");
return(StatusCode(StatusCodes.Status500InternalServerError, "Error"));
}
}
public async Task <Response> GetResponse(ReceivedRequest receivedRequest, string requestMethodType)
{
try{
Response outcome = null;
if (_isProxyEnabled && !string.IsNullOrEmpty(_proxyHost))
{
var urlToCall = $"{_proxyHost}{receivedRequest.Url}";
switch (requestMethodType)
{
case RequestType.GET:
outcome = await GetHttpCall(urlToCall);
break;
case RequestType.POST:
outcome = await PostHttpCall(urlToCall, receivedRequest.Data);
break;
}
}
if (outcome != null)
{
SaveMockRelationInDB(outcome,
receivedRequest,
requestMethodType);
}
return(outcome);
}
catch (Exception ex) {
_logger.LogError(ex, "GetResponse proxy");
return(null);
}
}
private async Task <bool> ProcessRequest(Socket clientSocket, StreamReader reader, StreamWriter writer)
{
var headers = new Dictionary <string, string>();
string url = null;
string method = null;
string line = null;
line = reader.ReadLine();
if (line == null)
{
// Connection has been closed by client.
return(false);
}
var request = new ReceivedRequest();
_requests.Add(request);
request.RequestLine = line;
string[] requestTokens = request.RequestLine.Split(' ');
method = requestTokens[0];
url = requestTokens[1];
while (!string.IsNullOrEmpty(line = reader.ReadLine()))
{
string[] headerParts = line.Split(':');
headers.Add(headerParts[0].Trim(), headerParts[1].Trim());
}
// Store any authentication header and check if credentials are required.
string authValue;
if (headers.TryGetValue(ProxyAuthorizationHeader, out authValue))
{
string[] authTokens = authValue.Split(' ');
request.AuthorizationHeaderValueScheme = authTokens[0];
if (authTokens.Length > 1)
{
request.AuthorizationHeaderValueToken = authTokens[1];
}
}
else if (_authSchemes != AuthenticationSchemes.None)
{
Send407Response(writer);
return(!_connectionCloseAfter407);
}
// Handle methods.
if (method.Equals("CONNECT"))
{
string[] tokens = url.Split(':');
string remoteHost = tokens[0];
int remotePort = int.Parse(tokens[1]);
Send200Response(writer);
await ProcessConnectMethod(clientSocket, (NetworkStream)reader.BaseStream, remoteHost, remotePort).ConfigureAwait(false);
return(false); // connection can't be used for any more requests
}
// Forward the request to the server.
var requestMessage = new HttpRequestMessage(HttpMethod.Get, url);
foreach (var header in headers)
{
if (header.Key != ProxyAuthorizationHeader) // don't forward proxy auth to server
{
requestMessage.Headers.Add(header.Key, header.Value);
}
}
// Add 'Via' header.
if (_addViaRequestHeader)
{
requestMessage.Headers.Add("Via", ViaHeaderValue);
}
var handler = new HttpClientHandler()
{
UseProxy = false
};
using (HttpClient outboundClient = new HttpClient(handler))
using (HttpResponseMessage response = await outboundClient.SendAsync(requestMessage).ConfigureAwait(false))
{
// Transfer the response headers from the server to the client.
var sb = new StringBuilder($"HTTP/{response.Version.ToString(2)} {(int)response.StatusCode} {response.ReasonPhrase}\r\n");
foreach (KeyValuePair <string, IEnumerable <string> > header in response.Headers)
{
sb.Append($"{header.Key}: {string.Join(", ", header.Value)}\r\n");
}
foreach (KeyValuePair <string, IEnumerable <string> > header in response.Content.Headers)
{
sb.Append($"{header.Key}: {string.Join(", ", header.Value)}\r\n");
}
sb.Append("\r\n");
writer.Write(sb.ToString());
// Forward the response body from the server to the client.
string responseBody = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
writer.Write(responseBody);
return(true);
}
}
public static Response CreateFailure(ReceivedRequest req, string failureMessage)
{
return(new Response(req, null, failureMessage));
}
public static Response CreateResponse(ReceivedRequest req, global::Generated.Improbable.Gdk.Tests.ComponentsWithNoFields.Empty payload)
{
return(new Response(req, payload, null));
}
internal Response(ReceivedRequest req, global::Generated.Improbable.Gdk.Tests.ComponentsWithNoFields.Empty?payload, string failureMessage)
{
RequestId = req.RequestId;
Payload = payload;
FailureMessage = failureMessage;
}
public void ReceivedRequestsSteps()
{
ManageRequest.Click();
ReceivedRequest.Click();
}
public static Response CreateResponse(ReceivedRequest req, global::Generated.Improbable.Gdk.Tests.NonblittableTypes.FirstCommandResponse payload)
{
return(new Response(req, payload, null));
}
internal Response(ReceivedRequest req, global::Generated.Improbable.Gdk.Tests.NonblittableTypes.FirstCommandResponse?payload, string failureMessage)
{
RequestId = req.RequestId;
Payload = payload;
FailureMessage = failureMessage;
}
