Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def create(ctx, service_name, update_configs, dry_run, wait, asg, force_asg):
"""
Create a new ECS service named SERVICE_NAME.
"""
service = FriendlyServiceFactory.new(service_name, config=ctx.obj['CONFIG'])
print()
if service.exists():
click.secho('Service "{}" already exists!'.format(service.serviceName), fg='red')
sys.exit(1)
click.secho('Creating service with these attributes:', fg='white')
click.secho(' Service info:', fg="green")
print_service_info(service)
click.secho(' Task Definition:', fg='green')
print_task_definition(service.desired_task_definition)
if service.tasks:
click.secho('\nCreating these helper tasks:', fg='white')
for key, value in service.tasks.items():
click.secho(" {}".format(key), fg='green')
print_task_definition(value.desired_task_definition)
parameters = service.get_config()
if update_configs:
def ssh(ctx, service_name, verbose):
"""
If the service SERVICE_NAME has any running tasks, randomly choose one of
the container instances on which one of those tasks is running and ssh into
it.
If the service SERVICE_NAME has no running tasks, randomly choose one of
the container instances in the cluster on which the service is defined.
"""
service = FriendlyServiceFactory.new(service_name, config=ctx.obj['CONFIG'])
service.ssh(verbose=verbose)
def show_config(ctx, service_name, diff, to_env_file):
"""
If the service SERVICE_NAME has a "config:" section defined, print a list of
all parameters for the service and the values they currently have in AWS.
"""
service = FriendlyServiceFactory.new(service_name, config=ctx.obj['CONFIG'])
if not to_env_file:
if diff:
click.secho('Diff between local and AWS parameters for service "{}":'.format(service_name), fg='white')
else:
click.secho('Live values of parameters for service "{}":'.format(service_name), fg='white')
parameters = service.get_config()
if len(parameters) == 0:
click.secho(" No parameters found.")
else:
if diff:
print_sorted_parameters(parameters)
else:
for p in parameters:
if p.exists:
if p.should_exist:
if to_env_file:
- name: my_tunnel
service: my_service
host: config.MY_TUNNEL_DESTINATION_HOST
port: 3306
local_port: 8888
where config.MY_TUNNEL_DESTINATION_HOST is the value of MY_TUNNEL_DESTINATION_HOST
for this service in the AWS Parameter Store. The host value could also just
be a hostname.
"""
config = ctx.obj['CONFIG']
yml = config.get_section_item('tunnels', tunnel_name)
service_name = yml['service']
service = FriendlyServiceFactory.new(service_name, config=config)
host = _interpolate_tunnel_info(yml['host'], service)
port = int(_interpolate_tunnel_info(yml['port'], service))
local_port = int(_interpolate_tunnel_info(yml['local_port'], service))
interim_port = random.randrange(10000, 64000, 1)
service.tunnel(host, local_port, interim_port, port)
Update the our ECS service from what is in deployfish.yml. This means two things:
\b
* Update the task definition
* Update the scaling policies (if any)
These things can only be changed by deleting and recreating the service:
\b
* service name
* cluster name
* load balancer
If you want to update the desiredCount on the service, use "deploy scale".
"""
service = FriendlyServiceFactory.new(service_name, config=ctx.obj['CONFIG'])
print()
click.secho('Updating "{}" service:'.format(service.serviceName), fg="white")
click.secho(' Current task definition:', fg="yellow")
print_task_definition(service.active_task_definition)
click.secho('\n New task definition:', fg="green")
print_task_definition(service.desired_task_definition)
if service.tasks:
click.secho('\nUpdating "{}" helper tasks to:'.format(service.serviceName), fg='white')
for key, value in service.tasks.items():
click.secho(" {}".format(key), fg='green')
print_task_definition(value.desired_task_definition)
if service.scaling and service.scaling.needs_update():
click.secho('\nUpdating "{}" application scaling'.format(service.serviceName), fg='white')
if not dry_run:
service.update()
if wait:
def docker_exec(ctx, service_name, verbose):
"""
SSH to an EC2 instance in the cluster defined in the service named SERVICE_NAME, then
run docker exec on the appropriate container.
"""
service = FriendlyServiceFactory.new(service_name, config=ctx.obj['CONFIG'])
service.docker_exec(verbose=verbose)
def write_config(ctx, service_name, dry_run):
"""
If the service SERVICE_NAME has a "config:" section defined, write
all of the parameters for the service to AWS Parameter Store.
"""
service = FriendlyServiceFactory.new(service_name, config=ctx.obj['CONFIG'])
parameters = service.get_config()
if len(parameters) == 0:
click.secho('No parameters found for service "{}":'.format(service_name), fg='white')
else:
if not dry_run:
click.secho('Updating parameters for service "{}":'.format(service_name), fg='white')
else:
click.secho('Would update parameters for service "{}" like so:'.format(service_name), fg='white')
print_sorted_parameters(parameters)
if not dry_run:
service.write_config()
else:
click.echo('\nDRY RUN: not making changes in AWS')
def cluster_ssh(ctx, service_name):
"""
SSH to the specified EC2 system in the ECS cluster running SERVICE_NAME.
"""
service = FriendlyServiceFactory.new(service_name, config=ctx.obj['CONFIG'])
ips = service.get_host_ips()
for index, ip in enumerate(ips):
click.echo("Instance {}: {}".format(index + 1, ip))
instance = click.prompt("Which instance to ssh to?", type=int)
if instance > len(ips):
click.echo("That is not a valid instance.")
return
instance_ip = ips[instance - 1]
service.cluster_ssh(instance_ip)
def info(ctx, service_name):
"""
Show current AWS information about this service and its task definition
"""
service = FriendlyServiceFactory.new(service_name, config=ctx.obj['CONFIG'])
print()
if service.exists():
click.secho('"{}" service live info:'.format(service.serviceName), fg="white")
click.secho(' Service info:', fg="green")
print_service_info(service)
click.secho(' Task Definition:', fg="green")
print_task_definition(service.active_task_definition)
if service.tasks:
click.secho('\n"{}" helper tasks:'.format(service.serviceName), fg='white')
for key, value in service.tasks.items():
click.secho(" {}".format(key), fg='green')
print_task_definition(value.active_task_definition)
else:
click.secho('"{}" service is not in AWS yet.'.format(service.serviceName), fg="white")
def restart(ctx, service_name, hard):
"""
Restart all tasks in the service SERVICE_NAME by killing them off one by
one. Kill each task and wait for it to be replaced before killing the next
one off.
"""
service = FriendlyServiceFactory.new(service_name, config=ctx.obj['CONFIG'])
print()
click.secho('Restarting tasks in "{}" service in cluster "{}"'.format(
service.serviceName,
service.clusterName
))
service.restart(hard=hard)