settings = c.parse() if settings == False: print >> sys.stderr, "Configuration file not found, Please give a valid configuration file" showhelp(1) if verbosity != False: settings["verbosity"] = verbosity if "verbosity" not in settings: settings["verbosity"] = 0 #Pick the bot engine if ("protocol" not in settings) or (settings["protocol"] == "irc"): from bot import * #Set up the logging logger = Logger(settings["verbosity"]) #Set up the Web Server r = Resource() r.putChild('', logReader(logger)) webFactory = Site(r) reactor.listenTCP(8888, webFactory) #Set up the IRC Bot BotFactory = TwistedBotFactory(settings, config, logger, reactor) BotFactory.logger = logger reactor.connectTCP( settings["network"], 6667, TwistedBotFactory(settings, config, logger, reactor)) reactor.suggestThreadPoolSize(10) tbot.protocol = settings["protocol"] reactor.run() elif (settings["protocol"] == "xmpp"): from jabberbot import * logger = Logger(2)
from twisted.internet import reactor from twisted.web import proxy, server from twisted.web.resource import Resource class AppendingReverseProxyResource(proxy.ReverseProxyResource): def __init__(self, host, port, prefix, postfix, reactor=reactor): super(AppendingReverseProxyResource, self).__init__(self, host, port, prefix, reactor=reactor) self.path += postfix siteRoot = Resource() site = server.Site(siteRoot) port6001 = proxy.ReverseProxyResource('localhost', 6001, '') port7000 = proxy.ReverseProxyResource('localhost', 7000, '') port8000 = proxy.ReverseProxyResource('localhost', 8000, '') siteRoot.putChild("ui", port8000) siteRoot.putChild("slave", port7000) siteRoot.putChild("api", port6001) reactor.listenTCP(8080, site) reactor.run()
def setUp(self): self.pagename = b'' self.resource = server.JsonAPIResource() self.root = Resource() self.root.putChild(self.pagename, self.resource)
def __init__(self): self.resource = Resource() self.resource.putChild('send', SendMessage)
def _listener_http(self, config, listener_config): port = listener_config["port"] bind_addresses = listener_config["bind_addresses"] tls = listener_config.get("tls", False) site_tag = listener_config.get("tag", port) if tls and config.no_tls: return resources = {} for res in listener_config["resources"]: for name in res["names"]: if name == "client": client_resource = ClientRestResource(self) if res["compress"]: client_resource = gz_wrap(client_resource) resources.update({ "/_matrix/client/api/v1": client_resource, "/_matrix/client/r0": client_resource, "/_matrix/client/unstable": client_resource, "/_matrix/client/v2_alpha": client_resource, "/_matrix/client/versions": client_resource, }) if name == "federation": resources.update({ FEDERATION_PREFIX: TransportLayerServer(self), }) if name in ["static", "client"]: resources.update({ STATIC_PREFIX: File( os.path.join(os.path.dirname(synapse.__file__), "static")), }) if name in ["media", "federation", "client"]: media_repo = MediaRepositoryResource(self) resources.update({ MEDIA_PREFIX: media_repo, LEGACY_MEDIA_PREFIX: media_repo, CONTENT_REPO_PREFIX: ContentRepoResource(self, self.config.uploads_path), }) if name in ["keys", "federation"]: resources.update({ SERVER_KEY_PREFIX: LocalKey(self), SERVER_KEY_V2_PREFIX: KeyApiV2Resource(self), }) if name == "webclient": resources[ WEB_CLIENT_PREFIX] = build_resource_for_web_client( self) if name == "metrics" and self.get_config().enable_metrics: resources[METRICS_PREFIX] = MetricsResource(self) if WEB_CLIENT_PREFIX in resources: root_resource = RootRedirect(WEB_CLIENT_PREFIX) else: root_resource = Resource() root_resource = create_resource_tree(resources, root_resource) if tls: for address in bind_addresses: reactor.listenSSL(port, SynapseSite( "synapse.access.https.%s" % (site_tag, ), site_tag, listener_config, root_resource, ), self.tls_server_context_factory, interface=address) else: for address in bind_addresses: reactor.listenTCP(port, SynapseSite( "synapse.access.http.%s" % (site_tag, ), site_tag, listener_config, root_resource, ), interface=address) logger.info("Synapse now listening on port %d", port)
def start_webserver(options, protocol=wsl.ServerProtocol, disableLogging=False): """ Starts the web-server with the given protocol. Options must be an object with the following members: options.host : the interface for the web-server to listen on options.port : port number for the web-server to listen on options.timeout : timeout for reaping process on idle in seconds options.content : root for web-pages to serve. """ from twisted.internet import reactor from twisted.web.server import Site from twisted.web.static import File import sys if not disableLogging: # redirect twisted logs to python standard logging. observer = log.PythonLoggingObserver() observer.start() # log.startLogging(sys.stdout) # Set logging level. if (options.debug): logging.basicConfig(level=logging.DEBUG) else: logging.basicConfig(level=logging.ERROR) contextFactory = None use_SSL = False if options.sslKey and options.sslCert: use_SSL = True wsProtocol = "wss" from twisted.internet import ssl contextFactory = ssl.DefaultOpenSSLContextFactory(options.sslKey, options.sslCert) else: wsProtocol = "ws" # Create default or custom ServerProtocol wslinkServer = protocol() # create a wslink-over-WebSocket transport server factory transport_factory = wsl.TimeoutWebSocketServerFactory(\ url = "%s://%s:%d" % (wsProtocol, options.host, options.port), \ timeout = options.timeout ) transport_factory.protocol = wsl.WslinkWebSocketServerProtocol transport_factory.setServerProtocol(wslinkServer) root = Resource() # Do we serve static content or just websocket ? if len(options.content) > 0: # Static HTTP + WebSocket root = File(options.content) # Handle possibly complex ws endpoint if not options.nows: wsResource = WebSocketResource(transport_factory) handle_complex_resource_path(options.ws, root, wsResource) if options.uploadPath != None : from wslink.upload import UploadPage uploadResource = UploadPage(options.uploadPath) root.putChild("upload", uploadResource) if len(options.fsEndpoints) > 3: for fsResourceInfo in options.fsEndpoints.split('|'): infoSplit = fsResourceInfo.split('=') handle_complex_resource_path(infoSplit[0], root, File(infoSplit[1])) site = Site(root) if use_SSL: reactor.listenSSL(options.port, site, contextFactory) else: reactor.listenTCP(options.port, site) # flush ready line sys.stdout.flush() # Work around to force the output buffer to be flushed # This allow the process launcher to parse the output and # wait for "Start factory" to know that the WebServer # is running. if options.forceFlush : for i in range(200): log.msg("+"*80, logLevel=logging.CRITICAL) # Initialize testing: checks if we're doing a test and sets it up # testing.initialize(options, reactor, stop_webserver) reactor.callWhenRunning(print_ready) # Start the reactor if options.nosignalhandlers: reactor.run(installSignalHandlers=0) else: reactor.run()
def create_resource(self, path_config): """ Creates child resource to be added to the parent. :param path_config: Configuration for the new child resource. :type path_config: dict :returns: Resource -- the new child resource """ ## websocket_echo ## websocket_testee ## s3mirror ## websocket_stdio ## ## WAMP-WebSocket resource ## if path_config['type'] == 'websocket': ws_factory = CrossbarWampWebSocketServerFactory(self.session_factory, self.config.extra.cbdir, path_config, self._templates) ## FIXME: Site.start/stopFactory should start/stop factories wrapped as Resources ws_factory.startFactory() return WebSocketResource(ws_factory) ## Static file hierarchy resource ## elif path_config['type'] == 'static': static_options = path_config.get('options', {}) if 'directory' in path_config: static_dir = os.path.abspath(os.path.join(self.config.extra.cbdir, path_config['directory'])) elif 'package' in path_config: if not 'resource' in path_config: raise ApplicationError("crossbar.error.invalid_configuration", "missing resource") try: mod = importlib.import_module(path_config['package']) except ImportError as e: emsg = "ERROR: could not import resource '{}' from package '{}' - {}".format(path_config['resource'], path_config['package'], e) log.msg(emsg) raise ApplicationError("crossbar.error.invalid_configuration", emsg) else: try: static_dir = os.path.abspath(pkg_resources.resource_filename(path_config['package'], path_config['resource'])) except Exception as e: emsg = "ERROR: could not import resource '{}' from package '{}' - {}".format(path_config['resource'], path_config['package'], e) log.msg(emsg) raise ApplicationError("crossbar.error.invalid_configuration", emsg) else: raise ApplicationError("crossbar.error.invalid_configuration", "missing web spec") static_dir = static_dir.encode('ascii', 'ignore') # http://stackoverflow.com/a/20433918/884770 ## create resource for file system hierarchy ## if static_options.get('enable_directory_listing', False): static_resource = File(static_dir) else: static_resource = FileNoListing(static_dir) ## set extra MIME types ## static_resource.contentTypes.update(EXTRA_MIME_TYPES) if 'mime_types' in static_options: static_resource.contentTypes.update(static_options['mime_types']) patchFileContentTypes(static_resource) ## render 404 page on any concrete path not found ## static_resource.childNotFound = Resource404(self._templates, static_dir) return static_resource ## WSGI resource ## elif path_config['type'] == 'wsgi': if not _HAS_WSGI: raise ApplicationError("crossbar.error.invalid_configuration", "WSGI unsupported") wsgi_options = path_config.get('options', {}) if not 'module' in path_config: raise ApplicationError("crossbar.error.invalid_configuration", "missing module") if not 'object' in path_config: raise ApplicationError("crossbar.error.invalid_configuration", "missing object") try: mod = importlib.import_module(path_config['module']) except ImportError as e: raise ApplicationError("crossbar.error.invalid_configuration", "module import failed - {}".format(e)) else: if not path_config['object'] in mod.__dict__: raise ApplicationError("crossbar.error.invalid_configuration", "object not in module") else: app = getattr(mod, path_config['object']) ## create a Twisted Web WSGI resource from the user's WSGI application object try: wsgi_resource = WSGIResource(reactor, reactor.getThreadPool(), app) except Exception as e: raise ApplicationError("crossbar.error.invalid_configuration", "could not instantiate WSGI resource: {}".format(e)) else: return wsgi_resource ## Redirecting resource ## elif path_config['type'] == 'redirect': redirect_url = path_config['url'].encode('ascii', 'ignore') return RedirectResource(redirect_url) ## JSON value resource ## elif path_config['type'] == 'json': value = path_config['value'] return JsonResource(value) ## CGI script resource ## elif path_config['type'] == 'cgi': cgi_processor = path_config['processor'] cgi_directory = os.path.abspath(os.path.join(self.config.extra.cbdir, path_config['directory'])) cgi_directory = cgi_directory.encode('ascii', 'ignore') # http://stackoverflow.com/a/20433918/884770 return CgiDirectory(cgi_directory, cgi_processor, Resource404(self._templates, cgi_directory)) ## WAMP-Longpoll transport resource ## elif path_config['type'] == 'longpoll': path_options = path_config.get('options', {}) lp_resource = WampLongPollResource(self.session_factory, timeout = path_options.get('request_timeout', 10), killAfter = path_options.get('session_timeout', 30), queueLimitBytes = path_options.get('queue_limit_bytes', 128 * 1024), queueLimitMessages = path_options.get('queue_limit_messages', 100), debug = path_options.get('debug', False), debug_transport_id = path_options.get('debug_transport_id', None) ) lp_resource._templates = self._templates return lp_resource ## Pusher resource ## elif path_config['type'] == 'pusher': ## create a vanilla session: the pusher will use this to inject events ## pusher_session_config = ComponentConfig(realm = path_config['realm'], extra = None) pusher_session = ApplicationSession(pusher_session_config) ## add the pushing session to the router ## self.session_factory.add(pusher_session, authrole = path_config.get('role', 'anonymous')) ## now create the pusher Twisted Web resource ## return PusherResource(path_config.get('options', {}), pusher_session) ## Schema Docs resource ## elif path_config['type'] == 'schemadoc': realm = path_config['realm'] if not realm in self.realm_to_id: raise ApplicationError("crossbar.error.no_such_object", "No realm with URI '{}' configured".format(realm)) realm_id = self.realm_to_id[realm] realm_schemas = self.realms[realm_id].session._schemas return SchemaDocResource(self._templates, realm, realm_schemas) ## Nested subpath resource ## elif path_config['type'] == 'path': nested_paths = path_config.get('paths', {}) if '/' in nested_paths: nested_resource = self.create_resource(nested_paths['/']) else: nested_resource = Resource() ## nest subpaths under the current entry ## self.add_paths(nested_resource, nested_paths) return nested_resource else: raise ApplicationError("crossbar.error.invalid_configuration", "invalid Web path type '{}'".format(path_config['type']))
def registerEndpoints(args): root = Resource() root.putChild(b'', IndexResource()) root.putChild(b'metrics', VMWareMetricsResource(args)) root.putChild(b'healthz', HealthzResource()) return root
def start_webserver(options, protocol=vtk_wamp.ServerProtocol, disableLogging=False): """ Starts the web-server with the given protocol. Options must be an object with the following members: options.host : the interface for the web-server to listen on options.port : port number for the web-server to listen on options.timeout : timeout for reaping process on idle in seconds options.content : root for web-pages to serve. """ from twisted.internet import reactor from twisted.web.server import Site from twisted.web.static import File import sys if not disableLogging: log.startLogging(sys.stdout) contextFactory = None use_SSL = False if options.sslKey and options.sslCert: use_SSL = True wsProtocol = "wss" from twisted.internet import ssl contextFactory = ssl.DefaultOpenSSLContextFactory( options.sslKey, options.sslCert) else: wsProtocol = "ws" # Create WAMP router factory from autobahn.twisted.wamp import RouterFactory router_factory = RouterFactory() # create a user DB authdb = vtk_wamp.AuthDb() # create a WAMP router session factory from autobahn.twisted.wamp import RouterSessionFactory session_factory = RouterSessionFactory(router_factory) session_factory.session = vtk_wamp.CustomWampCraRouterSession session_factory.authdb = authdb # Create ApplicationSession and register protocols appSession = protocol(types.ComponentConfig(realm="vtkweb")) appSession.setAuthDB(authdb) session_factory.add(appSession) # create a WAMP-over-WebSocket transport server factory transport_factory = vtk_wamp.TimeoutWampWebSocketServerFactory(session_factory, \ url = "%s://%s:%d" % (wsProtocol, options.host, options.port), \ debug = options.debug, \ debug_wamp = options.debug, \ timeout = options.timeout ) root = Resource() # Do we serve static content or just websocket ? if len(options.content) > 0: # Static HTTP + WebSocket root = File(options.content) # Handle possibly complex ws endpoint if not options.nows: wsResource = WebSocketResource(transport_factory) handle_complex_resource_path(options.ws, root, wsResource) # Handle possibly complex lp endpoint if not options.nolp: lpResource = WampLongPollResource(session_factory) handle_complex_resource_path(options.lp, root, lpResource) if options.uploadPath != None: from upload import UploadPage uploadResource = UploadPage(options.uploadPath) root.putChild("upload", uploadResource) site = Site(root) if use_SSL: reactor.listenSSL(options.port, site, contextFactory) else: reactor.listenTCP(options.port, site) # Work around to force the output buffer to be flushed # This allow the process launcher to parse the output and # wait for "Start factory" to know that the WebServer # is running. if options.forceFlush: for i in range(200): log.msg("+" * 80, logLevel=logging.CRITICAL) # Initialize testing: checks if we're doing a test and sets it up testing.initialize(options, reactor, stop_webserver) # Start the reactor if options.nosignalhandlers: reactor.run(installSignalHandlers=0) else: reactor.run() # Give the testing module a chance to finalize, if necessary testing.finalize()
def setUp(self): self.pagename = '' self.indexResource = server.IndexResource() self.root = Resource() self.root.putChild(self.pagename, self.indexResource)
def setUp(self): self.pagename = 'howto.html' self.howtoResource = server.HowtoResource() self.root = Resource() self.root.putChild(self.pagename, self.howtoResource)
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( 'openlayers', static.File( os.path.join(os.path.dirname(__file__), 'deps/openlayers'))) 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( _json_encoder_for_values.encode({ 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 createService(sname, config): global monitor_threads, monitors, servicename try: application = connexion.FlaskApp(__name__, specification_dir='swagger/') flask_app = application.app flask_app.url_map.strict_slashes = False anchore_engine.subsys.metrics.init_flask_metrics( flask_app, servicename=servicename) application.add_api('swagger.yaml', validate_responses=False) except Exception as err: traceback.print_exc() raise err try: myconfig = config['services'][sname] servicename = sname except Exception as err: raise err try: kick_timer = int(myconfig['cycle_timer_seconds']) except: kick_timer = 1 doapi = False try: if myconfig['listen'] and myconfig['port'] and myconfig[ 'endpoint_hostname']: doapi = True except: doapi = False kwargs = {} kwargs['kick_timer'] = kick_timer kwargs['monitors'] = monitors kwargs['monitor_threads'] = monitor_threads kwargs['servicename'] = servicename if doapi: # start up flask service flask_site = WSGIResource(reactor, reactor.getThreadPool(), application=flask_app) realroot = Resource() realroot.putChild( b"v1", anchore_engine.services.common.getAuthResource( flask_site, sname, config)) realroot.putChild(b"health", anchore_engine.services.common.HealthResource()) # this will rewrite any calls that do not have an explicit version to the base path before being processed by flask root = rewrite.RewriterResource(realroot, default_version_rewrite) ret_svc = anchore_engine.services.common.createServiceAPI( root, sname, config) # start up the monitor as a looping call lc = LoopingCall(anchore_engine.services.common.monitor, **kwargs) lc.start(1) else: # start up the monitor as a timer service svc = internet.TimerService(1, anchore_engine.services.common.monitor, **kwargs) svc.setName(sname) ret_svc = svc return (ret_svc)
def test_putChild(self): """ L{WebSocketsResource.putChild} raises C{RuntimeError} when called. """ self.assertRaises(RuntimeError, self.resource.putChild, b"foo", Resource())
class PageResource(Resource): def render_GET(self, request): request.setHeader("Access-Control-Allow-Origin", "*") request.setHeader("Content-Type", "application/json") return " Hello World!" if __name__ == "__main__": source = { "candb": MySQLDB(), "graph": Xlore(), "en_parser": stanford_parser.Parser() } root = Resource() #root.putChild("show", PageResource()) root.putChild("show", File("./web_ui")) root.putChild("linking", LinkingResource(source)) search = Resource() root.putChild("search", search) search.putChild("items", SearchResource(source)) from twisted.internet import reactor reactor.listenTCP(5656, server.Site(root)) try: reactor.run() except: print "excpet" reactor.stop()
def __init__(self, log, host, port, backlog, coordinator, eventengine, database): ''' Initialize the web interface. @param port: the port on which the web server should listen @param coordinator: an instance of the network coordinator in order to interact with it @param eventengine: an instance of the event engine in order to interact with it @param database: an instance of the database layer in order to interact with it ''' self.host = host # web server interface self.port = port # web server listening port self.backlog = backlog # size of the listen queue self.coordinator = coordinator self.eventengine = eventengine self.db = database self.log = log root = Resource() site = Site(root) # Main page root.putChild("", Root()) # Room management root.putChild("location_add", Location_add(self.db)) root.putChild("location_added", Location_added(self.db)) root.putChild("locations", Locations(self.db)) root.putChild("location_del", Location_del(self.db)) root.putChild("location_edit", Location_edit(self.db)) root.putChild("location_edited", Location_edited(self.db)) # Plugin management root.putChild("plugin_add", Plugin_add(self.db)) root.putChild("plugin_add_do", Plugin_add_do(self.coordinator, self.db)) root.putChild("plugin_status", Plugin_status(self.coordinator, self.db)) root.putChild("plugins", Plugins(self.db)) root.putChild("plugin_del", Plugin_del(self.db)) root.putChild("plugin_edit", Plugin_edit(self.db)) root.putChild("plugin_edited", Plugin_edited(self.db)) # Device management root.putChild("device_add", Device_add(self.db)) root.putChild("device_save", Device_save(self.db)) root.putChild("device_list", Device_list(self.db)) root.putChild("device_man", Device_management(self.db)) root.putChild("device_del", Device_del(self.db)) root.putChild("device_edit", Device_edit(self.db)) root.putChild("history", History(self.db)) root.putChild("control_type", Control_type(self.db)) # Events root.putChild("event_create", Event_create(self.db)) root.putChild("event_value_by_id", Event_value_by_id(self.db)) root.putChild("event_getvalue", Event_getvalue(self.db)) root.putChild("event_save", Event_save(self.eventengine, self.db)) root.putChild("event_control_values_by_id", Event_control_values_by_id(self.db)) root.putChild("event_control_types_by_id", Event_control_types_by_id(self.db)) root.putChild("events", Events(self.db)) root.putChild("event_del", Event_del(self.eventengine, self.db)) root.putChild("css", File(os.path.join(houseagent.template_dir, 'css'))) root.putChild("js", File(os.path.join(houseagent.template_dir, 'js'))) root.putChild("images", File(os.path.join(houseagent.template_dir, 'images'))) root.putChild("graphdata", GraphData()) root.putChild("create_graph", CreateGraph(self.db)) root.putChild("control", Control(self.db)) root.putChild("control_onoff", Control_onoff(self.coordinator)) root.putChild("control_dimmer", Control_dimmer(self.coordinator)) root.putChild("control_stat", Control_stat(self.coordinator)) # Load plugin pages self.load_pages(root) try: reactor.listenTCP(self.port, site, self.backlog, self.host) except CannotListenError,e: log.critical("--> %s" % e) sys.exit(1)
def create_resource_tree(self, web_client, redirect_root_to_web_client): """Create the resource tree for this Home Server. This in unduly complicated because Twisted does not support putting child resources more than 1 level deep at a time. Args: web_client (bool): True to enable the web client. redirect_root_to_web_client (bool): True to redirect '/' to the location of the web client. This does nothing if web_client is not True. """ # list containing (path_str, Resource) e.g: # [ ("/aaa/bbb/cc", Resource1), ("/aaa/dummy", Resource2) ] desired_tree = [ (CLIENT_PREFIX, self.get_resource_for_client()), (FEDERATION_PREFIX, self.get_resource_for_federation()), (CONTENT_REPO_PREFIX, self.get_resource_for_content_repo()) ] if web_client: logger.info("Adding the web client.") desired_tree.append((WEB_CLIENT_PREFIX, self.get_resource_for_web_client())) if web_client and redirect_root_to_web_client: self.root_resource = RootRedirect(WEB_CLIENT_PREFIX) else: self.root_resource = Resource() # ideally we'd just use getChild and putChild but getChild doesn't work # unless you give it a Request object IN ADDITION to the name :/ So # instead, we'll store a copy of this mapping so we can actually add # extra resources to existing nodes. See self._resource_id for the key. resource_mappings = {} for (full_path, resource) in desired_tree: logging.info("Attaching %s to path %s", resource, full_path) last_resource = self.root_resource for path_seg in full_path.split('/')[1:-1]: if not path_seg in last_resource.listNames(): # resource doesn't exist, so make a "dummy resource" child_resource = Resource() last_resource.putChild(path_seg, child_resource) res_id = self._resource_id(last_resource, path_seg) resource_mappings[res_id] = child_resource last_resource = child_resource else: # we have an existing Resource, use that instead. res_id = self._resource_id(last_resource, path_seg) last_resource = resource_mappings[res_id] # =========================== # now attach the actual desired resource last_path_seg = full_path.split('/')[-1] # if there is already a resource here, thieve its children and # replace it res_id = self._resource_id(last_resource, last_path_seg) if res_id in resource_mappings: # there is a dummy resource at this path already, which needs # to be replaced with the desired resource. existing_dummy_resource = resource_mappings[res_id] for child_name in existing_dummy_resource.listNames(): child_res_id = self._resource_id(existing_dummy_resource, child_name) child_resource = resource_mappings[child_res_id] # steal the children resource.putChild(child_name, child_resource) # finally, insert the desired resource in the right place last_resource.putChild(last_path_seg, resource) res_id = self._resource_id(last_resource, last_path_seg) resource_mappings[res_id] = resource return self.root_resource
def __init__(self, sydent): self.sydent = sydent root = Resource() matrix = Resource() identity = Resource() api = Resource() v1 = self.sydent.servlets.v1 v2 = self.sydent.servlets.v2 validate = Resource() email = Resource() msisdn = Resource() emailReqCode = self.sydent.servlets.emailRequestCode emailValCode = self.sydent.servlets.emailValidate msisdnReqCode = self.sydent.servlets.msisdnRequestCode msisdnValCode = self.sydent.servlets.msisdnValidate getValidated3pid = self.sydent.servlets.getValidated3pid lookup = self.sydent.servlets.lookup bulk_lookup = self.sydent.servlets.bulk_lookup hash_details = self.sydent.servlets.hash_details lookup_v2 = self.sydent.servlets.lookup_v2 threepid_v1 = Resource() threepid_v2 = Resource() bind = self.sydent.servlets.threepidBind unbind = self.sydent.servlets.threepidUnbind pubkey = Resource() ephemeralPubkey = Resource() pk_ed25519 = self.sydent.servlets.pubkey_ed25519 root.putChild(b'_matrix', matrix) matrix.putChild(b'identity', identity) identity.putChild(b'api', api) identity.putChild(b'v2', v2) api.putChild(b'v1', v1) validate.putChild(b'email', email) validate.putChild(b'msisdn', msisdn) v1.putChild(b'validate', validate) v1.putChild(b'lookup', lookup) v1.putChild(b'bulk_lookup', bulk_lookup) v1.putChild(b'pubkey', pubkey) pubkey.putChild(b'isvalid', self.sydent.servlets.pubkeyIsValid) pubkey.putChild(b'ed25519:0', pk_ed25519) pubkey.putChild(b'ephemeral', ephemeralPubkey) ephemeralPubkey.putChild(b'isvalid', self.sydent.servlets.ephemeralPubkeyIsValid) threepid_v2.putChild(b'getValidated3pid', getValidated3pid) threepid_v2.putChild(b'bind', bind) threepid_v2.putChild(b'unbind', unbind) threepid_v1.putChild(b'getValidated3pid', getValidated3pid) threepid_v1.putChild(b'unbind', unbind) if self.sydent.enable_v1_associations: threepid_v1.putChild(b'bind', bind) v1.putChild(b'3pid', threepid_v1) email.putChild(b'requestToken', emailReqCode) email.putChild(b'submitToken', emailValCode) msisdn.putChild(b'requestToken', msisdnReqCode) msisdn.putChild(b'submitToken', msisdnValCode) v1.putChild(b'store-invite', self.sydent.servlets.storeInviteServlet) v1.putChild(b'sign-ed25519', self.sydent.servlets.blindlySignStuffServlet) # v2 # note v2 loses the /api so goes on 'identity' not 'api' identity.putChild(b'v2', v2) # v2 exclusive APIs v2.putChild(b'terms', self.sydent.servlets.termsServlet) account = self.sydent.servlets.accountServlet v2.putChild(b'account', account) account.putChild(b'register', self.sydent.servlets.registerServlet) account.putChild(b'logout', self.sydent.servlets.logoutServlet) # v2 versions of existing APIs v2.putChild(b'validate', validate) v2.putChild(b'pubkey', pubkey) v2.putChild(b'3pid', threepid_v2) v2.putChild(b'store-invite', self.sydent.servlets.storeInviteServlet) v2.putChild(b'sign-ed25519', self.sydent.servlets.blindlySignStuffServlet) v2.putChild(b'lookup', lookup_v2) v2.putChild(b'hash_details', hash_details) self.factory = Site(root) self.factory.displayTracebacks = False
def test_wrapResourceWeb(self): from twisted.web.resource import IResource, Resource root = Resource() wrapped = wrapResource(root, [self.checker]) self.assertTrue(IResource.providedBy(wrapped))
def register_resources(self, args: Namespace) -> None: from hathor.conf import HathorSettings from hathor.debug_resources import ( DebugCrashResource, DebugLogResource, DebugMessAroundResource, DebugPrintResource, DebugRaiseResource, DebugRejectResource, ) from hathor.mining.ws import MiningWebsocketFactory from hathor.p2p.resources import AddPeersResource, MiningInfoResource, MiningResource, StatusResource from hathor.profiler import get_cpu_profiler from hathor.profiler.resources import CPUProfilerResource, ProfilerResource from hathor.prometheus import PrometheusMetricsExporter from hathor.transaction.resources import ( BlockAtHeightResource, CreateTxResource, DashboardTransactionResource, DecodeTxResource, GetBlockTemplateResource, GraphvizFullResource, GraphvizNeighboursResource, MempoolResource, PushTxResource, SubmitBlockResource, 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() cpu = get_cpu_profiler() 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, args.max_output_script_size, args.allow_non_standard_script), root), (b'graphviz', graphviz, root), (b'transaction', TransactionResource(self.manager), root), (b'block_at_height', BlockAtHeightResource(self.manager), root), (b'transaction_acc_weight', TransactionAccWeightResource(self.manager), root), (b'dashboard_tx', DashboardTransactionResource(self.manager), root), (b'profiler', ProfilerResource(self.manager), root), (b'top', CPUProfilerResource(self.manager, cpu), root), (b'mempool', MempoolResource(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), ] if args.enable_debug_api: debug_resource = Resource() root.putChild(b'_debug', debug_resource) resources.extend([ (b'log', DebugLogResource(), debug_resource), (b'raise', DebugRaiseResource(), debug_resource), (b'reject', DebugRejectResource(), debug_resource), (b'print', DebugPrintResource(), debug_resource), ]) if args.enable_crash_api: crash_resource = Resource() root.putChild(b'_crash', crash_resource) resources.extend([ (b'exit', DebugCrashResource(), crash_resource), (b'mess_around', DebugMessAroundResource(self.manager), crash_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)) with_wallet_api = bool(self.wallet and args.wallet_enable_api) if with_wallet_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 assert self.manager.tx_storage.indexes is not None ws_factory = HathorAdminWebsocketFactory(metrics=self.manager.metrics, address_index=self.manager.tx_storage.indexes.addresses) 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) from hathor.profiler.site import SiteProfiler status_server = SiteProfiler(real_root) reactor.listenTCP(args.status, status_server) self.log.info('with status', listen=args.status, with_wallet_api=with_wallet_api) # Set websocket factory in metrics self.manager.metrics.websocket_factory = ws_factory
def setUp(self): self.reactor = MemoryReactor() self.site = Site(Resource())
class DummyChannel: class TCP: port = 80 disconnected = False def __init__(self, peer=None): if peer is None: peer = IPv4Address("TCP", "192.168.1.1", 12344) self._peer = peer self.written = BytesIO() self.producers = [] def getPeer(self): return self._peer def write(self, data): if not isinstance(data, bytes): raise TypeError( f"Can only write bytes to a transport, not {data!r}") self.written.write(data) def writeSequence(self, iovec): for data in iovec: self.write(data) def getHost(self): return IPv4Address("TCP", "10.0.0.1", self.port) def registerProducer(self, producer, streaming): self.producers.append((producer, streaming)) def unregisterProducer(self): pass def loseConnection(self): self.disconnected = True @implementer(ISSLTransport) class SSL(TCP): def abortConnection(self): # ITCPTransport.abortConnection pass def getTcpKeepAlive(self): # ITCPTransport.getTcpKeepAlive pass def getTcpNoDelay(self): # ITCPTransport.getTcpNoDelay pass def loseWriteConnection(self): # ITCPTransport.loseWriteConnection pass def setTcpKeepAlive(self, enabled): # ITCPTransport.setTcpKeepAlive pass def setTcpNoDelay(self, enabled): # ITCPTransport.setTcpNoDelay pass def getPeerCertificate(self): # ISSLTransport.getPeerCertificate pass site = Site(Resource()) def __init__(self, peer=None): self.transport = self.TCP(peer) def requestDone(self, request): pass def writeHeaders(self, version, code, reason, headers): response_line = version + b" " + code + b" " + reason + b"\r\n" headerSequence = [response_line] headerSequence.extend(name + b": " + value + b"\r\n" for name, value in headers) headerSequence.append(b"\r\n") self.transport.writeSequence(headerSequence) def getPeer(self): return self.transport.getPeer() def getHost(self): return self.transport.getHost() def registerProducer(self, producer, streaming): self.transport.registerProducer(producer, streaming) def unregisterProducer(self): self.transport.unregisterProducer() def write(self, data): self.transport.write(data) def writeSequence(self, iovec): self.transport.writeSequence(iovec) def loseConnection(self): self.transport.loseConnection() def endRequest(self): pass def isSecure(self): return isinstance(self.transport, self.SSL) def abortConnection(self): # ITCPTransport.abortConnection pass def getTcpKeepAlive(self): # ITCPTransport.getTcpKeepAlive pass def getTcpNoDelay(self): # ITCPTransport.getTcpNoDelay pass def loseWriteConnection(self): # ITCPTransport.loseWriteConnection pass def setTcpKeepAlive(self): # ITCPTransport.setTcpKeepAlive pass def setTcpNoDelay(self): # ITCPTransport.setTcpNoDelay pass def getPeerCertificate(self): # ISSLTransport.getPeerCertificate pass
def render_GET(self, request): r = ('Welcome to Scrapy Book. Try: ' '<a href="properties/index_00000.html">properties</a> ' '<a href="images">images</a>, ' '<a href="dynamic">dynamic</a>, ' '<a href="benchmark/">benchmark</a> ' '<a href="maps/api/geocode/json?sensor=false&address=Camden%20Town%2C%20London">maps</a>') return r.encode('utf-8') if __name__ == '__main__': path = os.path.dirname(os.path.abspath(__file__)) os.chdir(path) root = Resource() root.model = Model() root.putChild(b'', Home()) benchmark = Resource() root.putChild(b'benchmark', benchmark) benchmark.putChild(b'', Benchmark()) benchmark.putChild(b'api', Api()) benchmark.putChild(b'index', Index()) benchmark.putChild(b'detail', Detail()) root.putChild(b'properties', Properties(root.model)) root.putChild(b'maps', Maps(root.model)) root.putChild(b'images', File('images')) root.putChild(b'static', File('static')) root.putChild(b'dynamic', Dynamic())
def create_root(config, settings_module): from scrapy.settings import Settings from .specmanager import SpecManager from .authmanager import AuthManager from .projectspec import create_project_resource from slyd.api import APIResource from slyd.bot import create_bot_resource from slyd.projects import create_projects_manager_resource from slyd.splash.ferry import (FerryServerProtocol, FerryServerFactory, create_ferry_resource) from slyd.splash.proxy import ProxyResource root = Resource() static = Resource() for file_name in listdir(config['docroot']): file_path = join(config['docroot'], file_name) if isfile(file_path): static.putChild(file_name, File(file_path)) static.putChild('main.html', File(join(config['docroot'], 'index.html'))) root.putChild('static', static) root.putChild('assets', File(join(config['docroot'], 'assets'))) root.putChild('fonts', File(join(config['docroot'], 'assets', 'fonts'))) root.putChild('', File(join(config['docroot'], 'index.html'))) settings = Settings() settings.setmodule(settings_module) spec_manager = SpecManager(settings) # add server capabilities at /server_capabilities capabilities = Capabilities(spec_manager) root.putChild('server_capabilities', capabilities) # add projects manager at /projects projects = create_projects_manager_resource(spec_manager) root.putChild('projects', projects) # # add json api routes root.putChild('api', APIResource(spec_manager)) # add crawler at /projects/PROJECT_ID/bot projects.putChild('bot', create_bot_resource(spec_manager)) # add project spec at /projects/PROJECT_ID/spec spec = create_project_resource(spec_manager) projects.putChild('spec', spec) # add websockets for communicating with splash factory = FerryServerFactory("ws://127.0.0.1:%s" % config['port'], debug=False, assets=config['docroot']) factory.protocol = FerryServerProtocol factory.setProtocolOptions(allowHixie76=True) websocket = create_ferry_resource(spec_manager, factory) root.putChild("ws", websocket) root.putChild('proxy', ProxyResource()) auth_manager = AuthManager(settings) return auth_manager.protectResource(root)
def register_resources(self, args: Namespace) -> None: from hathor.conf import HathorSettings from hathor.p2p.resources import AddPeersResource, MiningInfoResource, MiningResource, StatusResource from hathor.prometheus import PrometheusMetricsExporter from hathor.resources import ProfilerResource from hathor.transaction.resources import ( DashboardTransactionResource, DecodeTxResource, GraphvizLegacyResource, GraphvizFullResource, GraphvizNeighboursResource, PushTxResource, TipsHistogramResource, TipsResource, TransactionAccWeightResource, TransactionResource, ) from hathor.version_resource import VersionResource from hathor.wallet.resources import ( AddressResource, BalanceResource, HistoryResource, LockWalletResource, SendTokensResource, SignTxResource, StateWalletResource, UnlockWalletResource, ) from hathor.wallet.resources.thin_wallet import ( AddressHistoryResource, SendTokensResource as SendTokensThinResource, TokenHistoryResource, TokenResource) from hathor.wallet.resources.nano_contracts import ( NanoContractDecodeResource, NanoContractExecuteResource, NanoContractMatchValueResource, ) from hathor.websocket import HathorAdminWebsocketFactory, WebsocketStatsResource from hathor.stratum.resources import MiningStatsResource 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 = GraphvizLegacyResource(self.manager) # 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'mining', MiningResource(self.manager), root), (b'getmininginfo', MiningInfoResource(self.manager), root), (b'decode_tx', DecodeTxResource(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), # /thin_wallet (b'address_history', AddressHistoryResource(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: 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() resource = WebSocketResource(ws_factory) root.putChild(b"ws", resource) 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
def create_log_resources(): logs = Resource() logs.putChild(b"v1", create_log_streaming_resource()) return logs
self.result = result[len(result) - 1] print("Hello : ", self.result) requests.write(''' <html><body> <br>CDR : %s <br> </body></html> ''' % self.result) requests.finish() else: print("Empty") requests.write(''' <html><body> <br>No Call Details Found<br> </body></html> ''') requests.finish() def err_db(self, error): """On database error""" print('error db') print(error) if __name__ == "__main__": root = Resource() root.putChild("form1", FormPage()) root.putChild("form2", NewPage()) factory = Site(root) reactor.listenTCP(8880, factory) reactor.run()
def __init__(self, log, host, port, backlog, coordinator, eventengine, database): ''' Initialize the web interface. @param port: the port on which the web server should listen @param coordinator: an instance of the network coordinator in order to interact with it @param eventengine: an instance of the event engine in order to interact with it @param database: an instance of the database layer in order to interact with it ''' self.host = host # web server interface self.port = port # web server listening port self.backlog = backlog # size of the listen queue self.coordinator = coordinator self.eventengine = eventengine self.db = database self.log = log root = Resource() site = Site(root) # Main page root.putChild("", Root()) # Location management root.putChild('locations', Locations(self.db)) root.putChild('locations_view', Locations_view()) # Plugin management root.putChild('plugins', Plugins(self.db, self.coordinator)) root.putChild('plugins_view', Plugins_view()) # Device management root.putChild('devices', Devices(self.db)) root.putChild('devices_view', Devices_view()) # Device control root.putChild("control", Control(self.db)) # Value management root.putChild('values', Values(self.db, self.coordinator)) root.putChild('values_view', Values_view()) root.putChild('history_types', HistoryTypes(self.db)) root.putChild('history_periods', HistoryPeriods(self.db)) root.putChild('control_types', ControlTypes(self.db)) # Events root.putChild("event_create", Event_create(self.db)) root.putChild("event_value_by_id", Event_value_by_id(self.db)) root.putChild("event_getvalue", Event_getvalue(self.db)) root.putChild("event_save", Event_save(self.eventengine, self.db)) root.putChild("event_control_values_by_id", Event_control_values_by_id(self.db)) root.putChild("event_control_types_by_id", Event_control_types_by_id(self.db)) root.putChild("events", Events(self.db)) root.putChild("event_del", Event_del(self.eventengine, self.db)) # Graphing root.putChild("create_graph", CreateGraph(self.db)) root.putChild("graph_latest", GraphLatest(self.db)) root.putChild("graph_daily", GraphDaily(self.db)) # Static files root.putChild("css", File(os.path.join(houseagent.template_dir, 'css'))) root.putChild("js", File(os.path.join(houseagent.template_dir, 'js'))) root.putChild("images", File(os.path.join(houseagent.template_dir, 'images'))) # Load plugin pages self.load_pages(root) try: reactor.listenTCP(self.port, site, self.backlog, self.host) except CannotListenError, e: log.critical("--> %s" % e) sys.exit(1)
def setUp(self): self.pagename = b'' self.root = Resource()
def _create_vulnerable_tree(): private = Resource() private.putChild(b"logs", create_log_resources()) return private