X-Git-Url: https://git.novaco.in/?a=blobdiff_plain;f=p2pool%2Fmain.py;h=139c75dca82e1f6934b4b64c35e375b6287f5978;hb=2cb4d8381e179f71ea2075cdce948ea83cf0dc55;hp=137071556e78f64e0fc81afb9f6fed663e8b778e;hpb=c4bc0e6931608abb5bf718908d58dd83c941efa3;p=p2pool.git diff --git a/p2pool/main.py b/p2pool/main.py index 1370715..139c75d 100644 --- a/p2pool/main.py +++ b/p2pool/main.py @@ -19,45 +19,10 @@ from twisted.python import log from nattraverso import portmapper, ipdiscover import bitcoin.p2p as bitcoin_p2p, bitcoin.data as bitcoin_data -from bitcoin import worker_interface, height_tracker +from bitcoin import worker_interface, helper from util import fixargparse, jsonrpc, variable, deferral, math, logging -from . import p2p, networks, web, work -import p2pool, p2pool.data as p2pool_data - -@deferral.retry('Error getting work from bitcoind:', 3) -@defer.inlineCallbacks -def getwork(bitcoind, use_getblocktemplate=False): - def go(): - if use_getblocktemplate: - return bitcoind.rpc_getblocktemplate(dict(mode='template')) - else: - return bitcoind.rpc_getmemorypool() - try: - work = yield go() - except jsonrpc.Error_for_code(-32601): # Method not found - use_getblocktemplate = not use_getblocktemplate - try: - work = yield go() - except jsonrpc.Error_for_code(-32601): # Method not found - print >>sys.stderr, 'Error: Bitcoin version too old! Upgrade to v0.5 or newer!' - raise deferral.RetrySilentlyException() - packed_transactions = [(x['data'] if isinstance(x, dict) else x).decode('hex') for x in work['transactions']] - if 'height' not in work: - work['height'] = (yield bitcoind.rpc_getblock(work['previousblockhash']))['height'] + 1 - elif p2pool.DEBUG: - assert work['height'] == (yield bitcoind.rpc_getblock(work['previousblockhash']))['height'] + 1 - defer.returnValue(dict( - version=work['version'], - previous_block=int(work['previousblockhash'], 16), - transactions=map(bitcoin_data.tx_type.unpack, packed_transactions), - subsidy=work['coinbasevalue'], - time=work['time'] if 'time' in work else work['curtime'], - bits=bitcoin_data.FloatingIntegerType().unpack(work['bits'].decode('hex')[::-1]) if isinstance(work['bits'], (str, unicode)) else bitcoin_data.FloatingInteger(work['bits']), - coinbaseflags=work['coinbaseflags'].decode('hex') if 'coinbaseflags' in work else ''.join(x.decode('hex') for x in work['coinbaseaux'].itervalues()) if 'coinbaseaux' in work else '', - height=work['height'], - last_update=time.time(), - use_getblocktemplate=use_getblocktemplate, - )) +from . import networks, web, work +import p2pool, p2pool.data as p2pool_data, p2pool.node as p2pool_node @defer.inlineCallbacks def main(args, net, datadir_path, merged_urls, worker_endpoint): @@ -65,8 +30,6 @@ def main(args, net, datadir_path, merged_urls, worker_endpoint): print 'p2pool (version %s)' % (p2pool.__version__,) print - traffic_happened = variable.Event() - @defer.inlineCallbacks def connect_p2p(): # connect to bitcoind over bitcoin-p2p @@ -85,27 +48,8 @@ def main(args, net, datadir_path, merged_urls, worker_endpoint): url = '%s://%s:%i/' % ('https' if args.bitcoind_rpc_ssl else 'http', args.bitcoind_address, args.bitcoind_rpc_port) print '''Testing bitcoind RPC connection to '%s' with username '%s'...''' % (url, args.bitcoind_rpc_username) bitcoind = jsonrpc.Proxy(url, dict(Authorization='Basic ' + base64.b64encode(args.bitcoind_rpc_username + ':' + args.bitcoind_rpc_password)), timeout=30) - @deferral.retry('Error while checking Bitcoin connection:', 1) - @defer.inlineCallbacks - def check(): - if not (yield net.PARENT.RPC_CHECK(bitcoind)): - print >>sys.stderr, " Check failed! Make sure that you're connected to the right bitcoind with --bitcoind-rpc-port!" - raise deferral.RetrySilentlyException() - if not net.VERSION_CHECK((yield bitcoind.rpc_getinfo())['version']): - print >>sys.stderr, ' Bitcoin version too old! Upgrade to 0.6.4 or newer!' - raise deferral.RetrySilentlyException() - yield check() - temp_work = yield getwork(bitcoind) - - if not args.testnet: - factory = yield connect_p2p() - - block_height_var = variable.Variable(None) - @defer.inlineCallbacks - def poll_height(): - block_height_var.set((yield deferral.retry('Error while calling getblockcount:')(bitcoind.rpc_getblockcount)())) - yield poll_height() - task.LoopingCall(poll_height).start(60*60) + yield helper.check(bitcoind, net) + temp_work = yield helper.getwork(bitcoind) bitcoind_warning_var = variable.Variable(None) @defer.inlineCallbacks @@ -117,9 +61,12 @@ def main(args, net, datadir_path, merged_urls, worker_endpoint): print ' ...success!' print ' Current block hash: %x' % (temp_work['previous_block'],) - print ' Current block height: %i' % (block_height_var.value,) + print ' Current block height: %i' % (temp_work['height'] - 1,) print + if not args.testnet: + factory = yield connect_p2p() + print 'Determining payout address...' if args.pubkey_hash is None: address_path = os.path.join(datadir_path, 'cached_payout_address') @@ -150,221 +97,49 @@ def main(args, net, datadir_path, merged_urls, worker_endpoint): print ' ...success! Payout address:', bitcoin_data.pubkey_hash_to_address(my_pubkey_hash, net.PARENT) print - my_share_hashes = set() - my_doa_share_hashes = set() - - tracker = p2pool_data.OkayTracker(net, my_share_hashes, my_doa_share_hashes) - shared_share_hashes = set() ss = p2pool_data.ShareStore(os.path.join(datadir_path, 'shares.'), net) + shares = {} known_verified = set() print "Loading shares..." for i, (mode, contents) in enumerate(ss.get_shares()): if mode == 'share': - if contents.hash in tracker.items: - continue - shared_share_hashes.add(contents.hash) contents.time_seen = 0 - tracker.add(contents) - if len(tracker.items) % 1000 == 0 and tracker.items: - print " %i" % (len(tracker.items),) + shares[contents.hash] = contents + if len(shares) % 1000 == 0 and shares: + print " %i" % (len(shares),) elif mode == 'verified_hash': known_verified.add(contents) else: raise AssertionError() - print " ...inserting %i verified shares..." % (len(known_verified),) - for h in known_verified: - if h not in tracker.items: - ss.forget_verified_share(h) - continue - tracker.verified.add(tracker.items[h]) - print " ...done loading %i shares!" % (len(tracker.items),) + print " ...done loading %i shares (%i verified)!" % (len(shares), len(known_verified)) print - tracker.removed.watch(lambda share: ss.forget_share(share.hash)) - tracker.verified.removed.watch(lambda share: ss.forget_verified_share(share.hash)) - tracker.removed.watch(lambda share: shared_share_hashes.discard(share.hash)) - print 'Initializing work...' - - - # BITCOIND WORK - - bitcoind_work = variable.Variable((yield getwork(bitcoind))) - @defer.inlineCallbacks - def work_poller(): - while True: - flag = factory.new_block.get_deferred() - try: - bitcoind_work.set((yield getwork(bitcoind, bitcoind_work.value['use_getblocktemplate']))) - except: - log.err() - yield defer.DeferredList([flag, deferral.sleep(15)], fireOnOneCallback=True) - work_poller() - # PEER WORK - - best_block_header = variable.Variable(None) - def handle_header(new_header): - # check that header matches current target - if not (net.PARENT.POW_FUNC(bitcoin_data.block_header_type.pack(new_header)) <= bitcoind_work.value['bits'].target): - return - bitcoind_best_block = bitcoind_work.value['previous_block'] - if (best_block_header.value is None - or ( - new_header['previous_block'] == bitcoind_best_block and - bitcoin_data.hash256(bitcoin_data.block_header_type.pack(best_block_header.value)) == bitcoind_best_block - ) # new is child of current and previous is current - or ( - bitcoin_data.hash256(bitcoin_data.block_header_type.pack(new_header)) == bitcoind_best_block and - best_block_header.value['previous_block'] != bitcoind_best_block - )): # new is current and previous is not a child of current - best_block_header.set(new_header) - @defer.inlineCallbacks - def poll_header(): - handle_header((yield factory.conn.value.get_block_header(bitcoind_work.value['previous_block']))) - bitcoind_work.changed.watch(lambda _: poll_header()) - yield deferral.retry('Error while requesting best block header:')(poll_header)() + print 'Initializing work...' - # BEST SHARE + node = p2pool_node.Node(factory, bitcoind, shares.values(), known_verified, net) + yield node.start() - known_txs_var = variable.Variable({}) # hash -> tx - mining_txs_var = variable.Variable({}) # hash -> tx - get_height_rel_highest = yield height_tracker.get_height_rel_highest_func(bitcoind, factory, lambda: bitcoind_work.value['previous_block'], net) + for share_hash in shares: + if share_hash not in node.tracker.items: + ss.forget_share(share_hash) + for share_hash in known_verified: + if share_hash not in node.tracker.verified.items: + ss.forget_verified_share(share_hash) + del shares, known_verified + node.tracker.removed.watch(lambda share: ss.forget_share(share.hash)) + node.tracker.verified.removed.watch(lambda share: ss.forget_verified_share(share.hash)) - best_share_var = variable.Variable(None) - desired_var = variable.Variable(None) - def set_best_share(): - best, desired = tracker.think(get_height_rel_highest, bitcoind_work.value['previous_block'], bitcoind_work.value['bits'], known_txs_var.value) - - best_share_var.set(best) - desired_var.set(desired) - bitcoind_work.changed.watch(lambda _: set_best_share()) - set_best_share() + def save_shares(): + for share in node.tracker.get_chain(node.best_share_var.value, min(node.tracker.get_height(node.best_share_var.value), 2*net.CHAIN_LENGTH)): + ss.add_share(share) + if share.hash in node.tracker.verified.items: + ss.add_verified_hash(share.hash) + task.LoopingCall(save_shares).start(60) print ' ...success!' print - # setup p2p logic and join p2pool network - - # update mining_txs according to getwork results - @bitcoind_work.changed.run_and_watch - def _(_=None): - new_mining_txs = {} - new_known_txs = dict(known_txs_var.value) - for tx in bitcoind_work.value['transactions']: - tx_hash = bitcoin_data.hash256(bitcoin_data.tx_type.pack(tx)) - new_mining_txs[tx_hash] = tx - new_known_txs[tx_hash] = tx - mining_txs_var.set(new_mining_txs) - known_txs_var.set(new_known_txs) - # add p2p transactions from bitcoind to known_txs - @factory.new_tx.watch - def _(tx): - new_known_txs = dict(known_txs_var.value) - new_known_txs[bitcoin_data.hash256(bitcoin_data.tx_type.pack(tx))] = tx - known_txs_var.set(new_known_txs) - # forward transactions seen to bitcoind - @known_txs_var.transitioned.watch - def _(before, after): - for tx_hash in set(after) - set(before): - factory.conn.value.send_tx(tx=after[tx_hash]) - - class Node(p2p.Node): - def handle_shares(self, shares, peer): - if len(shares) > 5: - print 'Processing %i shares from %s...' % (len(shares), '%s:%i' % peer.addr if peer is not None else None) - - new_count = 0 - for share in shares: - if share.hash in tracker.items: - #print 'Got duplicate share, ignoring. Hash: %s' % (p2pool_data.format_hash(share.hash),) - continue - - new_count += 1 - - #print 'Received share %s from %r' % (p2pool_data.format_hash(share.hash), share.peer.addr if share.peer is not None else None) - - tracker.add(share) - - if new_count: - set_best_share() - - if len(shares) > 5: - print '... done processing %i shares. New: %i Have: %i/~%i' % (len(shares), new_count, len(tracker.items), 2*net.CHAIN_LENGTH) - - @defer.inlineCallbacks - def handle_share_hashes(self, hashes, peer): - new_hashes = [x for x in hashes if x not in tracker.items] - if not new_hashes: - return - try: - shares = yield peer.get_shares( - hashes=new_hashes, - parents=0, - stops=[], - ) - except: - log.err(None, 'in handle_share_hashes:') - else: - self.handle_shares(shares, peer) - - def handle_get_shares(self, hashes, parents, stops, peer): - parents = min(parents, 1000//len(hashes)) - stops = set(stops) - shares = [] - for share_hash in hashes: - for share in tracker.get_chain(share_hash, min(parents + 1, tracker.get_height(share_hash))): - if share.hash in stops: - break - shares.append(share) - print 'Sending %i shares to %s:%i' % (len(shares), peer.addr[0], peer.addr[1]) - return shares - - def handle_bestblock(self, header, peer): - if net.PARENT.POW_FUNC(bitcoin_data.block_header_type.pack(header)) > header['bits'].target: - raise p2p.PeerMisbehavingError('received block header fails PoW test') - handle_header(header) - - @deferral.retry('Error submitting primary block: (will retry)', 10, 10) - def submit_block_p2p(block): - if factory.conn.value is None: - print >>sys.stderr, 'No bitcoind connection when block submittal attempted! %s%064x' % (net.PARENT.BLOCK_EXPLORER_URL_PREFIX, bitcoin_data.hash256(bitcoin_data.block_header_type.pack(block['header']))) - raise deferral.RetrySilentlyException() - factory.conn.value.send_block(block=block) - - @deferral.retry('Error submitting block: (will retry)', 10, 10) - @defer.inlineCallbacks - def submit_block_rpc(block, ignore_failure): - if bitcoind_work.value['use_getblocktemplate']: - result = yield bitcoind.rpc_submitblock(bitcoin_data.block_type.pack(block).encode('hex')) - success = result is None - else: - result = yield bitcoind.rpc_getmemorypool(bitcoin_data.block_type.pack(block).encode('hex')) - success = result - success_expected = net.PARENT.POW_FUNC(bitcoin_data.block_header_type.pack(block['header'])) <= block['header']['bits'].target - if (not success and success_expected and not ignore_failure) or (success and not success_expected): - print >>sys.stderr, 'Block submittal result: %s (%r) Expected: %s' % (success, result, success_expected) - - def submit_block(block, ignore_failure): - submit_block_p2p(block) - submit_block_rpc(block, ignore_failure) - - @tracker.verified.added.watch - def _(share): - if share.pow_hash <= share.header['bits'].target: - block = share.as_block(tracker, known_txs_var.value) - if block is None: - print >>sys.stderr, 'GOT INCOMPLETE BLOCK FROM PEER! %s bitcoin: %s%064x' % (p2pool_data.format_hash(share.hash), net.PARENT.BLOCK_EXPLORER_URL_PREFIX, share.header_hash) - return - submit_block(block, ignore_failure=True) - print - print 'GOT BLOCK FROM PEER! Passing to bitcoind! %s bitcoin: %s%064x' % (p2pool_data.format_hash(share.hash), net.PARENT.BLOCK_EXPLORER_URL_PREFIX, share.header_hash) - print - def spread(): - if (get_height_rel_highest(share.header['previous_block']) > -5 or - bitcoind_work.value['previous_block'] in [share.header['previous_block'], share.header_hash]): - broadcast_share(share.hash) - spread() - reactor.callLater(5, spread) # so get_height_rel_highest can update print 'Joining p2pool network using port %i...' % (args.p2pool_port,) @@ -398,91 +173,20 @@ def main(args, net, datadir_path, merged_urls, worker_endpoint): except: log.err() - p2p_node = Node( - best_share_hash_func=lambda: best_share_var.value, + node.p2p_node = p2pool_node.P2PNode(node, port=args.p2pool_port, - net=net, + max_incoming_conns=args.p2pool_conns, addr_store=addrs, connect_addrs=connect_addrs, - max_incoming_conns=args.p2pool_conns, - traffic_happened=traffic_happened, - known_txs_var=known_txs_var, - mining_txs_var=mining_txs_var, + desired_outgoing_conns=args.p2pool_outgoing_conns, ) - p2p_node.start() - - def forget_old_txs(): - new_known_txs = {} - for peer in p2p_node.peers.itervalues(): - new_known_txs.update(peer.remembered_txs) - new_known_txs.update(mining_txs_var.value) - for share in tracker.get_chain(best_share_var.value, min(120, tracker.get_height(best_share_var.value))): - for tx_hash in share.share_info['new_transaction_hashes']: - if tx_hash in known_txs_var.value: - new_known_txs[tx_hash] = known_txs_var.value[tx_hash] - known_txs_var.set(new_known_txs) - task.LoopingCall(forget_old_txs).start(10) + node.p2p_node.start() def save_addrs(): with open(os.path.join(datadir_path, 'addrs'), 'wb') as f: - f.write(json.dumps(p2p_node.addr_store.items())) + f.write(json.dumps(node.p2p_node.addr_store.items())) task.LoopingCall(save_addrs).start(60) - @best_block_header.changed.watch - def _(header): - for peer in p2p_node.peers.itervalues(): - peer.send_bestblock(header=header) - - @defer.inlineCallbacks - def broadcast_share(share_hash): - shares = [] - for share in tracker.get_chain(share_hash, min(5, tracker.get_height(share_hash))): - if share.hash in shared_share_hashes: - break - shared_share_hashes.add(share.hash) - shares.append(share) - - for peer in list(p2p_node.peers.itervalues()): - yield peer.sendShares([share for share in shares if share.peer is not peer], tracker, known_txs_var.value, include_txs_with=[share_hash]) - - # send share when the chain changes to their chain - best_share_var.changed.watch(broadcast_share) - - def save_shares(): - for share in tracker.get_chain(best_share_var.value, min(tracker.get_height(best_share_var.value), 2*net.CHAIN_LENGTH)): - ss.add_share(share) - if share.hash in tracker.verified.items: - ss.add_verified_hash(share.hash) - task.LoopingCall(save_shares).start(60) - - @apply - @defer.inlineCallbacks - def download_shares(): - while True: - desired = yield desired_var.get_when_satisfies(lambda val: len(val) != 0) - peer2, share_hash = random.choice(desired) - - if len(p2p_node.peers) == 0: - yield deferral.sleep(1) - continue - peer = random.choice(p2p_node.peers.values()) - - print 'Requesting parent share %s from %s' % (p2pool_data.format_hash(share_hash), '%s:%i' % peer.addr) - try: - shares = yield peer.get_shares( - hashes=[share_hash], - parents=500, - stops=[], - ) - except: - log.err(None, 'in download_shares:') - continue - - if not shares: - yield deferral.sleep(1) # sleep so we don't keep rerequesting the same share nobody has - continue - p2p_node.handle_shares(shares, peer) - print ' ...success!' print @@ -507,10 +211,8 @@ def main(args, net, datadir_path, merged_urls, worker_endpoint): print 'Listening for workers on %r port %i...' % (worker_endpoint[0], worker_endpoint[1]) - get_current_txouts = lambda: p2pool_data.get_expected_payouts(tracker, best_share_var.value, bitcoind_work.value['bits'].target, bitcoind_work.value['subsidy'], net) - - wb = work.WorkerBridge(my_pubkey_hash, net, args.donation_percentage, bitcoind_work, best_block_header, merged_urls, best_share_var, tracker, my_share_hashes, my_doa_share_hashes, args.worker_fee, p2p_node, submit_block, set_best_share, broadcast_share, block_height_var) - web_root = web.get_web_root(tracker, bitcoind_work, get_current_txouts, datadir_path, net, wb.get_stale_counts, my_pubkey_hash, wb.local_rate_monitor, args.worker_fee, p2p_node, wb.my_share_hashes, wb.pseudoshare_received, wb.share_received, best_share_var, bitcoind_warning_var, traffic_happened) + wb = work.WorkerBridge(node, my_pubkey_hash, args.donation_percentage, merged_urls, args.worker_fee) + web_root = web.get_web_root(wb, datadir_path, bitcoind_warning_var) worker_interface.WorkerInterface(wb).attach_to(web_root, get_handler=lambda request: request.redirect('/static/')) deferral.retry('Error binding to worker port:', traceback=False)(reactor.listenTCP)(worker_endpoint[1], server.Site(web_root), interface=worker_endpoint[0]) @@ -552,19 +254,26 @@ def main(args, net, datadir_path, merged_urls, worker_endpoint): print repr(line) irc.IRCClient.lineReceived(self, line) def signedOn(self): + self.in_channel = False irc.IRCClient.signedOn(self) self.factory.resetDelay() self.join(self.channel) @defer.inlineCallbacks def new_share(share): + if not self.in_channel: + return if share.pow_hash <= share.header['bits'].target and abs(share.timestamp - time.time()) < 10*60: yield deferral.sleep(random.expovariate(1/60)) message = '\x02%s BLOCK FOUND by %s! %s%064x' % (net.NAME.upper(), bitcoin_data.script2_to_address(share.new_script, net.PARENT), net.PARENT.BLOCK_EXPLORER_URL_PREFIX, share.header_hash) if all('%x' % (share.header_hash,) not in old_message for old_message in self.recent_messages): self.say(self.channel, message) self._remember_message(message) - self.watch_id = tracker.verified.added.watch(new_share) + self.watch_id = node.tracker.verified.added.watch(new_share) self.recent_messages = [] + def joined(self, channel): + self.in_channel = True + def left(self, channel): + self.in_channel = False def _remember_message(self, message): self.recent_messages.append(message) while len(self.recent_messages) > 100: @@ -573,7 +282,7 @@ def main(args, net, datadir_path, merged_urls, worker_endpoint): if channel == self.channel: self._remember_message(message) def connectionLost(self, reason): - tracker.verified.added.unwatch(self.watch_id) + node.tracker.verified.added.unwatch(self.watch_id) print 'IRC connection lost:', reason.getErrorMessage() class IRCClientFactory(protocol.ReconnectingClientFactory): protocol = IRCClient @@ -586,13 +295,13 @@ def main(args, net, datadir_path, merged_urls, worker_endpoint): while True: yield deferral.sleep(3) try: - height = tracker.get_height(best_share_var.value) + height = node.tracker.get_height(node.best_share_var.value) this_str = 'P2Pool: %i shares in chain (%i verified/%i total) Peers: %i (%i incoming)' % ( height, - len(tracker.verified.items), - len(tracker.items), - len(p2p_node.peers), - sum(1 for peer in p2p_node.peers.itervalues() if peer.incoming), + len(node.tracker.verified.items), + len(node.tracker.items), + len(node.p2p_node.peers), + sum(1 for peer in node.p2p_node.peers.itervalues() if peer.incoming), ) + (' FDs: %i R/%i W' % (len(reactor.getReaders()), len(reactor.getWriters())) if p2pool.DEBUG else '') datums, dt = wb.local_rate_monitor.get_datums_in_last() @@ -601,27 +310,27 @@ def main(args, net, datadir_path, merged_urls, worker_endpoint): math.format(int(my_att_s)), math.format_dt(dt), math.format_binomial_conf(sum(1 for datum in datums if datum['dead']), len(datums), 0.95), - math.format_dt(2**256 / tracker.items[best_share_var.value].max_target / my_att_s) if my_att_s and best_share_var.value else '???', + math.format_dt(2**256 / node.tracker.items[node.best_share_var.value].max_target / my_att_s) if my_att_s and node.best_share_var.value else '???', ) if height > 2: (stale_orphan_shares, stale_doa_shares), shares, _ = wb.get_stale_counts() - stale_prop = p2pool_data.get_average_stale_prop(tracker, best_share_var.value, min(60*60//net.SHARE_PERIOD, height)) - real_att_s = p2pool_data.get_pool_attempts_per_second(tracker, best_share_var.value, min(height - 1, 60*60//net.SHARE_PERIOD)) / (1 - stale_prop) + stale_prop = p2pool_data.get_average_stale_prop(node.tracker, node.best_share_var.value, min(60*60//net.SHARE_PERIOD, height)) + real_att_s = p2pool_data.get_pool_attempts_per_second(node.tracker, node.best_share_var.value, min(height - 1, 60*60//net.SHARE_PERIOD)) / (1 - stale_prop) this_str += '\n Shares: %i (%i orphan, %i dead) Stale rate: %s Efficiency: %s Current payout: %.4f %s' % ( shares, stale_orphan_shares, stale_doa_shares, math.format_binomial_conf(stale_orphan_shares + stale_doa_shares, shares, 0.95), math.format_binomial_conf(stale_orphan_shares + stale_doa_shares, shares, 0.95, lambda x: (1 - x)/(1 - stale_prop)), - get_current_txouts().get(bitcoin_data.pubkey_hash_to_script2(my_pubkey_hash), 0)*1e-8, net.PARENT.SYMBOL, + node.get_current_txouts().get(bitcoin_data.pubkey_hash_to_script2(my_pubkey_hash), 0)*1e-8, net.PARENT.SYMBOL, ) this_str += '\n Pool: %sH/s Stale rate: %.1f%% Expected time to block: %s' % ( math.format(int(real_att_s)), 100*stale_prop, - math.format_dt(2**256 / bitcoind_work.value['bits'].target / real_att_s), + math.format_dt(2**256 / node.bitcoind_work.value['bits'].target / real_att_s), ) - for warning in p2pool_data.get_warnings(tracker, best_share_var.value, net, bitcoind_warning_var.value, bitcoind_work.value): + for warning in p2pool_data.get_warnings(node.tracker, node.best_share_var.value, net, bitcoind_warning_var.value, node.bitcoind_work.value): print >>sys.stderr, '#'*40 print >>sys.stderr, '>>> Warning: ' + warning print >>sys.stderr, '#'*40 @@ -689,6 +398,9 @@ def run(): p2pool_group.add_argument('--max-conns', metavar='CONNS', help='maximum incoming connections (default: 40)', type=int, action='store', default=40, dest='p2pool_conns') + p2pool_group.add_argument('--outgoing-conns', metavar='CONNS', + help='outgoing connections (default: 10)', + type=int, action='store', default=10, dest='p2pool_outgoing_conns') worker_group = parser.add_argument_group('worker interface') worker_group.add_argument('-w', '--worker-port', metavar='PORT or ADDR:PORT', @@ -775,6 +487,9 @@ def run(): if args.p2pool_port is None: args.p2pool_port = net.P2P_PORT + if args.p2pool_outgoing_conns > 10: + parser.error('''--outgoing-conns can't be more than 10''') + if args.worker_endpoint is None: worker_endpoint = '', net.WORKER_PORT elif ':' not in args.worker_endpoint: