protected override async Task HandleMessage(ReceivedWapMessage message)
{
switch (message.Type)
{
case MessageType.Event:
await HandleEventMessage(message);
break;
case MessageType.MethodCall:
var msg = await HandleMethodCall(message);
msg.SetSequenceNumber(message.SequenceNumber);
await SendMesssage(msg);
break;
case MessageType.MethodResponse:
var call = await _methodCalls.Get(message.SequenceNumber);
if ((call != null) && (call.Messsage.EndPoint == message.EndPoint))
{
call.CompletionSource.SetResult(message);
}
break;
}
}
private async Task <WapMessage> MethodCallHandler(ClientConnection client, ReceivedWapMessage message)
{
if (_serverMethods.HasMethod(message.EndPoint))
{
try
{
return(await _serverMethods.CallMethod(client, WapEndPoint.Parse(message.EndPoint), message));
}
catch (Exception ex)
{
return(new WapMessage <MethodResult <Empty> >(MessageType.MethodResponse, message.EndPoint, new MethodResult <Empty>()
{
Success = false,
Error = ex.Message
}));
}
}
else if (_clientMethods.ContainsKey(message.EndPoint))
{
return(await _clientMethods[message.EndPoint].Client.CallMethod(message));
}
else
{
return(new WapMessage <MethodResult <Empty> >(MessageType.MethodResponse, message.EndPoint, new MethodResult <Empty>()
{
Success = false,
Error = "Method not found"
}));
}
}
public async Task <WapMessage> CallMethod(WapEndPoint ep, ReceivedWapMessage msg)
{
if (!HasMethod(ep))
{
return(null);
}
return(await _methods[ep.ToString()](msg));
}
private Task <WapMessage> MethodCallHandler(ReceivedWapMessage receivedWapMessage)
{
if (!_methods.HasMethod(receivedWapMessage.EndPoint))
{
var mres = MethodResult <Empty> .FromError("Method not found in this endpoint!");
var msg = new WapMessage <MethodResult <Empty> >(MessageType.MethodResponse, receivedWapMessage.EndPoint, mres);
return(Task.FromResult <WapMessage>(msg));
}
return(_methods.CallMethod(WapEndPoint.Parse(receivedWapMessage.EndPoint), receivedWapMessage));
}
private Task EventHandler(ReceivedWapMessage receivedWapMessage)
{
var hdlrs =
_eventHandlers.Where(hdl => hdl.Key.Endpoint.ToString() == receivedWapMessage.EndPoint)
.Select(hdl => hdl.Value);
var tsks = new List <Task>();
foreach (var action in hdlrs)
{
tsks.Add(Task.Run(() => action(receivedWapMessage)));
}
return(Task.WhenAll(tsks));
}
private Task EventMessageHandler(ClientConnection client, ReceivedWapMessage msg)
{
if (!client.IsAuthenticated || !client.PublishingEvents.Contains(msg.EndPoint))
{
return(Task.FromResult(0)); // just return a completed task
}
List <Task> sendTasks = new List <Task>();
foreach (var subscr in _events[msg.EndPoint].Subscribtions)
{
sendTasks.Add(subscr.SendEventMessage(msg));
}
return(Task.WhenAll(sendTasks));
}
protected override Task HandleEventMessage(ReceivedWapMessage msg)
{
return(_eventHandler?.Invoke(msg));
}
protected override Task <WapMessage> HandleMethodCall(ReceivedWapMessage msg)
{
return(_methodCallHandler?.Invoke(msg));
}
protected abstract Task HandleMessage(ReceivedWapMessage msg);
private async Task <ReceivedWapMessage> ReceiveMessage(CancellationToken ct)
{
ReceiveStates state = ReceiveStates.Idle;
List <byte> msgBytes = new List <byte>();
await _rxSem.WaitAsync(ct);
while (true)
{
if (ct.IsCancellationRequested)
{
_rxSem.Release();
ct.ThrowIfCancellationRequested();
}
byte[] bs;
if (_bufBytes.Count > 0)
{
bs = _bufBytes.ToArray();
_bufBytes.Clear();
}
else
{
byte[] buf = new byte[ReadBlockSize];
int count = await _stream.ReadAsync(buf, 0, ReadBlockSize, ct).ConfigureAwait(false);
if (count == 0)
{
_rxSem.Release();
throw new OperationCanceledException("End of Stream reached during reading");
}
bs = new byte[count];
Array.Copy(buf, bs, count);
}
for (int i = 0; i < bs.Length; i++)
{
byte b = bs[i];
switch (state)
{
case ReceiveStates.Idle:
if (b == StartByte)
{
state = ReceiveStates.Reading;
}
break;
case ReceiveStates.Reading:
if (b == StartByte)
{
_rxSem.Release();
throw new BrokenFrameException("Unexpected start byte", msgBytes);
}
else if (b == EndByte)
{
ReceivedWapMessage msg;
try
{
msg = new ReceivedWapMessage(msgBytes.ToArray());
}
catch (Exception ex)
{
_rxSem.Release();
throw new BrokenFrameException("Parsing failed", msgBytes, ex);
}
_bufBytes.AddRange(bs.Skip(i + 1));
_rxSem.Release();
return(msg);
}
else if (b == EscapeByte)
{
state = ReceiveStates.ReadingEscaped;
}
else
{
msgBytes.Add(b);
}
break;
case ReceiveStates.ReadingEscaped:
if (b < EscapeOffset)
{
msgBytes.Add(b);
_rxSem.Release();
throw new BrokenFrameException("Illegal escaped sequence", msgBytes);
}
else
{
b -= EscapeOffset;
msgBytes.Add(b);
state = ReceiveStates.Reading;
}
break;
}
}
}
}
protected abstract Task <WapMessage> HandleMethodCall(ReceivedWapMessage msg);
