def get_keyname(self, default=None):
keyname = self.app.pargs.keyname
if not keyname:
keyname = default
# Get keyname from config file, if exists
if not keyname:
try:
keyname = commonops.get_default_keyname()
except NotInitializedError:
keyname = None
if self.force_non_interactive and not self.interactive:
return keyname
if keyname is None or \
(self.interactive and not self.app.pargs.keyname):
# Prompt for one
keyname = sshops.prompt_for_ec2_keyname()
elif keyname != -1:
commonops.upload_keypair_if_needed(keyname)
return keyname
def get_keyname(self, default=None):
keyname = self.app.pargs.keyname
if not keyname:
keyname = default
# Get keyname from config file, if exists
if not keyname:
try:
keyname = commonops.get_default_keyname()
except NotInitializedError:
keyname = None
if self.force_non_interactive and not self.interactive:
return keyname
if keyname is None or \
(self.interactive and not self.app.pargs.keyname):
# Prompt for one
keyname = sshops.prompt_for_ec2_keyname()
elif keyname != -1:
commonops.upload_keypair_if_needed(keyname)
return keyname
def get_keyname(self, keyname):
# Get keyname from config file, if exists
if not keyname:
try:
keyname = commonops.get_default_keyname()
except NotInitializedError:
keyname = None
if keyname is None:
# Prompt for one
keyname = sshops.prompt_for_ec2_keyname(message=prompts['platforminit.ssh'])
elif keyname != -1:
commonops.upload_keypair_if_needed(keyname)
return keyname
def get_keyname(self, keyname):
# Get keyname from config file, if exists
if not keyname:
try:
keyname = commonops.get_default_keyname()
except NotInitializedError:
keyname = None
if keyname is None:
# Prompt for one
keyname = sshops.prompt_for_ec2_keyname(
message=prompts['platforminit.ssh'])
elif keyname != -1:
commonops.upload_keypair_if_needed(keyname)
return keyname
def create_platform_version(
version,
major_increment,
minor_increment,
patch_increment,
instance_type,
vpc=None,
staged=False,
timeout=None,
tags=None,
):
_raise_if_directory_is_empty()
_raise_if_platform_definition_file_is_missing()
version and _raise_if_version_format_is_invalid(version)
platform_name = fileoperations.get_platform_name()
instance_profile = fileoperations.get_instance_profile(None)
key_name = commonops.get_default_keyname()
version = version or _resolve_version_number(
platform_name, major_increment, minor_increment, patch_increment)
tags = tagops.get_and_validate_tags(tags)
source_control = SourceControl.get_source_control()
io.log_warning(strings['sc.unstagedchanges']
) if source_control.untracked_changes_exist() else None
version_label = _resolve_version_label(source_control, staged)
bucket, key, file_path = _resolve_s3_bucket_and_key(
platform_name, version_label, source_control, staged)
_upload_platform_version_to_s3_if_necessary(bucket, key, file_path)
io.log_info('Creating Platform Version ' + version_label)
response = elasticbeanstalk.create_platform_version(
platform_name, version, bucket, key, instance_profile, key_name,
instance_type, tags, vpc)
environment_name = 'eb-custom-platform-builder-packer'
io.echo(
colored(
strings['platformbuildercreation.info'].format(environment_name),
attrs=['reverse']))
fileoperations.update_platform_version(version)
commonops.set_environment_for_current_branch(environment_name)
stream_platform_logs(response, platform_name, version, timeout)
def get_keyname(keyname, keyname_of_existing_app, interactive,
force_non_interactive):
keyname_passed_through_command_line = not not keyname
keyname = keyname or keyname_of_existing_app
if not keyname:
try:
keyname = commonops.get_default_keyname()
except NotInitializedError:
keyname = None
if force_non_interactive and not interactive:
return keyname
if ((interactive and not keyname_passed_through_command_line)
or (not keyname and not force_non_interactive)):
keyname = sshops.prompt_for_ec2_keyname()
elif keyname != -1:
commonops.upload_keypair_if_needed(keyname)
return keyname
def create_platform_version(
version,
major_increment,
minor_increment,
patch_increment,
instance_type,
vpc = None,
staged=False,
timeout=None):
platform_name = fileoperations.get_platform_name()
instance_profile = fileoperations.get_instance_profile(None)
key_name = commonops.get_default_keyname()
if version is None:
version = _get_latest_version(platform_name=platform_name, owner=Constants.OWNED_BY_SELF, ignored_states=[])
if version is None:
version = '1.0.0'
else:
major, minor, patch = version.split('.', 3)
if major_increment:
major = str(int(major) + 1)
minor = '0'
patch = '0'
if minor_increment:
minor = str(int(minor) + 1)
patch = '0'
if patch_increment or not(major_increment or minor_increment):
patch = str(int(patch) + 1)
version = "%s.%s.%s" % (major, minor, patch)
if not VALID_PLATFORM_VERSION_FORMAT.match(version):
raise InvalidPlatformVersionError(strings['exit.invalidversion'])
cwd = os.getcwd()
fileoperations._traverse_to_project_root()
try:
if heuristics.directory_is_empty():
raise PlatformWorkspaceEmptyError(strings['exit.platformworkspaceempty'])
finally:
os.chdir(cwd)
if not heuristics.has_platform_definition_file():
raise PlatformWorkspaceEmptyError(strings['exit.no_pdf_file'])
source_control = SourceControl.get_source_control()
if source_control.untracked_changes_exist():
io.log_warning(strings['sc.unstagedchanges'])
version_label = source_control.get_version_label()
if staged:
# Make a unique version label
timestamp = datetime.now().strftime("%y%m%d_%H%M%S")
version_label = version_label + '-stage-' + timestamp
file_descriptor, original_platform_yaml = tempfile.mkstemp()
os.close(file_descriptor)
copyfile('platform.yaml', original_platform_yaml)
s3_bucket = None
s3_key = None
try:
# Add option settings to platform.yaml
_enable_healthd()
s3_bucket, s3_key = get_app_version_s3_location(platform_name, version_label)
# Create zip file if the application version doesn't exist
if s3_bucket is None and s3_key is None:
file_name, file_path = _zip_up_project(version_label, source_control, staged=staged)
else:
file_name = None
file_path = None
finally:
# Restore original platform.yaml
move(original_platform_yaml, 'platform.yaml')
# Use existing bucket if it exists
bucket = elasticbeanstalk.get_storage_location() if s3_bucket is None else s3_bucket
# Use existing key if it exists
key = platform_name + '/' + file_name if s3_key is None else s3_key
try:
s3.get_object_info(bucket, key)
io.log_info('S3 Object already exists. Skipping upload.')
except NotFoundError:
io.log_info('Uploading archive to s3 location: ' + key)
s3.upload_platform_version(bucket, key, file_path)
# Just deletes the local zip
fileoperations.delete_app_versions()
io.log_info('Creating Platform Version ' + version_label)
response = elasticbeanstalk.create_platform_version(
platform_name, version, bucket, key, instance_profile, key_name, instance_type, vpc)
# TODO: Enable this once the API returns the name of the environment associated with a
# CreatePlatformRequest, and remove hard coded value. There is currently only one type
# of platform builder, we may support additional builders in the future.
#environment_name = response['PlatformSummary']['EnvironmentName']
environment_name = 'eb-custom-platform-builder-packer'
io.echo(colored(
strings['platformbuildercreation.info'].format(environment_name), attrs=['reverse']))
fileoperations.update_platform_version(version)
commonops.set_environment_for_current_branch(environment_name)
arn = response['PlatformSummary']['PlatformArn']
request_id = response['ResponseMetadata']['RequestId']
if not timeout:
timeout = 30
# Share streamer for platform events and builder events
streamer = io.get_event_streamer()
builder_events = threading.Thread(
target=logsops.stream_platform_logs,
args=(platform_name, version, streamer, 5, None, PackerStreamFormatter()))
builder_events.daemon = True
# Watch events from builder logs
builder_events.start()
commonops.wait_for_success_events(
request_id,
platform_arn=arn,
streamer=streamer,
timeout_in_minutes=timeout
)
def create_platform_version(version,
major_increment,
minor_increment,
patch_increment,
instance_type,
vpc=None,
staged=False,
timeout=None):
platform_name = fileoperations.get_platform_name()
instance_profile = fileoperations.get_instance_profile(None)
key_name = commonops.get_default_keyname()
if version is None:
version = _get_latest_version(platform_name=platform_name,
owner=Constants.OWNED_BY_SELF,
ignored_states=[])
if version is None:
version = '1.0.0'
else:
major, minor, patch = version.split('.', 3)
if major_increment:
major = str(int(major) + 1)
minor = '0'
patch = '0'
if minor_increment:
minor = str(int(minor) + 1)
patch = '0'
if patch_increment or not (major_increment or minor_increment):
patch = str(int(patch) + 1)
version = "%s.%s.%s" % (major, minor, patch)
if not VALID_PLATFORM_VERSION_FORMAT.match(version):
raise InvalidPlatformVersionError(strings['exit.invalidversion'])
cwd = os.getcwd()
fileoperations._traverse_to_project_root()
try:
if heuristics.directory_is_empty():
raise PlatformWorkspaceEmptyError(
strings['exit.platformworkspaceempty'])
finally:
os.chdir(cwd)
if not heuristics.has_platform_definition_file():
raise PlatformWorkspaceEmptyError(strings['exit.no_pdf_file'])
source_control = SourceControl.get_source_control()
if source_control.untracked_changes_exist():
io.log_warning(strings['sc.unstagedchanges'])
version_label = source_control.get_version_label()
if staged:
# Make a unique version label
timestamp = datetime.now().strftime("%y%m%d_%H%M%S")
version_label = version_label + '-stage-' + timestamp
file_descriptor, original_platform_yaml = tempfile.mkstemp()
os.close(file_descriptor)
copyfile('platform.yaml', original_platform_yaml)
try:
# Add option settings to platform.yaml
_enable_healthd()
s3_bucket, s3_key = get_app_version_s3_location(
platform_name, version_label)
# Create zip file if the application version doesn't exist
if s3_bucket is None and s3_key is None:
file_name, file_path = _zip_up_project(version_label,
source_control,
staged=staged)
else:
file_name = None
file_path = None
finally:
# Restore original platform.yaml
move(original_platform_yaml, 'platform.yaml')
# Use existing bucket if it exists
bucket = elasticbeanstalk.get_storage_location(
) if s3_bucket is None else s3_bucket
# Use existing key if it exists
key = platform_name + '/' + file_name if s3_key is None else s3_key
try:
s3.get_object_info(bucket, key)
io.log_info('S3 Object already exists. Skipping upload.')
except NotFoundError:
io.log_info('Uploading archive to s3 location: ' + key)
s3.upload_platform_version(bucket, key, file_path)
# Just deletes the local zip
fileoperations.delete_app_versions()
io.log_info('Creating Platform Version ' + version_label)
response = elasticbeanstalk.create_platform_version(
platform_name, version, bucket, key, instance_profile, key_name,
instance_type, vpc)
# TODO: Enable this once the API returns the name of the environment associated with a
# CreatePlatformRequest, and remove hard coded value. There is currently only one type
# of platform builder, we may support additional builders in the future.
#environment_name = response['PlatformSummary']['EnvironmentName']
environment_name = 'eb-custom-platform-builder-packer'
io.echo(
colored(
strings['platformbuildercreation.info'].format(environment_name),
attrs=['reverse']))
fileoperations.update_platform_version(version)
commonops.set_environment_for_current_branch(environment_name)
arn = response['PlatformSummary']['PlatformArn']
request_id = response['ResponseMetadata']['RequestId']
if not timeout:
timeout = 30
# Share streamer for platform events and builder events
streamer = io.get_event_streamer()
builder_events = threading.Thread(target=logsops.stream_platform_logs,
args=(platform_name, version, streamer,
5, None, PackerStreamFormatter()))
builder_events.daemon = True
# Watch events from builder logs
builder_events.start()
commonops.wait_for_success_events(request_id,
platform_arn=arn,
streamer=streamer,
timeout_in_minutes=timeout)
def do_command(self):
env_name = self.app.pargs.environment_name
modules = self.app.pargs.modules
if modules and len(modules) > 0:
self.compose_multiple_apps()
return
group = self.app.pargs.env_group_suffix
cname = self.app.pargs.cname
tier = self.app.pargs.tier
itype = self.app.pargs.instance_type
platform = self.app.pargs.platform
single = self.app.pargs.single
iprofile = self.app.pargs.instance_profile
service_role = self.app.pargs.service_role
label = self.app.pargs.version
branch_default = self.app.pargs.branch_default
key_name = self.app.pargs.keyname
sample = self.app.pargs.sample
nohang = self.app.pargs.nohang
tags = self.app.pargs.tags
envvars = self.app.pargs.envvars
scale = self.app.pargs.scale
timeout = self.app.pargs.timeout
cfg = self.app.pargs.cfg
elb_type = self.app.pargs.elb_type
source = self.app.pargs.source
process = self.app.pargs.process
enable_spot = self.app.pargs.enable_spot
spot_max_price = self.app.pargs.spot_max_price
instance_types = self.app.pargs.instance_types
on_demand_base_capacity = self.app.pargs.on_demand_base_capacity
on_demand_above_base_capacity = self.app.pargs.on_demand_above_base_capacity
max_instances = self.app.pargs.max_instances
min_instances = self.app.pargs.min_instances
interactive = False if env_name else True
provided_env_name = env_name
if sample and label:
raise InvalidOptionsError(strings['create.sampleandlabel'])
if single and scale:
raise InvalidOptionsError(strings['create.singleandsize'])
if (max_instances or min_instances) and scale:
raise InvalidOptionsError(strings['create.scaleandminmax'])
if (max_instances or min_instances) and single:
raise InvalidOptionsError(strings['create.singleandminmax'])
if single and elb_type:
raise InvalidOptionsError(strings['create.single_and_elb_type'])
if cname and tier and Tier.looks_like_worker_tier(tier):
raise InvalidOptionsError(strings['worker.cname'])
if cname and not elasticbeanstalk.is_cname_available(cname):
raise AlreadyExistsError(strings['cname.unavailable'].replace(
'{cname}', cname))
if tier and Tier.looks_like_worker_tier(tier):
if self.app.pargs.vpc_elbpublic or self.app.pargs.vpc_elbsubnets or self.app.pargs.vpc_publicip:
raise InvalidOptionsError(
strings['create.worker_and_incompatible_vpc_arguments'])
if (not tier or Tier.looks_like_webserver_tier(tier)) and single:
if self.app.pargs.vpc_elbpublic or self.app.pargs.vpc_elbsubnets:
raise InvalidOptionsError(
strings['create.single_and_elbpublic_or_elb_subnet'])
if (spot_max_price or on_demand_base_capacity
or on_demand_above_base_capacity) and not enable_spot:
raise InvalidOptionsError(strings['create.missing_enable_spot'])
if instance_types is "":
raise InvalidOptionsError(
strings['spot.instance_types_validation'])
if itype and instance_types:
raise InvalidOptionsError(strings['create.itype_and_instances'])
platform = _determine_platform(platform, iprofile)
app_name = self.get_app_name()
tags = tagops.get_and_validate_tags(tags)
envvars = get_and_validate_envars(envvars)
process_app_version = fileoperations.env_yaml_exists() or process
template_name = get_template_name(app_name, cfg)
tier = get_environment_tier(tier)
env_name = provided_env_name or get_environment_name(app_name, group)
cname = cname or get_environment_cname(env_name, provided_env_name,
tier)
key_name = key_name or commonops.get_default_keyname()
elb_type = elb_type or get_elb_type_from_customer(
interactive, single, tier)
enable_spot = enable_spot or spotops.get_spot_request_from_customer(
interactive)
instance_types = instance_types or spotops.get_spot_instance_types_from_customer(
interactive, enable_spot)
database = self.form_database_object()
vpc = self.form_vpc_object(tier, single)
if not timeout and database:
timeout = 15
env_request = CreateEnvironmentRequest(
app_name=app_name,
env_name=env_name,
group_name=group,
cname=cname,
template_name=template_name,
platform=platform,
tier=tier,
instance_type=itype,
version_label=label,
instance_profile=iprofile,
service_role=service_role,
single_instance=single,
key_name=key_name,
sample_application=sample,
tags=tags,
scale=scale,
database=database,
vpc=vpc,
elb_type=elb_type,
enable_spot=enable_spot,
instance_types=instance_types,
spot_max_price=spot_max_price,
on_demand_base_capacity=on_demand_base_capacity,
on_demand_above_base_capacity=on_demand_above_base_capacity,
min_instances=min_instances,
max_instances=max_instances)
env_request.option_settings += envvars
createops.make_new_env(env_request,
branch_default=branch_default,
process_app_version=process_app_version,
nohang=nohang,
interactive=interactive,
timeout=timeout,
source=source)
def get_keyname():
return commonops.get_default_keyname() or sshops.prompt_for_ec2_keyname(
message=prompts['platforminit.ssh'])
def do_command(self):
# save command line args
env_name = self.app.pargs.environment_name
modules = self.app.pargs.modules
if modules and len(modules) > 0:
self.compose_multiple_apps()
return
group = self.app.pargs.env_group_suffix
cname = self.app.pargs.cname
tier = self.app.pargs.tier
itype = self.app.pargs.instance_type
solution_string = self.app.pargs.platform or solution_stack_ops.get_default_solution_stack(
)
single = self.app.pargs.single
iprofile = self.app.pargs.instance_profile
service_role = self.app.pargs.service_role
label = self.app.pargs.version
branch_default = self.app.pargs.branch_default
key_name = self.app.pargs.keyname
sample = self.app.pargs.sample
nohang = self.app.pargs.nohang
tags = self.app.pargs.tags
envvars = self.app.pargs.envvars
scale = self.app.pargs.scale
timeout = self.app.pargs.timeout
cfg = self.app.pargs.cfg
elb_type = self.app.pargs.elb_type
source = self.app.pargs.source
process = self.app.pargs.process
region = self.app.pargs.region
interactive = False if env_name else True
provided_env_name = env_name
if sample and label:
raise InvalidOptionsError(strings['create.sampleandlabel'])
if single and scale:
raise InvalidOptionsError(strings['create.singleandsize'])
if single and elb_type:
raise InvalidOptionsError(strings['create.single_and_elb_type'])
if cname and tier and Tier.looks_like_worker_tier(tier):
raise InvalidOptionsError(strings['worker.cname'])
if cname and not elasticbeanstalk.is_cname_available(cname):
raise AlreadyExistsError(strings['cname.unavailable'].replace(
'{cname}', cname))
if tier and Tier.looks_like_worker_tier(tier):
if self.app.pargs.vpc_elbpublic or self.app.pargs.vpc_elbsubnets or self.app.pargs.vpc_publicip:
raise InvalidOptionsError(
strings['create.worker_and_incompatible_vpc_arguments'])
if (not tier or Tier.looks_like_webserver_tier(tier)) and single:
if self.app.pargs.vpc_elbpublic or self.app.pargs.vpc_elbsubnets:
raise InvalidOptionsError(
strings['create.single_and_elbpublic_or_elb_subnet'])
app_name = self.get_app_name()
tags = createops.get_and_validate_tags(tags)
envvars = get_and_validate_envars(envvars)
process_app_version = fileoperations.env_yaml_exists() or process
platform = get_platform(solution_string, iprofile)
template_name = get_template_name(app_name, cfg)
tier = get_environment_tier(tier)
env_name = provided_env_name or get_environment_name(app_name, group)
cname = cname or get_environment_cname(env_name, provided_env_name,
tier)
key_name = key_name or commonops.get_default_keyname()
elb_type = elb_type or get_elb_type_from_customer(
interactive, single, region, tier)
database = self.form_database_object()
vpc = self.form_vpc_object(tier, single)
# avoid prematurely timing out in the CLI when an environment is launched with a RDS DB
if not timeout and database:
timeout = 15
env_request = CreateEnvironmentRequest(app_name=app_name,
env_name=env_name,
group_name=group,
cname=cname,
template_name=template_name,
platform=platform,
tier=tier,
instance_type=itype,
version_label=label,
instance_profile=iprofile,
service_role=service_role,
single_instance=single,
key_name=key_name,
sample_application=sample,
tags=tags,
scale=scale,
database=database,
vpc=vpc,
elb_type=elb_type)
env_request.option_settings += envvars
createops.make_new_env(env_request,
branch_default=branch_default,
process_app_version=process_app_version,
nohang=nohang,
interactive=interactive,
timeout=timeout,
source=source)
