Initial update to OpenSim 0.8.2.1 source code.

1 files changed, 396 insertions, 86 deletions

diff --git a/OpenSim/Region/OptionalModules/Scripting/JsonStore/JsonStoreScriptModule.cs b/OpenSim/Region/OptionalModules/Scripting/JsonStore/JsonStoreScriptModule.cs
index 0c175ca..edf51a2 100644
--- a/OpenSim/Region/OptionalModules/Scripting/JsonStore/JsonStoreScriptModule.cs
+++ b/OpenSim/Region/OptionalModules/Scripting/JsonStore/JsonStoreScriptModule.cs
@@ -39,8 +39,10 @@ using OpenMetaverse.StructuredData;
 using OpenSim.Framework;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.Framework.Scenes.Scripting;
 using System.Collections.Generic;
 using System.Text.RegularExpressions;
+using PermissionMask = OpenSim.Framework.PermissionMask;
 
 namespace OpenSim.Region.OptionalModules.Scripting.JsonStore
 {
@@ -57,7 +59,9 @@ namespace OpenSim.Region.OptionalModules.Scripting.JsonStore
 
         private IScriptModuleComms m_comms;
         private IJsonStoreModule m_store;
-        
+
+        private Dictionary<UUID,HashSet<UUID>> m_scriptStores = new Dictionary<UUID,HashSet<UUID>>();
+
 #region Region Module interface
 
         // -----------------------------------------------------------------
@@ -92,12 +96,12 @@ namespace OpenSim.Region.OptionalModules.Scripting.JsonStore
             }
             catch (Exception e)
             {
-                m_log.ErrorFormat("[JsonStoreScripts] initialization error: {0}",e.Message);
+                m_log.ErrorFormat("[JsonStoreScripts]: initialization error: {0}", e.Message);
                 return;
             }
 
             if (m_enabled)
-                m_log.DebugFormat("[JsonStoreScripts] module is enabled");
+                m_log.DebugFormat("[JsonStoreScripts]: module is enabled");
         }
 
         // -----------------------------------------------------------------
@@ -124,6 +128,8 @@ namespace OpenSim.Region.OptionalModules.Scripting.JsonStore
         // -----------------------------------------------------------------
         public void AddRegion(Scene scene)
         {
+            scene.EventManager.OnScriptReset += HandleScriptReset;
+            scene.EventManager.OnRemoveScript += HandleScriptReset;
         }
 
         // -----------------------------------------------------------------
@@ -132,12 +138,34 @@ namespace OpenSim.Region.OptionalModules.Scripting.JsonStore
         // -----------------------------------------------------------------
         public void RemoveRegion(Scene scene)
         {
+            scene.EventManager.OnScriptReset -= HandleScriptReset;
+            scene.EventManager.OnRemoveScript -= HandleScriptReset;
+
             // need to remove all references to the scene in the subscription
             // list to enable full garbage collection of the scene object
         }
 
         // -----------------------------------------------------------------
         /// <summary>
+        /// </summary>
+        // -----------------------------------------------------------------
+        private void HandleScriptReset(uint localID, UUID itemID)
+        {
+            HashSet<UUID> stores;
+
+            lock (m_scriptStores)
+            {
+                if (! m_scriptStores.TryGetValue(itemID, out stores))
+                    return;
+                m_scriptStores.Remove(itemID);
+            }
+
+            foreach (UUID id in stores)
+                m_store.DestroyStore(id);
+        }
+
+        // -----------------------------------------------------------------
+        /// <summary>
         /// Called when all modules have been added for a region. This is 
         /// where we hook up events
         /// </summary>
@@ -150,7 +178,7 @@ namespace OpenSim.Region.OptionalModules.Scripting.JsonStore
                 m_comms = m_scene.RequestModuleInterface<IScriptModuleComms>();
                 if (m_comms == null)
                 {
-                    m_log.ErrorFormat("[JsonStoreScripts] ScriptModuleComms interface not defined");
+                    m_log.ErrorFormat("[JsonStoreScripts]: ScriptModuleComms interface not defined");
                     m_enabled = false;
                     return;
                 }
@@ -158,40 +186,20 @@ namespace OpenSim.Region.OptionalModules.Scripting.JsonStore
                 m_store = m_scene.RequestModuleInterface<IJsonStoreModule>();
                 if (m_store == null)
                 {
-                    m_log.ErrorFormat("[JsonStoreScripts] JsonModule interface not defined");
+                    m_log.ErrorFormat("[JsonStoreScripts]: JsonModule interface not defined");
                     m_enabled = false;
                     return;
                 }
-                    
+
                 try
                 {
-                    m_comms.RegisterScriptInvocation(this,"JsonCreateStore");
-                    m_comms.RegisterScriptInvocation(this,"JsonDestroyStore");
-
-                    m_comms.RegisterScriptInvocation(this,"JsonReadNotecard");
-                    m_comms.RegisterScriptInvocation(this,"JsonWriteNotecard");
-
-                    m_comms.RegisterScriptInvocation(this,"JsonTestPath");
-                    m_comms.RegisterScriptInvocation(this,"JsonTestPathJson");
-
-                    m_comms.RegisterScriptInvocation(this,"JsonGetValue");
-                    m_comms.RegisterScriptInvocation(this,"JsonGetValueJson");
-
-                    m_comms.RegisterScriptInvocation(this,"JsonTakeValue");
-                    m_comms.RegisterScriptInvocation(this,"JsonTakeValueJson");
-
-                    m_comms.RegisterScriptInvocation(this,"JsonReadValue");
-                    m_comms.RegisterScriptInvocation(this,"JsonReadValueJson");
-
-                    m_comms.RegisterScriptInvocation(this,"JsonSetValue");
-                    m_comms.RegisterScriptInvocation(this,"JsonSetValueJson");
-
-                    m_comms.RegisterScriptInvocation(this,"JsonRemoveValue");
+                    m_comms.RegisterScriptInvocations(this);
+                    m_comms.RegisterConstants(this);
                 }
                 catch (Exception e)
                 {
                     // See http://opensimulator.org/mantis/view.php?id=5971 for more information
-                    m_log.WarnFormat("[JsonStroreScripts] script method registration failed; {0}",e.Message);
+                    m_log.WarnFormat("[JsonStoreScripts]: script method registration failed; {0}", e.Message);
                     m_enabled = false;
                 }
             }
@@ -208,28 +216,73 @@ namespace OpenSim.Region.OptionalModules.Scripting.JsonStore
 
 #endregion
 
+#region ScriptConstantsInterface
+
+        [ScriptConstant]
+        public static readonly int JSON_NODETYPE_UNDEF = (int)JsonStoreNodeType.Undefined;
+
+        [ScriptConstant]
+        public static readonly int JSON_NODETYPE_OBJECT = (int)JsonStoreNodeType.Object;
+
+        [ScriptConstant]
+        public static readonly int JSON_NODETYPE_ARRAY = (int)JsonStoreNodeType.Array;
+
+        [ScriptConstant]
+        public static readonly int JSON_NODETYPE_VALUE = (int)JsonStoreNodeType.Value;
+
+        [ScriptConstant]
+        public static readonly int JSON_VALUETYPE_UNDEF = (int)JsonStoreValueType.Undefined;
+
+        [ScriptConstant]
+        public static readonly int JSON_VALUETYPE_BOOLEAN = (int)JsonStoreValueType.Boolean;
+
+        [ScriptConstant]
+        public static readonly int JSON_VALUETYPE_INTEGER = (int)JsonStoreValueType.Integer;
+
+        [ScriptConstant]
+        public static readonly int JSON_VALUETYPE_FLOAT = (int)JsonStoreValueType.Float;
+
+        [ScriptConstant]
+        public static readonly int JSON_VALUETYPE_STRING = (int)JsonStoreValueType.String;
+
+
+#endregion
+
 #region ScriptInvocationInteface
         // -----------------------------------------------------------------
         /// <summary>
         /// 
         /// </summary>
         // -----------------------------------------------------------------
-        protected void GenerateRuntimeError(string msg)
+        [ScriptInvocation]
+        public UUID JsonAttachObjectStore(UUID hostID, UUID scriptID)
         {
-            throw new Exception("JsonStore Runtime Error: " + msg);
+            UUID uuid = UUID.Zero;
+            if (! m_store.AttachObjectStore(hostID))
+                GenerateRuntimeError("Failed to create Json store");
+            
+            return hostID;
         }
-        
+
         // -----------------------------------------------------------------
         /// <summary>
         /// 
         /// </summary>
         // -----------------------------------------------------------------
-        protected UUID JsonCreateStore(UUID hostID, UUID scriptID, string value)
+        [ScriptInvocation]
+        public UUID JsonCreateStore(UUID hostID, UUID scriptID, string value)
         {
             UUID uuid = UUID.Zero;
             if (! m_store.CreateStore(value, ref uuid))
                 GenerateRuntimeError("Failed to create Json store");
             
+            lock (m_scriptStores)
+            {
+                if (! m_scriptStores.ContainsKey(scriptID))
+                    m_scriptStores[scriptID] = new HashSet<UUID>();
+                
+                m_scriptStores[scriptID].Add(uuid);
+            }
             return uuid;
         }
 
@@ -238,8 +291,15 @@ namespace OpenSim.Region.OptionalModules.Scripting.JsonStore
         /// 
         /// </summary>
         // -----------------------------------------------------------------
-        protected int JsonDestroyStore(UUID hostID, UUID scriptID, UUID storeID)
+        [ScriptInvocation]
+        public int JsonDestroyStore(UUID hostID, UUID scriptID, UUID storeID)
         {
+            lock(m_scriptStores)
+            {
+                if (m_scriptStores.ContainsKey(scriptID))
+                    m_scriptStores[scriptID].Remove(storeID);
+            }
+
             return m_store.DestroyStore(storeID) ? 1 : 0;
         }
 
@@ -248,10 +308,37 @@ namespace OpenSim.Region.OptionalModules.Scripting.JsonStore
         /// 
         /// </summary>
         // -----------------------------------------------------------------
-        protected UUID JsonReadNotecard(UUID hostID, UUID scriptID, UUID storeID, string path, UUID assetID)
+        [ScriptInvocation]
+        public int JsonTestStore(UUID hostID, UUID scriptID, UUID storeID)
+        {
+            return m_store.TestStore(storeID) ? 1 : 0;
+        }
+
+        // -----------------------------------------------------------------
+        /// <summary>
+        /// 
+        /// </summary>
+        // -----------------------------------------------------------------
+        [ScriptInvocation]
+        public UUID JsonRezAtRoot(UUID hostID, UUID scriptID, string item, Vector3 pos, Vector3 vel, Quaternion rot, string param)
+        {
+            UUID reqID = UUID.Random();
+            Util.FireAndForget(
+                o => DoJsonRezObject(hostID, scriptID, reqID, item, pos, vel, rot, param), null, "JsonStoreScriptModule.DoJsonRezObject");
+            return reqID;
+        }
+
+        // -----------------------------------------------------------------
+        /// <summary>
+        /// 
+        /// </summary>
+        // -----------------------------------------------------------------
+        [ScriptInvocation]
+        public UUID JsonReadNotecard(UUID hostID, UUID scriptID, UUID storeID, string path, string notecardIdentifier)
         {
             UUID reqID = UUID.Random();
-            Util.FireAndForget(delegate(object o) { DoJsonReadNotecard(reqID,hostID,scriptID,storeID,path,assetID); });
+            Util.FireAndForget(
+                o => DoJsonReadNotecard(reqID, hostID, scriptID, storeID, path, notecardIdentifier), null, "JsonStoreScriptModule.JsonReadNotecard");
             return reqID;
         }
         
@@ -260,10 +347,12 @@ namespace OpenSim.Region.OptionalModules.Scripting.JsonStore
         /// 
         /// </summary>
         // -----------------------------------------------------------------
-        protected UUID JsonWriteNotecard(UUID hostID, UUID scriptID, UUID storeID, string path, string name)
+        [ScriptInvocation]
+        public UUID JsonWriteNotecard(UUID hostID, UUID scriptID, UUID storeID, string path, string name)
         {
             UUID reqID = UUID.Random();
-            Util.FireAndForget(delegate(object o) { DoJsonWriteNotecard(reqID,hostID,scriptID,storeID,path,name); });
+            Util.FireAndForget(
+                o => DoJsonWriteNotecard(reqID,hostID,scriptID,storeID,path,name), null, "JsonStoreScriptModule.DoJsonWriteNotecard");
             return reqID;
         }
 
@@ -272,14 +361,41 @@ namespace OpenSim.Region.OptionalModules.Scripting.JsonStore
         /// 
         /// </summary>
         // -----------------------------------------------------------------
-        protected int JsonTestPath(UUID hostID, UUID scriptID, UUID storeID, string path)
+        [ScriptInvocation]
+        public string JsonList2Path(UUID hostID, UUID scriptID, object[] pathlist)
+        {
+            string ipath = ConvertList2Path(pathlist);
+            string opath;
+            
+            if (JsonStore.CanonicalPathExpression(ipath,out opath))
+                return opath;
+
+            // This won't parse if passed to the other routines as opposed to
+            // returning an empty string which is a valid path and would overwrite
+            // the entire store
+            return "**INVALID**";
+        }
+        
+        // -----------------------------------------------------------------
+        /// <summary>
+        /// 
+        /// </summary>
+        // -----------------------------------------------------------------
+        [ScriptInvocation]
+        public int JsonGetNodeType(UUID hostID, UUID scriptID, UUID storeID, string path)
         {
-            return m_store.TestPath(storeID,path,false) ? 1 : 0;
+            return (int)m_store.GetNodeType(storeID,path);
         }
 
-        protected int JsonTestPathJson(UUID hostID, UUID scriptID, UUID storeID, string path)
+        // -----------------------------------------------------------------
+        /// <summary>
+        /// 
+        /// </summary>
+        // -----------------------------------------------------------------
+        [ScriptInvocation]
+        public int JsonGetValueType(UUID hostID, UUID scriptID, UUID storeID, string path)
         {
-            return m_store.TestPath(storeID,path,true) ? 1 : 0;
+            return (int)m_store.GetValueType(storeID,path);
         }
 
         // -----------------------------------------------------------------
@@ -287,12 +403,14 @@ namespace OpenSim.Region.OptionalModules.Scripting.JsonStore
         /// 
         /// </summary>
         // -----------------------------------------------------------------
-        protected int JsonSetValue(UUID hostID, UUID scriptID, UUID storeID, string path, string value)
+        [ScriptInvocation]
+        public int JsonSetValue(UUID hostID, UUID scriptID, UUID storeID, string path, string value)
         {
             return m_store.SetValue(storeID,path,value,false) ? 1 : 0;
         }
 
-        protected int JsonSetValueJson(UUID hostID, UUID scriptID, UUID storeID, string path, string value)
+        [ScriptInvocation]
+        public int JsonSetJson(UUID hostID, UUID scriptID, UUID storeID, string path, string value)
         {
             return m_store.SetValue(storeID,path,value,true) ? 1 : 0;
         }
@@ -302,7 +420,8 @@ namespace OpenSim.Region.OptionalModules.Scripting.JsonStore
         /// 
         /// </summary>
         // -----------------------------------------------------------------
-        protected int JsonRemoveValue(UUID hostID, UUID scriptID, UUID storeID, string path)
+        [ScriptInvocation]
+        public int JsonRemoveValue(UUID hostID, UUID scriptID, UUID storeID, string path)
         {
             return m_store.RemoveValue(storeID,path) ? 1 : 0;
         }
@@ -312,14 +431,27 @@ namespace OpenSim.Region.OptionalModules.Scripting.JsonStore
         /// 
         /// </summary>
         // -----------------------------------------------------------------
-        protected string JsonGetValue(UUID hostID, UUID scriptID, UUID storeID, string path)
+        [ScriptInvocation]
+        public int JsonGetArrayLength(UUID hostID, UUID scriptID, UUID storeID, string path)
+        {
+            return m_store.GetArrayLength(storeID,path);
+        }
+        
+        // -----------------------------------------------------------------
+        /// <summary>
+        /// 
+        /// </summary>
+        // -----------------------------------------------------------------
+        [ScriptInvocation]
+        public string JsonGetValue(UUID hostID, UUID scriptID, UUID storeID, string path)
         {
             string value = String.Empty;
             m_store.GetValue(storeID,path,false,out value);
             return value;
         }
 
-        protected string JsonGetValueJson(UUID hostID, UUID scriptID, UUID storeID, string path)
+        [ScriptInvocation]
+        public string JsonGetJson(UUID hostID, UUID scriptID, UUID storeID, string path)
         {
             string value = String.Empty;
             m_store.GetValue(storeID,path,true, out value);
@@ -331,80 +463,109 @@ namespace OpenSim.Region.OptionalModules.Scripting.JsonStore
         /// 
         /// </summary>
         // -----------------------------------------------------------------
-        protected UUID JsonTakeValue(UUID hostID, UUID scriptID, UUID storeID, string path)
+        [ScriptInvocation]
+        public UUID JsonTakeValue(UUID hostID, UUID scriptID, UUID storeID, string path)
         {
             UUID reqID = UUID.Random();
-            Util.FireAndForget(delegate(object o) { DoJsonTakeValue(scriptID,reqID,storeID,path,false); });
+            Util.FireAndForget(
+                o => DoJsonTakeValue(scriptID,reqID,storeID,path,false), null, "JsonStoreScriptModule.DoJsonTakeValue");
             return reqID;
         }
 
-        protected UUID JsonTakeValueJson(UUID hostID, UUID scriptID, UUID storeID, string path)
+        [ScriptInvocation]
+        public UUID JsonTakeValueJson(UUID hostID, UUID scriptID, UUID storeID, string path)
         {
             UUID reqID = UUID.Random();
-            Util.FireAndForget(delegate(object o) { DoJsonTakeValue(scriptID,reqID,storeID,path,true); });
+            Util.FireAndForget(
+                o => DoJsonTakeValue(scriptID,reqID,storeID,path,true), null, "JsonStoreScriptModule.DoJsonTakeValueJson");
             return reqID;
         }
         
-        private void DoJsonTakeValue(UUID scriptID, UUID reqID, UUID storeID, string path, bool useJson)
-        {
-            try
-            {
-                m_store.TakeValue(storeID,path,useJson,delegate(string value) { DispatchValue(scriptID,reqID,value); });
-                return;
-            }
-            catch (Exception e)
-            {
-                m_log.InfoFormat("[JsonStoreScripts] unable to retrieve value; {0}",e.ToString());
-            }
-            
-            DispatchValue(scriptID,reqID,String.Empty);
-        }
-
-
         // -----------------------------------------------------------------
         /// <summary>
         /// 
         /// </summary>
         // -----------------------------------------------------------------
-        protected UUID JsonReadValue(UUID hostID, UUID scriptID, UUID storeID, string path)
+        [ScriptInvocation]
+        public UUID JsonReadValue(UUID hostID, UUID scriptID, UUID storeID, string path)
         {
             UUID reqID = UUID.Random();
-            Util.FireAndForget(delegate(object o) { DoJsonReadValue(scriptID,reqID,storeID,path,false); });
+            Util.FireAndForget(
+                o => DoJsonReadValue(scriptID,reqID,storeID,path,false), null, "JsonStoreScriptModule.DoJsonReadValue");
             return reqID;
         }
 
-        protected UUID JsonReadValueJson(UUID hostID, UUID scriptID, UUID storeID, string path)
+        [ScriptInvocation]
+        public UUID JsonReadValueJson(UUID hostID, UUID scriptID, UUID storeID, string path)
         {
             UUID reqID = UUID.Random();
-            Util.FireAndForget(delegate(object o) { DoJsonReadValue(scriptID,reqID,storeID,path,true); });
+            Util.FireAndForget(
+                o => DoJsonReadValue(scriptID,reqID,storeID,path,true), null, "JsonStoreScriptModule.DoJsonReadValueJson");
             return reqID;
         }
         
-        private void DoJsonReadValue(UUID scriptID, UUID reqID, UUID storeID, string path, bool useJson)
+#endregion
+
+        // -----------------------------------------------------------------
+        /// <summary>
+        /// 
+        /// </summary>
+        // -----------------------------------------------------------------
+        protected void GenerateRuntimeError(string msg)
+        {
+            m_log.InfoFormat("[JsonStore] runtime error: {0}",msg);
+            throw new Exception("JsonStore Runtime Error: " + msg);
+        }
+        
+        // -----------------------------------------------------------------
+        /// <summary>
+        /// 
+        /// </summary>
+        // -----------------------------------------------------------------
+        protected void DispatchValue(UUID scriptID, UUID reqID, string value)
+        {
+            m_comms.DispatchReply(scriptID,1,value,reqID.ToString());
+        }
+
+        // -----------------------------------------------------------------
+        /// <summary>
+        /// 
+        /// </summary>
+        // -----------------------------------------------------------------
+        private void DoJsonTakeValue(UUID scriptID, UUID reqID, UUID storeID, string path, bool useJson)
         {
             try
             {
-                m_store.ReadValue(storeID,path,useJson,delegate(string value) { DispatchValue(scriptID,reqID,value); });
+                m_store.TakeValue(storeID,path,useJson,delegate(string value) { DispatchValue(scriptID,reqID,value); });
                 return;
             }
             catch (Exception e)
             {
-                m_log.InfoFormat("[JsonStoreScripts] unable to retrieve value; {0}",e.ToString());
+                m_log.InfoFormat("[JsonStoreScripts]: unable to retrieve value; {0}",e.ToString());
             }
             
             DispatchValue(scriptID,reqID,String.Empty);
         }
 
-#endregion
 
         // -----------------------------------------------------------------
         /// <summary>
         /// 
         /// </summary>
         // -----------------------------------------------------------------
-        protected void DispatchValue(UUID scriptID, UUID reqID, string value)
+        private void DoJsonReadValue(UUID scriptID, UUID reqID, UUID storeID, string path, bool useJson)
         {
-            m_comms.DispatchReply(scriptID,1,value,reqID.ToString());
+            try
+            {
+                m_store.ReadValue(storeID,path,useJson,delegate(string value) { DispatchValue(scriptID,reqID,value); });
+                return;
+            }
+            catch (Exception e)
+            {
+                m_log.InfoFormat("[JsonStoreScripts]: unable to retrieve value; {0}",e.ToString());
+            }
+            
+            DispatchValue(scriptID,reqID,String.Empty);
         }
 
         // -----------------------------------------------------------------
@@ -412,31 +573,44 @@ namespace OpenSim.Region.OptionalModules.Scripting.JsonStore
         /// 
         /// </summary>
         // -----------------------------------------------------------------
-        private void DoJsonReadNotecard(UUID reqID, UUID hostID, UUID scriptID, UUID storeID, string path, UUID assetID)
+        private void DoJsonReadNotecard(
+            UUID reqID, UUID hostID, UUID scriptID, UUID storeID, string path, string notecardIdentifier)
         {
+            UUID assetID;
+
+            if (!UUID.TryParse(notecardIdentifier, out assetID))
+            {
+                SceneObjectPart part = m_scene.GetSceneObjectPart(hostID);               
+                assetID = ScriptUtils.GetAssetIdFromItemName(part, notecardIdentifier, (int)AssetType.Notecard);
+            }
+
             AssetBase a = m_scene.AssetService.Get(assetID.ToString());
             if (a == null)
-                GenerateRuntimeError(String.Format("Unable to find notecard asset {0}",assetID));
+                GenerateRuntimeError(String.Format("Unable to find notecard asset {0}", assetID));
 
             if (a.Type != (sbyte)AssetType.Notecard)
-                GenerateRuntimeError(String.Format("Invalid notecard asset {0}",assetID));
+                GenerateRuntimeError(String.Format("Invalid notecard asset {0}", assetID));
             
-            m_log.DebugFormat("[JsonStoreScripts] read notecard in context {0}",storeID);
+            m_log.DebugFormat("[JsonStoreScripts]: read notecard in context {0}",storeID);
 
             try 
             {
-                string jsondata = SLUtil.ParseNotecardToString(Encoding.UTF8.GetString(a.Data));
+                string jsondata = SLUtil.ParseNotecardToString(a.Data);
                 int result = m_store.SetValue(storeID, path, jsondata,true) ? 1 : 0;
-                m_comms.DispatchReply(scriptID,result, "", reqID.ToString());
+                m_comms.DispatchReply(scriptID, result, "", reqID.ToString());
                 return;
             }
+            catch(SLUtil.NotANotecardFormatException e)
+            {
+                m_log.WarnFormat("[JsonStoreScripts]: Notecard parsing failed; assetId {0} at line number {1}", assetID.ToString(), e.lineNumber);
+            }
             catch (Exception e)
             {
-                m_log.WarnFormat("[JsonStoreScripts] Json parsing failed; {0}",e.Message);
+                m_log.WarnFormat("[JsonStoreScripts]: Json parsing failed; {0}", e.Message);
             }
 
-            GenerateRuntimeError(String.Format("Json parsing failed for {0}",assetID.ToString()));
-            m_comms.DispatchReply(scriptID,0,"",reqID.ToString());
+            GenerateRuntimeError(String.Format("Json parsing failed for {0}", assetID));
+            m_comms.DispatchReply(scriptID, 0, "", reqID.ToString());
         }
             
         // -----------------------------------------------------------------
@@ -494,5 +668,141 @@ namespace OpenSim.Region.OptionalModules.Scripting.JsonStore
 
             m_comms.DispatchReply(scriptID,1,assetID.ToString(),reqID.ToString());
         }
+
+        // -----------------------------------------------------------------
+        /// <summary>
+        /// Convert a list of values that are path components to a single string path
+        /// </summary>
+        // -----------------------------------------------------------------
+        protected static Regex m_ArrayPattern = new Regex("^([0-9]+|\\+)$");
+        private string ConvertList2Path(object[] pathlist)
+        {
+            string path = "";
+            for (int i = 0; i < pathlist.Length; i++)
+            {
+                string token = "";
+                
+                if (pathlist[i] is string)
+                {
+                    token = pathlist[i].ToString();
+
+                    // Check to see if this is a bare number which would not be a valid
+                    // identifier otherwise
+                    if (m_ArrayPattern.IsMatch(token))
+                        token = '[' + token + ']';
+                }
+                else if (pathlist[i] is int)
+                {
+                    token = "[" + pathlist[i].ToString() + "]";
+                }
+                else
+                {
+                    token = "." + pathlist[i].ToString() + ".";
+                }
+                
+                path += token + ".";
+            }
+            
+            return path;
+        }
+        
+        // -----------------------------------------------------------------
+        /// <summary>
+        /// 
+        /// </summary>
+        // -----------------------------------------------------------------
+        private void DoJsonRezObject(UUID hostID, UUID scriptID, UUID reqID, string name, Vector3 pos, Vector3 vel, Quaternion rot, string param)
+        {
+            if (Double.IsNaN(rot.X) || Double.IsNaN(rot.Y) || Double.IsNaN(rot.Z) || Double.IsNaN(rot.W))
+            {
+                GenerateRuntimeError("Invalid rez rotation");
+                return;
+            }
+
+            SceneObjectGroup host = m_scene.GetSceneObjectGroup(hostID);
+            if (host == null)
+            {
+                GenerateRuntimeError(String.Format("Unable to find rezzing host '{0}'",hostID));
+                return;
+            }
+
+            // hpos = host.RootPart.GetWorldPosition()
+            // float dist = (float)llVecDist(hpos, pos);
+            // if (dist > m_ScriptDistanceFactor * 10.0f)
+            //     return;
+
+            TaskInventoryItem item = host.RootPart.Inventory.GetInventoryItem(name);
+            if (item == null)
+            {
+                GenerateRuntimeError(String.Format("Unable to find object to rez '{0}'",name));
+                return;
+            }
+
+            if (item.InvType != (int)InventoryType.Object)
+            {
+                GenerateRuntimeError("Can't create requested object; object is missing from database");
+                return;
+            }
+
+            List<SceneObjectGroup> objlist;
+            List<Vector3> veclist;
+            
+            bool success = host.RootPart.Inventory.GetRezReadySceneObjects(item, out objlist, out veclist);
+            if (! success)
+            {
+                GenerateRuntimeError("Failed to create object");
+                return;
+            }
+
+            int totalPrims = 0;
+            foreach (SceneObjectGroup group in objlist)
+                totalPrims += group.PrimCount;
+
+            if (! m_scene.Permissions.CanRezObject(totalPrims, item.OwnerID, pos))
+            {
+                GenerateRuntimeError("Not allowed to create the object");
+                return;
+            }
+
+            if (! m_scene.Permissions.BypassPermissions())
+            {
+                if ((item.CurrentPermissions & (uint)PermissionMask.Copy) == 0)
+                    host.RootPart.Inventory.RemoveInventoryItem(item.ItemID);
+            }
+
+            for (int i = 0; i < objlist.Count; i++)
+            {
+                SceneObjectGroup group = objlist[i];
+                Vector3 curpos = pos + veclist[i];
+
+                if (group.IsAttachment == false && group.RootPart.Shape.State != 0)
+                {
+                    group.RootPart.AttachedPos = group.AbsolutePosition;
+                    group.RootPart.Shape.LastAttachPoint = (byte)group.AttachmentPoint;
+                }
+
+                group.FromPartID = host.RootPart.UUID;
+                m_scene.AddNewSceneObject(group, true, curpos, rot, vel);
+
+                UUID storeID = group.UUID;
+                if (! m_store.CreateStore(param, ref storeID))
+                {
+                    GenerateRuntimeError("Unable to create jsonstore for new object");
+                    continue;
+                }
+
+                // We can only call this after adding the scene object, since the scene object references the scene
+                // to find out if scripts should be activated at all.
+                group.RootPart.SetDieAtEdge(true);
+                group.CreateScriptInstances(0, true, m_scene.DefaultScriptEngine, 3);
+                group.ResumeScripts();
+
+                group.ScheduleGroupForFullUpdate();
+
+                // send the reply back to the host object, use the integer param to indicate the number 
+                // of remaining objects
+                m_comms.DispatchReply(scriptID, objlist.Count-i-1, group.RootPart.UUID.ToString(), reqID.ToString());
+            }
+        }
     }
 }