void OnTimeSyncResponse(IInOctetStream stream)
{
//log.Trace("On Time Sync response");
if (state != ConnectionState.TimeSync)
{
if (useDebugLogging)
{
log.Warning("We are not in timesync state anymore");
}
return;
}
var echoedTicks = stream.ReadUint64();
var latency = monotonicClock.NowMilliseconds() - (long)echoedTicks;
// log.Trace($"Latency: {latency}");
var remoteTicks = stream.ReadUint64();
latencies.AddLatency((ushort)latency);
ushort averageLatency;
var isStable = latencies.StableLatency(out averageLatency);
if (isStable)
{
var remoteTimeIsNow = remoteTicks + averageLatency / (ulong)2;
//log.Trace($"We are stable! latency:{averageLatency}");
localMillisecondsToRemoteMilliseconds = (long)remoteTimeIsNow - monotonicClock.NowMilliseconds();
latencies = new LatencyCollection();
ConnectedAt = monotonicClock.NowMilliseconds();
SwitchState(ConnectionState.Connected, 100);
}
else
{
//log.Trace("Not stable yet, keep sending");
}
}
void ReadOOB(IInOctetStream stream, long packetTime)
{
var cmd = stream.ReadUint8();
switch (cmd)
{
case CommandValues.ChallengeResponse:
OnChallengeResponse(stream);
break;
case CommandValues.ConnectResponse:
OnConnectResponse(stream);
break;
case CommandValues.TimeSyncResponse:
OnTimeSyncResponse(stream);
break;
case CommandValues.PongResponse:
OnPongResponse(stream, packetTime);
break;
default:
throw new Exception($"Unknown command {cmd}");
}
}
public static ChallengeResponse Deserialize(IInOctetStream stream)
{
var myNonce = stream.ReadUint32();
var serverNonce = stream.ReadUint32();
return(new ChallengeResponse(myNonce, serverNonce));
}
public static string Deserialize(IInOctetStream stream)
{
var myNonce = stream.ReadUint8();
var characters = stream.ReadOctets(myNonce);
return(Encoding.UTF8.GetString(characters));
}
SequenceId HandleTend(IInOctetStream stream, long packetTime)
{
var info = TendDeserializer.Deserialize(stream);
if (useDebugLogging)
{
log.Debug($"received tend {info} ");
}
tendIn.ReceivedToUs(info.PacketId);
var valid = tendOut.ReceivedByRemote(info.Header);
if (valid)
{
PacketHistoryItem foundItem;
var worked = timestampedHistory.ReceivedConfirmation(info.Header.SequenceId, out foundItem, log);
if (worked)
{
var latency = packetTime - foundItem.Time;
var foundPacket = outStatsCollector.UpdateLatency((uint)info.Header.SequenceId.Value, latency);
if (!foundPacket)
{
log.Warning("didnt find latency to update", "sequenceID", info.Header.SequenceId.Value);
}
//simpleOut.AddLatency(latency);
}
}
CallbackTend();
return(info.PacketId);
}
void OnPongResponse(IInOctetStream stream, long packetTime)
{
var pongResponse = PongResponseHeaderDeserializer.Deserialize(stream);
OnPongResponseCmd(pongResponse);
HandleTend(stream, packetTime);
}
public static NameVersion Deserialize(IInOctetStream stream)
{
var name = StringDeserializer.Deserialize(stream);
var version = VersionDeserializer.Deserialize(stream);
return(new NameVersion(name, version));
}
void ReadConnectionPacket(IInOctetStream stream, long nowMs)
{
var packetId = HandleTend(stream, nowMs);
var count = stream.RemainingOctetCount;
var payload = stream.ReadOctets(count);
incomingPacketBuffer.AddPacket(packetId, payload);
}
public static void Deserialize(IInOctetStream stream, ConnectInfo cmd)
{
cmd.BriskVersion = NameVersionDeserializer.Deserialize(stream);
cmd.SdkVersion = NameVersionDeserializer.Deserialize(stream);
cmd.SchemaVersion = NameVersionDeserializer.Deserialize(stream);
cmd.ApplicationVersion = NameVersionDeserializer.Deserialize(stream);
cmd.Payload = PayloadDeserializer.Deserialize(stream);
}
public static ConnectResponse Deserialize(IInOctetStream stream)
{
var myNonce = stream.ReadUint32();
var serverNonce = stream.ReadUint32();
var connectionId = stream.ReadUint16();
return(new ConnectResponse(myNonce, connectionId, serverNonce));
}
public static CustomConnectPayload Deserialize(IInOctetStream stream)
{
var octetCount = stream.ReadUint8();
var octets = stream.ReadOctets(octetCount);
return(new CustomConnectPayload {
Payload = octets
});
}
public static Version Deserialize(IInOctetStream stream)
{
var major = stream.ReadUint16();
var minor = stream.ReadUint16();
var patch = stream.ReadUint16();
var prerelease = StringDeserializer.Deserialize(stream);
return(new Version(major, minor, patch, prerelease));
}
public static Info Deserialize(IInOctetStream stream)
{
var packetSequenceId = stream.ReadUint8();
var receivedByRemoteSequenceId = stream.ReadUint8();
var receiveMask = stream.ReadUint32();
var header = new Header(new SequenceId(receivedByRemoteSequenceId), new ReceiveMask(receiveMask));
var info = new Info
{
PacketId = new SequenceId(packetSequenceId),
Header = header
};
return(info);
}
void OnConnectResponse(IInOctetStream stream)
{
var response = ConnectResponseDeserializer.Deserialize(stream);
if (useDebugLogging)
{
log.Debug($"We have a connection! {response}");
}
connectionId = response.ConnectionId;
if (syncTimeOnConnect)
{
SwitchState(ConnectionState.TimeSync, connectedPeriodInMs);
}
else
{
ConnectedAt = monotonicClock.NowMilliseconds();
SwitchState(ConnectionState.Connected, 100);
}
}
void OnChallengeResponse(IInOctetStream stream)
{
var response = ChallengeResponseHeaderDeserializer.Deserialize(stream);
if (state != ConnectionState.Challenge)
{
return;
}
if (useDebugLogging)
{
log.Debug($"Challenge response {response}");
}
if (response.Nonce == challengeNonce)
{
remoteNonce = response.RemoteNonce;
SwitchState(ConnectionState.ConnectRequest, 100);
}
}
void ReadHeader(IInOctetStream stream, byte mode, int packetOctetCount, long nowMs)
{
var sequence = stream.ReadUint8();
var assignedConnectionId = stream.ReadUint16();
if (assignedConnectionId == 0)
{
ReadOOB(stream, nowMs);
}
else
{
if (assignedConnectionId == connectionId)
{
var headerSequenceId = new SequenceId(sequence);
if (lastIncomingSequence.IsValidSuccessor(headerSequenceId))
{
var diff = lastIncomingSequence.Distance(headerSequenceId);
var timeStamp = DateTime.UtcNow;
if (diff > 1)
{
inStatsCollector.PacketsDropped(timeStamp, diff - 1);
}
inStatsCollector.PacketReceived(timeStamp, packetOctetCount);
simpleIn.AddPacket(packetOctetCount);
lastIncomingSequence = headerSequenceId;
if (mode == OobMode)
{
ReadOOB(stream, nowMs);
}
else
{
ReadConnectionPacket(stream, nowMs);
}
}
}
}
lastValidHeader = monotonicClock.NowMilliseconds();
}
public static PongResponseHeader Deserialize(IInOctetStream stream)
{
var elapsedMilliseconds = (long)stream.ReadUint64();
return(new PongResponseHeader(elapsedMilliseconds));
}
