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 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 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 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 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 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 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 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 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 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 clientConnectionFailed(self, connector, reason):
print("connection failed: {}".format(reason))
reactor.fireSystemEvent('shutdown')
reactor.disconnectAll()
tornado.ioloop.IOLoop.instance().stop()
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 tearDown(self):
"""
Stop MySQL before each test
"""
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" % (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("-----------------------------------------------------------------------")
def stop(self):
"""disconnect from the jabber server"""
reactor.disconnectAll()
self.connected = False
reactor.stop()
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 tearDown(self):
d = self.tearDownServer()
d.addCallback(self.destroyDb)
d.addCallback(lambda x: reactor.disconnectAll())
return d
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(
"-----------------------------------------------------------------------"
)
