// Method is used to process and send the query for operation on databases as it is received by receiver of server
public void ProcessMessageQuery(ref Message ServerQuery, ref Sender ServerSender, ref HiResTimer HRTimer)
{
XDocument XMLDoc = XDocument.Parse(ServerQuery.MessageContent);
var Queries = XMLDoc.Element("QueryType").Elements(); //////
string QueryType = null, DBType = null; //
List <string> Results = new List <string>(); //
XElement Query = XMLDoc.Root; //
List <string> ParameterSelected = new List <string>(); // Query is forwarded as string of XML message to server from client
List <string> ParameterValue = new List <string>(); // It fetches paramaters and values required to process the query on DB.
QueryType = Query.Nodes().OfType <XText>().FirstOrDefault().Value; //
DBType = Query.FirstAttribute.Value.ToString(); //
if (Query.Elements("Parameters").Any()) //
{ //////////
foreach (var Param in Query.Element("Parameters").Descendants())
{
ParameterSelected.Add(Param.Name.ToString());
ParameterValue.Add(Param.Value.ToString());
}
}
HRTimer.Start(); // Timer is started as it is forwarded to process the query on database
Results = TestExecutive.QueryProcessing(DBType, QueryType, ParameterSelected, ParameterValue);
HRTimer.Stop(); // Timer is stopped as database is done with the processing of query
ServerQuery.ServerProcessTime = HRTimer.ElapsedMicroseconds;
TimeKeeper(QueryType, HRTimer.ElapsedMicroseconds);
foreach (string result in Results)
{
Query.Add(new XElement("Result", result)); // Results of query are added in the same received message
}
UtilityMethods.swapUrls(ref ServerQuery); // Same message is sent back with no update on TimeSent or TimeReceived property in order to
ServerQuery.MessageContent = XMLDoc.ToString(); // calculate the round-trip time of the message, and that's the reason why same message is used instead of creating a new one
ServerSender.sendMessage(ServerQuery);
}
static void Main(string[] args)
{
"\n Starting Write Client or writer for database".Wrap();
Console.Title = "WriteClient";
WriteClient Writeclient = new WriteClient();
Writeclient.processCommandLine(args);
String.Format(" Url of Write Client is {0}", Writeclient.LocalURL).Wrap();
string localPort = UtilityMethods.urlPort(Writeclient.LocalURL);
string localAddr = UtilityMethods.urlAddress(Writeclient.LocalURL);
Receiver WCReceiver = new Receiver(localPort, localAddr);
Sender WCSender = new Sender(Writeclient.LocalURL);
int NumberofQ = 0;
XDocument XMLDoc = new XDocument();
Message MessageStream = new Message();
// New service action is defined for receiver which handles the way receiver behaves on received message in WriteClient
Action WCserviceAction = () =>
{
try
{
Message ReceivedMessage = new Message();
while (true)
{
ReceivedMessage = WCReceiver.getMessage(); // note use of non-service method to deQ messages
if (ReceivedMessage.ToURL != ReceivedMessage.FromURL)
{
ReceivedMessage.TimeReceived = DateTime.Now;
ReceivedMessage.TravelTime = DateTime.Now - ReceivedMessage.TimeSent;
"\n Received a new message".Wrap();
Console.Write("\n Sender is {0}", ReceivedMessage.FromURL);
Console.Write("\n MessageContent is\n {0}", ReceivedMessage.MessageContent);
Console.Write("\n Message was sent on {0}", ReceivedMessage.TimeSent);
Console.Write("\n Message was received on {0}", DateTime.Now); //Demonstarting another way to convert milliseconds to microseconds. Although, all server measurments of time are done using high resolution timer.
Console.Write("\n Message took {0} milliseconds or {1} microseconds on communication channel (round-trip, including its processing)\n", (DateTime.Now - ReceivedMessage.TimeSent).TotalMilliseconds, (DateTime.Now.Ticks / 10 - ReceivedMessage.TimeSent.Ticks / 10));
if (ReceivedMessage.FromURL == Writeclient.RemoteURL)
{
Console.Write("\n Server took {0} microseconds to process this query)\n", ReceivedMessage.ServerProcessTime);
}
}
if (ReceivedMessage.MessageContent.StartsWith("<MessageStream>"))
{
Writeclient.ProcessStream(ref ReceivedMessage, ref Writeclient, ref WCSender);
"XML Message stream have been sent to the server for processing".Wrap();
MessageStream = ReceivedMessage;
XMLDoc = XDocument.Parse(ReceivedMessage.MessageContent);
foreach (var element in XMLDoc.Element("MessageStream").Elements()) // To know the total number of queries in original message
{
NumberofQ += int.Parse(element.LastAttribute.Value);
}
XMLDoc.Element("MessageStream").Elements().Remove(); // As client would be receiving two types of messages.
} // One is MessageStream XML message and other is Reply messages from server
if (ReceivedMessage.MessageContent.StartsWith("<QueryType"))
{
XElement QueryResult = XElement.Parse(ReceivedMessage.MessageContent);
XMLDoc.Root.Add(QueryResult);
--NumberofQ; // Reference for received message stream is saved in order to send the same message back to its source
if (NumberofQ == 0) // NumberofQ counted the number of queries. When all are processed,
{ // server is notified about that.
Message Final = new Message();
Final.ToURL = Writeclient.RemoteURL;
Final.FromURL = Writeclient.LocalURL;
Final.MessageContent = "DONE !! All queries from this client have been processed.";
Final.TimeSent = DateTime.Now;
WCSender.sendMessage(Final);
MessageStream.MessageContent = XMLDoc.ToString();
XMLDoc.Save("Results.xml");
if (MessageStream.ToURL != MessageStream.FromURL)
{
UtilityMethods.swapUrls(ref MessageStream);
WCSender.sendMessage(MessageStream);
}
}
}
if (ReceivedMessage.MessageContent == "closeReceiver")
{
break;
}
}
}
catch (Exception e)
{
Console.WriteLine(" " + e.Message);
}
};
if (WCReceiver.StartService())
{
WCReceiver.doService(WCserviceAction); // Receiver for write client is started to perform the action defined
}
// Comment following lines till 209 to enable this client to be able to process user defined query
// comment following lines in order to disable this client to perform queries automatically
Message LoadXMLMessage = new Message();
LoadXMLMessage.ToURL = Writeclient.LocalURL;
LoadXMLMessage.FromURL = Writeclient.LocalURL;
string ID = UtilityMethods.urlPort(Writeclient.LocalURL).Substring(2);
LoadXMLMessage.MessageID = "WC" + ID;
LoadXMLMessage.MessageContent = XDocument.Load("WCMessageStream.xml").ToString(); // It is used to load the previously created message stream. It is fed to its processing queue.
MessageStream = LoadXMLMessage; // Reference is saved in order to avoid any loss of information.
WCSender.sendMessage(LoadXMLMessage);
Thread.Sleep(100);
UtilityMethods.waitForUser();
Console.Write("\n\n");
}
