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