Several major improvements to group (V2) chat. Specifically: handle join/drop appropriately, invitechatboxes.

The major departure from flotsam is to send only one message per destination region, as opposed to one message per group member. This reduces messaging considerably in large groups that have clusters of members in certain regions.

1 files changed, 270 insertions, 115 deletions

diff --git a/OpenSim/Addons/Groups/GroupsMessagingModule.cs b/OpenSim/Addons/Groups/GroupsMessagingModule.cs
index 31e9175..be76ef1 100644
--- a/OpenSim/Addons/Groups/GroupsMessagingModule.cs
+++ b/OpenSim/Addons/Groups/GroupsMessagingModule.cs
@@ -39,6 +39,7 @@ using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Services.Interfaces;
 using PresenceInfo = OpenSim.Services.Interfaces.PresenceInfo;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
 
 namespace OpenSim.Groups
 {
@@ -79,6 +80,10 @@ namespace OpenSim.Groups
 
         private int m_usersOnlineCacheExpirySeconds = 20;
 
+        private Dictionary<UUID, List<string>> m_groupsAgentsDroppedFromChatSession = new Dictionary<UUID, List<string>>();
+        private Dictionary<UUID, List<string>> m_groupsAgentsInvitedToChatSession = new Dictionary<UUID, List<string>>();
+
+
         #region Region Module interfaceBase Members
 
         public void Initialise(IConfigSource config)
@@ -227,62 +232,50 @@ namespace OpenSim.Groups
         
         public void SendMessageToGroup(GridInstantMessage im, UUID groupID)
         {
-            List<GroupMembersData> groupMembers = m_groupData.GetGroupMembers(new UUID(im.fromAgentID).ToString(), groupID);
+            UUID fromAgentID = new UUID(im.fromAgentID);
+            List<GroupMembersData> groupMembers = m_groupData.GetGroupMembers(fromAgentID.ToString(), groupID);
             int groupMembersCount = groupMembers.Count;
+            PresenceInfo[] onlineAgents = null;
 
-            if (m_messageOnlineAgentsOnly)
-            {
-                string[] t1 = groupMembers.ConvertAll<string>(gmd => gmd.AgentID.ToString()).ToArray();
+            // In V2 we always only send to online members.
+            // Sending to offline members is not an option.
+            string[] t1 = groupMembers.ConvertAll<string>(gmd => gmd.AgentID.ToString()).ToArray();
 
-                // We cache in order not to overwhlem the presence service on large grids with many groups.  This does
-                // mean that members coming online will not see all group members until after m_usersOnlineCacheExpirySeconds has elapsed.
-                // (assuming this is the same across all grid simulators).
-                PresenceInfo[] onlineAgents;
-                if (!m_usersOnlineCache.TryGetValue(groupID, out onlineAgents))
-                {
-                    onlineAgents = m_presenceService.GetAgents(t1);
-                    m_usersOnlineCache.Add(groupID, onlineAgents, m_usersOnlineCacheExpirySeconds);
-                }
+            // We cache in order not to overwhlem the presence service on large grids with many groups.  This does
+            // mean that members coming online will not see all group members until after m_usersOnlineCacheExpirySeconds has elapsed.
+            // (assuming this is the same across all grid simulators).
+            if (!m_usersOnlineCache.TryGetValue(groupID, out onlineAgents))
+            {
+                onlineAgents = m_presenceService.GetAgents(t1);
+                m_usersOnlineCache.Add(groupID, onlineAgents, m_usersOnlineCacheExpirySeconds);
+            }
 
-                HashSet<string> onlineAgentsUuidSet = new HashSet<string>();
-                Array.ForEach<PresenceInfo>(onlineAgents, pi => onlineAgentsUuidSet.Add(pi.UserID));
+            HashSet<string> onlineAgentsUuidSet = new HashSet<string>();
+            Array.ForEach<PresenceInfo>(onlineAgents, pi => onlineAgentsUuidSet.Add(pi.UserID));
 
-                groupMembers = groupMembers.Where(gmd => onlineAgentsUuidSet.Contains(gmd.AgentID.ToString())).ToList();
+            groupMembers = groupMembers.Where(gmd => onlineAgentsUuidSet.Contains(gmd.AgentID.ToString())).ToList();
 
-    //            if (m_debugEnabled)
+//            if (m_debugEnabled)
 //                    m_log.DebugFormat(
 //                        "[Groups.Messaging]: SendMessageToGroup called for group {0} with {1} visible members, {2} online",
 //                        groupID, groupMembersCount, groupMembers.Count());
-            }
-            else
-            {
-                if (m_debugEnabled)
-                    m_log.DebugFormat(
-                        "[Groups.Messaging]: SendMessageToGroup called for group {0} with {1} visible members",
-                        groupID, groupMembers.Count);
-            }
 
             int requestStartTick = Environment.TickCount;
 
-            // Copy Message
-            GridInstantMessage msg = new GridInstantMessage();
-            msg.imSessionID = groupID.Guid;
-            msg.fromAgentName = im.fromAgentName;
-            msg.message = im.message;
-            msg.dialog = im.dialog;
-            msg.offline = im.offline;
-            msg.ParentEstateID = im.ParentEstateID;
-            msg.Position = im.Position;
-            msg.RegionID = im.RegionID;
-            msg.binaryBucket = im.binaryBucket;
-            msg.timestamp = (uint)Util.UnixTimeSinceEpoch();
-
-            msg.fromAgentID = im.fromAgentID;
-            msg.fromGroup = true;
+            im.imSessionID = groupID.Guid;
+            im.fromGroup = true;
+            IClientAPI thisClient = GetActiveClient(fromAgentID);
+            if (thisClient != null)
+            {
+                im.RegionID = thisClient.Scene.RegionInfo.RegionID.Guid;
+            }
 
             // Send to self first of all
-            msg.toAgentID = msg.fromAgentID; 
-            ProcessMessageFromGroupSession(msg);
+            im.toAgentID = im.fromAgentID; 
+            ProcessMessageFromGroupSession(im);
+
+            List<UUID> regions = new List<UUID>();
+            List<UUID> clientsAlreadySent = new List<UUID>();
 
             // Then send to everybody else
             foreach (GroupMembersData member in groupMembers)
@@ -290,27 +283,50 @@ namespace OpenSim.Groups
                 if (member.AgentID.Guid == im.fromAgentID)
                     continue;
 
-                if (m_groupData.hasAgentDroppedGroupChatSession(member.AgentID.ToString(), groupID))
+                if (hasAgentDroppedGroupChatSession(member.AgentID.ToString(), groupID))
                 {
                     // Don't deliver messages to people who have dropped this session
                     if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: {0} has dropped session, not delivering to them", member.AgentID);
                     continue;
                 }
 
-                msg.toAgentID = member.AgentID.Guid;
+                im.toAgentID = member.AgentID.Guid;
 
                 IClientAPI client = GetActiveClient(member.AgentID);
                 if (client == null)
                 {
                     // If they're not local, forward across the grid
+                    // BUT do it only once per region, please! Sim would be even better!
                     if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: Delivering to {0} via Grid", member.AgentID);
-                    m_msgTransferModule.SendInstantMessage(msg, delegate(bool success) { });
+
+                    bool reallySend = true;
+                    if (onlineAgents != null)
+                    {
+                        PresenceInfo presence = onlineAgents.First(p => p.UserID == member.AgentID.ToString());
+                        if (regions.Contains(presence.RegionID))
+                            reallySend = false;
+                        else
+                            regions.Add(presence.RegionID);
+                    }
+
+                    if (reallySend)
+                    {
+                        // We have to create a new IM structure because the transfer module
+                        // uses async send
+                        GridInstantMessage msg = new GridInstantMessage(im, true);
+                        m_msgTransferModule.SendInstantMessage(msg, delegate(bool success) { });
+                    }
                 }
                 else
                 {
                     // Deliver locally, directly
                     if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: Passing to ProcessMessageFromGroupSession to deliver to {0} locally", client.Name);
-                    ProcessMessageFromGroupSession(msg);
+
+                    if (clientsAlreadySent.Contains(member.AgentID))
+                        continue;
+                    clientsAlreadySent.Add(member.AgentID);
+
+                    ProcessMessageFromGroupSession(im);
                 }
             }
 
@@ -343,21 +359,90 @@ namespace OpenSim.Groups
             // Any other message type will not be delivered to a client by the 
             // Instant Message Module
 
-
+            UUID regionID = new UUID(msg.RegionID);
             if (m_debugEnabled)
             {
-                m_log.DebugFormat("[Groups.Messaging]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+                m_log.DebugFormat("[Groups.Messaging]: {0} called, IM from region {1}", 
+                    System.Reflection.MethodBase.GetCurrentMethod().Name, regionID);
 
                 DebugGridInstantMessage(msg);
             }
 
             // Incoming message from a group
-            if ((msg.fromGroup == true) && 
-                ((msg.dialog == (byte)InstantMessageDialog.SessionSend)
-                 || (msg.dialog == (byte)InstantMessageDialog.SessionAdd)
-                 || (msg.dialog == (byte)InstantMessageDialog.SessionDrop)))
+            if ((msg.fromGroup == true) && (msg.dialog == (byte)InstantMessageDialog.SessionSend))
             {
-                ProcessMessageFromGroupSession(msg);
+                // We have to redistribute the message across all members of the group who are here
+                // on this sim
+
+                UUID GroupID = new UUID(msg.imSessionID);
+
+                Scene aScene = m_sceneList[0];
+                GridRegion regionOfOrigin = aScene.GridService.GetRegionByUUID(aScene.RegionInfo.ScopeID, regionID);
+
+                List<GroupMembersData> groupMembers = m_groupData.GetGroupMembers(new UUID(msg.fromAgentID).ToString(), GroupID);
+                List<UUID> alreadySeen = new List<UUID>();
+
+                foreach (Scene s in m_sceneList)
+                {
+                    s.ForEachScenePresence(sp =>
+                        {
+                            // We need this, because we are searching through all
+                            // SPs, both root and children
+                            if (alreadySeen.Contains(sp.UUID))
+                            {
+                                if (m_debugEnabled)
+                                    m_log.DebugFormat("[Groups.Messaging]: skipping agent {0} because we've already seen it", sp.UUID);
+                                return;
+                            }
+                            alreadySeen.Add(sp.UUID);
+
+                            GroupMembersData m = groupMembers.Find(gmd =>
+                                {
+                                    return gmd.AgentID == sp.UUID;
+                                });
+                            if (m.AgentID == UUID.Zero)
+                            {
+                                if (m_debugEnabled)
+                                    m_log.DebugFormat("[Groups.Messaging]: skipping agent {0} because he is not a member of the group", sp.UUID);
+                                return;
+                            }
+
+                            // Check if the user has an agent in the region where
+                            // the IM came from, and if so, skip it, because the IM
+                            // was already sent via that agent
+                            if (regionOfOrigin != null)
+                            {
+                                AgentCircuitData aCircuit = s.AuthenticateHandler.GetAgentCircuitData(sp.UUID);
+                                if (aCircuit != null)
+                                {
+                                    if (aCircuit.ChildrenCapSeeds.Keys.Contains(regionOfOrigin.RegionHandle))
+                                    {
+                                        if (m_debugEnabled)
+                                            m_log.DebugFormat("[Groups.Messaging]: skipping agent {0} because he has an agent in region of origin", sp.UUID);
+                                        return;
+                                    }
+                                    else                                
+                                    {
+                                        if (m_debugEnabled)
+                                            m_log.DebugFormat("[Groups.Messaging]: not skipping agent {0}", sp.UUID);
+                                    }
+                                }
+                            }
+
+                            UUID AgentID = sp.UUID;
+                            msg.toAgentID = AgentID.Guid;
+
+                            if (!hasAgentDroppedGroupChatSession(AgentID.ToString(), GroupID)
+                                && !hasAgentBeenInvitedToGroupChatSession(AgentID.ToString(), GroupID))
+                            {
+                                AddAgentToSession(AgentID, GroupID, msg);
+                            }
+
+                            if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: Passing to ProcessMessageFromGroupSession to deliver to {0} locally", sp.Name);
+
+                            ProcessMessageFromGroupSession(msg);
+                        });
+                }
             }
         }
 
@@ -367,82 +452,40 @@ namespace OpenSim.Groups
 
             UUID AgentID = new UUID(msg.fromAgentID);
             UUID GroupID = new UUID(msg.imSessionID);
+            UUID toAgentID = new UUID(msg.toAgentID);
 
             switch (msg.dialog)
             {
                 case (byte)InstantMessageDialog.SessionAdd:
-                    m_groupData.AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
+                    AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
                     break;
 
                 case (byte)InstantMessageDialog.SessionDrop:
-                    m_groupData.AgentDroppedFromGroupChatSession(AgentID.ToString(), GroupID);
+                    AgentDroppedFromGroupChatSession(AgentID.ToString(), GroupID);
                     break;
 
                 case (byte)InstantMessageDialog.SessionSend:
-                    if (!m_groupData.hasAgentDroppedGroupChatSession(AgentID.ToString(), GroupID)
-                        && !m_groupData.hasAgentBeenInvitedToGroupChatSession(AgentID.ToString(), GroupID)
-                        )
+                    // User hasn't dropped, so they're in the session, 
+                    // maybe we should deliver it.
+                    IClientAPI client = GetActiveClient(new UUID(msg.toAgentID));
+                    if (client != null)
                     {
-                        // Agent not in session and hasn't dropped from session
-                        // Add them to the session for now, and Invite them
-                        m_groupData.AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
+                        // Deliver locally, directly
+                        if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: Delivering to {0} locally", client.Name);
 
-                        UUID toAgentID = new UUID(msg.toAgentID);
-                        IClientAPI activeClient = GetActiveClient(toAgentID);
-                        if (activeClient != null)
+                        if (!hasAgentDroppedGroupChatSession(toAgentID.ToString(), GroupID))
                         {
-                            GroupRecord groupInfo = m_groupData.GetGroupRecord(UUID.Zero.ToString(), GroupID, null);
-                            if (groupInfo != null)
-                            {
-                                if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: Sending chatterbox invite instant message");
-
-                                // Force? open the group session dialog???
-                                // and simultanously deliver the message, so we don't need to do a seperate client.SendInstantMessage(msg);
-                                IEventQueue eq = activeClient.Scene.RequestModuleInterface<IEventQueue>();
-                                eq.ChatterboxInvitation(
-                                    GroupID
-                                    , groupInfo.GroupName
-                                    , new UUID(msg.fromAgentID)
-                                    , msg.message
-                                    , new UUID(msg.toAgentID)
-                                    , msg.fromAgentName
-                                    , msg.dialog
-                                    , msg.timestamp
-                                    , msg.offline == 1
-                                    , (int)msg.ParentEstateID
-                                    , msg.Position
-                                    , 1
-                                    , new UUID(msg.imSessionID)
-                                    , msg.fromGroup
-                                    , OpenMetaverse.Utils.StringToBytes(groupInfo.GroupName)
-                                    );
-
-                                eq.ChatterBoxSessionAgentListUpdates(
-                                    new UUID(GroupID)
-                                    , new UUID(msg.fromAgentID)
-                                    , new UUID(msg.toAgentID)
-                                    , false //canVoiceChat
-                                    , false //isModerator
-                                    , false //text mute
-                                    );
-                            }
+                            if (!hasAgentBeenInvitedToGroupChatSession(toAgentID.ToString(), GroupID))
+                                // This actually sends the message too, so no need to resend it
+                                // with client.SendInstantMessage
+                                AddAgentToSession(toAgentID, GroupID, msg);
+                            else
+                                client.SendInstantMessage(msg);
                         }
                     }
-                    else if (!m_groupData.hasAgentDroppedGroupChatSession(AgentID.ToString(), GroupID))
+                    else
                     {
-                        // User hasn't dropped, so they're in the session, 
-                        // maybe we should deliver it.
-                        IClientAPI client = GetActiveClient(new UUID(msg.toAgentID));
-                        if (client != null)
-                        {
-                            // Deliver locally, directly
-                            if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: Delivering to {0} locally", client.Name);
-                            client.SendInstantMessage(msg);
-                        }
-                        else
-                        {
-                            m_log.WarnFormat("[Groups.Messaging]: Received a message over the grid for a client that isn't here: {0}", msg.toAgentID);
-                        }
+                        m_log.WarnFormat("[Groups.Messaging]: Received a message over the grid for a client that isn't here: {0}", msg.toAgentID);
                     }
                     break;
 
@@ -452,6 +495,53 @@ namespace OpenSim.Groups
             }
         }
 
+        private void AddAgentToSession(UUID AgentID, UUID GroupID, GridInstantMessage msg)
+        {
+            // Agent not in session and hasn't dropped from session
+            // Add them to the session for now, and Invite them
+            AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
+
+            IClientAPI activeClient = GetActiveClient(AgentID);
+            if (activeClient != null)
+            {
+                GroupRecord groupInfo = m_groupData.GetGroupRecord(UUID.Zero.ToString(), GroupID, null);
+                if (groupInfo != null)
+                {
+                    if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: Sending chatterbox invite instant message");
+
+                    // Force? open the group session dialog???
+                    // and simultanously deliver the message, so we don't need to do a seperate client.SendInstantMessage(msg);
+                    IEventQueue eq = activeClient.Scene.RequestModuleInterface<IEventQueue>();
+                    eq.ChatterboxInvitation(
+                        GroupID
+                        , groupInfo.GroupName
+                        , new UUID(msg.fromAgentID)
+                        , msg.message
+                        , AgentID
+                        , msg.fromAgentName
+                        , msg.dialog
+                        , msg.timestamp
+                        , msg.offline == 1
+                        , (int)msg.ParentEstateID
+                        , msg.Position
+                        , 1
+                        , new UUID(msg.imSessionID)
+                        , msg.fromGroup
+                        , OpenMetaverse.Utils.StringToBytes(groupInfo.GroupName)
+                        );
+
+                    eq.ChatterBoxSessionAgentListUpdates(
+                        new UUID(GroupID)
+                        , AgentID
+                        , new UUID(msg.toAgentID)
+                        , false //canVoiceChat
+                        , false //isModerator
+                        , false //text mute
+                        );
+                }
+            }
+        }
+
         #endregion
 
 
@@ -477,7 +567,7 @@ namespace OpenSim.Groups
     
                 if (groupInfo != null)
                 {
-                    m_groupData.AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
+                    AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
 
                     ChatterBoxSessionStartReplyViaCaps(remoteClient, groupInfo.GroupName, GroupID);
 
@@ -503,7 +593,7 @@ namespace OpenSim.Groups
                     m_log.DebugFormat("[Groups.Messaging]: Send message to session for group {0} with session ID {1}", GroupID, im.imSessionID.ToString());
 
                 //If this agent is sending a message, then they want to be in the session
-                m_groupData.AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
+                AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
 
                 SendMessageToGroup(im, GroupID);
             }
@@ -598,5 +688,70 @@ namespace OpenSim.Groups
         }
 
         #endregion
+
+        #region GroupSessionTracking
+
+        public void ResetAgentGroupChatSessions(string agentID)
+        {
+            foreach (List<string> agentList in m_groupsAgentsDroppedFromChatSession.Values)
+            {
+                agentList.Remove(agentID);
+            }
+        }
+
+        public bool hasAgentBeenInvitedToGroupChatSession(string agentID, UUID groupID)
+        {
+            // If we're  tracking this group, and we can find them in the tracking, then they've been invited
+            return m_groupsAgentsInvitedToChatSession.ContainsKey(groupID)
+                && m_groupsAgentsInvitedToChatSession[groupID].Contains(agentID);
+        }
+
+        public bool hasAgentDroppedGroupChatSession(string agentID, UUID groupID)
+        {
+            // If we're tracking drops for this group,
+            // and we find them, well... then they've dropped
+            return m_groupsAgentsDroppedFromChatSession.ContainsKey(groupID)
+                && m_groupsAgentsDroppedFromChatSession[groupID].Contains(agentID);
+        }
+
+        public void AgentDroppedFromGroupChatSession(string agentID, UUID groupID)
+        {
+            if (m_groupsAgentsDroppedFromChatSession.ContainsKey(groupID))
+            {
+                // If not in dropped list, add
+                if (!m_groupsAgentsDroppedFromChatSession[groupID].Contains(agentID))
+                {
+                    m_groupsAgentsDroppedFromChatSession[groupID].Add(agentID);
+                }
+            }
+        }
+
+        public void AgentInvitedToGroupChatSession(string agentID, UUID groupID)
+        {
+            // Add Session Status if it doesn't exist for this session
+            CreateGroupChatSessionTracking(groupID);
+
+            // If nessesary, remove from dropped list
+            if (m_groupsAgentsDroppedFromChatSession[groupID].Contains(agentID))
+            {
+                m_groupsAgentsDroppedFromChatSession[groupID].Remove(agentID);
+            }
+
+            // Add to invited
+            if (!m_groupsAgentsInvitedToChatSession[groupID].Contains(agentID))
+                m_groupsAgentsInvitedToChatSession[groupID].Add(agentID);
+        }
+
+        private void CreateGroupChatSessionTracking(UUID groupID)
+        {
+            if (!m_groupsAgentsDroppedFromChatSession.ContainsKey(groupID))
+            {
+                m_groupsAgentsDroppedFromChatSession.Add(groupID, new List<string>());
+                m_groupsAgentsInvitedToChatSession.Add(groupID, new List<string>());
+            }
+
+        }
+        #endregion
+
     }
 }