def find_dir(self, dirname, package=False): egg_info = pluginlib.find_egg_info_dir(os.getcwd()) # @@: Should give error about egg_info when top_level.txt missing f = open(os.path.join(egg_info, 'top_level.txt')) packages = [ l.strip() for l in f.readlines() if l.strip() and not l.strip().startswith('#') ] f.close() if not len(packages): raise BadCommand("No top level dir found for %s" % dirname) # @@: This doesn't support deeper servlet directories, # or packages not kept at the top level. base = os.path.dirname(egg_info) possible = [] for pkg in packages: d = os.path.join(base, pkg, dirname) if os.path.exists(d): possible.append((pkg, d)) if not possible: self.ensure_dir(os.path.join(base, packages[0], dirname), package=package) return self.find_dir(dirname) if len(possible) > 1: raise BadCommand("Multiple %s dirs found (%s)" % (dirname, possible)) return possible[0]
def command(self): """Main command to create controller""" try: file_op = FileOp(source_dir=('pylons', 'templates')) try: name, directory = file_op.parse_path_name_args(self.args[0]) except: raise BadCommand('No egg_info directory was found') # Check the name isn't the same as the package base_package = file_op.find_dir('controllers', True)[0] if base_package.lower() == name.lower(): raise BadCommand( 'Your controller name should not be the same as ' 'the package name %r.' % base_package) # Validate the name name = name.replace('-', '_') validate_name(name) # Determine the module's import statement if is_minimal_template(base_package): importstatement = ( 'from %s.controllers import BaseController' % base_package) else: importstatement = ('from %s.lib.base import BaseController' % base_package) if defines_render(base_package): importstatement += ', render' # Setup the controller fullname = os.path.join(directory, name) controller_name = util.class_name_from_module_name( name.split('/')[-1]) if not fullname.startswith(os.sep): fullname = os.sep + fullname testname = fullname.replace(os.sep, '_')[1:] module_dir = directory.replace('/', os.path.sep) check_controller_existence(base_package, module_dir, name) file_op.template_vars.update({ 'name': controller_name, 'fname': os.path.join(directory, name), 'tmpl_name': name, 'package': base_package, 'importstatement': importstatement }) file_op.copy_file(template='controller.py_tmpl', dest=os.path.join('controllers', directory), filename=name, template_renderer=paste_script_template_renderer) if not self.options.no_test: file_op.copy_file( template='test_controller.py_tmpl', dest=os.path.join('tests', 'functional'), filename='test_' + testname, template_renderer=paste_script_template_renderer) except BadCommand, e: raise BadCommand('An error occurred. %s' % e)
def check_config_file(self): if self.installer.expect_config_directory is None: return fn = self.config_file if self.installer.expect_config_directory: if os.path.splitext(fn)[1]: raise BadCommand( "The CONFIG_FILE argument %r looks like a filename, " "and a directory name is expected" % fn) else: if fn.endswith('/') or not os.path.splitext(fn): raise BadCommand( "The CONFIG_FILE argument %r looks like a directory " "name and a filename is expected" % fn)
def command(self): if self.requires_config_file: if not self.args: raise BadCommand('You must give a config file') app_spec = self.args[0] if (len(self.args) > 1 and self.args[1] in self.possible_subcommands): self.cmd = self.args[1] self.restvars = self.args[2:] else: self.cmd = None self.restvars = self.args[1:] else: app_spec = "" if (self.args and self.args[0] in self.possible_subcommands): self.cmd = self.args[0] self.restvars = self.args[1:] else: self.cmd = None self.restvars = self.args[:] self.logging_file_config(app_spec) config_name = 'config:%s' % app_spec here_dir = os.getcwd() parser = ConfigParser.ConfigParser() parser.read([app_spec]) if not parser.has_section(self.CONFIG_SECTION): raise BadCommand('Error: %s missing %s configuration section' % \ (app_spec, self.CONFIG_SECTION)) self.config = dict( parser.items(self.CONFIG_SECTION, vars={'here': here_dir})) engine = engine_from_config(self.config, 'sqlalchemy.') init_model(engine) # Load the wsgi app first so that everything is initialized right wsgiapp = loadapp(config_name, relative_to=here_dir) test_app = paste.fixture.TestApp(wsgiapp) # Query the test app to setup the environment tresponse = test_app.get('/_test_vars') request_id = int(tresponse.body) # Restore the state of the Pylons special objects # (StackedObjectProxies) paste.registry.restorer.restoration_begin(request_id)
def parse_args(self, *av, **kw): super(Command, self).parse_args(*av, **kw) if not self.args: raise BadCommand("please specify a configuration file") config = self.args[0] self.args = self.args[1:] self.parse_config(config)
def command(self): """Main command to create a new shell""" self.verbose = 3 if len(self.args) == 0: # Assume the .ini file is ./development.ini config_file = 'development.ini' if not os.path.isfile(config_file): raise BadCommand('%sError: CONFIG_FILE not found at: .%s%s\n' 'Please specify a CONFIG_FILE' % \ (self.parser.get_usage(), os.path.sep, config_file)) else: config_file = self.args[0] config_name = 'config:%s' % config_file here_dir = os.getcwd() if not self.options.quiet: # Configure logging from the config file self.logging_file_config(config_file) # Load the wsgi app first so that everything is initialized right wsgiapp = loadapp(config_name, relative_to=here_dir) test_app = paste.fixture.TestApp(wsgiapp) # Query the test app to setup the environment and get the mapper tresponse = test_app.get('/_test_vars') mapper = tresponse.config.get('routes.map') if mapper: print mapper
def get_distribution(self, req): """ This gets a distribution object, and installs the distribution if required. """ try: dist = pkg_resources.get_distribution(req) if self.verbose: print('Distribution already installed:') print(' ', dist, 'from', dist.location) return dist except pkg_resources.DistributionNotFound: if self.options.no_install: print("Because --no-install was given, we won't try to install the package %s" % req) raise options = ['-v', '-m'] for op in self.options.easy_install_op or []: if not op.startswith('-'): op = '--'+op options.append(op) for op in self.options.easy_install_find_links or []: options.append('--find-links=%s' % op) if self.simulate: raise BadCommand( "Must install %s, but in simulation mode" % req) print("Must install %s" % req) from setuptools.command import easy_install from setuptools import setup setup(script_args=['-q', 'easy_install'] + options + [req]) return pkg_resources.get_distribution(req)
def command(self): config_spec = self.args[0] section = self.options.section_name if section is None: if '#' in config_spec: config_spec, section = config_spec.split('#', 1) else: section = 'main' if not ':' in section: plain_section = section section = 'app:'+section else: plain_section = section.split(':', 1)[0] if not config_spec.startswith('config:'): config_spec = 'config:' + config_spec if plain_section != 'main': config_spec += '#' + plain_section config_file = config_spec[len('config:'):].split('#', 1)[0] config_file = os.path.join(os.getcwd(), config_file) self.logging_file_config(config_file) conf = appconfig(config_spec, relative_to=os.getcwd()) ep_name = conf.context.entry_point_name ep_group = conf.context.protocol dist = conf.context.distribution if dist is None: raise BadCommand( "The section %r is not the application (probably a filter). You should add #section_name, where section_name is the section that configures your application" % plain_section) installer = self.get_installer(dist, ep_group, ep_name) installer.setup_config( self, config_file, section, self.sysconfig_install_vars(installer)) self.call_sysconfig_functions( 'post_setup_hook', installer, config_file)
def run(self, args): # This is overridden so we can parse sys-config before we pass # it to optparse self.sysconfigs = self.default_sysconfigs new_args = [] while args: if args[0].startswith('--no-default-sysconfig'): self.sysconfigs = [] args.pop(0) continue if args[0].startswith('--sysconfig='): self.sysconfigs.insert( 0, (True, args.pop(0)[len('--sysconfig='):])) continue if args[0] == '--sysconfig': args.pop(0) if not args: raise BadCommand( "You gave --sysconfig as the last argument without " "a value") self.sysconfigs.insert(0, (True, args.pop(0))) continue new_args.append(args.pop(0)) self.load_sysconfigs() return super(AbstractInstallCommand, self).run(new_args)
def check_controller_existence(base_package, directory, name): """Check if given controller already exists in project.""" filename = os.path.join(base_package, 'controllers', directory, name + '.py') if os.path.exists(filename): raise BadCommand('Controller %s already exists.' % os.path.join(directory, name))
def command(self): config_spec = self.args[0] if not config_spec.startswith('config:'): config_spec = 'config:' + config_spec config_file = config_spec[len('config:'):].split('#', 1)[0] config_file = os.path.join(os.getcwd(), config_file) try: import isapi_wsgi except ImportError: raise BadCommand('missing requirement: isapi-wsgi not installed') file = '''import sys if hasattr(sys, "isapidllhandle"): import win32traceutil import isapi_wsgi import os def __ExtensionFactory__(): from paste.deploy import loadapp from paste.script.util.logging_config import fileConfig fileConfig('%(inifile)s') application = loadapp('config:%(inifile)s') def app(environ, start_response): user = environ.get('REMOTE_USER', None) if user is not None: os.environ['REMOTE_USER'] = user return application(environ, start_response) return isapi_wsgi.ISAPIThreadPoolHandler(app) if __name__=='__main__': from isapi.install import * params = ISAPIParameters() sm = [ScriptMapParams(Extension="*", Flags=0)] vd = VirtualDirParameters(Name="%(virtualdir)s", Description = "Kallithea", ScriptMaps = sm, ScriptMapUpdate = "replace") params.VirtualDirs = [vd] HandleCommandLine(params) ''' outdata = file % { 'inifile': config_file.replace('\\', '\\\\'), 'virtualdir': self.options.virtualdir } dispatchfile = os.path.join(os.getcwd(), 'dispatch.py') self.ensure_file(dispatchfile, outdata, False) print 'generating', dispatchfile print( 'run \'python "%s" install\' with administrative privileges ' 'to generate the _dispatch.dll file and install it into the ' 'default web site') % (dispatchfile, )
def command(self): """Main command that starts the migration.""" super(RunMigrationCommand, self).command() if self.options.list_scripts: self.list_scripts() return if not self.restvars: raise BadCommand("You must specify a migration script to run") script = self.restvars[0] if not hasattr(scripts, script): raise BadCommand("The migration script %s does not exist" % script) migrator = getattr(scripts, script) migrator()
def validate_name(name): """Validate that the name for the controller isn't present on the path already""" if not name: # This happens when the name is an existing directory raise BadCommand('Please give the name of a controller.') # 'setup' is a valid controller name, but when paster controller is ran # from the root directory of a project, importing setup will import the # project's setup.py causing a sys.exit(). Blame relative imports if name != 'setup' and can_import(name): raise BadCommand( "\n\nA module named '%s' is already present in your " "PYTHON_PATH.\nChoosing a conflicting name will likely cause " "import problems in\nyour controller at some point. It's " "suggested that you choose an\nalternate name, and if you'd " "like that name to be accessible as\n'%s', add a route " "to your projects config/routing.py file similar\nto:\n" " map.connect('%s', controller='my_%s')" \ % (name, name, name, name)) return True
def change_user_group(self, user, group): if not user and not group: return import pwd, grp uid = gid = None if group: try: gid = int(group) group = grp.getgrgid(gid).gr_name except ValueError: import grp try: entry = grp.getgrnam(group) except KeyError: raise BadCommand( "Bad group: %r; no such group exists" % group) gid = entry.gr_gid try: uid = int(user) user = pwd.getpwuid(uid).pw_name except ValueError: try: entry = pwd.getpwnam(user) except KeyError: raise BadCommand( "Bad username: %r; no such user exists" % user) if not gid: gid = entry.pw_gid uid = entry.pw_uid if self.verbose > 0: print('Changing user to %s:%s (%s:%s)' % ( user, group or '(unknown)', uid, gid)) if hasattr(os, 'initgroups'): os.initgroups(user, gid) else: os.setgroups([e.gr_gid for e in grp.getgrall() if user in e.gr_mem] + [gid]) if gid: os.setgid(gid) if uid: os.setuid(uid)
def command(self): """Main command to create a new shell""" self.verbose = 3 if len(self.args) == 0: # Assume the .ini file is ./development.ini config_file = 'development.ini' if not os.path.isfile(config_file): raise BadCommand('CONFIG_FILE not found at: .%s%s\n' 'Please specify a CONFIG_FILE' % \ (os.path.sep, config_file) ) else: config_file = self.args[0] config_name = 'config:%s' % config_file here_dir = os.getcwd() if not self.options.quiet: # Configure logging from the config file self.logging_file_config(config_file) # XXX: Note, initializing CONFIG here is Legacy support. pylons.config # will automatically be initialized and restored via the registry # restorer along with the other StackedObjectProxys # Load app config into paste.deploy to simulate request config # Setup the Paste CONFIG object, adding app_conf/global_conf for legacy # code conf = appconfig(config_name, relative_to=here_dir) conf.update(dict(app_conf=conf.local_conf, global_conf=conf.global_conf)) paste.deploy.config.CONFIG.push_thread_config(conf) # Load locals and populate with objects for use in shell sys.path.insert(0, here_dir) # Load the wsgi app first so that everything is initialized right wsgiapp = loadapp(config_name, relative_to=here_dir) test_app = paste.fixture.TestApp(wsgiapp) # Query the test app to setup the environment tresponse = test_app.get('/_test_vars') request_id = int(tresponse.body) # Disable restoration during test_app requests test_app.pre_request_hook = lambda self: \ paste.registry.restorer.restoration_end() test_app.post_request_hook = lambda self: \ paste.registry.restorer.restoration_begin(request_id) # Restore the state of the Pylons special objects # (StackedObjectProxies) paste.registry.restorer.restoration_begin(request_id)
def command(self): """Main command to create a new shell""" self.verbose = 3 if len(self.args) == 0: # Assume the .ini file is ./development.ini config_file = 'development.ini' if not os.path.isfile(config_file): raise BadCommand('CONFIG_FILE not found at: .%s%s\n' 'Please specify a CONFIG_FILE' % \ (os.path.sep, config_file) ) else: config_file = self.args[0] init_mediadrop(config_file, here_dir=os.getcwd(), disable_logging=self.options.quiet)
def run(self, args): """ Overrides Command.run Checks for a config file argument and loads it. """ if len(args) < self.min_args: raise BadCommand( self.min_args_error % {'min_args': self.min_args, 'actual_args': len(args)}) # Decrement because we're going to lob off the first argument. # @@ This is hacky self.min_args -= 1 self.bootstrap_config(args[0]) self.update_parser(args[1:]) return super(CeleryCommand, self).run(args[1:])
def init(self): "init" if len(self.args) == 0: config_file = '/etc/baruwa/production.ini' else: config_file = self.args[0] if not os.path.isfile(config_file): raise BadCommand('%sError: CONFIG_FILE not found at: %s, ' 'Please specify a CONFIG_FILE' % (self.parser.get_usage(), config_file)) here = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) here = os.path.dirname(here) config_name = 'config:' + config_file self.logging_file_config(config_file) conf = appconfig(config_name, relative_to=here) conf.update(dict(app_conf=conf.local_conf, global_conf=conf.global_conf)) wsgiapp = loadapp(config_name, relative_to=here) self.conf = conf
def load_sysconfigs(self): configs = self.sysconfigs[:] configs.reverse() self.sysconfig_modules = [] for index, (explicit, name) in enumerate(configs): # @@: At some point I'd like to give the specialized # modules some access to the values in earlier modules, # e.g., to specialize those values or functions. That's # why these modules are loaded backwards. if name.endswith('.py'): if not os.path.exists(name): if explicit: raise BadCommand( "sysconfig file %s does not exist" % name) else: continue globs = {} exec(compile(open(name).read(), name, 'exec'), globs) mod = new.module('__sysconfig_%i__' % index) for name, value in list(globs.items()): setattr(mod, name, value) mod.__file__ = name else: try: mod = import_string.simple_import(name) except ImportError as e: if explicit: raise else: continue mod.paste_command = self self.sysconfig_modules.insert(0, mod) # @@: I'd really prefer to clone the parser here somehow, # not to modify it in place parser = self.parser self.call_sysconfig_functions('add_custom_options', parser)
def command(self): """Main command to create controller""" try: file_op = FileOp(source_dir=('pylons', 'templates')) try: singularname, singulardirectory = \ file_op.parse_path_name_args(self.args[0]) pluralname, pluraldirectory = \ file_op.parse_path_name_args(self.args[1]) except: raise BadCommand('No egg_info directory was found') # Check the name isn't the same as the package base_package = file_op.find_dir('controllers', True)[0] if base_package.lower() == pluralname.lower(): raise BadCommand( 'Your controller name should not be the same as ' 'the package name %r.' % base_package) # Validate the name for name in [pluralname]: name = name.replace('-', '_') validate_name(name) # Determine the module's import statement if is_minimal_template(base_package): importstatement = ('from %s.controllers import BaseController' % base_package) else: importstatement = ('from %s.lib.base import BaseController' % base_package) if defines_render(base_package): importstatement += ', render' module_dir = pluraldirectory.replace('/', os.path.sep) check_controller_existence(base_package, module_dir, name) # Setup the controller fullname = os.path.join(pluraldirectory, pluralname) controller_name = util.class_name_from_module_name( pluralname.split('/')[-1]) if not fullname.startswith(os.sep): fullname = os.sep + fullname testname = fullname.replace(os.sep, '_')[1:] nameprefix = '' path = '' if pluraldirectory: nameprefix = pluraldirectory.replace(os.path.sep, '_') + '_' path = pluraldirectory + '/' controller_c = '' if nameprefix: controller_c = ", controller='%s', \n\t" % \ '/'.join([pluraldirectory, pluralname]) controller_c += "path_prefix='/%s', name_prefix='%s'" % \ (pluraldirectory, nameprefix) command = "map.resource('%s', '%s'%s)\n" % \ (singularname, pluralname, controller_c) file_op.template_vars.update( {'classname': controller_name, 'pluralname': pluralname, 'singularname': singularname, 'name': controller_name, 'nameprefix': nameprefix, 'package': base_package, 'path': path, 'resource_command': command.replace('\n\t', '\n%s#%s' % \ (' ' * 4, ' ' * 9)), 'fname': os.path.join(pluraldirectory, pluralname), 'importstatement': importstatement}) resource_command = ("\nTo create the appropriate RESTful mapping, " "add a map statement to your\n") resource_command += ("config/routing.py file near the top like " "this:\n\n") resource_command += command file_op.copy_file(template='restcontroller.py_tmpl', dest=os.path.join('controllers', pluraldirectory), filename=pluralname, template_renderer=paste_script_template_renderer) if not self.options.no_test: file_op.copy_file( template='test_restcontroller.py_tmpl', dest=os.path.join('tests', 'functional'), filename='test_' + testname, template_renderer=paste_script_template_renderer) print resource_command except BadCommand, e: raise BadCommand('An error occurred. %s' % e)
def get_or_raise(key): if key not in self.config: raise BadCommand( 'Error: %s %s configuration section is missing a ' 'value for %s' % (app_spec, self.CONFIG_SECTION, key)) return self.config[key]
def command(self): self.requirement = self.args[0] if '#' in self.requirement: if self.options.ep_name is not None: raise BadCommand( "You may not give both --name and a requirement with " "#name") self.requirement, self.options.ep_name = self.requirement.split('#', 1) if not self.options.ep_name: self.options.ep_name = 'main' self.distro = self.get_distribution(self.requirement) self.installer = self.get_installer( self.distro, self.options.ep_group, self.options.ep_name) if self.options.show_info: if len(self.args) > 1: raise BadCommand( "With --info you can only give one argument") return self.show_info() if len(self.args) < 2: # See if sysconfig can give us a default filename options = [_f for _f in self.call_sysconfig_functions( 'default_config_filename', self.installer) if _f] if not options: raise BadCommand( "You must give a configuration filename") self.config_file = options[0] else: self.config_file = self.args[1] self.check_config_file() self.project_name = self.distro.project_name self.vars = self.sysconfig_install_vars(self.installer) self.vars.update(self.parse_vars(self.args[2:])) self.vars['project_name'] = self.project_name self.vars['requirement'] = self.requirement self.vars['ep_name'] = self.options.ep_name self.vars['ep_group'] = self.options.ep_group self.vars.setdefault('app_name', self.project_name.lower()) self.vars.setdefault('app_instance_uuid', uuid.uuid4()) self.vars.setdefault('app_instance_secret', secret.secret_string()) if self.verbose > 1: print_vars = list(self.vars.items()) print_vars.sort() print('Variables for installation:') for name, value in print_vars: print(' %s: %r' % (name, value)) self.installer.write_config(self, self.config_file, self.vars) edit_success = True if self.options.edit: edit_success = self.run_editor() setup_configs = self.installer.editable_config_files(self.config_file) # @@: We'll just assume the first file in the list is the one # that works with setup-app... setup_config = setup_configs[0] if self.options.run_setup: if not edit_success: print('Config-file editing was not successful.') if self.ask('Run setup-app anyway?', default=False): self.run_setup(setup_config) else: self.run_setup(setup_config) else: filenames = self.installer.editable_config_files(self.config_file) assert not isinstance(filenames, str), ( "editable_config_files returned a string, not a list") if not filenames and filenames is not None: print('No config files need editing') else: print('Now you should edit the config files') if filenames: for fn in filenames: print(' %s' % fn)
def command(self): """Main command to create a new shell""" self.verbose = 3 if len(self.args) == 0: # Assume the .ini file is ./development.ini config_file = 'development.ini' if not os.path.isfile(config_file): raise BadCommand('%sError: CONFIG_FILE not found at: .%s%s\n' 'Please specify a CONFIG_FILE' % \ (self.parser.get_usage(), os.path.sep, config_file)) else: config_file = self.args[0] config_name = 'config:%s' % config_file here_dir = os.getcwd() locs = dict(__name__="pylons-admin") # XXX: Note, initializing CONFIG here is Legacy support. pylons.config # will automatically be initialized and restored via the registry # restorer along with the other StackedObjectProxys # Load app config into paste.deploy to simulate request config # Setup the Paste CONFIG object, adding app_conf/global_conf for legacy # code conf = appconfig(config_name, relative_to=here_dir) conf.update( dict(app_conf=conf.local_conf, global_conf=conf.global_conf)) paste.deploy.config.CONFIG.push_thread_config(conf) # Load locals and populate with objects for use in shell sys.path.insert(0, here_dir) # Load the wsgi app first so that everything is initialized right wsgiapp = loadapp(config_name, relative_to=here_dir) test_app = paste.fixture.TestApp(wsgiapp) # Query the test app to setup the environment tresponse = test_app.get('/_test_vars') request_id = int(tresponse.body) # Disable restoration during test_app requests test_app.pre_request_hook = lambda self: \ paste.registry.restorer.restoration_end() test_app.post_request_hook = lambda self: \ paste.registry.restorer.restoration_begin(request_id) # Restore the state of the Pylons special objects # (StackedObjectProxies) paste.registry.restorer.restoration_begin(request_id) # Determine the package name from the .egg-info top_level.txt. egg_info = find_egg_info_dir(here_dir) f = open(os.path.join(egg_info, 'top_level.txt')) packages = [ l.strip() for l in f.readlines() if l.strip() and not l.strip().startswith('#') ] f.close() # Start the rest of our imports now that the app is loaded found_base = False for pkg_name in packages: # Import all objects from the base module base_module = pkg_name + '.lib.base' found_base = can_import(base_module) if not found_base: # Minimal template base_module = pkg_name + '.controllers' found_base = can_import(base_module) if found_base: break if not found_base: raise ImportError("Could not import base module. Are you sure " "this is a Pylons app?") base = sys.modules[base_module] base_public = [__name for __name in dir(base) if not \ __name.startswith('_') or __name == '_'] for name in base_public: locs[name] = getattr(base, name) locs.update(dict(wsgiapp=wsgiapp, app=test_app)) mapper = tresponse.config.get('routes.map') if mapper: locs['mapper'] = mapper banner = " All objects from %s are available\n" % base_module banner += " Additional Objects:\n" if mapper: banner += " %-10s - %s\n" % ('mapper', 'Routes mapper object') banner += " %-10s - %s\n" % ('wsgiapp', "This project's WSGI App instance") banner += " %-10s - %s\n" % ('app', 'paste.fixture wrapped around wsgiapp') if not self.options.quiet: # Configure logging from the config file self.logging_file_config(config_file) try: if self.options.disable_ipython: raise ImportError() # try to use IPython if possible from IPython.Shell import IPShellEmbed shell = IPShellEmbed(argv=self.args) shell.set_banner(shell.IP.BANNER + '\n\n' + banner) try: shell(local_ns=locs, global_ns={}) finally: paste.registry.restorer.restoration_end() except ImportError: import code newbanner = "Pylons Interactive Shell\nPython %s\n\n" % sys.version banner = newbanner + banner shell = code.InteractiveConsole(locals=locs) try: import readline except ImportError: pass try: shell.interact(banner) finally: paste.registry.restorer.restoration_end()
def command(self): """Main command to create a new shell""" self.verbose = 3 if len(self.args) == 0: # Assume the .ini file is ./development.ini config_file = 'development.ini' if not os.path.isfile(config_file): raise BadCommand('%sError: CONFIG_FILE not found at: .%s%s\n' 'Please specify a CONFIG_FILE' % \ (self.parser.get_usage(), os.path.sep, config_file)) else: config_file = self.args[0] config_name = 'config:%s' % config_file here_dir = os.getcwd() locs = dict(__name__="pylons-admin") if not self.options.quiet: # Configure logging from the config file self.logging_file_config(config_file) # Load locals and populate with objects for use in shell sys.path.insert(0, here_dir) # Load the wsgi app first so that everything is initialized right wsgiapp = loadapp(config_name, relative_to=here_dir) test_app = paste.fixture.TestApp(wsgiapp) # Query the test app to setup the environment tresponse = test_app.get('/_test_vars') request_id = int(tresponse.body) # Disable restoration during test_app requests test_app.pre_request_hook = lambda self: \ paste.registry.restorer.restoration_end() test_app.post_request_hook = lambda self: \ paste.registry.restorer.restoration_begin(request_id) # Restore the state of the Pylons special objects # (StackedObjectProxies) paste.registry.restorer.restoration_begin(request_id) # Determine the package name from the pylons.config object pkg_name = pylons.config['pylons.package'] # Start the rest of our imports now that the app is loaded if is_minimal_template(pkg_name, True): model_module = None helpers_module = pkg_name + '.helpers' base_module = pkg_name + '.controllers' else: model_module = pkg_name + '.model' helpers_module = pkg_name + '.lib.helpers' base_module = pkg_name + '.lib.base' if model_module and can_import(model_module): locs['model'] = sys.modules[model_module] if can_import(helpers_module): locs['h'] = sys.modules[helpers_module] exec ('from pylons import app_globals, config, request, response, ' 'session, tmpl_context, url') in locs exec ('from pylons.controllers.util import abort, redirect') in locs exec 'from pylons.i18n import _, ungettext, N_' in locs locs.pop('__builtins__', None) # Import all objects from the base module __import__(base_module) base = sys.modules[base_module] base_public = [__name for __name in dir(base) if not \ __name.startswith('_') or __name == '_'] locs.update((name, getattr(base, name)) for name in base_public) locs.update(dict(wsgiapp=wsgiapp, app=test_app)) mapper = tresponse.config.get('routes.map') if mapper: locs['mapper'] = mapper banner = " All objects from %s are available\n" % base_module banner += " Additional Objects:\n" if mapper: banner += " %-10s - %s\n" % ('mapper', 'Routes mapper object') banner += " %-10s - %s\n" % ('wsgiapp', "This project's WSGI App instance") banner += " %-10s - %s\n" % ('app', 'paste.fixture wrapped around wsgiapp') try: if self.options.disable_ipython: raise ImportError() # try to use IPython if possible try: # ipython >= 0.11 from IPython.frontend.terminal.embed import InteractiveShellEmbed shell = InteractiveShellEmbed(banner2=banner) except ImportError: # ipython < 0.11 from IPython.Shell import IPShellEmbed shell = IPShellEmbed(argv=self.args) shell.set_banner(shell.IP.BANNER + '\n\n' + banner) try: shell(local_ns=locs, global_ns={}) finally: paste.registry.restorer.restoration_end() except ImportError: import code py_prefix = sys.platform.startswith('java') and 'J' or 'P' newbanner = "Pylons Interactive Shell\n%sython %s\n\n" % \ (py_prefix, sys.version) banner = newbanner + banner shell = code.InteractiveConsole(locals=locs) try: import readline except ImportError: pass try: shell.interact(banner) finally: paste.registry.restorer.restoration_end()
def command(self): 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 self.requires_config_file: if not self.args: raise BadCommand('You must give a config file') 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:] else: app_spec = "" if (self.args and self.args[0] in self.possible_subcommands): cmd = self.args[0] restvars = self.args[1:] else: cmd = None restvars = self.args[:] if (getattr(self.options, 'daemon', False) and getattr(self.options, 'reload', False)): raise BadCommand('The --daemon and --reload options may not be used together') jython_monitor = False if self.options.reload: if jython and not self.options.disable_jython_reloader: # JythonMonitor raises the special SystemRestart # exception that'll cause the Jython interpreter to # reload in the existing Java process (avoiding # subprocess startup time) try: from paste.reloader import JythonMonitor except ImportError: pass else: jython_monitor = JythonMonitor(poll_interval=int( self.options.reload_interval)) if self.requires_config_file: jython_monitor.watch_file(self.args[0]) if not jython_monitor: if os.environ.get(self._reloader_environ_key): from paste import reloader if self.verbose > 1: print('Running reloading file monitor') reloader.install(int(self.options.reload_interval)) if self.requires_config_file: reloader.watch_file(self.args[0]) else: return self.restart_with_reloader() if cmd not in (None, 'start', 'stop', 'restart', 'status'): raise BadCommand( 'Error: must give start|stop|restart (not %s)' % cmd) 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': print("Could not stop daemon; aborting") else: print("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:PasteScript' 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 = 'paster.pid' if not self.options.log_file: self.options.log_file = 'paster.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 BadCommand(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 BadCommand(msg) writeable_pid_file.close() if getattr(self.options, 'daemon', False): try: self.daemonize() except DaemonizeException as ex: if self.verbose > 0: print(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) self.logging_file_config(log_fn) try: 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) except SyntaxError as e: if self.options.reload and os.environ.get(self._reloader_environ_key): traceback.print_exc() reloader.watch_file(e.filename) while True: time.sleep(60*60) else: raise if self.verbose > 0: if hasattr(os, 'getpid'): msg = 'Starting server in PID %i.' % os.getpid() else: msg = 'Starting server.' print(msg) def serve(): try: server(app) except (SystemExit, KeyboardInterrupt) as e: if self.verbose > 1: raise if str(e): msg = ' '+str(e) else: msg = '' print('Exiting%s (-v to see traceback)' % msg) if jython_monitor: # JythonMonitor has to be ran from the main thread threading.Thread(target=serve).start() print('Starting Jython file monitor') jython_monitor.periodic_reload() else: serve()
'importstatement': importstatement}) file_op.copy_file(template='controller.py_tmpl', dest=os.path.join('controllers', directory), filename=name, template_renderer=paste_script_template_renderer) if not self.options.no_test: file_op.copy_file( template='test_controller.py_tmpl', dest=os.path.join('tests', 'functional'), filename='test_' + testname, template_renderer=paste_script_template_renderer) except BadCommand, e: raise BadCommand('An error occurred. %s' % e) except: msg = str(sys.exc_info()[1]) raise BadCommand('An unknown error occurred. %s' % msg) class RestControllerCommand(Command): """Create a REST Controller and accompanying functional test The RestController command will create a REST-based Controller file for use with the :meth:`~routes.mapper.Mapper.resource` REST-based dispatching. This template includes the methods that :meth:`~routes.mapper.Mapper.resource` dispatches to in addition to doc strings for clarification on when the methods will be called. The first argument should be the singular form of the REST resource. The second argument is the plural form of the word. If its a nested controller, put the directory information in front as