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; } } }