public void TestGameModePoolModifiedAndGameModePoolInserted() { var state = new ProtocolState(); state.GameModePool.TryAdd("gamemode1", new GameModeModel() { Name = "gamemode 1", FriendlyName = "Boring GameMode 1" }); var segment = new ProtocolStateSegment() { GameModePool = new ConcurrentDictionary<String, GameModeModel>() }; segment.GameModePool.TryAdd("gamemode1", new GameModeModel() { Name = "gamemode 1", FriendlyName = "Fun GameMode 1" }); segment.GameModePool.TryAdd("gamemode2", new GameModeModel() { Name = "gamemode 2", FriendlyName = "Fun GameMode 2" }); state.Set(segment); Assert.AreEqual(2, state.GameModePool.Count); Assert.AreEqual("Fun GameMode 1", state.GameModePool["gamemode1"].FriendlyName); Assert.AreEqual("Fun GameMode 2", state.GameModePool["gamemode2"].FriendlyName); }
//Invoke by Transporter, process the message internal void processMessage(byte[] bytes) { Package pkg = PackageProtocol.decode(bytes); //Ignore all the message except handshading at handshake stage if (pkg.type == PackageType.PKG_HANDSHAKE && this.state == ProtocolState.handshaking) { //Ignore all the message except handshading JsonObject data = (JsonObject)SimpleJson.SimpleJson.DeserializeObject(Encoding.UTF8.GetString(pkg.body)); processHandshakeData(data); this.state = ProtocolState.working; } else if (pkg.type == PackageType.PKG_HEARTBEAT && this.state == ProtocolState.working) { this.heartBeatService.resetTimeout(); } else if (pkg.type == PackageType.PKG_DATA && this.state == ProtocolState.working) { this.heartBeatService.resetTimeout(); pc.processMessage(messageProtocol.decode(pkg.body)); } else if (pkg.type == PackageType.PKG_KICK) { this.getPomeloClient().disconnect(); this.close(); } }
public void TestSingleGameModePoolRemoved() { var state = new ProtocolState(); state.GameModePool.TryAdd("gamemode1", new GameModeModel() { Name = "gamemode 1", FriendlyName = "Boring GameMode 1" }); state.GameModePool.TryAdd("gamemode2", new GameModeModel() { Name = "gamemode 2", FriendlyName = "Boring GameMode 2" }); var segment = new ProtocolStateSegment() { GameModePool = new ConcurrentDictionary<String, GameModeModel>() }; segment.GameModePool.TryAdd("gamemode1", new GameModeModel() { Name = "gamemode 1", FriendlyName = "Boring GameMode 1" }); state.Removed(segment); Assert.AreEqual(1, state.GameModePool.Count); Assert.AreEqual("Boring GameMode 2", state.GameModePool.First().Value.FriendlyName); }
public void TestMapPoolIdenticalNamesDifferentGameModes() { var state = new ProtocolState(); state.MapPool.TryAdd("gamemode1/map1", new MapModel() { Name = "map1", GameMode = new GameModeModel() { Name = "gamemode1" }, FriendlyName = "First Map" }); state.MapPool.TryAdd("gamemode2/map1", new MapModel() { Name = "map1", GameMode = new GameModeModel() { Name = "gamemode2" }, FriendlyName = "Second Map" }); var segment = new ProtocolStateSegment() { MapPool = new ConcurrentDictionary<String, MapModel>() }; segment.MapPool.TryAdd("gamemode1/map1", new MapModel() { Name = "map1", GameMode = new GameModeModel() { Name = "gamemode1" }, FriendlyName = "First Map" }); state.Removed(segment); Assert.AreEqual(1, state.MapPool.Count); Assert.AreEqual("Second Map", state.MapPool.First().Value.FriendlyName); }
public int HandlePacket(Packet packetIn, SerialPort serialPort, Chart chart = null, bool forceSend = false) { if (forceSend) { writePacket(packetIn, serialPort); return (int)ProtocolDirective.DoNothing; } switch (state) { case ProtocolState.Idle: if (packetIn.command == ((byte)PacketType.Start | (byte)PacketSender.GUI)) {// If we're idle and waiting to be told to do something and we receive a start packet from the GUI writePacket(packetIn, serialPort); state = ProtocolState.StartSent; } break; case ProtocolState.StartSent: if (packetIn.command == ((byte)PacketType.Start | (byte)PacketSender.Microcontroller)) {// If we're waiting for an acknowledge and we receive one from the microcontroller state = ProtocolState.WaitForData; } else if (packetIn.command == ((byte)PacketType.Error | (byte)PacketSender.Microcontroller)) {// If we're waiting for an acknowledge and we receive an error packet from the microcontroller state = ProtocolState.ErrorReceived; } break; case ProtocolState.StopSent: if (packetIn.command == ((byte)PacketType.Stop | (byte)PacketSender.Microcontroller)) {// If we're waiting for an acknowledge and we receive one from the microcontroller state = ProtocolState.Idle; } break; case ProtocolState.WaitForData: if (packetIn.command == ((byte)PacketType.Report | (byte)PacketSender.Microcontroller)) {// If we're waiting for data packets and we receive one from the microcontroller byte[] payload = new byte[1]; payload[0] = packetIn.payload[0]; Packet ackPacket = new Packet((byte)PacketType.Report | (byte)PacketSender.GUI, 1, payload); writePacket(ackPacket, serialPort); return (int)ProtocolDirective.AddData; } else if (packetIn.command == ((byte)PacketType.Stop | (byte)PacketSender.GUI)) {// If we're waiting for data packets and we receive a stop packet from the GUI writePacket(packetIn, serialPort); state = ProtocolState.StopSent; } break; case ProtocolState.ErrorReceived: break; default: break; } return (int)ProtocolDirective.DoNothing; }
public void TestGroupPoolModifiedAndGroupPoolInserted() { var state = new ProtocolState(); state.Groups.TryAdd("Team/1", new GroupModel() { Uid = "1", Type = GroupModel.Team, FriendlyName = "Boring Group 1" }); var segment = new ProtocolStateSegment() { Groups = new ConcurrentDictionary<String, GroupModel>() }; segment.Groups.TryAdd("Team/1", new GroupModel() { Uid = "1", Type = GroupModel.Team, FriendlyName = "Fun Group 1" }); segment.Groups.TryAdd("Team/2", new GroupModel() { Uid = "2", Type = GroupModel.Team, FriendlyName = "Fun Group 2" }); state.Modified(segment); Assert.AreEqual(2, state.Groups.Count); Assert.AreEqual("Fun Group 1", state.Groups["Team/1"].FriendlyName); Assert.AreEqual("Fun Group 2", state.Groups["Team/2"].FriendlyName); }
public Protocol(PomeloClient pc, System.Net.Sockets.Socket socket) { this.pc = pc; this.transporter = new Transporter (socket, this.processMessage); this.handshake = new HandShakeService(this); this.state = ProtocolState.start; }
internal void close() { transporter.close(); if (heartBeatService != null) heartBeatService.stop(); this.state = ProtocolState.closed; }
public Protocol(Connection pc, System.Net.Sockets.Socket socket) { this._pomeloClient = pc; this._transporter = new Transporter(socket, this.processMessage); this._transporter.onDisconnect = onDisconnect; this._handshake = new HandShakeService(this); this._state = ProtocolState.start; }
public Protocol(MongoClient mc, System.Net.Sockets.Socket socket) { this.mc = mc; this.transporter = new Transporter(socket, this.processMessage); this.transporter.onDisconnect = onDisconnect; this.handshake = new HandShakeService(this); this.state = ProtocolState.start; }
/// <summary> /// Initializes a new instance of the <see cref="RfbMessageReceiver"/>. /// </summary> /// <param name="context">The connection context.</param> public RfbMessageReceiver(RfbConnectionContext context) : base("RFB Message Receiver") { _context = context ?? throw new ArgumentNullException(nameof(context)); _state = context.GetState <ProtocolState>(); _logger = context.Connection.LoggerFactory.CreateLogger <RfbMessageReceiver>(); // Log failure events from background thread base Failed += (sender, args) => _logger.LogWarning(args.Exception, "Receive loop failed."); }
private void Reconnect() { if (mRunning && ((mConnection.State == BotConnectionState.Stopped) || (mConnection.State == BotConnectionState.Failed))) { mState = ProtocolState.Idle; mConnection.Start(); UpdateTimeout(); } }
public bool TryCreatePacket(int packetId, PacketBoundTo boundTo, ProtocolState state, out IPacket packet) { packet = _packetInfo.FirstOrDefault(info => info.PacketId == packetId && info.BoundTo == boundTo && (info.State == state || info.State == ProtocolState.Any) )?.Constructor(); return(packet != null); }
private void Disconnect() { if (_proto_state != ProtocolState.NONE) { _mystate = MyState.NONE; _proto_state = ProtocolState.NONE; _usb2snes.Disconnect(); } }
protected StateMachine(TransactionEnlistment enlistment) { this.enlistment = enlistment; this.state = enlistment.State; this.synchronization = new SynchronizationManager(this); if (DebugTrace.Warning || DiagnosticUtility.ShouldTraceWarning) { this.history = new StateMachineHistory(); } }
public void Close() { this.transporter.Close(); if (this.heartBeatService != null) { this.heartBeatService.Stop(); } this.state = ProtocolState.closed; }
public Protocol(PomeloClient pc, System.Net.Sockets.Socket socket) { this.pc = pc; Trace.TraceInformation("this.transporter = new Transporter"); this.transporter = new Transporter(socket, this.processMessage); this.transporter.onDisconnect = onDisconnect; this.handshake = new HandShakeService(this); this.state = ProtocolState.start; }
public Protocol(ITransporter transproter, Action <Message> messageProcessor, Action onProtoClose) { this.transporter = transproter; this.transporter.onReceive(this.processMessage); this.onProtocolClose += onProtoClose; this.messageProcessor += messageProcessor; this.handshake = new HandShakeService(this); this.state = ProtocolState.ready; }
public Protocol(PomeloClient pc, TransporterBase inTransporter) { this.pc = pc; this.transporter = inTransporter; this.transporter.SetMessageProcesser(this.processMessage); this.transporter.onDisconnect = onDisconnect; this.handshake = new HandShakeService(this); this.state = ProtocolState.start; }
public LogEntrySerialization(ProtocolState state) { if (state == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("state")); } this.state = state; this.protocolVersion = state.ProtocolVersion; this.maxLogEntrySize = this.state.TransactionManager.MaxLogEntrySize; }
public bool StartRun(ConfigPacket configPacket, StartPacket startPacket) { if (configPacket != null) // If we need to send a configuration packet (by default, we always will), { try { writePacket <ConfigPacket>(configPacket, serialPort); // try writing the packet } catch (Exception) { // If something bad happens, this.errorCode = (byte)ErrorCode.TimeOut; // set the error code to the ProtocolHandler-specific code, return(false); // and return false } this.state = ProtocolState.ConfigSent; // Otherwise, set the state, oneshotTimer(2000); // start the timer, while (!this.timerDone && this.state == ProtocolState.ConfigSent) { ; // and wait for either the timer to stop or the microcontroller to respond (state changes in HandlePacket) } if (this.state == ProtocolState.ConfigSent) // If we haven't changed states, that means we timed out, { this.state = ProtocolState.Idle; // so set us back to idle, this.errorCode = (byte)ErrorCode.TimeOut; // set the error code to the ProtocolHandler-specific code, return(false); // and return false } if (this.state == ProtocolState.ErrorReceived) // If we received an error, { this.state = ProtocolState.Idle; // set us back to idle, return(false); // and return false } } try { // If we made it to here, that means we successfully sent the configuration packet writePacket <StartPacket>(startPacket, serialPort); // Try writing the packet } catch (Exception) { // If something bad happens, this.errorCode = (byte)ErrorCode.TimeOut; // set the error code to the ProtocolHandler-specific code, return(false); // and return false } this.state = ProtocolState.StartSent; // Otherwise, set the state, oneshotTimer(2000); // start the timer, while (!this.timerDone && this.state == ProtocolState.StartSent) { ; // and wait for either the timer to stop or the microcontroller to respond } if (this.state == ProtocolState.StartSent) // If we haven't changed states, that means we timed out, { this.state = ProtocolState.Idle; // so set us back to idle, this.errorCode = (byte)ErrorCode.TimeOut; // set the error code to the ProtocolHander-specific code, return(false); // and return false } if (this.state == ProtocolState.ErrorReceived) // If we received and error, { this.state = ProtocolState.Idle; // set us back to idle, return(false); // and return false } return(true); // If we made it this far, that means we successfully sent both packets, so return true! }
internal void close() { transporter.close(); if (heartBeatService != null) { heartBeatService.stop(); } this.state = ProtocolState.closed; }
public ClientHandshake( VarInt protocolVersion, [DataLengthConstraint(Max = 255)] Utf8String serverAddress, ushort serverPort, VarInt nextState) { ProtocolVersion = protocolVersion; ServerAddress = serverAddress; ServerPort = serverPort; NextState = nextState.AsEnum <ProtocolState>(); }
internal void close() { Trace.TraceInformation("close"); transporter.close(); if (heartBeatService != null) { heartBeatService.stop(); } this.state = ProtocolState.closed; }
public void BeginHandling(Socket socket, string ip) { _socket = socket; _socket.Blocking = false; State = ProtocolState.Handshaked; IP = ip; Active = true; DCTime = -1; Manager.AddClient(this); }
internal void close() { if(this.state == ProtocolState.closed){ return; } this.state = ProtocolState.closed; transporter.close(); if(heartBeatService != null) { heartBeatService.stop(); } }
private void ProtocolError(string error) { if (!mRunning) { return; } mLastAvalabilityError = error; mState = ProtocolState.Finished; UpdateTimeout(); mConnection.BeginStop(); mDispatcher.ScheduleInvoke(RETRY_CONNECTION_INTERVAL, new ReconnectEvnetHandler(Reconnect)); SetAvailable(false); }
public void ReadFromPacket(IPacket packet) { PacketId = packet.PacketId; BoundTo = packet.BoundTo; State = packet.State; Content.WriteVarInt(packet.PacketId); var pos = BaseStream.Position; packet.WriteToStream(Content); BaseStream.Position = pos; PacketLength = (int)BaseStream.Length; DataLength = (int)BaseStream.Length; }
public void close() { if (heartBeatService != null) { heartBeatService.stop(); } this.state = ProtocolState.closed; if (onProtocolClose != null) { onProtocolClose(); } }
internal void StateChangeListener(object sender, ProtocolState state) { if (state == ProtocolState.Open && previousState == ProtocolState.Reconnecting) { kuzzle.GetEventHandler().DispatchReconnected(); Task.Run(async() => { QueryReplayer.WaitLoginToReplay = true; await Recover(); }); } previousState = state; }
public void Reset() { // We don't clear the receive buffer since there may be queued data that is still relevent to us, // plus clearing it here messes up the loop in ProcessReceivedData. protocolState = ProtocolState.Idle; unacknowledgedPacket = null; lastSendTime = DateTime.MinValue; sendRetries = 0; sendPVTData = false; sendSatData = false; pvtPacket = null; satDataPacket = null; sendStream.SetLength(0); }
private void MConnection_StateChanged(IBotConnection sender, BotConnectionState state) { if (!mRunning) { return; } if ((state == BotConnectionState.Stopped) || (state == BotConnectionState.Failed)) { ProtocolError((mConnection.LastError != null) ? mConnection.LastError : "Connection failed."); } else if (state == BotConnectionState.Started) { mConnection.SendMessage(Encoding.ASCII.GetBytes("INIT")); mState = ProtocolState.InitSent; UpdateTimeout(); } }
private void processHandshakeData(JsonObject msg) { if ((!msg.ContainsKey("code") || !msg.ContainsKey("sys")) || (Convert.ToInt32(msg["code"]) != 200)) { throw new Exception("Handshake error! Please check your handshake config."); } JsonObject obj2 = (JsonObject)msg["sys"]; JsonObject dict = new JsonObject(); if (obj2.ContainsKey("dict")) { dict = (JsonObject)obj2["dict"]; } JsonObject obj4 = new JsonObject(); JsonObject serverProtos = new JsonObject(); JsonObject clientProtos = new JsonObject(); if (obj2.ContainsKey("protos")) { obj4 = (JsonObject)obj2["protos"]; serverProtos = (JsonObject)obj4["server"]; clientProtos = (JsonObject)obj4["client"]; } this.messageProtocol = new MessageProtocol(dict, serverProtos, clientProtos); int timeout = 0; if (obj2.ContainsKey("heartbeat")) { timeout = Convert.ToInt32(obj2["heartbeat"]); } this.heartBeatService = new HeartBeatService(timeout, this); if (timeout > 0) { this.heartBeatService.start(); } this.handshake.ack(); this.state = ProtocolState.working; JsonObject data = new JsonObject(); if (msg.ContainsKey("user")) { data = (JsonObject)msg["user"]; } this.handshake.invokeCallback(data); }
public void TestRedefineBuildsPlayerOutliers() { var state = new ProtocolState(); state.Players.TryAdd("1", new PlayerModel() { Uid = "1", Kills = 2 }); state.Players.TryAdd("2", new PlayerModel() { Uid = "2", Kills = 4 }); state.Players.TryAdd("3", new PlayerModel() { Uid = "3", Kills = 4 }); state.Players.TryAdd("4", new PlayerModel() { Uid = "4", Kills = 4 }); state.Players.TryAdd("5", new PlayerModel() { Uid = "5", Kills = 5 }); state.Players.TryAdd("6", new PlayerModel() { Uid = "6", Kills = 5 }); state.Players.TryAdd("7", new PlayerModel() { Uid = "7", Kills = 7 }); state.Players.TryAdd("8", new PlayerModel() { Uid = "8", Kills = 9 }); state.Redefine(); Assert.AreEqual("Kills", state.Players["8"].Outliers.First().Field); Assert.AreEqual(5.0f, state.Players["8"].Outliers.First().Mean); Assert.AreEqual(2.0f, state.Players["8"].Outliers.First().StandardDeviation); Assert.AreEqual(2.0f, state.Players["8"].Outliers.First().Deviations); Assert.AreEqual(9.0f, state.Players["8"].Outliers.First().Value); }
public PacketIdMappingAttribute(ProtocolState state, int rawId) { switch (state) { case ProtocolState.Handshaking: case ProtocolState.Status: case ProtocolState.Login: case ProtocolState.Play: break; default: case ProtocolState.Undefined: case ProtocolState.Disconnected: throw new ArgumentOutOfRangeException(nameof(state)); } State = state; RawId = rawId; }
private bool isConnectionReady() { Debug.WriteLine("Checking connection"); if (_proto_state == ProtocolState.ATTACHED) { return(true); } // this method actually does a BLOCKING request-response cycle (!!) bool connected = _usb2snes.Connected(); if (!connected) { SetState(MyState.NONE); _proto_state = ProtocolState.NONE; } this.connect(); return(false); }
private void processHandshakeData(JsonData msg) { //Handshake error if (!msg.ContainsKey("code") || !msg.ContainsKey("sys") || Convert.ToInt32(msg["code"].ToString()) != 200) { throw new Exception("Handshake error! Please check your handshake config."); } //Debug.Log(msg.ToJson()); //Set compress data JsonData sys = (JsonData)msg["sys"]; //Init heartbeat service int interval = 0; if (sys.ContainsKey("heartbeat")) { interval = Convert.ToInt32(sys["heartbeat"].ToString()); } heartBeatService = new HeartBeatService(interval, this); if (interval > 0) { heartBeatService.start(); } this.InitProtoCache(sys); //send ack and change protocol state handshake.ack(); this.state = ProtocolState.working; //Invoke handshake callback JsonData user = new JsonData(); if (msg.ContainsKey("user")) { user = (JsonData)msg["user"]; } handshake.invokeCallback(user); }
private void processHandshakeData(byte[] data) { //Ignore all the message except handshading JsonObject msg = (JsonObject)SimpleJson.SimpleJson.DeserializeObject(Encoding.UTF8.GetString(data)); //Handshake error if (!msg.ContainsKey("code") || !msg.ContainsKey("sys") || Convert.ToInt32(msg["code"]) != 200) { throw new Exception("Handshake error! Please check your handshake config."); } //Set compress data JsonObject sys = (JsonObject)msg["sys"]; JsonObject dict = new JsonObject(); if (sys.ContainsKey("dict")) { dict = (JsonObject)sys["dict"]; } messageProtocol = new MessageProtocol(dict); //Init heartbeat service int interval = 0; if (sys.ContainsKey("heartbeat")) { interval = Convert.ToInt32(sys["heartbeat"]); } heartBeatService = new HeartBeatService(interval, this); if (interval > 0) { heartBeatService.start(); } //send ack and change protocol state handshake.ack(); this.state = ProtocolState.working; handshake.invokeCallback(data); }
private void MConnection_Message(IBotConnection sender, byte[] message) { switch (mState) { case ProtocolState.InitSent: if (Encoding.ASCII.GetString(message) == "REDY") { mState = ProtocolState.Connected; UpdateTimeout(); SetAvailable(true); } else { ProtocolError("Invalid response from bot."); } break; case ProtocolState.Connected: string text = Encoding.ASCII.GetString(message); int time; if (int.TryParse(text, out time)) { if (mTimerMain != null) { mTimerMain.SetTime(time); } } else { ProtocolError("Invalid message from bot."); } break; default: ProtocolError("Unexpected response from bot."); break; } }
internal void processMessage(byte[] bytes) { Package package = PackageProtocol.decode(bytes); if (package.type == PackageType.PKG_HANDSHAKE && this.state == ProtocolState.handshaking) { this.processHandshakeData((JsonObject)SimpleJson.SimpleJson.DeserializeObject(Encoding.UTF8.GetString(package.body))); this.state = ProtocolState.working; } else if (package.type == PackageType.PKG_HEARTBEAT && this.state == ProtocolState.working) this.heartBeatService.resetTimeout(); else if (package.type == PackageType.PKG_DATA && this.state == ProtocolState.working) { this.heartBeatService.resetTimeout(); this.pc.processMessage(this.messageProtocol.decode(package.body)); } else { if (package.type != PackageType.PKG_KICK) return; this.getPomeloClient().disconnect(); this.close(); } }
public void TestSingleUidBansRemoved() { var state = new ProtocolState(); state.Bans.TryAdd("Permanent/Uid/1", new BanModel() { Scope = { Times = { new TimeSubsetModel() { Context = TimeSubsetContext.Permanent } }, Players = new List<PlayerModel>() { new PlayerModel() { Uid = "1", Score = 1 } } } }); state.Bans.TryAdd("Time/Uid/2", new BanModel() { Scope = { Times = { new TimeSubsetModel() { Context = TimeSubsetContext.Time } }, Players = new List<PlayerModel>() { new PlayerModel() { Uid = "2", Score = 2 } } } }); var segment = new ProtocolStateSegment() { Bans = new ConcurrentDictionary<String, BanModel>() }; segment.Bans.TryAdd("Permanent/Uid/1", new BanModel() { Scope = { Times = { new TimeSubsetModel() { Context = TimeSubsetContext.Permanent } }, Players = new List<PlayerModel>() { new PlayerModel() { Uid = "1", Score = 1 } } } }); state.Removed(segment); Assert.AreEqual(1, state.Bans.Count); Assert.AreEqual(TimeSubsetContext.Time, state.Bans.First().Value.Scope.Times.First().Context); }
public void TestSinglePlayersRemoved() { var state = new ProtocolState(); state.Players.TryAdd("1", new PlayerModel() { Uid = "1", Score = 1 }); state.Players.TryAdd("2", new PlayerModel() { Uid = "2", Score = 2 }); var segment = new ProtocolStateSegment() { Players = new ConcurrentDictionary<String, PlayerModel>() }; segment.Players.TryAdd("1", new PlayerModel() { Uid = "1", Score = 1 }); state.Removed(segment); Assert.AreEqual(1, state.Players.Count); Assert.AreEqual(2, state.Players.First().Value.Score); }
public void TestSingleMapsRemoved() { var state = new ProtocolState(); state.Maps.TryAdd("gamemode1/map1", new MapModel() { Name = "map1", GameMode = new GameModeModel() { Name = "gamemode1" }, FriendlyName = "Boring Map 1" }); state.Maps.TryAdd("gamemode2/map2", new MapModel() { Name = "map2", GameMode = new GameModeModel() { Name = "gamemode2" }, FriendlyName = "Boring Map 2" }); var segment = new ProtocolStateSegment() { Maps = new ConcurrentDictionary<String, MapModel>() }; segment.Maps.TryAdd("gamemode1/map1", new MapModel() { Name = "map1", GameMode = new GameModeModel() { Name = "gamemode1" }, FriendlyName = "Boring Map 1" }); state.Removed(segment); Assert.AreEqual(1, state.Maps.Count); Assert.AreEqual("Boring Map 2", state.Maps.First().Value.FriendlyName); }
public void TestSingleItemPoolRemoved() { var state = new ProtocolState(); state.Items.TryAdd("1", new ItemModel() { Name = "1", FriendlyName = "Boring Item 1" }); state.Items.TryAdd("2", new ItemModel() { Name = "2", FriendlyName = "Boring Item 2" }); var segment = new ProtocolStateSegment() { Items = new ConcurrentDictionary<String, ItemModel>() }; segment.Items.TryAdd("1", new ItemModel() { Name = "1", FriendlyName = "Boring Item 1" }); state.Removed(segment); Assert.AreEqual(1, state.Items.Count); Assert.AreEqual("Boring Item 2", state.Items.First().Value.FriendlyName); }
public void TestTwoMapsIdenticalNamesDifferentGameModes() { var state = new ProtocolState(); state.Maps.TryAdd("gamemode1/map1", new MapModel() { Name = "map1", GameMode = new GameModeModel() { Name = "gamemode1" }, FriendlyName = "Boring Gamemode 1" }); state.Maps.TryAdd("gamemode2/map1", new MapModel() { Name = "map1", GameMode = new GameModeModel() { Name = "gamemode2" }, FriendlyName = "Boring Gamemode 2" }); var segment = new ProtocolStateSegment() { Maps = new ConcurrentDictionary<String, MapModel>() }; segment.Maps.TryAdd("gamemode1/map1", new MapModel() { Name = "map1", GameMode = new GameModeModel() { Name = "gamemode1" }, FriendlyName = "Fun First Map" }); segment.Maps.TryAdd("gamemode2/map1", new MapModel() { Name = "map1", GameMode = new GameModeModel() { Name = "gamemode2" }, FriendlyName = "Fun Second Map" }); state.Modified(segment); Assert.AreEqual(2, state.Maps.Count); Assert.AreEqual("Fun First Map", state.Maps.First(item => item.Value.Name == "map1" && item.Value.GameMode.Name == "gamemode1").Value.FriendlyName); Assert.AreEqual("Fun Second Map", state.Maps.First(item => item.Value.Name == "map1" && item.Value.GameMode.Name == "gamemode2").Value.FriendlyName); }
public void TestPlayerModifiedAndPlayerInserted() { var state = new ProtocolState(); state.Players.TryAdd("1", new PlayerModel() { Uid = "1", Score = 1 }); var segment = new ProtocolStateSegment() { Players = new ConcurrentDictionary<String, PlayerModel>() }; segment.Players.TryAdd("1", new PlayerModel() { Uid = "1", Score = 100 }); segment.Players.TryAdd("2", new PlayerModel() { Uid = "2", Score = 200 }); state.Modified(segment); Assert.AreEqual(2, state.Players.Count); Assert.AreEqual(100, state.Players.First(item => item.Value.Uid == "1").Value.Score); Assert.AreEqual(200, state.Players.First(item => item.Value.Uid == "2").Value.Score); }
internal void start(JsonObject user, Action<JsonObject> callback) { this.transporter.start(); this.handshakeUser = user; this.handshakeCallback = callback; this.state = ProtocolState.handshaking; }
internal void start(JsonObject user, Action<JsonObject> callback) { this.transporter.start(); this.handshake.request(user, callback); this.state = ProtocolState.handshaking; }
private void ProcessPacket(byte[] packet) { // Extract the packet ID and data length. byte packetId = packet[0]; byte dataLength = packet[1]; // Verify the checksum. We have previously checked that packets are at least 3 bytes long. int i; byte checksum = 0; for (i = 0; i < packet.Length - 1; i++) checksum -= packet[i]; if (checksum != packet[packet.Length - 1]) { // Corrupt packet. NACK it. SendPacket(BuildNACKPacket(packetId)); } else if (packetId == (byte)PacketId.ACK) { // ACK. We can only have an unacknowledged packet if we are not in the Idle state. if ((protocolState != ProtocolState.Idle) && (dataLength > 0) && (packet[2] == unacknowledgedPacket[1])) { // Advance the protocol state. This is where multi-part communications are continued. switch (protocolState) { case ProtocolState.SendProductData: SendPacket(BuildProtocolArrayPacket(), ProtocolState.NeedAck); break; case ProtocolState.SendAlmanacStart: // We specified D550 as the data type, so we don't actually have to send any data. SendPacket(BuildTransferCompletePacket((Int16)CommandId.TRANSFER_ALM), ProtocolState.NeedAck); break; default: // No more steps, or not a multi-part communication. unacknowledgedPacket = null; protocolState = ProtocolState.Idle; break; } // If we are now idle, check if there is any PVT or satellite data // that needs to be sent. If we were idle when the PVT or satellite // data arrived, it would have already been sent. if ((protocolState == ProtocolState.Idle) && (pvtPacket != null)) { SendPacket(pvtPacket); pvtPacket = null; } if ((protocolState == ProtocolState.Idle) && (satDataPacket != null)) { SendPacket(satDataPacket); satDataPacket = null; } } } else if (packetId == (byte)PacketId.NACK) { // We only need to retransmit if we aren't in the Idle state. if ((protocolState != ProtocolState.Idle) && (dataLength > 0) && (packet[2] == unacknowledgedPacket[1])) SendPacket(unacknowledgedPacket); } else if (protocolState == ProtocolState.Idle) { // Can only accept new commands if we are idle. The exception to this would be the interruption of // a record transfer, but we don't send any records so we will never have this. if (packetId != (byte)PacketId.PRODUCT_RQST) SendPacket(BuildACKPacket(packetId)); switch (packetId) { case (byte)PacketId.PRODUCT_RQST: // This is the first packet of a conversation, so start from scratch. Reset(); // Need to send the ACK packet here as the reset will have cleared the send buffer. SendPacket(BuildACKPacket(packetId)); SendPacket(BuildProductDataPacket(ProductId, SoftwareVersion, ProductDescription), ProtocolState.SendProductData); break; case (byte)PacketId.UNLOCK_CODE: SendPacket(BuildUnlockResponsePacket(true), ProtocolState.NeedAck); break; /* case (byte)PacketId.ENABLE_ASYNC_EVENTS: if (dataLength > 0) { // Enable or disable async satellite data depending on // which bits are set. if (packet[2] == 0) sendAsyncSatData = false; else if ((packet[2] & 0x80) > 0) sendAsyncSatData = true; } break; */ case (byte)PacketId.COMMAND_DATA: if (dataLength > 0) { switch (packet[2]) { case (byte)CommandId.TRANSFER_ALM: // We always send an empty almanac. SendPacket(BuildRecordsPacket(0), ProtocolState.SendAlmanacStart); break; case (byte)CommandId.TRANSFER_TIME: DateTime utc = DateTime.UtcNow; SendPacket(BuildDateTimePacket((byte)utc.Month, (byte)utc.Day, (UInt16)utc.Year, (byte)utc.Hour, (byte)utc.Minute, (byte)utc.Second), ProtocolState.NeedAck); break; case (byte)CommandId.TRANSFER_UNIT_ID: // The Que software doesn't send an ACK for this packet, so don't expect one. SendPacket(BuildUnitIdPacket(UnitId)); //SendPacket(BuildUnitIdPacket(UnitId), ProtocolState.NeedAck); break; case (byte)CommandId.START_PVT_DATA: sendPVTData = true; sendSatData = true; break; case (byte)CommandId.STOP_PVT_DATA: sendPVTData = false; sendSatData = false; break; case (byte)CommandId.START_SAT_DATA: case (byte)CommandId.START_DIFF_SAT_DATA: sendSatData = true; break; } } break; } } else { // We are not idle, and the packet wasn't relevent to changing that. That probably means that // the received packet is out of sequence, but we simply use this as a trigger to check if a // retransmit is necessary. This is in the hopes that the other end is capable of recovering // from this situation, since we certainly aren't. DoRetransmissionCheck(); } }
private void SendPacket(byte[] packet, ProtocolState newProtocolState) { protocolState = newProtocolState; unacknowledgedPacket = packet; SendPacket(packet); }
public void TestMultipleItemPoolModified() { var state = new ProtocolState(); state.Items.TryAdd("1", new ItemModel() { Name = "1", FriendlyName = "Boring Item 1" }); state.Items.TryAdd("2", new ItemModel() { Name = "2", FriendlyName = "Boring Item 2" }); var segment = new ProtocolStateSegment() { Items = new ConcurrentDictionary<String, ItemModel>() }; segment.Items.TryAdd("1", new ItemModel() { Name = "1", FriendlyName = "Fun Item 1" }); segment.Items.TryAdd("2", new ItemModel() { Name = "2", FriendlyName = "Fun Item 2" }); state.Modified(segment); Assert.AreEqual(2, state.Items.Count); Assert.AreEqual("Fun Item 1", state.Items["1"].FriendlyName); Assert.AreEqual("Fun Item 2", state.Items["2"].FriendlyName); }
public void TestMultipleMapsModified() { var state = new ProtocolState(); state.Maps.TryAdd("gamemode1/map1", new MapModel() { Name = "map1", GameMode = new GameModeModel() { Name = "gamemode1" }, FriendlyName = "Boring Map 1" }); state.Maps.TryAdd("gamemode2/map2", new MapModel() { Name = "map2", GameMode = new GameModeModel() { Name = "gamemode2" }, FriendlyName = "Boring Map 2" }); var segment = new ProtocolStateSegment() { Maps = new ConcurrentDictionary<String, MapModel>() }; segment.Maps.TryAdd("gamemode1/map1", new MapModel() { Name = "map1", GameMode = new GameModeModel() { Name = "gamemode1" }, FriendlyName = "Fun Map 1" }); segment.Maps.TryAdd("gamemode2/map2", new MapModel() { Name = "map2", GameMode = new GameModeModel() { Name = "gamemode2" }, FriendlyName = "Fun Map 2" }); state.Modified(segment); Assert.AreEqual(2, state.Maps.Count); Assert.AreEqual("Fun Map 1", state.Maps.First(item => item.Value.Name == "map1").Value.FriendlyName); Assert.AreEqual("Fun Map 2", state.Maps.First(item => item.Value.Name == "map2").Value.FriendlyName); }
public ProtocolHandler() { state = ProtocolState.Idle; }
public void TestStateSandboxedNotNull() { IProtocolState state = new ProtocolState(); var controller = new SandboxProtocolController() { SandboxedProtocol = new MockIntegrationTestProtocol() { WaitingState = state } }; Assert.AreEqual(state, controller.State); }
public void TestSettingsModified() { var state = new ProtocolState() { Settings = new Settings() { Current = { ServerNameText = "Boring Name" } } }; state.Modified(new ProtocolStateSegment() { Settings = new Settings() { Current = { ServerNameText = "Fun Name" } } }); Assert.AreEqual("Fun Name", state.Settings.Current.ServerNameText); }
private void processHandshakeData(JsonObject msg) { //Handshake error if(!msg.ContainsKey("code") || !msg.ContainsKey("sys") || Convert.ToInt32(msg["code"]) != 200){ throw new Exception("Handshake error! Please check your handshake config."); } //Set compress data JsonObject sys = (JsonObject)msg["sys"]; JsonObject dict = new JsonObject(); if(sys.ContainsKey("dict")) dict = (JsonObject)sys["dict"]; JsonObject protos = new JsonObject(); JsonObject serverProtos = new JsonObject(); JsonObject clientProtos = new JsonObject(); if(sys.ContainsKey("protos")){ protos = (JsonObject)sys["protos"]; serverProtos = (JsonObject)protos["server"]; clientProtos = (JsonObject)protos["client"]; } messageProtocol = new MessageProtocol (dict, serverProtos, clientProtos); //Init heartbeat service int interval = 0; if(sys.ContainsKey("heartbeat")) interval = Convert.ToInt32(sys["heartbeat"]); heartBeatService = new HeartBeatService(interval, this); if(interval > 0){ heartBeatService.start(); } //send ack and change protocol state handshake.ack(); this.state = ProtocolState.working; //Invoke handshake callback JsonObject user = new JsonObject(); if(msg.ContainsKey("user")) user = (JsonObject)msg["user"]; handshake.invokeCallback(user); }
public void TestIpBanModifiedAndIpBanInserted() { var state = new ProtocolState(); state.Bans.TryAdd("Permanent/Ip/1", new BanModel() { Scope = { Times = { new TimeSubsetModel() { Context = TimeSubsetContext.Permanent } }, Players = new List<PlayerModel>() { new PlayerModel() { Ip = "1", Score = 1 } } } }); var segment = new ProtocolStateSegment() { Bans = new ConcurrentDictionary<String, BanModel>() }; segment.Bans.TryAdd("Permanent/Ip/1", new BanModel() { Scope = { Times = { new TimeSubsetModel() { Context = TimeSubsetContext.Permanent } }, Players = new List<PlayerModel>() { new PlayerModel() { Ip = "1", Score = 3 } } } }); segment.Bans.TryAdd("Permanent/Ip/2", new BanModel() { Scope = { Times = { new TimeSubsetModel() { Context = TimeSubsetContext.Permanent } }, Players = new List<PlayerModel>() { new PlayerModel() { Ip = "2", Score = 4 } } } }); state.Modified(segment); Assert.AreEqual(2, state.Bans.Count); Assert.AreEqual(3, state.Bans.First(ban => ban.Key == "Permanent/Ip/1").Value.Scope.Players.First().Score); Assert.AreEqual(4, state.Bans.Last(ban => ban.Key == "Permanent/Ip/2").Value.Scope.Players.First().Score); }
public void TestSingleNameBansSet() { var state = new ProtocolState(); state.Bans.TryAdd("Permanent/Name/1", new BanModel() { Scope = { Times = { new TimeSubsetModel() { Context = TimeSubsetContext.Permanent } }, Players = new List<PlayerModel>() { new PlayerModel() { Name = "1", Score = 1 } } } }); state.Bans.TryAdd("Time/Name/2", new BanModel() { Scope = { Times = { new TimeSubsetModel() { Context = TimeSubsetContext.Time } }, Players = new List<PlayerModel>() { new PlayerModel() { Name = "2", Score = 2 } } } }); var segment = new ProtocolStateSegment() { Bans = new ConcurrentDictionary<String, BanModel>() }; // Technically it would have an incorrect key, so next sync it would be // removed because it does not exist.. segment.Bans.TryAdd("Permanent/Name/1", new BanModel() { Scope = { Times = { new TimeSubsetModel() { Context = TimeSubsetContext.Time } }, Players = new List<PlayerModel>() { new PlayerModel() { Name = "1", Score = 1 } } } }); state.Set(segment); Assert.AreEqual(1, state.Bans.Count); Assert.AreEqual(TimeSubsetContext.Time, state.Bans.First().Value.Scope.Times.First().Context); }
public void TestSingleGroupPoolRemoved() { var state = new ProtocolState(); state.Groups.TryAdd("Team/1", new GroupModel() { Uid = "1", Type = GroupModel.Team, FriendlyName = "Boring Group 1" }); state.Groups.TryAdd("Team/2", new GroupModel() { Uid = "2", Type = GroupModel.Team, FriendlyName = "Boring Group 2" }); var segment = new ProtocolStateSegment() { Groups = new ConcurrentDictionary<String, GroupModel>() }; segment.Groups.TryAdd("Team/1", new GroupModel() { Uid = "1", Type = GroupModel.Team, FriendlyName = "Boring Group 1" }); state.Removed(segment); Assert.AreEqual(1, state.Groups.Count); Assert.AreEqual("Boring Group 2", state.Groups.First().Value.FriendlyName); }