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 wrap(cls, app):
host, port = cls.parse_args()
if host:
from wsgiref.simple_server import make_server
server = make_server(host, port, app)
if cls._argument_parser.parse_args().ssl:
# Set HTTPS='1' makes wsgiref set wsgi.url_scheme='https'
# This in turn makes pyramid set request.scheme='https'
server.base_environ['HTTPS'] = '1'
with tempfile.TemporaryDirectory() as td:
# Generate temporary self-signed cert/key pair
# using the library used by Flask for 'adhoc' ssl_context
certpath = '{}/liveandletdie'.format(td)
make_ssl_devcert(certpath)
server.socket = ssl.wrap_socket(
server.socket,
server_side=True,
certfile='{}.crt'.format(certpath),
keyfile='{}.key'.format(certpath),
)
server.serve_forever()
server.server_close()
sys.exit()
def ssl(module, host='127.0.0.1', path=None):
"""
Adds SSL support for development
:param module: str
Name of the module
:param host: str
Domain or IP of the server
Default = '127.0.0.1'
:param path: str
Path to cert files (without .crt and .key ending)
If empty you have to install python OpenSSL lib
Default = None
"""
state_ = state(module)
if path:
state_.ssl = make_ssl_devcert(path, host=host)
else:
import importlib
# noinspection PyDeprecation
open_ssl = importlib.find_loader('OpenSSL')
if open_ssl:
state_.ssl = 'adhoc'
else:
raise ModuleNotFoundError(
'SSL generation requires the PyOpenSSl module. Please install it or pass the path\
to your self generated certificate')
def debug():
tempPath = tempfile.mkdtemp() + "/server"
atexit.register(cleanup, tempPath)
print(tempPath)
context = make_ssl_devcert(tempPath, host='localhost')
app.run(host="0.0.0.0", port=5000, debug=True, threaded=True, ssl_context=context)
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 create_app(config_name):
# Flask instance
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
db.init_app(app)
login_manager.init_app(app)
make_ssl_devcert('./ssl', host='localhost')
from catalog_items.main_app import main_blueprint
app.register_blueprint(main_blueprint)
from catalog_items.auth import auth_blueprint
app.register_blueprint(auth_blueprint)
app.register_error_handler(404, page_not_found)
app.register_error_handler(500, internal_server_error)
return app
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 run_dev_server(http_only=False, threaded=False):
# version of SSL included by werkzeug from pip is broken. Use github
ssl_prefix = join(config.src_home, 'lib', 'tmp', 'ssl')
if not isfile(ssl_prefix + '.key'):
make_ssl_devcert(ssl_prefix, host='localhost', cn=None)
ssl_context = ssl.Context(ssl.SSLv23_METHOD)
ssl_context.use_certificate_file(ssl_prefix + '.crt')
ssl_context.use_privatekey_file(ssl_prefix + '.key')
# run_simple is not so simple
def run_hive(port, ssl=False):
run_simple(
'0.0.0.0',
port,
application,
threaded=threaded,
use_reloader=True,
use_debugger=config.debug_mode,
use_evalex=config.
debug_unsecure # from werkzeug.debug import DebuggedApplication
,
static_files={'/lib': join(config.src_home, 'lib')},
ssl_context=ssl_context if ssl else None
#, processes = 0
)
if config.always_secure:
run_hive(config.ssl_port, True)
elif http_only:
run_hive(config.plain_port)
else:
child = os.fork()
if (child):
run_hive(config.plain_port)
else:
run_hive(config.ssl_port, True)
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 confd(global_datadir, tmp_path_factory) -> Path:
datadir = global_datadir / "confd"
develop = datadir / "odooconfig.develop.json"
stage = datadir / "odooconfig.stage.json"
prod = datadir / "odooconfig.prod.json"
develop_dict = json.loads(develop.read_text())
stage_dict = json.loads(stage.read_text())
prod_dict = json.loads(prod.read_text())
persist_dir = tmp_path_factory.mktemp("persist")
backup_dir = tmp_path_factory.mktemp("backup")
addons_dir = tmp_path_factory.mktemp("addons")
scoped_addons_dir = tmp_path_factory.mktemp("scoped_addons")
geoip_database_dir = tmp_path_factory.mktemp("geoip_database")
geoip_database_file = geoip_database_dir / "GeoLite2-City.mmdb"
geoip_database_file.touch()
upd = {
"data_dir": str(persist_dir),
"backup_dir": str(backup_dir),
"addons_dir": str(addons_dir),
"scoped_addons_dir": str(scoped_addons_dir),
"geoip_database": str(geoip_database_file),
}
crt_path, key_path = make_ssl_devcert(str(global_datadir),
host="localhost")
develop_dict.update(**upd)
develop_dict.update(ssl_keyfile=key_path, ssl_certfile=crt_path)
stage_dict.update(**upd)
prod_dict.update(**upd)
with develop.open(mode="w") as f:
f.write(json.dumps(develop_dict))
with stage.open(mode="w") as f:
f.write(json.dumps(stage_dict))
with prod.open(mode="w") as f:
f.write(json.dumps(prod_dict))
datadir.chmod(0o550)
yield datadir
datadir.chmod(0o777)
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 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'
from flask import Flask
from OpenSSL import SSL
import os
from werkzeug.serving import make_ssl_devcert
# make_ssl_devcert('key', host='localhost')
make_ssl_devcert('key')
context = SSL.Context(SSL.SSLv23_METHOD)
cer = os.path.join(os.path.dirname(__file__), 'key.crt')
key = os.path.join(os.path.dirname(__file__), 'key.key')
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'Hellokjnkj World!'
if __name__ == '__main__':
context = (cer, key)
app.run(host='0.0.0.0', port=5000, debug=True, ssl_context=context)
def main() -> None:
logging.basicConfig(level=logging.INFO)
if not os.path.exists('./key.pem') or not os.path.exists('./key.crt'):
logging.info('Creating dev cert')
make_ssl_devcert('./key', host='localhost')
server = ScoreboardTwitchExtensionServer()
time.sleep(1)
print(
f'Please visit https://localhost:{PORT} in your browser and ensure that the page is loading and not presenting a SSL error'
)
print(
'In chrome you can set the flag chrome://flags#allow-insecure-localhost, '
'for other browsers you may need to install the generated "key.crt" as a trusted root cert, '
'or launch the browser with a special argument.')
print(
'Once you have confirmed this page loads with no error (the page should appear empty with no content), '
'you should also be able to load it on twitch as a locally-hosted extension (see the readme for more info on setting this up).'
)
print()
if '--live' not in sys.argv:
if len(sys.argv) != 4:
print('-' * 32)
print(
'You need to provide your twitch API client ID if not running in "live data" mode. '
'You can find this on the first page when you create a new extension, '
'or regenerate it under "Extension Authorization Settings" on your extension\'s Developer Console'
)
client_id, secret_encoded, channel = sys.argv[1:]
secret = base64.b64decode(secret_encoded)
twitch = requests.Session()
twitch.headers.update({'Client-ID': client_id})
r = twitch.get('https://api.twitch.tv/helix/users?login='******'data'][0]['id']
gui = ScoreboardGui.create()
def update_extension(data: Dict):
message = {'timestamp': time.time(), 'teams': data['teams']}
auth = {
'user_id': str(user_id),
'exp': int(time.time() + 60),
'role': 'external',
'channel_id': str(user_id),
'pubsub_perms': {
'send': ['broadcast']
}
}
logging.info(f'Sending twitch broadcast: {message}')
r = twitch.post(
f'https://api.twitch.tv/extensions/message/{user_id}',
json={
'content_type': 'application/json',
'message': json.dumps(message),
'targets': ['broadcast']
},
headers={
'Authorization':
'Bearer ' + jwt.encode(auth, secret).decode()
})
try:
r.raise_for_status()
except Exception as e:
logging.exception(f'Failed to publish update: {r.text}',
exc_info=e)
def update_loop():
while True:
update_extension(gui.data)
time.sleep(10)
Thread(target=update_loop, daemon=True).start()
last_update = None
def rate_limited_update(data):
nonlocal last_update
if not last_update or time.time() - last_update > 1:
last_update = time.time()
update_extension(data)
gui.callback = rate_limited_update
gui.run()
else:
logging.info(
f'Running without player selector GUI - you must provide live data from OverTrack'
)
server.thread.join()
logging.info(f'Shutting down')
def inner_run(self, options):
if not HAS_WERKZEUG:
raise CommandError(
"Werkzeug is required to use runserver_plus. Please visit http://werkzeug.pocoo.org/ or install via pip. (pip install Werkzeug)"
)
# 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!"
)
class WSGIRequestHandler(_WSGIRequestHandler):
def make_environ(self):
environ = super().make_environ()
if not options['keep_meta_shutdown_func']:
del environ['werkzeug.server.shutdown']
return environ
threaded = options['threaded']
use_reloader = options['use_reloader']
open_browser = options['open_browser']
quit_command = 'CONTROL-C' if sys.platform != 'win32' else 'CTRL-BREAK'
reloader_interval = options['reloader_interval']
reloader_type = options['reloader_type']
self.extra_files = set(options['extra_files'])
self.nopin = options['nopin']
if self.show_startup_messages:
print("Performing system checks...\n")
try:
check_errors(
self.check)(display_num_errors=self.show_startup_messages)
check_errors(self.check_migrations)()
handler = check_errors(self.get_handler)(**options)
except Exception as exc:
self.stderr.write("Error occurred during checks: %r" % exc,
ending="\n\n")
handler = self.get_error_handler(exc, **options)
if USE_STATICFILES:
use_static_handler = options['use_static_handler']
insecure_serving = options['insecure_serving']
if use_static_handler and (settings.DEBUG or insecure_serving):
handler = StaticFilesHandler(handler)
if options["cert_path"] or options["key_file_path"]:
if not HAS_OPENSSL:
raise CommandError(
"Python OpenSSL Library is "
"required to use runserver_plus with ssl support. "
"Install via pip (pip install pyOpenSSL).")
certfile, keyfile = self.determine_ssl_files_paths(options)
dir_path, root = os.path.split(certfile)
root, _ = os.path.splitext(root)
try:
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)
if open_browser:
webbrowser.open(bind_url)
if use_reloader and settings.USE_I18N:
self.extra_files |= set(
filter(lambda filename: str(filename).endswith('.mo'),
gen_filenames()))
if getattr(settings, 'RUNSERVER_PLUS_EXTRA_FILES', []):
self.extra_files |= set(settings.RUNSERVER_PLUS_EXTRA_FILES)
# Werkzeug needs to be clued in its the main instance if running
# without reloader or else it won't show key.
# https://git.io/vVIgo
if not use_reloader:
os.environ['WERKZEUG_RUN_MAIN'] = 'true'
# Don't run a second instance of the debugger / reloader
# See also: https://github.com/django-extensions/django-extensions/issues/832
if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':
if self.nopin:
os.environ['WERKZEUG_DEBUG_PIN'] = 'off'
handler = DebuggedApplication(handler, True)
runserver_plus_started.send(sender=self)
run_simple(
self.addr,
int(self.port),
handler,
use_reloader=use_reloader,
use_debugger=True,
extra_files=self.extra_files,
exclude_patterns=WERKZEUG_EXCLUDE_PATTERNS,
reloader_interval=reloader_interval,
reloader_type=reloader_type,
threaded=threaded,
request_handler=WSGIRequestHandler,
ssl_context=ssl_context,
)
# -*- coding: utf-8 -*-
from flask import Flask
from OpenSSL import SSL
from werkzeug.serving import run_simple
from werkzeug.serving import make_ssl_devcert
from werkzeug.serving import is_running_from_reloader
#from myproject import make_app
app = Flask(__name__)
bestand = open("C:/Users/Daniel van Liempd/Desktop/DANIEL.txt", 'r')
#print (bestand.read())
make_ssl_devcert(
'C:/Users/Daniel van Liempd/PycharmProjects/Practicum-cloudinfra/venv',
host='Daniel-PC',
cn=None)
is_running_from_reloader()
run_simple(hostname='Daniel-PC',
port=8080,
application=(app),
use_reloader=False,
use_debugger=False,
use_evalex=True,
extra_files=None,
reloader_interval=1,
reloader_type='auto',
threaded=False,
processes=1,
request_handler=None,
def create_crt(path, host):
make_ssl_devcert(path, host=host)
if not result:
print("got here insert user 2")
return apology("Username already exists")
# query database for username
rows = db.execute("SELECT * FROM users WHERE username = :username",
username=request.form.get("username"))
# this is to initialize the user in the WINS table, with 0
# this made it easier to continually update win totals as opposed to insert OR update
wins = 0
uid = rows[0]["userid"]
wins_update = db.execute(
"INSERT INTO wins (userid, wins) VALUES (:uid, :wins)",
uid=uid,
wins=wins)
# remember which user has logged in
session["userid"] = rows[0]["userid"]
# redirect user to home page
return redirect(url_for("index"))
else:
return render_template("register.html")
if __name__ == "__main__":
make_ssl_devcert('/home/pi/pickem/dheslin', host='www.bygtech.com')
#run_simple('0.0.0.0', 5000, app, ssl_context=('/home/pi/pickem/dheslin/ssl.cert', '/home/pi/pickem/dheslin/ssl.key'))
def test_ssl_dev_cert(tmp_path, dev_server):
client = dev_server(ssl_context=make_ssl_devcert(tmp_path))
r = client.request()
assert r.json["wsgi.url_scheme"] == "https"
@app.route('/categories.JSON')
def CategoriesJSON():
category = session.query(Categories).all()
# CHECK IF THE USER LOGGED IN
if 'username' not in login_session:
return redirect('/login')
return jsonify(categories=[c.serialize for c in category])
@app.route('/categories/<int:category_id>/items/<int:item_id>/JSON')
def ArbitraryItemJSON(category_id, item_id):
#categroy = session.query(Categories).filter_by(
#id=category_id).one()
item = session.query(Items).filter_by(categories_id=category_id).filter_by(
id=item_id).all()
# CHECK IF THE USER LOGGED IN
if 'username' not in login_session:
return redirect('/login')
return jsonify(item=[i.serialize for i in item])
if __name__ == '__main__':
app.secret_key = 'super_secret_key'
app.debug = True
make_ssl_devcert('key', host='localhost')
app.run(host='0.0.0.0', port=80, ssl_context=('key.crt', 'key.key'))
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)
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
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)
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)
if open_browser:
import webbrowser
webbrowser.open(bind_url)
if use_reloader and settings.USE_I18N:
extra_files.extend(filter(lambda filename: filename.endswith('.mo'), gen_filenames()))
# Werkzeug needs to be clued in its the main instance if running
# without reloader or else it won't show key.
# https://git.io/vVIgo
if not use_reloader:
os.environ['WERKZEUG_RUN_MAIN'] = 'true'
# Don't run a second instance of the debugger / reloader
# See also: https://github.com/django-extensions/django-extensions/issues/832
if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':
if self.nopin:
os.environ['WERKZEUG_DEBUG_PIN'] = 'off'
handler = DebuggedApplication(handler, True)
run_simple(
self.addr,
int(self.port),
handler,
use_reloader=use_reloader,
use_debugger=True,
extra_files=extra_files,
reloader_interval=reloader_interval,
reloader_type=reloader_type,
threaded=threaded,
request_handler=WSGIRequestHandler,
ssl_context=ssl_context,
)
#-------------------------------------------------------------------------------
# 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 inner_run():
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)
if HAS_MIGRATIONS:
try:
self.check_migrations()
except ImproperlyConfigured:
pass
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)
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:
if self.show_startup_messages:
print("Werkzeug version is less than 0.9, trying adhoc certificate.")
ssl_context = "adhoc"
else:
ssl_context = None
if use_reloader and settings.USE_I18N:
try:
from django.utils.autoreload import gen_filenames
except ImportError:
pass
else:
extra_files.extend(filter(lambda filename: filename.endswith(".mo"), gen_filenames()))
run_simple(
self.addr,
int(self.port),
DebuggedApplication(handler, True),
use_reloader=use_reloader,
use_debugger=True,
extra_files=extra_files,
reloader_interval=reloader_interval,
threaded=threaded,
ssl_context=ssl_context,
)
__author__ = 'lekez2005'
from werkzeug.serving import make_ssl_devcert
import socket, os
def generate(regenerate):
ip = 'localhost'
try:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("8.8.8.8",80))
ip = s.getsockname()[0]
s.close()
except Exception, e:
print e
base_dir = os.path.dirname(os.path.realpath(__file__))
path = os.path.join(base_dir, 'server')
if regenerate:
server_crt, server_key = make_ssl_devcert(path, host=ip)
print 'Key created for ', ip
return ip, server_crt, server_key
else:
server_crt = path + '.crt'
server_key = path + '.key'
return ip, server_crt, server_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
#-------------------------------------------------------------------------------
# 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 ssl
import tempfile
from werkzeug import serving
def stdlib_ssl_app(environ, start_response):
start_response("200 OK", [("Content-Type", "text/html")])
return [b"hello"]
certificate, private_key = serving.make_ssl_devcert(
str(tempfile.mkdtemp(suffix="certs")))
ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
ctx.load_cert_chain(certificate, private_key)
ssl_kwargs = {}
ssl_kwargs["ssl_context"] = ctx
#-------------------------------------------------------------------------------
# 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(tmpdir):
certificate, private_key = \
serving.make_ssl_devcert(str(tmpdir))
assert os.path.isfile(certificate)
assert os.path.isfile(private_key)
# Generate fake ssl cert for development purposes
from werkzeug.serving import make_ssl_devcert
make_ssl_devcert("./config/ssl", host="localhost")
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
)
from app import app
from werkzeug.serving import make_ssl_devcert
import os
make_ssl_devcert('./ssl', host='localhost')
os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'
app.run(debug=True, ssl_context=('./ssl.crt', './ssl.key'))
