def subscribe(self, *args): connection = self.connection_ref() session = connection.get_session() if session.get('extranonce1'): # Already subscribed subs1 = Pubsub.get_subscription(connection, DifficultySubscription.event) subs2 = Pubsub.get_subscription(connection, MiningSubscription.event) extranonce1_hex = binascii.hexlify(session['extranonce1']) extranonce2_size = Interfaces.template_registry.extranonce2_size log.warning('Already subscribed') return (((subs1.event, subs1.get_key()), (subs2.event, subs2.get_key())),) + \ (extranonce1_hex, extranonce2_size) extranonce1 = Interfaces.template_registry.get_new_extranonce1() extranonce2_size = Interfaces.template_registry.extranonce2_size extranonce1_hex = binascii.hexlify(extranonce1) session['extranonce1'] = extranonce1 session['subscribed_at'] = posix_time() # Don't accept job_id if job_id < min_job_id session['min_job_id'] = 0 session['client_sw'] = self._get_client_sw(*args) subs1 = Pubsub.subscribe(connection, DifficultySubscription())[0] subs2 = Pubsub.subscribe(connection, MiningSubscription())[0] Interfaces.reporter.new_subscription(session) return ((subs1, subs2),) + (extranonce1_hex, extranonce2_size)
def subscribe(self, *args): if self._f.client == None or not self._f.client.connected: yield self._f.on_connect if self._f.client == None or not self._f.client.connected: raise UpstreamServiceException("Upstream not connected") if self.extranonce1 == None: # This should never happen, because _f.on_connect is fired *after* # connection receive mining.subscribe response raise UpstreamServiceException("Not subscribed on upstream yet") (tail, extranonce2_size) = self._get_unused_tail() session = self.connection_ref().get_session() session['tail'] = tail # Remove extranonce from registry when client disconnect self.connection_ref().on_disconnect.addCallback(self._drop_tail, tail) subs1 = Pubsub.subscribe(self.connection_ref(), DifficultySubscription())[0] subs2 = Pubsub.subscribe(self.connection_ref(), MiningSubscription())[0] defer.returnValue(((subs1, subs2), ) + (self.extranonce1 + tail, extranonce2_size))
def subscribe(self, *args): f = self._get_stratum_proxy().f job = self._get_stratum_proxy().jobreg if f.client is None or not f.client.connected: yield f.on_connect conn = self.connection_ref() if f.client is None or not f.client.connected or not conn: raise UpstreamServiceException("Upstream not connected") if job.extranonce1 is None: # This should never happen, because _f.on_connect is fired *after* # connection receive mining.subscribe response raise UpstreamServiceException("Not subscribed on upstream yet") (tail, extranonce2_size) = job._get_unused_tail() session = self.connection_ref().get_session() session['tail'] = tail # Remove extranonce from registry when client disconnect conn.on_disconnect.addCallback(job._drop_tail, tail) subs1 = Pubsub.subscribe(conn, DifficultySubscription())[0] subs2 = Pubsub.subscribe(conn, MiningSubscription())[0] log.info("Sending subscription to worker: %s/%s" % (job.extranonce1 + tail, extranonce2_size)) defer.returnValue(((subs1, subs2), ) + (job.extranonce1 + tail, extranonce2_size))
def subscribe(self, *args): f = self._get_stratum_proxy().f job = self._get_stratum_proxy().jobreg if f.client is None or not f.client.connected: yield f.on_connect conn = self.connection_ref() if f.client is None or not f.client.connected or not conn: raise UpstreamServiceException("Upstream not connected") if job.extranonce1 is None: # This should never happen, because _f.on_connect is fired *after* # connection receive mining.subscribe response raise UpstreamServiceException("Not subscribed on upstream yet") (tail, extranonce2_size) = job._get_unused_tail() session = self.connection_ref().get_session() session['tail'] = tail # Remove extranonce from registry when client disconnect conn.on_disconnect.addCallback(job._drop_tail, tail) subs1 = Pubsub.subscribe(conn, DifficultySubscription())[0] subs2 = Pubsub.subscribe(conn, MiningSubscription())[0] log.info( "Sending subscription to worker: %s/%s" % (job.extranonce1 + tail, extranonce2_size)) defer.returnValue( ((subs1, subs2),) + (job.extranonce1 + tail, extranonce2_size))
def login(self, params, *args): if self._f.client == None or not self._f.client.connected: yield self._f.on_connect if self._f.client == None or not self._f.client.connected: raise UpstreamServiceException("Upstream not connected") tail = self._get_unused_tail() session = self.connection_ref().get_session() session['tail'] = tail custom_user = self.custom_user if self.enable_worker_id and params.has_key("login"): if self.worker_id_from_ip: ip_login = self.connection_ref()._get_ip() ip_temp = ip_login.split('.') ip_int = int(ip_temp[0])*16777216 + int(ip_temp[1])*65536 + int(ip_temp[2])*256 + int(ip_temp[3]) custom_user = "******" % (custom_user, ip_int) else: params_login = re.sub(r'[^\d]', '', params["login"]) if params_login and int(params_login)>0: custom_user = "******" % (custom_user, params_login) first_job = (yield self._f.rpc('login', {"login":custom_user, "pass":self.custom_password})) try: self.connection_ref().on_disconnect.addCallback(self._drop_tail, tail) except Exception: pass subs = Pubsub.subscribe(self.connection_ref(), MiningSubscription())[0] MiningSubscription.add_user_id(subs[2], first_job['id']) defer.returnValue(first_job)
def request(self, *args): if not (self.authorize(args[0], args[1])): log.info("Failed worker authorization: IP %s" % str(ip)) raise SubmitException("Failed worker authorization") session = self.connection_ref().get_session() extranonce1_bin = session.get('extranonce1', None) if not extranonce1_bin: log.info("Connection is not subscribed for mining: IP %s" % str(ip)) raise SubmitException("Connection is not subscribed for mining") extranonce2 = struct.pack('>L', 0) (job_id, prevhash, version, nbits, ntime, _) = Interfaces.template_registry.get_last_broadcast_args() coinbase_bin = Interfaces.template_registry.last_block.serialize_coinbase( extranonce1_bin, extranonce2) coinbase_hash = util.doublesha(coinbase_bin) merkle_root_bin = Interfaces.template_registry.last_block.merkletree.withFirst( coinbase_hash) merkle_root = binascii.hexlify(merkle_root_bin) work_id = Interfaces.worker_manager.register_work( session['extranonce1'], merkle_root, session['difficulty'], job_id, session['basediff']) job = {} job['data'] = version + prevhash + merkle_root + ntime + nbits job['difficulty'] = session['difficulty'] return Pubsub.subscribe(self.connection_ref(), MiningSubscription(), job)
def login(self, params, *args): if self._f.client == None or not self._f.client.connected: yield self._f.on_connect if self._f.client == None or not self._f.client.connected: raise UpstreamServiceException("Upstream not connected") tail = self._get_unused_tail() session = self.connection_ref().get_session() session['tail'] = tail custom_user = self.custom_user if self.enable_worker_id and params.has_key("login"): if self.worker_id_from_ip: ip_login = self.connection_ref()._get_ip() ip_temp = ip_login.split('.') ip_int = int(ip_temp[0])*16777216 + int(ip_temp[1])*65536 + int(ip_temp[2])*256 + int(ip_temp[3]) custom_user = "******" % (custom_user, ip_int) else: params_login = re.sub(r'[^\d]', '', params["login"]) if params_login and int(params_login)>0: custom_user = "******" % (custom_user, params_login) first_job = (yield self._f.rpc('login', {"login":custom_user, "pass":self.custom_password})) try: self.connection_ref().on_disconnect.addCallback(self._drop_tail, tail) except Exception: pass subs = Pubsub.subscribe(self.connection_ref(), MiningSubscription())[0] MiningSubscription.add_user_id(subs[2], first_job['id']) defer.returnValue(first_job)
def configure_downstream(cls, connection_ref, values): """Version rolling configuration for downstream miners :param connection_ref: :param values: :return: :todo consider whether the result should indicate version rolling disabled in case there is no intersection between the upstream mask and the downstream requested mask """ result = super(VersionRollingExtension, cls).configure_downstream(connection_ref, values) try: downstream_proposed_mask = cls._get_mask_from_values(values) # Only when subscription is enabled compose a valid mask if VersionMaskSubscription.enabled: sub = VersionMaskSubscription(downstream_proposed_mask) result = { cls.namespace: True, cls.namespace + '.mask': '%x' % sub.get_effective_mask() } _ = Pubsub.subscribe(connection_ref(), sub) except Exception as e: log.error("Version mask not calculated, error: '%s'" % e) return result
def subscribe(self, *args): conn = self.connection_ref() if conn is None or not conn.connected: log.info( 'subscribe miner connection lost.............................%s' % (conn)) raise SubscribeException("Miner connection lost") stp = stproxy_ng.StratumServer._get_miner_proxy(conn._get_ip()) try: yield stp.connected log.info( 'subscribe yield proxy connected result......................%s %s' % (conn, stp)) except Exception as e: log.info( 'subscribe yield proxy connected exception.................. %s %s %s' % (conn, stp, e)) if not conn.connected: log.info( 'subscribe miner connection lost.............................%s %s' % (conn, stp)) raise SubscribeException("Miner connection lost") MinerConnectSubscription.emit(conn._get_ip(), id(stp.f)) session = conn.get_session() session['proxy'] = stp (tail, extranonce2_size) = stp.job_registry._get_unused_tail() # Remove extranonce from registry when client disconnect conn.on_disconnect.addCallback(stp.job_registry._drop_tail, tail) session['tail'] = tail subs1 = Pubsub.subscribe(conn, DifficultySubscription(stp))[0] subs2 = Pubsub.subscribe(conn, MiningSubscription(stp))[0] log.info( "Sending subscription to worker: %s/%s connection: %s proxy: %s" % (stp.job_registry.extranonce1 + tail, extranonce2_size, conn, stp)) defer.returnValue(((subs1, subs2), ) + (stp.job_registry.extranonce1 + tail, extranonce2_size))
def subscribe(self, *args): '''Subscribe for receiving mining jobs. This will return subscription details, extranonce1_hex and extranonce2_size''' extranonce1 = Interfaces.template_registry.get_new_extranonce1() extranonce2_size = Interfaces.template_registry.extranonce2_size extranonce1_hex = binascii.hexlify(extranonce1) session = self.connection_ref().get_session() session['extranonce1'] = extranonce1 session['difficulty'] = settings.POOL_TARGET # Following protocol specs, default diff is 1 return Pubsub.subscribe(self.connection_ref(), MiningSubscription()) + (extranonce1_hex, extranonce2_size)
def subscribe(self, *args): '''Subscribe for receiving mining jobs. This will return subscription details, extranonce1_hex and extranonce2_size''' extranonce1 = Interfaces.template_registry.get_new_extranonce1() extranonce2_size = Interfaces.template_registry.extranonce2_size extranonce1_hex = binascii.hexlify(extranonce1) session = self.connection_ref().get_session() session['extranonce1'] = extranonce1 session['difficulty'] = settings.POOL_TARGET # Following protocol specs, default diff is 1 return Pubsub.subscribe(self.connection_ref(), MiningSubscription()) + (extranonce1_hex, extranonce2_size)
def subscribe(self, *args): if self._f.client == None or not self._f.client.connected: yield self._f.on_connect if self._f.client == None or not self._f.client.connected: raise UpstreamServiceException("Upstream not connected") if self.extranonce1 == None: # This should never happen, because _f.on_connect is fired *after* # connection receive mining.subscribe response raise UpstreamServiceException("Not subscribed on upstream yet") (tail, extranonce2_size) = self._get_unused_tail() session = self.connection_ref().get_session() session['tail'] = tail # Remove extranonce from registry when client disconnect self.connection_ref().on_disconnect.addCallback(self._drop_tail, tail) subs1 = Pubsub.subscribe(self.connection_ref(), DifficultySubscription())[0] subs2 = Pubsub.subscribe(self.connection_ref(), MiningSubscription())[0] defer.returnValue(((subs1, subs2),) + (self.extranonce1+tail, extranonce2_size))
def subscribe(self, *args): '''Subscribe for receiving mining jobs. This will return subscription details, extranonce_hex and extranonce_size''' extranonce = Interfaces.template_registry.get_new_extranonce() extranonce_size = Interfaces.template_registry.extranonce_size extranonce_hex = binascii.hexlify(extranonce).decode('utf_8') session = self.connection_ref().get_session() session['extranonce'] = extranonce session['difficulty'] = settings.POOL_TARGET return Pubsub.subscribe( self.connection_ref(), MiningSubscription()) + (extranonce_hex, extranonce_size)
def subscribe(self, *args): '''Subscribe for receiving mining jobs. This will return subscription details, extranonce1_hex and extranonce2_size''' extranonce1 = Interfaces.template_registry.get_new_extranonce1() extranonce2_size = Interfaces.template_registry.extranonce2_size extranonce1_hex = binascii.hexlify(extranonce1) session = self.connection_ref().get_session() session['extranonce1'] = extranonce1 if settings.RSK_DEV_MODE and hasattr(settings, 'RSK_STRATUM_DIFFICULTY'): session['difficulty'] = settings.RSK_STRATUM_DIFFICULTY else: session[ 'difficulty'] = 1 # Following protocol specs, default diff is 1 return Pubsub.subscribe( self.connection_ref(), MiningSubscription()) + (extranonce1_hex, extranonce2_size)