Beispiel #1
0
    def command(self):
        if self.options.reload:
            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))

            else:
                self.restart_with_reloader()

        if self.verbose > 0:
            if hasattr(os, 'getpid'):
                msg = 'Starting server in PID %i.' % os.getpid()
            else:
                msg = 'Starting server.'
            print msg

        try:
            self.serve()
        except (SystemExit, KeyboardInterrupt), e:
            if self.verbose > 1:
                raise
            if str(e):
                msg = ' '+str(e)
            else:
                msg = ''
            print 'Exiting%s (-v to see traceback)' % msg
Beispiel #2
0
 def reloader():
     from paste import reloader
     reloader.install()
     reloader.watch_file(cfgfile)
     import glob # Restart on "compile_catalog"
     # TODO: make more generic, and more robust
     for lang in glob.glob('*/locale/*/LC_MESSAGES/*.mo'):
         reloader.watch_file(lang)
     for lang in glob.glob('*/i18n/*/LC_MESSAGES/*.mo'):
         reloader.watch_file(lang)
Beispiel #3
0
 def reloader():
     from paste import reloader
     reloader.install()
     reloader.watch_file(cfgfile)
     import glob  # Restart on "compile_catalog"
     # TODO: make more generic, and more robust
     for lang in glob.glob('*/locale/*/LC_MESSAGES/*.mo'):
         reloader.watch_file(lang)
     for lang in glob.glob('*/i18n/*/LC_MESSAGES/*.mo'):
         reloader.watch_file(lang)
Beispiel #4
0
def make_server(global_conf, port, host='', use_reloader=False):
    port = int(port)

    if use_reloader:
        from paste import reloader
        reloader.install()

    def serve(app):
        from paste import httpserver
        httpserver.serve(app, host=host, port=port)
    return serve
Beispiel #5
0
def _initConfig():
    """Setup configuration dictionary from default, command line and configuration file."""
    cmdLineOpts = _initCommandLineOptions()

    # Set config defaults
    config = DEFAULT_CONFIG.copy()

    # Configuration file overrides defaults
    config_file = cmdLineOpts.get("config_file")
    if config_file:
        verbose = cmdLineOpts.get("verbose", 2)
        fileConf = _readConfigFile(config_file, verbose)
        config.update(fileConf)
    else:
        if cmdLineOpts["verbose"] >= 2:
            print "Running without configuration file."

    # Command line overrides file
    if cmdLineOpts.get("port"):
        config["port"] = cmdLineOpts.get("port")
    if cmdLineOpts.get("host"):
        config["host"] = cmdLineOpts.get("host")
    if cmdLineOpts.get("verbose") is not None:
        config["verbose"] = cmdLineOpts.get("verbose")
    if cmdLineOpts.get("profile") is not None:
        config["profile"] = True

    if cmdLineOpts.get("root_path"):
        root_path = os.path.abspath(cmdLineOpts.get("root_path"))
        config["provider_mapping"]["/"] = FilesystemProvider(root_path)

    if cmdLineOpts["verbose"] >= 3:
        print "Configuration(%s):" % cmdLineOpts["config_file"]
        pprint(config)

    if not config["provider_mapping"]:
        print >> sys.stderr, "ERROR: No DAV provider defined. Try --help option."
        sys.exit(-1)
#        raise RuntimeWarning("At least one DAV provider must be specified by a --root option, or in a configuration file.")

    if cmdLineOpts.get("reload"):
        print >> sys.stderr, "Installing paste.reloader."
        from paste import reloader  #@UnresolvedImport
        reloader.install()
        if config_file:
            # Add config file changes
            reloader.watch_file(config_file)


#        import pydevd
#        pydevd.settrace()

    return config
Beispiel #6
0
def run_script(script):
    if not os.path.isfile(script):
        print script, "does not exist"
        sys.exit(1)
    reloader.install()
    reloader.watch_file(script)

    script_locals = {}
    execfile(script, {'__file__': script}, script_locals)
    app = script_locals['application']
    app = EvalException(app)
    app = PrintDebugMiddleware(app)
    serve(app)
Beispiel #7
0
def _initConfig():
    """Setup configuration dictionary from default, command line and configuration file."""
    cmdLineOpts = _initCommandLineOptions()

    # Set config defaults
    config = DEFAULT_CONFIG.copy()

    # Configuration file overrides defaults
    config_file = cmdLineOpts.get("config_file")
    if config_file: 
        verbose = cmdLineOpts.get("verbose", 2)
        fileConf = _readConfigFile(config_file, verbose)
        config.update(fileConf)
    else:
        if cmdLineOpts["verbose"] >= 2:
            print "Running without configuration file."
    
    # Command line overrides file
    if cmdLineOpts.get("port"):
        config["port"] = cmdLineOpts.get("port")
    if cmdLineOpts.get("host"):
        config["host"] = cmdLineOpts.get("host")
    if cmdLineOpts.get("verbose") is not None:
        config["verbose"] = cmdLineOpts.get("verbose")
    if cmdLineOpts.get("profile") is not None:
        config["profile"] = True

    if cmdLineOpts.get("root_path"):
        root_path = os.path.abspath(cmdLineOpts.get("root_path"))
        config["provider_mapping"]["/"] = FilesystemProvider(root_path)
    
    if cmdLineOpts["verbose"] >= 3:
        print "Configuration(%s):" % cmdLineOpts["config_file"]
        pprint(config)

    if not config["provider_mapping"]:
        print >>sys.stderr, "ERROR: No DAV provider defined. Try --help option."
        sys.exit(-1)
#        raise RuntimeWarning("At least one DAV provider must be specified by a --root option, or in a configuration file.")

    if cmdLineOpts.get("reload"):
        print >>sys.stderr, "Installing paste.reloader."
        from paste import reloader  #@UnresolvedImport
        reloader.install()
        if config_file:
            # Add config file changes
            reloader.watch_file(config_file)
#        import pydevd
#        pydevd.settrace()

    return config
Beispiel #8
0
    def wsgi_serve(self, with_reloader):
        if not with_reloader or self._reloader_key not in os.environ:
            self.logger.info('Listening on: %s:%s' % (self.host, self.port))

        if self._reloader_key in os.environ:
            self.logger.info('Monitoring code files')
            reloader.install()

        if self._reloader_key in os.environ or not with_reloader:
            if self.use_rfoo:
                from rfoo.utils import rconsole
                rconsole.spawn_server(self.rfoo_namespace, self.rfoo_port)
                self.logger.info('Rfoo listening on port %i' % self.rfoo_port)
            self.logger.info('http ready')

            server = WSGIServer(self.application, self.host, self.port,
                                get_http_logger(self.logger))
            server.serve_forever()
            return

        self.restart_with_reloader()
Beispiel #9
0
    def wsgi_serve(self, with_reloader):
        if not with_reloader or self._reloader_key not in os.environ:
            self.logger.info('Listening on: %s:%s' % (self.host, self.port))

        if self._reloader_key in os.environ:
            self.logger.info('Monitoring code files')
            reloader.install()

        if self._reloader_key in os.environ or not with_reloader:
            if self.use_rfoo:
                from rfoo.utils import rconsole
                rconsole.spawn_server(self.rfoo_namespace, self.rfoo_port)
                self.logger.info('Rfoo listening on port %i' % self.rfoo_port)
            self.logger.info('http ready')

            server = WSGIServer(self.application, self.host,
                                self.port, get_http_logger(self.logger))
            server.serve_forever()
            return

        self.restart_with_reloader()
Beispiel #10
0
def main():
    parser = ArgumentParser(description="DVDev: Distributed Versioned Development")

    parser.add_argument(
        'repositories', metavar='repository', type=str, nargs='*',
        default=[os.getcwd()],
        help='List of repositories to serve. If left blank, DVDev will search '
        'the current and subdirectories for existing repositories.')

    parser.add_argument(
        '-d', '--debug', action='store_true', default=False,
        help='Start dvdev in debugging mode.  This causes dvdev to monitor '
        'it\'s own source files and reload if they have changed.  Normally, '
        'only DVDev developers will ever have need of this functionality.')

    parser.add_argument(
        '-f', '--fragile', action='store_true', default=False,
        help='INTERNAL USE ONLY.  When specified, start a thread that watches '
        'DVDev\'s source files.  If any change, then quit this process.')

    parser.add_argument(
        '-c', '--create', action='store_true', default=False,
        help='For any directories passed in on the command line (or the '
        'current directory, if none), initialize them as a repository if they '
        'do not already contain one.')

    parser.add_argument(
        '-n', '--nolaunch', action='store_true', default=False,
        help='Don\'t launch a web browser after starting the http server.')

    parser.add_argument(
        '-p', '--port', type=int, default=4000,
        help='The port to serve on (by default: 4000).  If this port is in '
        'use, dvdev will try to randomly select an open port.')

    parser.add_argument(
        '-i', '--ip', default='0.0.0.0',
        help='The IP address to listen on. Defaults to 0.0.0.0, which means '
        'all IPv4 addresses')

    args = parser.parse_args()

    # We're gonna implement magic reload functionality, as seen in paster
    # serve. (Thanks, Ian Bicking, for the code and the explanation of what to
    # do.)

    # When this command is called with --debug, it does no actual serving.  It
    # opens a new process with a special flag that will tell DVDev to launch in
    # 'fragile mode'.  This means that it will call paste.reload.install(),
    # which starts a thread that kills the process if any of it's files change.

    # Meanwhile, back at the ranch (this process) we'll watch to see if our
    # subprocess dies and simply launch it again.  At the same time, we'll
    # watch for a Ctrl-C so that the user can interrupt us (and by extension,
    # the server.)

    if args.debug:

        nolaunch = args.nolaunch
        while True:
            child = None
            try:
                try:
                    print "Launching server process"
                    exit_code, child = launch_and_watch_child(_server_args(args, nolaunch))
                    if not child:
                        break

                    # We only let nolaunch be False on the first subprocess launch.
                    # After that, we never want to launch a webbrowser.
                    nolaunch = True
                except (SystemExit, KeyboardInterrupt):
                    "^C Pressed, shutting down server"
                    return
            finally:
                if child and hasattr(os, 'kill'):
                    # Apparantly, windows will litter processes in the case of
                    # catastrophic failure.
                    try:
                        os.kill(child, signal.SIGTERM)
                    except (OSError, IOError):
                        pass
            if exit_code != 3:
                # The child exited non-normally, so we will too.
                return exit_code


    if args.fragile:
        # This simple form does not work in jython, so I should fix that, since
        # the code is already written into paste.serve
        from paste import reloader
        # Do we need to allow a way to slow this down?  Defaults to checking
        # once per second.
        reloader.install()
        # If we ever add a config file, we need to add that to the watch list
        # like this:
        # reloader.watch_file(my_config_file)

    for index, repository in enumerate(args.repositories):
        if os.path.exists(repository):
            continue
        # Maybe this is a repository URL that mercurial recognizes?
        myui = ui.ui()
        myui.pushbuffer()

        from urllib2 import URLError
        try:
            commands.clone(myui, repository)
        except (RepoError, URLError):
            if args.create:
                try:
                    os.makedirs(repository)
                    try:
                        commands.init(myui, repository)
                        continue
                    except:
                        os.unlink(repository)
                except IOError:
                    pass
            print "Bad repository: %s" % repository
            import sys
            sys.exit(1)

        destination = myui.popbuffer().split('\n')[0]
        destination = destination.split('destination directory: ')[1]

        if not os.path.exists(destination):
            print "Successfully cloned repository %s but unable to read "\
            "local copy at %s" % (repository, destination)
            import sys
            sys.exit(1)
        print "Cloned repository %s in local directory %s" % (repository, destination)

        # Update our repository list with the new local copy
        args.repositories[index] = destination

    if args.create:
        all_repos = []
        for repo in args.repositories:
            found_repos = flatten(build_repo_tree(repo))
            if not found_repos:
                # Initialize
                myui = ui.ui()
                commands.init(myui, repo)
            else:
                all_repos += found_repos
    else:
        all_repos = filter(None, flatten([build_repo_tree(repo) for repo in args.repositories]))
    print "All repositories: %r" % all_repos
    config = {
        'use': 'egg:DVDev',
        'full_stack': 'true',
        'static_files': 'true',

        'reporoot': os.getcwd(),
        'cache_dir': os.path.join(os.getcwd(), 'data'),
        'beaker.session.key': 'dvdev',
        'beaker.session.secret': 'somesecret',

        'repo': ' '.join(all_repos),
        'project_home': 'issues',
        'who.log_level': 'debug',
        'who.log_file': 'stdout',
        'workspace': os.path.join(os.getcwd(), 'workspace'),
    }
    from dvdev.config.middleware import make_app
    app = make_app({'debug':(args.debug or args.fragile) and 'true' or 'false'}, **config)

    import webbrowser
    def webhelper(url):
        """\
        Curry the webbrowser.open method so that we can cancel it with a
        threaded timer."""
        def _launch_closure():
            webbrowser.open(url)
        return _launch_closure

    # Paste's httpserver doesn't return once it's started serving (which is
    # pretty normal).  The only problem is that we don't know if it
    # successfully captured the port unless it didn't return.  We don't want to
    # open the user's webbrowser unless we're successfully serving, so it's
    # sort of a chicken and egg problem.  We'll start a timer with a half
    # second delay (forever in computer time) in another thread.  If the server
    # returns, we'll cancel the timer, and try again.
    if not args.nolaunch:
        from threading import Timer
        safelaunch = Timer(0.7, webhelper('http://%s:%d/' % (args.ip, args.port)))
        safelaunch.start()

    import socket
    from paste.httpserver import serve
    try:
        serve(app, host=args.ip, port=args.port)
    except socket.error, e:
        safelaunch.cancel()
        print "Unable to serve on port %d : Error message was: %s" % (args.port, e[1])
Beispiel #11
0
def _init_config():
    """Setup configuration dictionary from default, command line and configuration file."""
    cli_opts = _init_command_line_options()
    cli_verbose = cli_opts["verbose"]

    # Set config defaults
    # config = DEFAULT_CONFIG.copy()
    config = copy.deepcopy(DEFAULT_CONFIG)

    # Configuration file overrides defaults
    config_file = cli_opts.get("config_file")
    if config_file:
        file_opts = _read_config_file(config_file, cli_verbose)
        # config.update(file_opts)
        util.deep_update(config, file_opts)
        if cli_verbose != DEFAULT_VERBOSE and "verbose" in file_opts:
            if cli_verbose >= 2:
                print("Config file defines 'verbose: {}' but is overridden by command line: {}."
                      .format(file_opts["verbose"], cli_verbose))
            config["verbose"] = cli_verbose
    else:
        if cli_verbose >= 2:
            print("Running without configuration file.")

    # Command line overrides file
    if cli_opts.get("port"):
        config["port"] = cli_opts.get("port")
    if cli_opts.get("host"):
        config["host"] = cli_opts.get("host")
    if cli_opts.get("verbose") is not None:
        config["verbose"] = cli_opts.get("verbose")
    if cli_opts.get("profile") is not None:
        config["profile"] = True
    if cli_opts.get("server") is not None:
        config["server"] = cli_opts.get("server")
    if cli_opts.get("ssl_adapter") is not None:
        config["ssl_adapter"] = cli_opts.get("ssl_adapter")

    if cli_opts.get("root_path"):
        root_path = os.path.abspath(cli_opts.get("root_path"))
        config["provider_mapping"]["/"] = FilesystemProvider(root_path)

    if config["verbose"] >= 5:
        print("Configuration({}):\n{}"
              .format(cli_opts["config_file"], pformat(config)))

    if not config["provider_mapping"]:
        print("ERROR: No DAV provider defined. Try --help option.", file=sys.stderr)
        sys.exit(-1)

    if cli_opts.get("reload"):
        print("Installing paste.reloader.", file=sys.stderr)
        from paste import reloader  # @UnresolvedImport
        reloader.install()
        if config_file:
            # Add config file changes
            reloader.watch_file(config_file)
        # import pydevd
        # pydevd.settrace()

    return config
Beispiel #12
0
		metavar="PORT", default = 8051)

	parser.add_option("-s", "--scheduler", dest="scheduler",
		help="The scheduling algorithm to be used by The Grid", 
		metavar="SCHEDULER", default = "FCFS")

	(options, args) = parser.parse_args()

	# Bring the Grid online
	try:
		model.grid = Grid(options.username, options.password, options.scheduler)
	except InvalidSchedulerException:
		print "Invalid Scheduler %s. Valid schedulers: %s." % (options.scheduler, ", ".join(Grid.SCHEDULERS))
		sys.exit(1)

	# Initalise the WSGI Server
	reloader.install()

	host = options.host
	port = options.port

	app = gridservice.utils.make_app(routes)
	try:
		httpserver.serve(app, host = host, port = port)
	except Exception:
		print 'Unable to start The Grid on this host and port, please try a different host and port.'
		sys.exit(1)



Beispiel #13
0
 def install(cls):
     from paste import reloader
     reloader.install(int(1))
Beispiel #14
0
    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(
                f'Error: must give start|stop|restart (not {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:
                print("Could not stop daemon")
                # It's ok to continue trying to restart if stop_daemon returns
                # a 1, otherwise shortcut and return.
                if cmd == 'restart' and result != 1:
                    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 = f"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 OSError as ioe:
                msg = f'Error: Unable to write to log file: {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 OSError as ioe:
                msg = f'Error: Unable to write to pid file: {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)

        server = loadserver(server_spec, name=server_name, relative_to=base, global_conf=vars)

        app = 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.'
            print(msg)

        def serve():
            try:
                server(app)
            except (SystemExit, KeyboardInterrupt) as e:
                if self.verbose > 1:
                    raise
                if str(e):
                    msg = f" {str(e)}"
                else:
                    msg = ''
                print(f'Exiting{msg} (-v to see traceback)')
            except AttributeError as e:
                # Capturing bad error response from paste
                if str(e) == "'WSGIThreadPoolServer' object has no attribute 'thread_pool'":
                    raise OSError(98, 'Address already in use')
                else:
                    raise AttributeError(e)

        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()
Beispiel #15
0
class Webapp2HandlerAdapter(webapp2.BaseHandlerAdapter):

    def __call__(self, request, response, exception):
        request.route_args = {
            'exception': exception
        }
        logging.exception(exception)
        handler = self.handler(request, response)

        return handler.get()

app.error_handlers[403] = Webapp2HandlerAdapter(errors.Error403Handler)
app.error_handlers[404] = Webapp2HandlerAdapter(errors.Error404Handler)
app.error_handlers[503] = Webapp2HandlerAdapter(errors.Error503Handler)
app.error_handlers[500] = Webapp2HandlerAdapter(errors.Error500Handler)

# Static File Serving
static_app = StaticURLParser("static/")

# Check static files first then fallback
application = Cascade([static_app, app])

if __name__ == '__main__' and basehandler.IS_DEV:
    import paste.reloader as reloader
    reloader.install(10)

    from paste.translogger import TransLogger
    application = TransLogger(application, logger_name=None)

    from paste import httpserver
    httpserver.serve(application, host='127.0.0.1', port='8080')
Beispiel #16
0
def _init_config():
    """Setup configuration dictionary from default, command line and configuration file."""
    cli_opts, parser = _init_command_line_options()
    cli_verbose = cli_opts["verbose"]

    # Set config defaults
    config = copy.deepcopy(DEFAULT_CONFIG)

    # Configuration file overrides defaults
    config_file = cli_opts.get("config_file")
    if config_file:
        file_opts = _read_config_file(config_file, cli_verbose)
        util.deep_update(config, file_opts)
        if cli_verbose != DEFAULT_VERBOSE and "verbose" in file_opts:
            if cli_verbose >= 2:
                print(
                    "Config file defines 'verbose: {}' but is overridden by command line: {}.".format(
                        file_opts["verbose"], cli_verbose
                    )
                )
            config["verbose"] = cli_verbose
    else:
        if cli_verbose >= 2:
            print("Running without configuration file.")

    # Command line overrides file
    if cli_opts.get("port"):
        config["port"] = cli_opts.get("port")
    if cli_opts.get("host"):
        config["host"] = cli_opts.get("host")
    if cli_opts.get("profile") is not None:
        config["profile"] = True
    if cli_opts.get("server") is not None:
        config["server"] = cli_opts.get("server")
    if cli_opts.get("ssl_adapter") is not None:
        config["ssl_adapter"] = cli_opts.get("ssl_adapter")

    # Command line overrides file only if -v or -q where passed:
    if cli_opts.get("verbose") != DEFAULT_VERBOSE:
        config["verbose"] = cli_opts.get("verbose")

    if cli_opts.get("root_path"):
        root_path = os.path.abspath(cli_opts.get("root_path"))
        config["provider_mapping"]["/"] = FilesystemProvider(root_path)

    if config["verbose"] >= 5:
        # TODO: remove passwords from user_mapping
        # config_cleaned = copy.deepcopy(config)
        print("Configuration({}):\n{}".format(cli_opts["config_file"], pformat(config)))

    if not config["provider_mapping"]:
        parser.error("No DAV provider defined.")

    # Quick-configuration of DomainController
    auth = cli_opts.get("auth")
    auth_conf = config.get("http_authenticator", {})
    if auth and auth_conf.get("domain_controller"):
        parser.error(
            "--auth option can only be used when no domain_controller is configured"
        )

    if auth == "anonymous":
        if config["simple_dc"]["user_mapping"]:
            parser.error(
                "--auth=anonymous can only be used when no user_mapping is configured"
            )
        auth_conf.update(
            {
                "domain_controller": "wsgidav.dc.simple_dc.SimpleDomainController",
                "accept_basic": True,
                "accept_digest": True,
                "default_to_digest": True,
            }
        )
        config["simple_dc"]["user_mapping"] = {"*": True}
    elif auth == "nt":
        if config.get("nt_dc"):
            parser.error(
                "--auth=nt can only be used when no nt_dc settings are configured"
            )
        auth_conf.update(
            {
                "domain_controller": "wsgidav.dc.nt_dc.NTDomainController",
                "accept_basic": True,
                "accept_digest": False,
                "default_to_digest": False,
            }
        )
        config["nt_dc"] = {}
    elif auth == "pam-login":
        if config.get("pam_dc"):
            parser.error(
                "--auth=pam-login can only be used when no pam_dc settings are configured"
            )
        auth_conf.update(
            {
                "domain_controller": "wsgidav.dc.pam_dc.PAMDomainController",
                "accept_basic": True,
                "accept_digest": False,
                "default_to_digest": False,
            }
        )
        config["pam_dc"] = {"service": "login"}
    # print(config)

    if cli_opts.get("reload"):
        print("Installing paste.reloader.", file=sys.stderr)
        from paste import reloader  # @UnresolvedImport

        reloader.install()
        if config_file:
            # Add config file changes
            reloader.watch_file(config_file)
        # import pydevd
        # pydevd.settrace()

    return config
Beispiel #17
0
    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 self.options.reload:
            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 (self.options.monitor_restart
                and not os.environ.get(self._monitor_environ_key)):
            return self.restart_with_monitor()

        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

        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()

        # Ensure the log file is writeable
        if self.options.log_file:
            try:
                writeable_log_file = open(self.options.log_file, 'a')
            except IOError, ioe:
                msg = 'Error: Unable to write to log file: %s' % ioe
                raise BadCommand(msg)
            writeable_log_file.close()
    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, ioe:
                msg = 'Error: Unable to write to log file: %s' % ioe
                raise BadCommand(msg)
            writeable_log_file.close()
Beispiel #19
0
def main():
    parser = OptionParser(description="Community Almanac: A place to tell your stories.")

    parser.add_option(
        '-d', '--debug', action='store_true', default=False,
        help='Start community almanac in debugging mode.  This causes '
        'community almanac to monitor it\'s own source files and reload if '
        'they have changed.  Normally, only community almanac developers will '
        'ever have need of this functionality.')

    parser.add_option(
        '-f', '--fragile', action='store_true', default=False,
        help='INTERNAL USE ONLY.  When specified, start a thread that watches '
        'Community Almanac\'s source files.  If any change, then quit this '
        'process.')

    parser.add_option(
        '-n', '--nolaunch', action='store_true', default=False,
        help='Don\'t launch a web browser after starting the http server.')

    parser.add_option(
        '-p', '--port', type=int, default=4000,
        help='The port to serve on (by default: 4000).  If this port is in '
        'use, community almanac will try to randomly select an open port.')

    parser.add_option(
        '-i', '--ip', default='0.0.0.0',
        help='The IP address to listen on. Defaults to 0.0.0.0, which means '
        'all IPv4 addresses')

    parser.add_option(
        '-e', '--emailserver', default='mail.openplans.org',
        help='The SMTP server to use for sending emails.  This needs to be an '
        'open relay.')

    parser.add_option(
        '-u', '--url', default='postgres://*****:*****@localhost/almanac',
        help='The DB url to pass to sqlalchemy. It defaults to '
        '"postgres://*****:*****@localhost/almanac"')

    parser.add_option(
        '-s', '--setup', action='store_true', default=False,
        help='Run the community almanac setup.  This creates any necessary models.')

    parser.add_option(
        '-m', '--map-key',
        default='ABQIAAAArBPF8riaRhqOCRInVOpLVhS7l0GBSa1x8uTWSQog_urT4TWq5xQAsIXoWoBjWzF7uvuoy8WT3pGQQA',
        help='The google maps api key to use')

    parser.add_option(
        '--recaptcha-public',
        default='6Le2wAcAAAAAAMAt001e7rSZgigoGgbFFyFN_jWi',
        help='The recaptcha public key to use')

    parser.add_option(
        '--recaptcha-private',
        default='6Le2wAcAAAAAAGKOoOcrBrNpYlaP3xW4RcWE1YX2',
        help='The recaptcha private key to use')

    args = parser.parse_args()[0]

    config = {
        'use': 'egg:communityalmanac',
        'full_stack': 'true',
        'static_files': 'true',

        'cache_dir': os.path.join(os.getcwd(), 'data'),
        'beaker.session.key': 'almanac',
        'beaker.session.secret': 'somesecret',

        'smtp_server': args.emailserver,
        'smtp_port': 25,
        'sqlalchemy.url': args.url,
        'map_key': args.map_key,
        'captcha_pubkey': args.recaptcha_public,
        'captcha_privkey': args.recaptcha_private,
        'captcha_enabled': 'True',
        'host_whitelist': 'player.soundcloud.com,soundcloud.com,youtube.com,video.google.com,vimeo.com,blip.tv'.split(','),
        'allow_tags': 'embed,object,param'.split(','),
        'support_sending_enabled': False,
        'support_email': 'nobody@localhost',
    }

    if args.setup:
        conf = type('TempConfig', (object,), dict(global_conf=config, local_conf=config))
        from communityalmanac.websetup import setup_app
        setup_app(None, conf, {})
        sys.exit(0)
    # We're gonna implement magic reload functionality, as seen in paster
    # serve. (Thanks, Ian Bicking, for the code and the explanation of what to
    # do.)

    # When this command is called with --debug, it does no actual serving.  It
    # opens a new process with a special flag that will tell Community Almanac
    # to launch in 'fragile mode'.  This means that it will call
    # paste.reload.install(), which starts a thread that kills the process if
    # any of it's files change.

    # Meanwhile, back at the ranch (this process) we'll watch to see if our
    # subprocess dies and simply launch it again.  At the same time, we'll
    # watch for a Ctrl-C so that the user can interrupt us (and by extension,
    # the server.)

    if args.debug:

        nolaunch = args.nolaunch
        while True:
            child = None
            try:
                try:
                    print "Launching server process"
                    exit_code, child = launch_and_watch_child(_server_args(args, nolaunch))
                    if not child:
                        break

                    # We only let nolaunch be False on the first subprocess launch.
                    # After that, we never want to launch a webbrowser.
                    nolaunch = True
                except (SystemExit, KeyboardInterrupt):
                    "^C Pressed, shutting down server"
                    return
            finally:
                if child and hasattr(os, 'kill'):
                    # Apparantly, windows will litter processes in the case of
                    # catastrophic failure.
                    try:
                        os.kill(child, signal.SIGTERM)
                    except (OSError, IOError):
                        pass
            if exit_code != 3:
                # The child exited non-normally, so we will too.
                return exit_code


    if args.fragile:
        # This simple form does not work in jython, so I should fix that, since
        # the code is already written into paste.serve
        from paste import reloader
        # Do we need to allow a way to slow this down?  Defaults to checking
        # once per second.
        reloader.install()
        # If we ever add a config file, we need to add that to the watch list
        # like this:
        # reloader.watch_file(my_config_file)

    from communityalmanac.config.middleware import make_app
    app = make_app({'debug':(args.debug or args.fragile) and 'true' or 'false'}, **config)

    import webbrowser
    def webhelper(url):
        """\
        Curry the webbrowser.open method so that we can cancel it with a
        threaded timer."""
        def _launch_closure():
            webbrowser.open(url)
        return _launch_closure

    import socket
    from paste.httpserver import serve

    # Paste's httpserver doesn't return once it's started serving (which is
    # pretty normal).  The only problem is that we don't know if it
    # successfully captured the port unless it didn't return.  We don't want to
    # open the user's webbrowser unless we're successfully serving, so it's
    # sort of a chicken and egg problem.  We'll start a timer with a half
    # second delay (forever in computer time) in another thread.  If the server
    # returns, we'll cancel the timer, and try again.
    if not args.nolaunch:
        from threading import Timer
        safelaunch = Timer(0.5, webhelper('http://%s:%d/' % (args.ip, args.port)))
        safelaunch.start()

    try:
        serve(app, host=args.ip, port=args.port)
    except socket.error, e:
        try:
            safelaunch.cancel()
        except NameError:
            pass
        print "Unable to serve on port %d : Error message was: %s" % (args.port, e[1])
Beispiel #20
0
# defined custom error handlers
class Webapp2HandlerAdapter(webapp2.BaseHandlerAdapter):
    def __call__(self, request, response, exception):
        request.route_args = {'exception': exception}
        logging.exception(exception)
        handler = self.handler(request, response)

        return handler.get()


app.error_handlers[403] = Webapp2HandlerAdapter(errors.Error403Handler)
app.error_handlers[404] = Webapp2HandlerAdapter(errors.Error404Handler)
app.error_handlers[503] = Webapp2HandlerAdapter(errors.Error503Handler)
app.error_handlers[500] = Webapp2HandlerAdapter(errors.Error500Handler)

# Static File Serving
static_app = StaticURLParser("static/")

# Check static files first then fallback
application = Cascade([static_app, app])

if __name__ == '__main__' and basehandler.IS_DEV:
    import paste.reloader as reloader
    reloader.install(10)

    from paste.translogger import TransLogger
    application = TransLogger(application, logger_name=None)

    from paste import httpserver
    httpserver.serve(application, host='127.0.0.1', port='8080')
Beispiel #21
0
    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 self.options.reload:
            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 (self.options.monitor_restart
            and not os.environ.get(self._monitor_environ_key)):
            return self.restart_with_monitor()

        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

        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()

        # Ensure the log file is writeable
        if self.options.log_file:
            try:
                writeable_log_file = open(self.options.log_file, 'a')
            except IOError, ioe:
                msg = 'Error: Unable to write to log file: %s' % ioe
                raise BadCommand(msg)
            writeable_log_file.close()
Beispiel #22
0
def _init_config():
    """Setup configuration dictionary from default, command line and configuration file."""
    cli_opts, parser = _init_command_line_options()
    cli_verbose = cli_opts["verbose"]

    # Set config defaults
    config = copy.deepcopy(DEFAULT_CONFIG)

    # Configuration file overrides defaults
    config_file = cli_opts.get("config_file")
    if config_file:
        file_opts = _read_config_file(config_file, cli_verbose)
        util.deep_update(config, file_opts)
        if cli_verbose != DEFAULT_VERBOSE and "verbose" in file_opts:
            if cli_verbose >= 2:
                print(
                    "Config file defines 'verbose: {}' but is overridden by command line: {}.".format(
                        file_opts["verbose"], cli_verbose
                    )
                )
            config["verbose"] = cli_verbose
    else:
        if cli_verbose >= 2:
            print("Running without configuration file.")

    # Command line overrides file
    if cli_opts.get("port"):
        config["port"] = cli_opts.get("port")
    if cli_opts.get("host"):
        config["host"] = cli_opts.get("host")
    if cli_opts.get("profile") is not None:
        config["profile"] = True
    if cli_opts.get("server") is not None:
        config["server"] = cli_opts.get("server")
    if cli_opts.get("ssl_adapter") is not None:
        config["ssl_adapter"] = cli_opts.get("ssl_adapter")

    # Command line overrides file only if -v or -q where passed:
    if cli_opts.get("verbose") != DEFAULT_VERBOSE:
        config["verbose"] = cli_opts.get("verbose")

    if cli_opts.get("root_path"):
        root_path = os.path.abspath(cli_opts.get("root_path"))
        config["provider_mapping"]["/"] = FilesystemProvider(root_path)

    if config["verbose"] >= 5:
        # TODO: remove passwords from user_mapping
        # config_cleaned = copy.deepcopy(config)
        print("Configuration({}):\n{}".format(cli_opts["config_file"], pformat(config)))

    if not config["provider_mapping"]:
        parser.error("No DAV provider defined.")

    # Quick-configuration of DomainController
    auth = cli_opts.get("auth")
    auth_conf = config.get("http_authenticator", {})
    if auth and auth_conf.get("domain_controller"):
        parser.error(
            "--auth option can only be used when no domain_controller is configured"
        )

    if auth == "anonymous":
        if config["simple_dc"]["user_mapping"]:
            parser.error(
                "--auth=anonymous can only be used when no user_mapping is configured"
            )
        auth_conf.update(
            {
                "domain_controller": "wsgidav.dc.simple_dc.SimpleDomainController",
                "accept_basic": True,
                "accept_digest": True,
                "default_to_digest": True,
            }
        )
        config["simple_dc"]["user_mapping"] = {"*": True}
    elif auth == "nt":
        if config.get("nt_dc"):
            parser.error(
                "--auth=nt can only be used when no nt_dc settings are configured"
            )
        auth_conf.update(
            {
                "domain_controller": "wsgidav.dc.nt_dc.NTDomainController",
                "accept_basic": True,
                "accept_digest": False,
                "default_to_digest": False,
            }
        )
        config["nt_dc"] = {}
    elif auth == "pam-login":
        if config.get("pam_dc"):
            parser.error(
                "--auth=pam-login can only be used when no pam_dc settings are configured"
            )
        auth_conf.update(
            {
                "domain_controller": "wsgidav.dc.pam_dc.PAMDomainController",
                "accept_basic": True,
                "accept_digest": False,
                "default_to_digest": False,
            }
        )
        config["pam_dc"] = {"service": "login"}
    # print(config)

    if cli_opts.get("reload"):
        print("Installing paste.reloader.", file=sys.stderr)
        from paste import reloader  # @UnresolvedImport

        reloader.install()
        if config_file:
            # Add config file changes
            reloader.watch_file(config_file)
        # import pydevd
        # pydevd.settrace()

    return config
Beispiel #23
0
        input_timezone = environ['PATH_INFO'][1:]
        if input_timezone:
            try:
                input_timezone = timezone(input_timezone)
            except UnknownTimeZoneError:
                start_response('200 OK', [('Content-Type', 'text/plain')])
                return [b'Unknown time zone']
        else:
            input_timezone = None

        msg = 'Time '
        if input_timezone:
            msg += 'in %s:\n' % input_timezone
        else:
            msg += 'on server:\n'

        start_response('200 OK', [('Content-Type', 'text/plain')])
        return [
            bytes(msg + datetime.now(tz=input_timezone).time().isoformat() +
                  '\nAdd needed timezone to the url\n',
                  encoding='utf-8')
        ]


if __name__ == '__main__':
    from paste import reloader
    from paste.httpserver import serve

    reloader.install()
    serve(app)
Beispiel #24
0
def _initConfig():
    """Setup configuration dictionary from default, command line and configuration file."""
    cmdLineOpts, args = _initCommandLineOptions()

    # Set config defaults
    config = DEFAULT_CONFIG.copy()
    if cmdLineOpts["verbose"] is None:
        temp_verbose = config["verbose"]
    else:
        temp_verbose = cmdLineOpts["verbose"]

    # print "verbose #1: ", temp_verbose

    # Configuration file overrides defaults
    config_file = cmdLineOpts.get("config_file")
    if config_file: 
        fileConf = _readConfigFile(config_file, temp_verbose)
        config.update(fileConf)
    else:
        if temp_verbose >= 2:
            print "Running without configuration file."
    
    # print "verbose #2: ", config.get("verbose")

    # Command line overrides file
    if cmdLineOpts.get("port"):
        config["port"] = cmdLineOpts.get("port")
    if cmdLineOpts.get("host"):
        config["host"] = cmdLineOpts.get("host")
    if cmdLineOpts.get("verbose") is not None:
        config["verbose"] = cmdLineOpts.get("verbose")
    if cmdLineOpts.get("profile") is not None:
        config["profile"] = True

    if cmdLineOpts.get("root_path"):
        root_path = os.path.abspath(cmdLineOpts.get("root_path"))
        config["provider_mapping"]["/"] = FilesystemProvider(root_path)
    
    if config["verbose"] >= 3:
        print "Configuration(%s):" % cmdLineOpts["config_file"]
        pprint(config)

    log_path = cmdLineOpts.get("log_path", "")
    if log_path:
        log_path = os.path.abspath(log_path)
        config["log_path"] = log_path

    pid_file = cmdLineOpts.get("pid_file", "")
    if pid_file:
        pid_file = os.path.abspath(pid_file)
        config["pid_file"] = pid_file

    if not useLxml and config["verbose"] >= 1:
        print "WARNING: Could not import lxml: using xml instead (slower). Consider installing lxml from http://codespeak.net/lxml/."

    # print "verbose #3: ", config.get("verbose")

    if not config["provider_mapping"]:
        print >>sys.stderr, "ERROR: No DAV provider defined. Try --help option."
        sys.exit(-1)
#        raise RuntimeWarning("At least one DAV provider must be specified by a --root option, or in a configuration file.")

    if cmdLineOpts.get("reload"):
        print >>sys.stderr, "Installing paste.reloader."
        from paste import reloader  #@UnresolvedImport
        reloader.install()
        if config_file:
            # Add config file changes
            reloader.watch_file(config_file)
#        import pydevd
#        pydevd.settrace()
    return config, args
Beispiel #25
0
    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:
                print("Could not stop daemon")
                # It's ok to continue trying to restart if stop_daemon returns
                # a 1, otherwise shortcut and return.
                if cmd == 'restart' and result != 1:
                    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)

        server = loadserver(server_spec, name=server_name, relative_to=base, global_conf=vars)

        app = 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.'
            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)
            except AttributeError as e:
                # Capturing bad error response from paste
                if str(e) == "'WSGIThreadPoolServer' object has no attribute 'thread_pool'":
                    import socket
                    raise socket.error(98, 'Address already in use')
                else:
                    raise AttributeError(e)

        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()
Beispiel #26
0
    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, ioe:
                msg = 'Error: Unable to write to log file: %s' % ioe
                raise BadCommand(msg)
            writeable_log_file.close()
Beispiel #27
0
def _initConfig():
    """Setup configuration dictionary from default, command line and configuration file."""
    cmdLineOpts = _initCommandLineOptions()

    # Set config defaults
    config = DEFAULT_CONFIG.copy()
    if cmdLineOpts["verbose"] is None:
        temp_verbose = config["verbose"]
    else:
        temp_verbose = cmdLineOpts["verbose"]

    # print "verbose #1: ", temp_verbose

    # Configuration file overrides defaults
    config_file = cmdLineOpts.get("config_file")
    if config_file:
        fileConf = _readConfigFile(config_file, temp_verbose)
        config.update(fileConf)
    else:
        if temp_verbose >= 2:
            print("Running without configuration file.")

    # print "verbose #2: ", config.get("verbose")

    # Command line overrides file
    if cmdLineOpts.get("port"):
        config["port"] = cmdLineOpts.get("port")
    if cmdLineOpts.get("host"):
        config["host"] = cmdLineOpts.get("host")
    if cmdLineOpts.get("verbose") is not None:
        config["verbose"] = cmdLineOpts.get("verbose")
    if cmdLineOpts.get("profile") is not None:
        config["profile"] = True
    if cmdLineOpts.get("server") is not None:
        config["server"] = cmdLineOpts.get("server")
    if cmdLineOpts.get("ssl_adapter") is not None:
        config["ssl_adapter"] = cmdLineOpts.get("ssl_adapter")

    if cmdLineOpts.get("root_path"):
        root_path = os.path.abspath(cmdLineOpts.get("root_path"))
        config["provider_mapping"]["/"] = FilesystemProvider(root_path)

    if config["verbose"] >= 4:
        print("Configuration({}):\n{}".format(cmdLineOpts["config_file"],
                                              pformat(config)))

    # if not useLxml and config["verbose"] >= 1:
    #     print("WARNING: Could not import lxml: using xml instead (slower). Consider installing"
    #         "lxml from http://codespeak.net/lxml/.")

    # print "verbose #3: ", config.get("verbose")

    if not config["provider_mapping"]:
        print("ERROR: No DAV provider defined. Try --help option.",
              file=sys.stderr)
        sys.exit(-1)
#        raise RuntimeWarning("At least one DAV provider must be specified by a --root option,"
#             or in a configuration file.")

    if cmdLineOpts.get("reload"):
        print("Installing paste.reloader.", file=sys.stderr)
        from paste import reloader  # @UnresolvedImport
        reloader.install()
        if config_file:
            # Add config file changes
            reloader.watch_file(config_file)


#        import pydevd
#        pydevd.settrace()

    return config
Beispiel #28
0
    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 self.options.reload:
            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

        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, ioe:
                msg = "Error: Unable to write to log file: %s" % ioe
                raise BadCommand(msg)
            writeable_log_file.close()