def disconnect_connection(self): try: global listen_video_ref if listen_video_ref != None: reactor.disconnectAll() listen_video_ref = None App.get_running_app().mainForm.stop_sloop_send_hello_videoref() App.get_running_app().mainForm.display_result_grid() App.get_running_app().mainForm.console_writer("WARNING", "La comunicacion con el videoref se ha cerrado correctamente.") else: App.get_running_app().mainForm.console_writer("WARNING", "No se ha iniciado una comunicacion con el videoref.") except: App.get_running_app().mainForm.console_writer("ERROR", "Los puertos de comunicacion con el videoref " + "no se han podido cerrar correctamente" + ", datos del error:\n" + str(sys.exc_info()[0]))
def signal_handler(signal, frame): print 'You pressed Ctrl+C' # As per here: # http://www.tornadoweb.org/documentation/twisted.html reactor.fireSystemEvent('shutdown') reactor.disconnectAll() sys.exit(0)
def restart(self): reactor.disconnectAll() import sys import os argv = [sys.executable] argv.extend(sys.argv) os.execv(sys.executable, argv)
def restart(self): reactor.disconnectAll() import sys import os argv = [ sys.executable ] argv.extend(sys.argv) os.execv(sys.executable, argv)
def tearDown(self): if self.client: self.client.disconnect() self.listeningPort.stopListening reactor.disconnectAll() for p in reactor.getDelayedCalls(): p.cancel()
def tearDown(self): """Kill all connections with fire.""" if self.transport: self.transport.loseConnection() super(EmailServerServiceTests, self).tearDown() # FIXME: this is definitely not how we're supposed to do this, but it # kills the DirtyReactorAggregateErrors. reactor.disconnectAll() reactor.runUntilCurrent()
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" % (settings.POOL_HOST, settings.POOL_PORT)) f = SocketTransportClientFactory(settings.POOL_HOST, settings.POOL_PORT, debug=settings.DEBUG, proxy=None, event_handler=client_service.ClientMiningService)
def signal_handler(signal_number, frame): global d d.cancel() print(os.getpid()) #signal.signal(signal.SIGINT, signal_handler) #signal.signal(signal.SIGTERM, process_quit) reactor.disconnectAll() process_quit(signal_number, frame)
def close_reactor(): try: reactor.disconnectAll() except: pass try: reactor.stop() except: pass cleanup()
def handleConnectionLost(connector, reason): protocolDebug(u'client_twisted client_twisted handleConnectionLost:', str(connector), reason.getErrorMessage()) try: if frame.taskBar: frame.taskBar.Destroy() frame.taskBar = None #pylint: disable=W0702 except: pass #pylint: disable=E1101 reactor.disconnectAll()
def process_quit(signal_number, frame): try: reactor.disconnectAll() except: pass try: reactor.stop() except: pass cleanup()
def clientConnectionLost(self, connector, reason): protocolDebug( u'client_twisted client_twisted Lost connection. Reason:', reason.getErrorMessage()) try: self.deferred.callback(reason) except: pass if frame.taskBar: frame.taskBar.Destroy() frame.taskBar=None reactor.disconnectAll() reactor.stop()
def main(): reactor.disconnectAll() failover = False if settings.POOL_FAILOVER_ENABLE: failover = settings.failover_pool settings.failover_pool = not settings.failover_pool pool_host = settings.POOL_HOST pool_port = settings.POOL_PORT if failover and settings.POOL_FAILOVER_ENABLE: pool_host = settings.POOL_HOST_FAILOVER pool_port = settings.POOL_PORT_FAILOVER log.warning("Monero Stratum proxy version: %s" % version.VERSION) log.warning("Trying to connect to Stratum pool at %s:%d" % (pool_host, pool_port)) # Connect to Stratum pool, main monitoring connection f = SocketTransportClientFactory(pool_host, pool_port, debug=settings.DEBUG, proxy=None, event_handler=client_service.ClientMiningService) job_registry = jobs.JobRegistry(f) 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) # Block until proxy connect to the pool try: yield f.on_connect except TransportException: log.warning("First pool server must be online first time to start failover") return # Setup stratum listener stratum_listener.StratumProxyService._set_upstream_factory(f) stratum_listener.StratumProxyService._set_custom_user(settings.CUSTOM_USER, settings.CUSTOM_PASSWORD, settings.ENABLE_WORKER_ID, settings.WORKER_ID_FROM_IP) reactor.listenTCP(settings.STRATUM_PORT, SocketTransportFactory(debug=settings.DEBUG, event_handler=ServiceEventHandler), interface=settings.STRATUM_HOST) # Setup multicast responder reactor.listenMulticast(3333, multicast_responder.MulticastResponder((pool_host, pool_port), settings.STRATUM_PORT), listenMultiple=True) log.warning("-----------------------------------------------------------------------") if settings.STRATUM_HOST == '0.0.0.0': log.warning("PROXY IS LISTENING ON ALL IPs ON PORT %d (stratum)" % settings.STRATUM_PORT) else: log.warning("LISTENING FOR MINERS ON stratum+tcp://%s:%d (stratum)" % \ (settings.STRATUM_HOST, settings.STRATUM_PORT)) log.warning("-----------------------------------------------------------------------")
def restart(self): self.children.killall() reactor.disconnectAll() if self.display and hasattr(self.display, "underware") and self.display.underware: self.display.underware.Uninit() import sys import os if platform.system() == "Windows": os.execv("pok3d.exe", ["pok3d.exe", "--restart"]) else: argv = [ sys.executable ] argv.extend(sys.argv) os.execv(sys.executable, argv)
def stopServer(self): ''' #停止服务''' if self.connect != None: self.ui.startServer_pushButton.setEnabled(True) self.ui.stopServer_pushButton.setEnabled(False) self.ui.mysql_groupBox.setDisabled(False) self.ui.text_groupBox.setDisabled(False) self.ui.xml_groupBox.setDisabled(False) #pylint: disable=E1101 reactor.disconnectAll() # self.clearUserInfo() self.statusBar().showMessage("server is stopped!") uiDebug("stopServer")
def testTearDown(self): # Clean ZopeReactor zr = getUtility(IZopeReactor) for dc in zr.reactor.getDelayedCalls(): if not dc.cancelled: dc.cancel() zr.stop() wait_for_reactor_state(zr.reactor, state=False) #Clean normal reactor for the twisted unit tests. from twisted.internet import reactor reactor.disconnectAll() for dc in reactor.getDelayedCalls(): if not dc.cancelled: dc.cancel()
def restart(self): self.children.killall() reactor.disconnectAll() if self.display and hasattr(self.display, "underware") and self.display.underware: self.display.underware.Uninit() import sys import os if platform.system() == "Windows": os.execv("pok3d.exe", ["pok3d.exe", "--restart"]) else: argv = [sys.executable] argv.extend(sys.argv) os.execv(sys.executable, argv)
def upgradeReady(self, target_dir, upgrades_dir): if self.verbose >= 0: self.message("PokerClientFactory::upgradeReady") self.children.killall() reactor.disconnectAll() if hasattr(self.display, "underware"): self.display.underware.Uninit() import sys import os if platform.system() == "Windows": os.execv(upgrades_dir + "/upgrade.exe", [ upgrades_dir + "/upgrade.exe", '"' + target_dir + '"', '"' + sys.executable + '"' ]) else: # FIXME: shouldn't this be an .in file and use @SHELL@ here? os.execv("/bin/sh", [ upgrades_dir + "/upgrade", '-x', upgrades_dir + "/upgrade", upgrades_dir, sys.executable ] + sys.argv)
def tearDown(self): """Kill all connections with fire.""" if self.transport: if not hasattr(self.transport, 'protocol'): factory = server.addServer(self.config, self.dist) self.transport.protocol = factory.buildProtocol( ('127.0.0.1', 0)) self.transport.loseConnection() super(EmailServerServiceTests, self).tearDown() # FIXME: this is definitely not how we're supposed to do this, but it # kills the DirtyReactorAggregateErrors. reactor.disconnectAll() reactor.runUntilCurrent()
def OnTogglebutton_serverStopButton(self, evt): # Replace with event handler code uiDebug( "serverManagerUi OnTogglebutton_serverStopButton()") if self.serverStopButton.GetValue()==False: self.serverStopButton.SetValue(True) return self.mainStatusBar.SetLabel(" server is stopped") self.serverControlPanelString=" server is stopped" if self.connect!=None: reactor.disconnectAll() # reactor.removeAll() # reactor.stop() self.serverStartButton.SetValue(False)
def tearDown(self): """Cleanup method after each ``test_*`` method runs; removes timed out connections on the reactor and clears the :ivar:`transport`. Basically, kill all connections with fire. """ for delay in reactor.getDelayedCalls(): try: delay.cancel() except (AlreadyCalled, AlreadyCancelled): pass # FIXME: this is definitely not how we're supposed to do this, but it # kills the DirtyReactorAggregateErrors. reactor.disconnectAll() reactor.runUntilCurrent()
def _pools_connect(self): reactor.disconnectAll() config_xml = self.config.configuration pools = config_xml.getElementsByTagName("pool") for pool in pools: pool_name = pool.getAttribute("name") pool_coin = pool.getAttribute("coin") pool_host = pool.getAttribute("poolHost") pool_port = pool.getAttribute("poolPort") pool_api = pool.getAttribute("api") pool_user = pool.getElementsByTagName("user")[0] pool_user_wallet = pool_user.getAttribute("wallet") pool_user_password = pool_user.getAttribute("password") log.info("Запуск пула {} хост {}:{}".format(pool_name, pool_host, pool_port)) pool_factory = SocketTransportClientFactory(pool_host, int(pool_port), debug=True, proxy=None, event_handler=ProxyClientMiningService) job_registry = ProxyJobRegistry(pool_factory) ProxyClientMiningService.job_registry = job_registry ProxyClientMiningService.reset_timeout() pool_factory.on_connect.addCallback(on_connect) pool_factory.on_disconnect.addCallback(on_disconnect) # Cleanup properly on shutdown reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, pool_factory) # Block until proxy connect to the pool try: yield pool_factory.on_connect except TransportException: log.warning("First pool server must be online first time to start failover") return # Setup stratum listener ProxyStratumService._set_upstream_factory(pool_factory) ProxyStratumService._set_custom_user(pool_user_wallet, pool_user_password, True, True) reactor.listenTCP(5556, SocketTransportFactory(debug=True, event_handler=ServiceEventHandler), interface="0.0.0.0")
def tearDown(self): d = defer.DeferredList(( self.tearDownServer(), self.tearDownProxy() )) d.addCallback(self.destroyDb) d.addCallback(lambda x: reactor.disconnectAll()) return d
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 disconnect(self): self.send_message('r;') reactor.disconnectAll() self.conn = None
def onClose(self, wasClean, code, reason): print("WebSocket connection closed: {0}".format(reason)) reactor.disconnectAll() reactor.stop()
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" % (settings.POOL_HOST, settings.POOL_PORT)) f = SocketTransportClientFactory( settings.POOL_HOST, settings.POOL_PORT, debug=settings.DEBUG, proxy=None, event_handler=client_service.ClientMiningService) f1 = None f2 = None f3 = None if settings.POOL_FAILOVER_ENABLE: log.warning( "Trying to connect to failover Stratum pool-1 at %s:%d" % (settings.POOL_HOST_FAILOVER1, settings.POOL_PORT_FAILOVER1)) f1 = SocketTransportClientFactory( settings.POOL_HOST_FAILOVER1, settings.POOL_PORT_FAILOVER1, debug=settings.DEBUG, proxy=None, event_handler=client_service.ClientMiningService) f1.is_failover = True log.warning( "Trying to connect to failover Stratum pool-2 at %s:%d" % (settings.POOL_HOST_FAILOVER2, settings.POOL_PORT_FAILOVER2)) f2 = SocketTransportClientFactory( settings.POOL_HOST_FAILOVER2, settings.POOL_PORT_FAILOVER2, debug=settings.DEBUG, proxy=None, event_handler=client_service.ClientMiningService) f2.is_failover = True log.warning( "Trying to connect to failover Stratum pool-3 at %s:%d" % (settings.POOL_HOST_FAILOVER3, settings.POOL_PORT_FAILOVER3)) f3 = SocketTransportClientFactory( settings.POOL_HOST_FAILOVER3, settings.POOL_PORT_FAILOVER3, 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.warning("First pool server must be online first time during start") return 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" % settings.WALLET) 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 tearDown(self): """ Stop MySQL before each test """ reactor.disconnectAll()
def tearDown(self): d = defer.DeferredList((self.tearDownServer(), self.tearDownProxy())) d.addCallback(self.destroyDb) d.addCallback(lambda x: reactor.disconnectAll()) return d
def DisconnectAll(): reactor.disconnectAll()
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 clientConnectionFailed(self, connector, reason): print("connection failed: {}".format(reason)) reactor.fireSystemEvent('shutdown') reactor.disconnectAll() tornado.ioloop.IOLoop.instance().stop()
def stop(self): """disconnect from the jabber server""" reactor.disconnectAll() self.connected = False reactor.stop()
def _reconnect(self): """ Disconnect the current reactor to try to connect again """ log.info("No data received in %ss: Trying to reconnect" % KEEPALIVED_TIMEOUT) reactor.disconnectAll()
def doClose(self): if self.taskBar: self.taskBar.Destroy() self.taskBar=None reactor.disconnectAll() reactor.stop()
def going_away(registry, user, instruction, match): reactor.fireSystemEvent('shutdown') reactor.disconnectAll() tornado.ioloop.IOLoop.instance().stop() return {'success': True, 'answer': "So long and thanks for all the fish."}
def tearDown(self): d = self.tearDownServer() d.addCallback(self.destroyDb) d.addCallback(lambda x: reactor.disconnectAll()) return d
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" % (settings.POOL_HOST, settings.POOL_PORT)) f = SocketTransportClientFactory(settings.POOL_HOST, settings.POOL_PORT, debug=settings.DEBUG, proxy=None, event_handler=client_service.ClientMiningService) f.is_failover = False ff = None if settings.POOL_FAILOVER_ENABLE: log.warning("Trying to connect to failover Stratum pool at %s:%d" % (settings.POOL_HOST_FAILOVER, settings.POOL_PORT_FAILOVER)) ff = SocketTransportClientFactory(settings.POOL_HOST_FAILOVER, settings.POOL_PORT_FAILOVER, debug=settings.DEBUG, proxy=None, event_handler=client_service.ClientMiningService) ff.is_failover = True job_registry = jobs.JobRegistry(f,ff) 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 ff: ff.on_connect.addCallback(on_connect) ff.on_disconnect.addCallback(on_disconnect) reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, ff) # Block until proxy connect to the pool try: yield f.on_connect except TransportException: log.warning("First pool server must be online first time during start") return 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" % settings.WALLET) 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("-----------------------------------------------------------------------")
import tornado.ioloop import tornado.web import tornado.platform.twisted tornado.platform.twisted.install() from twisted.internet import reactor from internals.commandRegistry import CommandRegistry from connectors import irc, jabber from commands import shutdown, deploy if __name__ == "__main__": import config reg = CommandRegistry.getRegistry() if reg.websinks: application = tornado.web.Application(reg.websinks) p = getattr(config, 'webport', 8808) application.listen(p) try: print "Starting loop" tornado.ioloop.IOLoop.instance().start() except: print "Stopping loop ... shutdown" reactor.fireSystemEvent('shutdown') print "Disconnect all" reactor.disconnectAll() print "Actual stop" tornado.ioloop.IOLoop.instance().stop() print "Stopped"
def main(): reactor.disconnectAll() failover = False if settings.POOL_FAILOVER_ENABLE: failover = settings.failover_pool settings.failover_pool = not settings.failover_pool pool_host = settings.POOL_HOST pool_port = settings.POOL_PORT if failover and settings.POOL_FAILOVER_ENABLE: pool_host = settings.POOL_HOST_FAILOVER pool_port = settings.POOL_PORT_FAILOVER log.warning("Monero Stratum proxy versao: %s" % version.VERSION) log.warning("Tentando se conectar a Stratum pool as %s:%d" % (pool_host, pool_port)) # Connect to Stratum pool, main monitoring connection f = SocketTransportClientFactory( pool_host, pool_port, debug=settings.DEBUG, proxy=None, event_handler=client_service.ClientMiningService) job_registry = jobs.JobRegistry(f) 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) # Block until proxy connect to the pool try: yield f.on_connect except TransportException: log.warning( "O Pool Primaria deve estar conectada pela primeira vez para iniciar o failover" ) return # Setup stratum listener stratum_listener.StratumProxyService._set_upstream_factory(f) stratum_listener.StratumProxyService._set_custom_user( settings.CUSTOM_USER, settings.CUSTOM_PASSWORD, settings.ENABLE_WORKER_ID, settings.WORKER_ID_FROM_IP) reactor.listenTCP(settings.STRATUM_PORT, SocketTransportFactory( debug=settings.DEBUG, event_handler=ServiceEventHandler), interface=settings.STRATUM_HOST) # Setup multicast responder reactor.listenMulticast(3333, multicast_responder.MulticastResponder( (pool_host, pool_port), settings.STRATUM_PORT), listenMultiple=True) log.warning( "-----------------------------------------------------------------------" ) if settings.STRATUM_HOST == '0.0.0.0': log.warning("PROXY esta escutando todos os IPS na porta %d (stratum)" % settings.STRATUM_PORT) else: log.warning("esperando pelos mineiros/rigs em stratum+tcp://%s:%d (stratum)" % \ (settings.STRATUM_HOST, settings.STRATUM_PORT)) log.warning( "-----------------------------------------------------------------------" )