def start(cls, net, factory, uniod, peer_ports, merged_urls):
self = cls()
self.n = node.Node(factory, uniod, [], [], net)
yield self.n.start()
self.n.p2p_node = node.P2PNode(self.n,
port=0,
max_incoming_conns=1000000,
addr_store={},
connect_addrs=[
('127.0.0.1', peer_port)
for peer_port in peer_ports
])
self.n.p2p_node.start()
wb = work.WorkerBridge(node=self.n,
my_pubkey_hash=random.randrange(2**160),
donation_percentage=random.uniform(0, 10),
merged_urls=merged_urls,
worker_fee=3)
self.wb = wb
web_root = resource.Resource()
worker_interface.WorkerInterface(wb).attach_to(web_root)
self.web_port = reactor.listenTCP(0, server.Site(web_root))
defer.returnValue(self)
def test_node(self):
bitd = dcrd()
mm_root = resource.Resource()
mm_root.putChild('', jsonrpc.HTTPServer(mm_provider))
mm_port = reactor.listenTCP(0, server.Site(mm_root))
n = node.Node(bitd, bitd, [], [], mynet)
yield n.start()
wb = work.WorkerBridge(node=n,
my_pubkey_hash=42,
donation_percentage=2,
merged_urls=[('http://127.0.0.1:%i' %
(mm_port.getHost().port, ), '')],
worker_fee=3,
args=math.Object(donation_percentage=2,
address='foo',
worker_fee=3,
timeaddresses=1000),
pubkeys=main.keypool(),
dcrd=bitd)
web_root = resource.Resource()
worker_interface.WorkerInterface(wb).attach_to(web_root)
port = reactor.listenTCP(0, server.Site(web_root))
proxy = jsonrpc.HTTPProxy(
'http://127.0.0.1:' + str(port.getHost().port),
headers=dict(Authorization='Basic ' +
base64.b64encode('user/0:password')))
yield deferral.sleep(3)
for i in xrange(100):
blah = yield proxy.rpc_getwork()
yield proxy.rpc_getwork(blah['data'])
yield deferral.sleep(3)
assert len(n.tracker.items) == 100
assert n.tracker.verified.get_height(n.best_share_var.value) == 100
wb.stop()
n.stop()
yield port.stopListening()
del n, wb, web_root, port, proxy
import gc
gc.collect()
gc.collect()
gc.collect()
yield deferral.sleep(20) # waiting for work_poller to exit
yield mm_port.stopListening()
def test_node(self):
mm_root = resource.Resource()
mm_root.putChild('', jsonrpc.Server(mm_provider))
mm_port = reactor.listenTCP(0, server.Site(mm_root))
n = node.Node(factory, bitcoind, [], [], mynet)
yield n.start()
wb = work.WorkerBridge(node=n,
my_pubkey_hash=42,
donation_percentage=2,
merged_urls=[('http://127.0.0.1:%i' %
(mm_port.getHost().port, ), '')],
worker_fee=3)
web_root = resource.Resource()
worker_interface.WorkerInterface(wb).attach_to(web_root)
port = reactor.listenTCP(0, server.Site(web_root))
proxy = jsonrpc.Proxy('http://127.0.0.1:' + str(port.getHost().port))
yield deferral.sleep(3)
for i in xrange(100):
blah = yield proxy.rpc_getwork()
yield proxy.rpc_getwork(blah['data'])
yield deferral.sleep(3)
assert len(n.tracker.items) == 100
assert n.tracker.verified.get_height(n.best_share_var.value) == 100
wb.stop()
n.stop()
yield port.stopListening()
del n, wb, web_root, port, proxy
import gc
gc.collect()
gc.collect()
gc.collect()
yield deferral.sleep(20) # waiting for work_poller to exit
yield mm_port.stopListening()
def main(args, net, datadir_path, worker_endpoint):
try:
print 'p2pool (version %s)' % (p2pool.__version__, )
print
@defer.inlineCallbacks
def connect_p2p(): # TODO: fix unknown type no type for 'getminings'
# connect to dcrd over decred-p2p
print '''Testing dcrd P2P connection to '%s:%s'...''' % (
args.dcrd_address, args.dcrd_p2p_port)
factory = decred_p2p.ClientFactory(net.PARENT)
reactor.connectTCP(args.dcrd_address, args.dcrd_p2p_port, factory)
def long():
print ''' ...taking a while. Common reasons for this include all of dcrd's connection slots being used...'''
long_dc = reactor.callLater(5, long)
yield factory.getProtocol() # waits until handshake is successful
if not long_dc.called: long_dc.cancel()
print ' ...success!'
print
defer.returnValue(factory)
if args.testnet: # establish p2p connection first if testnet so dcrd can work without connections
factory = yield connect_p2p()
# connect to dcrd over JSON-RPC and do initial getmemorypool
url = '%s://%s:%i/' % ('http' if args.dcrd_no_rpc_ssl else 'https',
args.dcrd_address, args.dcrd_rpc_port)
print '''Testing dcrd RPC connection to '%s' with username '%s'...''' % (
url, args.dcrd_rpc_username)
dcrd = jsonrpc.HTTPProxy(
url,
dict(Authorization='Basic ' +
base64.b64encode(args.dcrd_rpc_username + ':' +
args.dcrd_rpc_password)),
timeout=30)
yield helper.check(dcrd, net)
temp_work = yield helper.getwork(dcrd)
dcrd_getinfo_var = variable.Variable(None)
@defer.inlineCallbacks
def poll_warnings():
dcrd_getinfo_var.set(
(yield deferral.retry('Error while calling getinfo:')(
dcrd.rpc_getinfo)()))
yield poll_warnings()
deferral.RobustLoopingCall(poll_warnings).start(20 * 60)
print ' ...success!'
print ' Current block hash: {0:x}'.format(
temp_work['previous_block'])
print ' Current block height: {}'.format(temp_work['height'] - 1)
print
if not args.testnet:
factory = yield connect_p2p()
if args.pubkey_hash is None:
#
# Connect to locally running dcrwallet instance
#
# - TODO: find out if we use any other wallet api's apart from the 'getaccountaddress' below.
# If not we can:
# - make this self contained then remove the connection
# OR
# - remove all wallet connection logic and demand an address on the commandline
#
# wallet separate
# 9111/19111
walleturl = '%s://%s:%i/' % ('http' if args.dcrd_no_rpc_ssl else
'https', args.dcrd_address,
args.dcrd_rpc_wallet_port)
print '''Testing dcrdwallet RPC connection to '%s' with username '%s'...''' % (
walleturl, args.dcrd_rpc_username)
dcrwallet = jsonrpc.HTTPProxy(
walleturl,
dict(Authorization='Basic ' +
base64.b64encode(args.dcrd_rpc_username + ':' +
args.dcrd_rpc_password)),
timeout=30)
wallet_online = yield helper.checkwallet(dcrwallet, net)
print 'Determining payout address...'
pubkeys = keypool()
if args.pubkey_hash is None:
address_path = os.path.join(datadir_path, 'cached_payout_address')
if os.path.exists(address_path):
with open(address_path, 'rb') as f:
address = f.read().strip('\r\n')
print ' Loaded cached address: %s...' % (address, )
else:
address = None
if address is None and wallet_online:
print ' Getting payout address from local dcrwallet...not a great idea...'
address = yield deferral.retry('Error getting payout address from local dcrwallet:', 5) \
(lambda: dcrwallet.rpc_getaccountaddress('default'))()
with open(address_path, 'wb') as f:
f.write(address)
if address is None:
raise Exception('Failed to get an address from local wallet')
my_pubkey_hash = decred_addr.address_to_pubkey_hash(
address, net.PARENT)
pubkeys.addkey(my_pubkey_hash)
print ' ...success! Payout address:', address, 'pubkey hash', my_pubkey_hash
print
else:
my_pubkey_hash = args.pubkey_hash
print ' ...success! Payout address:', decred_addr.pubkey_hash_to_address(
my_pubkey_hash, net.PARENT)
print
pubkeys.addkey(my_pubkey_hash)
print "Loading shares..."
shares = {}
known_verified = set()
def share_cb(share):
share.time_seen = 0 # XXX
shares[share.hash] = share
if len(shares) % 1000 == 0 and shares:
print " %i" % (len(shares), )
ss = p2pool_data.ShareStore(os.path.join(datadir_path, 'shares.'), net,
share_cb, known_verified.add)
print " ...done loading %i shares (%i verified)!" % (
len(shares), len(known_verified))
print
print 'Initializing work...'
node = p2pool_node.Node(factory, dcrd, shares.values(), known_verified,
net)
yield node.start()
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)
node.tracker.removed.watch(lambda share: ss.forget_share(share.hash))
node.tracker.verified.removed.watch(
lambda share: ss.forget_verified_share(share.hash))
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)
deferral.RobustLoopingCall(save_shares).start(60)
print ' ...success!'
print
print 'Joining p2pool network using port %i...' % (args.p2pool_port, )
@defer.inlineCallbacks
def parse(host):
port = net.P2P_PORT
if ':' in host:
host, port_str = host.split(':')
port = int(port_str)
defer.returnValue(((yield reactor.resolve(host)), port))
addrs = {}
if os.path.exists(os.path.join(datadir_path, 'addrs')):
try:
with open(os.path.join(datadir_path, 'addrs'), 'rb') as f:
addrs.update(
dict((tuple(k), v) for k, v in json.loads(f.read())))
except:
print >> sys.stderr, 'error parsing addrs'
for addr_df in map(parse, net.BOOTSTRAP_ADDRS):
try:
addr = yield addr_df
if addr not in addrs:
addrs[addr] = (0, time.time(), time.time())
except:
log.err()
connect_addrs = set()
for addr_df in map(parse, args.p2pool_nodes):
try:
connect_addrs.add((yield addr_df))
except:
log.err()
node.p2p_node = p2pool_node.P2PNode(
node,
port=args.p2pool_port,
max_incoming_conns=args.p2pool_conns,
addr_store=addrs,
connect_addrs=connect_addrs,
desired_outgoing_conns=args.p2pool_outgoing_conns,
advertise_ip=args.advertise_ip,
external_ip=args.p2pool_external_ip,
)
node.p2p_node.start()
def save_addrs():
with open(os.path.join(datadir_path, 'addrs'), 'wb') as f:
f.write(json.dumps(node.p2p_node.addr_store.items()))
deferral.RobustLoopingCall(save_addrs).start(60)
print ' ...success!'
print
if args.upnp:
@defer.inlineCallbacks
def upnp_thread():
while True:
try:
is_lan, lan_ip = yield ipdiscover.get_local_ip()
if is_lan:
pm = yield portmapper.get_port_mapper()
yield pm._upnp.add_port_mapping(
lan_ip, args.p2pool_port, args.p2pool_port,
'p2pool', 'TCP')
except defer.TimeoutError:
pass
except:
if p2pool.DEBUG:
log.err(None, 'UPnP error:')
yield deferral.sleep(random.expovariate(1 / 120))
upnp_thread()
# start listening for workers with a JSON-RPC server
print 'Listening for workers on %r port %i...' % (worker_endpoint[0],
worker_endpoint[1])
wb = work.WorkerBridge(node, my_pubkey_hash, args.donation_percentage,
args.worker_fee, args, pubkeys, dcrd)
web_root = web.get_web_root(wb, datadir_path, dcrd_getinfo_var)
caching_wb = worker_interface.CachingWorkerBridge(wb)
worker_interface.WorkerInterface(caching_wb).attach_to(
web_root, get_handler=lambda request: request.redirect('/static/'))
web_serverfactory = server.Site(web_root)
serverfactory = switchprotocol.FirstByteSwitchFactory(
{'{': stratum.StratumServerFactory(caching_wb)}, web_serverfactory)
deferral.retry('Error binding to worker port:', traceback=False)(
reactor.listenTCP)(worker_endpoint[1],
serverfactory,
interface=worker_endpoint[0])
with open(os.path.join(os.path.join(datadir_path, 'ready_flag')),
'wb') as f:
pass
print ' ...success!'
print
# done!
print 'Started successfully!'
print 'Go to http://127.0.0.1:%i/ to view graphs and statistics!' % (
worker_endpoint[1], )
if args.donation_percentage > 1.1:
print '''Donating %.1f%% of work towards P2Pool's development. Thanks for the tip!''' % (
args.donation_percentage, )
elif args.donation_percentage < .9:
print '''Donating %.1f%% of work towards P2Pool's development. Please donate to encourage further development of P2Pool!''' % (
args.donation_percentage, )
else:
print '''Donating %.1f%% of work towards P2Pool's development. Thank you!''' % (
args.donation_percentage, )
print 'You can increase this amount with --give-author argument! (or decrease it, if you must)'
print
if hasattr(signal, 'SIGALRM'):
signal.signal(
signal.SIGALRM, lambda signum, frame: reactor.callFromThread(
sys.stderr.write, 'Watchdog timer went off at:\n' + ''.
join(traceback.format_stack())))
signal.siginterrupt(signal.SIGALRM, False)
deferral.RobustLoopingCall(signal.alarm, 30).start(1)
# if args.irc_announce:
# from twisted.words.protocols import irc
# class IRCClient(irc.IRCClient):
# nickname = 'p2pool%02i' % (random.randrange(100),)
# channel = net.ANNOUNCE_CHANNEL
# def lineReceived(self, line):
# if p2pool.DEBUG:
# 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(), decred_addr.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 = 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:
# self.recent_messages.pop(0)
# def privmsg(self, user, channel, message):
# if channel == self.channel:
# self._remember_message(message)
# def connectionLost(self, reason):
# node.tracker.verified.added.unwatch(self.watch_id)
# print 'IRC connection lost:', reason.getErrorMessage()
# class IRCClientFactory(protocol.ReconnectingClientFactory):
# protocol = IRCClient
# reactor.connectTCP("irc.freenode.net", 6667, IRCClientFactory(), bindAddress=(worker_endpoint[0], 0))
@defer.inlineCallbacks
def status_thread():
last_str = None
last_time = 0
while True:
yield deferral.sleep(3)
try:
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(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()
my_att_s = sum(datum['work'] / dt for datum in datums)
my_shares_per_s = sum(
datum['work'] / dt /
decred_data.target_to_average_attempts(
datum['share_target']) for datum in datums)
this_str += '\n Local: %sH/s in last %s Local dead on arrival: %s Expected time to share: %s' % (
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(1 / my_shares_per_s)
if my_shares_per_s else '???',
)
if height > 2:
(stale_orphan_shares,
stale_doa_shares), shares, _ = wb.get_stale_counts()
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)
paystr = ''
paytot = 0.0
for i in range(len(pubkeys.keys)):
curtot = node.get_current_txouts().get(
decred_addr.pubkey_hash_to_script2(
pubkeys.keys[i]), 0)
paytot += curtot * 1e-8
paystr += "(%.4f)" % (curtot * 1e-8, )
paystr += "=%.4f" % (paytot, )
this_str += '\n Shares: %i (%i orphan, %i dead) Stale rate: %s Efficiency: %s Current payout: %s %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)),
paystr,
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 / node.dcrd_work.value['bits'].target /
real_att_s),
)
for warning in p2pool_data.get_warnings(
node.tracker, node.best_share_var.value, net,
dcrd_getinfo_var.value, node.dcrd_work.value):
print >> sys.stderr, '#' * 40
print >> sys.stderr, '>>> Warning: ' + warning
print >> sys.stderr, '#' * 40
if gc.garbage:
print '%i pieces of uncollectable cyclic garbage! Types: %r' % (
len(gc.garbage), map(type, gc.garbage))
if this_str != last_str or time.time() > last_time + 15:
print this_str
last_str = this_str
last_time = time.time()
except:
log.err()
status_thread()
except:
reactor.stop()
log.err(None, 'Fatal error:')
