def validate_dockerrun_v2(dockerrun):
if dockerrun is None:
raise ValidationError(strings['local.missingdockerrun'])
elif _get_version(dockerrun) != VERSION_TWO:
raise ValidationError(strings['local.invaliddockerrunversion'])
def validate_build_config(build_config):
if build_config.service_role is not None:
# Verify that the service role exists in the customers account
from ebcli.lib.iam import get_roles
role = build_config.service_role
validated_role = None
existing_roles = get_roles()
for existing_role in existing_roles:
if role == existing_role['Arn'] or role == existing_role[
'RoleName']:
validated_role = existing_role['Arn']
if validated_role is None:
LOG.debug(
"Role '{0}' not found in retrieved list of roles".format(role))
raise ValidationError("Role '{0}' does not exist.".format(role))
build_config.service_role = validated_role
else:
io.log_warning(
"To learn more about creating a service role for CodeBuild, see Docs:"
" https://docs-aws.amazon.com/codebuild/latest/userguide/setting-up.html#setting-up-service-role"
)
raise ValidationError(
"No service role specified in buildspec; this is a required argument."
)
# Fail because the service role is required
if build_config.image is None:
# Fail because the image is required
raise ValidationError(
"No image specified in buildspec; this is a required argument.")
def validate_dockerrun_v1(dockerrun, is_used_to_make_dockerfile):
"""
Validates given Dockerrun.aws.json version, and that if no Dockerfile
exists, Image.Name and Ports[0].ContainerPort exists.
:param dockerrun: dict: dictionary representation of Dockerrun.aws.json
:param is_used_to_make_dockerfile: bool: whether used to make Dockerfile
:return: None
"""
if dockerrun is None:
return
if _get_version(dockerrun) != VERSION_ONE:
raise ValidationError(strings['local.invaliddockerrunversion'])
if not is_used_to_make_dockerfile:
return
if IMG_KEY not in dockerrun or IMG_NAME_KEY not in dockerrun[IMG_KEY]:
raise ValidationError(strings['local.missingdockerrunimage'])
elif PORTS_KEY not in dockerrun:
raise ValidationError(strings['local.missingdockerrunports'])
elif CONTAINER_PORT_KEY not in dockerrun[PORTS_KEY][0]:
raise ValidationError(strings['local.missingdockerruncontainerport'])
def delete_app_version_label(app_name, version_label):
if version_label:
# check if version_label exists under app_name
app_versions = elasticbeanstalk.get_application_versions(app_name)['ApplicationVersions']
# if the given version label does not exist at all!
if not any(version_label == app_version['VersionLabel'] for app_version in app_versions):
raise ValidationError(strings['appversion.delete.notfound'].format(app_name, version_label))
envs = elasticbeanstalk.get_app_environments(app_name)
versions_in_use = [(e.version_label, e.name) for e in envs]
# find all the environments that are using the app version
used_envs = [version[1] for version in versions_in_use if version[0] == version_label]
if used_envs:
raise ValidationError(strings['appversion.delete.deployed'].format(version_label, ','.join(used_envs)))
try:
io.validate_action(prompts['appversion.delete.validate'].format(version_label), "y")
elasticbeanstalk.delete_application_version(app_name, version_label)
io.echo('Application Version deleted successfully.')
delete_successful = True
except ValidationError:
io.echo('Application Version will not be deleted.')
delete_successful = False
return delete_successful
else:
raise NotFoundError(strings['appversion.delete.none'])
def delete_platform_version(platform_version, force=False):
arn = _version_to_arn(platform_version)
if not force:
io.echo(prompts['platformdelete.confirm'].replace(
'{platform-arn}', arn))
io.validate_action(prompts['platformdelete.validate'], arn)
environments = []
try:
environments = [
env for env in elasticbeanstalk.get_environments()
if env.platform.version == arn
]
except NotFoundError:
pass
if len(environments) > 0:
_, platform_name, platform_version = PlatformVersion.arn_to_platform(
arn)
raise ValidationError(strings['platformdeletevalidation.error'].format(
platform_name, platform_version,
'\n '.join([env.name for env in environments])))
response = elasticbeanstalk.delete_platform(arn)
request_id = response['ResponseMetadata']['RequestId']
timeout = 10
commonops.wait_for_success_events(request_id,
timeout_in_minutes=timeout,
platform_arn=arn)
def _validate_preconfig_dockerfile(soln_stk, container_config,
full_docker_path):
"""
Validates that the Dockerfile found at full_docker_path has the correct
Docker base image that matches runtime Docker image appropriate for this
solution stack. For example, the given solution stack:
64bit Debian jessie v1.2.0 running GlassFish 4.1 Java 8 (Preconfigured - Docker)
must have
glassfish-runtime-4.1-jdk8 base image in the Dockerfile.
:param soln_stk: SolutionStack: the solution stack
:param container_config: dict: container_config.json as dict
:param full_docker_path: str: path to the Dockerfile
:return: bool
"""
container_info = containerops._get_preconfig_info(soln_stk,
container_config)
expected_img = container_info[containerops.RUNTIME_IMG_KEY]
actual_img = commands._get_base_img(full_docker_path)
err_msg = (
'Invalid base Docker img in Dockerfile. Expected {} but got {}'.format(
expected_img, actual_img))
if actual_img != expected_img:
raise ValidationError(err_msg)
def _fst_match_in_dockerfile(full_docker_path, predicate, not_found_error_msg):
raw_lines = fileoperations.readlines_from_text_file(full_docker_path)
stripped_lines = (x.strip() for x in raw_lines)
try:
line = next(x for x in stripped_lines if predicate(x))
return line.split()
except StopIteration:
raise ValidationError(not_found_error_msg)
def delete_app_version_label(app_name, version_label):
if version_label:
app_versions = elasticbeanstalk.get_application_versions(
app_name)['ApplicationVersions']
if not any(version_label == app_version['VersionLabel']
for app_version in app_versions):
raise ValidationError(strings['appversion.delete.notfound'].format(
app_name, version_label))
envs = elasticbeanstalk.get_app_environments(app_name)
versions_in_use = [(e.version_label, e.name) for e in envs]
used_envs = [
version[1] for version in versions_in_use
if version[0] == version_label
]
if used_envs:
raise ValidationError(strings['appversion.delete.deployed'].format(
version_label, ','.join(used_envs)))
should_delete = io.get_boolean_response(
text=prompts['appversion.delete.validate'].format(version_label),
default=True)
if not should_delete:
io.echo('Application Version will not be deleted.')
delete_successful = False
else:
elasticbeanstalk.delete_application_version(
app_name, version_label)
io.echo('Application Version deleted successfully.')
delete_successful = True
return delete_successful
else:
raise NotFoundError(strings['appversion.delete.none'])
def get_dockerrun(dockerrun_path):
"""
Return dict representation of Dockerrun.aws.json in dockerrun_path
Return None if Dockerrun doesn't exist at that path.
:param dockerrun_path: str: full path to Dockerrun.aws.json
:return: dict
"""
try:
return fileoperations.get_json_dict(dockerrun_path)
except ValueError:
raise ValidationError(strings['local.invalidjson'])
except IOError: # Dockerrun.aws.json doesn't exist
return None
def get_build_configuration():
# TODO: Verify this is correct.
# Values expected in the eb config section in BuildSpec
service_role_key = 'CodeBuildServiceRole'
image_key = 'Image'
compute_key = 'ComputeType'
timeout_key = 'Timeout'
# get setting from global if it exists
cwd = os.getcwd() # save working directory
try:
_traverse_to_project_root()
build_spec = _get_yaml_dict(buildspec_name)
# Assert that special beanstalk section exists
if buildspec_config_header not in build_spec.keys():
LOG.debug("Buildspec Keys: {0}".format(build_spec.keys()))
raise ValidationError("Beanstalk configuration header '{0}' is missing from Buildspec file".format(buildspec_config_header))
build_configuration = BuildConfiguration()
beanstalk_build_configs = build_spec[buildspec_config_header]
LOG.debug("EB Config Keys: {0}".format(beanstalk_build_configs.keys()))
if service_role_key in beanstalk_build_configs.keys():
build_configuration.service_role = beanstalk_build_configs[service_role_key]
if image_key in beanstalk_build_configs.keys():
build_configuration.image = beanstalk_build_configs[image_key]
if compute_key in beanstalk_build_configs.keys():
build_configuration.compute_type = beanstalk_build_configs[compute_key]
if timeout_key in beanstalk_build_configs.keys():
build_configuration.timeout = beanstalk_build_configs[timeout_key]
finally:
os.chdir(cwd) # move back to working directory
return build_configuration
def make_api_call(service_name, operation_name, **operation_options):
operation = _set_operation(service_name, operation_name)
aggregated_error_message = []
max_attempts = 10
region = _region_name
if not region:
region = 'default'
attempt = 0
while True:
attempt += 1
if attempt > 1:
LOG.debug('Retrying -- attempt #' + str(attempt))
delay = _get_delay(attempt)
time.sleep(delay)
try:
LOG.debug('Making api call: (' + service_name + ', ' +
operation_name + ') to region: ' + region +
' with args:' + str(operation_options))
response_data = operation(**operation_options)
status = response_data['ResponseMetadata']['HTTPStatusCode']
LOG.debug('API call finished, status = ' + str(status))
if response_data:
LOG.debug('Response: ' + str(response_data))
return response_data
except botocore.exceptions.ClientError as e:
_handle_response_code(e.response, attempt,
aggregated_error_message)
except botocore.parsers.ResponseParserError as e:
LOG.debug('Botocore could not parse response received')
if attempt > max_attempts:
raise MaxRetriesError(
'Max retries exceeded for ResponseParserErrors' +
os.linesep.join(aggregated_error_message))
aggregated_error_message.insert(attempt, str(e))
except botocore.exceptions.NoCredentialsError:
LOG.debug('No credentials found')
raise CredentialsError('Operation Denied. You appear to have no'
' credentials')
except botocore.exceptions.PartialCredentialsError as e:
LOG.debug('Credentials incomplete')
raise CredentialsError(str(e))
except (botocore.exceptions.ValidationError,
botocore.exceptions.ParamValidationError) as e:
raise ValidationError(str(e))
except botocore.exceptions.BotoCoreError:
LOG.error('Botocore Error')
raise
except IOError as error:
if hasattr(error.args[0], 'reason') and str(error.args[0].reason) == \
'[Errno -2] Name or service not known':
raise ConnectionError()
LOG.error('Error while contacting Elastic Beanstalk Service')
LOG.debug('error:' + str(error))
raise ServiceError(error)
def validate_action(output, expected_input):
result = get_input(output)
if result != expected_input:
raise ValidationError(prompts['terminate.nomatch'])
