def run(self):
     self._host.run()
     if self._port != 443:
         run_simple(self._host_name, self._port, self, threaded=True)
     else:
         make_ssl_devcert('key', host=self._host_name)
         run_simple(self._host_name, self._port, self, threaded=True, ssl_context=('key.crt', 'key.key'))

        def inner_run():
            print "Validating models..."
            self.validate(display_num_errors=True)
            print "\nDjango version %s, using settings %r" % (django.get_version(), settings.SETTINGS_MODULE)
            print "Development server is running at http://%s:%s/" % (addr, port)
            print "Using the Werkzeug debugger (http://werkzeug.pocoo.org/)"
            print "Quit the server with %s." % quit_command
            path = options.get('admin_media_path', '')
            if not path:
                admin_media_path = os.path.join(django.__path__[0], 'contrib/admin/static/admin')
                if os.path.isdir(admin_media_path):
                    path = admin_media_path
                else:
                    path = os.path.join(django.__path__[0], 'contrib/admin/media')
            handler = WSGIHandler()
            if USE_ADMINMEDIAHANDLER:
                handler = AdminMediaHandler(handler, path)
            if USE_STATICFILES:
                use_static_handler = options.get('use_static_handler', True)
                insecure_serving = options.get('insecure_serving', False)
                if use_static_handler and (settings.DEBUG or insecure_serving):
                    handler = StaticFilesHandler(handler)
            if open_browser:
                import webbrowser
                url = "http://%s:%s/" % (addr, port)
                webbrowser.open(url)
            if cert_path:
                try:
                    from werkzeug.serving import make_ssl_devcert
                    ssl_context = make_ssl_devcert(cert_path, host='localhost')
                    run_simple(
                        addr,
                        int(port),
                        DebuggedApplication(handler, True),
                        use_reloader=use_reloader,
                        use_debugger=True,
                        threaded=threaded,
                        ssl_context=ssl_context
                    )
                except ImportError:
                    raise CommandError("""Werkzeug 0.8.2 or later is required
to use runserver_plus with ssl support.  Please
visit http://werkzeug.pocoo.org/download""")
            else:
                run_simple(
                    addr,
                    int(port),
                    DebuggedApplication(handler, True),
                    use_reloader=use_reloader,
                    use_debugger=True,
                    threaded=threaded
                )

def test_stdlib_ssl_contexts(dev_server, tmpdir):
    certificate, private_key = serving.make_ssl_devcert(str(tmpdir))
    ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
    ctx.load_cert_chain(certificate, private_key)

    def hello(environ, start_response):
        start_response('200 OK', [('Content-Type', 'text/html')])
        return [b'hello']
    server, addr = dev_server(hello, ssl_context=ctx)
    assert addr is not None
    connection = httplib.HTTPSConnection(addr)
    connection.request('GET', '/')
    response = connection.getresponse()
    assert response.read() == b'hello'

def test_stdlib_ssl_contexts(dev_server, tmpdir):
    certificate, private_key = \
        serving.make_ssl_devcert(str(tmpdir.mkdir('certs')))

    server = dev_server('''
    def app(environ, start_response):
        start_response('200 OK', [('Content-Type', 'text/html')])
        return [b'hello']

    import ssl
    ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
    ctx.load_cert_chain("%s", "%s")
    kwargs['ssl_context'] = ctx
    ''' % (certificate, private_key))

    assert server.addr is not None
    r = requests.get(server.url, verify=False)
    assert r.content == b'hello'

def test_stdlib_ssl_contexts(dev_server, tmpdir):
    certificate, private_key = \
        serving.make_ssl_devcert(str(tmpdir.mkdir('certs')))

    server = dev_server('''
    def app(environ, start_response):
        start_response('200 OK', [('Content-Type', 'text/html')])
        return [b'hello']

    import ssl
    ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
    ctx.load_cert_chain("%s", "%s")
    kwargs['ssl_context'] = ctx
    ''' % (certificate, private_key))

    assert server.addr is not None
    connection = httplib.HTTPSConnection(server.addr)
    connection.request('GET', '/')
    response = connection.getresponse()
    assert response.read() == b'hello'

        def inner_run():
            print("Validating models...")
            try:
                self.check(display_num_errors=True)
            except AttributeError:
                self.validate(display_num_errors=True)
            print("\nDjango version %s, using settings %r" % (django.get_version(), settings.SETTINGS_MODULE))
            print("Development server is running at %s" % (bind_url,))
            print("Using the Werkzeug debugger (http://werkzeug.pocoo.org/)")
            print("Quit the server with %s." % quit_command)
            path = options.get('admin_media_path', '')
            if not path:
                admin_media_path = os.path.join(django.__path__[0], 'contrib/admin/static/admin')
                if os.path.isdir(admin_media_path):
                    path = admin_media_path
                else:
                    path = os.path.join(django.__path__[0], 'contrib/admin/media')
            handler = WSGIHandler()
            if USE_ADMINMEDIAHANDLER:
                handler = AdminMediaHandler(handler, path)
            if USE_STATICFILES:
                use_static_handler = options.get('use_static_handler', True)
                insecure_serving = options.get('insecure_serving', False)
                if use_static_handler and (settings.DEBUG or insecure_serving):
                    handler = StaticFilesHandler(handler)
            if open_browser:
                import webbrowser
                webbrowser.open(bind_url)
            if cert_path:
                """
                OpenSSL is needed for SSL support.

                This will make flakes8 throw warning since OpenSSL is not used
                directly, alas, this is the only way to show meaningful error
                messages. See:
                http://lucumr.pocoo.org/2011/9/21/python-import-blackbox/
                for more information on python imports.
                """
                try:
                    import OpenSSL  # NOQA
                except ImportError:
                    raise CommandError("Python OpenSSL Library is "
                                       "required to use runserver_plus with ssl support. "
                                       "Install via pip (pip install pyOpenSSL).")

                dir_path, cert_file = os.path.split(cert_path)
                if not dir_path:
                    dir_path = os.getcwd()
                root, ext = os.path.splitext(cert_file)
                certfile = os.path.join(dir_path, root + ".crt")
                keyfile = os.path.join(dir_path, root + ".key")
                try:
                    from werkzeug.serving import make_ssl_devcert
                    if os.path.exists(certfile) and \
                            os.path.exists(keyfile):
                                ssl_context = (certfile, keyfile)
                    else:  # Create cert, key files ourselves.
                        ssl_context = make_ssl_devcert(
                            os.path.join(dir_path, root), host='localhost')
                except ImportError:
                    print("Werkzeug version is less than 0.9, trying adhoc certificate.")
                    ssl_context = "adhoc"

            else:
                ssl_context = None
            run_simple(
                self.addr,
                int(self.port),
                DebuggedApplication(handler, True),
                use_reloader=use_reloader,
                use_debugger=True,
                threaded=threaded,
                ssl_context=ssl_context
            )

def test_make_ssl_devcert(tmpdir):
    certificate, private_key = \
        serving.make_ssl_devcert(str(tmpdir))
    assert os.path.isfile(certificate)
    assert os.path.isfile(private_key)

    def inner_run(self, options):
        import django

        try:
            from werkzeug import run_simple, DebuggedApplication
            from werkzeug.serving import WSGIRequestHandler as _WSGIRequestHandler

            # Set colored output
            if settings.DEBUG:
                try:
                    set_werkzeug_log_color()
                except Exception:  # We are dealing with some internals, anything could go wrong
                    if self.show_startup_messages:
                        print("Wrapping internal werkzeug logger for color highlighting has failed!")
                    pass

        except ImportError:
            raise CommandError("Werkzeug is required to use runserver_plus.  Please visit http://werkzeug.pocoo.org/ or install via pip. (pip install Werkzeug)")

        class WSGIRequestHandler(_WSGIRequestHandler):
            def make_environ(self):
                environ = super(WSGIRequestHandler, self).make_environ()
                if not options.get('keep_meta_shutdown_func'):
                    del environ['werkzeug.server.shutdown']
                return environ

        threaded = options.get('threaded', True)
        use_reloader = options.get('use_reloader', True)
        open_browser = options.get('open_browser', False)
        cert_path = options.get("cert_path")
        quit_command = (sys.platform == 'win32') and 'CTRL-BREAK' or 'CONTROL-C'
        extra_files = options.get('extra_files', None) or []
        reloader_interval = options.get('reloader_interval', 1)
        reloader_type = options.get('reloader_type', 'auto')

        self.nopin = options.get('nopin', False)

        if self.show_startup_messages:
            print("Performing system checks...\n")
        if hasattr(self, 'check'):
            self.check(display_num_errors=self.show_startup_messages)
        else:
            self.validate(display_num_errors=self.show_startup_messages)
        try:
            self.check_migrations()
        except ImproperlyConfigured:
            pass
        handler = get_internal_wsgi_application()
        if USE_STATICFILES:
            use_static_handler = options.get('use_static_handler', True)
            insecure_serving = options.get('insecure_serving', False)
            if use_static_handler and (settings.DEBUG or insecure_serving):
                handler = StaticFilesHandler(handler)
        if cert_path:
            """
            OpenSSL is needed for SSL support.

            This will make flakes8 throw warning since OpenSSL is not used
            directly, alas, this is the only way to show meaningful error
            messages. See:
            http://lucumr.pocoo.org/2011/9/21/python-import-blackbox/
            for more information on python imports.
            """
            try:
                import OpenSSL  # NOQA
            except ImportError:
                raise CommandError("Python OpenSSL Library is "
                                   "required to use runserver_plus with ssl support. "
                                   "Install via pip (pip install pyOpenSSL).")

            dir_path, cert_file = os.path.split(cert_path)
            if not dir_path:
                dir_path = os.getcwd()
            root, ext = os.path.splitext(cert_file)
            certfile = os.path.join(dir_path, root + ".crt")
            keyfile = os.path.join(dir_path, root + ".key")
            try:
                from werkzeug.serving import make_ssl_devcert
                if os.path.exists(certfile) and \
                        os.path.exists(keyfile):
                            ssl_context = (certfile, keyfile)
                else:  # Create cert, key files ourselves.
                    ssl_context = make_ssl_devcert(
                        os.path.join(dir_path, root), host='localhost')
            except ImportError:
                if self.show_startup_messages:
                    print("Werkzeug version is less than 0.9, trying adhoc certificate.")
                ssl_context = "adhoc"

        else:
            ssl_context = None

        bind_url = "%s://%s:%s/" % (
            "https" if ssl_context else "http", self.addr if not self._raw_ipv6 else '[%s]' % self.addr, self.port)

        if self.show_startup_messages:
            print("\nDjango version %s, using settings %r" % (django.get_version(), settings.SETTINGS_MODULE))
            print("Development server is running at %s" % (bind_url,))
            print("Using the Werkzeug debugger (http://werkzeug.pocoo.org/)")
            print("Quit the server with %s." % quit_command)
#.........这里部分代码省略.........

#-------------------------------------------------------------------------------
# Name:        sslgen
# Purpose:     generate development ssl certs
#
# Author:      a

# Licence:     MIT
#-------------------------------------------------------------------------------
from werkzeug.serving import run_simple
from werkzeug.serving import make_ssl_devcert
import os
scriptdir = os.path.dirname(os.path.abspath(__file__))



make_ssl_devcert(scriptdir+'\\ast', host='localhost', cn=None)

##app = make_app(...)
##run_simple('localhost', 8080, app, use_reloader=True)

 def test_make_ssl_devcert(self):
     certificate, private_key = serving.make_ssl_devcert(get_temporary_directory())
     assert os.path.isfile(certificate)
     assert os.path.isfile(private_key)

#-------------------------------------------------------------------------------
# Name:        模块1
# Purpose:
#
# Author:      1
#
# Created:     25/02/2016
# Copyright:   (c) 1 2016
# Licence:     <your licence>
#-------------------------------------------------------------------------------

from werkzeug.serving import make_ssl_devcert

make_ssl_devcert('./', host='localhost')
('./key.crt', './key.key')

import argparse
from werkzeug.serving import make_ssl_devcert
parser = argparse.ArgumentParser(description='Generate SSL cert')
parser.add_argument('host', type=str,
                   help='host to be used in SSL cert')
args = parser.parse_args()
path=make_ssl_devcert('key', args.host)
print "Keys written to ", path