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])