def register_aggregator(aggregator): web_aggregator = server.Site(WebCookieAggregator(aggregator)) reactor.listenTCP(settings.WEB_AGGREGATOR_PORT, web_aggregator)
def main(): """ The main event loop that starts the server and configures it. """ usage = "usage: %prog [options]" parser = OptionParser(usage) parser.add_option( "-p", "--port", help="Port the HTTP server listens to for the GitHub Service Hook" + " [default: %default]", default=4000, type=int, dest="port") parser.add_option( "-m", "--buildmaster", help="Buildbot Master host and port. ie: localhost:9989 [default:" + " %default]", default="localhost:9989", dest="buildmaster") parser.add_option( "-l", "--log", help="The absolute path, including filename, to save the log to" + " [default: %default]", default=tempfile.gettempdir() + "/github_buildbot.log", dest="log") parser.add_option( "-L", "--level", help="The logging level: debug, info, warn, error, fatal [default:" + " %default]", default='warn', dest="level") parser.add_option( "-g", "--github", help="The github server. Changing this is useful if you've specified" + " a specific HOST handle in ~/.ssh/config for github " + "[default: %default]", default='github.com', dest="github") parser.add_option( "--pidfile", help="Write the process identifier (PID) to this file on start." + " The file is removed on clean exit. [default: %default]", default=None, dest="pidfile") (options, _) = parser.parse_args() if options.pidfile: with open(options.pidfile, 'w') as f: f.write(str(os.getpid())) levels = { 'debug': logging.DEBUG, 'info': logging.INFO, 'warn': logging.WARNING, 'error': logging.ERROR, 'fatal': logging.FATAL, } filename = options.log log_format = "%(asctime)s - %(levelname)s - %(message)s" logging.basicConfig(filename=filename, format=log_format, level=levels[options.level]) github_bot = GitHubBuildBot() github_bot.github = options.github github_bot.master = options.buildmaster site = server.Site(github_bot) reactor.listenTCP(options.port, site) reactor.run() if options.pidfile and os.path.exists(options.pidfile): os.unlink(options.pidfile)
params = namedParameters() port = params.get('socket', 8080) if 'twisted' in params: from twisted.web import server from twisted.web.wsgi import WSGIResource from twisted.python.threadpool import ThreadPool from twisted.python import log from twisted.internet import reactor from twisted.application import service, strports # Create and start a thread pool, wsgiThreadPool = ThreadPool() wsgiThreadPool.start() # ensuring that it will be stopped when the reactor shuts down reactor.addSystemEventTrigger('after', 'shutdown', wsgiThreadPool.stop) reactor.listenTCP( port, server.Site(WSGIResource(reactor, wsgiThreadPool, wsgi_application))) log.startLogging(log.FileLogObserver(sys.stderr)) reactor.run() else: import wsgiref, wsgiref.simple_server httpd = wsgiref.simple_server.make_server('', port, wsgi_application) httpd.serve_forever()
def setUp(self): xmlrpc = Test() addIntrospection(xmlrpc) self.p = reactor.listenTCP(0, server.Site(xmlrpc),interface="127.0.0.1") self.port = self.p.getHost().port self.factories = []
# See the License for the specific language governing permissions and # limitations under the License. """ a very simple json echo server """ from twswebrpc import JSONResource from twisted.internet import reactor from twisted.web import server def serve_echo(value): return value def serve_add(a, b): return a + b jsonServerResource = JSONResource() jsonServerResource.add_method('echo', serve_echo) jsonServerResource.add_method('add', serve_add) serverSite = server.Site(jsonServerResource) # listen to available ips at port 1080 reactor.listenTCP(1080, serverSite) print 'launch simpleechoclient.py or simpleechoclient_tester.py for test ' reactor.run()
def __init__(self, reactor, top, note_dirty, read_only_dbs, writable_db, http_endpoint, ws_endpoint, root_cap, title): self.__http_port = http_endpoint self.__ws_port = ws_endpoint self.__ws_protocol = txws.WebSocketFactory( OurStreamFactory(top, root_cap)) # Roots of resource trees # - appRoot is everything stateful/authority-bearing # - serverRoot is the HTTP '/' and static resources are placed there serverRoot = _make_static(staticResourcePath) if root_cap is None: appRoot = serverRoot self.__visit_path = '/' else: serverRoot = _make_static(staticResourcePath) appRoot = _SlashedResource() serverRoot.putChild(root_cap, appRoot) self.__visit_path = '/' + urllib.quote(root_cap, safe='') + '/' # UI entry point appRoot.putChild('', _RadioIndexHtmlResource(title)) # Exported radio control objects appRoot.putChild('radio', BlockResource(top, note_dirty, notDeletable)) # Frequency DB appRoot.putChild('dbs', shinysdr.db.DatabasesResource(read_only_dbs)) appRoot.putChild('wdb', shinysdr.db.DatabaseResource(writable_db)) # Debug graph appRoot.putChild('flow-graph', FlowgraphVizResource(reactor, top)) # Construct explicit resources for merge. test = _reify(serverRoot, 'test') jasmine = _reify(test, 'jasmine') for name in ['jasmine.css', 'jasmine.js', 'jasmine-html.js']: jasmine.putChild( name, static.File( os.path.join(os.path.dirname(__file__), 'deps/jasmine/lib/jasmine-core/', name))) client = _reify(serverRoot, 'client') client.putChild( 'require.js', static.File( os.path.join(os.path.dirname(__file__), 'deps/require.js'))) # Plugin resources load_list_css = [] load_list_js = [] plugin_resources = Resource() client.putChild('plugins', plugin_resources) for resource_def in getPlugins(IClientResourceDef, shinysdr.plugins): # Add the plugin's resource to static serving plugin_resources.putChild(resource_def.key, resource_def.resource) plugin_resource_url = '/client/plugins/' + urllib.quote( resource_def.key, safe='') + '/' # Tell the client to load the plugins # TODO constrain path values to be relative if resource_def.load_css_path is not None: load_list_css.append(plugin_resource_url + resource_def.load_cs_path) if resource_def.load_js_path is not None: # TODO constrain value to be in the directory load_list_js.append(plugin_resource_url + resource_def.load_js_path) # Client plugin list client.putChild( 'plugin-index.json', static.Data( _serialize({ u'css': load_list_css, u'js': load_list_js, }).encode('utf-8'), 'application/json')) self.__site = server.Site(serverRoot) self.__ws_port_obj = None self.__http_port_obj = None
def createServer(self, resource): self.p = reactor.listenTCP( 0, server.Site(resource), interface="127.0.0.1") self.addCleanup(self.p.stopListening) self.port = self.p.getHost().port self.proxy = xmlrpc.Proxy('http://127.0.0.1:%d' % self.port)
def register_resources(self, args: Namespace) -> None: from hathor.conf import HathorSettings from hathor.mining.ws import MiningWebsocketFactory from hathor.p2p.resources import AddPeersResource, MiningInfoResource, MiningResource, StatusResource from hathor.prometheus import PrometheusMetricsExporter from hathor.resources import ProfilerResource from hathor.transaction.resources import ( CreateTxResource, DashboardTransactionResource, DecodeTxResource, GetBlockTemplateResource, GraphvizFullResource, GraphvizNeighboursResource, PushTxResource, SubmitBlockResource, TipsHistogramResource, TipsResource, TransactionAccWeightResource, TransactionResource, TxParentsResource, ValidateAddressResource, ) from hathor.version_resource import VersionResource from hathor.wallet.resources import ( AddressResource, BalanceResource, HistoryResource, LockWalletResource, SendTokensResource, SignTxResource, StateWalletResource, UnlockWalletResource, ) from hathor.wallet.resources.nano_contracts import ( NanoContractDecodeResource, NanoContractExecuteResource, NanoContractMatchValueResource, ) from hathor.wallet.resources.thin_wallet import ( AddressBalanceResource, AddressHistoryResource, AddressSearchResource, SendTokensResource as SendTokensThinResource, TokenHistoryResource, TokenResource, ) from hathor.websocket import HathorAdminWebsocketFactory, WebsocketStatsResource settings = HathorSettings() if args.prometheus: kwargs: Dict[str, Any] = {'metrics': self.manager.metrics} if args.data: kwargs['path'] = os.path.join(args.data, 'prometheus') else: raise ValueError( 'To run prometheus exporter you must have a data path') prometheus = PrometheusMetricsExporter(**kwargs) prometheus.start() if args.status: # TODO get this from a file. How should we do with the factory? root = Resource() wallet_resource = Resource() root.putChild(b'wallet', wallet_resource) thin_wallet_resource = Resource() root.putChild(b'thin_wallet', thin_wallet_resource) contracts_resource = Resource() wallet_resource.putChild(b'nano-contract', contracts_resource) p2p_resource = Resource() root.putChild(b'p2p', p2p_resource) graphviz = Resource() # XXX: reach the resource through /graphviz/ too, previously it was a leaf so this wasn't a problem graphviz.putChild(b'', graphviz) for fmt in ['dot', 'pdf', 'png', 'jpg']: bfmt = fmt.encode('ascii') graphviz.putChild( b'full.' + bfmt, GraphvizFullResource(self.manager, format=fmt)) graphviz.putChild( b'neighbours.' + bfmt, GraphvizNeighboursResource(self.manager, format=fmt)) resources = ( (b'status', StatusResource(self.manager), root), (b'version', VersionResource(self.manager), root), (b'create_tx', CreateTxResource(self.manager), root), (b'decode_tx', DecodeTxResource(self.manager), root), (b'validate_address', ValidateAddressResource(self.manager), root), (b'push_tx', PushTxResource(self.manager), root), (b'graphviz', graphviz, root), (b'tips-histogram', TipsHistogramResource(self.manager), root), (b'tips', TipsResource(self.manager), root), (b'transaction', TransactionResource(self.manager), root), (b'transaction_acc_weight', TransactionAccWeightResource(self.manager), root), (b'dashboard_tx', DashboardTransactionResource(self.manager), root), (b'profiler', ProfilerResource(self.manager), root), # mining (b'mining', MiningResource(self.manager), root), (b'getmininginfo', MiningInfoResource(self.manager), root), (b'get_block_template', GetBlockTemplateResource(self.manager), root), (b'submit_block', SubmitBlockResource(self.manager), root), (b'tx_parents', TxParentsResource(self.manager), root), # /thin_wallet (b'address_history', AddressHistoryResource(self.manager), thin_wallet_resource), (b'address_balance', AddressBalanceResource(self.manager), thin_wallet_resource), (b'address_search', AddressSearchResource(self.manager), thin_wallet_resource), (b'send_tokens', SendTokensThinResource(self.manager), thin_wallet_resource), (b'token', TokenResource(self.manager), thin_wallet_resource), (b'token_history', TokenHistoryResource(self.manager), thin_wallet_resource), # /wallet/nano-contract (b'match-value', NanoContractMatchValueResource(self.manager), contracts_resource), (b'decode', NanoContractDecodeResource(self.manager), contracts_resource), (b'execute', NanoContractExecuteResource(self.manager), contracts_resource), # /p2p (b'peers', AddPeersResource(self.manager), p2p_resource), ) for url_path, resource, parent in resources: parent.putChild(url_path, resource) if self.manager.stratum_factory is not None: from hathor.stratum.resources import MiningStatsResource root.putChild(b'miners', MiningStatsResource(self.manager)) if self.wallet and args.wallet_enable_api: wallet_resources = ( # /wallet (b'balance', BalanceResource(self.manager), wallet_resource ), (b'history', HistoryResource(self.manager), wallet_resource), (b'address', AddressResource(self.manager), wallet_resource), (b'send_tokens', SendTokensResource(self.manager), wallet_resource), (b'sign_tx', SignTxResource(self.manager), wallet_resource), (b'unlock', UnlockWalletResource(self.manager), wallet_resource), (b'lock', LockWalletResource(self.manager), wallet_resource), (b'state', StateWalletResource(self.manager), wallet_resource), ) for url_path, resource, parent in wallet_resources: parent.putChild(url_path, resource) # Websocket resource ws_factory = HathorAdminWebsocketFactory( metrics=self.manager.metrics, wallet_index=self.manager.tx_storage.wallet_index) ws_factory.start() root.putChild(b'ws', WebSocketResource(ws_factory)) # Mining websocket resource mining_ws_factory = MiningWebsocketFactory(self.manager) root.putChild(b'mining_ws', WebSocketResource(mining_ws_factory)) ws_factory.subscribe(self.manager.pubsub) # Websocket stats resource root.putChild(b'websocket_stats', WebsocketStatsResource(ws_factory)) real_root = Resource() real_root.putChild(settings.API_VERSION_PREFIX.encode('ascii'), root) status_server = server.Site(real_root) reactor.listenTCP(args.status, status_server) # Set websocket factory in metrics self.manager.metrics.websocket_factory = ws_factory
else: req.setResponseCode(400) return json.dumps({ 'success': False, 'error': 'no data parameter' }).encode() if __name__ == '__main__': import argparse parser = argparse.ArgumentParser( description='Launch an OpenDHT node with an HTTP control interface') parser.add_argument('-p', '--port', help='OpenDHT port to bind', type=int, default=4222) parser.add_argument('-hp', '--http-port', help='HTTP port to bind', type=int, default=8080) parser.add_argument('-b', '--bootstrap', help='bootstrap address', default="bootstrap.ring.cx:4222") args = parser.parse_args() endpoints.serverFromString(reactor, "tcp:" + str(args.http_port)).listen( server.Site(DhtServer(args.port, args.bootstrap))) reactor.run()
#!/usr/bin/env python from __future__ import print_function from twisted.internet import reactor from twisted.internet.endpoints import serverFromString from twisted.web import server, static serverFromString(reactor, "onion:80").listen( server.Site(static.Data("Hello, world!", "text/plain")) ).addCallback(print) reactor.run()
def render_GET(self, request): return "redis: %s\n" % repr(self.db) class XmlrpcHandler(BaseHandler, xmlrpc.XMLRPC): allowNone = True @defer.inlineCallbacks def xmlrpc_get(self, key): value = yield self.db.get(key) defer.returnValue(value) @defer.inlineCallbacks def xmlrpc_set(self, key, value): result = yield self.db.set(key, value) defer.returnValue(result) # redis connection _db = redis.lazyConnectionPool() # http resources root = Root() root.putChild("", IndexHandler(_db)) root.putChild("info", InfoHandler(_db)) root.putChild("xmlrpc", XmlrpcHandler(_db)) application = service.Application("webredis") srv = internet.TCPServer(8888, server.Site(root), interface="127.0.0.1") srv.setServiceParent(application)
data = request.content.getvalue().decode('utf-8') msg = 'POST处理结果' if (path == '/func' or path == '/func1/'): msg = myFunc1(2, 3) #print('POST...path=', path) # path= b'/this/is' if post to url 'http://127.0.0.1:12347/this/is?a=1&b=2' #print('arg=', args) # arg= {'a': ['de中啊文fg'], 'd': ['20190722']} #print('post data:', data) res = { 'method': 'POST', 'path': path, 'args': args, 'data': data, 'out': msg } res['dec_data'] = parse.unquote(data) retstr = json.dumps(res, ensure_ascii=False) return retstr.encode('utf-8') if __name__ == '__main__': # 监听的端口号 port = 9601 site = server.Site(Server()) endpoint = endpoints.TCP4ServerEndpoint(reactor, port) endpoint.listen(site) print('READY at port ', port) reactor.run()
# Start a django-compatible webserver. from twisted.python import threadpool from src.server.webserver import DjangoWebRoot, WSGIWebServer # start a thread pool and define the root url (/) as a wsgi resource # recognized by Django threads = threadpool.ThreadPool(minthreads=max(1, settings.WEBSERVER_THREADPOOL_LIMITS[0]), maxthreads=max(1, settings.WEBSERVER_THREADPOOL_LIMITS[1])) web_root = DjangoWebRoot(threads) # point our media resources to url /media web_root.putChild("media", static.File(settings.MEDIA_ROOT)) # point our static resources to url /static web_root.putChild("static", static.File(settings.STATIC_ROOT)) web_site = server.Site(web_root, logPath=settings.HTTP_LOG_FILE) for proxyport, serverport in WEBSERVER_PORTS: # create the webserver (we only need the port for this) webserver = WSGIWebServer(threads, serverport, web_site, interface='127.0.0.1') webserver.setName('EvenniaWebServer%s' % serverport) EVENNIA.services.addService(webserver) print " webserver: %s" % serverport ENABLED = [] if IRC_ENABLED: # IRC channel connections ENABLED.append('irc') if IMC2_ENABLED:
class IndexPage(resource.Resource): def __init__(self, wikiData): self.wikiData = wikiData resource.Resource.__init__(self) def render(self, request): pages = self.wikiData.listPages() pages.sort() links = ["<li><a href='%s'>%s</a></li>" % (p, p) for p in pages] return """ <html> <head><title>Wiki Index</title></head> <body> <a href='/'>Home</a> <h1>Index</h1> <body> <ul> %s </ul> </body> </html> """ % "".join(links) if __name__ == '__main__': import sys from twisted.internet import reactor wikiData = WikiData(sys.argv[1]) reactor.listenTCP(8082, server.Site(RootResource(wikiData))) reactor.run()
# -*- coding:utf-8 –*- from twisted.web import server, resource from twisted.internet import reactor class MainResource(resource.Resource): isLeaf = True # 用于处理GET类型请求 def render_GET(self, request): # name参数 name = 'World' if request.args.has_key('name'): name = request.args['name'][0] # 设置响应编码 request.responseHeaders.addRawHeader("Content-Type", "text/html; charset=utf-8") # 响应的内容直接返回 return "<html><body>Hello, " + name + "</body></html>" site = server.Site(MainResource()) reactor.listenTCP(8080, site) reactor.run()
# Copyright (c) 2001-2004 Twisted Matrix Laboratories. # See LICENSE for details. from twisted.internet import reactor from twisted.web import proxy, server site = server.Site(proxy.ReverseProxyResource('www.yahoo.com', 80, '')) reactor.listenTCP(8080, site) reactor.run()
PORT = 8080 def delayed_render(request, name): request.write("Hello %s, sorry about the delay." % name) request.finish() class HelloResource(resource.Resource): isLeaf = True def render_GET(self, request): # Check that the 'name' URL param was passed. name = request.args.get('name', None) if name is None: return resource.ErrorPage(400, "Bad Request", "Missing 'name' param.").render(request) name = name[0] delay_seconds = 2 print "Delaying for %s seconds." % delay_seconds # Delay requires a callback reactor.callLater(delay_seconds, delayed_render, request, name) return NOT_DONE_YET reactor.listenTCP(PORT, server.Site(HelloResource())) print "Listening on http://localhost:%s" % PORT reactor.run()
# # ep0: # launch a new Tor instance, configure a hidden service on some # port and pubish descriptor for port 80 # ep1: # connect to existing Tor via control-port 9051, configure a hidden # service listening locally on 8080, publish a descriptor for port # 80 and use an explicit hiddenServiceDir (where "hostname" and # "private_key" files are put by Tor). We set SOCKS port # explicitly, too. # ep2: # all the same as ep1, except we launch a new Tor (because no # "controlPort=9051") # ep0 = "onion:80" ep1 = "onion:80:controlPort=9051:localPort=8080:socksPort=9089:hiddenServiceDir=/home/human/src/txtorcon/hidserv" ep2 = "onion:80:localPort=8080:socksPort=9089:hiddenServiceDir=/home/human/src/txtorcon/hidserv" hs_endpoint = serverFromString(reactor, ep0) txtorcon.IProgressProvider(hs_endpoint).add_progress_listener(progress) # create our Web server and listen on the endpoint; this does the # actual launching of (or connecting to) tor. site = server.Site(Simple()) d = hs_endpoint.listen(site) d.addCallback(setup_complete) d.addErrback(setup_failed) reactor.run()
def main(): from twisted.internet import reactor from twisted.web import server r = Echoer() reactor.listenTCP(7080, server.Site(r)) reactor.run()
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) yield factory.getProtocol() # waits until handshake is successful 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) temp_work = yield helper.getwork(bitcoind) bitcoind_warning_var = variable.Variable(None) @defer.inlineCallbacks def poll_warnings(): errors = (yield deferral.retry('Error while calling getmininginfo:')( bitcoind.rpc_getmininginfo)())['errors'] bitcoind_warning_var.set(errors if errors != '' else None) yield poll_warnings() task.LoopingCall(poll_warnings).start(20 * 60) print ' ...success!' 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...' pubkey_path = os.path.join(datadir_path, 'cached_payout_pubkey') if os.path.exists(pubkey_path): with open(pubkey_path, 'rb') as f: pubkey = f.read().strip('\r\n') print ' Loaded cached pubkey, payout address: %s...' % ( bitcoin_data.pubkey_to_address(pubkey.decode('hex'), net.PARENT), ) else: pubkey = None if pubkey is not None: res = yield deferral.retry( 'Error validating cached pubkey:', 5)(lambda: bitcoind.rpc_validatepubkey(pubkey))() if not res['isvalid'] or not res['ismine']: print ' Cached pubkey is either invalid or not controlled by local bitcoind!' address = None if pubkey is None: print ' Getting payout pubkey from bitcoind...' pubkey = yield deferral.retry( 'Error getting payout pubkey from bitcoind:', 5)(lambda: bitcoind.rpc_getnewpubkey('p2pool'))() with open(pubkey_path, 'wb') as f: f.write(pubkey) my_pubkey = pubkey.decode('hex') address = bitcoin_data.pubkey_to_address(my_pubkey, net.PARENT) 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 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': contents.time_seen = 0 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 " ...done loading %i shares (%i verified)!" % ( len(shares), len(known_verified)) print print 'Initializing work...' 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) 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)) 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 print 'Joining p2pool network using port %i...' % (args.p2pool_port, ) @defer.inlineCallbacks def parse(x): if ':' in x: ip, port = x.split(':') defer.returnValue(((yield reactor.resolve(ip)), int(port))) else: defer.returnValue(((yield reactor.resolve(x)), net.P2P_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, ) 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())) task.LoopingCall(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, args.donation_percentage, merged_urls, args.worker_fee) web_root = web.get_web_root(wb, datadir_path, bitcoind_warning_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) task.LoopingCall(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()) @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) 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(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( 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)), node.get_current_txouts().get( bitcoin_data.pubkey_to_script2(my_pubkey), 0) * 1e-6, 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_warning_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 setUp(self): self.p = reactor.listenTCP(0, server.Site(TestAuthHeader()), interface="127.0.0.1") self.port = self.p.getHost().port self.factories = []
def setUp(self): portal = MaayPortal(WebappConfiguration()) portal.registerChecker(FakeChecker(portal.realm)) rpcserver = server.Site(rpc.MaayRPCServer(portal)) self.p = reactor.listenTCP(0, rpcserver, interface="127.0.0.1") self.port = self.p.getHost().port
#don't provide enabled which will implicitly disable the genome query_args = { 'status': 'error', 'verbose_error': json.dumps(val), 'index_version': tmap_version } encoded_args = urllib.urlencode(query_args) url = 'http://localhost/configure/references/genome/status/' + id url_read = urllib2.urlopen(url, encoded_args).read() logger.debug(url_read) shutil.rmtree(temp_path) if __name__ == '__main__': try: logger.info("ionJobServer Started Ver: %s" % __version__) execService = ProcessExecutionService() aq = AnalysisQueue(settings.ANALYSIS_ROOT) aq.loop() r = AnalysisServer(aq, execService) reactor.callLater(0, r.execService.startService) reactor.listenTCP(settings.JOBSERVER_PORT, server.Site(r)) reactor.run() except Exception as err: logger.exception("Job Server run-time failure.")
def factory(self, *args, **kwargs): return server.Site(resource.Resource(), *args, **kwargs)
def getAppService(port, interface): root = resource.Resource() root.putChild("liveness", Liveness()) root.putChild("readiness", Readiness()) site = server.Site(root) return internet.TCPServer(port, site, interface=interface)
def createServer(self, r): chan = DummyChannel() chan.site = server.Site(r) return chan
def startXMLRPC(control_point, port): from twisted.web import server r = XMLRPC(control_point) print(f'XMLRPC-API on port {port:d} ready') reactor.listenTCP(port, server.Site(r))
from debianpackage import DebianBuildManager from slave import XMLRPCBuildDSlave conffile = os.environ.get("SHUTTLE_SLAVE_CONFIG", "shuttle-slave-example.conf") conf = ConfigParser() conf.read(conffile) slave = XMLRPCBuildDSlave(conf) slave.registerBuilder(DebianBuildManager, "debian") application = service.Application("BuildSlave") builddslaveService = service.IServiceCollection(application) root = resource.Resource() root.putChild("rpc", slave) root.putChild("filecache", static.File(conf.get('slave', 'filecache'))) is_twistd = False if is_twistd: slavesite = server.Site(root) strports.service(slave.slave._config.get("slave", "bindport"), slavesite).setServiceParent(builddslaveService) else: from twisted.internet import reactor from twisted.web.server import Site factory = Site(root) reactor.listenTCP(slave.slave._config.getint("slave", "bindport"), factory) reactor.run()
if __name__ == '__main__': # Set up logging logger = logging.getLogger('similarity') logger.setLevel(logging.DEBUG) handler = RotatingFileHandler(LOGFILE_INDEXING_SERVER, maxBytes=2 * 1024 * 1024, backupCount=5) handler.setLevel(logging.DEBUG) std_handler = logging.StreamHandler() std_handler.setLevel(logging.DEBUG) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) logger.addHandler(handler) std_handler.setFormatter(formatter) logger.addHandler(std_handler) handler_graypy = graypy.GELFHandler('10.55.0.48', 12201) logger.addHandler(handler_graypy) # Start service logger.info('Configuring similarity INDEXING service...') root = resource.Resource() root.putChild("similarity", SimilarityServer()) site = server.Site(root) reactor.listenTCP(INDEXING_SERVER_LISTEN_PORT, site) logger.info('Started similarity INDEXING service, listening to port ' + str(INDEXING_SERVER_LISTEN_PORT) + "...") reactor.run() logger.info('Service stopped.')
from twisted.application import internet, service from twisted.web import server from scripts import resources app = service.MultiService() web_root = resources.Root('./web') web_root.putChild('crypt', resources.Crypt()) web_factory = server.Site(web_root) web_service = internet.TCPServer(8081, web_factory, interface='0.0.0.0') web_service.setServiceParent(app) application = service.Application("ansible-vault") app.setServiceParent(application)