public async Task AddOutgoingAsync <TSupplierType>(string outgoingPrefix, TSupplierType supplierType, CancellationToken cancellationToken = default)
{
try
{
outgoingPrefix.NotNullOrWhiteSpace(nameof(outgoingPrefix));
supplierType.NotNull(nameof(supplierType));
var strSupplierType = supplierType.ConvertTo <string>();
var hashCode = outgoingPrefix.GetInvariantHashCode();
Logger.SetProperty(LogConstants.OutgoingRequestHashCode, hashCode);
Logger.SetProperty(LogConstants.SupplierType, strSupplierType);
var outgoingRequest = new OutgoingRequest
{
CreatedAt = SystemClock.DateTimeNow,
HashCode = hashCode
};
using (await AsyncLock.LockAsync())
await OutgoingRequestStore.AddAsync(outgoingRequest, cancellationToken);
}
catch (Exception ex)
when(Logger.LogErrorIfNotBefore(ex, "Exception ocurred in {MethodName}", nameof(AddOutgoingAsync)))
{
throw;
}
}
public virtual TConnection Generate(Tcp.Connection connection, URL url, params string[] reqSubprotocols)
{
ClientConnection httpClient = new ClientConnection(connection);
OutgoingRequest req = httpClient.Enqueue("HTTP/1.1", "GET", url);
TConnection newConnection = GenerateConnection(connection, req.Head);
string reqExtensions = NegotiatingExtension.Stringify(RequestExtensions());
string key = Secret.GenerateKey();
req["Connection"] = "Upgrade";
req["Upgrade"] = "websocket";
req["Sec-WebSocket-Version"] = "13";
req["Sec-WebSocket-Key"] = key;
if (reqSubprotocols.Length > 0)
{
req["Sec-WebSocket-Protocol"] = SubprotocolNegotiation.Stringify(reqSubprotocols);
}
if (reqExtensions.Length > 0)
{
req["Sec-WebSocket-Extensions"] = reqExtensions;
}
req.OnResponse += (res) =>
{
if (!VerifyResponseHead(res, key))
{
httpClient.Terminate(); return;
}
string subprotocol = res["Sec-WebSocket-Protocol"];
if (subprotocol != null)
{
bool validSubprotocol = false;
for (int i = 0; i < reqSubprotocols.Length; i++)
{
if (reqSubprotocols[i] == subprotocol)
{
validSubprotocol = true; break;
}
}
if (!validSubprotocol)
{
httpClient.Terminate(); return;
}
}
newConnection.SetSubprotocol(subprotocol);
if (
!NegotiatingExtension.TryParse(res["Sec-WebSocket-Extensions"] ?? "", out NegotiatingExtension[] resExtensions) ||
!CheckExtensions(resExtensions)
)
{
httpClient.Terminate(); return;
}
byte[] trail = httpClient.Freeze();
if (!httpClient.End())
{
return;
}
newConnection.Initiate(trail);
};
public void CreateNewRequest(OutgoingRequest request)
{
var port = GetPortByNumber(request.Target);
var message = "";
switch (port.State)
{
case PortState.Busy:
message = "Subscriber is busy now";
break;
case PortState.Disabled:
message = "Subscriber is not available now";
break;
case PortState.Free:
port.State = PortState.Busy;
port.NewIncomingRequest(request.Source);
port.CallRespond += ((sender, respond) => GetRespond((Port)sender, respond));
return;
default:
throw new ArgumentOutOfRangeException();
}
port.NewStationRespond(new StationRespond()
{
Request = request, DeclineMessage = message, State = RespondState.Decline
});
_currentCall.State = CallState.Rejected;
}
private void HasNewRequest(object sender, OutgoingRequest request)
{
var handler = new RequestHandler(request.Source, request.Target, _portCollection, GetTariff());
handler.CreateNewRequest(request);
_billingStation.NewCallInfo(handler.GetCallInfo());
}
public void OnOutgoingRequest(object sender, PhoneNumber target)
{
OutgoingRequest?.Invoke(sender, new Requests.OutgoingRequest()
{
Source = Terminal.Number, Target = target
});
}
public async Task ShouldSerializeRequests()
{
var pipe = new Pipe(new PipeOptions());
using var handler = NewHandler(pipe.Writer);
var value = new OutgoingRequest {
Method = "method",
Id = 1,
Params = new object(),
};
handler.Send(value);
await handler.WriteAndFlush();
using var reader = new StreamReader(pipe.Reader.AsStream());
var received = await reader.ReadToEndAsync();
const string send =
"Content-Length: 60\r\n\r\n{\"seq\":1,\"type\":\"request\",\"command\":\"method\",\"arguments\":{}}";
received.Should().Be(send);
}
internal void RaiseOutgoingRequest(string request)
{
OutgoingRequest?.Invoke(this, request);
}
public static void HttpClientConnectionTest(string[] args)
{
IPEndPoint clientEndPoint = new IPEndPoint(IPAddress.Loopback, 420);
IPEndPoint serverEndPoint = new IPEndPoint(IPAddress.Any, 420);
HttpListener listener = new HttpListener(serverEndPoint);
ServerConnection server = null;
listener.OnRequest = (sreq, res) =>
{
Console.WriteLine("Server request");
server = sreq.Connection;
if (sreq.Path != "/echo")
{
res["Content-Length"] = "0";
res.End(404, "Not Found"); return;
}
switch (sreq.Method)
{
case "GET":
Console.WriteLine("Server GET request");
res["Content-Type"] = "text/plain";
res["Transfer-Encoding"] = "chunked";
res.SendHead(200, "OK");
res.Write(UTF8.GetBytes("GET on /echo\r\nMake a POST request to echo its body"));
res.End();
Console.WriteLine("Server response finish");
break;
case "POST":
Console.WriteLine("Server POST request");
sreq.OnFinish += () =>
{
Console.WriteLine("Server POST request finish");
if (sreq.BufferedReadable == 0)
{
res.End(400, "Bad Request"); return;
}
res["Content-Type"] = "text/plain";
res["Transfer-Encoding"] = "chunked";
res.SendHead(200, "OK");
res.Write(UTF8.GetBytes("/ path on POST!\r\n"));
res.Write(UTF8.GetBytes("Body is as follows:\r\n\r\n"));
byte[] data = sreq.Read();
Console.WriteLine(UTF8.GetString(data).Replace("\r", "\\r").Replace("\n", "\\n"));
res.Write(data);
res.End();
Console.WriteLine("Server response finish");
};
break;
default: res.End(400, "Bad Request"); break;
}
};
listener.Start();
ClientConnection client = null;
client = new ClientConnection(clientEndPoint, () =>
{
OutgoingRequest creq = client.Enqueue("HTTP/1.1", "POST", "/echo");
creq.OnResponse += (res) =>
{
Console.WriteLine("Client response {0} {1}", res.StatusCode, res.StatusDescription);
res.OnFinish += () =>
{
Console.WriteLine("Client response finish\r\n{0}", UTF8.GetString(res.Read()));
client.End();
client.Base.End();
};
};
creq["Transfer-Encoding"] = "chunked";
creq.SendHead();
creq.Write(UTF8.GetBytes("I am a body"));
creq.End();
Console.WriteLine("Client request finish");
});
Console.ReadKey();
listener.Stop();
Console.ReadKey();
//client.Terminate();
}
private async void HasNewRequestAsynс(object sender, OutgoingRequest request)
{
await Task.Run(() => HasNewRequest(sender, request));
}
public void OnOutgoingRequest(object sender, OwinContext context)
{
OutgoingRequest?.Invoke(sender, new OwinEventArgs(context));
}
