def launch_memory_usage_server(port = 8080): import cherrypy import dowser cherrypy.tree.mount(dowser.Root()) cherrypy.config.update({'envoronment':'embedded', 'server.socket_port':port}) cherrypy.engine.start()
def start(port): cherrypy.tree.mount(dowser.Root()) cherrypy.config.update({ 'environment': 'embedded', 'server.socket_port': port }) cherrypy.engine.start()
def start(port): cherrypy.tree.mount(dowser.Root()) cherrypy.config.update({ "environment": "embedded", "server.socket_port": port }) cherrypy.engine.start()
def start(port): cherrypy.config.update({ 'environment': 'embedded', 'server.socket_port': port, 'server.socket_host': '0.0.0.0', }) cherrypy.tree.mount(dowser.Root()) # cherrypy.server.quickstart() cherrypy.engine.start()
def start_profiling(): import cherrypy import dowser cherrypy.tree.mount(dowser.Root()) cherrypy.config.update({ 'environment': 'embedded', 'server.socket_host': '0.0.0.0', 'server.socket_port': 8484, }) cherrypy.engine.start()
def _startDowser(self): try: import cherrypy import dowser cherrypy.config.update({'server.socket_port': 8080}) cherrypy.tree.mount(dowser.Root()) cherrypy.engine.start() self.dowserStatus.SetLabel('Dowser is running') return True except: print_exc() return False
class MDRoot(object): """The root application of pyFF. The root application assembles the MDStats and WellKnown classes with an MDServer instance. """ def __init__(self, server): self.server = server self._well_known.server = server self.discovery.server = server stats = MDStats() discovery = SHIBDiscovery() if config.devel_memory_profile: try: # pragma: nocover import dowser memory = dowser.Root() except ImportError: memory = NotImplementedFunction('Memory profiling needs dowser') _well_known = WellKnown() static = cherrypy.tools.staticdir.handler("/static", os.path.join(site_dir, "static")) @cherrypy.expose def status(self): status = "loading" if self.server.ready: status = "running" version = pkg_resources.require("pyFF")[0].version cherrypy.response.headers['Content-Type'] = 'application/json' return dumps({'status': status, 'version': version}) @cherrypy.expose def shutdown(self): cfg = cherrypy.request.app.config['global'] if 'allow_shutdown' in cfg and bool(cfg.get('allow_shutdown')): from threading import Timer Timer(3, cherrypy.engine.exit, ()).start() return "bye ..." else: # pragma: nocover raise cherrypy.HTTPError(403, _("Endpoint disabled in configuration")) @cherrypy.expose @cherrypy.tools.expires(secs=3600, debug=True) def robots_txt(self): """Returns a robots.txt that disables all robots. """ return """ User-agent: * Disallow: / """ @cherrypy.expose() @cherrypy.tools.expires(secs=3600, debug=True) def storage(self): """ The crossdomain storage hub iframe """ entity_id = cherrypy.request.params.get('entity_id') return render_template("storage.html") @cherrypy.expose def favicon_ico(self): """Returns the pyff icon (the alchemic symbol for sublimation). """ cherrypy.response.headers['Content-Type'] = 'image/x-icon' return resource_string('favicon.ico', "site/static/icons") @cherrypy.expose def entities(self, path=None): """Process an MDX request with Content-Type hard-coded to application/xml. Regardless of the suffix you will get XML back from /entities/... """ return self.server.request(path=path, content_type="application/xml") @cherrypy.expose def metadata(self, path=None): """The main request entry point. Any requests are subject to content negotiation based on Accept headers and based on file name extension. Requesting /metadata/foo.xml gets you (signed) XML (assuming your pipeline contains that mode), requesting /metadata/foo.json gets you json, and /metadata/foo.ds gets you a discovery interface based on the IdPs found in 'foo'. Here 'foo' is any supported lookup expression. """ return self.server.request(path=path) @cherrypy.expose def about(self): """The 'about' page. Contains links to statistics etc. """ import pkg_resources # part of setuptools version = pkg_resources.require("pyFF")[0].version return render_template("about.html", version=version, cversion=cherrypy.__version__, sysinfo=" ".join(os.uname()), cmdline=" ".join(sys.argv), stats=stats, repo=self.server.md, plumbings=self.server.plumbings) @cherrypy.expose def reset(self): """The /reset page clears all local browser settings for the device. After visiting this page users of the discovery service will see a "new device" page. """ return render_template("reset.html") @cherrypy.expose def settings(self): """The /settings page documents the (non) use of cookies. """ return render_template("settings.html") @cherrypy.expose def search(self, paged=False, query=None, page=0, page_limit=10, entity_filter=None, related=None): """ Search the active set for matching entities. :param paged: page the result when True :param query: the string query :param page: the page to return of the paged result :param page_limit: the number of result per page :param entity_filter: an optional filter to apply to the active set before searching :param related: an optional '+'-separated list of related domain names for prioritizing search results :return: a JSON-formatted search result """ cherrypy.response.headers['Content-Type'] = 'application/json' if paged: res, more, total = self.server.md.search( query, page=int(page), page_limit=int(page_limit), entity_filter=entity_filter, related=related) return dumps({'entities': res, 'more': more, 'total': total}) else: return dumps( self.server.md.search(query, entity_filter=entity_filter, related=related)) @cherrypy.expose def index(self): """Alias for /metadata """ return self.server.request() @cherrypy.expose def default(self, *args, **kwargs): """The default request processor unpacks base64-encoded reuqests and passes them onto the MDServer.request handler. """ # log.debug("ROOT default args: %s, kwargs: %s" % (repr(args), repr(kwargs))) if len(args) > 0 and args[0] in self.server.aliases: kwargs['pfx'] = args[0] if len(args) > 1: kwargs['path'] = args[1] return self.server.request(**kwargs) else: kwargs['pfx'] = None kwargs['path'] = "/" + "/".join(args) return self.server.request(**kwargs)
def __init__( self, config ): self.config = Config( config ) self.users = UserStore( config ) self.pools = PoolStore( config, self.users ) self.admins = AdminStore( config ) self.getwork = GetWork( self.pools, self.config['pool']['defaultPool'] ) console = logging.StreamHandler() formatter = logging.Formatter('%(asctime)s: %(name)s - %(levelname)s - %(message)s') console.setFormatter( formatter ) logging.getLogger('').addHandler( console ) LEVELS = { 'debug': logging.DEBUG, 'info': logging.INFO, 'warning': logging.WARNING, 'error': logging.ERROR, 'critical': logging.CRITICAL } #if "logFile" in self.config: # fileHandler = logging.FileHandle( str( self.config['logFile'] ) ) # fileHandler.setFormatter( formatter ) # logging.getLogger('').addHandler( fileHandler ) self.logger = logging.getLogger( "PoolManager" ) try: self.logger.setLevel( LEVELS[self.config['logLevel']] ) except: self.logger.setLevel( logging.ERROR ) self.logger.info( "PoolManager Started" ) self.logger.info( "Creating Tornado Applications" ) self.longpoll = LongPoll( self.pools, "triplemining.com" ) #TODO: Make this configurable self.threadpool = ThreadPool( 20 ) self.getworkApp = tornado.web.Application( [ (r"/", GetWorkHandler ), ( r"/LP", LongPollHandler ) ] ) self.getworkApp.pools = self.pools self.getworkApp.users = self.users self.getworkApp.getwork = self.getwork self.getworkApp.poolname = self.config['pool']['defaultPool'] self.getworkApp.longpoll = self.longpoll self.getworkApp.threadpool = self.threadpool self.logger.info( "Creating HTTPServers for the Web interfave and the pool backend." ) self.getworkServer = tornado.httpserver.HTTPServer(self.getworkApp) settings = { "cookie_secret": base64.b64encode(uuid.uuid4().bytes + uuid.uuid4().bytes), "login_url": "/login" } dowser_app = WSGIContainer( cherrypy.tree.mount( dowser.Root() , '/dowser' ) ) self.frontendApp = tornado.web.Application( [ ( r"/", DefaultHandler ), ( r"/getusers", DefaultHandler ), ( r"/getpools", DefaultHandler ), ( r"/admin(/[\w\d\+%]+)?", AdminHandler ), ( r"/login", LoginHandler ), ( r"/pool/([\w\d\.\+ %]+)", PoolHandler ), (r"/dowser.*", tornado.web.FallbackHandler ) #( r"/memory", MemoryDisplayHandler, dict( hp=self.hp ) ) ], **settings ) self.frontendApp.pools = self.pools self.frontendApp.users = self.users self.frontendApp.admins = self.admins self.frontendApp.getwork = self.getwork self.frontendApp.poolname = self.config['pool']['defaultPool'] self.frontendServer = tornado.httpserver.HTTPServer( self.frontendApp ) self.logger.info( "Pool Running On Port ( %d )", self.config['pool']['port'] ) self.getworkServer.listen( self.config['pool']['port'] ) self.logger.info( "Web Interface Running On Port ( %d )", self.config['http']['port'] ) self.frontendServer.listen( self.config['http']['port'] ) self.logger.info( "Starting IOLoop" ) tornado.ioloop.IOLoop.instance().start()