def test_is_cgap_env():
assert is_cgap_env(None) is False
assert is_cgap_env('fourfront-cgap') is True
assert is_cgap_env('cgap-prod') is True
assert is_cgap_env('fourfront-blue') is False
def infer_repo_from_env(event):
source_env = event['source_env']
dest_env = event['dest_env']
if is_cgap_env(source_env) and is_cgap_env(dest_env):
return 'cgap-portal'
elif is_cgap_env(source_env) and is_cgap_env(dest_env):
return 'fourfront'
else:
raise InconsistentEnvironments(source_env=source_env,
dest_env=dest_env)
def mocked_standard_mirror_env(envname):
assert envname.endswith(
"-prd-env"
), "mocked_standard_mirror_env does nto handle %r." % envname
if env_utils.is_fourfront_env(envname):
return "fourfront-stg-env"
elif env_utils.is_cgap_env(envname):
return None
else:
raise AssertionError(
"mocked_standard_mirror_env does not handle %r." % envname)
def test_compute_prd_env_for_env():
computed_ff_prd = compute_prd_env_for_env('fourfront-mastertest')
assert is_fourfront_env(computed_ff_prd)
assert is_stg_or_prd_env(computed_ff_prd)
computed_cgap_prd = compute_prd_env_for_env('fourfront-cgapwolf')
assert is_cgap_env(computed_cgap_prd)
assert is_stg_or_prd_env(computed_cgap_prd)
with pytest.raises(NotBeanstalkEnvironment):
compute_prd_env_for_env('fourfront-production-blue')
def provision_indexer_environment(connection, **kwargs):
""" Provisions an indexer environment for the given env. Note that only one indexer can be online
per application (one for 4DN, one for CGAP).
IMPORTANT: env is an EB ENV NAME ('data', 'staging' are NOT valid).
IMPORTANT: This ecosystem will break some integrated tests in dcicutils
"""
check = CheckResult(connection, 'provision_indexer_environment')
env = kwargs.get('env', None)
application_version = kwargs.get('application_version', None)
if application_version is None:
check.status = 'ERROR'
check.summary = 'Did not provide application_version to deploy indexer, which is required. ' \
'Get this information from the EB Console.'
return check
def _deploy_indexer(e, version):
if is_fourfront_env(e):
description = try_to_describe_indexer_env(FF_ENV_INDEXER)
else:
description = try_to_describe_indexer_env(CGAP_ENV_INDEXER)
if description is not None:
check.status = 'ERROR'
check.summary = 'Tried to spin up indexer env for %s when one already exists for this portal' % e
return False
else:
return EBDeployer.deploy_indexer(e, version)
if is_cgap_env(env) or is_fourfront_env(env):
success = _deploy_indexer(env, application_version)
if success:
check.status = 'PASS'
check.summary = 'Successfully triggered indexer-server provision for environment %s' % env
else:
check.status = 'ERROR'
check.summary = 'An error occurred on deployment. Check the AWS EB Console.'
else:
check.status = 'FAIL'
check.summary = 'Gave an unknown environment: %s' % env
return check
def convert_to_html(data, environment):
if is_cgap_env(environment):
logo_url = CGAP_LOGO_URL
logo_url_alt = "CGAP helix logo"
page_name = "CGAP Status"
else:
logo_url = FF_LOGO_URL
logo_url_alt = "4DN sphere logo"
page_name = "Fourfront Status"
message = data.get("message")
calendar_events = data.get('calendar')
if not calendar_events and not message:
# When there's no error message to shown, supply a default event if nothing else to show.
calendar_events = [NULL_EVENT]
priority = data.get('priority') or DEFAULT_PRIORITY
event_str = io.StringIO()
sections_used = []
for i, event in enumerate(calendar_events, start=1):
# print("calendar_event=", calendar_event, "i=", i)
event_name = event.get('name') or "Event %s" % i
affects = event.get('affects') or {}
affects_name = affects.get('name') or ""
# affects_envs = affects.get('environments') or []
section = io.StringIO()
section.write('<dt class="calendar-event">%s</dt>\n' %
html.escape(event_name))
section.write("<dd>\n")
section.write('<p><span class="who">%s</span>' %
html.escape(affects_name))
section.write(
' <span class="when">(%s to %s)</span></p>\n' %
(html.escape(event.get('start_time') or "now"),
html.escape(event.get('end_time') or "the foreseeable future")))
section.write(
'<p class="what">%s</p>\n' %
(html.escape(event.get("description") or "To Be Determined")))
section.write("</dt>\n")
event_str.write(section.getvalue())
sections_used.append(i)
event_body = event_str.getvalue()
message = '<div class="message bgcolor_orange"><p>NOTE: ' + html.escape(
message) + '</p></div>' if message else ''
substitutions = {
'PRIORITY': priority,
'LOGO_URL': logo_url,
'LOGO_URL_ALT': logo_url_alt,
'PAGE_NAME': page_name,
'EVENT_BODY': event_body,
'MESSAGE': message,
}
body = '''
<!DOCTYPE html>
<html>
<head>
<title>4DN Status</title>
<meta name="robots" content="noindex, nofollow" />
<style><!--
.bgcolor_red {background: #ffdddd}
.bgcolor_orange {background: #ffeedd}
.bgcolor_yellow {background: #ffffdd}
.bgcolor_green {background: #ddffdd}
.banner {padding-left: 30pt; padding-bottom: 10pt; padding-top: 10pt;}
.page-name {padding-left: 10pt; font-size: 30pt;}
.logo {height: 100%; vertical-align: middle; height: 36pt;}
.calendar {padding-left: 30pt;}
.calendar-event {font-size: 20pt;}
.who {font-weight: bold; font-size: 16pt;}
.when {font-weight: bold; font-size: 14pt;}
.what {font-size: 12pt;}
div.message {margin-top: 5pt; padding-left: 30pt; border: 1pt red solid; width: 500pt;}
div.message p {font-weight: bold;}
--></style>
</head>
<body>
<div class="banner bgcolor_<<PRIORITY>>" id="banner">
<table>
<tr>
<td valign="middle">
<img src="<<LOGO_URL>>" class="logo" alt="<<LOGO_URL_ALT>>" />
</td>
<td class="page-name" valign="bottom"><<PAGE_NAME>></td>
</tr>
</table>
</div>
<<MESSAGE>>
<dl class="calendar">
<<EVENT_BODY>>
</dl>
</body>
</html>'''
for name, val in substitutions.items():
body = body.replace('<<' + name + '>>', val)
return body
def test_magic_cnames_by_cname_consistency():
# These tests are highly specific and will have to change if we make something else be magic.
# But such is magic. The values should not be casually changed, and such overhead is appropriate.
# It's good to have tests that will catch unwanted tinkering, typos, etc.
ff_magic_envs = [FF_ENV_PRODUCTION_GREEN, FF_ENV_PRODUCTION_BLUE]
cgap_magic_envs = [CGAP_ENV_WEBPROD]
assert ff_magic_envs == ['fourfront-green', 'fourfront-blue']
assert cgap_magic_envs == ['fourfront-cgap']
client = boto3.client('elasticbeanstalk', region_name=base.REGION)
res = base.describe_beanstalk_environments(client,
ApplicationName='4dn-web')
envs = res['Environments']
roles = defaultdict(lambda: [])
for env in envs:
env_name = env.get('EnvironmentName')
cname = env.get('CNAME')
ip = socket.gethostbyname(cname)
note = ""
if cname == base._FF_MAGIC_CNAME:
assert env_name in ff_magic_envs
ff_prod = "data.4dnucleome.org"
ff_prod_ips = _ip_addresses(ff_prod)
assert _ip_addresses(cname) == ff_prod_ips
note = "\n => FF PRODUCTION (%s @ %s)" % (ff_prod,
",".join(ff_prod_ips))
roles['FF_PRODUCTION'].append(env_name)
assert env_utils.is_stg_or_prd_env(env_name)
elif cname == base._CGAP_MAGIC_CNAME:
assert env_name in cgap_magic_envs
cgap_prod = "cgap.hms.harvard.edu"
cgap_prod_ips = _ip_addresses(cgap_prod)
assert _ip_addresses(cname) == cgap_prod_ips
note = "\n => CGAP PRODUCTION (%s @ %s)" % (
cgap_prod, ",".join(cgap_prod_ips))
roles['CGAP_PRODUCTION'].append(env_name)
assert env_utils.is_stg_or_prd_env(env_name)
elif env_utils.is_stg_or_prd_env(env_name):
if env_utils.is_cgap_env(env_name):
note = "\n => CGAP STAGING ???" # An error about this is reported later
roles['CGAP_STAGING'].append(env_name)
assert env_utils.is_stg_or_prd_env(env_name)
else:
ff_staging = "staging.4dnucleome.org"
ff_staging_ips = _ip_addresses(ff_staging)
assert _ip_addresses(cname) == ff_staging_ips
note = "\n => FF STAGING (%s @ %s)" % (
ff_staging, ",".join(ff_staging_ips))
roles['FF_STAGING'].append(env_name)
assert env_utils.is_stg_or_prd_env(env_name)
print("%s (%s) = %s %s" % (env_name, ip, cname, note))
print("roles =", json.dumps(roles, indent=2))
assert len(roles['FF_PRODUCTION']) == 1
assert len(roles['FF_STAGING']) == 1
assert len(roles['CGAP_PRODUCTION']) == 1
assert len(roles['CGAP_STAGING']
) == 0 # CGAP does not expect to have a production mirror
assert env_utils.get_standard_mirror_env(
roles['FF_PRODUCTION'][0]) == roles['FF_STAGING'][0]
assert env_utils.get_standard_mirror_env(
roles['FF_STAGING'][0]) == roles['FF_PRODUCTION'][0]