def action_runserver(instance_path, hostname, port, reloader, debugger,
profiler, profiler_file, profiler_dir, shell, show_sql,
threaded, processes):
"""start a new development server
\b
Start the LNT server using a development WSGI server. Additional options can be
used to control the server host and port, as well as useful development
features such as automatic reloading.
The command has built-in support for running the server on an instance which
has been packed into a (compressed) tarball. The tarball will be automatically
unpacked into a temporary directory and removed on exit. This is useful for
passing database instances back and forth, when others only need to be able to
view the results.
"""
import lnt.server.ui.app
import os
init_logger(logging.INFO, show_sql=show_sql)
app = lnt.server.ui.app.App.create_standalone(instance_path, )
if debugger:
app.debug = True
if profiler:
import werkzeug.contrib.profiler
if profiler_dir:
if not os.path.isdir(profiler_dir):
os.mkdir(profiler_dir)
app.wsgi_app = werkzeug.contrib.profiler.ProfilerMiddleware(
app.wsgi_app,
stream=open(profiler_file, 'w'),
profile_dir=profiler_dir)
if shell:
from flask import current_app
from flask import g
import code
ctx = app.test_request_context()
ctx.push()
vars = globals().copy()
vars.update(locals())
shell = code.InteractiveConsole(vars)
shell.interact()
else:
app.run(hostname,
port,
use_reloader=reloader,
use_debugger=debugger,
threaded=threaded,
processes=processes)
def action_runserver(instance_path, hostname, port, reloader, debugger,
profiler, profiler_file, profiler_dir, shell, show_sql,
threaded, processes):
"""start a new development server
\b
Start the LNT server using a development WSGI server. Additional options can be
used to control the server host and port, as well as useful development
features such as automatic reloading.
The command has built-in support for running the server on an instance which
has been packed into a (compressed) tarball. The tarball will be automatically
unpacked into a temporary directory and removed on exit. This is useful for
passing database instances back and forth, when others only need to be able to
view the results.
"""
import lnt.server.ui.app
import os
init_logger(logging.INFO, show_sql=show_sql)
app = lnt.server.ui.app.App.create_standalone(instance_path,)
if debugger:
app.debug = True
if profiler:
import werkzeug.contrib.profiler
if profiler_dir:
if not os.path.isdir(profiler_dir):
os.mkdir(profiler_dir)
app.wsgi_app = werkzeug.contrib.profiler.ProfilerMiddleware(
app.wsgi_app, stream=open(profiler_file, 'w'),
profile_dir=profiler_dir)
if shell:
from flask import current_app
from flask import g
import code
ctx = app.test_request_context()
ctx.push()
vars = globals().copy()
vars.update(locals())
shell = code.InteractiveConsole(vars)
shell.interact()
else:
app.run(hostname, port,
use_reloader=reloader,
use_debugger=debugger,
threaded=threaded,
processes=processes)
def action_runserver(name, args):
"""start a new development server"""
parser = OptionParser("""\
%s [options] <instance path>
Start the LNT server using a development WSGI server. Additional options can be
used to control the server host and port, as well as useful development features
such as automatic reloading.
The command has built-in support for running the server on an instance which has
been packed into a (compressed) tarball. The tarball will be automatically
unpacked into a temporary directory and removed on exit. This is useful for
passing database instances back and forth, when others only need to be able to
view the results.\
""" % name)
parser.add_option("",
"--hostname",
dest="hostname",
type=str,
help="host interface to use [%default]",
default='localhost')
parser.add_option("",
"--port",
dest="port",
type=int,
metavar="N",
help="local port to use [%default]",
default=8000)
parser.add_option("",
"--reloader",
dest="reloader",
default=False,
action="store_true",
help="use WSGI reload monitor")
parser.add_option("",
"--debugger",
dest="debugger",
default=False,
action="store_true",
help="use WSGI debugger")
parser.add_option("",
"--profiler-file",
dest="profiler_file",
help="file to dump profile info to [%default]",
default="profiler.log")
parser.add_option("", "--profiler-dir", dest="profiler_dir",
help="pstat.Stats files are saved to this directory " \
+"[%default]",
default=None)
parser.add_option("",
"--profiler",
dest="profiler",
default=False,
action="store_true",
help="enable WSGI profiler")
parser.add_option("",
"--shell",
dest="shell",
default=False,
action="store_true",
help="Load in shell.")
parser.add_option("",
"--show-sql",
dest="show_sql",
default=False,
action="store_true",
help="show all SQL queries")
parser.add_option("",
"--threaded",
dest="threaded",
default=False,
action="store_true",
help="use a threaded server")
parser.add_option("",
"--processes",
dest="processes",
type=int,
metavar="N",
help="number of processes to use [%default]",
default=1)
(opts, args) = parser.parse_args(args)
if len(args) != 1:
parser.error("invalid number of arguments")
input_path, = args
# Setup the base LNT logger.
# Root logger in debug.
logger = logging.getLogger(LOGGER_NAME)
if opts.debugger:
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
handler.setLevel(logging.DEBUG)
handler.setFormatter(
logging.Formatter('%(asctime)s %(levelname)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S'))
logger.addHandler(handler)
# Enable full SQL logging, if requested.
if opts.show_sql:
sa_logger = logging.getLogger("sqlalchemy")
if opts.debugger:
sa_logger.setLevel(logging.DEBUG)
sa_logger.setLevel(logging.INFO)
sa_logger.addHandler(handler)
import lnt.server.ui.app
app = lnt.server.ui.app.App.create_standalone(input_path, )
if opts.debugger:
app.debug = True
if opts.profiler:
if opts.profiler_dir:
if not os.path.isdir(opts.profiler_dir):
os.mkdir(opts.profiler_dir)
app.wsgi_app = werkzeug.contrib.profiler.ProfilerMiddleware(
app.wsgi_app,
stream=open(opts.profiler_file, 'w'),
profile_dir=opts.profiler_dir)
if opts.shell:
from flask import current_app
from flask import g
ctx = app.test_request_context()
ctx.push()
vars = globals().copy()
vars.update(locals())
shell = code.InteractiveConsole(vars)
shell.interact()
else:
app.run(opts.hostname,
opts.port,
use_reloader=opts.reloader,
use_debugger=opts.debugger,
threaded=opts.threaded,
processes=opts.processes)
def action_view_comparison(name, args):
"""view a report comparison using a temporary server"""
import lnt.server.instance
import lnt.server.ui.app
import lnt.server.db.migrate
parser = OptionParser("%s [options] <report A> <report B>" % (name,))
parser.add_option("", "--hostname", dest="hostname", type=str,
help="host interface to use [%default]",
default='localhost')
parser.add_option("", "--port", dest="port", type=int, metavar="N",
help="local port to use [%default]", default=8000)
parser.add_option("", "--dry-run", dest="dry_run",
help="Do a dry run through the comparison. [%default]"
" [%default]", action="store_true", default=False)
(opts, args) = parser.parse_args(args)
if len(args) != 2:
parser.error("invalid number of arguments")
report_a_path, report_b_path = args
# Set up the default logger.
logger = logging.getLogger("lnt")
logger.setLevel(logging.ERROR)
handler = logging.StreamHandler(sys.stderr)
handler.setFormatter(logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S'))
logger.addHandler(handler)
# Create a temporary directory to hold the instance.
tmpdir = tempfile.mkdtemp(suffix='lnt')
try:
# Create a temporary instance.
url = 'http://%s:%d' % (opts.hostname, opts.port)
db_path = os.path.join(tmpdir, 'data.db')
db_info = lnt.server.config.DBInfo(
'sqlite:///%s' % (db_path,), '0.4', None,
lnt.server.config.EmailConfig(False, '', '', []), "0")
# _(self, name, zorgURL, dbDir, tempDir,
# profileDir, secretKey, databases, blacklist):
config = lnt.server.config.Config('LNT', url, db_path, tmpdir,
None, None, {'default': db_info},
None)
instance = lnt.server.instance.Instance(None, config)
# Create the database.
lnt.server.db.migrate.update_path(db_path)
# Import the two reports.
with contextlib.closing(config.get_database('default')) as db:
import_and_report(
config, 'default', db, report_a_path,
'<auto>', commit=True)
import_and_report(
config, 'default', db, report_b_path,
'<auto>', commit=True)
# Dispatch another thread to start the webbrowser.
comparison_url = '%s/v4/nts/2?compare_to=1' % (url,)
note("opening comparison view: %s" % (comparison_url,))
if not opts.dry_run:
thread.start_new_thread(start_browser, (comparison_url, True))
# Run the webserver.
app = lnt.server.ui.app.App.create_with_instance(instance)
app.debug = True
if opts.dry_run:
# Don't catch out exceptions.
app.testing = True
# Create a test client.
client = app.test_client()
response = client.get(comparison_url)
assert response.status_code == 200, "Page did not return 200."
else:
app.run(opts.hostname, opts.port, use_reloader=False)
finally:
shutil.rmtree(tmpdir)
def action_view_comparison(report_a, report_b, hostname, port, dry_run,
testsuite):
"""view a report comparison using a temporary server"""
from .common import init_logger
from lnt.util import logger
from lnt.util.ImportData import import_and_report
import contextlib
import lnt.server.db.migrate
import lnt.server.instance
import lnt.server.ui.app
import logging
import os
import shutil
import sys
import tempfile
import thread
import time
import urllib
import webbrowser
init_logger(logging.ERROR)
# Create a temporary directory to hold the instance.
tmpdir = tempfile.mkdtemp(suffix='lnt')
try:
# Create a temporary instance.
url = 'http://%s:%d' % (hostname, port)
db_path = os.path.join(tmpdir, 'data.db')
db_info = lnt.server.config.DBInfo(
'sqlite:///%s' % (db_path, ), None,
lnt.server.config.EmailConfig(False, '', '', []), "0")
# _(self, name, zorgURL, dbDir, tempDir,
# profileDir, secretKey, databases, blacklist):
config = lnt.server.config.Config('LNT', url, db_path, tmpdir, None,
"Not secret key.",
{'default': db_info}, None, None)
instance = lnt.server.instance.Instance(None, config)
# Create the database.
lnt.server.db.migrate.update_path(db_path)
# Import the two reports.
with contextlib.closing(config.get_database('default')) as db:
session = db.make_session()
r = import_and_report(config,
'default',
db,
session,
report_a,
'<auto>',
testsuite,
select_machine='match')
import_and_report(config,
'default',
db,
session,
report_b,
'<auto>',
testsuite,
select_machine='match')
# Dispatch another thread to start the webbrowser.
comparison_url = '%s/v4/nts/2?compare_to=1' % (url, )
logger.info("opening comparison view: %s" % (comparison_url, ))
if not dry_run:
thread.start_new_thread(_start_browser, (comparison_url, True))
# Run the webserver.
app = lnt.server.ui.app.App.create_with_instance(instance)
app.debug = True
if dry_run:
# Don't catch out exceptions.
app.testing = True
# Create a test client.
client = app.test_client()
response = client.get(comparison_url)
assert response.status_code == 200, "Page did not return 200."
else:
app.run(hostname, port, use_reloader=False)
finally:
shutil.rmtree(tmpdir)
def action_view_comparison(report_a, report_b, hostname, port, dry_run,
testsuite):
"""view a report comparison using a temporary server"""
from .common import init_logger
from lnt.util import logger
from lnt.util.ImportData import import_and_report
import contextlib
import lnt.server.db.migrate
import lnt.server.instance
import lnt.server.ui.app
import logging
import os
import shutil
import tempfile
import thread
init_logger(logging.ERROR)
# Create a temporary directory to hold the instance.
tmpdir = tempfile.mkdtemp(suffix='lnt')
try:
# Create a temporary instance.
url = 'http://%s:%d' % (hostname, port)
db_path = os.path.join(tmpdir, 'data.db')
db_info = lnt.server.config.DBInfo(
'sqlite:///%s' % (db_path,), None,
lnt.server.config.EmailConfig(False, '', '', []), "0")
# _(self, name, zorgURL, dbDir, tempDir,
# profileDir, secretKey, databases, blacklist):
config = lnt.server.config.Config('LNT', url, db_path, tmpdir,
None, "Not secret key.",
{'default': db_info}, None,
None)
instance = lnt.server.instance.Instance(None, config)
# Create the database.
lnt.server.db.migrate.update_path(db_path)
# Import the two reports.
with contextlib.closing(config.get_database('default')) as db:
session = db.make_session()
import_and_report(config, 'default', db, session, report_a,
'<auto>', testsuite, select_machine='match')
import_and_report(config, 'default', db, session, report_b,
'<auto>', testsuite, select_machine='match')
# Dispatch another thread to start the webbrowser.
comparison_url = '%s/v4/nts/2?compare_to=1' % (url,)
logger.info("opening comparison view: %s" % (comparison_url,))
if not dry_run:
thread.start_new_thread(_start_browser, (comparison_url, True))
# Run the webserver.
app = lnt.server.ui.app.App.create_with_instance(instance)
app.debug = True
if dry_run:
# Don't catch out exceptions.
app.testing = True
# Create a test client.
client = app.test_client()
response = client.get(comparison_url)
assert response.status_code == 200, "Page did not return 200."
else:
app.run(hostname, port, use_reloader=False)
finally:
shutil.rmtree(tmpdir)
def action_runserver(name, args):
"""start a new development server"""
parser = OptionParser("""\
%s [options] <instance path>
Start the LNT server using a development WSGI server. Additional options can be
used to control the server host and port, as well as useful development features
such as automatic reloading.
The command has built-in support for running the server on an instance which has
been packed into a (compressed) tarball. The tarball will be automatically
unpacked into a temporary directory and removed on exit. This is useful for
passing database instances back and forth, when others only need to be able to
view the results.\
""" % name)
parser.add_option("", "--hostname", dest="hostname", type=str,
help="host interface to use [%default]",
default='localhost')
parser.add_option("", "--port", dest="port", type=int, metavar="N",
help="local port to use [%default]", default=8000)
parser.add_option("", "--reloader", dest="reloader", default=False,
action="store_true", help="use WSGI reload monitor")
parser.add_option("", "--debugger", dest="debugger", default=False,
action="store_true", help="use WSGI debugger")
parser.add_option("", "--profiler", dest="profiler", default=False,
action="store_true", help="enable WSGI profiler")
parser.add_option("", "--show-sql", dest="show_sql", default=False,
action="store_true", help="show all SQL queries")
parser.add_option("", "--threaded", dest="threaded", default=False,
action="store_true", help="use a threaded server")
parser.add_option("", "--processes", dest="processes", type=int,
metavar="N", help="number of processes to use [%default]",
default=1)
(opts, args) = parser.parse_args(args)
if len(args) != 1:
parser.error("invalid number of arguments")
input_path, = args
# Setup the base LNT logger.
logger = logging.getLogger("lnt")
if opts.debugger:
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stderr)
handler.setFormatter(logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S'))
logger.addHandler(handler)
# Enable full SQL logging, if requested.
if opts.show_sql:
sa_logger = logging.getLogger("sqlalchemy")
if opts.debugger:
sa_logger.setLevel(logging.DEBUG)
sa_logger.setLevel(logging.DEBUG)
sa_logger.addHandler(handler)
import lnt.server.ui.app
app = lnt.server.ui.app.App.create_standalone(input_path,)
if opts.debugger:
app.debug = True
if opts.profiler:
app.wsgi_app = werkzeug.contrib.profiler.ProfilerMiddleware(
app.wsgi_app, stream = open('profiler.log', 'w'))
app.run(opts.hostname, opts.port,
use_reloader = opts.reloader,
use_debugger = opts.debugger,
threaded = opts.threaded,
processes = opts.processes)
def action_view_comparison(name, args):
"""view a report comparison using a temporary server"""
import lnt.server.instance
import lnt.server.ui.app
import lnt.server.db.migrate
parser = OptionParser("%s [options] <report A> <report B>" % (name,))
parser.add_option("", "--hostname", dest="hostname", type=str,
help="host interface to use [%default]",
default='localhost')
parser.add_option("", "--port", dest="port", type=int, metavar="N",
help="local port to use [%default]", default=8000)
(opts, args) = parser.parse_args(args)
if len(args) != 2:
parser.error("invalid number of arguments")
report_a_path,report_b_path = args
# Set up the default logger.
logger = logging.getLogger("lnt")
logger.setLevel(logging.ERROR)
handler = logging.StreamHandler(sys.stderr)
handler.setFormatter(logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S'))
logger.addHandler(handler)
# Create a temporary directory to hold the instance.
tmpdir = tempfile.mkdtemp(suffix='lnt')
try:
# Create a temporary instance.
url = 'http://%s:%d' % (opts.hostname, opts.port)
db_path = os.path.join(tmpdir, 'data.db')
db_info = lnt.server.config.DBInfo(
'sqlite:///%s' % (db_path,), '0.4', None,
lnt.server.config.EmailConfig(False, '', '', []), "0")
config = lnt.server.config.Config(
'LNT', url, db_path, tmpdir,
None, { 'default' : db_info })
instance = lnt.server.instance.Instance(None, config)
# Create the database.
lnt.server.db.migrate.update_path(db_path)
# Import the two reports.
with contextlib.closing(config.get_database('default')) as db:
result = lnt.util.ImportData.import_and_report(
config, 'default', db, report_a_path,
'<auto>', commit=True)
result = lnt.util.ImportData.import_and_report(
config, 'default', db, report_b_path,
'<auto>', commit=True)
# Dispatch another thread to start the webbrowser.
comparison_url = '%s/v4/nts/2?compare_to=1' % (url,)
note("opening comparison view: %s" % (comparison_url,))
thread.start_new_thread(start_browser, (comparison_url, True))
# Run the webserver.
app = lnt.server.ui.app.App.create_with_instance(instance)
app.debug = True
app.run(opts.hostname, opts.port, use_reloader=False)
finally:
shutil.rmtree(tmpdir)
