/// Called when an incoming message is received
public override void MessageReceived(NetClientBase client_in, BaseMessage msg_in)
{
Console.WriteLine($"App: Received: from {client_in.GetNicePeerAddr()} '{msg_in.ToString()}'");
switch (msg_in.GetType())
{
case MessageType.Handshake:
{
HandshakeMessage hsMsg = msg_in as HandshakeMessage;
//cout << "Handshake message received, '" << hsMsg.getMyAddr() << "'" << endl;
if (hsMsg.GetMyVersion() != "V01")
{
Console.Error.WriteLine($"Wrong version '{hsMsg.GetMyVersion()}'");
client_in.Close();
return;
}
HandshakeResponseMessage resp = new HandshakeResponseMessage("V01", myName, client_in.GetPeerAddr());
client_in.SendMessage(resp);
}
break;
case MessageType.Ping:
{
PingMessage pingMsg = msg_in as PingMessage;
//cout << "Ping message received, '" << pingMsg.GetText() << "'" << endl;
PingResponseMessage resp = new PingResponseMessage("Resp_from_" + myName + "_to_" + pingMsg.GetText());
client_in.SendMessage(resp);
}
break;
default:
System.Diagnostics.Debug.Assert(false);
break;
}
}
/// <summary>
/// Handles an incoming handshake request. We should only receive one of these!
/// </summary>
protected async Task handleHandshakeRequestMessage(HandshakeRequestMessage message)
{
CurrentViewPort = message.InitialViewport;
AbsoluteCursorPosition = message.InitialAbsCursorPosition;
// Tell everyone else about the new client
ClientStatesMessage newClientNotification = new ClientStatesMessage();
newClientNotification.ClientStates.Add(GenerateStateSnapshot());
await manager.Broadcast(this, newClientNotification);
// Send the new client a response to their handshake request
HandshakeResponseMessage handshakeResponse = new HandshakeResponseMessage();
handshakeResponse.Id = Id;
handshakeResponse.Colour = Colour;
handshakeResponse.Name = Name;
foreach (Plane plane in manager.NibriServer.PlaneManager.Planes)
{
handshakeResponse.Planes.Add(plane.Name);
}
await Send(handshakeResponse);
// Tell the new client about everyone else who's connected
// FUTURE: If we need to handle a large number of connections, we should generate this message based on the chunks surrounding the client
await Send(GenerateClientStateUpdate());
}
/// <summary>
/// Writes the serialized representation of a <see cref="HandshakeResponseMessage"/> to the specified writer.
/// </summary>
/// <param name="responseMessage">The message to write.</param>
/// <param name="output">The output writer.</param>
public static void WriteResponseMessage(HandshakeResponseMessage responseMessage, IBufferWriter <byte> output)
{
var reusableWriter = ReusableUtf8JsonWriter.Get(output);
try
{
var writer = reusableWriter.GetJsonWriter();
writer.WriteStartObject();
if (!string.IsNullOrEmpty(responseMessage.Error))
{
writer.WriteString(ErrorPropertyNameBytes, responseMessage.Error);
}
writer.WriteEndObject();
writer.Flush();
Debug.Assert(writer.CurrentDepth == 0);
}
finally
{
ReusableUtf8JsonWriter.Return(reusableWriter);
}
TextMessageFormatter.WriteRecordSeparator(output);
}
private static async Task ProvideServerHandshake(PipeReader reader, PipeWriter writer, CancellationToken cancellationToken)
{
bool isHandshakeCompleted = false;
while (!isHandshakeCompleted)
{
var result = await reader.ReadAsync(cancellationToken).ConfigureAwait(false);
if (cancellationToken.IsCancellationRequested)
{
break;
}
var buffer = result.Buffer;
if (HandshakeProtocol.TryParseRequestMessage(ref buffer, out var requestMessage))
{
var responseMessage = HandshakeResponseMessage.Empty;
if (requestMessage.Protocol != nameof(MessageStoreHubProtocol))
{
responseMessage = new HandshakeResponseMessage($"Protocol '{requestMessage.Protocol}' is not supported.");
}
reader.AdvanceTo(buffer.Start, buffer.Start);
HandshakeProtocol.WriteResponseMessage(responseMessage, writer);
await writer.FlushAsync(cancellationToken).ConfigureAwait(false);
isHandshakeCompleted = true;
}
public static bool TryParseHandshakeResponseMessage(string message, out HandshakeResponseMessage responseMessage)
{
if ("{}".Equals(message))
{
responseMessage = HandshakeResponseMessage.Empty;
return(true);
}
try
{
responseMessage = JsonConvert.DeserializeObject <HandshakeResponseMessage>(message, _serializerSettings);
}
catch (JsonSerializationException)
{
Log.Debug("客户端与服务器的协议不一致");
responseMessage = null;
return(false);
}
if (responseMessage.Type != null &&
responseMessage.Type >= HubProtocolConstants.InvocationMessageType &&
responseMessage.Type <= HubProtocolConstants.CloseMessageType)
{
// a handshake response does not have a type
Log.Debug($"a handshake response does not have a type. type={responseMessage.Type}");
responseMessage = null;
return(false);
}
return(true);
}
private void ProcessHandhakeResponse(HandshakeResponseMessage response)
{
switch (response.Location)
{
case CellNeighbourhood.Row:
if (Sender != Self)
{
rowCells.Add(Sender);
}
break;
case CellNeighbourhood.Column:
if (Sender != Self)
{
columnCells.Add(Sender);
}
break;
case CellNeighbourhood.Square:
if (Sender != Self)
{
squareCells.Add(Sender);
}
break;
}
if (rowCells.Count == 8 && columnCells.Count == 8 && squareCells.Count == 8)
{
Context.Parent.Tell(new HandshakeDoneMessage(cellNumber));
}
}
public async Task <Task> ConnectAsync(
EndPoint endPoint,
bool sendHandshakeRequestMessage = true,
bool expectedHandshakeResponseMessage = true)
{
if (sendHandshakeRequestMessage)
{
using (var memoryStream = new MemoryStream())
{
HandshakeProtocol.WriteRequestMessage(new HandshakeRequestMessage(_protocol.Name), memoryStream);
await Connection.Application.Output.WriteAsync(memoryStream.ToArray());
}
}
var connection = endPoint.OnConnectedAsync(Connection);
if (expectedHandshakeResponseMessage)
{
// note that the handshake response might not immediately be readable
// e.g. server is waiting for request, times out after configured duration,
// and sends response with timeout error
HandshakeResponseMessage = (HandshakeResponseMessage) await ReadAsync(true).OrTimeout();
}
return(connection);
}
/// <summary>
/// Creates a new <see cref="HandshakeResponseMessage"/> from the specified serialized representation.
/// </summary>
/// <param name="buffer">The serialized representation of the message.</param>
/// <param name="responseMessage">When this method returns, contains the parsed message.</param>
/// <returns>A value that is <c>true</c> if the <see cref="HandshakeResponseMessage"/> was successfully parsed; otherwise, <c>false</c>.</returns>
public static bool TryParseResponseMessage(ref ReadOnlySequence <byte> buffer, [NotNullWhen(true)] out HandshakeResponseMessage?responseMessage)
{
if (!TextMessageParser.TryParseMessage(ref buffer, out var payload))
{
responseMessage = null;
return(false);
}
var reader = new Utf8JsonReader(payload, isFinalBlock: true, state: default);
reader.CheckRead();
reader.EnsureObjectStart();
string?error = null;
while (reader.CheckRead())
{
if (reader.TokenType == JsonTokenType.PropertyName)
{
if (reader.ValueTextEquals(TypePropertyNameBytes.EncodedUtf8Bytes))
{
// a handshake response does not have a type
// check the incoming message was not any other type of message
throw new InvalidDataException("Expected a handshake response from the server.");
}
else if (reader.ValueTextEquals(ErrorPropertyNameBytes.EncodedUtf8Bytes))
{
error = reader.ReadAsString(ErrorPropertyName);
}
else
{
reader.Skip();
}
}
else if (reader.TokenType == JsonTokenType.EndObject)
{
break;
}
else
{
throw new InvalidDataException($"Unexpected token '{reader.TokenType}' when reading handshake response JSON.");
}
}
;
responseMessage = new HandshakeResponseMessage(error);
return(true);
}
public Task StartAsync()
{
_processIncoming = Task.Run(async() =>
{
while (true)
{
var result = await MockServicePipe.Input.ReadAsync();
if (result.IsCanceled || result.IsCompleted)
{
break;
}
var buffer = result.Buffer;
try
{
if (!buffer.IsEmpty)
{
while (_servicePro.TryParseMessage(ref buffer, out var message))
{
if (message is HandshakeRequestMessage)
{
var handshakeResponse = new HandshakeResponseMessage("");
_servicePro.WriteMessage(handshakeResponse, MockServicePipe.Output);
var flushResult = await MockServicePipe.Output.FlushAsync();
if (flushResult.IsCanceled || flushResult.IsCompleted)
{
CompletedServiceConnectionHandshake.TrySetResult(false);
}
else
{
CompletedServiceConnectionHandshake.TrySetResult(true);
}
break;
}
}
}
}
finally
{
MockServicePipe.Input.AdvanceTo(buffer.Start, buffer.End);
}
}
});
return(Task.CompletedTask);
}
// internal to only allow FayeClient to instantiate this class
internal FayeConnection(ITransportConnection connection,
HandshakeResponseMessage handshakeResponse,
int messageCounter,
Advice advice,
TimeSpan handshakeTimeout,
string connectionId) : base(messageCounter: messageCounter,
handshakeTimeout: handshakeTimeout)
{
_connection = connection;
ClientId = handshakeResponse.ClientId;
_connection.MessageReceived += SocketMessageReceived;
_subscribedChannels = new Dictionary <string, List <Action <string> > >();
_synchronousMessageEvents = new Dictionary <int, TaskCompletionSource <MessageReceivedArgs> >();
_advice = advice;
_connection.ConnectionLost += SocketConnectionLost;
_connection.ConnectionReestablished += SocketConnectionReestablished;
_logger = LoggerFetcher.GetLogger(connectionId,
this);
}
private bool HandshakeResponseMessagesEqual(HandshakeResponseMessage x, HandshakeResponseMessage y)
{
return(StringEqual(x.ErrorMessage, y.ErrorMessage));
}
private void ReceiveHandshakeResponseMessage(HandshakeResponseMessage message)
{
Context.Watch(Context.Sender);
}
public static Task SendHandshakeResponseAsync(PipeWriter output, HandshakeResponseMessage response = null)
{
ServiceProtocol.WriteMessage(response ?? new HandshakeResponseMessage(), output);
return(output.FlushAsync().AsTask());
}
