def main(args=None): if args is None: args = sys.argv[1:] opts = parse_options(args) if opts.reload: kw = {} if opts.poll: from hupper.polling import PollingFileMonitor pkw = {} if opts.poll_interval: pkw['poll_interval'] = opts.poll_interval kw['monitor_factory'] = lambda cb: PollingFileMonitor(cb, **pkw) if opts.watchdog: from hupper.watchdog import WatchdogFileMonitor kw['monitor_factory'] = WatchdogFileMonitor if opts.reload_interval: kw['reload_interval'] = opts.reload_interval reloader = hupper.start_reloader(__name__ + '.main', **kw) if hupper.is_active(): reloader.watch_files([os.path.join(here, 'foo.ini')]) reloader.watch_files(opts.watch_files) if opts.callback_file: with open(opts.callback_file, 'ab') as fp: fp.write('{:d}\n'.format(int(time.time())).encode('utf8')) try: while True: time.sleep(1) except KeyboardInterrupt: pass
def register() -> None: settings = config.registry.settings.get(apiname) if settings and settings.get("spec") is not None: raise ConfigurationError( "Spec has already been configured. You may only call " "pyramid_openapi3_spec or pyramid_openapi3_spec_directory once" ) if hupper.is_active(): # pragma: no cover hupper.get_reloader().watch_files([filepath]) spec_dict = read_yaml_file(filepath) validate_spec(spec_dict) spec = create_spec(spec_dict) def spec_view(request: Request) -> FileResponse: return FileResponse(filepath, request=request, content_type="text/yaml") config.add_route(route_name, route) config.add_view(route_name=route_name, permission=permission, view=spec_view) custom_formatters = config.registry.settings.get("pyramid_openapi3_formatters") config.registry.settings[apiname] = { "filepath": filepath, "spec_route_name": route_name, "spec": spec, "request_validator": RequestValidator( spec, custom_formatters=custom_formatters ), "response_validator": ResponseValidator( spec, custom_formatters=custom_formatters ), } APIS.append(apiname)
def register() -> None: if hupper.is_active(): # pragma: no cover hupper.get_reloader().watch_files([filepath]) spec_dict = read_yaml_file(filepath) validate_spec(spec_dict) spec = create_spec(spec_dict) def spec_view(request: Request) -> FileResponse: return FileResponse(filepath, request=request, content_type="text/yaml") config.add_route(route_name, route) config.add_view(route_name=route_name, view=spec_view) custom_formatters = config.registry.settings.get( "pyramid_openapi3_formatters") config.registry.settings["pyramid_openapi3"] = { "filepath": filepath, "spec_route_name": route_name, "spec": spec, "request_validator": RequestValidator(spec, custom_formatters), "response_validator": ResponseValidator(spec, custom_formatters), }
def load_config(filenames, include, environ=os.environ, environ_prefix='NEXTGISWEB', hupper=False): if filenames is None: filenames = environ.get(environ_prefix + '_CONFIG') if isinstance(filenames, six.string_types): filenames = filenames.split(':') if include is None: include = environ.get(environ_prefix + '_CONFIG_INCLUDE') result = OrderedDict() def apply_kv(key, value): if value != '': result[key] = value elif key in result: # Remove key for empty value del result[key] def load_fp(fp): cfg = RawConfigParser() (cfg.readfp if six.PY2 else cfg.read_file)(fp) for section in cfg.sections(): for k, v in cfg.items(section): rkey = '.'.join((section, k)) apply_kv(rkey, v) if hupper: from hupper import is_active, get_reloader if is_active(): get_reloader().watch_files(filenames) if filenames is not None: for fn in filenames: with io.open(fn, 'r') as fp: load_fp(fp) if include is not None: fp = io.StringIO(six.ensure_text(include)) load_fp(fp) for k, v in environ.items(): rkey = environ_to_key(k, prefix=environ_prefix) if rkey is not None: apply_kv(rkey, v) environ_substitution(result, environ) return result
def register() -> None: settings = config.registry.settings.get(apiname) if settings and settings.get("spec") is not None: raise ConfigurationError( "Spec has already been configured. You may only call " "pyramid_openapi3_spec or pyramid_openapi3_spec_directory once" ) if route.endswith((".yaml", ".yml", ".json")): raise ConfigurationError( "Having route be a filename is not allowed when using a spec directory" ) path = Path(filepath).resolve() if hupper.is_active(): # pragma: no cover hupper.get_reloader().watch_files(list(path.parent.iterdir())) spec_dict = read_yaml_file(path) spec_url = path.as_uri() validate_spec(spec_dict, spec_url=spec_url) spec = create_spec(spec_dict, spec_url=spec_url) config.add_static_view(route, str(path.parent), permission=permission) config.add_route(route_name, f"{route}/{path.name}") custom_formatters = config.registry.settings.get( "pyramid_openapi3_formatters") custom_deserializers = config.registry.settings.get( "pyramid_openapi3_deserializers") config.registry.settings[apiname] = { "filepath": filepath, "spec_route_name": route_name, "spec": spec, "request_validator": RequestValidator( spec, custom_formatters=custom_formatters, custom_media_type_deserializers=custom_deserializers, ), "response_validator": ResponseValidator( spec, custom_formatters=custom_formatters, custom_media_type_deserializers=custom_deserializers, ), } config.registry.settings.setdefault("pyramid_openapi3_apinames", []).append(apiname)
def getReloader(self): """Get the current reloader if the application is monitored.""" reloader = None with warnings.catch_warnings(): # ignore deprecation warnings from hupper warnings.filterwarnings('ignore', category=DeprecationWarning) try: import hupper except ImportError: pass else: if hupper.is_active(): try: reloader = hupper.get_reloader() except RuntimeError: pass if reloader: print('Application is monitored for reloading.') print() return reloader
def serve(args): try: from waitress import serve except ImportError as e: raise RuntimeError('Waitress server is not installed') from e scheme = args.url_scheme host, port = args.host, args.port path = args.url_prefix.strip('/') if path: path = f'/{path}/' url = f'{scheme}://{host}:{port}{path}' if args.browser: import time import threading import webbrowser def openBrowser(): time.sleep(1) webbrowser.open(url) t = threading.Thread(target=openBrowser) t.setDaemon(True) t.start() if args.reload: try: import hupper except ImportError as e: raise RuntimeError( 'The hupper process monitor is not installed') from e if not hupper.is_active(): print('Running Webware with reloading option...') args.browser = args.reload = False hupper.start_reloader('webware.Scripts.WaitressServer.serve', reload_interval=int(args.reload_interval), worker_args=[args]) development = not args.prod from os import environ if development: environ['WEBWARE_DEVELOPMENT'] = 'true' elif 'WEBWARE_DEVELOPMENT' in environ: del environ['WEBWARE_DEVELOPMENT'] try: # get application from WSGI script with open(args.wsgi_script, encoding='utf-8') as f: script = f.read() # set development flag in the script script = script.replace('development =', f'development = {development} #') # do not change working directory in the script script = script.replace('workDir =', "workDir = '' #") scriptVars = {} exec(script, scriptVars) application = scriptVars['application'] except Exception as e: raise RuntimeError( 'Cannot find Webware application.\nIs the current directory' ' the application working directory?') from e args = vars(args) for arg in 'browser reload reload_interval prod wsgi_script'.split(): del args[arg] if args['trusted_proxy_headers']: args['trusted_proxy_headers'] = args['trusted_proxy_headers'].split( ',') if not args['trusted_proxy']: if args['trusted_proxy_count'] == 1: del args['trusted_proxy_count'] if not args['trusted_proxy_headers']: del args['trusted_proxy_headers'] logLevel = args.pop('log_level') if logLevel: logLevel = logging.getLevelName(logLevel) if isinstance(logLevel, int): logger = logging.getLogger('waitress') logger.setLevel(logLevel) print(f"Waitress serving Webware application on {url}") serve(application, **args)
def run(self): # pragma: no cover if not self.args: self.out('You must give a config file') return 2 app_spec = self.args[0] vars = self.get_options() app_name = self.options.app_name if not self._scheme_re.search(app_spec): app_spec = 'config:' + app_spec server_name = self.options.server_name if self.options.server: server_spec = 'egg:pyramid' assert server_name is None server_name = self.options.server else: server_spec = app_spec base = os.getcwd() # do not open the browser on each reload so check hupper first if self.options.browser and not hupper.is_active(): def open_browser(): context = loadcontext(SERVER, app_spec, name=server_name, relative_to=base, global_conf=vars) url = 'http://127.0.0.1:{port}/'.format(**context.config()) time.sleep(1) webbrowser.open(url) t = threading.Thread(target=open_browser) t.setDaemon(True) t.start() if self.options.reload and not hupper.is_active(): if self.options.verbose > 1: self.out('Running reloading file monitor') hupper.start_reloader( 'pyramid.scripts.pserve.main', reload_interval=int(self.options.reload_interval), verbose=self.options.verbose, ) return 0 if hupper.is_active(): reloader = hupper.get_reloader() if app_spec.startswith('config:'): reloader.watch_files([app_spec[len('config:'):]]) log_fn = app_spec if log_fn.startswith('config:'): log_fn = app_spec[len('config:'):] elif log_fn.startswith('egg:'): log_fn = None if log_fn: log_fn = os.path.join(base, log_fn) setup_logging(log_fn, global_conf=vars) server = self.loadserver(server_spec, name=server_name, relative_to=base, global_conf=vars) app = self.loadapp(app_spec, name=app_name, relative_to=base, global_conf=vars) if self.options.verbose > 0: if hasattr(os, 'getpid'): msg = 'Starting server in PID %i.' % os.getpid() else: msg = 'Starting server.' self.out(msg) def serve(): try: server(app) except (SystemExit, KeyboardInterrupt) as e: if self.options.verbose > 1: raise if str(e): msg = ' ' + str(e) else: msg = '' self.out('Exiting%s (-v to see traceback)' % msg) serve()
def take_action(self, opts): if opts.stop_daemon: return self.stop_daemon(opts) if not hasattr(opts, 'set_user'): # Windows case: opts.set_user = opts.set_group = None self.verbose = self.app_args.verbose_level # @@: Is this the right stage to set the user at? self.change_user_group(opts.set_user, opts.set_group) app_spec = opts.config_file if opts.args and opts.args[0] in self.possible_subcommands: cmd = opts.args[0] restvars = opts.args[1:] else: cmd = None restvars = opts.args[0:] if cmd not in (None, 'start', 'stop', 'restart', 'status'): self.out('Error: must give start|stop|restart (not %s)' % cmd) return 2 if cmd == 'status' or opts.show_status: return self.show_status(opts) if opts.monitor_restart and opts.reload: self.out('Cannot user --monitor-restart with --reload') return 2 if opts.monitor_restart and not os.environ.get(self._monitor_environ_key): # gearbox serve was started with an angel and we are not already inside the angel. # Switch this process to being the angel and start a new one with the real server. return self.restart_with_monitor() if opts.reload and not hupper.is_active(): if self.verbose > 1: self.out('Running reloading file monitor') reloader = hupper.reloader.Reloader( worker_path='gearbox.main.main', reload_interval=opts.reload_interval, monitor_factory=hupper.reloader.find_default_monitor_factory( logging.getLogger('gearbox') ), logger=logging.getLogger('gearbox'), ) reloader.run() if hupper.is_active(): # Tack also config file changes hupper.get_reloader().watch_files([opts.config_file]) if cmd == 'restart' or cmd == 'stop': result = self.stop_daemon(opts) if result: if cmd == 'restart': self.out("Could not stop daemon; aborting") else: self.out("Could not stop daemon") return result if cmd == 'stop': return result opts.daemon = True if cmd == 'start': opts.daemon = True app_name = opts.app_name parsed_vars = self.parse_vars(restvars) if not self._scheme_re.search(app_spec): app_spec = 'config:' + app_spec server_name = opts.server_name if opts.server: server_spec = 'egg:gearbox' assert server_name is None server_name = opts.server else: server_spec = app_spec base = os.getcwd() if getattr(opts, 'daemon', False): if not opts.pid_file: opts.pid_file = 'gearbox.pid' # Ensure the pid file is writeable if opts.pid_file: try: writeable_pid_file = open(opts.pid_file, 'a') except IOError as ioe: msg = 'Error: Unable to write to pid file: %s' % ioe raise ValueError(msg) writeable_pid_file.close() if getattr(opts, 'daemon', False): try: self.daemonize(opts) except DaemonizeException as ex: if self.verbose > 0: self.out(str(ex)) return 2 if opts.pid_file: self.record_pid(opts.pid_file) log_fn = app_spec if log_fn.startswith('config:'): log_fn = app_spec[len('config:'):] elif log_fn.startswith('egg:'): log_fn = None if self.app.options.log_file: stdout_log = LazyWriter(self.app.options.log_file, 'a') sys.stdout = stdout_log sys.stderr = stdout_log try: server = self.loadserver(server_spec, name=server_name, relative_to=base, global_conf=parsed_vars) except Exception: self.out('Failed to load server', error=True) raise if log_fn: log_fn = os.path.join(base, log_fn) setup_logging(log_fn) try: app = self.loadapp(app_spec, name=app_name, relative_to=base, global_conf=parsed_vars) except Exception: self.out('Failed to load application', error=True) raise if self.verbose > 0: if hasattr(os, 'getpid'): msg = 'Starting server in PID %i.' % os.getpid() else: msg = 'Starting server.' self.out(msg) def serve(): try: server(app) except (SystemExit, KeyboardInterrupt) as e: if self.verbose > 1: raise if str(e): msg = ' ' + str(e) else: msg = '' self.out('Exiting%s (-v to see traceback)' % msg) serve()
def run(self): # pragma: no cover if not self.args.config_uri: self.out('You must give a config file') return 2 config_uri = self.args.config_uri config_vars = parse_vars(self.args.config_vars) app_spec = self.args.config_uri app_name = self.args.app_name loader = self._get_config_loader(config_uri) loader.setup_logging(config_vars) self.pserve_file_config(loader, global_conf=config_vars) server_name = self.args.server_name if self.args.server: server_spec = 'egg:pyramid' assert server_name is None server_name = self.args.server else: server_spec = app_spec server_loader = loader if server_spec != app_spec: server_loader = self.get_config_loader(server_spec) # do not open the browser on each reload so check hupper first if self.args.browser and not hupper.is_active(): url = self.open_url if not url: url = self.guess_server_url(server_loader, server_name, config_vars) if not url: self.out('WARNING: could not determine the server\'s url to ' 'open the browser. To fix this set the "open_url" ' 'setting in the [pserve] section of the ' 'configuration file.') else: def open_browser(): time.sleep(1) webbrowser.open(url) t = threading.Thread(target=open_browser) t.setDaemon(True) t.start() if self.args.reload and not hupper.is_active(): if self.args.verbose > 1: self.out('Running reloading file monitor') hupper.start_reloader('pyramid.scripts.pserve.main', reload_interval=int( self.args.reload_interval), verbose=self.args.verbose, worker_kwargs=self.worker_kwargs) return 0 config_path = self.get_config_path(loader) self.watch_files.add(config_path) server_path = self.get_config_path(server_loader) self.watch_files.add(server_path) if hupper.is_active(): reloader = hupper.get_reloader() reloader.watch_files(list(self.watch_files)) server = server_loader.get_wsgi_server(server_name, config_vars) app = loader.get_wsgi_app(app_name, config_vars) if self.args.verbose > 0: if hasattr(os, 'getpid'): msg = 'Starting server in PID %i.' % os.getpid() else: msg = 'Starting server.' self.out(msg) try: server(app) except (SystemExit, KeyboardInterrupt) as e: if self.args.verbose > 1: raise if str(e): msg = ' ' + str(e) else: msg = '' self.out('Exiting%s (-v to see traceback)' % msg)
def take_action(self, opts): if opts.stop_daemon: return self.stop_daemon(opts) if not hasattr(opts, 'set_user'): # Windows case: opts.set_user = opts.set_group = None self.verbose = self.app_args.verbose_level # @@: Is this the right stage to set the user at? self.change_user_group(opts.set_user, opts.set_group) app_spec = opts.config_file if opts.args and opts.args[0] in self.possible_subcommands: cmd = opts.args[0] restvars = opts.args[1:] else: cmd = None restvars = opts.args[0:] if cmd not in (None, 'start', 'stop', 'restart', 'status'): self.out('Error: must give start|stop|restart (not %s)' % cmd) return 2 if cmd == 'status' or opts.show_status: return self.show_status(opts) if opts.monitor_restart and opts.reload: self.out('Cannot user --monitor-restart with --reload') return 2 if opts.monitor_restart and not os.environ.get( self._monitor_environ_key): # gearbox serve was started with an angel and we are not already inside the angel. # Switch this process to being the angel and start a new one with the real server. return self.restart_with_monitor() if opts.reload and not hupper.is_active(): if self.verbose > 1: self.out('Running reloading file monitor') reloader = hupper.reloader.Reloader( worker_path='gearbox.main.main', reload_interval=opts.reload_interval, monitor_factory=hupper.reloader.find_default_monitor_factory( logging.getLogger('gearbox')), logger=logging.getLogger('gearbox'), ) reloader.run() if hupper.is_active(): # Tack also config file changes hupper.get_reloader().watch_files([opts.config_file]) if cmd == 'restart' or cmd == 'stop': result = self.stop_daemon(opts) if result: if cmd == 'restart': self.out("Could not stop daemon; aborting") else: self.out("Could not stop daemon") return result if cmd == 'stop': return result opts.daemon = True if cmd == 'start': opts.daemon = True app_name = opts.app_name parsed_vars = self.parse_vars(restvars) if not self._scheme_re.search(app_spec): app_spec = 'config:' + app_spec server_name = opts.server_name if opts.server: server_spec = 'egg:gearbox' assert server_name is None server_name = opts.server else: server_spec = app_spec base = os.getcwd() if getattr(opts, 'daemon', False): if not opts.pid_file: opts.pid_file = 'gearbox.pid' # Ensure the pid file is writeable if opts.pid_file: try: writeable_pid_file = open(opts.pid_file, 'a') except IOError as ioe: msg = 'Error: Unable to write to pid file: %s' % ioe raise ValueError(msg) writeable_pid_file.close() if getattr(opts, 'daemon', False): try: self.daemonize(opts) except DaemonizeException as ex: if self.verbose > 0: self.out(str(ex)) return 2 if opts.pid_file: self.record_pid(opts.pid_file) log_fn = app_spec if log_fn.startswith('config:'): log_fn = app_spec[len('config:'):] elif log_fn.startswith('egg:'): log_fn = None if self.app.options.log_file: stdout_log = LazyWriter(self.app.options.log_file, 'a') sys.stdout = stdout_log sys.stderr = stdout_log try: server = self.loadserver(server_spec, name=server_name, relative_to=base, global_conf=parsed_vars) except Exception: self.out('Failed to load server', error=True) raise if log_fn: log_fn = os.path.join(base, log_fn) setup_logging(log_fn) try: app = self.loadapp(app_spec, name=app_name, relative_to=base, global_conf=parsed_vars) except Exception: self.out('Failed to load application', error=True) raise if self.verbose > 0: if hasattr(os, 'getpid'): msg = 'Starting server in PID %i.' % os.getpid() else: msg = 'Starting server.' self.out(msg) def serve(): try: server(app) except (SystemExit, KeyboardInterrupt) as e: if self.verbose > 1: raise if str(e): msg = ' ' + str(e) else: msg = '' self.out('Exiting%s (-v to see traceback)' % msg) serve()
def run(self): # pragma: no cover if not self.args.config_uri: self.out('You must give a config file') return 2 config_uri = self.args.config_uri config_vars = parse_vars(self.args.config_vars) app_spec = self.args.config_uri app_name = self.args.app_name loader = self._get_config_loader(config_uri) loader.setup_logging(config_vars) self.pserve_file_config(loader, global_conf=config_vars) server_name = self.args.server_name if self.args.server: server_spec = 'egg:pyramid' assert server_name is None server_name = self.args.server else: server_spec = app_spec server_loader = loader if server_spec != app_spec: server_loader = self.get_config_loader(server_spec) # do not open the browser on each reload so check hupper first if self.args.browser and not hupper.is_active(): url = self.open_url if not url: url = self.guess_server_url( server_loader, server_name, config_vars) if not url: self.out('WARNING: could not determine the server\'s url to ' 'open the browser. To fix this set the "open_url" ' 'setting in the [pserve] section of the ' 'configuration file.') else: def open_browser(): time.sleep(1) webbrowser.open(url) t = threading.Thread(target=open_browser) t.setDaemon(True) t.start() if self.args.reload and not hupper.is_active(): if self.args.verbose > 1: self.out('Running reloading file monitor') hupper.start_reloader( 'pyramid.scripts.pserve.main', reload_interval=int(self.args.reload_interval), verbose=self.args.verbose, worker_kwargs=self.worker_kwargs ) return 0 config_path = self.get_config_path(loader) self.watch_files.add(config_path) server_path = self.get_config_path(server_loader) self.watch_files.add(server_path) if hupper.is_active(): reloader = hupper.get_reloader() reloader.watch_files(list(self.watch_files)) server = server_loader.get_wsgi_server(server_name, config_vars) app = loader.get_wsgi_app(app_name, config_vars) if self.args.verbose > 0: if hasattr(os, 'getpid'): msg = 'Starting server in PID %i.' % os.getpid() else: msg = 'Starting server.' self.out(msg) try: server(app) except (SystemExit, KeyboardInterrupt) as e: if self.args.verbose > 1: raise if str(e): msg = ' ' + str(e) else: msg = '' self.out('Exiting%s (-v to see traceback)' % msg)
def run(self): # pragma: no cover if not self.args.config_uri: self.out('You must give a config file') return 2 app_spec = self.args.config_uri vars = self.get_config_vars() app_name = self.args.app_name base = os.getcwd() if not self._scheme_re.search(app_spec): config_path = os.path.join(base, app_spec) app_spec = 'config:' + app_spec else: config_path = None server_name = self.args.server_name if self.args.server: server_spec = 'egg:pyramid' assert server_name is None server_name = self.args.server else: server_spec = app_spec # do not open the browser on each reload so check hupper first if self.args.browser and not hupper.is_active(): def open_browser(): context = loadcontext( SERVER, app_spec, name=server_name, relative_to=base, global_conf=vars) url = 'http://127.0.0.1:{port}/'.format(**context.config()) time.sleep(1) webbrowser.open(url) t = threading.Thread(target=open_browser) t.setDaemon(True) t.start() if self.args.reload and not hupper.is_active(): if self.args.verbose > 1: self.out('Running reloading file monitor') hupper.start_reloader( 'pyramid.scripts.pserve.main', reload_interval=int(self.args.reload_interval), verbose=self.args.verbose, ) return 0 if config_path: setup_logging(config_path, global_conf=vars) self.pserve_file_config(config_path, global_conf=vars) self.watch_files.append(config_path) if hupper.is_active(): reloader = hupper.get_reloader() reloader.watch_files(self.watch_files) server = self.loadserver( server_spec, name=server_name, relative_to=base, global_conf=vars) app = self.loadapp( app_spec, name=app_name, relative_to=base, global_conf=vars) if self.args.verbose > 0: if hasattr(os, 'getpid'): msg = 'Starting server in PID %i.' % os.getpid() else: msg = 'Starting server.' self.out(msg) try: server(app) except (SystemExit, KeyboardInterrupt) as e: if self.args.verbose > 1: raise if str(e): msg = ' ' + str(e) else: msg = '' self.out('Exiting%s (-v to see traceback)' % msg)
def serve(args): try: from waitress import serve except ImportError: raise RuntimeError('Waitress server is not installed') if args.browser: scheme = args.url_scheme host, port = args.host, args.port prefix = args.url_prefix.strip('/') if prefix: prefix += '/' url = f'{scheme}://{host}:{port}/{prefix}' import time import threading import webbrowser def openBrowser(): time.sleep(1) webbrowser.open(url) t = threading.Thread(target=openBrowser) t.setDaemon(True) t.start() if args.reload: try: import hupper except ImportError: raise RuntimeError('The hupper process monitor is not installed') if not hupper.is_active(): print('Running Webware with reloading option...') args.browser = args.reload = False hupper.start_reloader('webware.Scripts.WaitressServer.serve', reload_interval=int(args.reload_interval), worker_args=[args]) development = not args.prod from os import environ if development: environ['WEBWARE_DEVELOPMENT'] = 'true' elif 'WEBWARE_DEVELOPMENT' in environ: del environ['WEBWARE_DEVELOPMENT'] try: # get application from WSGI script with open('Scripts/WSGIScript.py') as f: script = f.read() # set development flag in the script script = script.replace('development =', f'development = {development} #') # do not change working directory in the script script = script.replace('workDir =', "workDir = '' #") scriptVars = {} exec(script, scriptVars) application = scriptVars['application'] except Exception as e: raise RuntimeError( f'Cannot find Webware application:\n{e}\n' 'Is the current directory the application working directory?') print("Waitress serving Webware application...") args = vars(args) for arg in 'browser reload reload_interval prod'.split(): del args[arg] if args['trusted_proxy_headers']: args['trusted_proxy_headers'] = args['trusted_proxy_headers'].split( ',') if not args['trusted_proxy']: if args['trusted_proxy_count'] == 1: del args['trusted_proxy_count'] if not args['trusted_proxy_headers']: del args['trusted_proxy_headers'] serve(application, **args)
def run(self): # pragma: no cover if not self.args.config_uri: self.out('You must give a config file') return 2 app_spec = self.args.config_uri vars = self.get_config_vars() app_name = self.args.app_name base = os.getcwd() if not self._scheme_re.search(app_spec): config_path = os.path.join(base, app_spec) app_spec = 'config:' + app_spec else: config_path = None server_name = self.args.server_name if self.args.server: server_spec = 'egg:pyramid' assert server_name is None server_name = self.args.server else: server_spec = app_spec # do not open the browser on each reload so check hupper first if self.args.browser and not hupper.is_active(): self.pserve_file_config(config_path, global_conf=vars) url = self.open_url # do not guess the url if the server is sourced from a different # location than the config_path if not url and server_spec == app_spec: url = self._guess_server_url(config_path, server_name, vars) if not url: self.out('WARNING: could not determine the server\'s url to ' 'open the browser. To fix this set the "open_url" ' 'setting in the [pserve] section of the ' 'configuration file.') else: def open_browser(): time.sleep(1) webbrowser.open(url) t = threading.Thread(target=open_browser) t.setDaemon(True) t.start() if self.args.reload and not hupper.is_active(): if self.args.verbose > 1: self.out('Running reloading file monitor') hupper.start_reloader('pyramid.scripts.pserve.main', reload_interval=int( self.args.reload_interval), verbose=self.args.verbose, worker_kwargs=self.worker_kwargs) return 0 if config_path: setup_logging(config_path, global_conf=vars) self.pserve_file_config(config_path, global_conf=vars) self.watch_files.add(config_path) if hupper.is_active(): reloader = hupper.get_reloader() reloader.watch_files(list(self.watch_files)) server = self.loadserver(server_spec, name=server_name, relative_to=base, global_conf=vars) app = self.loadapp(app_spec, name=app_name, relative_to=base, global_conf=vars) if self.args.verbose > 0: if hasattr(os, 'getpid'): msg = 'Starting server in PID %i.' % os.getpid() else: msg = 'Starting server.' self.out(msg) try: server(app) except (SystemExit, KeyboardInterrupt) as e: if self.args.verbose > 1: raise if str(e): msg = ' ' + str(e) else: msg = '' self.out('Exiting%s (-v to see traceback)' % msg)
def run(self): # pragma: no cover if not self.args.config_uri: self.out('You must give a config file') return 2 app_spec = self.args.config_uri vars = self.get_config_vars() app_name = self.args.app_name base = os.getcwd() if not self._scheme_re.search(app_spec): config_path = os.path.join(base, app_spec) app_spec = 'config:' + app_spec else: config_path = None server_name = self.args.server_name if self.args.server: server_spec = 'egg:pyramid' assert server_name is None server_name = self.args.server else: server_spec = app_spec if self.args.reload and not hupper.is_active(): if self.args.verbose > 1: self.out('Running reloading file monitor') hupper.start_reloader( 'pyramid_plaster.plserve.main', reload_interval=int(self.args.reload_interval), verbose=self.args.verbose, ) return 0 if config_path: plaster.setup_logging(config_path) self.pserve_file_config(config_path, global_conf=vars) self.watch_files.append(config_path) if hupper.is_active(): reloader = hupper.get_reloader() reloader.watch_files(self.watch_files) server = self.loadserver( config_path, name=server_name, relative_to=base, global_conf=vars) app = self.loadapp( config_path, name=app_name, relative_to=base, global_conf=vars) if self.args.verbose > 0: if hasattr(os, 'getpid'): msg = 'Starting server in PID %i.' % os.getpid() else: msg = 'Starting server.' self.out(msg) try: server(app) except (SystemExit, KeyboardInterrupt) as e: if self.args.verbose > 1: raise if str(e): msg = ' ' + str(e) else: msg = '' self.out('Exiting%s (-v to see traceback)' % msg)