private void OnRemoteInvokingEvent(NetMessageHandler msgHandler)
{
UseMethod2Server msg = msgHandler.GetMessage <UseMethod2Server>();
//Debug.Log("Serverę„ę¶å°UseMethod2Serverļ¼" + JsonUtils.ToJson(msg));
int code = 0;
string error = "";
try
{
MethodInfo mInfo = null;
foreach (var mData in invokeMothodsInfos)
{
if (mData.Key.FullName == msg.classFullName)
{
List <MethodInfo> methods = mData.Value;
foreach (var m in methods)
{
if (m.Name == msg.methodName)
{
mInfo = m;
break;
}
}
}
}
if (mInfo != null)
{
List <object> pValues = new List <object>();
ParameterInfo[] parameters = mInfo.GetParameters();
for (int i = 0; i < parameters.Length; i++)
{
ParameterInfo p = parameters[i];
object v = SimpleJsonUtils.FromJson(p.ParameterType, msg.paramNameValues[p.Name]);
pValues.Add(v);
}
mInfo.Invoke(null, pValues.ToArray());
}
else
{
code = -2;
}
}
catch (Exception e)
{
code = -1;
error = e.ToString();
Debug.LogError(e);
}
UseMethod2Client toMsg = new UseMethod2Client();
toMsg.code = code;
toMsg.error = error;
netManager.Send(msgHandler.player, toMsg);
//Debug.Log("åéUseMethod2Clientļ¼" + JsonUtils.ToJson(toMsg));
}
private void waitingProcess(NetMessageHandler handler, string sessionId, SceneMessage sceneMessage,
MessageQueue <DispetcherMessage> dispatcherHandler)
{
DispatcherExitCondition exitCondition = new DispatcherExitCondition(handler, sessionId, isDisconnected);
QueueListener <DispetcherMessage> queueListener = new QueueListener <DispetcherMessage>(dispatcherHandler, m_log);
queueListener.AddResponse("MergerFinishMessage", mergerFinishMessageEvent);
queueListener.AddResponse("MergerUpdateMessage", mergerUpdateMessageEvent);
queueListener.AddResponse("MergerUpdateFailedMessage", mergerUpdateFailedMessageEvent);
queueListener.Run(exitCondition);
}
private void OnMsgFunctionSwitch(NetMessageHandler msgHandler)
{
FunctionSwitch2Server msg = msgHandler.GetMessage <FunctionSwitch2Server>();
if (msg.functionName == FunctionName)
{
IsOpenFunction = msg.isOpenFunction;
SendSwitchState2Client(msgHandler.player);
}
}
private void sendAuthorizationResultMessage(bool isAuthorized, NetMessageHandler handler)
{
try
{
handler.SendSynchMessage(new AuthorizationResultMessage(isAuthorized));
}
catch (Exception)
{
m_log.Error("Error when sending authorization message");
}
}
private void sendClientMessage(NetMessageHandler handler, StatusMessage.StatusEnum status)
{
try
{
StatusMessage msg = new StatusMessage(status);
handler.SendSynchMessage(msg); //send message to client to mantain a connection while waiting
}
catch (Exception e)
{
m_log.Warning("Error sending sync message. " + e.Message);
}
}
private void sendError(NetMessageHandler handler, string message)
{
try
{
StatusMessage errMes = new StatusMessage(StatusMessage.StatusEnum.Failed, message);
handler.SendSynchMessage(errMes);
}
catch (Exception)
{
m_log.Error("Error when sending error message");
}
}
/// <param name="bPolicyServerMode">Adobe policy server behaviour *only*</param>
public NetServer(bool bPolicyServerMode, INetClientApp netClientApp)
{
mPolicyServerMode = bPolicyServerMode;
mNetClientApp = netClientApp;
mMaxConnectionsEnforcer = new Semaphore(MAX_CONNECTIONS, MAX_CONNECTIONS);
if (mPolicyServerMode)
{
mNetMessageHandler = new NetMessageHandlerPolicyServer();
mBufferManager = new BufferManager(8192, 512);
}
else
{
mNetMessageHandler = new NetMessageHandler();
mBufferManager = new BufferManager(MAX_CONNECTIONS * 2, 4096);
}
}
//check if abort message was send by client
private bool isDisconnected(NetMessageHandler handler, string sessionId)
{
sendClientMessage(handler, StatusMessage.StatusEnum.OK);
StatusMessage statusMess = handler.GetSynchMessage() as StatusMessage;
if (((statusMess != null) && (statusMess.Status == StatusMessage.StatusEnum.Aborted)) || (!handler.Connected()))
{
try
{
m_log.Info("Got abort message or connection was disconnected. ID: " + m_threadsID[sessionId].ToString());
//sending abort messeges to workers
for (int i = 0; i < m_renderAbortHandlers[m_threadsID[sessionId]].Count; ++i)
{
try
{
m_renderAbortHandlers[m_threadsID[sessionId]][i].AddMessage(new ToAbortRenderMessage());
}
catch (Exception e)
{
m_log.Warning("renderQueue was already deleted. Error: " + m_renderAbortHandlers[m_threadsID[sessionId]][i].ToString() + ". ID: " + m_threadsID[sessionId].ToString());
m_log.Warning(e.Message);
}
}
MessageQueue <MergerMessage> abortQueue = new MessageQueue <MergerMessage>(m_threadsID[sessionId].ToString() + "abort");
AbortMergeMessage mergerMessage = new AbortMergeMessage("uniqueBlob" + m_threadsID[sessionId].ToString() + '_' + sessionId.ToString(), m_threadsID[sessionId]);
abortQueue.AddMessage(mergerMessage);
m_renderAbortHandlers.Remove(m_threadsID[sessionId]);
m_log.Info("Aborted by user. ID: " + m_threadsID[sessionId].ToString());
return(true);
}
catch (Exception e)
{
m_log.Error("Error for ID " + m_threadsID[sessionId] + " when checking connection status:" + e.Message);
return(false);
}
}
else
{
return(false);
}
}
/// <summary>
/// Subscribe to notify new handler.
/// </summary>
/// <param name="handler">Handler for subscribe</param>
public void Subscribe (NetMessageHandler handler)
{
handlers.Add(handler);
}
static void Main(string[] args)
{
Console.WriteLine("Amion.Network SimpleChat Server\n");
Console.WriteLine("Type '!start' to start the server");
Console.WriteLine("Type '!help' for all commands\n");
//Create the network server
server = new NetServer();
//Subscribe to Connection Added/Removed event
server.ConnectionAdded += Server_ConnectionAdded;
server.ConnectionRemoved += Server_ConnectionRemoved;
//Create a message handler for incoming network messages
messageHandler = new NetMessageHandler();
//Subscribe to the MessageReceived event where we will handle all incoming network messages
messageHandler.MessageReceived += MessageHandler_MessageReceived;
//Start the message processor thread
messageHandler.StartMessageProcessor();
//Begin Loop to keep the program running
bool exit = false;
do
{
string command = Console.ReadLine();
switch (command)
{
case "!start":
{
Console.WriteLine("Starting the server");
//Start the server's listener socket on IP: 127.0.0.1:6695
server.StartListener(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 6695));
break;
}
case "!stop":
{
Console.WriteLine("Stopping the server");
server.StopListener();
server.DisconnectAll();
break;
}
case "!exit":
{
Console.WriteLine("Exiting the program");
exit = true;
break;
}
case "!help":
{
Console.WriteLine("Type '!exit' to quit the program");
Console.WriteLine("Type '!stop' to stop the server");
Console.WriteLine("Type '!start' to start the server");
break;
}
default:
{
Console.WriteLine("Unknown command");
break;
}
}
} while (!exit);
}
static void Main(string[] args)
{
Console.WriteLine("Amion.Network SimpleChat Client\n");
Console.WriteLine("Type '!connect' to connect to the server");
Console.WriteLine("Type '!help' for all commands\n");
//Create the network client
client = new NetClient();
//Subscribe to Connection Added/Removed event
client.ConnectionAdded += Client_ConnectionAdded;
client.ConnectionRemoved += Client_ConnectionRemoved;
//Create a message handler for incoming network messages
messageHandler = new NetMessageHandler();
//Subscribe to the MessageReceived event where we will handle all incoming network messages
messageHandler.MessageReceived += MessageHandler_MessageReceived;
//Start the message processor thread
messageHandler.StartMessageProcessor();
//Begin Loop to keep the program running
bool exit = false;
do
{
string command = Console.ReadLine();
switch (command)
{
case "!connect":
{
Console.WriteLine("Connecting to the server");
//Connect to IP: 127.0.0.1:6695
client.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 6695));
break;
}
case "!disconnect":
{
Console.WriteLine("Disconnecting from the server");
client.Disconnect();
break;
}
case "!exit":
{
Console.WriteLine("Exiting the program");
exit = true;
break;
}
case "!help":
{
Console.WriteLine("Type '!exit' to quit the program");
Console.WriteLine("Type '!disconnect' to disconnect from the server");
Console.WriteLine("Type '!connect' to connect to the server");
break;
}
default:
{
//Create an outgoing network message for the chat message
NetOutMessage netMessage = new NetOutMessage();
netMessage.Write(command);
netMessage.Finish();
//Send the message if possible
client.Connection?.Send(netMessage);
break;
}
}
} while (!exit);
}
private void processingScene(NetMessageHandler handler, SceneMessage message, byte[] sceneFile, string sessionGuid,
MessageQueue <DispetcherMessage> dispatcherHandler)
{
string sceneName = null;
int threadID = m_threadsID[sessionGuid];
string uniqueBlobName = string.Format("{0}_{1}", BlobName.UNIQUE_BLOB + threadID.ToString(), sessionGuid);
try
{
lock (m_BlobLock)
{
CloudBlockBlob blob = renderStorage.Get().CreateBlob(BlobName.SCENE_BLOB, uniqueBlobName);//sceneContainer.GetBlockBlobReference(uniqueBlobName);
Utils.UpploadBlobByteArray(blob, sceneFile);
sceneName = blob.Uri.ToString();
}
}
catch (Exception e)
{
m_log.Error("Error saving scene to blob: " + e.Message);
m_instanceManager.IncreaseFreeMergerCount(); //if no blob created than mark requested instances as free
//and kill thread
m_instanceManager.IncreaseFreeWorkerCount(message.InstanceCnt);
Thread.CurrentThread.Abort();
}
StartMergeMessage mergerMessage = new StartMergeMessage(message.InstanceCnt, message.TotalTime,
message.UpdateTime, sessionGuid, threadID, message.RequiredSpp);
m_mergerHandler.AddMessage(mergerMessage);
m_log.Info("IsMergerReady message sent");
WaitForWorkerAction action = new WaitForWorkerAction(sendClientMessage, handler);
lock (m_waitMergerLock)
{
//wait for merger allocating
InstanceManager.Get(m_log).WaitForMerger(dispatcherHandler, m_threadsID[sessionGuid], action);
}
lock (m_waitWorkerLock)
{
//check if workers has been already allocated, if no wait for it
InstanceManager.Get(m_log).WaitForWorkers(message.InstanceCnt, dispatcherHandler, sessionGuid, threadID, action);
}
sendClientMessage(handler, StatusMessage.StatusEnum.Allocated);
m_log.Info("StartMergeMessage sent to merger. ID: " + threadID);
m_log.Info("Scene GUID: " + sessionGuid + "Scene ID: " + threadID);
m_renderAbortHandlers.Add(threadID, new List <MessageQueue <RenderMessage> >()); //each m_renderAbortHandlers contains list of worker queues
MessageQueue <RenderMessage> toRenderQueue = new MessageQueue <RenderMessage>(threadID.ToString());
double sppPerOneWorker = 0; //how much spp is required from each worker
for (int i = 0; i < message.InstanceCnt; i++)
{
//adding new renderqueue for list that correspond to ID of scene which is connected with m_threadsID[sessionGuid]
try
{
MessageQueue <RenderMessage> newAbortQueue = new MessageQueue <RenderMessage>(threadID.ToString() + m_renderAbortHandlers[threadID].Count.ToString());
newAbortQueue.Clear();
m_renderAbortHandlers[threadID].Add(newAbortQueue);
}
catch (Exception e)
{
m_log.Error("Error creating queue: " + e.Message + ". ID: " + threadID);
}
sppPerOneWorker = message.RequiredSpp / message.InstanceCnt;
ToRenderMessage msg = new ToRenderMessage(sceneName, message.TotalTime,
message.UpdateTime, threadID, threadID.ToString() +
(m_renderAbortHandlers[threadID].Count - 1).ToString(), //scene ID + number of worker that is rendering this scene
sppPerOneWorker);
m_log.Info("Abort queue name suffix: " + (threadID.ToString() + (m_renderAbortHandlers[threadID].Count - 1)).ToString());
toRenderQueue.AddMessage(msg);
m_log.Info("ToRenderMessage sent to worker: " + i);
}
m_log.Info("ToRenderMessage sent to workers. ID: " + threadID);
}
public WaitForWorkerAction(PerformedAction action, NetMessageHandler handler)
{
m_action = action;
m_handler = handler;
}
public DispatcherExitCondition(NetMessageHandler connectionHandler, string sessionId, DispatcherCondition exitCondition = null)
{
m_exitCondition = exitCondition;
m_connectionHandler = connectionHandler;
m_sessionId = sessionId;
}
/// <summary>
/// unsubscribe to notify handler.
/// </summary>
/// <param name="handler">Handler for unsubscribe</param>
public void Unsubscribe (NetMessageHandler handler)
{
handlers.Remove(handler);
}
private void OnClearLogEvent(NetMessageHandler msgHandler)
{
logDatas.Clear();
}
private void processConnection(TcpClient client)
{
m_connectionWaitHandle.Set(); //unblock listener thread
string sessionID = Guid.NewGuid().ToString();
m_log.Info("Thread GUID: " + sessionID);
lock (m_IDLock)
{
m_threadsID.Add(sessionID, m_scenesId.GetNewSceneID());
}
MessageQueue <DispetcherMessage> dispatcherHandler = new MessageQueue <DispetcherMessage>(m_threadsID[sessionID].ToString(), true);
m_log.Info("Start");
//get scene info
NetMessageHandler handler = new NetMessageHandler(client, 30);
NetMessage message = null;
m_connectionHandlers.Add(sessionID, handler);
while (true)
{
try
{
message = handler.GetSynchMessage();
if (message == null)
{
continue;
}
}
catch (Exception)
{
sendError(handler, "Can't read connection message");
return;
}
SceneMessage sceneMessage;
bool userAuthorized = false;
//User authorization
if (message is AuthorizationMessage)
{
var loginMessage = message as AuthorizationMessage;
if (Utils.DataBaseUtils.CheckLoginCorrect(loginMessage.Login, loginMessage.Pwd) == false)
{
m_log.Info("Wrong password. ID: " + m_threadsID[sessionID].ToString());
sendAuthorizationResultMessage(false, handler);
return;
}
else
{
m_log.Info("User had been authorized. ID: " + m_threadsID[sessionID].ToString());
userAuthorized = true;
sendAuthorizationResultMessage(true, handler);
}
}
else if (message is SceneMessage)
{
if (!userAuthorized)
{
m_log.Warning("User not authorized.");
}
sceneMessage = message as SceneMessage;
try
{
if (sceneMessage.RequiredSpp == 0 && sceneMessage.TotalTime < DocConstants.MINIMUM_RENDER_TIME)
{
m_log.Warning("Minimum render time is 60 sec");
sendError(handler, "Minimum render time is 60 sec");
return;
}
}
catch (Exception e)
{
m_log.Error("Unexpected problem when checking password: "******". ID: " + m_threadsID[sessionID].ToString());
sendError(handler, "Error requesting database");
return;
}
//get scene file
byte[] sceneFile = null;
try
{
sceneFile = new byte[sceneMessage.SceneFileSize];
handler.GetFile(sceneFile);
}
catch (Exception ex)
{
m_log.Error("Error uploading scene" + ex.Message);
sendError(handler, "Error uploading scene");
return;
}
if (!m_instanceManager.Require(sceneMessage.InstanceCnt)) //gives new worker and merger
//instances if needed
{
sendError(handler, "Error while allocating instances. Try again later");
return;
}
try
{
sendClientMessage(handler, StatusMessage.StatusEnum.OK);
}
catch (Exception e)
{
m_log.Error("Error sending sync message" + e.Message);
}
try
{
m_log.Info("ProcessingScene. ID: " + m_threadsID[sessionID].ToString());
processingScene(handler, sceneMessage, sceneFile, sessionID, dispatcherHandler);
m_log.Info("/ProcessingScene. ID: " + m_threadsID[sessionID].ToString());
m_log.Info("WaitingProcess. ID: " + m_threadsID[sessionID].ToString());
waitingProcess(handler, sessionID, sceneMessage, dispatcherHandler);
m_log.Info("/WaitingProcess. ID: " + m_threadsID[sessionID].ToString());
}
catch (Exception ex)
{
isDisconnected(handler, sessionID);
sendError(handler, ex.Message);
m_log.Error("Processing error: " + ex.Message + ". ID: " + m_threadsID[sessionID].ToString());
}
m_log.Info("Workers had finished. ID: " + m_threadsID[sessionID].ToString());
//free resources
try
{
m_threadsID.Remove(sessionID);
m_instanceManager.FreeResources(sceneMessage.InstanceCnt);
}
catch (Exception e)
{
m_log.Error("Error when freeing resources" + e.Message);
}
m_log.Info("resources was freed. ");
m_log.Info("sceneMessage.InstanceCount : " + sceneMessage.InstanceCnt);
m_log.Info("Finish");
return;
}
else
{
m_log.Info("message type: " + message.ToString());
m_log.Warning("SceneInfo: Incorrect or damaged scene file.");
sendError(handler, Resources.MEESAGE_INCORRECT_SCENE);
return;
}
}
}
