Beispiel #1
0
        /// <summary>
        ///  notify a server that a client just connected
        /// </summary>
        /// <param name="client"></param>
        public void SendClientConnect(UserContext client)
        {
            ServerContext server = PickServer();

            Message resp = new Message();
            resp.Type = ResponseType.Connection;
            resp.Data = client.ClientAddress.ToString();

            server.Send(Newtonsoft.Json.JsonConvert.SerializeObject(resp));
        }
Beispiel #2
0
        /// <summary>
        /// Sends an error message to the client who caused the error
        /// </summary>
        /// <param name="ErrorMessage">Details of the error</param>
        /// <param name="AContext">The user's connection context</param>
        private static void SendError(string ErrorMessage, UserContext AContext, ServerMessage message)
        {
            Log.Warn("Error Message: " + ErrorMessage);
            Message r = new Message();

            r = new Message();
            r.Type = ResponseType.Error;
            r.Data = new { Message = ErrorMessage };

            //AContext.Send(JsonConvert.SerializeObject(r));
        }
Beispiel #3
0
        // NOTE: This is not safe code. You may end up broadcasting to people who
        // disconnected. Luckily for us, Alchemy handles exceptions in its event methods, so we don't
        // have random, catastrophic changes.
        /// <summary>
        /// Event triggered when a user disconnected from a proxy
        /// Remove a user from the online users list 
        /// and broadcast the disconnection message to all connected users.
        /// </summary>
        /// <param name="AContext">The user's connection context</param>
        public static void OnDisconnect(RCATContext RContext, ServerMessage message)
        {
            try
            {
                Log.Info("[PROXY->SERVANT]: User disconnected: " + message.Data);

                User user = dataConnector.GetUser(message.Data);

                Message r = new Message();

                if (!String.IsNullOrEmpty(user.n))
                {
                    dataConnector.RemoveUser(user.n);
                    string[] clients = dataConnector.GetAllUsersNames();
                    RContext.Broadcast(new { n = user.n }, clients, ResponseType.Disconnect, message.TimeStamp);
                }
                else
                    Log.Warn("[PROXY->SERVANT]: User " + user.n + " not found OnDisconnect.");
            }
            catch (Exception e)
            {
                Log.Error("[PROXY->SERVANT]: Error in OnDisconnect.",e);
            }
        }
Beispiel #4
0
        public void SendToClient(ClientMessage message)
        {
            string name = message.clients[0];
            UserContext user = Proxy.onlineUsers[name];
            try
            {
                Message m = new Message();
                m.Type = message.Type;
                m.Data = message.Data;

                string json = JsonConvert.SerializeObject(m);

                user.Send(json);
            }
            catch
            {
                Log.Debug("[PROXY->CLIENT]: User " + user + " not found.");
            }
        }
Beispiel #5
0
        /// <summary>
        ///send the same data to multiple clients (broadcast contains the data to send and the array of clients to send to) 
        /// </summary>
        /// <param name="broadcast"></param>
        public void BroadcastToClients(ClientMessage broadcast)
        {
            try
            {
                string name = (string)broadcast.Data.SelectToken("n");
                UserContext user = null;
                if (Proxy.onlineUsers.ContainsKey(name))
                    user = Proxy.onlineUsers[name];
                else
                {
                    Log.Debug("User " + name + " not present in this Proxy");
                    return;
                }
                long lastupdate = user.LastUpdate;
                if (broadcast.Type == ResponseType.Disconnect)
                    lastupdate = 0; // Just to be sure it will enter next if

                user.SendingSemaphore.Wait();
                if (broadcast.TimeStamp >= lastupdate)
                {
                    user.LastUpdate = broadcast.TimeStamp;
                    Message m = new Message();
                    m.Type = broadcast.Type;
                    m.Data = broadcast.Data;

                    string json = JsonConvert.SerializeObject(m);
                    foreach (string client in broadcast.clients)
                    {
                        try
                        {
                            UserContext cl = Proxy.onlineUsers[client];
                            cl.Send(json);
                        }
                        catch
                        {
                            Log.Debug("[PROXY->CLIENT]: User " + client + " not found.");
                        }
                    }
                }
                else
                {
                    user.LatePackets++;
                    user.SendingSemaphore.Release();
                    return;
                }

                if (broadcast.Type == ResponseType.Disconnect)
                {
                    if (Proxy.onlineUsers.ContainsKey(name))
                        Proxy.onlineUsers.Remove(name);
                }
                else
                {
                    user.SentCounter--;
                    if (user.SentCounter <= 0 && lastupdate > 0)
                    {
                        user.SentCounter = UserContext.DefaultSentCounter;
                        long timetoprocess = user.TimeToProcess;
                        LoggingObject logobj = new LoggingObject(broadcast.TimeStamp, user, timetoprocess);
                        ThreadPool.QueueUserWorkItem(new WaitCallback(LogRoundTrip), logobj);
                        user.TimeToProcess = DateTime.Now.Ticks;
                    }
                }
                user.SendingSemaphore.Release();
            }
            catch (Exception e)
            {
                Log.Error(e);
            }
        }