def get_instance(env, ssh_args=''):
beanstalk = boto.connect_beanstalk()
instances = beanstalk.describe_environment_resources(environment_name=env)\
.get('DescribeEnvironmentResourcesResponse')\
.get('DescribeEnvironmentResourcesResult')\
.get('EnvironmentResources')\
.get('Instances')
instance_ids = map(lambda i: i['Id'], instances)
ec2 = boto.connect_ec2()
reservations = ec2.get_all_instances(instance_ids=instance_ids)
i = 0
dns_names = {}
for r in reservations:
i += 1
if r.instances[0].vpc_id and r.instances[0].private_ip_address:
dns_names[i] = r.instances[0].private_ip_address
else:
dns_names[i] = r.instances[0].public_dns_name
while True:
instance = get_input_from_choices(
dns_names,
'instances (%s):' % env, 'instance'
)
_ssh(instance, ssh_args)
def describe_environments(params, coriolis):
client = boto.connect_beanstalk()
response = client.describe_environments()
environments = response["DescribeEnvironmentsResponse"][
"DescribeEnvironmentsResult"]["Environments"]
return str(json.dumps(
[environment["EnvironmentName"] for environment in environments]))
def describe_environments(params, coriolis):
client = boto.connect_beanstalk()
response = client.describe_environments()
environments = response["DescribeEnvironmentsResponse"][
"DescribeEnvironmentsResult"]["Environments"]
return str(
json.dumps(
[environment["EnvironmentName"] for environment in environments]))
def list_beanstalk(region, environment_name_args):
# args are named differently here as the use case is that we want attributes for exactly one environment
region_info = boto.regioninfo.RegionInfo(None, region, 'elasticbeanstalk.{}.amazonaws.com'.format(region))
eb_conn = boto.connect_beanstalk(
region=region_info,
)
environments = eb_conn.describe_environment_resources(**environment_name_args)
resources = environments['DescribeEnvironmentResourcesResponse']['DescribeEnvironmentResourcesResult']['EnvironmentResources']
return resources
def get_env():
beanstalk = boto.connect_beanstalk()
envs = beanstalk.describe_environments()\
.get('DescribeEnvironmentsResponse')\
.get('DescribeEnvironmentsResult')\
.get('Environments')
choices = {i+1: env['EnvironmentName'] for i, env in enumerate(envs)}
env = None
while not env:
env = get_input_from_choices(choices, 'environments:', 'environment')
return env
def environment_health(params, coriolis):
try:
client = boto.connect_beanstalk()
if len(params) == 0:
response = client.describe_environments()
else:
response = client.describe_environments(environment_names=params)
environments = response["DescribeEnvironmentsResponse"][
"DescribeEnvironmentsResult"]["Environments"]
return json.dumps([{
environment[
"EnvironmentName"]: environment["Health"]} for environment in environments])
except Exception as e:
return e.message
def environment_health(params, coriolis):
try:
client = boto.connect_beanstalk()
if len(params) == 0:
response = client.describe_environments()
else:
response = client.describe_environments(environment_names=params)
environments = response["DescribeEnvironmentsResponse"][
"DescribeEnvironmentsResult"]["Environments"]
return json.dumps([{
environment["EnvironmentName"]:
environment["Health"]
} for environment in environments])
except Exception as e:
return e.message
def main():
"""Set arguments, perform Ansible module setup, and call state implementation functions."""
argument_spec = ec2_argument_spec()
argument_spec.update(
dict(
application_name=dict(required=True),
application_version=dict(),
environment_name=dict(
default="".join(
random.choice(string.ascii_letters + string.digits) for __ in range(10)
)
),
cname=dict(
default="".join(
random.choice(string.ascii_letters + string.digits) for __ in range(10)
)
),
application_s3_bucket=dict(),
application_s3_key=dict(),
solution_stack=dict(),
environment_options=dict(type="list"),
state=dict(choices=["present", "absent", "restarted"], required=True),
redeploy=dict(default=False, type="bool")
)
)
module = AnsibleModule(
argument_spec=argument_spec,
mutually_exclusive=[[
"configuration_template",
"environment_options"
]]
)
if not HAS_BOTO:
module.fail_json(msg='boto required for this module')
region, ec2_url, aws_connect_kwargs = get_aws_connection_info(module)
aws_connect_kwargs.pop("validate_certs")
beanstalk = boto.connect_beanstalk(**aws_connect_kwargs)
state = module.params.get("state")
if state == "present":
(changed, environment) = make_present(module, beanstalk)
elif state == "absent":
(changed, environment) = make_absent(module, beanstalk)
elif state == "restarted":
(changed, environment) = make_restarted(module, beanstalk)
module.exit_json(changed=changed, environment=environment)
def environment_logs(params, coriolis):
if len(params) == 0:
return "Usage: !logs environment_name"
coriolis.msg(coriolis.current_chan, "Tailing logs..")
client = boto.connect_beanstalk()
tries = iter([x for x in xrange(2, 7)]) # 20 seconds
timeout = next(tries)
response = ""
def _get_logs():
try:
delay = next(tries)
client.request_environment_info(environment_name=params[0])
r = client.retrieve_environment_info(
environment_name=params[0])
environmentinfo = r[
"RetrieveEnvironmentInfoResponse"][
"RetrieveEnvironmentInfoResult"][
"EnvironmentInfo"]
if len(environmentinfo) > 0:
coriolis.msg(
coriolis.current_chan, str(environmentinfo[0]["Message"]))
else:
reactor.callLater(delay, _get_logs)
except StopIteration:
coriolis.msg(
coriolis.current_chan,
"Couldn't get logs after 20 seconds, you should try again.")
except boto.exception.BotoServerError as e:
if "must be ready" in str(e.message.lower()):
reactor.callLater(delay, _get_logs)
else:
coriolis.msg(coriolis.current_chan, "Something went awry, heres the output:")
coriolis.msg(coriolis.current_chan, str(e))
reactor.callLater(timeout, _get_logs)
return ""
def environment_logs(params, coriolis):
if len(params) == 0:
return "Usage: !logs environment_name"
coriolis.msg(coriolis.current_chan, "Tailing logs..")
client = boto.connect_beanstalk()
tries = iter([x for x in xrange(2, 7)]) # 20 seconds
timeout = next(tries)
response = ""
def _get_logs():
try:
delay = next(tries)
client.request_environment_info(environment_name=params[0])
r = client.retrieve_environment_info(environment_name=params[0])
environmentinfo = r["RetrieveEnvironmentInfoResponse"][
"RetrieveEnvironmentInfoResult"]["EnvironmentInfo"]
if len(environmentinfo) > 0:
coriolis.msg(coriolis.current_chan,
str(environmentinfo[0]["Message"]))
else:
reactor.callLater(delay, _get_logs)
except StopIteration:
coriolis.msg(
coriolis.current_chan,
"Couldn't get logs after 20 seconds, you should try again.")
except boto.exception.BotoServerError as e:
if "must be ready" in str(e.message.lower()):
reactor.callLater(delay, _get_logs)
else:
coriolis.msg(coriolis.current_chan,
"Something went awry, heres the output:")
coriolis.msg(coriolis.current_chan, str(e))
reactor.callLater(timeout, _get_logs)
return ""
def update_environment(environment, version):
beanstalk = boto.connect_beanstalk()
beanstalk.update_environment(environment_name=environment,
version_label=version)
def create_version(application, version):
beanstalk = boto.connect_beanstalk()
beanstalk.create_application_version(application, version,
s3_bucket=BUCKET_NAME,
s3_key=version)
def update_environment(environment, version):
beanstalk = boto.connect_beanstalk(ACCESS_KEY, SECRET_KEY)
beanstalk.update_environment(environment_name=environment, version_label=version)
