//internal Dictionary<int, IScriptScheduler> ScriptMapping = new Dictionary<int, IScriptScheduler>();


        //
        // HANDLE EVENTS FROM SCRIPTS
        // We will handle script add, change and remove events outside of command pipeline
        //
        #region Script Add/Change/Remove
        void Events_RezScript(uint localID, UUID itemID, string script, int startParam, bool postOnRez, string engine)
        {
            // ###
            // # New script created
            // ###
            m_log.DebugFormat(
                "[{0}] NEW SCRIPT: localID: {1}, itemID: {2}, startParam: {3}, postOnRez: {4}, engine: {5}",
                Name, localID, itemID, startParam, postOnRez, engine);

            // Make a script object
            ScriptStructure scriptObject = new ScriptStructure();
            scriptObject.RegionInfo = RegionInfo;
            scriptObject.LocalID = localID;
            scriptObject.ItemID = itemID;
            scriptObject.Source = script;

            //
            // Get MetaData from script header
            //
            ScriptMetaData scriptMetaData = ScriptMetaData.Extract(ref script);
            scriptObject.ScriptMetaData = scriptMetaData;
            foreach (string key in scriptObject.ScriptMetaData.Keys)
            {
                m_log.DebugFormat("[{0}] Script metadata: Key: \"{1}\", Value: \"{2}\".", Name, key, scriptObject.ScriptMetaData[key]);
            }

            //
            // Load this assembly
            //
            // TODO: Use Executor to send a command instead?
            m_log.DebugFormat("[{0}] Adding script to scheduler", Name);
            RegionInfo.FindScheduler(scriptObject.ScriptMetaData).AddScript(scriptObject);
            // Add to our internal mapping
            //ScriptMapping.Add(itemID, Schedulers[scheduler]);
        }
예제 #2
0
 public void Executors_Execute(ScriptStructure scriptContainer, EventParams p)
 {
     // Execute a command on all executors
     lock (Executors)
     {
         foreach (IScriptExecutor exec in Executors.Values)
         {
             exec.ExecuteCommand(ref scriptContainer, p);
         }
     }
 }
예제 #3
0
 public void Executors_Execute(ScriptStructure scriptContainer, EventParams p)
 {
     // Execute a command on all executors
     lock (Executors)
     {
         foreach (IScriptExecutor exec in Executors.Values)
         {
             exec.ExecuteCommand(ref scriptContainer, p);
         }
     }
 }
        //private Dictionary<InstanceData, DetectParams[]> detparms = new Dictionary<InstanceData, DetectParams[]>();

        // Load/Unload structure


        public void AddScript(ScriptStructure script)
        {
            lock (LUQueue)
            {
                if ((LUQueue.Count >= LoadUnloadMaxQueueSize))
                {
                    m_log.ErrorFormat("[{0}] ERROR: Load queue count is at {1} of max {2}. Ignoring load request for script LocalID: {3}, ItemID: {4}.", 
                        Name, LUQueue.Count, LoadUnloadMaxQueueSize, script.LocalID, script.ItemID);
                    return;
                }

                LoadUnloadStructure ls = new LoadUnloadStructure();
                ls.Script = script;
                ls.Action = LoadUnloadStructure.LUType.Load;
                LUQueue.Enqueue(ls);
            }

        }
        public void _StopScript(uint localID, UUID itemID)
        {
            ScriptStructure ss = new ScriptStructure();
            if (!TryGetScript(localID, itemID, ref ss))
                return;

            m_log.DebugFormat("[{0}] Unloading script", Name);

            // Stop long command on script
            //AsyncCommandManager.RemoveScript(ss);

            try
            {
                // Get AppDomain
                // Tell script not to accept new requests
                ss.Running = false;
                ss.Disabled = true;
                //AppDomain ad = ss.AppDomain;

                // Remove from internal structure
                MemRemoveScript(localID, itemID);

                // TODO: Tell AppDomain that we have stopped script
                
            }
            catch (Exception e) // LEGIT: User Scripting
            {
                m_log.Error("[" +
                        Name +
                        "]: Exception stopping script localID: " +
                        localID + " LLUID: " + itemID.ToString() +
                        ": " + e.ToString());
            }
        }
예제 #6
0
        public static void MakeBaseClass(ScriptStructure script)
        {
            string asmName = "ScriptAssemblies";
            string ModuleID = asmName;
            string ClassID = "Script";
            string moveToDir = "ScriptEngines";
            string asmFileName = ModuleID + "_" + ClassID + ".dll";
            if (!Directory.Exists(moveToDir))
                Directory.CreateDirectory(moveToDir);

            ILGenerator ilgen;
            AssemblyBuilder asmBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
                new AssemblyName(asmName), AssemblyBuilderAccess.RunAndSave);

            // The module builder
            ModuleBuilder modBuilder = asmBuilder.DefineDynamicModule(ModuleID, asmFileName);

            // The class builder
            TypeBuilder classBuilder = modBuilder.DefineType(ClassID, TypeAttributes.Class | TypeAttributes.Public);

            // The default constructor
            //ConstructorBuilder ctorBuilder = classBuilder.DefineDefaultConstructor(MethodAttributes.Public);


            Type[] paramsTypeArray = new Type[] {typeof (System.ParamArrayAttribute)};
            Type[] executeFunctionTypeArray = new Type[] {typeof (string), typeof (System.ParamArrayAttribute)};
            foreach (IScriptCommandProvider cp in script.RegionInfo.CommandProviders.Values)
            {
                Type t = cp.GetType();
                foreach (MethodInfo mi in t.GetMethods())
                {
                    MethodBuilder methodBuilder = classBuilder.DefineMethod(mi.Name, mi.Attributes, mi.GetType(), Type.EmptyTypes);
                    methodBuilder.SetParameters(paramsTypeArray);
                    //ParameterBuilder paramBuilder = methodBuilder.DefineParameter(1, ParameterAttributes.None, "args");
                    
                    ilgen = methodBuilder.GetILGenerator();
                    //ilgen.Emit(OpCodes.Nop);
                    //ilgen.Emit(OpCodes.Ldarg_0);
                    //ilgen.Emit(OpCodes.Ldc_I4_0);
                    //ilgen.Emit(OpCodes.Ldelem_Ref);
                    //ilgen.MarkSequencePoint(doc, 6, 1, 6, 100);

                        //MethodInfo ExecuteFunction = typeof(ScriptAssemblies.IScript).GetMethod(
                        // "ExecuteFunction",
                        // executeFunctionTypeArray);

                        ilgen.DeclareLocal(typeof(string));
                        ilgen.Emit(OpCodes.Nop);
                    ilgen.Emit(OpCodes.Ldstr, mi.Name);
                    ilgen.Emit(OpCodes.Stloc_0);
                    ilgen.Emit(OpCodes.Ldarg_0);
                    ilgen.Emit(OpCodes.Ldloc_0);
                    ilgen.Emit(OpCodes.Ldarg_1);

    //                FieldInfo testInfo = classBuilder.
    //BindingFlags.NonPublic | BindingFlags.Instance);

                    //ilgen.Emit(OpCodes.Ldfld, testInfo);

                    //ilgen.EmitCall(OpCodes.Call, ExecuteFunction, executeFunctionTypeArray);
                    ilgen.EmitCall(OpCodes.Call, typeof(System.Console).GetMethod("WriteLine"), executeFunctionTypeArray);

                //    // string.Format("Hello, {0} World!", toWhom)
                //    //
                //    ilgen.Emit(OpCodes.Ldstr, "Hello, {0} World!");
                //    ilgen.Emit(OpCodes.Ldarg_1);
                //    ilgen.Emit(OpCodes.Call, typeof(string).GetMethod
                //("Format", new Type[] { typeof(string), typeof(object) }));

                //    // m_log.Debug("Hello, World!");
                //    //
                //    ilgen.Emit(OpCodes.Call, typeof(Console).GetMethod
                //    ("WriteLine", new Type[] { typeof(string) }));
                    ilgen.Emit(OpCodes.Ret);

                    

                    //Label eom = ilgen.DefineLabel();
                    //ilgen.Emit(OpCodes.Br_S, eom);
                    //ilgen.MarkLabel(eom);
                    //ilgen.Emit(OpCodes.Ret);
                    //Type test = methodBuilder.SetParameters();


                    //methodBuilder.SetParameters(typeof (object[]));

                    
                }
            }


            //// Two fields: m_firstname, m_lastname
            //FieldBuilder fBuilderFirstName = classBuilder.DefineField("m_firstname", typeof(string), FieldAttributes.Private);
            //FieldBuilder fBuilderLastName = classBuilder.DefineField("m_lastname", typeof(string), FieldAttributes.Private);

            //// Two properties for this object: FirstName, LastName
            //PropertyBuilder pBuilderFirstName = classBuilder.DefineProperty("FirstName", System.Reflection.PropertyAttributes.HasDefault, typeof(string), null);
            //PropertyBuilder pBuilderLastName = classBuilder.DefineProperty("LastName", System.Reflection.PropertyAttributes.HasDefault, typeof(string), null);

            //// Custom attributes for get, set accessors
            //MethodAttributes getSetAttr = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName;

            //// get,set accessors for FirstName
            //MethodBuilder mGetFirstNameBuilder = classBuilder.DefineMethod("get_FirstName", getSetAttr, typeof(string), Type.EmptyTypes);

            //// Code generation
            //ilgen = mGetFirstNameBuilder.GetILGenerator();
            //ilgen.Emit(OpCodes.Ldarg_0);
            //ilgen.Emit(OpCodes.Ldfld, fBuilderFirstName); // returning the firstname field
            //ilgen.Emit(OpCodes.Ret);

            //MethodBuilder mSetFirstNameBuilder = classBuilder.DefineMethod("set_FirstName", getSetAttr, null, new Type[] { typeof(string) });

            //// Code generation
            //ilgen = mSetFirstNameBuilder.GetILGenerator();
            //ilgen.Emit(OpCodes.Ldarg_0);
            //ilgen.Emit(OpCodes.Ldarg_1);
            //ilgen.Emit(OpCodes.Stfld, fBuilderFirstName); // setting the firstname field from the first argument (1)
            //ilgen.Emit(OpCodes.Ret);

            //// get,set accessors for LastName
            //MethodBuilder mGetLastNameBuilder = classBuilder.DefineMethod("get_LastName", getSetAttr, typeof(string), Type.EmptyTypes);

            //// Code generation
            //ilgen = mGetLastNameBuilder.GetILGenerator();
            //ilgen.Emit(OpCodes.Ldarg_0);
            //ilgen.Emit(OpCodes.Ldfld, fBuilderLastName); // returning the firstname field
            //ilgen.Emit(OpCodes.Ret);

            //MethodBuilder mSetLastNameBuilder = classBuilder.DefineMethod("set_LastName", getSetAttr, null, new Type[] { typeof(string) });

            //// Code generation
            //ilgen = mSetLastNameBuilder.GetILGenerator();
            //ilgen.Emit(OpCodes.Ldarg_0);
            //ilgen.Emit(OpCodes.Ldarg_1);
            //ilgen.Emit(OpCodes.Stfld, fBuilderLastName); // setting the firstname field from the first argument (1)
            //ilgen.Emit(OpCodes.Ret);

            //// Assigning get/set accessors
            //pBuilderFirstName.SetGetMethod(mGetFirstNameBuilder);
            //pBuilderFirstName.SetSetMethod(mSetFirstNameBuilder);

            //pBuilderLastName.SetGetMethod(mGetLastNameBuilder);
            //pBuilderLastName.SetSetMethod(mSetLastNameBuilder);

            //// Now, a custom method named GetFullName that concatenates FirstName and LastName properties
            //MethodBuilder mGetFullNameBuilder = classBuilder.DefineMethod("GetFullName", MethodAttributes.Public, typeof(string), Type.EmptyTypes);

            //// Code generation
            //ilgen = mGetFullNameBuilder.GetILGenerator();
            //ilgen.Emit(OpCodes.Ldarg_0);
            //ilgen.Emit(OpCodes.Call, mGetFirstNameBuilder); // getting the firstname
            //ilgen.Emit(OpCodes.Ldstr, " "); // an space
            //ilgen.Emit(OpCodes.Ldarg_0);
            //ilgen.Emit(OpCodes.Call, mGetLastNameBuilder); // getting the lastname

            //// We need the 'Concat' method from string type
            //MethodInfo concatMethod = typeof(String).GetMethod("Concat", new Type[] { typeof(string), typeof(string), typeof(string) });

            //ilgen.Emit(OpCodes.Call, concatMethod); // calling concat and returning the result
            //ilgen.Emit(OpCodes.Ret);

            //// Another constructor that initializes firstname and lastname
            //ConstructorBuilder ctorBuilder2 = classBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { typeof(string), typeof(string) });
            //ctorBuilder2.DefineParameter(1, ParameterAttributes.In, "firstname");
            //ctorBuilder2.DefineParameter(2, ParameterAttributes.In, "lastname");

            //// Code generation
            //ilgen = ctorBuilder2.GetILGenerator();

            //// First of all, we need to call the base constructor, 
            //// the Object's constructor in this sample
            //Type objType = Type.GetType("System.Object");
            //ConstructorInfo objCtor = objType.GetConstructor(Type.EmptyTypes);

            //ilgen.Emit(OpCodes.Ldarg_0);
            //ilgen.Emit(OpCodes.Call, objCtor); // calling the Object's constructor

            //ilgen.Emit(OpCodes.Ldarg_0);
            //ilgen.Emit(OpCodes.Ldarg_1);
            //ilgen.Emit(OpCodes.Call, mSetFirstNameBuilder); // setting the firstname field from the first argument (1)
            //ilgen.Emit(OpCodes.Ldarg_0);
            //ilgen.Emit(OpCodes.Ldarg_2);
            //ilgen.Emit(OpCodes.Call, mSetLastNameBuilder);  // setting the lastname field from the second argument (2)
            //ilgen.Emit(OpCodes.Ret);

            // Finally, create the type and save the assembly
            classBuilder.CreateType();

            asmBuilder.Save(asmFileName);
            string toFile = Path.Combine(moveToDir, asmFileName);
            if (File.Exists(toFile))
                File.Delete(toFile);
            File.Move(asmFileName, toFile);

            //string a = "";
        }
예제 #7
0
        private void MemAddScript(ScriptStructure script)
        {
            lock (scriptLock)
            {
                // Create object if it doesn't exist
                if (!Scripts.ContainsKey(script.LocalID))
                    Scripts.Add(script.LocalID, new Dictionary<UUID, ScriptStructure>());

                // Delete script if it exists
                Dictionary<UUID, ScriptStructure> Obj;
                if (Scripts.TryGetValue(script.LocalID, out Obj))
                    if (Obj.ContainsKey(script.ItemID) == true)
                        Obj.Remove(script.ItemID);

                // Add to object
                Obj.Add(script.ItemID, script);
            }
        }
예제 #8
0
 public void ExecuteCommand(ref ScriptStructure scriptContainer, EventParams p)
 {
     m_log.DebugFormat("[{0}] ######################################################", Name);
     m_log.DebugFormat("[{0}] Command execution ItemID {1}: \"{2}\".", Name, scriptContainer.ItemID, p.EventName);
     scriptContainer.ExecuteEvent(p);
     m_log.DebugFormat("[{0}] ######################################################", Name);
 }
예제 #9
0
 public void ExecuteCommand(EventParams p)
 {
     ScriptStructure ss = new ScriptStructure();
     if (TryGetScript(p.LocalID, p.ItemID, ref ss))
         ExecuteCommand(ref ss, p);
 }
예제 #10
0
        public bool TryGetScript(uint localID, UUID itemID, ref ScriptStructure script)
        {
            lock (scriptLock)
            {

                if (Scripts.ContainsKey(localID) == false)
                    return false;

                Dictionary<UUID, ScriptStructure> Obj;
                if (Scripts.TryGetValue(localID, out Obj))
                    if (Obj.ContainsKey(itemID) == false)
                        return false;

                // Get script
                return Obj.TryGetValue(itemID, out script);
            }
        }
예제 #11
0
파일: Scheduler.cs 프로젝트: ChrisD/opensim
 public void AddScript(ScriptStructure scriptStructure)
 {
     m_ScriptManager.AddScript(scriptStructure);
 }
예제 #12
0
        public ScriptAssemblies.IScript LoadScript(ScriptStructure script)
        {
            // Find next available AppDomain to put it in
            AppDomainStructure FreeAppDomain;

            // If we already have loaded file, then reuse that AppDomains
            if (AppDomainFiles.ContainsKey(script.AssemblyFileName))
                FreeAppDomain = AppDomainFiles[script.AssemblyFileName];
            else
                FreeAppDomain = GetFreeAppDomain();

            // Set script object AppDomain
            script.AppDomain = FreeAppDomain.CurrentAppDomain;

            // Create instance of script
            ScriptAssemblies.IScript mbrt = (ScriptAssemblies.IScript)               
                FreeAppDomain.CurrentAppDomain.CreateInstanceFromAndUnwrap(
                               script.AssemblyFileName, "ScriptAssemblies.Script");
            //, true, BindingFlags.CreateInstance, null);
            FreeAppDomain.ScriptsLoaded++;

            return mbrt;
        }