public void Parse_XMLString_SolveRequestResponseMessage()
{
/*********** Actual message ***********/
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"xml_samples\SolveRequestResponse.xml");
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(path);
string xmlStr = xmlDoc.OuterXml;
string name = Message.GetMessageName(xmlStr);
SolveRequestResponseMessage actualMessage = null;
if (name == SolveRequestResponseMessage.ELEMENT_NAME)
{
actualMessage = SolveRequestResponseMessage.Construct(xmlStr);
}
/*********** Expected message ***********/
ulong id = 12;
SolveRequestResponseMessage expectedMessage = new SolveRequestResponseMessage(id);
Assert.AreEqual(expectedMessage, actualMessage);
}
/// <summary>
/// SolveRequest is sent by Computational Client
/// </summary>
/// <param name="messagePackage"></param>
private void handleSolveRequestMessage(MessagePackage messagePackage)
{
SolveRequestMessage message = (SolveRequestMessage)messagePackage.Message;
InformBackup(message);
// if the cluster can solve this problem
if (clientTracker.CanSolveProblem(message.ProblemType))
{
Task task = new Task((int)systemTracker.GetNextTaskID(), message.ProblemType,
message.Data);
taskTracker.AddTask(task);
if (Server.primaryMode)
{
NoOperationMessage responseNoOp = new NoOperationMessage(clientTracker.BackupServers);
SolveRequestResponseMessage response = new SolveRequestResponseMessage((ulong)task.ID);
List <Message> messages = new List <Message>();
messages.Add(responseNoOp);
messages.Add(response);
server.Send(messagePackage.Socket, messages);
SmartConsole.PrintLine("Sent a SolveRequestResponse Message", SmartConsole.DebugLevel.Basic);
}
}
else
{
//TODO RESPONSE MESSAGE
Console.Write(" >> TM ERROR\n");
}
}
private void handleSolverRequestResponseMessage(SolveRequestResponseMessage solveRequestResponseMessage)
{
SmartConsole.PrintLine("Solve request respone message has been received", SmartConsole.DebugLevel.Advanced);
systemTracker.Node.Id = solveRequestResponseMessage.Id;
keepAliveTimer.Start(solveRequestResponseMessage.Id);
}
public static SolveRequestResponseMessage CreateSolveRequestResponseMessage()
{
ulong id = 12;
SolveRequestResponseMessage expectedMessage = new SolveRequestResponseMessage(id);
return(expectedMessage);
}
protected override void ProcessSolveRequestResponseMessage(SolveRequestResponseMessage message)
{
_taskId = message.Id;
_waitingForSolution = true;
_solutionRequestApoloniuszTimer = new Timer(SolutionCheckTime);
_solutionRequestApoloniuszTimer.Elapsed += CheckForSolution;
//_solutionRequestApoloniuszTimer.Start();
EventLogger.GetLog().InfoFormat("Zaczęto rozwiązywanie problemu. Przydzielone id:{0}",_taskId);
}
public void SolveRequestResponseMessageXmlIsProperlySerializedAndDeserialized()
{
var message = new SolveRequestResponseMessage
{
AssignedId = 5
};
var serializedMessage = _serializer.Serialize(message);
var deserializedMessage = _serializer.Deserialize(serializedMessage);
Assert.IsInstanceOfType(deserializedMessage, typeof(SolveRequestResponseMessage));
}
public void SolveRequestResponseMessageSerialization()
{
string testData = System.IO.File.ReadAllText(@"XMLTestData\SolveRequestResponseMessage.xml");
var serializer = new ComputationSerializer <SolveRequestResponseMessage>();
var solveRequestResponseMessage = new SolveRequestResponseMessage()
{
Id = 1
};
var result = serializer.Serialize(solveRequestResponseMessage);
Assert.AreEqual(result, testData);
}
private void ButtonSendSolveRequest_Click(object sender, RoutedEventArgs e)
{
var message = this.computationalClient.SendSolveRequest(this.solveRequestMessage);
this.potwierdzenie.Text += "\nReceived form CC" + message;
var serializer = new ComputationSerializer <SolveRequestResponseMessage>();
SolveRequestResponseMessage srrm = serializer.Deserialize(message);
this.problemId = srrm.Id;
this.potwierdzenie.Text += "\n\nAssigned problem ID = " + this.problemId;
}
/// <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);
}
/// <summary>
/// Handle solve request message.
/// </summary>
/// <param name="msg">Solve request 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(SolveRequestMessage msg, TcpDataProviderMetadata metadata)
{
var solvingTimeout = msg.SolvingTimeout ?? ulong.MaxValue;
var id = _workManager.AddProblem(msg.ProblemType, msg.ProblemData, solvingTimeout);
var response = new SolveRequestResponseMessage
{
AssignedId = id
};
return(new List <Message> {
response
});
}
public void Parse_SolveRequestResponseMessage_XMLString()
{
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"xml_samples\SolveRequestResponse.xml");
ulong id = 12;
SolveRequestResponseMessage message = new SolveRequestResponseMessage(id);
string actualXmlStr = message.ToXmlString();
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(path);
string expectedXmlStr = xmlDoc.OuterXml;
Assert.AreEqual(expectedXmlStr, actualXmlStr);
}
private string ProcessCaseSolveRequest(string message)
{
var deserializedMessage = DeserializeMessage <SolveRequestMessage>(message);
ulong solutionId = GenerateNewSolutionId();
var solveRequestResponse = new SolveRequestResponseMessage()
{
Id = solutionId
};
if (!solveRequests.TryAdd(solutionId, deserializedMessage))
{
_logger.Error("Could not add SolveRequest to dictionary. SolutionId: " + solutionId + ", message: " + deserializedMessage);
solveRequestResponse.Id = 0;
}
return(SerializeMessage(solveRequestResponse));
}
private void ProcessSolveRequestMessage(SolveRequestMessage msg, TcpClient client)
{
var data = msg.Data;
var problemType = msg.ProblemType;
var timeout = msg.SolvingTimeout;
var taskManagerInfo = GetTaskManagerByProblemType(problemType);
if (taskManagerInfo == null)
{
EventLogger.GetLog().ErrorFormat("Brak task managera dla problemu {0}", msg.ProblemType);
return;
}
var problemInstance = new ProblemInstanceInfo(++_maxProblemId, msg.ProblemType)
{
Data = data,
TaskManager = taskManagerInfo,
ComputationalClient = GetComponentsInfoByTcpClient(client),
SolvingTimeout = timeout,
ProblemType = msg.ProblemType
};
_problemInstances.Add(problemInstance);
//Wyslij odpowiedz
var responseMsg = new SolveRequestResponseMessage(problemInstance.Id);
SendMessage(responseMsg.Serialize(), client);
EventLogger.GetLog().InfoFormat("Otrzymano żądanie rozwiązania problemu {0} o id {1}", problemInstance.ProblemType, problemInstance.Id);
//Wyslij prosbe o podzielenie
var availableComputationalNodes = _computationalNodes.Count(c => c.SolvableProblems.Contains(problemInstance.ProblemType));
var divideProblemMsg = new DivideProblemMessage(problemInstance.ProblemType, problemInstance.Id, problemInstance.Data, (ulong)availableComputationalNodes);
SendMessage(divideProblemMsg.Serialize(), taskManagerInfo.Client);
EventLogger.GetLog().InfoFormat("Wysłano żądanie podzielenia problemu {0} o id {1} do TM {2}", problemInstance.ProblemType, problemInstance.Id, taskManagerInfo.Id);
}
public void SolveRequestResponseMessageSerializationTest()
{
var solveRequestResponseMessage = new SolveRequestResponseMessage(123L);
var result = solveRequestResponseMessage.SerializeToXml();
Assert.IsNotNull(result);
Assert.AreNotEqual(0, result.Length);
var xmlValidator = new XmlValidator();
var xsdSchemaFile = "SolveRequestResponseMessage.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"?>
//<SolveRequestResponse xmlns="http://www.mini.pw.edu.pl/ucc/">
// <Id>123</Id>
//</SolveRequestResponse>
#endregion
}
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"));
}
protected virtual void ProcessSolveRequestResponseMessage(SolveRequestResponseMessage message)
{
}
