public static void RegisterNewUser() { bool isUserCreated = false; var api = new API(); do { Console.Clear(); Console.Write("Enter new user name: \n"); var userName = Console.ReadLine(); Console.Write("Enter new password: \n"); var password = Console.ReadLine(); Console.Write("Enter new password again: \n"); var passwordVerify = Console.ReadLine(); var result = api.Register(userName, password, passwordVerify); if (result == false) { var input = RegisterMessage.Error(); if (input != "") { Console.Clear(); break; } } else { RegisterMessage.Success(userName, password); isUserCreated = true; } } while (isUserCreated == false); }
public bool Register(RegisterMessage message) { bool retval = false; if (string.IsNullOrEmpty(message.UserId) || string.IsNullOrEmpty(message.PublicKey)) { return(false); } try { byte[] publicKeyBuffer = Convert.FromBase64String(message.PublicKey); // Hash the public key. SHA256 hashalg = SHA256.Create(); byte[] publicKeyHashBuffer = hashalg.ComputeHash(publicKeyBuffer); string publicKeyHash = Convert.ToBase64String(publicKeyHashBuffer); retval = DAL.Instance.RegisterUser(message.UserId, publicKeyBuffer, publicKeyHash, message.DeviceName); } catch (Exception) { } return(retval); }
public void RegisterMessageSerializationTest() { var problemList = new List <string>() { "DVRP" }; var registerMessage = new RegisterMessage(EComponentType.TaskManager, 1, problemList); var result = registerMessage.SerializeToXml(); Assert.IsNotNull(result); Assert.AreNotEqual(0, result.Length); var xmlValidator = new XmlValidator(); var xsdSchemaFile = "RegisterMessage.xsd"; var xsdSchemaPath = Path.Combine(_xsdSchemasPath, xsdSchemaFile); var validationResult = xmlValidator.Validate(result, xsdSchemaPath, true); var errorsCount = validationResult.Errors.Count + validationResult.Warnings.Count; Assert.AreEqual(0, errorsCount); #region ExampleResult //<?xml version="1.0" encoding="utf-16"?> //<Register xmlns="http://www.mini.pw.edu.pl/ucc/"> // <Type>TaskManager</Type> // <SolvableProblems> // <ProblemName>DVRP</ProblemName> // </SolvableProblems> // <ParallelThreads>1</ParallelThreads> //</Register> #endregion }
public async Task <bool> CreateAdmin(RegisterMessage message) { var user = new User { Id = Guid.NewGuid().ToString(), Email = message.Email, Username = message.Username, Nickname = message.Username, Image = "default.png", Location = "", FollowersCount = 0, FollowingCount = 0, Verified = true }; _userContext.Add(user); _userContext.SaveChanges(); await _messagePublisher.PublishMessageAsync("NewAdminMessage", new { Id = user.Id, Email = user.Email, Username = user.Username, Password = message.Password }); await _messagePublisher.PublishMessageAsync("NewProfileMessage", new { Id = user.Id, Username = user.Username, Nickname = user.Nickname, Image = user.Image }); return(true); }
public RegisterReplyMessage addUser(RegisterMessage message, UserInfo user) { RegisterReplyMessage replyMessage = new RegisterReplyMessage(message); if (manager.database.conn.KeyExists("usernames:" + user.username)) { replyMessage.reply = RegisterReplyMessage.registerReply.USEREXISTS; return(replyMessage); } string id = Guid.NewGuid().ToString(); HashEntry[] entries = { new HashEntry("id", id), new HashEntry("username", user.username), new HashEntry("password", user.password), new HashEntry("permissions", (int)user.permissions) }; manager.database.conn.HashSet("user:"******"username", user.username), new HashEntry("id", id) }; manager.database.conn.HashSet("usernames:" + user.username, entries2); replyMessage.reply = RegisterReplyMessage.registerReply.SUCCESS; replyMessage.user = user; return(replyMessage); }
/// <summary> /// Sends a join request to RegistrarServer and returns the confirmation number. This method opens /// a connection to the server sends a request message, receives a response message and closes the /// connection to the server. /// </summary> /// <param name="groupIP">The group IP address to join</param> /// <param name="groupPort">The group port number to join</param> /// <returns>The RTP unicast port</returns> public int join(IPAddress groupIP, int groupPort) { try { // Creating and initializing the network related objects. TcpClient tcpC = new TcpClient(regSrvIP.AddressFamily); tcpC.Connect(regSrvIP, regSrvPort); NetworkStream netStream = tcpC.GetStream(); BinaryFormatter bf = new BinaryFormatter(); joiningMulticastEP = new IPEndPoint(groupIP, groupPort); // Building the message to be sent to RegistrarServer (MessageType: Join) RegisterMessage regMsg = new RegisterMessage(MessageType.Join, groupIP, groupPort); // Sending the message request object to the RegistrarSErver bf.Serialize(netStream, regMsg); // Receiving the message response object from the RegistrarServer Object obj = bf.Deserialize(netStream); regMsg = (RegisterMessage)obj; // Closing the server connection. tcpC.Close(); // Saving the confirmation number and RTP unicast port refSrvCookie = regMsg.confirmNumber; return(regMsg.unicastPort); } catch (Exception e) { eventLog.WriteEntry("Join request to server " + regSrvIP + ":" + regSrvPort + "for " + joiningMulticastEP + " failed. \n" + e.ToString(), System.Diagnostics.EventLogEntryType.Error, (int)RtpEL.ID.ReflectorJoinFailed); throw; } }
/// <summary> /// Initialize ChromaSDK and get SessionId. /// </summary> /// <param name="jsonMessage">Application information as JSON string</param> /// <returns>SessionId as string</returns> public async Task <string> Register(string jsonMessage) { var registerMessage = new RegisterMessage(jsonMessage); var response = await Request(registerMessage).ConfigureAwait(false);; var result = JsonConvert.DeserializeObject <Dictionary <string, string> >(response, new JsonSerializerSettings()); if (!result.ContainsKey("sessionid")) { throw new ChromaNetCoreApiException($"Error when register API client: {response}"); } sessionId = result["sessionid"]; var newExposedBaseAddress = new Uri(result["uri"]); #if DEBUG if (Bootstrapper.DebugMode) { newExposedBaseAddress = new Uri(result["uri"].Replace("localhost", "localhost.fiddler")); } #endif ClientConfiguration.ExposedBaseAddress = newExposedBaseAddress; return(sessionId); }
public void RegisterAtServer() { var registerMessage = new RegisterMessage() { ParallelThreads = 1,//??? SolvableProblems = new string[] { "DVRP" }, Type = RegisterType.TaskManager }; var messageString = SerializeMessage(registerMessage); var socket = communicationModule.SetupClient(); communicationModule.Connect(socket); communicationModule.SendData(messageString, socket); var response = communicationModule.ReceiveData(socket); var deserializedResponse = DeserializeMessage <RegisterResponseMessage>(response); this.NodeId = deserializedResponse.Id; this.Timeout = deserializedResponse.TimeoutTimeSpan; communicationModule.CloseSocket(socket); _logger.Info("Succesfully registered at server. Assigned id: " + this.NodeId + " received timeout: " + deserializedResponse.Timeout); }
/// <summary> /// Sends a leave request to RegistrarServer for groupIP and groupPort. This method opens /// a connection to the server sends a request message, receives a response message and closes the /// connection to the server. /// </summary> /// <param name="groupIP">The group IP address to leave</param> /// <param name="groupPort">The group Port number to leave</param> /// <param name="confirmNumber">The confirmation number received from the RegistrarServer at the join time</param> public void leave() { try { // Creating and initializing the network related objects. TcpClient tcpC = new TcpClient(regSrvIP.AddressFamily); tcpC.Connect(regSrvIP, regSrvPort); NetworkStream netStream = tcpC.GetStream(); BinaryFormatter bf = new BinaryFormatter(); // Building the message to be sent to RegistrarServer (MessageType: Leave) RegisterMessage regMsg = new RegisterMessage(MessageType.Leave, joiningMulticastEP.Address, joiningMulticastEP.Port, refSrvCookie); // Sending the message request object to the RegistrarSErver bf.Serialize(netStream, regMsg); // Receiving the message response object from the RegistrarServer Object obj = bf.Deserialize(netStream); regMsg = (RegisterMessage)obj; // Closing the server connection tcpC.Close(); } catch (Exception e) { eventLog.WriteEntry("Leave request to server " + regSrvIP + ":" + regSrvPort + "for " + joiningMulticastEP + " failed. \n" + e.ToString(), System.Diagnostics.EventLogEntryType.Error, (int)RtpEL.ID.ReflectorJoinFailed); } }
public void Parse_XMLString_RegisterMessage() { /*********** Actual message ***********/ string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"xml_samples\Register.xml"); XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(path); string xmlStr = xmlDoc.OuterXml; string name = Message.GetMessageName(xmlStr); RegisterMessage actualMessage = null; if (name == RegisterMessage.ELEMENT_NAME) { actualMessage = RegisterMessage.Construct(xmlStr); } /*********** Expected message ***********/ RegisterType type = RegisterType.TaskManager; byte threads = 3; string[] problems = { "TSP", "GraphColoring" }; RegisterMessage expectedMessage = new RegisterMessage(type, threads, problems); expectedMessage.Deregister = true; expectedMessage.Id = 5; Assert.AreEqual(expectedMessage, actualMessage); }
private bool registerExistingNode(RegisterMessage message, Socket socket) { NetworkNode node = new NetworkNode(message.Type, message.Id, (uint)systemTracker.Timeout, message.ParallelThreads, message.SolvableProblems, clientTracker.BackupServers); IPAddress address = (socket.RemoteEndPoint as IPEndPoint).Address; int port = (ushort)Server.PRIMARY_PORT; // TODO hack if (clientTracker.BackupServers.Length == 1) { port = (ushort)Server.PRIMARY_PORT2; } node.Address = address; node.Port = (ushort)port; // Dont inform backup about it self // It comes naturally in NoOperation message if (node.Type == RegisterType.CommunicationServer && (server.Address.ToString().Equals(address.ToString()) && server.Port == port)) { return(false); } SmartConsole.PrintLine("Backup adding existing node", SmartConsole.DebugLevel.Advanced); clientTracker.AddNode(node); return(true); }
public static void ForceLeave(ClientEntry client) { RegisterMessage leaveMessage = new RegisterMessage(MessageType.Leave, client.GroupEP.Address, client.GroupEP.Port, client.ConfirmNumber); ProcessLeaveRequest(leaveMessage, client.ClientIP); }
public void RegistrationMessageIsAcceptedAndRegisterResponseMessageIsPassedBack() { var waitHandle = new AutoResetEvent(false); var msg = new RegisterMessage { ParallelThreads = 5, SolvableProblems = new List <string> { "dvrp" }, ComponentType = ComponentType.ComputationalNode }; var rawMsg = _marshaller.Marshall(new Message[] { msg }); Message outputMessage = null; ProcessedDataCallback c = response => { outputMessage = _marshaller.Unmarshall(response)[0]; waitHandle.Set(); }; _processor.StartProcessing(); _processor.EnqueueDataToProcess(rawMsg, null, c); waitHandle.WaitOne(10000); _processor.StopProcessing(); Assert.IsInstanceOfType(outputMessage, typeof(RegisterResponseMessage)); }
public void RegistrationMessageIsAcceptedAndItsCallbackInvoked() { var waitHandle = new AutoResetEvent(false); var callbackCalled = false; var msg = new RegisterMessage { ComponentType = ComponentType.TaskManager, ParallelThreads = 5, SolvableProblems = new List <string> { "dvrp" } }; var rawMsg = _marshaller.Marshall(new Message[] { msg }); ProcessedDataCallback c = response => { callbackCalled = true; waitHandle.Set(); }; _processor.StartProcessing(); _processor.EnqueueDataToProcess(rawMsg, null, c); waitHandle.WaitOne(5000); _processor.StopProcessing(); Assert.IsTrue(callbackCalled); }
/// <summary> /// Register user in database and return his token for api calls. /// </summary> /// <param name="username"></param> /// <param name="password"></param> /// <param name="facebookId"></param> /// <returns></returns> public string Register(string username, string password, string facebookId = "") { var message = new RegisterMessage() { FacebookId = facebookId, Username = username, Password = password }; var httpResponse = HttpRequestHelper.PostObjectAsync(Endpoint + "/register", message).Result; var body = HttpRequestHelper.GetContent(httpResponse).Result; var statusCode = HttpRequestHelper.GetStatusCode(httpResponse); if (statusCode != HttpStatusCode.OK) { throw new Exception(body); } // setup token var token = JsonConvert.DeserializeObject <string>(body); if (!string.IsNullOrWhiteSpace(token)) { UserToken.Token = token; } return(token); }
public async Task <ActionResult <RegisterMessage> > CreateMessage([FromBody] RegisterMessage message) { RegisterMessage result = this.Manager.CreateMessage(message, this.Identity); await this.HubContext.Clients.AllExcept(new string[] { this.Identity.ID }).SendAsync("onNewMessage", result); return(this.Ok(result)); }
protected override bool _GetPlayerInfo(NetworkReader reader, int connectionId, out short type, out int roomIndex, out int playerIndex) { type = 0; roomIndex = -1; playerIndex = -1; if (__roomMap == null) { return(false); } RegisterMessage message = reader == null ? null : reader.ReadMessage <RegisterMessage>(); if (message == null) { return(false); } Room room; if (!__roomMap.TryGetValue(message.roomName, out room) || room == null) { return(false); } if (__playerMap == null) { __playerMap = new Dictionary <string, Player>(); } Player player; if (!__playerMap.TryGetValue(message.name, out player)) { if (!room.isRunning && GetCount(room.index) > 3) { return(false); } player.index = GetRoomNextIndex(room.index); player.roomName = message.roomName; __playerMap.Add(message.name, player); if (__playerNames == null) { __playerNames = new Pool <string>(); } __playerNames.Insert(nextNodeIndex, message.name); } type = (short)(player.index >= 0 && player.index < 4 ? (player.index + 4 - room.dealerIndex) & 3 : 4); roomIndex = room.index; playerIndex = player.index; return(true); }
public void Receive(Message msg) { if (!Connected) { return; } if (msg is AuthMessage authmsg) { if (Authed) //Someone tried to auth twice? { return; } Character = new Character { Client = this, Name = authmsg.Mail }; Send(new AuthConfirmMessage()); Send(new GMChangedMessage { IsGM = true }); Send(new TimeTurnMessage { Time = DateTime.UtcNow, TurnEnd = DateTime.UtcNow.AddHours(1) }); Authed = true; return; } else if (msg is RegisterMessage) { RegisterMessage regMsg = (RegisterMessage)msg; UserModel registeredUser = new UserModel(regMsg.Mail, regMsg.Password); if (Server.RegisterUser(registeredUser)) { Send(new RegisterResponeMessage { Response = RegisterResponse.Ok }); //TODO: Get a db } else { Send(new RegisterResponeMessage { Response = RegisterResponse.NameTaken }); } } if (!Authed) { return; } if (msg is SpeechMessage speechmsg) { Character.Speak(speechmsg.Text); } }
private RegisterMessage CreateRegisterMessage(ref Register register) { RegisterMessage message = new RegisterMessage(base.messageVersion, ref register); if (register.SupportingToken != null) { CoordinationServiceSecurity.AddSupportingToken(message, register.SupportingToken); } return message; }
public async Task <RegisterResponse> Register(RegisterMessage authorizeMessage) { var result = await HttpNetworkService.Post( JsonDecoder.Serialize(authorizeMessage), string.Concat(baseLobbyUrl, NetworkConfig.RegisterUrl) ); return(new RegisterResponse()); }
private void WSConnected(object sender, EventArgs e) { RegisterMessage registerMessage = new RegisterMessage(); registerMessage.roomId = this.m_roomId; registerMessage.signalingKey = this.m_signalingKey; Debug.Log("Signaling: WS connected."); this.WSSend(JsonUtility.ToJson(registerMessage)); }
/// <summary> /// Gets RegisterMessage specified for this component. /// </summary> /// <returns>A proper RegisterMessage.</returns> private RegisterMessage GetRegisterMessage() { var registerMessage = new RegisterMessage { ComponentType = ComponentType, ParallelThreads = _threadManager.ParallelThreads, SolvableProblems = new List <string>(TaskSolvers.Keys) }; return(registerMessage); }
public static void Regist(string user, string pass, string nickname) { var msg = new RegisterMessage() { Name = user, NickName = nickname, Pass = pass, }; MessageManager.SendMessage("Client.Send", msg); }
public async void Register (string deviceId, Guid multiplayerChallengeId) { try { var registerMsg = new RegisterMessage (deviceId, multiplayerChallengeId); string message = JsonConvert.SerializeObject (registerMsg, jsonSerializerSettings); await connectionService.Send (message); Debug.WriteLine ("sent register message: " + message); } catch (Exception e) { Debug.WriteLine ("registering failed: " + e.Message); } }
public void Register() { var msg = new RegisterMessage("Username", "Password"); Assert.AreEqual("Username", msg.Username); Assert.AreEqual("Password", msg.Password); msg = msg.AssertLengthMatches(); Assert.AreEqual("Username", msg.Username); Assert.AreEqual("Password", msg.Password); }
public void Register(string v, Deck deck) { if (RegistrationSent) { return; } RegistrationSent = true; var registerMessage = new RegisterMessage(v, deck); Send(new NetworkMessage(MessageTypes.RegisterForGame, registerMessage, Player.Id, NetworkId.Generate())); }
public async Task Register() { var registerMsg = new RegisterMessage(); registerMsg.challengeId = challengeId; registerMsg.deviceId = deviceId; var registerMessage = new MessageFrame("register", registerMsg); string message = JsonConvert.SerializeObject(registerMessage); await connection.SendAsync(message); Debug.WriteLine("sent register message: " + message); }
/// <summary> /// registers the component to server /// </summary> /// <param name="endpoint"></param> public void Register(IPEndPoint endpoint) { _tcpClient.Connect(endpoint); var listen = new Thread(ListenForMessages); listen.Start(); var msg = new RegisterMessage(Type, MaxParallelThreads, SolvableProblems); SendMessage(msg.Serialize()); }
public void RegisterMessageDeserializationTest() { var problemList = new List <string>() { "DVRP" }; var registerMessage = new RegisterMessage(EComponentType.TaskManager, 1, problemList); var result = Message.Deserialize <RegisterMessage>(registerMessage.SerializeToXml()); Assert.AreEqual("DVRP", result.SolvableProblems[0]); }
private static RegisterMessage ProcessLeaveRequest(RegisterMessage leaveRequestMessage, IPAddress senderIP) { try { lock (clientRegTable.SyncRoot) { if (clientRegTable.ContainsKey(senderIP)) { bool drop = true; clientRegTable.Remove(senderIP); ReflectorMgr.PC[ReflectorPC.ID.CurrentParticipats] = clientRegTable.Count; // Drop membership if no other member exists foreach (ClientEntry entry in clientRegTable.Values) { if (entry.GroupEP.Address.Equals(leaveRequestMessage.groupIP)) { drop = false; break; } } if (drop) { if (leaveRequestMessage.groupIP.AddressFamily == AddressFamily.InterNetwork) { MulticastOption mo = new MulticastOption(leaveRequestMessage.groupIP, ReflectorMgr.MulticastInterfaceIP); ReflectorMgr.Sockets.SockMCv4RTP.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.DropMembership, mo); ReflectorMgr.Sockets.SockMCv4RTCP.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.DropMembership, mo); } else { IPv6MulticastOption mo = new IPv6MulticastOption(leaveRequestMessage.groupIP); ReflectorMgr.Sockets.SockMCv6RTP.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.DropMembership, mo); ReflectorMgr.Sockets.SockMCv6RTCP.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.DropMembership, mo); } } return(new RegisterMessage(MessageType.Confirm, leaveRequestMessage.groupIP, leaveRequestMessage.groupPort, leaveRequestMessage.confirmNumber)); } else { // No entries found for the leave request return(new RegisterMessage(MessageType.LeaveWithoutJoinError, IPAddress.Any)); } } } catch { return(new RegisterMessage(MessageType.UnknownError, IPAddress.Any)); } }
/// <summary> /// Constructs message by given xml string /// </summary> /// <param name="xmlString"> /// xml in string /// </param> /// <returns> /// Message constructed by the xml /// </returns> public static Message Construct(string xmlString) { xmlString = concCompabilityIssuesStringWojtekIsGay(xmlString); if (GetMessageName(xmlString) == RegisterMessage.ELEMENT_NAME) { return(RegisterMessage.Construct(xmlString)); } if (GetMessageName(xmlString) == DivideProblemMessage.ELEMENT_NAME) { return(DivideProblemMessage.Construct(xmlString)); } if (GetMessageName(xmlString) == NoOperationMessage.ELEMENT_NAME) { return(NoOperationMessage.Construct(xmlString)); } if (GetMessageName(xmlString) == RegisterResponseMessage.ELEMENT_NAME) { return(RegisterResponseMessage.Construct(xmlString)); } if (GetMessageName(xmlString) == SolutionRequestMessage.ELEMENT_NAME) { return(SolutionRequestMessage.Construct(xmlString)); } if (GetMessageName(xmlString) == SolutionsMessage.ELEMENT_NAME) { return(SolutionsMessage.Construct(xmlString)); } if (GetMessageName(xmlString) == SolvePartialProblemsMessage.ELEMENT_NAME) { try { //return SolvePartialProblemsMessage.Construct(xmlString); } catch (InvalidOperationException e) { return(null); } Console.WriteLine("******** SOLVE PARTIAL PROBLEM MESSAGE **************"); return(SolvePartialProblemsMessage.Construct(xmlString)); } if (GetMessageName(xmlString) == SolveRequestMessage.ELEMENT_NAME) { return(SolveRequestMessage.Construct(xmlString)); } if (GetMessageName(xmlString) == SolveRequestResponseMessage.ELEMENT_NAME) { return(SolveRequestResponseMessage.Construct(xmlString)); } if (GetMessageName(xmlString) == StatusMessage.ELEMENT_NAME) { return(StatusMessage.Construct(xmlString)); } return(null); }
public static RegisterMessage CreateRegisterMessage() { RegisterType type = RegisterType.TaskManager; byte threads = 3; string[] problems = { "TSP", "GraphColoring" }; RegisterMessage expectedMessage = new RegisterMessage(type, threads, problems); expectedMessage.Deregister = true; expectedMessage.Id = 5; return(expectedMessage); }
public async Task <IActionResult> Post([FromBody] RegisterMessage command) { Customer customer = await register.Handle(command); CustomerData result = new CustomerData { CustomerId = customer.Id, Name = customer.Name.Text, Personnummer = customer.PIN.Text }; return(CreatedAtRoute("GetCustomer", new { id = result.CustomerId }, result)); }
public async Task<bool> Register(RegisterMessage message) { bool retval = false; var info = await HttpContext.Authentication.GetAuthenticateInfoAsync(Constants.PrimaryAuthenticationType); var sub = info.Principal.Claims.Where(x => x.Type == JwtClaimTypes.Subject).Select(x => x.Value).FirstOrDefault(); var user = _signInService.FindBySubject(sub); if (user == null || message.PublicKey == null) { return false; } try { SHA256 hashalg = SHA256.Create(); byte[] publicKeyHashBuffer = hashalg.ComputeHash(Encoding.UTF8.GetBytes(message.PublicKey)); string publicKeyHash = Convert.ToBase64String(publicKeyHashBuffer); retval = _credentialService.RegisterCredential(message.UserId, message.PublicKey, publicKeyHash, message.DeviceName); } catch (Exception) { } return retval; }