def createRestApi():
"""Create the REST API URL hierarchy"""
siteRoot = RootNode()
jobWrapper = guard.HTTPAuthSessionWrapper(Portal(JobRealm(), [JobDBChecker(db)]), [guard.BasicCredentialFactory("thundercloud job management")])
siteRoot.putChild("job", jobWrapper)
# slave tree needs specific authentication
slaveWrapper = guard.HTTPAuthSessionWrapper(Portal(SlaveRealm(), [SlaveDBChecker(db)]), [guard.BasicCredentialFactory("thundercloud slave management")])
siteRoot.putChild("slave", slaveWrapper)
return server.Site(siteRoot)
def wrapResource(resource, checkers, credFactories=[], realmName=""):
defaultCredFactory = guard.BasicCredentialFactory(realmName)
credFactories.insert(0, defaultCredFactory)
realm = HTTPAuthRealm(resource)
portal = Portal(realm, checkers)
return guard.HTTPAuthSessionWrapper(portal, credFactories)
def __init__(self, dbPassFile, realm):
self.wrapper = guard.HTTPAuthSessionWrapper(
Portal(realm, [FilePasswordDB(dbPassFile)]), [
guard.DigestCredentialFactory(
'md5',
'Authentication required for CS437 - XML Web Data Pub/Sub')
])
def __init__(self):
super().__init__()
self._success = SuccessfulResource()
self._timeout = TimeoutResource()
checkers = [InMemoryUsernamePasswordDatabaseDontUse(user = b"user")]
portal = Portal(SimpleRealm(), checkers)
self._auth_resource = guard.HTTPAuthSessionWrapper(portal, [guard.BasicCredentialFactory("auth")])
def main():
log.startLogging(sys.stdout)
checkers = [InMemoryUsernamePasswordDatabaseDontUse(joe='blow')]
wrapper = guard.HTTPAuthSessionWrapper(
Portal(SimpleRealm(), checkers),
[guard.DigestCredentialFactory('md5', 'example.com')])
reactor.listenTCP(8889, server.Site(resource=wrapper))
reactor.run()
def create_auth_session(root):
pw_path = os.path.join(conf.settings['data_dir'], ".api_keys")
initialize_api_key_file(pw_path)
checker = PasswordChecker.load_file(pw_path)
realm = HttpPasswordRealm(root)
portal_to_realm = portal.Portal(realm, [checker, ])
factory = guard.BasicCredentialFactory('Login to lbrynet api')
_lbrynet_server = guard.HTTPAuthSessionWrapper(portal_to_realm, [factory, ])
return _lbrynet_server
def makeWrapper(guarded, username, pwd):
checkerList = [
checkers.InMemoryUsernamePasswordDatabaseDontUse(**{username: pwd})
]
realm = SimpleRealm(guarded)
myPortal = portal.Portal(realm, checkerList)
webGuard = guard.BasicCredentialFactory("nanoauto")
wrapper = guard.HTTPAuthSessionWrapper(myPortal, [webGuard])
return wrapper
def main(root):
log.startLogging(sys.stdout)
checkers = [InMemoryUsernamePasswordDatabaseDontUse(**USERS)]
wrapper = guard.HTTPAuthSessionWrapper(
Portal(SimpleRealm(root), checkers),
[guard.DigestCredentialFactory('md5', 'whatever.com')])
reactor.listenSSL(443, server.Site(resource=wrapper),
contextFactory=sslContext)
reactor.run()
def _wrapTwistedWebResource(resource,
checkers,
credFactories=[],
realmName=""):
if not web:
raise ImportError("twisted.web does not seem to be installed.")
from twisted.web import guard
defaultCredFactory = guard.BasicCredentialFactory(realmName)
credFactories.insert(0, defaultCredFactory)
realm = HTTPAuthRealm(resource)
portal = Portal(realm, checkers)
return guard.HTTPAuthSessionWrapper(portal, credFactories)
def main():
log.startLogging(sys.stdout)
# TBD: get the admin password from an environment variable
credCheckers = [InMemoryUsernamePasswordDatabaseDontUse(admin='secret')]
wrapper = guard.HTTPAuthSessionWrapper(
Portal(AdministrativeRealm(), credCheckers),
[guard.DigestCredentialFactory('md5', 'suse.com')])
reactor.listenTCP(8889, server.Site(resource = wrapper))
reactor.run()
def getServerFactory(self):
if conf.settings['use_auth_http']:
log.info("Using authenticated API")
pw_path = os.path.join(conf.settings['data_dir'], ".api_keys")
initialize_api_key_file(pw_path)
checker = PasswordChecker.load_file(pw_path)
realm = HttpPasswordRealm(self)
portal_to_realm = portal.Portal(realm, [checker, ])
factory = guard.BasicCredentialFactory('Login to lbrynet api')
root = guard.HTTPAuthSessionWrapper(portal_to_realm, [factory, ])
else:
log.info("Using non-authenticated API")
root = self
return server.Site(root)
def setupProtectedResource(self, resource_obj, checkers):
@implementer(IRealm)
class SimpleRealm(object):
"""
A realm which gives out L{ChangeHookResource} instances for authenticated
users.
"""
def requestAvatar(self, avatarId, mind, *interfaces):
if resource.IResource in interfaces:
return (resource.IResource, resource_obj, lambda: None)
raise NotImplementedError()
portal = Portal(SimpleRealm(), checkers)
credentialFactory = guard.BasicCredentialFactory('Protected area')
wrapper = guard.HTTPAuthSessionWrapper(portal, [credentialFactory])
return wrapper
def getServerFactory(self, keyring: Keyring, use_authentication: bool,
use_https: bool) -> server.Site:
factory_class = HTTPSJSONRPCFactory if use_https else HTTPJSONRPCFactory
if use_authentication:
log.info("Using authenticated API")
checker = PasswordChecker(keyring)
realm = HttpPasswordRealm(self)
portal_to_realm = portal.Portal(realm, [
checker,
])
root = guard.HTTPAuthSessionWrapper(portal_to_realm, [
guard.BasicCredentialFactory('Login to lbrynet api'),
])
else:
log.info("Using non-authenticated API")
root = self
return factory_class(root, keyring)
def createSite(configuration):
resource = static.File("./WWW")
resource.putChild("API", API())
if configuration["LOCAL_SERVER"]["AUTHENTICATION"]["USERNAME"] != "":
realm = HTTPRealm(resource)
checkers = [HTTPUsernamePasswordCredentialsChecker(configuration)]
credentialFactories = [guard.BasicCredentialFactory("JAP")]
resource = guard.HTTPAuthSessionWrapper(portal.Portal(realm, checkers),
credentialFactories)
site = server.Site(resource)
return site
def main():
# log
log.startLogging(sys.stdout)
# checkers = [InMemoryUsernamePasswordDatabaseDontUse(joe='blow')]
checkers = [FilePasswordDB('httpd.password')]
portal = Portal(SimpleRealm(), checkers)
credFactory = [guard.DigestCredentialFactory('md5', 'example.com')]
wrapper = guard.HTTPAuthSessionWrapper(portal, credFactory)
factory = server.Site(resource=wrapper)
reactor.listenTCP(8889, factory)
reactor.run()
def setupProtectedResource(self, resource_obj):
class SimpleRealm(object):
"""
A realm which gives out L{ChangeHookResource} instances for authenticated
users.
"""
implements(IRealm)
def requestAvatar(self, avatarId, mind, *interfaces):
if resource.IResource in interfaces:
return (resource.IResource, resource_obj, lambda: None)
raise NotImplementedError()
login, password = self.change_hook_auth
checker = InMemoryUsernamePasswordDatabaseDontUse()
checker.addUser(login, password)
portal = Portal(SimpleRealm(), [checker])
credentialFactory = guard.BasicCredentialFactory('Protected area')
wrapper = guard.HTTPAuthSessionWrapper(portal, [credentialFactory])
return wrapper
def getConfigResource():
creds = {settings.config["web"]["user"]: settings.config["web"]["sesame"]}
checker = checkers.InMemoryUsernamePasswordDatabaseDontUse(**creds)
configPortal = portal.Portal(ConfigRealm(), [checker])
factory = guard.DigestCredentialFactory("md5", "config")
return guard.HTTPAuthSessionWrapper(configPortal, [factory])
def requestAvatar(self, avatarId, mind, *interfaces):
if resource.IResource in interfaces:
return resource.IResource, http_root, lambda: None
raise NotImplementedError()
def cmp_pass(uname, password, storedpass):
sizeof_hash = len(storedpass)
if sizeof_hash == 13:
return crypt.crypt(password, storedpass[:2])
else:
return util.get_apache_md5(password, storedpass)
checkers = [FilePasswordDB(options.htpasswd_file, hash=cmp_pass)]
wrapper = guard.HTTPAuthSessionWrapper(Portal(
SimpleRealm(), checkers), [guard.BasicCredentialFactory('qasino.com')])
ssl_site = server.Site(wrapper)
try:
if not os.path.isfile(options.htpasswd_file):
raise Exception("htpasswd file '%s' does not exist" %
options.htpasswd_file)
reactor.listenSSL(
constants.HTTPS_PORT, ssl_site,
ssl.DefaultOpenSSLContextFactory(options.keys_dir + 'server.key',
options.keys_dir + 'server.crt'))
except Exception as e:
logging.info(
def initialize_server(self, name, server_type, port, print_frames=False):
if name not in self.servers:
if server_type == 'sle_protocol':
self.servers[name] = CommonProviderProtocolFactory(
self, print_frames)
elif server_type == 'sle_stateless_protocol':
self.servers[name] = CommonStatelessProviderProtocolFactory(
self, print_frames)
elif server_type == 'json_data_protocol':
self.servers[name] = DataProviderProtocolFactory(
self, print_frames)
elif server_type in ['https_rest_protocol', 'http_rest_protocol']:
checkers = [
FilePasswordDB('http.password',
delim=b'=',
hash=check_hashed_password)
]
realm = Realm()
realm.initialize(self, configurable_sle_parameters, commands)
portal = Portal(realm, checkers)
resource = guard.HTTPAuthSessionWrapper(
portal, [guard.BasicCredentialFactory('auth')])
self.servers[name] = Site(resource)
elif server_type in [
'https_no_auth_rest_protocol', 'http_no_auth_rest_protocol'
]:
root = RestfulManager()
root.container = self
root.sle_config = configurable_sle_parameters
root.commands = commands
self.servers[name] = Site(root.app.resource())
else:
logger.error(
"Server type {} does not exist!".format(server_type))
return False
if port not in self.ports.values():
if server_type in [
'https_rest_protocol', 'https_no_auth_rest_protocol'
]:
with open('server.pem') as f:
cert_data = f.read()
self.certificate = ssl.PrivateCertificate.loadPEM(
cert_data)
self.connectors.update({
name:
reactor.listenSSL(port, self.servers[name],
self.certificate.options())
})
else:
self.connectors.update(
{name: reactor.listenTCP(port, self.servers[name])})
self.ports.update({name: port})
logger.info("{} with {} is now running on port: {}".format(
name, server_type, port))
return True
else:
logger.error("Port {} already used!".format(port))
return False
else:
logger.error("Server with name {} already exists!".format(name))
return False
def postCallback(self, jobId, request):
jobNodeWrapper = guard.HTTPAuthSessionWrapper(
Portal(JobNodeRealm(), [JobNodeDBChecker(db, jobId)]),
[guard.BasicCredentialFactory("thundercloud job #%d" % jobId)])
self.putChild("%d" % jobId, jobNodeWrapper)
self.writeJson(request, jobId)
def main(args, net, datadir_path, merged_urls, worker_endpoint):
try:
print 'p2pool (version %s)' % (p2pool.__version__, )
print
@defer.inlineCallbacks
def connect_p2p():
# connect to bitcoind over bitcoin-p2p
print '''Testing bitcoind P2P connection to '%s:%s'...''' % (
args.bitcoind_address, args.bitcoind_p2p_port)
factory = bitcoin_p2p.ClientFactory(net.PARENT)
reactor.connectTCP(args.bitcoind_address, args.bitcoind_p2p_port,
factory)
def long():
print ''' ...taking a while. Common reasons for this include all of bitcoind'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 bitcoind can work without connections
factory = yield connect_p2p()
# connect to bitcoind over JSON-RPC and do initial getmemorypool
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.HTTPProxy(
url,
dict(Authorization='Basic ' +
base64.b64encode(args.bitcoind_rpc_username + ':' +
args.bitcoind_rpc_password)),
timeout=30)
yield helper.check(bitcoind, net, args)
temp_work = yield helper.getwork(bitcoind)
bitcoind_getnetworkinfo_var = variable.Variable(None)
@defer.inlineCallbacks
def poll_warnings():
bitcoind_getnetworkinfo_var.set(
(yield deferral.retry('Error while calling getnetworkinfo:')(
bitcoind.rpc_getnetworkinfo)()))
yield poll_warnings()
deferral.RobustLoopingCall(poll_warnings).start(20 * 60)
print ' ...success!'
print
print ' Current block hash: %x' % (temp_work['previous_block'], )
print ' Current block height: %i' % (temp_work['height'] - 1, )
print
if not args.testnet:
factory = yield connect_p2p()
print 'Determining payout address...'
pubkeys = keypool()
if args.pubkey_hash is None and args.address != 'dynamic':
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 not None:
# check address validity
res = yield deferral.retry(
'Error validating cached address:',
5)(lambda: bitcoind.rpc_validateaddress(address))()
if not res['isvalid']:
print ' Cached address is invalid!'
address = None
else:
# check address belongs to local bitcoind
res = yield deferral.retry(
'Error validating cached address:',
5)(lambda: bitcoind.rpc_getaddressinfo(address))()
if not res['ismine']:
print ' Cached address is not controlled by local bitcoind!'
address = None
if address is None:
print ' Getting payout address from bitcoind...'
address = yield deferral.retry(
'Error getting payout address from bitcoind:',
5)(lambda: bitcoind.rpc_getaccountaddress('p2pool'))()
with open(address_path, 'wb') as f:
f.write(address)
my_pubkey_hash = bitcoin_data.address_to_pubkey_hash(
address, net.PARENT)
print ' ...success! Payout address:', bitcoin_data.pubkey_hash_to_address(
my_pubkey_hash, net.PARENT)
print
pubkeys.addkey(my_pubkey_hash)
elif args.address != 'dynamic':
my_pubkey_hash = args.pubkey_hash
print ' ...success! Payout address:', bitcoin_data.pubkey_hash_to_address(
my_pubkey_hash, net.PARENT)
print
pubkeys.addkey(my_pubkey_hash)
else:
print ' Entering dynamic address mode.'
if args.numaddresses < 2:
print ' ERROR: Can not use fewer than 2 addresses in dynamic mode. Resetting to 2.'
args.numaddresses = 2
for i in range(args.numaddresses):
address = yield deferral.retry(
'Error getting a dynamic address from bitcoind:',
5)(lambda: bitcoind.rpc_getnewaddress('p2pool'))()
new_pubkey = bitcoin_data.address_to_pubkey_hash(
address, net.PARENT)
pubkeys.addkey(new_pubkey)
pubkeys.updatestamp(time.time())
my_pubkey_hash = pubkeys.keys[0]
for i in range(len(pubkeys.keys)):
print ' ...payout %d: %s' % (
i,
bitcoin_data.pubkey_hash_to_address(
pubkeys.keys[i], net.PARENT),
)
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\r" % (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...'
global gnode
gnode = node = p2pool_node.Node(factory, bitcoind, 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)
if len(shares) > net.CHAIN_LENGTH:
best_share = shares[node.best_share_var.value]
previous_share = shares[
best_share.share_data['previous_share_hash']]
counts = p2pool_data.get_desired_version_counts(
node.tracker,
node.tracker.get_nth_parent_hash(previous_share.hash,
net.CHAIN_LENGTH * 9 // 10),
net.CHAIN_LENGTH // 10)
p2pool_data.update_min_protocol_version(counts, best_share)
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])
# Mining worker bridge
wb = work.WorkerBridge(node, my_pubkey_hash, args.donation_percentage,
merged_urls, args.worker_fee, args, pubkeys,
bitcoind)
# Web server start
web_root = web.get_web_root(wb,
datadir_path,
bitcoind_getnetworkinfo_var,
static_dir=args.web_static)
# simple auth implementation
@implementer(IRealm)
class SimpleRealm(object):
"""
A realm which gives out L{GuardedResource} instances for authenticated
users.
"""
def requestAvatar(self, avatarId, mind, *interfaces):
root = IResource
if root in interfaces:
return IResource, web_root, lambda: None
raise NotImplementedError()
# worker bridge should not require passwords
caching_wb = worker_interface.CachingWorkerBridge(wb)
worker_interface.WorkerInterface(caching_wb).attach_to(
web_root, get_handler=lambda request: request.redirect(
'/static/')) # / to /static redirect
checkers = [FilePasswordDB('httpd.password')]
portal = Portal(SimpleRealm(), checkers)
credFactory = [guard.DigestCredentialFactory('md5', 'c2pool.bit')]
wrapper = guard.HTTPAuthSessionWrapper(portal, credFactory)
web_serverfactory = server.Site(resource=wrapper)
# stratum
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(),
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 = 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(30)
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 /
bitcoin_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(
bitcoin_data.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.bitcoind_work.value['bits'].target /
real_att_s),
)
for warning in p2pool_data.get_warnings(
node.tracker, node.best_share_var.value, net,
bitcoind_getnetworkinfo_var.value,
node.bitcoind_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:')
def guardResourceWithBasicAuth(resource, realm, db):
checker = checkers.InMemoryUsernamePasswordDatabaseDontUse(**db)
logPortal = portal.Portal(BasicAuthRealm(resource), [checker])
credentialFactory = guard.BasicCredentialFactory(
"%s:%s" % (config.log.http.vhost, config.log.http.port))
return guard.HTTPAuthSessionWrapper(logPortal, [credentialFactory])
def simple_guard_resource(root):
checkers = [InMemoryUsernamePasswordDatabaseDontUse(fk='test')]
wrapper = guard.HTTPAuthSessionWrapper(
Portal(SimpleRealm(root), checkers),
[guard.DigestCredentialFactory('md5', 'frikanalen.no')])
return wrapper
def main():
# setup logging
log.startLogging(open(conf.get('general', 'common_log'), 'a'),
setStdout=False)
acclog = AccountingLogObserver(
open(conf.get('general', 'accounting_log'), 'a'))
log.addObserver(acclog.emit)
# load backends
load_blob_backends()
load_mq_backends()
load_ds_backends()
load_authn_conf()
# initialize backends
vcdm.env['ds'] = vcdm.datastore_backends[conf.get('general',
'ds.backend')]()
# load all backends
for blob_backend in conf.get('general', 'blob.backends').split(','):
blob_backend = blob_backend.strip()
log.msg("Activating %s backend." % blob_backend)
backend_type = conf.get(blob_backend, 'type')
vcdm.env['blobs'][blob_backend] = vcdm.blob_backends[backend_type](
blob_backend)
# set default
def_backend = conf.get('general', 'blob.default.backend')
print "Setting default backend to %s (%s)" % (
def_backend, conf.get(def_backend, 'type'))
vcdm.env['blob'] = vcdm.env['blobs'][def_backend]
# initiate accounting logging
task.LoopingCall(vcdm.blob.get_stored_size_all_avatars). \
start(conf.getfloat('general', 'accounting.total_frequency')) #in seconds
# do we want queue backend? just a single one at the moment
if conf.getboolean('general', 'support_mq'):
vcdm.env['mq'] = vcdm.mq_backends[conf.get('general', 'mq.backend')]()
current_capabilities.system['queues'] = True
interface_for_binding = conf.get('general',
'server.endpoint').split(":")[0]
authn_methods, used_checkers = vcdm.env['authn_methods']
wrapper = guard.HTTPAuthSessionWrapper(
Portal(SimpleRealm(), used_checkers), authn_methods)
print "Binding to interface %s" % interface_for_binding
# unencrypted/unprotected connection for testing/development
if conf.getboolean('general', 'server.use_debug_port'):
from vcdm.server.cdmi.root import RootCDMIResource
reactor.listenTCP(conf.getint('general', 'server.debug_port', 2364),
server.Site(resource=RootCDMIResource()),
interface=interface_for_binding)
reactor.listenTCP(conf.getint('general', 'server.debug_port_authn',
2365),
server.Site(resource=wrapper),
interface=interface_for_binding)
# 1-way SSL for production
from twisted.internet import ssl
sslContext = ssl.DefaultOpenSSLContextFactory(
conf.get('general', 'server.credentials.key'),
conf.get('general', 'server.credentials.cert'))
reactor.listenSSL(int(
conf.get('general', 'server.endpoint').split(":")[1]),
server.Site(resource=wrapper),
contextFactory=sslContext,
interface=interface_for_binding)
reactor.run()
def _getAuthSessionWrapper(self, realm, msg):
checker = checkers.FilePasswordDB(self._htpasswd)
p = portal.Portal(realm, [checker])
f = guard.DigestCredentialFactory('md5', msg)
f.digest = BugfixedDigest('md5', msg)
return guard.HTTPAuthSessionWrapper(p, [f])
