public void Clear()
 {
     foreach (BSConstraint cons in m_constraints)
     {
         m_constraints.Remove(cons);
         cons.Dispose();
     }
 }
        private void CheckLongPollThreads()
        {
            // The only purpose of this thread is to check the EQs for events.
            // If there are events, that thread will be placed in the "ready-to-serve" queue, m_requests.
            // If there are no events, that thread will be back to its "waiting" queue, m_longPollRequests.
            // All other types of tasks (Inventory handlers, http-in, etc) don't have the long-poll nature,
            // so if they aren't ready to be served by a worker thread (no events), they are placed
            // directly back in the "ready-to-serve" queue by the worker thread.
            while (IsRunning)
            {
                Thread.Sleep(500);
                Watchdog.UpdateThread();

//                List<PollServiceHttpRequest> not_ready = new List<PollServiceHttpRequest>();
                if (m_longPollRequests.Count > 0 && IsRunning)
                {
                    List <PollServiceHttpRequest> ready = m_longPollRequests.FindAll(req =>
                                                                                     (req.PollServiceArgs.HasEvents(req.RequestID, req.PollServiceArgs.Id) ||    // there are events in this EQ
                                                                                      (Environment.TickCount - req.RequestTime) > req.PollServiceArgs.TimeOutms) // no events, but timeout
                                                                                     );

                    ready.ForEach(req =>
                    {
                        m_requests.Enqueue(req);
                        m_longPollRequests.Remove(req);
                    });
                }
            }
        }
        public override void RemoveRegion(Scene scene)
        {
            if (!m_enabled)
            {
                return;
            }

            MainServer.Instance.RemoveXmlRPCHandler("concierge_update_welcome");

            // unsubscribe from NewClient events
            scene.EventManager.OnNewClient -= OnNewClient;

            // unsubscribe from *Chat events
            scene.EventManager.OnChatFromWorld -= OnChatFromWorld;
            if (!m_replacingChatModule)
            {
                scene.EventManager.OnChatFromClient -= OnChatFromClient;
            }
            scene.EventManager.OnChatBroadcast -= OnChatBroadcast;

            // unsubscribe from agent change events
            scene.EventManager.OnMakeRootAgent  -= OnMakeRootAgent;
            scene.EventManager.OnMakeChildAgent -= OnMakeChildAgent;

            m_scenes.Remove(scene);
            m_conciergedScenes.Remove(scene);

            m_log.InfoFormat("[Concierge]: removed {0}", scene.RegionInfo.RegionName);
        }
Esempio n. 4
0
 public void RemoveRegion(Scene scene)
 {
     if (m_Enabled)
     {
         scene.UnregisterModuleInterface <IImprovedAssetCache>(this);
         m_Scenes.Remove(scene);
     }
 }
 public void RemoveRegion(Scene scene)
 {
     if (m_Enabled)
     {
         scene.UnregisterModuleInterface <IUserManagement>(this);
         m_Scenes.Remove(scene);
     }
 }
        public void RemoveRegion(Scene scene)
        {
            if (!enabled)
            {
                return;
            }

            m_SceneList.Remove(scene);
        }
        public virtual void RemoveRegion(Scene scene)
        {
            if (!m_Enabled)
            {
                return;
            }

            m_Scenes.Remove(scene);
        }
Esempio n. 8
0
        public void RemoveRegion(Scene scene)
        {
            if (!m_enabled)
            {
                return;
            }

            m_scenes.Remove(scene);
        }
Esempio n. 9
0
        public void RemoveRegion(Scene scene)
        {
            if (!IsEnabled())
            {
                return;
            }

            scene.UnregisterModuleInterface <IXMLRPC>(this);
            m_scenes.Remove(scene);
        }
        public void RemoveRegion(Scene scene)
        {
            m_scenes.Remove(scene);
            if (m_scene == scene && m_scenes.Count > 0)
            {
                m_scene = m_scenes[0];
            }

            scene.EventManager.OnNewClient -= OnNewClient;
        }
Esempio n. 11
0
        public void RemoveRegion(Scene scene)
        {
            if (!m_Enabled)
            {
                return;
            }

            scene.UnregisterModuleInterface <ISearchModule>(this);
            m_Scenes.Remove(scene);
        }
Esempio n. 12
0
        public void RemoveRegion(Scene scene)
        {
            if (!m_Enabled)
            {
                return;
            }

            m_scenes.Remove(scene);
            scene.EventManager.OnNewClient -= OnNewClient;
            scene.EventManager.OnIncomingInstantMessage -= OnIncomingInstantMessage;
        }
Esempio n. 13
0
 public void UnSetSenseRepeaterEvents(uint m_localID, UUID m_itemID)
 {
     // Remove from timer
     foreach (SensorInfo ts in SenseRepeaters)
     {
         if (ts.localID == m_localID && ts.itemID == m_itemID)
         {
             SenseRepeaters.Remove(ts);
         }
     }
 }
Esempio n. 14
0
        public void RemoveRegion(Scene scene)
        {
            if (!m_Enabled)
            {
                return;
            }

            m_SceneList.Remove(scene);

            scene.EventManager.OnNewClient    -= OnNewClient;
            scene.EventManager.OnClientClosed -= OnClientClosed;
        }
        public void RemoveRegion(Scene scene)
        {
            if (!m_Enabled)
            {
                return;
            }

            m_Scenes.Remove(scene);

            scene.EventManager.OnNewClient -= OnNewClient;
            scene.EventManager.OnIncomingInstantMessage +=
                OnIncomingInstantMessage;

            scene.UnregisterModuleInterface <ICallingCardModule>(this);
        }
Esempio n. 16
0
        // Only close the connector if the dependency count is zero.

        public void Close()
        {
            m_log.InfoFormat("[IRC-Connector-{0}] Closing", idn);

            lock (msyncConnect)
            {
                if ((depends == 0) && Enabled)
                {
                    m_enabled = false;

                    if (Connected)
                    {
                        m_log.DebugFormat("[IRC-Connector-{0}] Closing interface", idn);

                        // Cleanup the IRC session

                        try
                        {
                            m_writer.WriteLine(String.Format("QUIT :{0} to {1} wormhole to {2} closing",
                                                             m_nick, m_ircChannel, m_server));
                            m_writer.Flush();
                        }
                        catch (Exception) { }


                        m_connected = false;

                        try { m_writer.Close(); }
                        catch (Exception) { }
                        try { m_reader.Close(); }
                        catch (Exception) { }
                        try { m_stream.Close(); }
                        catch (Exception) { }
                        try { m_tcp.Close(); }
                        catch (Exception) { }
                    }

                    m_connectors.Remove(this);
                }
            }

            m_log.InfoFormat("[IRC-Connector-{0}] Closed", idn);
        }
        private void OnMapNameRequestHandler(IClientAPI remoteClient, string mapName, uint flags)
        {
            try
            {
                m_Clients.Add(remoteClient.AgentId);
            }
            catch
            {
                return;
            }

            try
            {
                OnMapNameRequest(remoteClient, mapName, flags);
            }
            finally
            {
                m_Clients.Remove(remoteClient.AgentId);
            }
        }
        public bool Delete(string userID, string friendID)
        {
            List <FriendsData> lst = m_Data.FindAll(delegate(FriendsData fdata) { return(fdata.PrincipalID == userID.ToString()); });

            if (lst != null)
            {
                FriendsData friend = lst.Find(delegate(FriendsData fdata) { return(fdata.Friend == friendID); });
                if (friendID != null)
                {
//                    m_log.DebugFormat(
//                        "[NULL FRIENDS DATA]: Deleting friend {0} {1} for {2}",
//                        friend.Friend, friend.Data["Flags"], friend.PrincipalID);

                    m_Data.Remove(friend);
                    return(true);
                }
            }

            return(false);
        }
        public void RemoveRegion(Scene scene)
        {
            if (!Enabled)
            {
                return;
            }

            if (m_region == null)
            {
                return;
            }

            if (!String.IsNullOrEmpty(m_password))
            {
                MainServer.Instance.RemoveXmlRPCHandler("irc_admin");
            }

            m_region.Close();

            m_regions.Remove(m_region);
        }
Esempio n. 20
0
        public void RemovePrimFromOverMe(SceneObjectGroup obj)
        {
//            m_log.DebugFormat("[LAND OBJECT]: Removing scene object {0} {1} from over {2}", obj.Name, obj.LocalId, LandData.Name);

            primsOverMe.Remove(obj);
        }
        public void RemoveRegion(Scene scene)
        {
//            m_log.DebugFormat("[ATTACHMENTS COMMAND MODULE]: REGION {0} REMOVED", scene.RegionInfo.RegionName);

            m_scenes.Remove(scene);
        }
Esempio n. 22
0
 public void RemoveItem(UUID itemID)
 {
     m_ids.Remove(itemID);
     m_items.Remove(itemID);
 }
Esempio n. 23
0
 public void RemoveRegion(Scene scene)
 {
     scene.EventManager.OnNewClient -= OnNewClient;
     scene.EventManager.OnIncomingInstantMessage -= OnGridInstantMessage;
     m_Scenelist.Remove(scene);
 }
Esempio n. 24
0
 public void RemoveRegion(Scene scene)
 {
     m_regions.Remove(scene);
 }
 public void RemoveRegion(Scene scene)
 {
     m_scenes.Remove(scene);
     scene.EventManager.OnNewClient -= OnNewClient;
 }
Esempio n. 26
0
 public void RemoveRegion(Scene scene)
 {
     m_SceneList.Remove(scene);
 }
Esempio n. 27
0
 /// <summary>
 /// Removes a scene object from the coalescene
 /// </summary>
 /// <param name="sceneObjectId"></param>
 /// <returns>true if the object was there to be removed, false if not.</returns>
 public bool Remove(SceneObjectGroup obj)
 {
     return(m_memberObjects.Remove(obj));
 }