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 main():
debug = False
# Try to connect to remote server
d = defer.Deferred()
hostname = 'california.stratum.bitcoin.cz'
#hostname = 'localhost'
f = SocketTransportClientFactory(hostname,
3333,
allow_trusted=True,
allow_untrusted=False,
debug=debug,
signing_key=None,
signing_id=None,
on_connect=d,
event_handler=ServiceEventHandler)
yield d # Wait to on_connect event
(event, subscription_key) = (yield f.subscribe('example.pubsub.subscribe',
[
1,
]))
print("Subscribed:", event, subscription_key)
reactor.callLater(3, unsubscribe, f, event, subscription_key)
print(yield f.rpc('discovery.list_services', []))
#print (yield f.rpc('discovery.list_methods', ['example']))
#print (yield f.rpc('discovery.list_params', ['example.ping']))
print(yield f.rpc('example.ping', ['testing payload']))
'''
s = time.time()
x = 10
for x in range(x):
(yield f.rpc('node.ping', ['hi',]))
print float(x) / (time.time() - s)
'''
#print (yield f.rpc('blockchain.transaction.broadcast', ['01000000016e71be76a49eac1d1f55113e4a581ea21a33e94a17453f6a0f3624db0b43b101000000008b48304502207e1fd0a8a8051fb21561df5d9d0e3ad0f3ced2b51e90ff1cebc85406a654cfaf022100bc7d3cf9a93959ff80953272d45fbd5cbdb8800874db0858783547ecef19c2ce014104e6a069738d8e8491a8abd3bed7d303c9b2dc3792173a18483653036fd74a5100fc6ee327b6a82b3df79005f101b88496988fa414af32df11fff3e96d53d26d03ffffffff0180969800000000001976a914e1c9b052561cf0a1da9ee3175df7d5a2d7ff7dd488ac00000000']))
'''
print (yield f.rpc_multi([
['blockchain.block[Electrum].get_blocknum', [], False],
['node.get_peers', [], False],
['firstbits.create', ['1MarekMKDKRb6PEeHeVuiCGayk9avyBGBB',], False],
['firstbits.create', ['1MarekMKDKRb6PEeHeVuiCGayk9avyBGBB',], False],
['node.ping', ['test'], False],
]))
'''
'''
def _connect(self, hostname, port, on_connect, on_disconnect):
from stratum.socket_transport import SocketTransportClientFactory
# Try to connect to remote server
return SocketTransportClientFactory(
hostname,
port,
allow_trusted=True,
allow_untrusted=False,
debug=False,
signing_key=None,
signing_id=None,
on_connect=on_connect,
on_disconnect=on_disconnect,
is_reconnecting=False,
)
def _connect(self, login, passwd):
if self._con_factory or self._subscription:
raise Exception('Factory or subscription already present')
# Try to connect to remote server
self._con_factory = SocketTransportClientFactory(POOL_HOST,
POOL_PORT,
allow_trusted=True,
allow_untrusted=False,
debug=DEBUG,
signing_key=None,
signing_id=None,
event_handler=self)
self.out("connecting... ")
try:
yield self._con_factory.on_connect # Wait to on_connect event
except:
self.out('ERR: connection failed')
raise
auth_result = (yield
self._con_factory.subscribe('mining.authorize',
[login, passwd]))
self.out("authorized %s %s" % (login, str(auth_result)))
(_, extranonce1, extranonce2_size) = (yield
self._con_factory.subscribe(
'mining.subscribe', [
'minersim-1.0',
]))[:3]
self._subscription = {
'login': login,
'difficulty': 1,
'difficulty_new': 1,
'job_id': None,
'ntime': time.time(),
'extranonce2_size': extranonce2_size,
'job_specified': defer.Deferred()
}
self.out("subscribed, waiting for a job")
yield self._subscription['job_specified']
self.START = time.time()
self.COUNTER = 0
def main(args):
if args.pid_file:
fp = file(args.pid_file, 'w')
fp.write(str(os.getpid()))
fp.close()
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=None,
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 connect to the pool
yield f.on_connect
# thread
thread = threading.Thread(target=mine, args=[args, job_registry, workers])
#thread.daemon = True
thread.start()
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(
"-----------------------------------------------------------------------"
)
