bad merge?

3 files changed, 249 insertions, 43 deletions

diff --git a/OpenSim/Region/CoreModules/Avatar/InstantMessage/InstantMessageModule.cs b/OpenSim/Region/CoreModules/Avatar/InstantMessage/InstantMessageModule.cs
index c33a296..55e30a0 100644
--- a/OpenSim/Region/CoreModules/Avatar/InstantMessage/InstantMessageModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/InstantMessage/InstantMessageModule.cs
@@ -27,6 +27,7 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
+using System.Timers;
 using log4net;
 using Mono.Addins;
 using Nini.Config;
@@ -44,6 +45,10 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
         private static readonly ILog m_log = LogManager.GetLogger(
                 MethodBase.GetCurrentMethod().DeclaringType);
 
+        private Timer m_logTimer = new Timer(10000);
+        private List<GridInstantMessage> m_logData = new List<GridInstantMessage>();
+        private string m_restUrl;
+
         /// <value>
         /// Is this module enabled?
         /// </value>
@@ -63,9 +68,12 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
                         "InstantMessageModule", "InstantMessageModule") !=
                         "InstantMessageModule")
                     return;
+                m_restUrl = config.Configs["Messaging"].GetString("LogURL", String.Empty);
             }
             
             m_enabled = true;
+            m_logTimer.AutoReset = false;
+            m_logTimer.Elapsed += LogTimerElapsed;
         }
 
         public void AddRegion(Scene scene)
@@ -150,6 +158,9 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
         {
             byte dialog = im.dialog;
 
+            if (client != null && dialog == (byte)InstantMessageDialog.MessageFromAgent)
+                LogInstantMesssage(im);
+
             if (dialog != (byte)InstantMessageDialog.MessageFromAgent
                 && dialog != (byte)InstantMessageDialog.StartTyping
                 && dialog != (byte)InstantMessageDialog.StopTyping
@@ -159,6 +170,32 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
                 return;
             }
 
+            //DateTime dt = DateTime.UtcNow;
+
+            // Ticks from UtcNow, but make it look like local. Evil, huh?
+            //dt = DateTime.SpecifyKind(dt, DateTimeKind.Local);
+
+            //try
+            //{
+            //    // Convert that to the PST timezone
+            //    TimeZoneInfo timeZoneInfo = TimeZoneInfo.FindSystemTimeZoneById("America/Los_Angeles");
+            //    dt = TimeZoneInfo.ConvertTime(dt, timeZoneInfo);
+            //}
+            //catch
+            //{
+            //    //m_log.Info("[OFFLINE MESSAGING]: No PST timezone found on this machine. Saving with local timestamp.");
+            //}
+
+            //// And make it look local again to fool the unix time util
+            //dt = DateTime.SpecifyKind(dt, DateTimeKind.Utc);
+
+            // If client is null, this message comes from storage and IS offline
+            if (client != null)
+                im.offline = 0;
+
+            if (im.offline == 0)
+                im.timestamp = (uint)Util.UnixTimeSinceEpoch();
+
             if (m_TransferModule != null)
             {
                 if (client != null)
@@ -202,5 +239,35 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
             //
             OnInstantMessage(null, msg);
         }
+
+        private void LogInstantMesssage(GridInstantMessage im)
+        {
+            if (m_logData.Count < 20)
+            {
+                // Restart the log write timer
+                m_logTimer.Stop();
+            }
+            if (!m_logTimer.Enabled)
+                m_logTimer.Start();
+
+            lock (m_logData)
+            {
+                m_logData.Add(im);
+            }
+        }
+
+        private void LogTimerElapsed(object source, ElapsedEventArgs e)
+        {
+            lock (m_logData)
+            {
+                if (m_restUrl != String.Empty && m_logData.Count > 0)
+                {
+                    bool success = SynchronousRestObjectRequester.MakeRequest<List<GridInstantMessage>, bool>("POST", m_restUrl + "/LogMessages/", m_logData);
+                    if (!success)
+                        m_log.ErrorFormat("[INSTANT MESSAGE]: Failed to save log data");
+                }
+                m_logData.Clear();
+            }
+        }
     }
 }
diff --git a/OpenSim/Region/CoreModules/Avatar/InstantMessage/MessageTransferModule.cs b/OpenSim/Region/CoreModules/Avatar/InstantMessage/MessageTransferModule.cs
index 2462ff8..5573c94 100644
--- a/OpenSim/Region/CoreModules/Avatar/InstantMessage/MessageTransferModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/InstantMessage/MessageTransferModule.cs
@@ -50,6 +50,7 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         private bool m_Enabled = false;
+        protected string m_MessageKey = String.Empty;
         protected List<Scene> m_Scenes = new List<Scene>();
         protected Dictionary<UUID, UUID> m_UserRegionMap = new Dictionary<UUID, UUID>();
 
@@ -69,14 +70,17 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
         public virtual void Initialise(IConfigSource config)
         {
             IConfig cnf = config.Configs["Messaging"];
-            if (cnf != null && cnf.GetString(
-                    "MessageTransferModule", "MessageTransferModule") !=
-                    "MessageTransferModule")
+            if (cnf != null)
             {
-                m_log.Debug("[MESSAGE TRANSFER]: Disabled by configuration");
-                return;
-            }
+                if (cnf.GetString("MessageTransferModule",
+                        "MessageTransferModule") != "MessageTransferModule")
+                {
+                    return;
+                }
 
+                m_MessageKey = cnf.GetString("MessageKey", String.Empty);
+            }
+            m_log.Debug("[MESSAGE TRANSFER]: Module enabled");
             m_Enabled = true;
         }
 
@@ -135,6 +139,9 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
         {
             UUID toAgentID = new UUID(im.toAgentID);
 
+            if (toAgentID == UUID.Zero)
+                return;
+
             // Try root avatar only first
             foreach (Scene scene in m_Scenes)
             {
@@ -249,6 +256,19 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
                         && requestData.ContainsKey("position_z") && requestData.ContainsKey("region_id")
                         && requestData.ContainsKey("binary_bucket"))
                 {
+                    if (m_MessageKey != String.Empty)
+                    {
+                        XmlRpcResponse error_resp = new XmlRpcResponse();
+                        Hashtable error_respdata = new Hashtable();
+                        error_respdata["success"] = "FALSE";
+                        error_resp.Value = error_respdata;
+
+                        if (!requestData.Contains("message_key"))
+                            return error_resp;
+                        if (m_MessageKey != (string)requestData["message_key"])
+                            return error_resp;
+                    }
+
                     // Do the easy way of validating the UUIDs
                     UUID.TryParse((string)requestData["from_agent_id"], out fromAgentID);
                     UUID.TryParse((string)requestData["to_agent_id"], out toAgentID);
@@ -425,34 +445,89 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
             return resp;
         }
 
+<<<<<<< HEAD
         /// <summary>
         /// delegate for sending a grid instant message asynchronously
         /// </summary>
         public delegate void GridInstantMessageDelegate(GridInstantMessage im, MessageResultNotification result);
+=======
+        private delegate void GridInstantMessageDelegate(GridInstantMessage im, MessageResultNotification result);
+>>>>>>> avn/ubitvar
 
-        protected virtual void GridInstantMessageCompleted(IAsyncResult iar)
-        {
-            GridInstantMessageDelegate icon =
-                    (GridInstantMessageDelegate)iar.AsyncState;
-            icon.EndInvoke(iar);
-        }
+        private class GIM {
+            public GridInstantMessage im;
+            public MessageResultNotification result;
+        };
 
+        private Queue<GIM> pendingInstantMessages = new Queue<GIM>();
+        private int numInstantMessageThreads = 0;
 
-        protected virtual void SendGridInstantMessageViaXMLRPC(GridInstantMessage im, MessageResultNotification result)
+        private void SendGridInstantMessageViaXMLRPC(GridInstantMessage im, MessageResultNotification result)
         {
-            GridInstantMessageDelegate d = SendGridInstantMessageViaXMLRPCAsync;
+            lock (pendingInstantMessages) {
+                if (numInstantMessageThreads >= 4) {
+                    GIM gim = new GIM();
+                    gim.im = im;
+                    gim.result = result;
+                    pendingInstantMessages.Enqueue(gim);
+                } else {
+                    ++ numInstantMessageThreads;
+                    //m_log.DebugFormat("[SendGridInstantMessageViaXMLRPC]: ++numInstantMessageThreads={0}", numInstantMessageThreads);
+                    GridInstantMessageDelegate d = SendGridInstantMessageViaXMLRPCAsyncMain;
+                    d.BeginInvoke(im, result, GridInstantMessageCompleted, d);
+                }
+            }
+        }
 
+<<<<<<< HEAD
             d.BeginInvoke(im, result, GridInstantMessageCompleted, d);
+=======
+        private void GridInstantMessageCompleted(IAsyncResult iar)
+        {
+            GridInstantMessageDelegate d = (GridInstantMessageDelegate)iar.AsyncState;
+            d.EndInvoke(iar);
+>>>>>>> avn/ubitvar
         }
 
         /// <summary>
         /// Internal SendGridInstantMessage over XMLRPC method.
         /// </summary>
+<<<<<<< HEAD
         /// <remarks>
         /// This is called from within a dedicated thread.
         /// </remarks>
         private void SendGridInstantMessageViaXMLRPCAsync(GridInstantMessage im, MessageResultNotification result)
+=======
+        /// <param name="prevRegionHandle">
+        /// Pass in 0 the first time this method is called.  It will be called recursively with the last 
+        /// regionhandle tried
+        /// </param>
+        private void SendGridInstantMessageViaXMLRPCAsyncMain(GridInstantMessage im, MessageResultNotification result)
+>>>>>>> avn/ubitvar
         {
+            GIM gim;
+            do {
+                try {
+                    SendGridInstantMessageViaXMLRPCAsync(im, result, UUID.Zero);
+                } catch (Exception e) {
+                    m_log.Error("[SendGridInstantMessageViaXMLRPC]: exception " + e.Message);
+                }
+                lock (pendingInstantMessages) {
+                    if (pendingInstantMessages.Count > 0) {
+                        gim = pendingInstantMessages.Dequeue();
+                        im = gim.im;
+                        result = gim.result;
+                    } else {
+                        gim = null;
+                        -- numInstantMessageThreads;
+                        //m_log.DebugFormat("[SendGridInstantMessageViaXMLRPC]: --numInstantMessageThreads={0}", numInstantMessageThreads);
+                    }
+                }
+            } while (gim != null);
+        }
+        private void SendGridInstantMessageViaXMLRPCAsync(GridInstantMessage im, MessageResultNotification result, UUID prevRegionID)
+        {
+
             UUID toAgentID = new UUID(im.toAgentID);
             UUID regionID;
             bool needToLookupAgent;
@@ -494,6 +569,7 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
                     break;
                 }
 
+<<<<<<< HEAD
                 // Try to send the message to the agent via the retrieved region.
                 Hashtable msgdata = ConvertGridInstantMessageToXMLRPC(im);
                 msgdata["region_handle"] = 0;
@@ -501,6 +577,13 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
 
                 // If the message delivery was successful, then cache the entry.
                 if (imresult)
+=======
+            if (upd != null)
+            {
+                GridRegion reginfo = m_Scenes[0].GridService.GetRegionByUUID(UUID.Zero,
+                    upd.RegionID);
+                if (reginfo != null)
+>>>>>>> avn/ubitvar
                 {
                     lock (m_UserRegionMap)
                     {
@@ -622,6 +705,8 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
             gim["position_z"] = msg.Position.Z.ToString();
             gim["region_id"] = new UUID(msg.RegionID).ToString();
             gim["binary_bucket"] = Convert.ToBase64String(msg.binaryBucket,Base64FormattingOptions.None);
+            if (m_MessageKey != String.Empty)
+                gim["message_key"] = m_MessageKey;
             return gim;
         }
 
diff --git a/OpenSim/Region/CoreModules/Avatar/InstantMessage/OfflineMessageModule.cs b/OpenSim/Region/CoreModules/Avatar/InstantMessage/OfflineMessageModule.cs
index c75920d..76023bd 100644
--- a/OpenSim/Region/CoreModules/Avatar/InstantMessage/OfflineMessageModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/InstantMessage/OfflineMessageModule.cs
@@ -40,6 +40,13 @@ using OpenSim.Region.Framework.Scenes;
 
 namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
 {
+    public struct SendReply
+    {
+        public bool Success;
+        public string Message;
+        public int Disposition;
+    }
+
     [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "OfflineMessageModule")]
     public class OfflineMessageModule : ISharedRegionModule
     {
@@ -50,6 +57,7 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
         private string m_RestURL = String.Empty;
         IMessageTransferModule m_TransferModule = null;
         private bool m_ForwardOfflineGroupMessages = true;
+        private Dictionary<IClientAPI, List<UUID>> m_repliesSent= new Dictionary<IClientAPI, List<UUID>>();
 
         public void Initialise(IConfigSource config)
         {
@@ -169,11 +177,21 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
         private void OnNewClient(IClientAPI client)
         {
             client.OnRetrieveInstantMessages += RetrieveInstantMessages;
+            client.OnLogout += OnClientLoggedOut;
+        }
+
+        public void OnClientLoggedOut(IClientAPI client)
+        {
+            m_repliesSent.Remove(client);
         }
 
         private void RetrieveInstantMessages(IClientAPI client)
         {
-            if (m_RestURL != "")
+            if (m_RestURL == String.Empty)
+            {
+                return;
+            }
+            else
             {
                 m_log.DebugFormat("[OFFLINE MESSAGING]: Retrieving stored messages for {0}", client.AgentId);
 
@@ -181,28 +199,28 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
                     = SynchronousRestObjectRequester.MakeRequest<UUID, List<GridInstantMessage>>(
                         "POST", m_RestURL + "/RetrieveMessages/", client.AgentId);
 
-                if (msglist == null)
+                if (msglist != null)
                 {
-                    m_log.WarnFormat("[OFFLINE MESSAGING]: WARNING null message list.");
-                    return;
-                }
-
-                foreach (GridInstantMessage im in msglist)
-                {
-                    if (im.dialog == (byte)InstantMessageDialog.InventoryOffered)
-                        // send it directly or else the item will be given twice
-                        client.SendInstantMessage(im);
-                    else
+                    foreach (GridInstantMessage im in msglist)
                     {
-                        // Send through scene event manager so all modules get a chance
-                        // to look at this message before it gets delivered.
-                        //
-                        // Needed for proper state management for stored group
-                        // invitations
-                        //
-                        Scene s = FindScene(client.AgentId);
-                        if (s != null)
-                            s.EventManager.TriggerIncomingInstantMessage(im);
+                        if (im.dialog == (byte)InstantMessageDialog.InventoryOffered)
+                            // send it directly or else the item will be given twice
+                            client.SendInstantMessage(im);
+                        else
+                        {
+                            // Send through scene event manager so all modules get a chance
+                            // to look at this message before it gets delivered.
+                            //
+                            // Needed for proper state management for stored group
+                            // invitations
+                            //
+
+                            im.offline = 1;
+
+                            Scene s = FindScene(client.AgentId);
+                            if (s != null)
+                                s.EventManager.TriggerIncomingInstantMessage(im);
+                        }
                     }
                 }
             }
@@ -214,11 +232,13 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
                 im.dialog != (byte)InstantMessageDialog.MessageFromAgent &&
                 im.dialog != (byte)InstantMessageDialog.GroupNotice &&
                 im.dialog != (byte)InstantMessageDialog.GroupInvitation &&
-                im.dialog != (byte)InstantMessageDialog.InventoryOffered)
+                im.dialog != (byte)InstantMessageDialog.InventoryOffered &&
+                im.dialog != (byte)InstantMessageDialog.TaskInventoryOffered)
             {
                 return;
             }
 
+<<<<<<< HEAD
             if (!m_ForwardOfflineGroupMessages)
             {
                 if (im.dialog == (byte)InstantMessageDialog.GroupNotice ||
@@ -228,6 +248,15 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
 
             bool success = SynchronousRestObjectRequester.MakeRequest<GridInstantMessage, bool>(
                     "POST", m_RestURL+"/SaveMessage/", im, 10000);
+=======
+            Scene scene = FindScene(new UUID(im.fromAgentID));
+            if (scene == null)
+                scene = m_SceneList[0];
+
+            SendReply reply = SynchronousRestObjectRequester.MakeRequest<GridInstantMessage, SendReply>(
+                    "POST", m_RestURL+"/SaveMessage/?scope=" +
+                    scene.RegionInfo.ScopeID.ToString(), im);
+>>>>>>> avn/ubitvar
 
             if (im.dialog == (byte)InstantMessageDialog.MessageFromAgent)
             {
@@ -235,13 +264,38 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
                 if (client == null)
                     return;
 
-                client.SendInstantMessage(new GridInstantMessage(
-                        null, new UUID(im.toAgentID),
-                        "System", new UUID(im.fromAgentID),
-                        (byte)InstantMessageDialog.MessageFromAgent,
-                        "User is not logged in. "+
-                        (success ? "Message saved." : "Message not saved"),
-                        false, new Vector3()));
+                if (reply.Message == String.Empty)
+                    reply.Message = "User is not logged in. " + (reply.Success ? "Message saved." : "Message not saved");
+
+                bool sendReply = true;
+
+                switch (reply.Disposition)
+                {
+                case 0: // Normal
+                    break;
+                case 1: // Only once per user
+                    if (m_repliesSent.ContainsKey(client) && m_repliesSent[client].Contains(new UUID(im.toAgentID)))
+                    {
+                        sendReply = false;
+                    }
+                    else
+                    {
+                        if (!m_repliesSent.ContainsKey(client))
+                            m_repliesSent[client] = new List<UUID>();
+                        m_repliesSent[client].Add(new UUID(im.toAgentID));
+                    }
+                    break;
+                }
+
+                if (sendReply)
+                {
+                    client.SendInstantMessage(new GridInstantMessage(
+                            null, new UUID(im.toAgentID),
+                            "System", new UUID(im.fromAgentID),
+                            (byte)InstantMessageDialog.MessageFromAgent,
+                            reply.Message,
+                            false, new Vector3()));
+                }
             }
         }
     }