update pserve

Michael Merickel

2017-03-30 3e489b740b1836c81af240cba579245ab18177da

 pyramid/scripts/pserve.py

@@ -18,16 +18,11 @@
import webbrowser

import hupper
from paste.deploy import (
    loadapp,
    loadserver,
)

from pyramid.compat import PY2
from pyramid.compat import configparser

from pyramid.scripts.common import get_config_loader
from pyramid.scripts.common import parse_vars
from pyramid.scripts.common import setup_logging
from pyramid.path import AssetResolver
from pyramid.settings import aslist

@@ -113,9 +108,7 @@
             "passed here.",
        )

    ConfigParser = configparser.ConfigParser  # testing
    loadapp = staticmethod(loadapp)  # testing
    loadserver = staticmethod(loadserver)  # testing
    _get_config_loader = staticmethod(get_config_loader)  # for testing

    open_url = None

@@ -133,26 +126,14 @@
        if self.args.verbose > 0:
            print(msg)

    def get_config_vars(self):
        restvars = self.args.config_vars
        return parse_vars(restvars)
    def get_config_path(self, loader):
        return os.path.abspath(loader.uri.path)

    def pserve_file_config(self, filename, global_conf=None):
        here = os.path.abspath(os.path.dirname(filename))
        defaults = {}
        if global_conf:
            defaults.update(global_conf)
        defaults['here'] = here

        config = self.ConfigParser(defaults=defaults)
        config.optionxform = str
        config.read(filename)
        try:
            items = dict(config.items('pserve'))
        except configparser.NoSectionError:
            return

        watch_files = aslist(items.get('watch_files', ''), flatten=False)
    def pserve_file_config(self, loader, global_conf=None):
        settings = loader.get_settings('pserve', global_conf)
        config_path = self.get_config_path(loader)
        here = os.path.dirname(config_path)
        watch_files = aslist(settings.get('watch_files', ''), flatten=False)

        # track file paths relative to the ini file
        resolver = AssetResolver(package=None)
@@ -164,45 +145,30 @@
            self.watch_files.add(os.path.abspath(file))

        # attempt to determine the url of the server
        open_url = items.get('open_url')
        open_url = settings.get('open_url')
        if open_url:
            self.open_url = open_url

    def _guess_server_url(self, filename, server_name,
                          global_conf=None):  # pragma: no cover
    def guess_server_url(self, loader, server_name, global_conf=None):
        server_name = server_name or 'main'
        here = os.path.abspath(os.path.dirname(filename))
        defaults = {}
        if global_conf:
            defaults.update(global_conf)
        defaults['here'] = here

        config = self.ConfigParser(defaults=defaults)
        config.optionxform = str
        config.read(filename)
        try:
            items = dict(config.items('server:' + server_name))
        except configparser.NoSectionError:
            return

        if 'port' in items:
            return 'http://127.0.0.1:{port}'.format(**items)
        settings = loader.get_settings('server:' + server_name, global_conf)
        if 'port' in settings:
            return 'http://127.0.0.1:{port}'.format(**settings)

    def run(self):  # pragma: no cover
        if not self.args.config_uri:
            self.out('You must give a config file')
            return 2
        config_uri = self.args.config_uri
        config_vars = parse_vars(self.args.config_vars)
        app_spec = self.args.config_uri

        vars = self.get_config_vars()
        app_name = self.args.app_name

        base = os.getcwd()
        if not self._scheme_re.search(app_spec):
            config_path = os.path.join(base, app_spec)
            app_spec = 'config:' + app_spec
        else:
            config_path = None
        loader = self._get_config_loader(config_uri)
        loader.setup_logging(config_vars)

        self.pserve_file_config(loader, global_conf=config_vars)

        server_name = self.args.server_name
        if self.args.server:
            server_spec = 'egg:pyramid'
@@ -211,15 +177,17 @@
        else:
            server_spec = app_spec

        server_loader = loader
        if server_spec != app_spec:
            server_loader = self.get_config_loader(server_spec)

        # do not open the browser on each reload so check hupper first
        if self.args.browser and not hupper.is_active():
            self.pserve_file_config(config_path, global_conf=vars)
            url = self.open_url

            # do not guess the url if the server is sourced from a different
            # location than the config_path
            if not url and server_spec == app_spec:
                url = self._guess_server_url(config_path, server_name, vars)
            if not url:
                url = self.guess_server_url(
                    server_loader, server_name, config_vars)

            if not url:
                self.out('WARNING: could not determine the server\'s url to '
@@ -246,20 +214,19 @@
            )
            return 0

        if config_path:
            setup_logging(config_path, global_conf=vars)
            self.pserve_file_config(config_path, global_conf=vars)
            self.watch_files.add(config_path)
        config_path = self.get_config_path(loader)
        self.watch_files.add(config_path)

        server_path = self.get_config_path(server_loader)
        self.watch_files.add(server_path)

        if hupper.is_active():
            reloader = hupper.get_reloader()
            reloader.watch_files(list(self.watch_files))

        server = self.loadserver(
            server_spec, name=server_name, relative_to=base, global_conf=vars)
        server = server_loader.get_wsgi_server(server_name, config_vars)

        app = self.loadapp(
            app_spec, name=app_name, relative_to=base, global_conf=vars)
        app = loader.get_wsgi_app(app_name, config_vars)

        if self.args.verbose > 0:
            if hasattr(os, 'getpid'):