protected override void Run()
{
bool foundService = false;
string requestMessage = "mpos_serv_req_wp:" + appName + ":" + appVersion;
while (running && !foundService)
{
Debug.WriteLine("#> [DiscoveryService]: Started Discovery Service for endpoint: " + server.Type + " and app: " + appName + "/" + appVersion);
foundService = true;
ClientTcp socket = null;
try
{
socket = new ClientTcp(256, false);
if (server.Type == EndpointType.SECONDARY_SERVER && !MposFramework.Instance.DeviceController.IsOnline())
{
throw new ConnectException("The mobile is completly offline!");
}
socket.Connect(server.Ip, servicePort);
Sent(socket, requestMessage);
Receive(socket);
}
catch (Exception e)
{
Debug.WriteLine("## [DiscoveryService]: Error -> \n" + e.ToString());
foundService = false;
}
finally
{
if (running && !foundService)
{
Debug.WriteLine(">> [DiscoveryService]: Retry Discovery Service for endpoint: " + server.Type + ", in " + EndpointController.REPEAT_DISCOVERY_TASK + " ms");
Thread.Sleep(EndpointController.REPEAT_DISCOVERY_TASK);
}
else
{
Debug.WriteLine("#> [DiscoveryService]: Finished Discovery Service for endpoint: " + server.Type + " on " + server.Ip);
MposFramework.Instance.EndpointController.StartDecisionMaker(server);
}
socket.Close();
}
}
}
protected override void Run()
{
Debug.WriteLine("#> [DeployRpcService]: Started Deploy App " + appName + "/" + appVersion + " on Remote Server (" + server.Ip + ":" + server.DeployAppPort + ")");
ClientTcp socket = null;
//async programming, but run synch mode
task = new DependenceFileLoadTask();
task.RunSynchronous();
try
{
socket = new ClientTcp(false);
socket.Connect(server.Ip, server.DeployAppPort);
string deployRequest = "mpos_deploy_app:" + appName + ":" + appVersion;
//Debug.WriteLine("[DEBUG]: sent -> " + deployRequest);
Sent(socket, deployRequest);
if (!ReceiveFeedbackMessage(socket))
{
throw new NetworkException("Problems in deploy request");
}
string mposDependence = "mpos_dependence_size:" + task.dependenceFiles.Count;
//Debug.WriteLine("[DEBUG]: sent -> " + mposDependence);
Sent(socket, mposDependence);
if (!ReceiveFeedbackMessage(socket))
{
throw new NetworkException("Problems in deploy request");
}
SentFiles(socket);
server.RpcServicePort = ReceiveServicePort(socket);
}
catch (Exception e)
{
Debug.WriteLine("## [DeployRpcService]: Any problem in I/O processing!\n" + e.ToString());
}
finally
{
Debug.WriteLine("#> [DeployRpcService]: Finished Deploy App " + appName + "/" + appVersion + " on Remote Server port: " + server.RpcServicePort);
socket.Close();
}
}
public object Call(bool needProfile, bool manualSerialization, Object objOriginal, String methodName, object[] methodParams)
{
ClientTcp socket = null;
if (server == null)
{
throw new NetworkException("Need to setup any server for use the RPC Client");
}
try
{
socket = new ClientTcp();
socket.Connect(server.Ip, server.RpcServicePort);
Sent(socket, manualSerialization, needProfile, objOriginal, methodName, methodParams);
ResponseRemotable response = Receive(socket, objOriginal, methodName);
if (response.Code == Code.OK)
{
return response.MethodReturn;
}
else if (response.Code == Code.METHOD_THROW_ERROR)
{
throw new RpcException("[Server]: Remote method thrown some errors\n" + response.Except);
}
else
{
throw new RpcException("[Server]: RPC call terminated with some errors!\n" + response.Except);
}
}
catch (SocketException e)
{
throw new ConnectException("Failed to connect to server: " + server.Ip + ":" + server.RpcServicePort, e);
}
finally
{
socket.Close();
}
}
private void Receive(ClientTcp socket)
{
using (MemoryStream ms = socket.Receive())
{
//ignore 4 byte of header
string jsonData = Encoding.UTF8.GetString(ms.GetBuffer(), 0, (int)ms.Length);
if (jsonData != null && !jsonData.Equals(""))
{
if (server.JsonToPorts(jsonData))
{
MposFramework.Instance.EndpointController.DeployService(server);
}
Stop();
}
else
{
throw new ConnectException("Didn't received nothing about remote services in: " + server.Ip);
}
}
}
private void Sent(ClientTcp socket, string message)
{
socket.Sent(Encoding.UTF8.GetBytes(message));
}
//async method can't receive out params!
private ResponseRemotable Receive(ClientTcp socket, object objOriginal, string methodName)
{
//Debug.WriteLine(">> start RpcClient Receive Data");
ResponseRemotable response = new ResponseRemotable();
BinaryReader reader = null;
long downloadTime = 0L;
int downloadSize = 0;
if (dataFlag == Code.CUSTOMSTREAM || dataFlag == Code.BSONSTREAM)
{
reader = new BinaryReader(socket.ReceiveWithHeaderSize());
}
else
{
reader = new BinaryReader(socket.ReceiveWithHeaderDebug(ref downloadTime, ref downloadSize));
}
//Debug.WriteLine(">> RpcClient Receive wait first flag");
dataFlag = reader.ReadByte();
//Debug.WriteLine(">> RpcClient Receive end first flag");
if (dataFlag == Code.CUSTOMSTREAM)
{
response.Code = Code.OK;
response.MethodReturn = ((RpcSerializable)objOriginal).ReadMethodReturn(reader, methodName);
}
else if (dataFlag == Code.BSONSTREAM)
{
response.Code = Code.OK;
response.MethodReturn = GetMethodReturn(reader);
}
else if (dataFlag == Code.CUSTOMSTREAMDEBUG)
{
response.Code = Code.OK;
profile.UploadSize = reader.ReadInt32();
profile.UploadTime = reader.ReadInt64();
profile.ExecutionCpuTime = reader.ReadInt64();
response.MethodReturn = ((RpcSerializable)objOriginal).ReadMethodReturn(reader, methodName);
profile.DonwloadTime = downloadTime;
profile.DownloadSize = downloadSize;
}
else if (dataFlag == Code.BSONSTREAMDEBUG)
{
response.Code = Code.OK;
profile.UploadSize = reader.ReadInt32();
profile.UploadTime = reader.ReadInt64();
profile.ExecutionCpuTime = reader.ReadInt64();
response.MethodReturn = GetMethodReturn(reader);
profile.DonwloadTime = downloadTime;
profile.DownloadSize = downloadSize;
}
else if (dataFlag == Code.METHOD_THROW_ERROR)
{
response.Code = dataFlag;
response.Except = reader.ReadString();
}
else
{
response.Code = Code.SERVER_ERROR;
response.Except = "Code different from expected: " + dataFlag;
}
//Debug.WriteLine(">> end RpcClient Receive Data");
reader.Dispose();
return response;
}
private void Sent(ClientTcp socket, bool manualSerialization, bool debug, object objOriginal, string methodName, object[] methodParams)
{
using (MemoryStream memoryStream = new MemoryStream(1024))
{
using (BinaryWriter writer = new BinaryWriter(memoryStream))
{
if (manualSerialization)
{
dataFlag = debug ? Code.CUSTOMSTREAMDEBUG : Code.CUSTOMSTREAM;
writer.Write(objOriginal.GetType().FullName);
writer.Write(methodName);
((RpcSerializable)objOriginal).WriteMethodParams(writer, methodName, methodParams);
}
else
{
dataFlag = debug ? Code.BSONSTREAMDEBUG : Code.BSONSTREAM;
writer.Write(objOriginal.GetType().FullName);
writer.Write(methodName);
byte[] bsonData = BsonFormatter.Serialize(methodParams);
writer.Write(bsonData.Length);
writer.Write(bsonData);
}
writer.Flush();
byte[] headerSize = new byte[5];
headerSize[4] = dataFlag;
Array.Copy(BitConverter.GetBytes(memoryStream.Length), headerSize, 4);
byte[] sentStream = new byte[(int)memoryStream.Length + 5];
headerSize.CopyTo(sentStream, 0);
memoryStream.ToArray().CopyTo(sentStream, headerSize.Length);
socket.Sent(sentStream);
}
}
//Debug.WriteLine(">> RpcClient Sent Data");
}
private void SentFiles(ClientTcp socket)
{
foreach (DependenceFile dep in task.dependenceFiles)
{
MemoryStream memoryStream = new MemoryStream(64 * 1024);
BinaryWriter writer = new BinaryWriter(memoryStream);
writer.Write(dep.name);
writer.Write(dep.length);
writer.Write(dep.data, 0, dep.data.Length);
writer.Flush();
byte[] streamSize = BitConverter.GetBytes(memoryStream.Length);
socket.Sent(streamSize);
socket.Sent(memoryStream.ToArray());
writer.Close();
memoryStream.Close();
if (!ReceiveFeedbackMessage(socket))
{
throw new NetworkException("Problems in sent file to server");
}
Debug.WriteLine("#> [DeployRpcService]: server receive file -> " + dep.name);
}
}
private int ReceiveServicePort(ClientTcp socket)
{
MemoryStream ms = socket.Receive();
if (ms.Length > 0)
{
string message = Encoding.UTF8.GetString(ms.GetBuffer(), 0, (int)ms.Length);
return Convert.ToInt32(message.Split(new char[] { ':' })[1]);
}
return -1;
}
private bool ReceiveFeedbackMessage(ClientTcp socket)
{
MemoryStream ms = socket.Receive();
if (ms.Length > 0)
{
string message = Encoding.UTF8.GetString(ms.GetBuffer(), 0, (int)ms.Length);
return message.Equals("ok");
}
return false;
}
