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)
