def removeTrigger(self, trigger):
     """
     Remove a trigger by its handle from the reactor and from
     C{self.triggers}.
     """
     reactor.removeSystemEventTrigger(trigger)
     self.triggers.remove(trigger)

 def shutdown(self):
     """Shutdown the worker thread.
     """
     self._q.put(self.SHUTDOWN)
     if self._shutdownTriggerId is not None:
         reactor.removeSystemEventTrigger(self._shutdownTriggerId)
         self._shutdownTriggerId = None

 def processEnded(self, status_object):
     if self.shutdown_trigger:
         reactor.removeSystemEventTrigger(self.shutdown_trigger)
         self.shutdown_trigger = None
     self.deferred.callback(status_object.value.exitCode)
     for d in self.shutdown_deferreds:
         d.callback(status_object.value.exitCode)

 def shutdown(self):
     self.shutting_down = True
     try:
         reactor.removeSystemEventTrigger(self.shutdown_trigger)
     except ValueError:
         pass # We may have been called automatically at shutdown.
     if self.proc:
         self.proc.signalProcess("INT")

 def shutdown(self):
     """Manually stop the pool.  This is only necessary from tests, as the
     pool will stop itself when the reactor stops under normal
     circumstances."""
     if not self._stop_evt:
         return # pool is already stopped
     reactor.removeSystemEventTrigger(self._stop_evt)
     self._stop()

 def close(self):
     """Close all pool connections and shutdown the pool"""
     if self.shutdownID:
         reactor.removeSystemEventTrigger(self.shutdownID)
         self.shutdownID = None
     if self.startID:
         reactor.removeSystemEventTrigger(self.startID)
         self.startID = None
     self.finalClose()

 def clean_up(failure):
     if self.missing_timer is not None:
         self.missing_timer.cancel()
         self._substantiation_failed(failure)
     if self._shutdown_callback_handle is not None:
         handle = self._shutdown_callback_handle
         del self._shutdown_callback_handle
         reactor.removeSystemEventTrigger(handle)
     return failure

 def insubstantiate(self, fast=False):
     self._clearBuildWaitTimer()
     d = self.stop_instance(fast)
     if self._shutdown_callback_handle is not None:
         handle = self._shutdown_callback_handle
         del self._shutdown_callback_handle
         reactor.removeSystemEventTrigger(handle)
     self.substantiated = False
     self.building.clear() # just to be sure
     return d

 def tearDown(self):
     """
     Remove all remaining triggers from the reactor.
     """
     while self.triggers:
         trigger = self.triggers.pop()
         try:
             reactor.removeSystemEventTrigger(trigger)
         except (ValueError, KeyError):
             pass

	def __init__(self, dbapiName, *connargs, **connkw):
		"""
		Create a new instance of the connection pool.
		
		This overridden constructor makes sure the Twisted reactor
		doesn't get started in non-twisted.web-hosted environments.
		"""
		TimeoutConnectionPool.__init__(self, dbapiName, *connargs, **connkw)
		from twisted.internet import reactor
		if(self.startID):
			reactor.removeSystemEventTrigger(self.startID)

 def _cleanThreads(self):
     reactor = self._getReactor()
     if interfaces.IReactorThreads.providedBy(reactor):
         reactor.suggestThreadPoolSize(0)
         if getattr(reactor, "threadpool", None) is not None:
             try:
                 reactor.removeSystemEventTrigger(reactor.threadpoolShutdownID)
             except KeyError:
                 pass
             # Remove the threadpool, and let the reactor put it back again
             # later like a good boy
             reactor._stopThreadPool()

    def stop(self):
        log.msg("IRCBotPlugin stopping...")
        if self.shutdown_trigger is not None:
            reactor.removeSystemEventTrigger(self.shutdown_trigger)
        self.stopTrying()
        if self.client:
            log.msg("Sending quit message")
            self.client.quit("Daisy, daisy...")

        # The server should disconnect us after a QUIT command, but just in
        # case, terminate the connection after 5 seconds.
        reactor.callLater(5, self.connector.disconnect)

 def insubstantiate(self, fast=False):
     self.insubstantiating = True
     self._clearBuildWaitTimer()
     d = self.stop_instance(fast)
     if self._shutdown_callback_handle is not None:
         handle = self._shutdown_callback_handle
         del self._shutdown_callback_handle
         reactor.removeSystemEventTrigger(handle)
     self.substantiated = False
     self.building.clear()  # just to be sure
     yield d
     self.insubstantiating = False
     self.botmaster.maybeStartBuildsForWorker(self.name)

 def unmapRTP(self):
     from xshtoom.nat import getMapper
     if self.needSTUN is False:
         return defer.succeed(None)
     # Currently removing an already-fired trigger doesn't hurt,
     # but this seems likely to change.
     try:
         reactor.removeSystemEventTrigger(self._shutdownHook)
     except:
         pass
     d = getMapper()
     d.addCallback(self._cb_unmap_gotMapper)
     return d

 def _stopServer(self, *ignored):
     self.stopping = True
     try:
         yield self._dispatch(self.stopServer)
     except Exception as e:
         self._error = failure.Failure(e)
     finally:
         try:
             self._cxn.disconnect()
         except Exception:
             pass
         # remove the event trigger, so we don't get
         # called again if the reactor shuts down later
         if hasattr(self, '_shutdownID'):
             reactor.removeSystemEventTrigger(self._shutdownID)

 def shutdown( self ):
     
     logger.debug( "Cleaning up before shutdown." )
     
     if self.shutdown_trigger_id is not None:        
         reactor.removeSystemEventTrigger( self.shutdown_trigger_id )
     
     deferreds = []
     
     if self.site is not None:
         logger.debug( "Stopping listening on main HTTP interface." )
         d = self.site_port.stopListening()
         if isinstance(d, Deferred):
             deferreds.append( d )
     
     if self.web_admin_site is not None:
         logger.debug( "Stopping listening on web admin interface." )
         d = self.web_admin_site_port.stopListening()
         if isinstance(d, Deferred):
             deferreds.append( d )
             
     if self.coordinateloop is not None:
         logger.debug( "Stopping coordinating loop." )
         d = self.coordinateloop.stop()
         if isinstance(d, Deferred):
             deferreds.append( d )
             
     if self.queryloop is not None:
         logger.debug( "Stopping query loop." )
         d = self.queryloop.stop()
         if isinstance(d, Deferred):
             deferreds.append( d )
             
     if self.aws_sdb_coordination_domain is not None:
         logger.debug( "Removing data from SDB coordination domain." )
         d = self.sdb.delete( self.aws_sdb_coordination_domain, self.uuid )
         d.addCallback(self._cleanupBeforeShutdown)
         d.addCallback(self.peerCheckRequest)
         deferreds.append( d )
     
     if len( deferreds ) > 0:
         logger.debug( "Combinining deferred shutdown processes." )
         d = DeferredList( deferreds )
         d.addCallback( self._shutdownCallback )
         return d
     else:
         logger.debug( "No deferred processes." )
         return self._shutdownCallback( None )

 def cleanup(self):
     """
     Cleans up the reactor stuff.
     @rtype: L{twisted.defer.DeferredList}
     """
     log.info("_cleanup the Master")
     deferreds = []
     reactor.removeSystemEventTrigger(self._shutdown_event_id)
     # quit all slaves
     for command in self.get_all_commands():
         if command.slave_state == STATE_RUNNING:
             deferreds.append(command.quit_slave())
     # stop the master's loop
     if self._looping_call.running:
         d = self._looping_call.deferred
         self._looping_call.stop() # FIXME
         deferreds.append(d)
     return defer.DeferredList(deferreds)

 def _cancelCleanup(self, result, call_id):
     reactor.removeSystemEventTrigger(call_id)
     return result

 def shutdown(self):
     """End the pending webclient calls."""
     self.running = False
     # pylint: disable=E1101
     reactor.removeSystemEventTrigger(self.trigger_id)

 def tearDown(self):
     for t in self.triggers:
         try:
             reactor.removeSystemEventTrigger(t)
         except:
             pass