def start(): log = logging.getLogger('Rocket') log.addHandler(logging.FileHandler('server.log')) session_opts = { 'session.data_dir' : '/tmp/fmk/data', 'session.lock_dir' : '/tmp/fmk/lock', 'session.type' : 'redis', 'session.url' : '127.0.0.1:6379?db=3' } app = Dispatcher(mapfile='rest.map', wrap=Request) app = Session(app, session_opts) server = Server( interfaces=('127.0.0.1', 9000), method='wsgi', app_info=dict(wsgi_app=app), min_threads=64, max_threads=128, timeout=60 ) try: print 'starting wsgi server...' server.start() except KeyboardInterrupt: server.stop() except Exception as e: print type(e) print e.args, e server.stop()
def run_server(): log = logging.getLogger('Rocket') log.setLevel(logging.INFO) log.addHandler(logging.StreamHandler(sys.stdout)) server = Rocket(interfaces=('0.0.0.0', 5000), method='wsgi', app_info={"wsgi_app": app}) server.start()
def run_server(): global platform_log if print_debug: print("Starting iotplatform") server = Rocket( interfaces = ('0.0.0.0', 8005), method = 'wsgi', app_info = {'wsgi_app': app}) server.start() platform_log.info("Started Server")
def run_server(): # Setup logging log = logging.getLogger('Rocket') log.setLevel(logging.INFO) log.addHandler(logging.StreamHandler(sys.stdout)) # Set the configuration of the web server server = Rocket(interfaces=('0.0.0.0', 5000), method='wsgi', app_info={"wsgi_app": app}) # Start the Rocket web server server.start()
def rocket_http(debug=False): # Setup logging log = logging.getLogger('Rocket') log.setLevel(logging.INFO) if debug: log.addHandler(logging.StreamHandler(sys.stdout)) else: log.addHandler(logging.FileHandler('http.log')) # Set the configuration of the web server server = Rocket(interfaces=('0.0.0.0', 8010, 'ssl/server.key', 'ssl/server.crt'), method='wsgi', app_info={"wsgi_app": app}) server.start(background=True)
def run_webserver(self): #noinspection PyBroadException try: host = self.config['HOST'] port = self.config['PORT'] ssl = self.config['SSL'] interfaces = [(host, port)] if ssl['enabled']: interfaces.append((ssl['host'], ssl['port'], ssl['key'], ssl['certificate'])) logging.info('Firing up the Rocket') rocket = Rocket(interfaces=interfaces, app_info={'wsgi_app': bottle_app}, ) rocket.start() logging.debug('Rocket has landed') except KeyboardInterrupt as _: logging.exception('Keyboard interrupt, request a global shutdown.') holder.bot.shutdown() except Exception as _: logging.exception('The Rocket has exploded.') self.warn_admins("There's an issue with the Rocket: %s" % _)
class Webserver(BotPlugin): def __init__(self, *args, **kwargs): self.webserver = None self.webchat_mode = False self.ssl_context = None self.test_app = TestApp(bottle_app) super().__init__(*args, **kwargs) def get_configuration_template(self): return {'HOST': '0.0.0.0', 'PORT': 3141, 'SSL': {'enabled': False, 'host': '0.0.0.0', 'port': 3142, 'certificate': "", 'key': ""}} def check_configuration(self, configuration): # it is a pain, just assume a default config if SSL is absent or set to None if configuration.get('SSL', None) is None: configuration['SSL'] = {'enabled': False, 'host': '0.0.0.0', 'port': 3142, 'certificate': "", 'key': ""} super().check_configuration(configuration) def activate(self): if not self.config: self.log.info('Webserver is not configured. Forbid activation') return host = self.config['HOST'] port = self.config['PORT'] ssl = self.config['SSL'] interfaces = [(host, port)] if ssl['enabled']: # noinspection PyTypeChecker interfaces.append((ssl['host'], ssl['port'], ssl['key'], ssl['certificate'])) self.log.info('Firing up the Rocket') self.webserver = Rocket(interfaces=interfaces, app_info={'wsgi_app': bottle_app}, ) self.webserver.start(background=True) self.log.debug('Liftoff!') super().activate() def deactivate(self): if self.webserver is not None: self.log.debug('Sending signal to stop the webserver') self.webserver.stop() super().deactivate() # noinspection PyUnusedLocal @botcmd(template='webstatus') def webstatus(self, mess, args): """ Gives a quick status of what is mapped in the internal webserver """ return {'rules': (((route.rule, route.name) for route in bottle_app.routes))} @webhook def echo(self, incoming_request): """ A simple test webhook """ self.log.debug("Your incoming request is :" + str(incoming_request)) return str(incoming_request) @botcmd(split_args_with=' ') def webhook_test(self, _, args): """ Test your webhooks from within err. The syntax is : !webhook test [relative_url] [post content] It triggers the notification and generate also a little test report. """ url = args[0] content = ' '.join(args[1:]) # try to guess the content-type of what has been passed try: # try if it is plain json loads(content) contenttype = 'application/json' except ValueError: # try if it is a form splitted = content.split('=') # noinspection PyBroadException try: payload = '='.join(splitted[1:]) loads(unquote(payload)) contenttype = 'application/x-www-form-urlencoded' except Exception as _: contenttype = 'text/plain' # dunno what it is self.log.debug('Detected your post as : %s' % contenttype) response = self.test_app.post(url, params=content, content_type=contenttype) return TEST_REPORT % (url, contenttype, response.status_code) @botcmd(admin_only=True) def generate_certificate(self, mess, args): """ Generate a self-signed SSL certificate for the Webserver """ if not has_crypto: yield ("It looks like pyOpenSSL isn't installed. Please install this " "package using for example `pip install pyOpenSSL`, then try again") return yield ("Generating a new private key and certificate. This could take a " "while if your system is slow or low on entropy") key_path = os.sep.join((self.bot_config.BOT_DATA_DIR, "webserver_key.pem")) cert_path = os.sep.join((self.bot_config.BOT_DATA_DIR, "webserver_certificate.pem")) make_ssl_certificate(key_path=key_path, cert_path=cert_path) yield "Certificate successfully generated and saved in {}".format(self.bot_config.BOT_DATA_DIR) suggested_config = self.config suggested_config['SSL']['enabled'] = True suggested_config['SSL']['host'] = suggested_config['HOST'] suggested_config['SSL']['port'] = suggested_config['PORT'] + 1 suggested_config['SSL']['key'] = key_path suggested_config['SSL']['certificate'] = cert_path yield ("To enable SSL with this certificate, the following config " "is recommended:") yield "{!r}".format(suggested_config)
def run_server(): server = Rocket( interfaces = ('0.0.0.0', 9200), method = 'wsgi', app_info = {'wsgi_app': app}) server.start()
path_info = MAP_FILES[path_info] if path_info in FILES: content_type = FILES[path_info] path_info = os.path.join(os.getcwd(), path_info.strip("/")) f = open(path_info, "r") http_content = substitue_content(f.read()) if "$$$MODULE_CONTENT$$$" in http_content: http_content = insert_modules(http_content) except: traceback.print_exc() headers = [('Content-type', content_type)] start_response(status, headers) return http_content my_demo = {"wsgi_app": my_simple_app} if __name__ == '__main__': log = logging.getLogger('Rocket.Requests') log.setLevel(logging.INFO) fmt = logging.Formatter('%(levelname)s:%(name)s:%(message)s') h = logging.StreamHandler() h.setFormatter(fmt) log.addHandler(h) r = Rocket(interfaces=[('127.0.0.1', 8000), ('::1', 8000)], method='wsgi', app_info=my_demo) r.start()
class FlaskWebThread(threading.Thread): def __init__(self, queues, port, username, password): self.credentials = [{"username": username, "password": password}] self.app = Flask(__name__, static_folder='static', static_path='/static', static_url_path='/static') self.app.debug = False self.authHelper = authenticator(self.credentials) self.cmd_q = queues['in'] self.reply_q = queues['out'] self.logger = logging.getLogger('app') self.host = '0.0.0.0' self.port = port self.shutdown_pass = self.random_string() self.server = None rocketlog = logging.getLogger('Rocket') rocketlog.setLevel(logging.INFO) super(FlaskWebThread, self).__init__() def random_string(self): return ''.join( random.choice(string.ascii_uppercase + string.digits) for _ in range(50)) def admin(self): return render_template('admin.html') def sense(self): self.logger.debug("Got sense command") return self.status() def status(self): self.logger.debug("Got status command") command = interlockcommands.ReadState() response = self.sendCommand(command) if self.is_json(): status = self.interpret_response(response.data) buffer = json.dumps({"status": status}) else: buffer = render_template('status.html', data=print_bytes(response.data), cmd='status') return buffer def enable(self, data): shutdowns = data.get('shutdowns', 0) shutdowns = int(shutdowns) problems = data.get('problems', 0) problems = int(problems) self.logger.debug("Got enable command, %s shutdowns, %s problems" % (shutdowns, problems)) if shutdowns > 0: #command = interlockcommands.EnterState(9) #only available if keyswitch is turned command = interlockcommands.EnterState(4) elif problems > 0: command = interlockcommands.EnterState(4) else: command = interlockcommands.EnterState(2) response = self.sendCommand(command) if self.is_json(): buffer = json.dumps({"status": "unlocked"}) else: buffer = render_template('enable.html', data=print_bytes(response.data), cmd='enable') return buffer def disable(self, data): shutdowns = data.get('shutdowns', 0) shutdowns = int(shutdowns) problems = data.get('problems', 0) problems = int(problems) self.logger.debug("Got disable command, %s shutdowns, %s problems" % (shutdowns, problems)) if shutdowns > 0: command = interlockcommands.EnterState(8) elif problems > 0: command = interlockcommands.EnterState(3) else: command = interlockcommands.EnterState(1) response = self.sendCommand(command) if self.is_json(): buffer = json.dumps({"status": "locked"}) else: buffer = render_template('enable.html', data=print_bytes(response.data), cmd='disable') return buffer def proxy(self, data): #verify shutdowns = data.get('shutdowns', 0) shutdowns = int(shutdowns) problems = data.get('problems', 0) problems = int(problems) scheme = data.get('scheme', 'http') host = data['host'] port = data['port'] username = data.get('username', self.credentials[0]['username']) password = data.get( 'password', self.credentials[0]['password'] ) #since this method requires authentication, this should be okay command = data['command'] if command not in [ "status", "sense", "enable", "disable", "unlock", "lock" ]: return Response( '{"status": "error", "message": "no such command"}', 404) if scheme not in ["http", "https"]: return Response('{"status": "error", "message": "no such scheme"}', 404) headers = {'Content-type': 'application/json'} json_data = {"shutdowns": shutdowns, "problems": problems} url = '%s://%s:%s/%s' % (scheme, host, port, command) auth = HTTPBasicAuth(username, password) self.logger.debug("Proxying request: %s, %s, %s, %s" % (url, command, shutdowns, problems)) response = requests.post(url, data=json_data, headers=headers, auth=auth) self.logger.debug("Got response code %s " % response.status_code) return Response(response.text, response.status_code) def is_json(self): self.logger.debug("IS JSON?") self.logger.debug("Accept header: " + request.headers.get("Accept", "")) self.logger.debug("Content-Type header: " + request.headers.get("Content-Type", "")) json = False if request.headers.get('Content-Type', False) == 'application/json' or \ request.headers.get('Accept', False) == 'application/json': json = True return json def run(self): self.setupRoutes() self.logger.debug('Flask Server Starting') self.server = Rocket((self.host, self.port), 'wsgi', {"wsgi_app": self.app}) self.server.start(background=False) #self.app.run(host=self.host, port=self.port) self.logger.debug('Flask Server Stopping') def setupRoutes(self): @self.app.route('/admin', methods=['GET', 'POST']) @self.authHelper.requires_auth def admin(): return self.admin() @self.app.route('/sense', methods=['GET', 'POST']) @self.authHelper.requires_auth def sense(): return self.sense() @self.app.route('/status', methods=['GET', 'POST']) @self.authHelper.requires_auth def status(): return self.status() @self.app.route('/enable', methods=['POST']) @self.authHelper.requires_auth def enable(): return self.enable(request.form) @self.app.route('/disable', methods=['POST']) @self.authHelper.requires_auth def disable(): return self.disable(request.form) @self.app.route('/unlock', methods=['POST']) @self.authHelper.requires_auth def unlock_to_enable(): return self.enable(request.form) @self.app.route('/lock', methods=['POST']) @self.authHelper.requires_auth def log_to_disable(): return self.disable(request.form) @self.app.route('/static', methods=['GET']) @self.app.route('/static/', methods=['GET']) @self.app.route('/', methods=['GET']) def serve_static_index(): self.logger.debug('static asset') return self.app.send_static_file('index.html') @self.app.route('/swagger.yaml', methods=['GET']) def swagger(): self.logger.debug('swagger yaml') buffer = render_template('swagger.yaml', host=request.host) return buffer @self.app.route('/proxy', methods=['POST']) @self.authHelper.requires_auth def proxy(): return self.proxy(request.get_json()) @self.app.route('/shutdown/<shutdown_pass>', methods=['POST']) def shutdown(shutdown_pass): if shutdown_pass == self.shutdown_pass: func = request.environ.get('werkzeug.server.shutdown') if func is None: raise RuntimeError('Not running with the Werkzeug Server') func() return "Shutting down..." else: return "" def sendCommand(self, command): self.cmd_q.put(command) response = self.reply_q.get(True, 5) if response.type == ClientReply.ERROR: self.logger.error("ERROR response is : %s" % pprint.pformat(response)) raise Exception('Error response from interlock box: %s' % response.data) self.logger.debug("response is : %s" % pprint.pformat(response)) return response def shutdown_flask(self): requests.post('http://localhost:' + str(self.port) + '/shutdown/' + self.shutdown_pass) def join(self): self.logger.debug("shutting down") self.server.stop() #self.shutdown_flask() self.logger.debug("shutdown request sent") threading.Thread.join(self) def interpret_response(self, data): unlocked_states = [2, 4, 5, 9] locked_states = [1, 3, 7, 8] if len(data) == 2 and data[0] == 85: if data[1] in unlocked_states: return "unlocked" elif data[1] in locked_states: return "locked" else: return "unknown" else: return "unknown"
class Webserver(BotPlugin): def __init__(self, *args, **kwargs): self.webserver = None self.webchat_mode = False self.ssl_context = None self.test_app = TestApp(bottle_app) super().__init__(*args, **kwargs) def get_configuration_template(self): return {'HOST': '0.0.0.0', 'PORT': 3141, 'SSL': {'enabled': False, 'host': '0.0.0.0', 'port': 3142, 'certificate': "", 'key': ""}} def check_configuration(self, configuration): # it is a pain, just assume a default config if SSL is absent or set to None if configuration.get('SSL', None) is None: configuration['SSL'] = {'enabled': False, 'host': '0.0.0.0', 'port': 3142, 'certificate': "", 'key': ""} super().check_configuration(configuration) def activate(self): if not self.config: self.log.info('Webserver is not configured. Forbid activation') return host = self.config['HOST'] port = self.config['PORT'] ssl = self.config['SSL'] interfaces = [(host, port)] if ssl['enabled']: # noinspection PyTypeChecker interfaces.append((ssl['host'], ssl['port'], ssl['key'], ssl['certificate'])) self.log.info('Firing up the Rocket') self.webserver = Rocket(interfaces=interfaces, app_info={'wsgi_app': bottle_app}, ) self.webserver.start(background=True) self.log.debug('Liftoff!') super().activate() def deactivate(self): if self.webserver is not None: self.log.debug('Sending signal to stop the webserver') self.webserver.stop() super().deactivate() # noinspection PyUnusedLocal @botcmd(template='webstatus') def webstatus(self, msg, args): """ Gives a quick status of what is mapped in the internal webserver """ return {'rules': (((route.rule, route.name) for route in bottle_app.routes))} @webhook def echo(self, incoming_request): """ A simple test webhook """ self.log.debug("Your incoming request is :" + str(incoming_request)) return str(incoming_request) @botcmd(split_args_with=' ') def webhook_test(self, _, args): """ Test your webhooks from within err. The syntax is : !webhook test [relative_url] [post content] It triggers the notification and generate also a little test report. """ url = args[0] content = ' '.join(args[1:]) # try to guess the content-type of what has been passed try: # try if it is plain json loads(content) contenttype = 'application/json' except ValueError: # try if it is a form splitted = content.split('=') # noinspection PyBroadException try: payload = '='.join(splitted[1:]) loads(unquote(payload)) contenttype = 'application/x-www-form-urlencoded' except Exception as _: contenttype = 'text/plain' # dunno what it is self.log.debug('Detected your post as : %s' % contenttype) response = self.test_app.post(url, params=content, content_type=contenttype) return TEST_REPORT % (url, contenttype, response.status_code) @botcmd(admin_only=True) def generate_certificate(self, _, args): """ Generate a self-signed SSL certificate for the Webserver """ if not has_crypto: yield ("It looks like pyOpenSSL isn't installed. Please install this " "package using for example `pip install pyOpenSSL`, then try again") return yield ("Generating a new private key and certificate. This could take a " "while if your system is slow or low on entropy") key_path = os.sep.join((self.bot_config.BOT_DATA_DIR, "webserver_key.pem")) cert_path = os.sep.join((self.bot_config.BOT_DATA_DIR, "webserver_certificate.pem")) make_ssl_certificate(key_path=key_path, cert_path=cert_path) yield "Certificate successfully generated and saved in {}".format(self.bot_config.BOT_DATA_DIR) suggested_config = self.config suggested_config['SSL']['enabled'] = True suggested_config['SSL']['host'] = suggested_config['HOST'] suggested_config['SSL']['port'] = suggested_config['PORT'] + 1 suggested_config['SSL']['key'] = key_path suggested_config['SSL']['certificate'] = cert_path yield ("To enable SSL with this certificate, the following config " "is recommended:") yield "{!r}".format(suggested_config)
def run(self, handler): from rocket import Rocket server = Rocket((self.host, self.port), 'wsgi', { 'wsgi_app' : handler }) server.start()
class Webserver(BotPlugin): min_err_version = VERSION # don't copy paste that for your plugin, it is just because it is a bundled plugin ! max_err_version = VERSION def __init__(self): self.webserver = None self.webchat_mode = False self.ssl_context = None self.test_app = TestApp(bottle_app) super(Webserver, self).__init__() def get_configuration_template(self): return {'HOST': '0.0.0.0', 'PORT': 3141, 'SSL': {'enabled': False, 'host': '0.0.0.0', 'port': 3142, 'certificate': "", 'key': ""}} def check_configuration(self, configuration): # it is a pain, just assume a default config if SSL is absent or set to None if configuration.get('SSL', None) is None: configuration['SSL'] = {'enabled': False, 'host': '0.0.0.0', 'port': 3142, 'certificate': "", 'key': ""} super(Webserver, self).check_configuration(configuration) def activate(self): if not self.config: logging.info('Webserver is not configured. Forbid activation') return host = self.config['HOST'] port = self.config['PORT'] ssl = self.config['SSL'] interfaces = [(host, port)] if ssl['enabled']: interfaces.append((ssl['host'], ssl['port'], ssl['key'], ssl['certificate'])) logging.info('Firing up the Rocket') self.webserver = Rocket(interfaces=interfaces, app_info={'wsgi_app': bottle_app}, ) self.webserver.start(background=True) logging.debug('Liftoff!') super(Webserver, self).activate() logging.info('Webserver activated') def deactivate(self): if self.webserver is not None: logging.debug('Sending signal to stop the webserver') self.webserver.stop() super(Webserver, self).deactivate() #noinspection PyUnusedLocal @botcmd(template='webstatus') def webstatus(self, mess, args): """ Gives a quick status of what is mapped in the internal webserver """ return {'rules': (((route.rule, route.name) for route in bottle_app.routes))} @webhook def echo(self, incoming_request): """ A simple test webhook """ logging.debug("Your incoming request is :" + str(incoming_request)) return str(incoming_request) @botcmd(split_args_with=' ') def webhook_test(self, _, args): """ Test your webhooks from within err. The syntax is : !webhook test [relative_url] [post content] It triggers the notification and generate also a little test report. """ url = args[0] if PY3 else args[0].encode() # PY2 needs a str not unicode content = ' '.join(args[1:]) # try to guess the content-type of what has been passed try: # try if it is plain json loads(content) contenttype = 'application/json' except ValueError: # try if it is a form splitted = content.split('=') #noinspection PyBroadException try: payload = '='.join(splitted[1:]) loads(unquote(payload)) contenttype = 'application/x-www-form-urlencoded' except Exception as _: contenttype = 'text/plain' # dunno what it is logging.debug('Detected your post as : %s' % contenttype) response = self.test_app.post(url, params=content, content_type=contenttype) return TEST_REPORT % (url, contenttype, response.status_code)
class FlaskProxyWebThread(threading.Thread): def __init__(self, queues, port, username, password): self.credentials = [{"username": username, "password": password}] self.app = Flask(__name__, static_folder='static', static_path='/static', static_url_path='/static') self.app.debug = False self.authHelper = authenticator(self.credentials) self.cmd_q = queues['in'] self.reply_q = queues['out'] self.logger = logging.getLogger('app') self.host = '0.0.0.0' self.port = port self.shutdown_pass = self.random_string() self.server = None rocketlog = logging.getLogger('Rocket') rocketlog.setLevel(logging.INFO) super(FlaskProxyWebThread, self).__init__() def random_string(self): return ''.join( random.choice(string.ascii_uppercase + string.digits) for _ in range(50)) def proxy(self, data): #verify shutdowns = data.get('shutdowns', 0) shutdowns = int(shutdowns) problems = data.get('problems', 0) problems = int(problems) scheme = data.get('scheme', 'http') host = data['host'] port = data['port'] username = data.get('username', self.credentials[0]['username']) password = data.get( 'password', self.credentials[0]['password'] ) #since this method requires authentication, this should be okay command = data['command'] if command not in [ "status", "sense", "enable", "disable", "unlock", "lock" ]: return Response( '{"status": "error", "message": "no such command"}', 404) if scheme not in ["http", "https"]: return Response('{"status": "error", "message": "no such scheme"}', 404) headers = {'Content-type': 'application/json'} json_data = {"shutdowns": shutdowns, "problems": problems} url = '%s://%s:%s/%s' % (scheme, host, port, command) auth = HTTPBasicAuth(username, password) self.logger.debug("Proxying request: %s, %s, %s, %s" % (url, command, shutdowns, problems)) response = requests.post(url, data=json_data, headers=headers, auth=auth) self.logger.debug("Got response code %s " % response.status_code) return Response(response.text, response.status_code) def is_json(self): self.logger.debug("IS JSON?") self.logger.debug("Accept header: " + request.headers.get("Accept", "")) self.logger.debug("Content-Type header: " + request.headers.get("Content-Type", "")) json = False if request.headers.get('Content-Type', False) == 'application/json' or \ request.headers.get('Accept', False) == 'application/json': json = True return json def run(self): self.setupRoutes() self.logger.debug('Flask Proxy Server Starting') self.server = Rocket((self.host, self.port), 'wsgi', {"wsgi_app": self.app}) self.server.start(background=False) #self.app.run(host=self.host, port=self.port) self.logger.debug('Flask Server Stopping') def setupRoutes(self): @self.app.route('/static', methods=['GET']) @self.app.route('/static/', methods=['GET']) @self.app.route('/', methods=['GET']) def serve_static_index(): self.logger.debug('static asset') return self.app.send_static_file('index.html') @self.app.route('/swagger.yaml', methods=['GET']) def swagger(): self.logger.debug('swagger yaml') buffer = render_template('swaggerProxy.yaml', host=request.host) return buffer @self.app.route('/proxy', methods=['POST']) @self.authHelper.requires_auth def proxy(): return self.proxy(request.get_json()) @self.app.route('/shutdown/<shutdown_pass>', methods=['POST']) def shutdown(shutdown_pass): if shutdown_pass == self.shutdown_pass: func = request.environ.get('werkzeug.server.shutdown') if func is None: raise RuntimeError('Not running with the Werkzeug Server') func() return "Shutting down..." else: return "" def shutdown_flask(self): requests.post('http://localhost:' + str(self.port) + '/shutdown/' + self.shutdown_pass) def join(self): self.logger.debug("shutting down") self.server.stop() self.logger.debug("shutdown request sent") threading.Thread.join(self)
def __init__(self, root): super(RedfishServer, self).__init__(autojson=False) self.redfish_root = root self.create_handlers() self.install_handlers() def create_handlers(self): self.get_request_handler = GetRequestHandler(self, self.redfish_root) def install_handlers(self): self.get_request_handler.install() if __name__ == '__main__': log = logging.getLogger('Rocket.Errors') log.setLevel(logging.INFO) log.addHandler(logging.StreamHandler(sys.stdout)) redfish_root = RedfishBottleRoot() app = RedfishServer(redfish_root) default_cert = os.path.join( sys.prefix, 'share', os.path.basename(__file__), 'cert.pem') server = Rocket( ('0.0.0.0', 8080, default_cert, default_cert), 'wsgi', {'wsgi_app': app}, min_threads=1, max_threads=1) print "Starting Server" server.start()
class Webserver(BotPlugin): min_err_version = VERSION # don't copy paste that for your plugin, it is just because it is a bundled plugin ! max_err_version = VERSION def __init__(self): self.webserver = None self.webchat_mode = False self.ssl_context = None self.test_app = TestApp(bottle_app) super(Webserver, self).__init__() def get_configuration_template(self): return { 'HOST': '0.0.0.0', 'PORT': 3141, 'SSL': { 'enabled': False, 'host': '0.0.0.0', 'port': 3142, 'certificate': "", 'key': "" } } def check_configuration(self, configuration): # it is a pain, just assume a default config if SSL is absent or set to None if configuration.get('SSL', None) is None: configuration['SSL'] = { 'enabled': False, 'host': '0.0.0.0', 'port': 3142, 'certificate': "", 'key': "" } super(Webserver, self).check_configuration(configuration) def activate(self): if not self.config: logging.info('Webserver is not configured. Forbid activation') return host = self.config['HOST'] port = self.config['PORT'] ssl = self.config['SSL'] interfaces = [(host, port)] if ssl['enabled']: interfaces.append( (ssl['host'], ssl['port'], ssl['key'], ssl['certificate'])) logging.info('Firing up the Rocket') self.webserver = Rocket( interfaces=interfaces, app_info={'wsgi_app': bottle_app}, ) self.webserver.start(background=True) logging.debug('Liftoff!') super(Webserver, self).activate() logging.info('Webserver activated') def deactivate(self): if self.webserver is not None: logging.debug('Sending signal to stop the webserver') self.webserver.stop() super(Webserver, self).deactivate() #noinspection PyUnusedLocal @botcmd(template='webstatus') def webstatus(self, mess, args): """ Gives a quick status of what is mapped in the internal webserver """ return { 'rules': (((route.rule, route.name) for route in bottle_app.routes)) } @webhook def echo(self, incoming_request): """ A simple test webhook """ logging.debug("Your incoming request is :" + str(incoming_request)) return str(incoming_request) @botcmd(split_args_with=' ') def webhook_test(self, _, args): """ Test your webhooks from within err. The syntax is : !webhook test [relative_url] [post content] It triggers the notification and generate also a little test report. """ url = args[0] if PY3 else args[0].encode( ) # PY2 needs a str not unicode content = ' '.join(args[1:]) # try to guess the content-type of what has been passed try: # try if it is plain json loads(content) contenttype = 'application/json' except ValueError: # try if it is a form splitted = content.split('=') #noinspection PyBroadException try: payload = '='.join(splitted[1:]) loads(unquote(payload)) contenttype = 'application/x-www-form-urlencoded' except Exception as _: contenttype = 'text/plain' # dunno what it is logging.debug('Detected your post as : %s' % contenttype) response = self.test_app.post(url, params=content, content_type=contenttype) return TEST_REPORT % (url, contenttype, response.status_code)
class ConnectionTest(unittest.TestCase): def setUp(self): global SERVER_PORT_START SERVER_PORT_START += 1 self.starttuple = ('127.0.0.1', SERVER_PORT_START) #log = logging.getLogger('Rocket') #log.setLevel(logging.DEBUG) #fmt = logging.Formatter('%(levelname)s:%(name)s:%(message)s') #h = logging.StreamHandler() #h.setFormatter(fmt) #log.addHandler(h) self.server = Rocket(self.starttuple, "fs", min_threads=0) self.server.start(background=True) # Create a socket connecting to listener's port self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.settimeout(SOCKET_TIMEOUT) self.sock.connect(self.starttuple) def tearDown(self): self.sock.close() self.server.stop() def testMembers(self): c = connection.Connection(*(self.server.active_queue.get(timeout=10))) members = [ "close", "client_addr", "server_port", "ssl", "socket", "start_time" ] for m in members: self.assert_(hasattr(c, m), msg="Connection object does not have %s " % m) def testSocketTimeout(self): c = connection.Connection(*(self.server.active_queue.get(timeout=10))) timeout = c.socket.gettimeout() self.assertEqual(timeout, SOCKET_TIMEOUT) def testSocketRecv(self): c = connection.Connection(*(self.server.active_queue.get(timeout=10))) SENT_DATA = "this is a test" self.sock.send(SENT_DATA) data = c.recv(len(SENT_DATA)) self.assertEqual(data, SENT_DATA) def testSocketSend(self): c = connection.Connection(*(self.server.active_queue.get(timeout=10))) RECVD_DATA = "this is a test" c.send(RECVD_DATA) data = self.sock.recv(len(RECVD_DATA)) self.assertEqual(data, RECVD_DATA) def testFileLikeSocketRead(self): c = connection.Connection(*(self.server.active_queue.get(timeout=10))) SENT_DATA = "this is a test" self.sock.send(SENT_DATA) f = c.makefile() data = f.read(len(SENT_DATA)) self.assertEqual(data, SENT_DATA) f.close() def testFileLikeSocketReadline(self): c = connection.Connection(*(self.server.active_queue.get(timeout=10))) SENT_DATA = """this is a test\r\nthis is another line\r\n""" self.sock.send(SENT_DATA) time.sleep(0.25) f = c.makefile() for l in SENT_DATA.splitlines(): data = f.readline() self.assertEqual(data, l + "\r\n") f.close() def testFileLikeSocketReadlines(self): c = connection.Connection(*(self.server.active_queue.get(timeout=10))) SENT_DATA = """this is a test\r\nthis is another line\r\n""" self.sock.send(SENT_DATA) self.sock.close() time.sleep(0.25) f = c.makefile() sent_lines = [x + '\r\n' for x in SENT_DATA.splitlines()] data_lines = f.readlines() self.assertEqual(sent_lines, data_lines) f.close()
http_content = "moduuid {} not available".format(mod_uuid) else: path_info = environ["PATH_INFO"] if path_info in MAP_FILES: path_info = MAP_FILES[path_info] if path_info in FILES: content_type = FILES[path_info] path_info = os.path.join(os.getcwd(), path_info.strip("/")) f = open(path_info, "r") http_content = substitue_content(f.read()) if "$$$MODULE_CONTENT$$$" in http_content: http_content = insert_modules(http_content) except: traceback.print_exc() headers = [('Content-type', content_type)] start_response(status, headers) return http_content my_demo = { "wsgi_app": my_simple_app } if __name__ == '__main__': log = logging.getLogger('Rocket.Requests') log.setLevel(logging.INFO) fmt = logging.Formatter('%(levelname)s:%(name)s:%(message)s') h = logging.StreamHandler() h.setFormatter(fmt) log.addHandler(h) r = Rocket(interfaces=[('127.0.0.1', 8000), ('::1', 8000)], method='wsgi', app_info=my_demo) r.start()
from rocket import Rocket my_argparser = argparse.ArgumentParser() my_argparser.add_argument( '--listen-on-ip', '-l', required=True ) my_argparser.add_argument( '--listen-on-port', '-p', type=int, required=True ) my_argparser.add_argument( '--ssl-key', required=True ) my_argparser.add_argument( '--ssl-cert', required=True ) my_argparser.add_argument( '--verbose', action='store_true') parsedargs = my_argparser.parse_args() my_example_app = Bottle( ) # A global handler that runs for all requests @my_example_app.hook('before_request') def before_request(): response.set_header('X-Rocket-Powered', socket.getfqdn()) # Let people test to see if we are alive @my_example_app.route('/ping') def hello(): return "pong" #Enable INFO logging? if parsedargs.verbose: log = logging.getLogger('Rocket') log.setLevel( logging.INFO ) log.addHandler(logging.StreamHandler()) #Let's go my_rocket = Rocket( ( parsedargs.listen_on_ip, parsedargs.listen_on_port, parsedargs.ssl_key, parsedargs.ssl_cert ), 'wsgi', { "wsgi_app":my_example_app } ) my_rocket.start()
class ConnectionTest(unittest.TestCase): def setUp(self): global SERVER_PORT_START SERVER_PORT_START += 1 self.starttuple = ('127.0.0.1', SERVER_PORT_START) #log = logging.getLogger('Rocket') #log.setLevel(logging.DEBUG) #fmt = logging.Formatter('%(levelname)s:%(name)s:%(message)s') #h = logging.StreamHandler() #h.setFormatter(fmt) #log.addHandler(h) self.server = Rocket(self.starttuple, "fs", min_threads=0) self.server.start(background=True) # Create a socket connecting to listener's port self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.settimeout(SOCKET_TIMEOUT) self.sock.connect(self.starttuple) def tearDown(self): self.sock.close() self.server.stop() def testMembers(self): c = connection.Connection(*(self.server.active_queue.get(timeout=10))) members = ["close", "client_addr", "server_port", "ssl", "socket", "start_time"] for m in members: self.assertTrue(hasattr(c, m), msg="Connection object does not have %s " % m) def testSocketTimeout(self): c = connection.Connection(*(self.server.active_queue.get(timeout=10))) timeout = c.socket.gettimeout() self.assertEqual(timeout, SOCKET_TIMEOUT) def testSocketRecv(self): c = connection.Connection(*(self.server.active_queue.get(timeout=10))) SENT_DATA = b("this is a test") self.sock.send(SENT_DATA) data = c.recv(len(SENT_DATA)) self.assertEqual(data, SENT_DATA) def testSocketSend(self): c = connection.Connection(*(self.server.active_queue.get(timeout=10))) RECVD_DATA = b("this is a test") c.send(RECVD_DATA) data = self.sock.recv(len(RECVD_DATA)) self.assertEqual(data, RECVD_DATA) def testFileLikeSocketRead(self): c = connection.Connection(*(self.server.active_queue.get(timeout=10))) SENT_DATA = b("this is a test") self.sock.send(SENT_DATA) f = c.makefile() data = b(f.read(len(SENT_DATA))) self.assertEqual(data, SENT_DATA) f.close() def testFileLikeSocketReadline(self): c = connection.Connection(*(self.server.active_queue.get(timeout=10))) SENT_DATA = b("""this is a test\nthis is another line\n""") self.sock.send(SENT_DATA) time.sleep(0.25) f = c.makefile() try: for l in SENT_DATA.splitlines(): data = b(f.readline()) self.assertEqual(data, l+b("\n")) finally: f.close() c.close() def testFileLikeSocketReadlines(self): c = connection.Connection(*(self.server.active_queue.get(timeout=10))) SENT_DATA = b("""this is a test\nthis is another line\n""") self.sock.send(SENT_DATA) self.sock.close() time.sleep(0.25) f = c.makefile() sent_lines = [x + b('\n') for x in SENT_DATA.splitlines()] data_lines = [b(x) for x in f.readlines()] self.assertEqual(sent_lines, data_lines) f.close() c.close()
response = r.read() if response == 'ON': state = '1' else: state = '0' else: state = msg.payload client.publish(PREFIX + '{}_Relay_{}'.format(controller, relay), state) if __name__ == '__main__': log = logging.getLogger('Rocket') log.setLevel(logging.INFO) fmt = logging.Formatter('%(levelname)s:%(name)s:%(message)s') h = logging.FileHandler('/var/log/wb-ab-log-eth.log') h.setFormatter(fmt) log.addHandler(h) mqttc.on_connect = on_connect mqttc.on_message = on_message mqttc.connect("localhost", 1883) server = Rocket(interfaces=('0.0.0.0', 9999), method='wsgi', app_info={"wsgi_app":ab_log_app}) mqttc.loop_start() server.start() mqttc.loop_stop() mqttc.disconnect()
teaching WSGI concepts."""