/// <summary> /// 处理注册信息 /// </summary> /// <param name="c"></param> /// <param name="msgBase"></param> public void MessageRegister(ClientSocket clientSocket, MessageBase msgBase) { MessageRegister msg = (MessageRegister)msgBase; var rst = _useController.Register(msg.RegisterType, msg.Account, msg.Password, out string token); msg.Result = rst; _serverSocket.Send(clientSocket, msg); }
public void RegisterMessage_EmptyMessage_TrowsException() { var messageRegister = new MessageRegister(); var ex = Assert.Catch <Exception>(() => messageRegister.RegisterMessage(null)); StringAssert.Contains("Value cannot be null", ex.Message); }
/// <summary> /// 处理注册信息 /// </summary> /// <param name="clientSocket"></param> /// <param name="messageBase"></param> public static void MessageRegister(ClientSocket clientSocket, MessageBase messageBase) { MessageRegister messageRegister = (MessageRegister)messageBase; var rst = UserManager.Instance.Register(messageRegister.RegisterType, messageRegister.Username, messageRegister.Password, out string token); messageRegister.Result = rst; ServerSocket.Send(clientSocket, messageRegister); }
public void RegisterMessage_EmptyUser_TrowsException() { var messageRegister = new MessageRegister(); var user = new User { ChatId = "null", MessengerClass = null }; var message = new Message(user) { BasicText = "Test" }; var ex = Assert.Catch <Exception>(() => messageRegister.RegisterMessage(message)); StringAssert.Contains("Value cannot be null", ex.Message); }
public void RegisterMessage_UnknownMessage_ReturnsFirstLevelState() { var messageRegister = new MessageRegister(); var user = new User { ChatId = "123456", MessengerClass = nameof(FakeMessengerApi) }; var message = new Message(user) { BasicText = "Test" }; var states = messageRegister.RegisterMessage(message); Assert.AreEqual(UserStates.FirstLevel, states); }
public void GetState_EmptyUser_TrowsException() { var messageRegister = new MessageRegister(); var user = new User { ChatId = "null", MessengerClass = null }; var message = new Message(user) { BasicText = "Test" }; var ex = Assert.Catch <Exception>(() => messageRegister.GetState(message)); StringAssert.Contains("Message doesn't register", ex.Message); }
/// <summary> /// 注册协议提交 /// </summary> /// <param name="registerType"></param> /// <param name="username"></param> /// <param name="password"></param> /// <param name="code"></param> /// <param name="callback"></param> public static void Register(RegisterType registerType, string username, string password, string code , Action <RegisterResult> callback) { MessageRegister messageRegister = new MessageRegister(); messageRegister.RegisterType = registerType; messageRegister.Username = username; messageRegister.Password = password; messageRegister.Code = code; NetManager.Instance.SendMessage(messageRegister); NetManager.Instance.AddProtocalListener(ProtocolEnum.MessageRegister, (resmsg) => { MessageRegister message = (MessageRegister)resmsg; callback(message.Result); }); }
public void GetState_UnknownMessage_ThrowException() { var messageRegister = new MessageRegister(); var user = new User { ChatId = "123456", MessengerClass = nameof(FakeMessengerApi) }; var message = new Message(user) { BasicText = "Test" }; var ex = Assert.Catch <Exception>(() => messageRegister.GetState(message)); StringAssert.Contains("Message doesn't register", ex.Message); }
public void SetState_UnknownUser_SetStateToUser() { var messageRegister = new MessageRegister(); var user = new User { ChatId = "123456", MessengerClass = nameof(FakeMessengerApi) }; var message = new Message(user) { BasicText = "Test" }; messageRegister.SetState(message, UserStates.SecondLevel); var states = messageRegister.RegisterMessage(message); Assert.AreEqual(UserStates.SecondLevel, states); }
/// <summary> /// 注册协议提交 /// </summary> /// <param name="registerType"></param> /// <param name="userName"></param> /// <param name="password"></param> /// <param name="code"></param> /// <param name="callback"></param> public void Register(RegisterType registerType, string userName, string password, string code, Action <RegisterResult> callback) { MessageRegister msg = new MessageRegister(); msg.RegisterType = registerType; msg.Account = userName; msg.Password = password; msg.Code = code; _netController.RegisterProtoHandler(ProtocolEnum.MessageRegister, (message) => { MessageRegister msgRegister = (MessageRegister)message; callback(msgRegister.Result); }); _netController.SendMessage(msg); }
public bool SendMessageRegister() { OktoResultCodes resultCode = OktoResultCodes.OKTO_RESULT_TID_NOT_AVAILABLE; Random rand = new Random((int)DateTime.Now.Ticks); // // Deal with collisions on TenantId e.g. if sock shutdown slower than looping new runtime. // for (int tidInUseCount = 0; tidInUseCount < MAX_INVALID_TID_RETRIES && resultCode == OktoResultCodes.OKTO_RESULT_TID_NOT_AVAILABLE; tidInUseCount++) { TenantId = (uint)rand.Next(2000, int.MaxValue); MessageRegister mRegister = new MessageRegister(++SeqNo, TenantId, ALERT_VEC); resultCode = RegisterMessageSupport(conn, mRegister.Serialize, mRegister.SeqNo); } return(resultCode == OktoResultCodes.OKTO_RESULT_SUCCESS); }
public static void Init() { register = new MessageRegister(); }
public static void Dispose() { register.Dispose(); register = null; }
/// <summary> /// Called by a connection when it has received an intact and complete message in wire-format. /// Parses the supplied byte-array to generate a typed message for processing. /// On return from this routine the connection is free to overwrite the buffer contents. /// /// </summary> /// <param name="conn">Connection (think TCP to specific network agent) on which message arrived.</param> /// <param name="buff">Buffer encoding the message.</param> /// <param name="offset">Offset to start of message in the supplied buffer.</param> /// <param name="length">Length of message encoding in supplied buffer</param> public void ReceiveMessage(Connection conn, MessageTypes messageType, byte[] buff, int offset, int length) { switch (messageType) { case MessageTypes.MessageTypeRegister: { MessageRegister msgRegister = MessageRegister.CreateFromNetBytes(buff, offset); TenantId = msgRegister.TenantId; client.CallbackMessageRegister(conn, msgRegister.TenantId, msgRegister.AlertVec); MessageAck ack = new MessageAck(msgRegister.SeqNo, MessageTypes.MessageTypeRegisterAck, (uint)OktoResultCodes.OKTO_RESULT_SUCCESS); SendSynchronous(conn, ack.Serialize); conn.BeginReceive(); break; } case MessageTypes.MessageTypeIoFlowCreate: { MessageIoFlowCreate msgFlowc = MessageIoFlowCreate.CreateFromNetBytes(buff, offset); lock (LockLocal) { foreach (IoFlowMessageParams flowc in msgFlowc.ListParams) { Console.WriteLine("Agent MessageIoFlowCreate({0},{1})", flowc.FlowId, flowc.ParameterString); if (DictFlowCreateParams.ContainsKey(flowc.FlowId)) { throw new ArgumentOutOfRangeException(string.Format("Agent flowc dup FlowId {0}", flowc.FlowId)); } DictFlowCreateParams.Add(flowc.FlowId, flowc); } } MessageAck ack = new MessageAck(msgFlowc.SeqNo, MessageTypes.MessageTypeIoFlowCreateAck, (uint)OktoResultCodes.OKTO_RESULT_SUCCESS); SendSynchronous(conn, ack.Serialize); conn.BeginReceive(); break; } case MessageTypes.MessageTypeRapFsCreate: { MessageRapFsCreate msgRapc = MessageRapFsCreate.CreateFromNetBytes(buff, offset); lock (LockLocal) { foreach (MsgRapArg rapc in msgRapc.ListMsgRapArg) { Console.WriteLine("Agent MessageRapFsCreate({0},{1},{2})", rapc.FlowId, rapc.stringSid, rapc.ShareOrVolume); if (!DictFlowCreateParams.ContainsKey(rapc.FlowId)) { throw new ArgumentOutOfRangeException(string.Format("Agent rapc invalid FlowId {0}", rapc.FlowId)); } if (DictRapCreateParams.ContainsKey(rapc.FlowId)) { throw new ArgumentOutOfRangeException(string.Format("Agent rapc dup FlowId {0}", rapc.FlowId)); } if (!DictFlowCreateParams.ContainsKey(rapc.FlowId)) { throw new ArgumentOutOfRangeException(string.Format("Agent rapc unmatched FlowId {0}", rapc.FlowId)); } DictRapCreateParams.Add(rapc.FlowId, rapc); } } // // Params look reasonable and FlowCreate and RapCreate match up. // Now we can invite the client to create its IoFlows. // OktoResultCodes result = client.CallbackIoFlowCreate(DictFlowCreateParams, DictRapCreateParams); MessageAck ack = new MessageAck(msgRapc.SeqNo, MessageTypes.MessageTypeRapFsCreateAck, (uint)result); SendSynchronous(conn, ack.Serialize); conn.BeginReceive(); break; } case MessageTypes.MessageTypeStatsZero: { MessageStatsZero msgZero = MessageStatsZero.CreateFromNetBytes(buff, offset); OktoResultCodes result = client.CallbackMessageStatsZero(); MessageAck ack = new MessageAck(msgZero.SeqNo, MessageTypes.MessageTypeStatsZeroAck, (uint)result); SendSynchronous(conn, ack.Serialize); conn.BeginReceive(); break; } case MessageTypes.MessageTypeIoFlowUpdate: { MessageIoFlowUpdate msgFlowc = MessageIoFlowUpdate.CreateFromNetBytes(buff, offset); lock (LockLocal) { foreach (IoFlowMessageParams flowu in msgFlowc.ListParams) { if (!DictFlowCreateParams.ContainsKey(flowu.FlowId)) { throw new ArgumentOutOfRangeException(string.Format("Agent flowu invalid FlowId {0}", flowu.FlowId)); } } } OktoResultCodes result = client.CallbackMessageIoFlowUpdate(msgFlowc.ListParams); MessageAck ack = new MessageAck(msgFlowc.SeqNo, MessageTypes.MessageTypeIoFlowUpdateAck, (uint)result); SendSynchronous(conn, ack.Serialize); conn.BeginReceive(); break; } case MessageTypes.MessageTypeTenantDelete: { MessageTenantDelete msgTend = MessageTenantDelete.CreateFromNetBytes(buff, offset); OktoResultCodes result = client.CallbackMessageTenantDelete(); MessageAck ack = new MessageAck(msgTend.SeqNo, MessageTypes.MessageTypeTenantDeleteAck, (uint)result); SendSynchronous(conn, ack.Serialize); conn.BeginReceive(); break; } case MessageTypes.MessageTypeIoFlowStatsQuery: { MessageIoFlowStatsQuery msgStatsQ = MessageIoFlowStatsQuery.CreateFromNetBytes(buff, offset); List <IoFlowMessageParams> listStats = client.CallbackMessageIoFlowStatsQuery(); lock (LockLocal) { foreach (IoFlowMessageParams stats in listStats) { if (!DictFlowCreateParams.ContainsKey(stats.FlowId)) { throw new ArgumentOutOfRangeException(string.Format("Stats reply invalid FlowId {0}", stats.FlowId)); } } } MessageIoFlowStatsReply msgStatsReply = new MessageIoFlowStatsReply(msgStatsQ.SeqNo, listStats, TenantId); SendSynchronous(conn, msgStatsReply.Serialize); conn.BeginReceive(); break; } case MessageTypes.MessageTypeNameToStringSidBatchQuery: { MessageNameToStringSidBatchQuery msgSidBatchQuery = MessageNameToStringSidBatchQuery.CreateFromNetBytes(buff, offset); Dictionary <string, string> DictVmNameToSid = new Dictionary <string, string>(); System.Security.Principal.SecurityIdentifier sid = null; foreach (string vmName in msgSidBatchQuery.ListVmNames) { //XXXET: following two lines are for account names of type europe\ sid = VmSID.GetVMnameSid(vmName); if (sid == null) { try { NTAccount ntaccount = new NTAccount(vmName); sid = (SecurityIdentifier)ntaccount.Translate(typeof(SecurityIdentifier)); } catch (Exception e) { Debug.Assert(0 == 1, e.Message); } } Console.WriteLine("MessageTypeNameToStringSidBatchQuery: {0} sid {1}", vmName, sid.ToString()); DictVmNameToSid.Add(vmName, sid.ToString()); } MessageVmNameToStringSidBatchReply msgSidReply = new MessageVmNameToStringSidBatchReply(msgSidBatchQuery.SeqNo, (uint)OktoResultCodes.OKTO_RESULT_SUCCESS, DictVmNameToSid); SendSynchronous(conn, msgSidReply.Serialize); conn.BeginReceive(); break; } default: { string msg = string.Format("ReceiveMessage: unexpected message type {0}", messageType); throw new ApplicationException(msg); } } // switch }