def rrun(): reactor.removeAll() port = random.randrange(8000, 8100) print "Listening: %s" % port resource = File('web') factory = Site(resource) reactor.callLater(25, rrun) reactor.listenTCP(port, factory)
def stop(s, nargs): s.logger.info("[*] Player %s stopped the server." % s.display_name) s.factory.send_chat("Stopping..") s.close("Server have been stopped.") reactor.removeAll() reactor.iterate() reactor.stop() os._exit(0)
def tearDown(self): yield self.client.remove('test', CF) yield self.client.remove('test2', CF) yield self.client.remove('test', SCF) yield self.client.remove('test2', SCF) self.cmanager.shutdown() for c in reactor.getDelayedCalls(): c.cancel() reactor.removeAll()
def process(self): #self.reason = " (" + "".join(self.cmdobj['args_raw'][-1:]) + ")" #self.osc = self.cmdobj['scope'] #chat(self.osc, "\u00A7o\u00A78[" + self.osc.username + ": Stopping the server" + self.reason + "]\u00A7r", 1) #for plindex in self.osc.eobj_byid: # kick(self.osc.eobj_byid[plindex], "\u00A7cThe server was shut down" + self.reason + ".\u00A7r") #sleep(1) print("Mineserver (INFO/warn)> The server is shutting down from /stop command signal.") reactor.removeAll() reactor.iterate() reactor.stop()
def stop(self, *args): """ Called when the DSLink is going to stop. Override this if you start any threads you need to stop. Be sure to call the super function. :param args: Signal arguments. """ if self.wsp is not None: reactor.callFromThread(self.wsp.sendClose) reactor.removeAll() reactor.iterate() reactor.stop()
def checkReactor(self, phase, *_): has_network_selectables = False for item in reactor.getReaders() + reactor.getWriters(): if isinstance(item, HTTPChannel) or isinstance(item, Client): has_network_selectables = True break if has_network_selectables: # TODO(Martijn): we wait a while before we continue the check since network selectables # might take some time to cleanup. I'm not sure what's causing this. yield deferLater(reactor, 0.2, lambda: None) # This is the same check as in the _cleanReactor method of Twisted's Trial selectable_strings = [] for sel in reactor.removeAll(): if interfaces.IProcessTransport.providedBy(sel): self._logger.error("Sending kill signal to %s", repr(sel)) sel.signalProcess('KILL') selectable_strings.append(repr(sel)) self.assertFalse(selectable_strings, "The reactor has leftover readers/writers during %s: %r" % (phase, selectable_strings)) # Check whether we have closed all the sockets open_readers = reactor.getReaders() for reader in open_readers: self.assertNotIsInstance(reader, BasePort) # Check whether the threadpool is clean tp_items = len(reactor.getThreadPool().working) if tp_items > 0: # Print all stacks to debug this issue self.watchdog.print_all_stacks() self.assertEqual(tp_items, 0, "Still items left in the threadpool")
def cleanReactor(cls): """ Remove all delayed calls, readers and writers from the reactor. """ if not reactor: return try: reactor.removeAll() except (RuntimeError, KeyError): # FIXME:863: # When running threads the reactor is cleaned from multiple places # and removeAll will fail since it detects that internal state # is changed from other source. pass reactor.threadCallQueue = [] for delayed_call in reactor.getDelayedCalls(): if delayed_call.active(): delayed_call.cancel()
def _cleanSelectables(self): """Remove all selectables and return their string representation. Kill any of them that were processes. """ for sel in reactor.removeAll(): if interfaces.IProcessTransport.providedBy(sel): sel.signalProcess("KILL") yield sel
def _cleanReactor(self): """ Remove all selectables from the reactor, kill any of them that were processes, and return their string representation. """ reactor = self._getReactor() selectableStrings = [] for sel in reactor.removeAll(): if interfaces.IProcessTransport.providedBy(sel): sel.signalProcess('KILL') selectableStrings.append(repr(sel)) return selectableStrings
def do_cleanReactor(cls): s = [] from twisted.internet import reactor removedSelectables = reactor.removeAll() if removedSelectables: s.append(DIRTY_REACTOR_MSG) for sel in removedSelectables: if interfaces.IProcessTransport.providedBy(sel): sel.signalProcess('KILL') s.append(repr(sel)) if s: raise DirtyReactorError(' '.join(s))
def cleanup_reactor(force=False): log.debug('comptest', 'running cleanup_reactor...') delayed = reactor.getDelayedCalls() for dc in delayed: dc.cancel() # the rest is taken from twisted trial... sels = reactor.removeAll() if sels: log.info('comptest', 'leftover selectables...: %r %r' % (sels, reactor.waker)) for sel in sels: if interfaces.IProcessTransport.providedBy(sel): sel.signalProcess('KILL')
def command(player, command, args): if command == 'stop': player.kick_all('Server stopped') plugin.log(player.username + ' has stopped server') time.sleep(1) from twisted.internet import reactor reactor.removeAll() reactor.iterate() reactor.stop() if command == 'tp': if len(args) == 3: x, y, z = args[0], args[1], args[2] player.set_position(x, y, z) player.send_chat('Teleported to X:%s Y:%s Z:%s' % (str(x), str(y), str(z))) else: player.send_chat('Need 3 args: x,y,z') if command == 'item' or command == 'give': if len(args) == 3: id, count, slot = int(args[0]), int(args[1]), int(args[2]) player.send_set_slot(id, count, slot) else: player.send_chat('3 args need') if command == 'help': player.send_chat( '/tp [x, y, z]\n/stop\n/title line1 line2 2\n/give id count slot') if command == 'title': if len(args) == 3: player.send_title(args[0], args[1], 25, int(args[2]) * 25, 25) else: player.send_chat('3 args need') if command == 'brodcast' or command == 'bc': if len(args) == 0: player.send_chat('Enter your message') else: player.send_chat_all(''.join(args))
def handler(player, command, args): if command == "stop": player.send_chat("Server stopping... You will be kicked in two seconds") time.sleep(2) plugin.log(player.nickname + " has stopped the server!") from twisted.internet import reactor # Import reactor and call stop methods reactor.removeAll() reactor.iterate() reactor.stop() if command == "tppos": # If command called with 3 arguments if len(args) == 3: # Set player position try: x, y, z = [float(arg) for arg in args] # Convert strings to floats player.set_position(x, y, z) player.send_chat("Teleported to X:{0} Y:{1} Z:{2} successfully".format(x, y, z)) except ValueError: # If we can't convert it player.send_chat("You need to supply numbers!") else: player.send_chat("tppos takes 3 arguments: x,y,z") if command == "help": # TODO: Make something useful here player.send_chat("There's nothing here, sorry :(")
def checkReactor(self, phase, *_): delayed_calls = reactor.getDelayedCalls() if delayed_calls: self._logger.error("The reactor was dirty during %s:", phase) for dc in delayed_calls: self._logger.error("> %s", dc) dc.cancel() from pony.orm.core import local if local.db_context_counter > 0: self._logger.error("Leftover pony db sessions found!") from pony.orm import db_session for _ in range(local.db_context_counter): db_session.__exit__() has_network_selectables = False for item in reactor.getReaders() + reactor.getWriters(): if isinstance(item, HTTPChannel) or isinstance(item, Client): has_network_selectables = True break if has_network_selectables: # TODO(Martijn): we wait a while before we continue the check since network selectables # might take some time to cleanup. I'm not sure what's causing this. yield deferLater(reactor, 0.2, lambda: None) # This is the same check as in the _cleanReactor method of Twisted's Trial selectable_strings = [] for sel in reactor.removeAll(): if interfaces.IProcessTransport.providedBy(sel): self._logger.error("Sending kill signal to %s", repr(sel)) sel.signalProcess('KILL') selectable_strings.append(repr(sel)) self.assertFalse(selectable_strings, "The reactor has leftover readers/writers during %s: %r" % (phase, selectable_strings)) # Check whether we have closed all the sockets open_readers = reactor.getReaders() for reader in open_readers: self.assertNotIsInstance(reader, BasePort) # Check whether the threadpool is clean tp_items = len(reactor.getThreadPool().working) if tp_items > 0: # Print all stacks to debug this issue self.watchdog.print_all_stacks() self.assertEqual(tp_items, 0, "Still items left in the threadpool")
def clean_reactor(): reactor.removeAll()
def signal_handler(signal, frame): print 'Terminating...' reactor.removeAll() reactor.stop()
def _done(self): print 'in _done' os.system('killall -9 node') reactor.removeAll() reactor.stop()
def tearDown(self): """Cleanup method after each ``test_*`` method runs; removes all selectable readers and writers from the reactor. """ reactor.removeAll()
def tearDown(self): yield self.client.system_drop_keyspace(self.my_keyspace.name) self.cmanager.shutdown() for c in reactor.getDelayedCalls(): c.cancel() reactor.removeAll()
def _cleanSelectables(self): reactor.removeAll()
def main(): reactor.disconnectAll() log.warning("Ethereum Stratum proxy version: %s" % version.VERSION) # Connect to Stratum pool, main monitoring connection log.warning("Trying to connect to Stratum pool at %s:%d" % (mainpool, mainport)) f = SocketTransportClientFactory(mainpool, mainport, debug=settings.DEBUG, proxy=None, event_handler=client_service.ClientMiningService) f1 = None f2 = None f3 = None if settings.POOL_FAILOVER_ENABLE: if not (backuppool1 is None): log.warning("Trying to connect to failover Stratum pool-1 at %s:%d" % (backuppool1, backupport1)) f1 = SocketTransportClientFactory(backuppool1, backupport1, debug=settings.DEBUG, proxy=None, event_handler=client_service.ClientMiningService) f1.is_failover = True if not (backuppool2 is None): log.warning("Trying to connect to failover Stratum pool-2 at %s:%d" % (backuppool2, backupport2)) f2 = SocketTransportClientFactory(backuppool2, backupport2, debug=settings.DEBUG, proxy=None, event_handler=client_service.ClientMiningService) f2.is_failover = True if not (backuppool3 is None): log.warning("Trying to connect to failover Stratum pool-3 at %s:%d" % (backuppool3, backupport3)) f3 = SocketTransportClientFactory(backuppool3, backupport3, debug=settings.DEBUG, proxy=None, event_handler=client_service.ClientMiningService) f3.is_failover = True job_registry = jobs.JobRegistry(f,f1,f2,f3) client_service.ClientMiningService.job_registry = job_registry client_service.ClientMiningService.reset_timeout() f.on_connect.addCallback(on_connect) f.on_disconnect.addCallback(on_disconnect) # Cleanup properly on shutdown reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f) if f1: f1.on_connect.addCallback(on_connect) f1.on_disconnect.addCallback(on_disconnect) reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f1) if f2: f2.on_connect.addCallback(on_connect) f2.on_disconnect.addCallback(on_disconnect) reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f2) if f3: f3.on_connect.addCallback(on_connect) f3.on_disconnect.addCallback(on_disconnect) reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f3) # Block until proxy connect to the pool try: yield f.on_connect except TransportException: log.error("First pool server must be online during proxy startup. Dying Gracefully.") reactor.stop() reactor.removeAll() return if len(proxywallet)!=42 and len(proxywallet)!=40: conn = reactor.listenTCP(settings.PORT, Site(getwork_listener.Root(job_registry, False)), interface=settings.HOST) else: conn = reactor.listenTCP(settings.PORT, Site(getwork_listener.Root(job_registry, settings.ENABLE_WORKER_ID)), interface=settings.HOST) try: conn.socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1) # Enable keepalive packets conn.socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPIDLE, 60) # Seconds before sending keepalive probes conn.socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPINTVL, 1) # Interval in seconds between keepalive probes conn.socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPCNT, 5) # Failed keepalive probles before declaring other end dead except: pass # Some socket features are not available on all platforms (you can guess which one) log.warning("-----------------------------------------------------------------------") if settings.HOST == '0.0.0.0': log.warning("PROXY IS LISTENING ON ALL IPs ON PORT %d" % settings.PORT) else: log.warning("LISTENING FOR MINERS ON http://%s:%d" % (settings.HOST, settings.PORT)) log.warning("-----------------------------------------------------------------------") log.warning("Wallet: %s" % proxywallet) if len(proxywallet)!=42 and len(proxywallet)!=40: log.warning("Wallet is not 40/42 Characters in Length, WORKER ID DISABLED") log.warning("OK if using non-eth address based pool authentication") log.warning("Otherwise - BAD ETH WALLET") else: log.warning("Worker ID enabled: %s" % settings.ENABLE_WORKER_ID) if settings.MONITORING: log.warning("Email monitoring on %s" % settings.MONITORING_EMAIL) else: log.warning("Email monitoring disabled") log.warning("Failover enabled: %s" % settings.POOL_FAILOVER_ENABLE) log.warning("-----------------------------------------------------------------------")
def rrun(servers): print "\n\nRestaring listeners." reactor.removeAll() for server in servers: server.spinUp() reactor.callLater(20, rrun, servers)
def handle_signal(signal, frame): print('SIGINT received, stop') reactor.removeAll() reactor.stop()
def tearDown(self): del self.channel_layer reactor.removeAll() super(TwistedTests, self).tearDown()
def tearDown(self): reactor.removeAll() super(RabbitmqChannelLayerTwistedTest, self).tearDown()
def tearDown(self): os.environ.pop("SENTRY_DSN", None) reactor.removeAll()
def tearDown(self): reactor.removeAll() return self.port.stopListening()
def main(): reactor.disconnectAll() log.warning("Ethereum Stratum proxy version: %s" % version.VERSION) # Connect to Stratum pool, main monitoring connection log.warning("Trying to connect to Stratum pool at %s:%d" % (mainpool, mainport)) f = SocketTransportClientFactory( mainpool, mainport, debug=settings.DEBUG, proxy=None, event_handler=client_service.ClientMiningService) f1 = None f2 = None f3 = None if settings.POOL_FAILOVER_ENABLE: if not (backuppool1 is None): log.warning( "Trying to connect to failover Stratum pool-1 at %s:%d" % (backuppool1, backupport1)) f1 = SocketTransportClientFactory( backuppool1, backupport1, debug=settings.DEBUG, proxy=None, event_handler=client_service.ClientMiningService) f1.is_failover = True if not (backuppool2 is None): log.warning( "Trying to connect to failover Stratum pool-2 at %s:%d" % (backuppool2, backupport2)) f2 = SocketTransportClientFactory( backuppool2, backupport2, debug=settings.DEBUG, proxy=None, event_handler=client_service.ClientMiningService) f2.is_failover = True if not (backuppool3 is None): log.warning( "Trying to connect to failover Stratum pool-3 at %s:%d" % (backuppool3, backupport3)) f3 = SocketTransportClientFactory( backuppool3, backupport3, debug=settings.DEBUG, proxy=None, event_handler=client_service.ClientMiningService) f3.is_failover = True job_registry = jobs.JobRegistry(f, f1, f2, f3) client_service.ClientMiningService.job_registry = job_registry client_service.ClientMiningService.reset_timeout() f.on_connect.addCallback(on_connect) f.on_disconnect.addCallback(on_disconnect) # Cleanup properly on shutdown reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f) if f1: f1.on_connect.addCallback(on_connect) f1.on_disconnect.addCallback(on_disconnect) reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f1) if f2: f2.on_connect.addCallback(on_connect) f2.on_disconnect.addCallback(on_disconnect) reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f2) if f3: f3.on_connect.addCallback(on_connect) f3.on_disconnect.addCallback(on_disconnect) reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f3) # Block until proxy connect to the pool try: yield f.on_connect except TransportException: log.error( "First pool server must be online during proxy startup. Dying Gracefully." ) reactor.stop() reactor.removeAll() return if len(proxywallet) != 42 and len(proxywallet) != 40: conn = reactor.listenTCP( settings.PORT, Site(getwork_listener.Root(job_registry, False)), interface=settings.HOST) else: conn = reactor.listenTCP( settings.PORT, Site(getwork_listener.Root(job_registry, settings.ENABLE_WORKER_ID)), interface=settings.HOST) try: conn.socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1) # Enable keepalive packets conn.socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPIDLE, 60) # Seconds before sending keepalive probes conn.socket.setsockopt( socket.SOL_TCP, socket.TCP_KEEPINTVL, 1) # Interval in seconds between keepalive probes conn.socket.setsockopt( socket.SOL_TCP, socket.TCP_KEEPCNT, 5) # Failed keepalive probles before declaring other end dead except: pass # Some socket features are not available on all platforms (you can guess which one) log.warning( "-----------------------------------------------------------------------" ) if settings.HOST == '0.0.0.0': log.warning("PROXY IS LISTENING ON ALL IPs ON PORT %d" % settings.PORT) else: log.warning("LISTENING FOR MINERS ON http://%s:%d" % (settings.HOST, settings.PORT)) log.warning( "-----------------------------------------------------------------------" ) log.warning("Wallet: %s" % proxywallet) if len(proxywallet) != 42 and len(proxywallet) != 40: log.warning( "Wallet is not 40/42 Characters in Length, WORKER ID DISABLED") log.warning("OK if using non-eth address based pool authentication") log.warning("Otherwise - BAD ETH WALLET") else: log.warning("Worker ID enabled: %s" % settings.ENABLE_WORKER_ID) if settings.MONITORING: log.warning("Email monitoring on %s" % settings.MONITORING_EMAIL) else: log.warning("Email monitoring disabled") log.warning("Failover enabled: %s" % settings.POOL_FAILOVER_ENABLE) log.warning( "-----------------------------------------------------------------------" )
def ctrl_c_handler(signum, *args): reactor.removeAll() reactor.iterate() reactor.stop() return
def command_stop(self, ctx, *args): ctx.server.logger.info("Server close by " + ctx.player.display_name) reactor.removeAll() reactor.iterate() reactor.stop()
def tearDown(self): reactor.removeAll() deferredResult(self.server.stopListening())
def signal_handler(signal, frame): print 'You pressed Ctrl+C!' reactor.removeAll() reactor.iterate() reactor.stop()
def rrun(factory): reactor.removeAll() port = random.randrange(500, 599) print "Listening @ %s" % port reactor.listenTCP(port, factory) reactor.callLater(10, rrun, factory)
def stop_server(): reactor.removeAll()
def exit(): reactor.removeAll() reactor.iterate() reactor.stop()
def stop(self): self.alive = 0 reactor.removeAll() reactor.iterate() reactor.stop()
def stop(self): reactor.removeAll() reactor.stop() self._running = False