public void RegisterResponseMessageSerializationTest()
{
var registerResponseMessage = new RegisterResponseMessage(123123123L, DateTime.Now);
var result = registerResponseMessage.SerializeToXml();
Assert.IsNotNull(result);
Assert.AreNotEqual(0, result.Length);
var xmlValidator = new XmlValidator();
var xsdSchemaFile = "RegisterResponseMessage.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"?>
//<RegisterResponse xmlns="http://www.mini.pw.edu.pl/ucc/">
// <Id>123123123</Id>
// <Timeout>2014-03-07T23:25:05.0728496+01:00</Timeout>
//</RegisterResponse>
#endregion
}
public void Parse_XMLString_RegisterResponseMessage()
{
/*********** Actual message ***********/
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"xml_samples\RegisterResponse.xml");
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(path);
string xmlStr = xmlDoc.OuterXml;
string name = Message.GetMessageName(xmlStr);
RegisterResponseMessage actualMessage = null;
if (name == RegisterResponseMessage.ELEMENT_NAME)
{
actualMessage = RegisterResponseMessage.Construct(xmlStr);
}
/*********** Expected message ***********/
ulong id = 9;
uint timeout = 11111;
BackupCommunicationServer[] backupServers =
{
new BackupCommunicationServer("192.168.1.10", 80),
new BackupCommunicationServer("192.168.1.11", 80),
};
RegisterResponseMessage expectedMessage = new RegisterResponseMessage(id, timeout, backupServers);
Assert.AreEqual(expectedMessage, actualMessage);
}
public void Parse_RegisterResponseMessage_XMLString()
{
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"xml_samples\RegisterResponse.xml");
ulong id = 9;
uint timeout = 11111;
BackupCommunicationServer[] backupServers =
{
new BackupCommunicationServer("192.168.1.10", 80),
new BackupCommunicationServer("192.168.1.11", 80),
};
RegisterResponseMessage message = new RegisterResponseMessage(id, timeout, backupServers);
//message.ToXmlFile(path);
string actualXmlStr = message.ToXmlString();
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(path);
string expectedXmlStr = xmlDoc.OuterXml;
Assert.AreEqual(expectedXmlStr, actualXmlStr);
}
private async Task SendRegisterResponse(bool success)
{
var msg = new RegisterResponseMessage {
success = success
};
await SendMessage(msg);
}
public async Task <(bool success, string message)> RegisterAsync(string username)
{
RegisterResponseMessage response = await connection.RequestAsync <RegisterResponseMessage>(new RegisterMessage(username));
bool registered = response?.Registered ?? false;
return(registered, response?.Message);
}
private void handleRegisterResponsenMessage(MessagePackage package)
{
RegisterResponseMessage message = (RegisterResponseMessage)package.Message;
systemTracker.Node.Id = message.Id;
systemTracker.Node.Timeout = message.Timeout;
systemTracker.Node.BackupServers = message.BackupCommunicationServers;
clientTracker.BackupServers = message.BackupCommunicationServers;
}
/// <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 void RegisterResponseMessageSerialization()
{
string testData = System.IO.File.ReadAllText(@"XMLTestData\RegisterResponseMessage.xml");
var serializer = new ComputationSerializer <RegisterResponseMessage>();
var registerResponseMessage = new RegisterResponseMessage()
{
Id = 1,
Timeout = "01:00:00",
};
var result = serializer.Serialize(registerResponseMessage);
Assert.AreEqual(result, testData);
}
public static RegisterResponseMessage CreateRegisterResponseMessage()
{
ulong id = 9;
uint timeout = 11111;
BackupCommunicationServer[] backupServers =
{
new BackupCommunicationServer("192.168.1.10", 80),
new BackupCommunicationServer("192.168.1.11", 80),
};
RegisterResponseMessage expectedMessage = new RegisterResponseMessage(id, timeout, backupServers);
return(expectedMessage);
}
private string ProcessCaseRegister(string message)
{
var registerMessage = DeserializeMessage <RegisterMessage>(message);
var newId = GenerateNewNodeId();
RegisterNode(newId, registerMessage.Type, registerMessage.SolvableProblems.ToList(),
registerMessage.ParallelThreads);
var registerResponse = new RegisterResponseMessage()
{
Id = newId,
TimeoutTimeSpan = this.DefaultTimeout
};
return(SerializeMessage(registerResponse));
}
public ActionResult Index(LoginAndRegisterViewModel loginAndRegisterViewModel)
{
if (loginAndRegisterViewModel.loginRequestMessage != null)
{
var response = client.PostAsJsonAsync("https://mtsk-proje.herokuapp.com/api/users/login", loginAndRegisterViewModel.loginRequestMessage);
response.Wait();
var q = response.Result;
var responseString = q.Content.ReadAsStringAsync();
LoginResponseMessage message = new LoginResponseMessage();
message = JsonConvert.DeserializeObject <LoginResponseMessage>(responseString.Result);
if (message.Success == 1)
{
Session["token"] = message.Token;
return(RedirectToAction("Index", "Home"));
}
else
{
ViewBag.alert = "danger";
ViewBag.result = "Kullanıcı adı veya şifre hatalı!";
return(View());
}
}
else
{
var response = client.PostAsJsonAsync("https://mtsk-proje.herokuapp.com/api/users", loginAndRegisterViewModel.registerRequestMessage);
response.Wait();
var q = response.Result;
var responseString = q.Content.ReadAsStringAsync();
RegisterResponseMessage message = new RegisterResponseMessage();
message = JsonConvert.DeserializeObject <RegisterResponseMessage>(responseString.Result);
if (message.success == 1)
{
ViewBag.alert = "success";
ViewBag.result = "Kayıt başarılı!";
return(View());
}
else
{
ViewBag.alert = "danger";
ViewBag.result = "Kayıt yapılamadı!";
return(View());
}
}
}
/// <summary>
/// Register new node - Primary server job
/// </summary>
private void registerNewNode(RegisterMessage message, Socket socket)
{
// Place holder, have to fetch info from the System.
ulong id = systemTracker.GetNextClientID();
uint timeout = (uint)systemTracker.Timeout;
SmartConsole.PrintLine("Adding new Node", SmartConsole.DebugLevel.Advanced);
NetworkNode node = new NetworkNode(message.Type, id, timeout, message.ParallelThreads, message.SolvableProblems,
clientTracker.BackupServers);
node.LastSeen = DateTime.Now;
// Backup Server
if (node.Type == RegisterType.CommunicationServer)
{
// update Node
IPAddress address = (socket.RemoteEndPoint as IPEndPoint).Address;
int port = (ushort)Server.PRIMARY_PORT;
node.Address = address;
// TODO hack
if (clientTracker.BackupServers.Length == 1)
{
port = (ushort)Server.PRIMARY_PORT2;
}
node.Port = (ushort)port;
}
// Add the node to system
clientTracker.AddNode(node);
RegisterResponseMessage response = new RegisterResponseMessage(id, timeout, clientTracker.BackupServers);
server.Send(socket, response);
RegisterMessage backUpmessage = new RegisterMessage(message.Type, message.ParallelThreads, message.SolvableProblems);
backUpmessage.Id = id;
InformBackup(backUpmessage);
}
public void RegisterResponseMessageXmlIsProperlySerializedAndDeserialized()
{
var si = new ServerInfo
{
IpAddress = "192.168.1.0",
Port = 9001
};
var message = new RegisterResponseMessage
{
AssignedId = 5,
BackupServers = new List <ServerInfo> {
si
},
CommunicationTimeout = 50
};
var serializedMessage = _serializer.Serialize(message);
var deserializedMessage = _serializer.Deserialize(serializedMessage);
Assert.IsInstanceOfType(deserializedMessage, typeof(RegisterResponseMessage));
}
/// <summary>
/// Handle registration message.
/// </summary>
/// <param name="msg">Register message.</param>
/// <param name="metadata">Information about data and the TCP connection it came from.</param>
/// <returns>List of response messages.</returns>
private List <Message> HandleMessage(RegisterMessage msg, TcpDataProviderMetadata metadata)
{
ComponentInfo componentInfo;
switch (msg.ComponentType)
{
case ComponentType.CommunicationServer:
var serverInfo = new ServerInfo
{
IpAddress = metadata.SenderAddress.Address.ToString(),
Port = (ushort)metadata.SenderAddress.Port
};
componentInfo = new BackupServerInfo(serverInfo, msg.ParallelThreads);
break;
case ComponentType.ComputationalNode:
case ComponentType.TaskManager:
componentInfo = new SolverNodeInfo(msg.ComponentType, msg.SolvableProblems, msg.ParallelThreads);
break;
default:
throw new InvalidOperationException("Invalid component type registration (" + msg.ComponentType +
").");
}
_componentOverseer.TryRegister(componentInfo);
var responseMsg = new RegisterResponseMessage
{
AssignedId = componentInfo.ComponentId.Value,
BackupServers = CreateBackupList(),
CommunicationTimeout = _componentOverseer.CommunicationTimeout
};
return(new List <Message> {
responseMsg
});
}
/// <summary>
/// generates id for the component, adds it to an adequate list, and sends returning message
/// </summary>
/// <param name="client"></param>
/// <param name="type"></param>
/// <param name="parallelThreads"></param>
/// <param name="solvableProblems"></param>
public void RegisterComponent(TcpClient client, EComponentType type, int parallelThreads = 1, List <string> solvableProblems = null)
{
var componentsInfo = new ComponentsInfo(type, ++_maxComponentId, client, _timeout, parallelThreads, solvableProblems);
componentsInfo.ComponentTimedOut += componentsInfo_ComponentTimedOut;
switch (type.ToString())
{
case ("TaskManager"):
_taskManagers.Add(componentsInfo);
break;
case ("ComputationalNode"):
_computationalNodes.Add(componentsInfo);
break;
case ("ComputationalClient"):
_computationalClients.Add(componentsInfo);
break;
}
var responseMsg = new RegisterResponseMessage(_maxComponentId, DateTime.Now);
SendMessage(responseMsg.Serialize(), client);
EventLogger.GetLog().InfoFormat("Zarejestrowano {0} z Id:{1}", componentsInfo.Type, componentsInfo.Id);
}
public void Execute(Server server, TcpClient client, IMessage message)
{
RegisterMessage registerMessage = message as RegisterMessage;
User test = server.GetUsers().Find(u => u.Username == registerMessage.Username);
RegisterResponseMessage registerResponseMessage = new RegisterResponseMessage
{
Success = false
};
bool authenticatedServerPassword = true;
if (server.HasPassword())
{
authenticatedServerPassword = server.CheckPassword(registerMessage.ServerPassword);
}
if (authenticatedServerPassword)
{
if (!IsValid(server, registerMessage.Username, registerMessage.Password))
{
registerResponseMessage.Content = errorMessage;
}
else
{
//int id = server.GetUsers().OrderBy(u => u.Id).Last().Id + 1;
User user = new User
{
Id = server.GetNextUserId(),
Username = registerMessage.Username.Trim(),
Password = registerMessage.Password,
SessionIds = new List <string>(),
tcpClients = new List <TcpClient>()
};
server.AddUser(user);
user.tcpClients.Add(client);
server.SaveUsers();
registerResponseMessage.Content = "New User created";
string sessionId = Guid.NewGuid().ToString();
user.SessionIds.Add(sessionId);
registerResponseMessage.SessionId = sessionId;
server.AddClient(client);
UserCountMessage userCountMessage = new UserCountMessage
{
UserCount = server.GetUsers().Count,
UserOnlineCount = server.GetUsers().Count(u => u.SessionIds.Count > 0)
};
string userCountMessageJson = JsonSerializer.Serialize(userCountMessage);
byte[] userCountMessageBytes = System.Text.Encoding.UTF8.GetBytes(userCountMessageJson);
UserListRequestMessage userListRequestMessage = message as UserListRequestMessage;
var query = from u in server.GetUsers() select new { u.Id, u.Username };
var userList = query.ToList();
string userListJson = JsonSerializer.Serialize(userList);
UserListResponseMessage userListResponseMessage = new UserListResponseMessage
{
UserListJson = userListJson
};
string messageJson = JsonSerializer.Serialize(userListResponseMessage);
byte[] byteMessage = Encoding.UTF8.GetBytes(messageJson);
foreach (TcpClient remoteClient in server.GetClients())
{
if (remoteClient != client)
{
remoteClient.GetStream().Write(byteMessage, 0, byteMessage.Length);
}
remoteClient.GetStream().Write(userCountMessageBytes, 0, userCountMessageBytes.Length);
}
}
}
bool authenticated = IsValid(server, registerMessage.Username, registerMessage.Password) && authenticatedServerPassword;
registerResponseMessage.Success = authenticated;
string json_response = JsonSerializer.Serialize(registerResponseMessage);
byte[] msg = System.Text.Encoding.UTF8.GetBytes(json_response);
client.GetStream().Write(msg, 0, msg.Length);
}
public static void SendRegisterResponse(Microsoft.Transactions.Wsat.Messaging.RequestAsyncResult result, ref RegisterResponse response)
{
Message reply = new RegisterResponseMessage(result.MessageVersion, ref response);
result.Finished(reply);
}
static void Main(string[] args)
{
EventLogger.AddAppender(new Log4NetAppender());
var ipAddress = "127.0.0.1";
var port = 8123;
IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse(ipAddress), port);
Console.WriteLine("Choose component: \n"
+ "1 ComputationalClient\n"
+ "2 TaskManager\n"
+ "3 ComputationalNode\n");
Console.WriteLine("Select: ");
int componentType;
int.TryParse(Console.ReadLine(), out componentType);
Component component = new ComputationalClient();
switch (componentType)
{
case 1:
component = new ComputationalClient();
break;
case 2:
component = new TaskManager();
break;
case 3:
component = new ComputationalNode();
break;
}
component.SolvableProblems = new List <string>()
{
"MultiplyProblem", "DVRP"
};
component.Register(endPoint);
var filePath = @"DvrpData\okulD.vrp";
var problem = new DvrpProblem(new DvrpProblemData(filePath));
//var problem = new MultiplyProblem(10, 3, 1000000);
while (true)
{
Common.Abstractions.Message msg = null;
int result;
Console.WriteLine("RegisterMessage was sent\n"
+ "Choose another message: \n"
+ "1 RegisterMessage\n"
+ "2 RegisterResponseMessage\n"
+ "3 StatusMessage\n"
+ "4 SolveRequestMessage\n"
+ "5 SolveRequestResponseMessage\n"
+ "6 DivideProblemMessage\n"
+ "7 SolutionRequestMessage\n"
+ "8 PartialProblemsMessage\n"
+ "9 Solutions message\n"
+ "10 Exit"
);
Console.WriteLine("Choose message to send: ");
if (int.TryParse(Console.ReadLine(), out result) == false || result < 1 || result > 10)
{
Console.WriteLine("\nWrong input\n\n");
continue;
}
switch (result)
{
case 1:
msg = new RegisterMessage(component.Type, 0, component.SolvableProblems);
break;
case 2:
msg = new RegisterResponseMessage(123L, DateTime.Now);
break;
case 3:
msg = new StatusMessage(123L, null);
break;
case 4:
msg = new SolveRequestMessage(problem.ProblemType, problem.SolvingTimeout, problem.Data);
break;
case 5:
msg = new SolveRequestResponseMessage(123L);
break;
case 6:
msg = new DivideProblemMessage("Problem type", 123L, Encoding.UTF8.GetBytes("test1"), 321L);
break;
case 7:
msg = new SolutionRequestMessage(123L);
break;
case 8:
msg = new SolvePartialProblemsMessage("problem type", 123L, Encoding.UTF8.GetBytes("test1"), 333L, null);
break;
case 9:
msg = new SolutionsMessage("problemy type", 123L, Encoding.UTF8.GetBytes("test1"), null);
break;
case 10:
Environment.Exit(0);
break;
}
component.SendMessage(msg.Serialize());
}
//component.SendMessage(Encoding.UTF8.GetBytes("dupa"));
}
private void ProcessRegisterResponseMessage(RegisterResponseMessage message)
{
Id = message.Id;
//StartStatusTimer();
}
private void handleRegisterResponsenMessage(RegisterResponseMessage message)
{
systemTracker.Node.Id = message.Id;
systemTracker.Node.Timeout = message.Timeout;
systemTracker.Node.BackupServers = message.BackupCommunicationServers;
}
