def _perform_project_stages(project_env, project_root_dir):
"""
performs the stages of an individual project: docker startup,
seed_users, smoke_tests, docker teardown
takes a ProjectEnv
Returns a list of stage_results (the objects returned
by _perform_stage)
"""
stage_results = list()
project_name = project_env.get_project_name()
stage_name = project_name + ' web_assets:dist'
client_dist_stage = _perform_stage(stage_name, compile_ops._compile,
project_root_dir, 'web_assets:dist',
ProjectEnv.hello_world_instance(),
RunLevel.development_instance())
stage_results.append(client_dist_stage)
stage_name = project_name + ' startup containers'
startup_containers_stage = _perform_stage(stage_name,
docker_ops._docker_action,
'startup', 'all', project_env,
RunLevel.development_instance(),
NestSite.localhost_instance(),
project_root_dir)
stage_results.append(startup_containers_stage)
stage_name = project_name + ' ensure db tables'
db_tables_project_stage = _perform_stage(stage_name, db_ops._run_db_action,
'ensure_tables', project_env,
NestSite.localhost_instance())
stage_results.append(db_tables_project_stage)
stage_name = project_name + ' seed_users'
seed_users_project_stage = _perform_stage(
stage_name, seed_users_ops._run_seed_users_script, project_env,
RunLevel.development_instance())
stage_results.append(seed_users_project_stage)
stage_name = project_name + ' smoke_test'
smoke_project_stage = _perform_stage(stage_name,
smoke_test_ops._run_smoke_test,
project_env,
NestSite.localhost_instance())
stage_results.append(smoke_project_stage)
stage_name = project_name + ' teardown containers'
teardown_containers_stage = _perform_stage(stage_name,
docker_ops._docker_action,
'teardown', 'all', project_env,
RunLevel.development_instance(),
NestSite.localhost_instance(),
project_root_dir)
stage_results.append(teardown_containers_stage)
return stage_results
def _run_remote_maintenance_cmd(arg_map):
"""
translates arguments from commandline to calls to python methods. Input is
the output from argparse.parse_args(), output is an exit code indicating if
the maintenance script succeeded.
"""
target_site_name = arg_map['site']
target_site = NestSite.from_string(target_site_name)
if target_site == NestSite.localhost_instance():
print("Can't perform remote maintenance on localhost. \
Run ci_scripts/nightly_maintenance.sh directly")
return 1
exit_code = _run_remote_maintenance(target_site)
return exit_code
def _run_smoke_test_cmd(arg_map):
"""
translates arguments from commandline to calls to python methods. Input is
the output from argparse.parse_args(), output is an exit code indicating if
the compilation succeeded.
"""
project_root_dir = arg_map['project_root_dir']
project_env_name = arg_map['project']
project_env = ProjectEnv.from_string(project_env_name)
target_site_name = arg_map['site']
target_site = NestSite.from_string(target_site_name)
exit_code = _run_smoke_test(project_env, target_site)
return exit_code
def app():
from nest_py.core.flask.app2 import create_app
run_level = RunLevel.development_instance()
project_env = ProjectEnv.knoweng_instance()
config = nest_config.generate_config(run_level, project_env)
#force localhost as the db server
host = NestSite.localhost_instance().get_server_ip_address()
config['host'] = host
_app = create_app(config, project_env, run_level)
ctx = _app.test_request_context()
ctx.push()
yield _app
ctx.pop()
def generate_db_config(project_env=None, runlevel=None):
if project_env is None:
project_env = ProjectEnv.hello_world_instance()
if runlevel is None:
runlevel = RunLevel.development_instance()
config = {
"user":os.getenv('POSTGRES_USERNAME', "nest"),
"port": os.getenv('POSTGRES_PORT', 5432), #exported in docker startup
"password":os.getenv('POSTGRES_PASSWORD', "GARBAGESECRET"),
"db_name":os.getenv('POSTGRES_DATABASE', "nest"),
#"verbose_logging":True
"verbose_logging":False
}
host = os.getenv('POSTGRES_HOST', NestSite.localhost_instance().get_server_ip_address())
config['host'] = host
return config
def _run_docker_cmd(arg_map):
"""
translates arguments from commandline to calls to python methods. Input is
the output from argparse.parse_args(), output is an exit code indicating if
the compilation succeeded.
"""
project_root_dir = arg_map['project_root_dir']
action = arg_map['action']
project_env_name = arg_map['project']
project_env = ProjectEnv.from_string(project_env_name)
target_site_name = arg_map['site']
target_site = NestSite.from_string(target_site_name)
runlevel_name = arg_map['runlevel']
runlevel = RunLevel.from_string(runlevel_name)
service = arg_map['service']
exit_code = _docker_action(action, service, project_env, \
runlevel, target_site, project_root_dir)
return exit_code
def _run_seed_cmd(arg_map):
"""
translates arguments from commandline to calls to python methods. Input is
the output from argparse.parse_args(), output is an exit code indicating if
the job succeeded.
"""
project_root_dir = arg_map['project_root_dir']
project_env_name = arg_map['project']
project_env = ProjectEnv.from_string(project_env_name)
target_site_name = arg_map['site']
target_site = NestSite.from_string(target_site_name)
flavor_name = arg_map['flavor']
subsample_raw = arg_map['subsample']
subsample_lower = subsample_raw.lower()
if subsample_lower == 'true':
subsample = True
else:
subsample = False
exit_code = _run_seed_script(project_env, target_site, flavor_name,
subsample)
return exit_code
def build_and_test(project_root_dir):
"""
run all compilation and unit tests
"""
stage_results = list()
log("START ci_ops.BUILD_AND_TEST")
py_compile_stage = _perform_stage('python compilation ',
compile_ops._compile, project_root_dir,
'python', ProjectEnv.default_instance(),
RunLevel.development_instance())
stage_results.append(py_compile_stage)
js_compile_stage = _perform_stage('web_assets compilation',
compile_ops._compile, project_root_dir,
'web_assets',
ProjectEnv.hello_world_instance(),
RunLevel.development_instance())
stage_results.append(js_compile_stage)
build_containers_stage = _perform_stage('build containers ',
docker_ops._docker_action, 'build',
'all',
ProjectEnv.hello_world_instance(),
RunLevel.development_instance(),
NestSite.localhost_instance(),
project_root_dir)
stage_results.append(build_containers_stage)
#run pytests and clienttests against the hello_world_app containers
startup_containers_stage = _perform_stage(
'startup containers ', docker_ops._docker_action, 'startup', 'all',
ProjectEnv.hello_world_instance(), RunLevel.development_instance(),
NestSite.localhost_instance(), project_root_dir)
stage_results.append(startup_containers_stage)
clienttest_stage = _perform_stage('clienttest ',
clienttest_ops._run_unit_test,
project_root_dir)
stage_results.append(clienttest_stage)
pytest_stage = _perform_stage('pytest tests/unit/ ',
pytest_ops._run_unit_test, project_root_dir,
True)
stage_results.append(pytest_stage)
teardown_containers_stage = _perform_stage(
'teardown containers ', docker_ops._docker_action, 'teardown', 'all',
ProjectEnv.hello_world_instance(), RunLevel.development_instance(),
NestSite.localhost_instance(), project_root_dir)
stage_results.append(teardown_containers_stage)
#test the lifecycle and smoke scripts of all projects
project_names = nest_envs.VALID_PROJECT_NAMES
for project_name in project_names:
project_env = ProjectEnv(project_name)
project_stage_results = _perform_project_stages(
project_env, project_root_dir)
stage_results += project_stage_results
exit_code = _finalize_build(stage_results)
log("BUILD_AND_TESTS returning exit_code: " + str(exit_code))
return exit_code