def __init__(self): handlers = [] add_versioned_resource_urls(handlers, ResourceSet("test", {1: TestResource, 2: V2TestResource}), prefix="/api") add_versioned_resource_urls( handlers, ResourceSet("another", {1: AnotherResource, 2: AnotherResource}), prefix="/api" ) add_versioned_resource_urls(handlers, MyOwnResourceSet(), prefix="/api") Application.__init__(self, handlers, debug=True)
def __init__(self): self.db_pool = adbapi.ConnectionPool("psycopg2", host="127.0.0.1", database="bench", user="******", password="******", cp_max=32, cp_reconnect=True) handlers = [ (r"/bench", BenchEndpoint, dict(db=self.db_pool)), ] Application.__init__(self, handlers, dict(xheaders=True))
def __init__(self, root, **settings): self.store = InMemoryCardStore() handlers = [ (r"/", root), (r"/publish/(?P<channel>.*)/", PublicationHandler, dict(store=self.store)), (r"/subscribe", SubscriptionHandler, dict(store=self.store)), ] Application.__init__(self, handlers, **settings)
def __init__(self, config_file=None, **settings): if self.config_required and config_file is None: raise ValueError( "Please specify a config file using --appopts=<config.yaml>") config = self.get_config_settings(config_file) self.setup_factory_preprocessor(config) self.initialize(settings, config) path_prefix = self._get_configured_path_prefix(config) routes = self._build_routes(path_prefix) Application.__init__(self, routes, **settings)
def __init__(self): self.db_pool = txpostgres.ConnectionPool("psycopg2", host="127.0.0.1", database="bench", user="******", password="******", min=32) d = self.db_pool.start() d.addCallback(lambda _: log.msg("DB connected")) handlers = [ (r"/bench", BenchEndpoint, dict(db=self.db_pool)), ] Application.__init__(self, handlers, dict(xheaders=True))
def load(self): if "secret" not in self.data: self.logger.warn("Generating secret. DO NOT SHARE IT WITH ANYONE!") self.logger.warn("It's stored in data/plugins/web/data.json - " "keep this file secure!") with self.data: self.data["secret"] = mkpasswd(60, 20, 20, 20) self.template_loader = TemplateLoader(self) if self.config.get("output_requests", True): log_function = self.log_request else: log_function = self.null_log self.application = Application( list(self.handlers.items()), # Handler list ## General settings xheaders=True, log_function=log_function, gzip=True, # Are there browsers that don't support this now? # error_handler=ErrorHandler, ## Security settings cookie_secret=self.data["secret"], login_url="/login", ## Template settings template_loader=self.template_loader, ## Static file settings static_path="web/static" ) if self.config.get("hosted", False): hosted = self.config["hosted"] if isinstance(hosted, dict): self.interface = os.environ.get(hosted["hostname"], False) self.port = os.environ.get(hosted["port"], False) if not self.interface: self.logger.error( "Unknown env var: %s" % hosted["hostname"] ) return False if not self.port: self.logger.error( "Unknown env var: %s" % hosted["port"] ) return False else: if hosted in ["openshift"]: self.interface = os.environ.get("OPENSHIFT__IP", False) self.port = os.environ.get("OPENSHIFT__PORT", False) if not self.interface: self.logger.error( "Unknown env var: OPENSHIFT__IP - Are you on " "OpenShift?" ) return False if not self.port: self.logger.error( "Unknown env var: OPENSHIFT__PORT - Are you on " "OpenShift?" ) return False else: self.logger.error("Unknown hosted service: %s" % hosted) return False else: if self.config.get("hostname", "0.0.0.0").strip() == "0.0.0.0": self.interface = "" else: self.interface = self.config.get("hostname") self.listen_port = self.config.get("port", 8080) return True
def request(self, jbody=None, role=None, user_id=None, headers=None, body='', remote_ip='0.0.0.0', method='MOCK', kwargs={}): """ Function userful for performing mock requests. Args: jbody: The body of the request as a dict (it will be automatically converted to string) body: The body of the request as a string role: If we should perform authentication role can be either "admin", "receiver" or "wb" user_id: If when performing authentication the session should be bound to a certain user_id. method: HTTP method, e.g. "GET" or "POST" uri: URL to fetch role: the role headers: (dict or :class:`cyclone.httputil.HTTPHeaders` instance) HTTP headers to pass on the request remote_ip: If a particular remote_ip should be set. """ if jbody and not body: body = json.dumps(jbody) elif body and jbody: raise ValueError('jbody and body in conflict') application = Application([]) tr = proto_helpers.StringTransport() connection = GLHTTPConnection() connection.factory = application connection.makeConnection(tr) request = httpserver.HTTPRequest(uri='mock', method=method, headers=headers, body=body, remote_ip=remote_ip, connection=connection) handler = self._handler(application, request, **kwargs) if role: session = authentication.GLSession(user_id, role, 'enabled') handler.request.headers['X-Session'] = session.id return handler
def mock_app_builder(): return Application([ (r'/testing/', _TestHandler), (r'/deferred_testing/', DeferredTestHandler), (r'/cookie_testing/', CookieTestHandler), ], cookie_secret="insecure")
class WebPlugin(PluginObject): """ Web plugin object """ api_log = None api_keys = None api_key_data = {} config = {} data = {} namespace = {} # Global, not used right now handlers = {} # Cyclone handlers interface = "" # Listening interface listen_port = 8080 running = False application = None # Cyclone application port = None # Twisted's server port storage = None template_loader = None navbar_items = {} ## Stuff plugins might find useful commands = None events = None packages = None plugins = None sessions = None stats = None ## Internal(ish) functions def setup(self): self.storage = StorageManager() try: self.config = self.storage.get_file(self, "config", YAML, "plugins/web.yml") self.logger.debug("Config loaded") except Exception: self.logger.exception(_("Error loading configuration")) self._disable_self() return if not self.config.exists: self.logger.error(_("Unable to find config/plugins/web.yml")) self._disable_self() return try: self.data = self.storage.get_file(self, "data", JSON, "plugins/web/data.json") self.logger.debug("Data loaded") except Exception: self.logger.exception("Error loading data file!") return self._disable_self() try: _sessions = self.storage.get_file(self, "data", JSON, "plugins/web/sessions.json") self.logger.debug("Sessions loaded") except Exception: self.logger.exception("Error loading sessions file!") return self._disable_self() try: self.api_log = open("logs/api.log", "w") except Exception: self.logger.exception("Unable to open api log file!") return self._disable_self() try: self.api_key_data = self.storage.get_file( self, "data", JSON, "plugins/web/apikeys.json") self.logger.debug("Sessions loaded") except Exception: self.logger.exception("Error loading API keys!") return self._disable_self() try: self.api_log = open("logs/api.log", "w") except Exception: self.logger.exception("Unable to open api log file!") return self._disable_self() self.config.add_callback(self.restart) self.data.add_callback(self.restart) # Index page self.add_handler(r"/", "plugins.web.routes.index.Route") # Login-related self.add_handler(r"/login", "plugins.web.routes.login.Route") self.add_handler(r"/logout", "plugins.web.routes.logout.Route") self.add_handler(r"/login/reset", "plugins.web.routes.login-reset.Route") # Accounts-related self.add_handler(r"/account", "plugins.web.routes.account.index.Route") self.add_handler(r"/account/password/change", "plugins.web.routes.account.password.change.Route") self.add_handler(r"/account/apikeys/create", "plugins.web.routes.account.apikeys.create.Route") self.add_handler(r"/account/apikeys/delete", "plugins.web.routes.account.apikeys.delete.Route") self.add_handler(r"/account/users/logout", "plugins.web.routes.account.users.logout.Route") # Admin-related self.add_handler(r"/admin", "plugins.web.routes.admin.index.Route") self.add_handler(r"/admin/files", "plugins.web.routes.admin.files.Route") self.add_handler(r"/admin/files/(config|data)/(.*)", "plugins.web.routes.admin.file.Route") self.add_handler(r"/api/admin/get_stats", "plugins.web.routes.api.admin.get_stats.Route") self.add_navbar_entry("admin", "/admin", "settings") # API routes self.add_api_handler( r"/plugins/web/get_username", "plugins.web.routes.api.plugins.web.get_username.Route") # Stuff routes might find useful self.api_keys = APIKeys(self, self.api_key_data) self.commands = CommandManager() self.events = EventManager() self.packages = Packages(False) self.plugins = PluginManager() self.sessions = Sessions(self, _sessions) self.stats = Stats() # Load 'er up! r = self.load() if not r: self._disable_self() return if not self.factory_manager.running: self.events.add_callback("ReactorStarted", self, self.start, 0) else: self.start() def load(self): if "secret" not in self.data: self.logger.warn("Generating secret. DO NOT SHARE IT WITH ANYONE!") self.logger.warn("It's stored in data/plugins/web/data.json - " "keep this file secure!") with self.data: self.data["secret"] = mkpasswd(60, 20, 20, 20) self.template_loader = TemplateLoader(self) if self.config.get("output_requests", True): log_function = self.log_request else: log_function = self.null_log self.application = Application( list(self.handlers.items()), # Handler list ## General settings xheaders=self.config.get("x_forwarded_for", False), log_function=log_function, gzip=True, # Are there browsers that don't support this now? # error_handler=ErrorHandler, ## Security settings cookie_secret=self.data["secret"], login_url="/login", ## Template settings template_loader=self.template_loader, ## Static file settings static_path="web/static") if self.config.get("hosted", False): hosted = self.config["hosted"] if isinstance(hosted, dict): self.interface = os.environ.get(hosted["hostname"], False) self.port = os.environ.get(hosted["port"], False) if not self.interface: self.logger.error("Unknown env var: %s" % hosted["hostname"]) return False if not self.port: self.logger.error("Unknown env var: %s" % hosted["port"]) return False else: if hosted in ["openshift"]: self.interface = os.environ.get("OPENSHIFT__IP", False) self.port = os.environ.get("OPENSHIFT__PORT", False) if not self.interface: self.logger.error( "Unknown env var: OPENSHIFT__IP - Are you on " "OpenShift?") return False if not self.port: self.logger.error( "Unknown env var: OPENSHIFT__PORT - Are you on " "OpenShift?") return False else: self.logger.error("Unknown hosted service: %s" % hosted) return False else: if self.config.get("hostname", "0.0.0.0").strip() == "0.0.0.0": self.interface = "" else: self.interface = self.config["hostname"] self.listen_port = self.config.get("port", 8080) return True def start(self, _=None): self.stats.start() self.port = reactor.listenTCP(self.listen_port, self.application, interface=self.interface) self.logger.info("Server started") self.running = True self.events.run_callback("Web/ServerStartedEvent", ServerStartedEvent(self, self.application)) def stop(self): self.application.doStop() d = self.port.stopListening() d.addCallback(lambda _: self.logger.info("Server stopped")) d.addCallback(lambda _: setattr(self, "running", False)) d.addCallback(lambda _: self.events.run_callback( "Web/ServerStopped", ServerStoppedEvent(self))) d.addErrback(lambda f: self.logger.error("Failed to stop: %s" % f)) self.stats.stop() return d def restart(self): d = self.stop() d.addCallback(lambda _: [self.load(), self.start()]) def deactivate(self): d = self.stop() self.handlers.clear() self.navbar_items.clear() return d def log_request(self, request): log = self.logger.info status_code = request.get_status() if status_code >= 500: log = self.logger.error elif status_code >= 400: log = self.logger.warn path = request.request.path # Check if this is an API method and hide the key if so matched = re.match(r"/api/v[0-9]/([a-zA-Z0-9]+)/.*", path) if matched: key = matched.groups()[0] user = self.api_keys.get_username(key) if user: path = path.replace(key, "<API: %s>" % user) else: path = path.replace(key, "<API: Invalid key>") log("[%s] %s %s -> HTTP %s" % (request.request.remote_ip, request.request.method, path, request.get_status())) def null_log(self, *args, **kwargs): pass ## Public API functions def add_api_handler(self, pattern, handler, version=1): if not pattern.startswith("/"): pattern = "/%s" % pattern pattern = "/api/v%s/([A-Za-z0-9]+)%s" % (version, pattern) return self.add_handler(pattern, handler) def add_handler(self, pattern, handler): self.logger.debug("Adding route: %s -> %s" % (pattern, handler)) if pattern in self.handlers: self.logger.debug("Route already exists.") return False self.handlers[pattern] = handler if self.application is not None: self.application.add_handlers(r".*$", [(pattern, handler)]) self.logger.debug("Handlers list: %s" % list(self.handlers.values())) def add_navbar_entry(self, title, url, icon="question"): if title in self.navbar_items: return False self.logger.debug("Adding navbar entry: %s -> %s" % (title, url)) self.navbar_items[title] = {"url": url, "active": False, "icon": icon} return True def check_permission(self, perm, session=None): if session is None: username = None elif isinstance(session, str) or isinstance(session, unicode): username = session else: username = session["username"] return self.commands.perm_handler.check(perm, username, "web", "plugin-web") def remove_api_handlers(self, *names, **kwargs): """ :param names: :param version: :return: """ version = kwargs.get("version", 1) patterns = [] for pattern in names: if not pattern.startswith("/"): pattern = "/%s" % pattern pattern = "/api/v%s/([A-Za-z0-9]+)%s" % (version, pattern) patterns.append(pattern) return self.remove_handlers(*patterns) def remove_handlers(self, *names): found = False for name in names: if name in self.handlers: found = True del self.handlers[name] if found: self.restart() def write_api_log(self, address, key, username, message): self.api_log.write("%s | %s (%s) | %s\n" % (address, key, username, message))
def setUp(self): self.app = Application(some_setting="foo") self.request = Mock() self.rh = RequestHandler(self.app, self.request)
def request(self, jbody=None, user_id=None, role=None, headers=None, body='', remote_ip='0.0.0.0', method='MOCK', kwargs={}): """ Function userful for performing mock requests. Args: jbody: The body of the request as a dict (it will be automatically converted to string) body: The body of the request as a string user_id: when simulating authentication the session should be bound to a certain user_id. role: when simulating authentication the session should be bound to a certain role. method: HTTP method, e.g. "GET" or "POST" headers: (dict or :class:`cyclone.httputil.HTTPHeaders` instance) HTTP headers to pass on the request remote_ip: If a particular remote_ip should be set. """ if jbody and not body: body = json.dumps(jbody) elif body and jbody: raise ValueError('jbody and body in conflict') application = Application([]) tr = proto_helpers.StringTransport() connection = GLHTTPConnection() connection.factory = application connection.makeConnection(tr) request = httpserver.HTTPRequest(uri='mock', method=method, headers=headers, body=body, remote_ip=remote_ip, connection=connection) handler = self._handler(application, request, **kwargs) if user_id is None and role is not None: if role == 'admin': user_id = self.dummyAdminUser['id'] elif role == 'receiver': user_id = self.dummyReceiverUser_1['id'] elif role == 'custodian': user_id = self.dummyCustodianUser['id'] if role is not None: session = GLSession(user_id, role, 'enabled') handler.request.headers['X-Session'] = session.id return handler
def request(self, jbody=None, user_id=None, role=None, headers=None, body='', remote_ip='0.0.0.0', method='MOCK', attached_file={}, kwargs={}): """ Function userful for performing mock requests. Args: jbody: The body of the request as a dict (it will be automatically converted to string) body: The body of the request as a string user_id: when simulating authentication the session should be bound to a certain user_id. role: when simulating authentication the session should be bound to a certain role. method: HTTP method, e.g. "GET" or "POST" headers: (dict or :class:`cyclone.httputil.HTTPHeaders` instance) HTTP headers to pass on the request remote_ip: If a particular remote_ip should be set. attached_file: A cyclone.httputil.HTTPFiles or a dict to place in the request.files obj """ if jbody and not body: body = json.dumps(jbody) elif body and jbody: raise ValueError('jbody and body in conflict') if attached_file is None: fake_files = {} else: fake_files = { 'file': [attached_file] } # Yes this is ugly, but it's the format application = Application([]) tr = proto_helpers.StringTransport() connection = GLHTTPConnection() connection.factory = application connection.makeConnection(tr) request = httpserver.HTTPRequest(uri='mock', method=method, headers=headers, body=body, remote_ip=remote_ip, connection=connection, files=fake_files) def mock_write(cls, response=None): if response: self.responses.append(response) self._handler.write = mock_write def mock_finish(cls): pass self._handler.finish = mock_finish handler = self._handler(application, request, **kwargs) # pylint: disable=not-callable if user_id is None and role is not None: if role == 'admin': user_id = self.dummyAdminUser['id'] elif role == 'receiver': user_id = self.dummyReceiverUser_1['id'] elif role == 'custodian': user_id = self.dummyCustodianUser['id'] if role is not None: session = GLSession(user_id, role, 'enabled') handler.request.headers['X-Session'] = session.id return handler
for k, v in request.get('http_request_headers', {}).iteritems(): http_request_headers[str(k)] = map(str, v) self.control_measurement( http_url=str(request['http_request']), include_http_responses=include_http_responses, http_request_headers=http_request_headers, socket_list=request['tcp_connect'], invalid_sockets=invalid_sockets ) except HTTPError: raise except Exception as exc: log.msg("Got invalid request") log.exception(exc) raise HTTPError(400, 'invalid request') class WebConnectivityStatus(RequestHandler): def get(self): self.write({"status": "ok"}) HTTPRandomPageHelper = Application([ # XXX add regexps here (r"/(.*)/(.*)", HTTPRandomPage) ], log_function=log_function) WebConnectivityHelper = Application([ (r"/status", WebConnectivityStatus), (r"/", WebConnectivity) ], log_function=log_function)
def log_request(self, handler): if getattr(handler, 'suppress_request_log', False): # The handler doesn't want to be logged, so we're done. return return Application.log_request(self, handler)
class WebPlugin(PluginObject): """ Web plugin object """ api_log = None api_keys = None api_key_data = {} config = {} data = {} namespace = {} # Global, not used right now handlers = {} # Cyclone handlers interface = "" # Listening interface listen_port = 8080 running = False application = None # Cyclone application port = None # Twisted's server port storage = None template_loader = None navbar_items = {} ## Stuff plugins might find useful commands = None events = None packages = None plugins = None sessions = None stats = None ## Internal(ish) functions def setup(self): self.storage = StorageManager() try: self.config = self.storage.get_file(self, "config", YAML, "plugins/web.yml") self.logger.debug("Config loaded") except Exception: self.logger.exception(_("Error loading configuration")) self._disable_self() return if not self.config.exists: self.logger.error(_("Unable to find config/plugins/web.yml")) self._disable_self() return try: self.data = self.storage.get_file(self, "data", JSON, "plugins/web/data.json") self.logger.debug("Data loaded") except Exception: self.logger.exception("Error loading data file!") return self._disable_self() try: _sessions = self.storage.get_file(self, "data", JSON, "plugins/web/sessions.json") self.logger.debug("Sessions loaded") except Exception: self.logger.exception("Error loading sessions file!") return self._disable_self() try: self.api_log = open("logs/api.log", "w") except Exception: self.logger.exception("Unable to open api log file!") return self._disable_self() try: self.api_key_data = self.storage.get_file( self, "data", JSON, "plugins/web/apikeys.json" ) self.logger.debug("Sessions loaded") except Exception: self.logger.exception("Error loading API keys!") return self._disable_self() try: self.api_log = open("logs/api.log", "w") except Exception: self.logger.exception("Unable to open api log file!") return self._disable_self() self.config.add_callback(self.restart) self.data.add_callback(self.restart) # Index page self.add_handler(r"/", "plugins.web.routes.index.Route") # Login-related self.add_handler(r"/login", "plugins.web.routes.login.Route") self.add_handler(r"/logout", "plugins.web.routes.logout.Route") self.add_handler( r"/login/reset", "plugins.web.routes.login-reset.Route" ) # Accounts-related self.add_handler(r"/account", "plugins.web.routes.account.index.Route") self.add_handler( r"/account/password/change", "plugins.web.routes.account.password.change.Route" ) self.add_handler( r"/account/apikeys/create", "plugins.web.routes.account.apikeys.create.Route" ) self.add_handler( r"/account/apikeys/delete", "plugins.web.routes.account.apikeys.delete.Route" ) self.add_handler( r"/account/users/logout", "plugins.web.routes.account.users.logout.Route" ) # Admin-related self.add_handler( r"/admin", "plugins.web.routes.admin.index.Route" ) self.add_handler( r"/admin/files", "plugins.web.routes.admin.files.Route" ) self.add_handler( r"/admin/files/(config|data)/(.*)", "plugins.web.routes.admin.file.Route" ) self.add_handler( r"/api/admin/get_stats", "plugins.web.routes.api.admin.get_stats.Route" ) self.add_navbar_entry("admin", "/admin", "settings") # API routes self.add_api_handler( r"/plugins/web/get_username", "plugins.web.routes.api.plugins.web.get_username.Route" ) # Stuff routes might find useful self.api_keys = APIKeys(self, self.api_key_data) self.commands = CommandManager() self.events = EventManager() self.packages = Packages(False) self.plugins = PluginManager() self.sessions = Sessions(self, _sessions) self.stats = Stats() # Load 'er up! r = self.load() if not r: self._disable_self() return if not self.factory_manager.running: self.events.add_callback( "ReactorStarted", self, self.start, 0 ) else: self.start() def load(self): if "secret" not in self.data: self.logger.warn("Generating secret. DO NOT SHARE IT WITH ANYONE!") self.logger.warn("It's stored in data/plugins/web/data.json - " "keep this file secure!") with self.data: self.data["secret"] = mkpasswd(60, 20, 20, 20) self.template_loader = TemplateLoader(self) if self.config.get("output_requests", True): log_function = self.log_request else: log_function = self.null_log self.application = Application( list(self.handlers.items()), # Handler list ## General settings xheaders=True, log_function=log_function, gzip=True, # Are there browsers that don't support this now? # error_handler=ErrorHandler, ## Security settings cookie_secret=self.data["secret"], login_url="/login", ## Template settings template_loader=self.template_loader, ## Static file settings static_path="web/static" ) if self.config.get("hosted", False): hosted = self.config["hosted"] if isinstance(hosted, dict): self.interface = os.environ.get(hosted["hostname"], False) self.port = os.environ.get(hosted["port"], False) if not self.interface: self.logger.error( "Unknown env var: %s" % hosted["hostname"] ) return False if not self.port: self.logger.error( "Unknown env var: %s" % hosted["port"] ) return False else: if hosted in ["openshift"]: self.interface = os.environ.get("OPENSHIFT__IP", False) self.port = os.environ.get("OPENSHIFT__PORT", False) if not self.interface: self.logger.error( "Unknown env var: OPENSHIFT__IP - Are you on " "OpenShift?" ) return False if not self.port: self.logger.error( "Unknown env var: OPENSHIFT__PORT - Are you on " "OpenShift?" ) return False else: self.logger.error("Unknown hosted service: %s" % hosted) return False else: if self.config.get("hostname", "0.0.0.0").strip() == "0.0.0.0": self.interface = "" else: self.interface = self.config.get("hostname") self.listen_port = self.config.get("port", 8080) return True def start(self, _=None): self.stats.start() self.port = reactor.listenTCP( self.listen_port, self.application, interface=self.interface ) self.logger.info("Server started") self.running = True self.events.run_callback( "Web/ServerStartedEvent", ServerStartedEvent(self, self.application) ) def stop(self): self.application.doStop() d = self.port.stopListening() d.addCallback(lambda _: self.logger.info("Server stopped")) d.addCallback(lambda _: setattr(self, "running", False)) d.addCallback(lambda _: self.events.run_callback( "Web/ServerStopped", ServerStoppedEvent(self) )) d.addErrback(lambda f: self.logger.error("Failed to stop: %s" % f)) self.stats.stop() return d def restart(self): d = self.stop() d.addCallback(lambda _: [self.load(), self.start()]) def deactivate(self): d = self.stop() self.handlers.clear() self.navbar_items.clear() return d def log_request(self, request): log = self.logger.info status_code = request.get_status() if status_code >= 500: log = self.logger.error elif status_code >= 400: log = self.logger.warn path = request.request.path # Check if this is an API method and hide the key if so matched = re.match(r"/api/v[0-9]/([a-zA-Z0-9]+)/.*", path) if matched: key = matched.groups()[0] user = self.api_keys.get_username(key) if user: path = path.replace(key, "<API: %s>" % user) else: path = path.replace(key, "<API: Invalid key>") log( "[%s] %s %s -> HTTP %s" % ( request.request.remote_ip, request.request.method, path, request.get_status() ) ) def null_log(self, *args, **kwargs): pass ## Public API functions def add_api_handler(self, pattern, handler, version=1): if not pattern.startswith("/"): pattern = "/%s" % pattern pattern = "/api/v%s/([A-Za-z0-9]+)%s" % (version, pattern) return self.add_handler(pattern, handler) def add_handler(self, pattern, handler): self.logger.debug("Adding route: %s -> %s" % (pattern, handler)) if pattern in self.handlers: self.logger.debug("Route already exists.") return False self.handlers[pattern] = handler if self.application is not None: self.application.add_handlers(r".*$", [(pattern, handler)]) self.logger.debug("Handlers list: %s" % list(self.handlers.values())) def add_navbar_entry(self, title, url, icon="question"): if title in self.navbar_items: return False self.logger.debug("Adding navbar entry: %s -> %s" % (title, url)) self.navbar_items[title] = {"url": url, "active": False, "icon": icon} return True def check_permission(self, perm, session=None): if session is None: username = None elif isinstance(session, str) or isinstance(session, unicode): username = session else: username = session["username"] return self.commands.perm_handler.check( perm, username, "web", "plugin-web" ) def remove_api_handlers(self, *names, **kwargs): """ :param names: :param version: :return: """ version = kwargs.get("version", 1) patterns = [] for pattern in names: if not pattern.startswith("/"): pattern = "/%s" % pattern pattern = "/api/v%s/([A-Za-z0-9]+)%s" % (version, pattern) patterns.append(pattern) return self.remove_handlers(*patterns) def remove_handlers(self, *names): found = False for name in names: if name in self.handlers: found = True del self.handlers[name] if found: self.restart() def write_api_log(self, address, key, username, message): self.api_log.write( "%s | %s (%s) | %s\n" % (address, key, username, message) )
selected by the user. /<length>/<keyword> XXX this is currently disabled as it is not of use to any test. """ isLeaf = True def _gen_random_string(self, length): return ''.join(random.choice(string.letters) for x in range(length)) def genRandomPage(self, length=100, keyword=None): data = self._gen_random_string(length / 2) if keyword: data += keyword data += self._gen_random_string(length - length / 2) data += '\n' return data def all(self, length, keyword): self.set_header('Content-Disposition', 'attachment; filename="%s.txt"' % randomStr(10)) length = 100 if length > 100000: length = 100000 self.write(self.genRandomPage(length, keyword)) HTTPRandomPageHelper = Application([ # XXX add regexps here (r"/(.*)/(.*)", HTTPRandomPage) ])
def post(self, *arg, **kw): method_hack = self.get_arguments('_method') if method_hack and method_hack == 'DELETE': return self.delete() s = json.dumps(self.handle_upload(), separators=(',',':')) if 'application/json' in self.request.headers.get('Accept'): self.set_header('Content-Type', 'application/json') self.write(s) def delete(self): pass static_dir = os.path.abspath(os.path.join('..', '..')) spec = [(r'/server/php', UploadHandler), (r'/(.*)', StaticFileHandler, {'path': static_dir}), ] from twisted.internet import reactor from cyclone.web import Application application = Application(spec, debug=True) reactor.listenTCP(listen_port, application) reactor.run()