def _callFUT(self, config_file):
from pyramid.scripts.common import logging_file_config
dummy_cp = DummyConfigParserModule
return logging_file_config(config_file, self.fileConfig, dummy_cp)
def run(self, shell=None):
if not self.args:
self.out("Requires a config file argument")
return
config_uri = self.args[0]
config_file = config_uri.split("#", 1)[0]
logging_file_config(config_file)
self.pshell_file_config(config_file)
# bootstrap the environ
env = self.bootstrap[0](config_uri)
# remove the closer from the env
closer = env.pop("closer")
# setup help text for default environment
env_help = dict(env)
env_help["app"] = "The WSGI application."
env_help["root"] = "Root of the default resource tree."
env_help["registry"] = "Active Pyramid registry."
env_help["request"] = "Active request object."
env_help["root_factory"] = "Default root factory used to create `root`."
# override use_script with command-line options
if self.options.setup:
self.setup = self.options.setup
if self.setup:
# store the env before muddling it with the script
orig_env = env.copy()
# call the setup callable
resolver = DottedNameResolver(None)
setup = resolver.maybe_resolve(self.setup)
setup(env)
# remove any objects from default help that were overidden
for k, v in env.items():
if k not in orig_env or env[k] != orig_env[k]:
env_help[k] = v
# load the pshell section of the ini file
env.update(self.loaded_objects)
# eliminate duplicates from env, allowing custom vars to override
for k in self.loaded_objects:
if k in env_help:
del env_help[k]
# generate help text
help = ""
if env_help:
help += "Environment:"
for var in sorted(env_help.keys()):
help += "\n %-12s %s" % (var, env_help[var])
if self.object_help:
help += "\n\nCustom Variables:"
for var in sorted(self.object_help.keys()):
help += "\n %-12s %s" % (var, self.object_help[var])
if shell is None and not self.options.disable_ipython:
shell = self.make_ipython_v0_11_shell()
if shell is None:
shell = self.make_ipython_v0_10_shell()
if shell is None:
shell = self.make_default_shell()
try:
shell(env, help)
finally:
closer()
def run(self): # pragma: no cover
if self.options.stop_daemon:
return self.stop_daemon()
if not hasattr(self.options, 'set_user'):
# Windows case:
self.options.set_user = self.options.set_group = None
# @@: Is this the right stage to set the user at?
self.change_user_group(
self.options.set_user, self.options.set_group)
if not self.args:
self.out('You must give a config file')
return
app_spec = self.args[0]
if (len(self.args) > 1
and self.args[1] in self.possible_subcommands):
cmd = self.args[1]
restvars = self.args[2:]
else:
cmd = None
restvars = self.args[1:]
if self.options.reload:
if os.environ.get(self._reloader_environ_key):
if self.verbose > 1:
self.out('Running reloading file monitor')
install_reloader(int(self.options.reload_interval))
if self.requires_config_file:
watch_file(self.args[0])
else:
return self.restart_with_reloader()
if cmd not in (None, 'start', 'stop', 'restart', 'status'):
self.out(
'Error: must give start|stop|restart (not %s)' % cmd)
return
if cmd == 'status' or self.options.show_status:
return self.show_status()
if cmd == 'restart' or cmd == 'stop':
result = self.stop_daemon()
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
self.options.daemon = True
if cmd == 'start':
self.options.daemon = True
app_name = self.options.app_name
vars = self.parse_vars(restvars)
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()
if getattr(self.options, 'daemon', False):
if not self.options.pid_file:
self.options.pid_file = 'pyramid.pid'
if not self.options.log_file:
self.options.log_file = 'pyramid.log'
# Ensure the log file is writeable
if self.options.log_file:
try:
writeable_log_file = open(self.options.log_file, 'a')
except IOError as ioe:
msg = 'Error: Unable to write to log file: %s' % ioe
raise ValueError(msg)
writeable_log_file.close()
# Ensure the pid file is writeable
if self.options.pid_file:
try:
writeable_pid_file = open(self.options.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(self.options, 'daemon', False):
try:
self.daemonize()
except DaemonizeException as ex:
if self.verbose > 0:
self.out(str(ex))
return
if (self.options.monitor_restart
and not os.environ.get(self._monitor_environ_key)):
return self.restart_with_monitor()
if self.options.pid_file:
self.record_pid(self.options.pid_file)
if self.options.log_file:
stdout_log = LazyWriter(self.options.log_file, 'a')
sys.stdout = stdout_log
sys.stderr = stdout_log
logging.basicConfig(stream=stdout_log)
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)
logging_file_config(log_fn)
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.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()
