def GetworkProxy_main(cb):
log.info("Stratum proxy version %s Connecting to Pool..." % version.VERSION)
# Connect to Stratum pool
f = SocketTransportClientFactory(settings.HOSTNAME, settings.LISTEN_SOCKET_TRANSPORT,
debug=False, proxy=None, event_handler=client_service.ClientMiningService)
job_registry = jobs.JobRegistry(f, cmd='', no_midstate=settings.GW_DISABLE_MIDSTATE, real_target=settings.GW_SEND_REAL_TARGET)
client_service.ClientMiningService.job_registry = job_registry
client_service.ClientMiningService.reset_timeout()
workers = worker_registry.WorkerRegistry(f)
f.on_connect.addCallback(on_connect, workers, job_registry)
f.on_disconnect.addCallback(on_disconnect, workers, job_registry)
# Cleanup properly on shutdown
reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f)
# Block until proxy connects to the pool
yield f.on_connect
# Setup getwork listener
gw_site = Site(getwork_listener.Root(job_registry, workers,
stratum_host=settings.HOSTNAME, stratum_port=settings.LISTEN_SOCKET_TRANSPORT,
custom_lp=False, custom_stratum=False,
custom_user=False, custom_password=False
))
gw_site.noisy = False
reactor.listenTCP(settings.GW_PORT, gw_site, interface='0.0.0.0')
log.info("Getwork Proxy is online, Port: %d" % (settings.GW_PORT))
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 __init__(self, host, port, user, passw):
self.difficulty = 1
self.last_broadcast = None
self.use_set_extranonce = False
log.info("Connecting to Stratum pool at %s:%d" % (host, port))
self.host = host
self.port = int(port)
self._detect_set_extranonce()
self.job_registry = jobs.JobRegistry()
self.auth = (user, passw)
self.connected = defer.Deferred()
self.authorized = False
self.f = SocketTransportClientFactory(
host,
port,
debug=True,
event_handler=client_service.ClientMiningService)
self.f.on_connect.addCallbacks(self.on_connect, self.on_timeout)
self.f.on_disconnect.addCallback(self.on_disconnect)
def set_pool(self, host, port, user, passw, timeout=120):
self.log.warning(
"Trying to connect to Stratum pool at %s:%d" %
(host, port))
self.host = host
self.port = int(port)
self._detect_set_extranonce()
self.cservice = client_service.ClientMiningService
self.f = SocketTransportClientFactory(
host,
port,
debug=True,
event_handler=self.cservice)
self.jobreg = jobs.JobRegistry(self.f, scrypt_target=True)
self.cservice.job_registry = self.jobreg
self.cservice.use_dirty_ping = False
self.pool_timeout = timeout
self.cservice.reset_timeout()
self.cservice.auth = (user, passw)
self.sharestats = share_stats.ShareStats()
self.cservice.f = self.f
self.f.on_connect.addCallback(self.on_connect)
self.f.on_disconnect.addCallback(self.on_disconnect)
def main(args):
if args.pid_file:
fp = file(args.pid_file, 'w')
fp.write(str(os.getpid()))
fp.close()
if args.port != 3333:
'''User most likely provided host/port
for getwork interface. Let's try to detect
Stratum host/port of given getwork pool.'''
try:
new_host = (yield utils.detect_stratum(args.host, args.port))
except:
log.exception("Stratum host/port autodetection failed")
new_host = None
if new_host != None:
args.host = new_host[0]
args.port = new_host[1]
log.warning("Stratum proxy version: %s" % version.VERSION)
if args.tor:
log.warning("Configuring Tor connection")
args.proxy = '127.0.0.1:9050'
args.host = 'pool57wkuu5yuhzb.onion'
args.port = 3333
if args.proxy:
proxy = args.proxy.split(':')
if len(proxy) < 2:
proxy = (proxy, 9050)
else:
proxy = (proxy[0], int(proxy[1]))
log.warning("Using proxy %s:%d" % proxy)
else:
proxy = None
log.warning("Trying to connect to Stratum pool at %s:%d" %
(args.host, args.port))
# Connect to Stratum pool
f = SocketTransportClientFactory(
args.host,
args.port,
debug=args.verbose,
proxy=proxy,
event_handler=client_service.ClientMiningService)
job_registry = jobs.JobRegistry(f,
cmd=args.blocknotify_cmd,
no_midstate=args.no_midstate,
real_target=args.real_target)
client_service.ClientMiningService.job_registry = job_registry
client_service.ClientMiningService.reset_timeout()
workers = worker_registry.WorkerRegistry(f)
f.on_connect.addCallback(on_connect, workers, job_registry)
f.on_disconnect.addCallback(on_disconnect, workers, job_registry)
if args.test:
f.on_connect.addCallback(test_launcher, job_registry)
# Cleanup properly on shutdown
reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f)
# Block until proxy connect to the pool
yield f.on_connect
# Setup getwork listener
if args.getwork_port > 0:
reactor.listenTCP(args.getwork_port,
Site(
getwork_listener.Root(
job_registry,
workers,
stratum_host=args.stratum_host,
stratum_port=args.stratum_port,
custom_lp=args.custom_lp,
custom_stratum=args.custom_stratum,
custom_user=args.custom_user,
custom_password=args.custom_password)),
interface=args.getwork_host)
# Setup stratum listener
if args.stratum_port > 0:
stratum_listener.StratumProxyService._set_upstream_factory(f)
reactor.listenTCP(
args.stratum_port,
SocketTransportFactory(debug=False,
event_handler=ServiceEventHandler))
# Setup multicast responder
reactor.listenMulticast(3333,
multicast_responder.MulticastResponder(
(args.host, args.port), args.stratum_port,
args.getwork_port),
listenMultiple=True)
log.warning(
"-----------------------------------------------------------------------"
)
if args.getwork_host == '0.0.0.0' and args.stratum_host == '0.0.0.0':
log.warning(
"PROXY IS LISTENING ON ALL IPs ON PORT %d (stratum) AND %d (getwork)"
% (args.stratum_port, args.getwork_port))
else:
log.warning("LISTENING FOR MINERS ON http://%s:%d (getwork) and stratum+tcp://%s:%d (stratum)" % \
(args.getwork_host, args.getwork_port, args.stratum_host, args.stratum_port))
log.warning(
"-----------------------------------------------------------------------"
)
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 main(args):
if args.pid_file:
fp = file(args.pid_file, 'w')
fp.write(str(os.getpid()))
fp.close()
if args.port != 3333:
'''User most likely provided host/port
for getwork interface. Let's try to detect
Stratum host/port of given getwork pool.'''
try:
new_host = (yield utils.detect_stratum(args.host, args.port))
except:
log.exception("Stratum host/port autodetection failed")
new_host = None
if new_host != None:
args.host = new_host[0]
args.port = new_host[1]
log.warning("Stratum proxy version: %s" % version.VERSION)
# Setup periodic checks for a new version
#test_update()
if args.tor:
log.warning("Configuring Tor connection")
args.proxy = '127.0.0.1:9050'
args.host = 'pool57wkuu5yuhzb.onion'
args.port = 3333
if args.proxy:
proxy = args.proxy.split(':')
if len(proxy) < 2:
proxy = (proxy, 9050)
else:
proxy = (proxy[0], int(proxy[1]))
log.warning("Using proxy %s:%d" % proxy)
else:
proxy = None
log.warning("Trying to connect to Stratum pool at %s:%d" %
(args.host, args.port))
# Connect to Stratum pool
f = SocketTransportClientFactory(
args.host,
args.port,
debug=args.verbose,
proxy=proxy,
event_handler=client_service.ClientMiningService)
job_registry = jobs.JobRegistry(f,
cmd=args.blocknotify_cmd,
scrypt_target=args.scrypt_target,
no_midstate=args.no_midstate,
real_target=args.real_target,
use_old_target=args.old_target)
client_service.ClientMiningService.job_registry = job_registry
client_service.ClientMiningService.reset_timeout()
workers = worker_registry.WorkerRegistry(f)
f.on_connect.addCallback(on_connect, workers, job_registry)
f.on_disconnect.addCallback(on_disconnect, workers, job_registry)
if args.test:
f.on_connect.addCallback(test_launcher, job_registry)
# Cleanup properly on shutdown
reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f)
# Block until proxy connect to the pool
yield f.on_connect
# Setup getwork listener
if args.getwork_port > 0:
conn = reactor.listenTCP(
args.getwork_port,
Site(
getwork_listener.Root(job_registry,
workers,
stratum_host=args.stratum_host,
stratum_port=args.stratum_port,
custom_lp=args.custom_lp,
custom_stratum=args.custom_stratum,
custom_user=args.custom_user,
custom_password=args.custom_password)),
interface=args.getwork_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)
# Setup stratum listener
#if args.stratum_port > 0:
# stratum_listener.StratumProxyService._set_upstream_factory(f)
# stratum_listener.StratumProxyService._set_custom_user(args.custom_user, args.custom_password)
# reactor.listenTCP(args.stratum_port, SocketTransportFactory(debug=False, event_handler=ServiceEventHandler), interface=args.stratum_host)
# Setup multicast responder
#reactor.listenMulticast(3333, multicast_responder.MulticastResponder((args.host, args.port), args.stratum_port, args.getwork_port), listenMultiple=True)
log.warning(
"-----------------------------------------------------------------------"
)
if args.getwork_host == '0.0.0.0':
log.warning("PROXY IS LISTENING ON ALL IPs ON PORT %d (getwork)" %
args.getwork_port)
else:
log.warning("LISTENING FOR MINERS ON http://%s:%d (getwork) " % \
(args.getwork_host, args.getwork_port))
log.warning(
"-----------------------------------------------------------------------"
)
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 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(
"-----------------------------------------------------------------------"
)
log.info(
'Connected to the coind - Begining to load Address and Module Checks!')
# Start the coinbaser
coinbaser = SimpleCoinbaser(sia_rpc, getattr(settings, 'CENTRAL_WALLET'))
(yield coinbaser.on_load)
# Connect to Sia Daemon via Factory
f = SocketTransportClientFactory(
args.host,
args.port,
debug=args.verbose,
proxy=proxy,
event_handler=client_service.ClientMiningService)
job_registry = jobs.JobRegistry(f, cmd=args.blocknotify_cmd)
client_service.ClientMiningService.job_registry = job_registry
client_service.ClientMiningService.reset_timeout()
workers = worker_registry.WorkerRegistry(f)
f.on_connect.addCallback(on_connect, workers, job_registry)
f.on_disconnect.addCallback(on_disconnect, workers, job_registry)
registry = TemplateRegistry(BlockTemplate, coinbaser, sia_rpc,
getattr(settings, 'INSTANCE_ID'),
MiningSubscription.on_template,
Interfaces.share_manager.on_network_block)
# Template registry is the main interface between Stratum service
# and pool core logic
Interfaces.set_template_registry(job_registry)
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)
