def command_name(args):
if args.name:
result = armada_api.post('name', {'name': args.name})
armada_api.print_result_from_armada_api(result)
else:
result = armada_api.get('name')
print(result)
def command_restart(args):
if args.verbose:
global verbose
verbose = True
microservice_name = args.microservice_name or os.environ['MICROSERVICE_NAME']
if not microservice_name:
raise ValueError('No microservice name supplied.')
instances = armada_utils.get_matched_containers(microservice_name)
instances_count = len(instances)
if instances_count > 1:
if not args.all:
raise armada_utils.ArmadaCommandException(
'There are too many ({instances_count}) matching containers. '
'Provide more specific container_id or microservice name or use -a/--all flag.'.format(**locals()))
print('Restarting {instances_count} services {microservice_name}...'.format(**locals()))
else:
print('Restarting service {microservice_name}...'.format(**locals()))
were_errors = False
for i, instance in enumerate(instances):
try:
if instances_count > 1:
print('[{0}/{1}]'.format(i + 1, instances_count))
container_id = instance['ServiceID'].split(':')[0]
is_run_locally = armada_utils.is_local_container(container_id)
if is_run_locally:
result = json.loads(armada_api.get('env/{container_id}/ARMADA_RUN_COMMAND'.format(**locals())))
if result['status'] == 'ok':
stop_command = 'armada stop {container_id}'.format(**locals())
run_command = base64.b64decode(result['value'])
assert armada_utils.execute_local_command(stop_command, stream_output=True, retries=3)[0] == 0
assert armada_utils.execute_local_command(run_command, stream_output=True, retries=5)[0] == 0
if instances_count > 1:
print()
else:
raise armada_utils.ArmadaCommandException('ERROR: {0}'.format(result['error']))
else:
payload = {'container_id': container_id}
result = armada_api.post('restart', payload, ship_name=instance['Node'])
if result['status'] == 'ok':
new_container_id = result['container_id']
print('Service has been restarted and is running in container {new_container_id} '
'available at addresses:'.format(**locals()))
for service_address, docker_port in result['endpoints'].iteritems():
print(' {0} ({1})'.format(service_address, docker_port))
if instances_count > 1:
print()
else:
raise armada_utils.ArmadaCommandException('ERROR: {0}'.format(result['error']))
except:
traceback.print_exc()
were_errors = True
if were_errors:
sys.exit(1)
def command_recover(args):
with open(args.saved_containers_path) as saved_containers_file:
saved_containers = json.load(saved_containers_file)
payload = {'saved_containers': saved_containers}
result = armada_api.post('recover', payload)
if result['status'] != 'ok':
print(result['error'])
sys.exit(1)
else:
print('Containers have been restored.')
def command_restart(args):
microservice_handle = args.microservice_handle or os.environ['MICROSERVICE_NAME']
if not microservice_handle:
raise ValueError('No microservice name or container id supplied.')
instances = armada_utils.get_matched_containers(microservice_handle)
instances_count = len(instances)
if instances_count > 1:
if not args.all:
raise armada_utils.ArmadaCommandException(
'There are too many ({instances_count}) matching containers. '
'Provide more specific container_id or microservice name or use -a/--all flag.'.format(**locals()))
print('Restarting {instances_count} services {microservice_handle}...'.format(**locals()))
else:
microservice_name = instances[0]['ServiceName']
container_id = instances[0]["ServiceID"].split(':')[0]
print('Restarting service {microservice_name} ({container_id})...'.format(**locals()))
were_errors = False
for i, instance in enumerate(instances):
try:
if instances_count > 1:
print('[{0}/{1}]'.format(i + 1, instances_count))
container_id = instance['ServiceID'].split(':')[0]
payload = {'container_id': container_id}
if args.ship:
payload['target_ship'] = args.ship
payload['force'] = args.force
print('Checking if there is new image version. May take few minutes if download is needed...')
ship_name = instance['Address']
result = armada_api.post('restart', payload, ship_name=ship_name)
if result['status'] == 'ok':
new_container_id = result['container_id']
print('Service has been restarted and is running in container {new_container_id} '
'available at addresses:'.format(**locals()))
for service_address, docker_port in result['endpoints'].iteritems():
print(' {0} ({1})'.format(service_address, docker_port))
if instances_count > 1:
print()
else:
raise armada_utils.ArmadaCommandException(result['error'])
except armada_utils.ArmadaCommandException as e:
print("ArmadaCommandException: {0}".format(str(e)))
were_errors = True
except:
traceback.print_exc()
were_errors = True
if were_errors:
sys.exit(1)
def command_stop(args):
microservice_handle = args.microservice_handle or os.environ['MICROSERVICE_NAME']
if not microservice_handle:
raise ValueError('No microservice name or container id supplied.')
instances = armada_utils.get_matched_containers(microservice_handle)
instances_count = len(instances)
if instances_count > 1:
if not args.all:
raise armada_utils.ArmadaCommandException(
'There are too many ({instances_count}) matching containers. '
'Provide more specific container_id or microservice name or use -a/--all flag.'.format(**locals()))
print('Stopping {instances_count} services {microservice_handle}...'.format(**locals()))
else:
microservice_name = instances[0]['ServiceName']
container_id = instances[0]["ServiceID"].split(':')[0]
print('Stopping service {microservice_name} ({container_id})...'.format(**locals()))
were_errors = False
for i, instance in enumerate(instances):
try:
if instances_count > 1:
print('[{0}/{1}]'.format(i + 1, instances_count))
if 'kv_index' in instance:
kv.kv_remove('service/{}/{}'.format(instance['ServiceName'], instance['kv_index']))
print('Service {} has been removed.'.format(instance['ServiceName']))
else:
container_id = instance['ServiceID'].split(':')[0]
payload = {'container_id': container_id}
ship_name = instance['Address']
result = armada_api.post('stop', payload, ship_name=ship_name)
if result['status'] == 'ok':
print('Service {container_id} has been stopped.'.format(**locals()))
if instances_count > 1:
print()
else:
raise ArmadaCommandException('Stopping error: {0}'.format(result['error']))
except:
traceback.print_exc()
were_errors = True
if were_errors:
sys.exit(1)
def command_run(args):
if args.verbose:
global verbose
verbose = True
microservice_name = args.microservice_name
if not microservice_name:
raise ArmadaCommandException('ERROR: Please specify microservice_name argument'
' or set MICROSERVICE_NAME environment variable')
ship = args.ship
is_run_locally = ship is None
dockyard_alias = args.dockyard or dockyard.get_dockyard_alias(microservice_name, is_run_locally)
vagrant_dev = _is_vagrant_dev(args.hidden_vagrant_dev, dockyard_alias, microservice_name)
dockyard_alias, image = _find_dockyard_with_image(vagrant_dev, args.hidden_is_restart, dockyard_alias,
microservice_name)
_print_run_info(image, dockyard_alias, ship, args.rename)
payload = RunPayload()
payload.update_image_path(image.image_path)
payload.update_dockyard(dockyard_alias)
if vagrant_dev:
payload.update_vagrant(args.dynamic_ports, args.use_latest_image_code, microservice_name)
payload.update_environment(args.e)
payload.update_ports(args.publish)
payload.update_volumes(args.volumes)
payload.update_microservice_vars(args.rename, args.env, args.app_id)
payload.update_run_command(vagrant_dev)
payload.update_resource_limits(args.cpu_shares, args.memory, args.memory_swap, args.cgroup_parent)
payload.update_configs(args.configs)
if verbose:
print('payload: {0}'.format(payload))
warn_if_hit_crontab_environment_variable_length(payload.get('environment'))
print('Checking if there is new image version. May take few minutes if download is needed...')
result = armada_api.post('run', payload.data(), ship_name=ship)
_handle_result(result, args.hidden_is_restart)
def command_join(args):
result = armada_api.post('join', {'host': args.address})
armada_api.print_result_from_armada_api(result)
def command_promote(args):
result = armada_api.post('promote')
armada_api.print_result_from_armada_api(result)
def command_promote(args):
result = armada_api.post('promote')
armada_api.print_result_from_armada_api(result)
def command_restart(args):
microservice_handle = args.microservice_handle or os.environ['MICROSERVICE_NAME']
if not microservice_handle:
raise ValueError('No microservice name or container id supplied.')
instances = armada_utils.get_matched_containers(microservice_handle)
instances_count = len(instances)
if instances_count > 1:
if not args.all:
raise armada_utils.ArmadaCommandException(
'There are too many ({instances_count}) matching containers. '
'Provide more specific container_id or microservice name or use -a/--all flag.'.format(**locals()))
print('Restarting {instances_count} services {microservice_handle}...'.format(**locals()))
else:
microservice_name = instances[0]['ServiceName']
container_id = instances[0]["ServiceID"].split(':')[0]
print('Restarting service {microservice_name} ({container_id})...'.format(**locals()))
were_errors = False
for i, instance in enumerate(instances):
try:
if instances_count > 1:
print('[{0}/{1}]'.format(i + 1, instances_count))
if 'kv_index' in instance:
if not instance['params']:
raise armada_utils.ArmadaCommandException(
'There is no run command available for service {}.'.format(instance['ServiceName']))
run_command = instance['params']['run_command']
with suppress_version_check():
assert armada_utils.execute_local_command(run_command, stream_output=True, retries=5)[0] == 0
kv.kv_remove('service/{}/{}'.format(instance['ServiceName'], instance['kv_index']))
if instances_count > 1:
print()
continue
container_id = instance['ServiceID'].split(':')[0]
is_run_locally = armada_utils.is_local_container(container_id) and not args.ship
if is_run_locally:
result = json.loads(armada_api.get('env/{container_id}/ARMADA_RUN_COMMAND'.format(**locals())))
if result['status'] == 'ok':
stop_command = 'armada stop {container_id}'.format(**locals())
run_command = base64.b64decode(result['value'])
with suppress_version_check():
assert armada_utils.execute_local_command(stop_command, stream_output=True, retries=3)[0] == 0
assert armada_utils.execute_local_command(run_command, stream_output=True, retries=5)[0] == 0
if instances_count > 1:
print()
else:
raise armada_utils.ArmadaCommandException(result['error'])
else:
payload = {'container_id': container_id}
if args.ship:
payload['target_ship'] = args.ship
payload['force'] = args.force
print('Checking if there is new image version. May take few minutes if download is needed...')
ship_name = instance['Address']
result = armada_api.post('restart', payload, ship_name=ship_name)
if result['status'] == 'ok':
new_container_id = result['container_id']
print('Service has been restarted and is running in container {new_container_id} '
'available at addresses:'.format(**locals()))
for service_address, docker_port in result['endpoints'].iteritems():
print(' {0} ({1})'.format(service_address, docker_port))
if instances_count > 1:
print()
else:
raise armada_utils.ArmadaCommandException(result['error'])
except armada_utils.ArmadaCommandException as e:
print("ArmadaCommandException: {0}".format(str(e)))
were_errors = True
except:
traceback.print_exc()
were_errors = True
if were_errors:
sys.exit(1)
def command_promote(args):
result = armada_api.post('promote')
print(result)
def command_join(args):
result = armada_api.post('join', {'host': args.address})
armada_api.print_result_from_armada_api(result)
def command_shutdown(args):
result = armada_api.post('shutdown')
armada_api.print_result_from_armada_api(result)
def command_join(args):
result = armada_api.post('join', {'host': args.address})
print(result)
def command_restart(args):
if args.verbose:
global verbose
verbose = True
microservice_handle = args.microservice_handle or os.environ["MICROSERVICE_NAME"]
if not microservice_handle:
raise ValueError("No microservice name or container id supplied.")
instances = armada_utils.get_matched_containers(microservice_handle)
instances_count = len(instances)
if instances_count > 1:
if not args.all:
raise armada_utils.ArmadaCommandException(
"There are too many ({instances_count}) matching containers. "
"Provide more specific container_id or microservice name or use -a/--all flag.".format(**locals())
)
print("Restarting {instances_count} services {microservice_handle}...".format(**locals()))
else:
microservice_name = instances[0]["ServiceName"]
container_id = instances[0]["ServiceID"].split(":")[0]
print("Restarting service {microservice_name} ({container_id})...".format(**locals()))
were_errors = False
for i, instance in enumerate(instances):
try:
if instances_count > 1:
print("[{0}/{1}]".format(i + 1, instances_count))
container_id = instance["ServiceID"].split(":")[0]
is_run_locally = armada_utils.is_local_container(container_id)
if is_run_locally:
result = json.loads(armada_api.get("env/{container_id}/ARMADA_RUN_COMMAND".format(**locals())))
if result["status"] == "ok":
stop_command = "armada stop {container_id}".format(**locals())
run_command = base64.b64decode(result["value"])
assert armada_utils.execute_local_command(stop_command, stream_output=True, retries=3)[0] == 0
assert armada_utils.execute_local_command(run_command, stream_output=True, retries=5)[0] == 0
if instances_count > 1:
print()
else:
raise armada_utils.ArmadaCommandException("ERROR: {0}".format(result["error"]))
else:
payload = {"container_id": container_id}
result = armada_api.post("restart", payload, ship_name=instance["Node"])
if result["status"] == "ok":
new_container_id = result["container_id"]
print(
"Service has been restarted and is running in container {new_container_id} "
"available at addresses:".format(**locals())
)
for service_address, docker_port in result["endpoints"].iteritems():
print(" {0} ({1})".format(service_address, docker_port))
if instances_count > 1:
print()
else:
raise armada_utils.ArmadaCommandException("ERROR: {0}".format(result["error"]))
except:
traceback.print_exc()
were_errors = True
if were_errors:
sys.exit(1)
def command_shutdown(args):
result = armada_api.post('shutdown')
print(result)
def command_shutdown(args):
result = armada_api.post('shutdown')
armada_api.print_result_from_armada_api(result)
def command_run(args):
if args.verbose:
global verbose
verbose = True
microservice_name = args.microservice_name
if not microservice_name:
raise ArmadaCommandException('ERROR: Please specify microservice_name argument'
' or set MICROSERVICE_NAME environment variable')
ship = args.ship
is_run_locally = ship is None
dockyard_alias = args.dockyard or dockyard.get_dockyard_alias(microservice_name, is_run_locally)
vagrant_dev = False
if args.hidden_vagrant_dev or (are_we_in_vagrant() and not args.dockyard and dockyard_alias == 'local'):
print('INFO: Detected development environment for microservice {microservice_name}. '
'Using local docker registry.'.format(**locals()))
vagrant_dev = True
image = ArmadaImage(microservice_name, dockyard_alias)
if args.hidden_is_restart:
local_image = ArmadaImage(image.microservice_name, 'local')
image = select_latest_image(image, local_image)
if vagrant_dev and not image.exists():
print('Image {image} not found. Searching in default dockyard...'.format(**locals()))
dockyard_alias = get_default()
image = ArmadaImage(microservice_name, dockyard_alias)
if not image.exists():
if dockyard_alias == DOCKYARD_FALLBACK_ALIAS:
was_fallback_dockyard = True
else:
print('Image {image} not found. Searching in official Armada dockyard...'.format(**locals()))
dockyard_alias = DOCKYARD_FALLBACK_ALIAS
image = ArmadaImage(microservice_name, dockyard_alias)
was_fallback_dockyard = False
if was_fallback_dockyard or not image.exists():
print('Image {image} not found. Aborting.'.format(**locals()))
sys.exit(1)
dockyard_string = image.dockyard_address or ''
if dockyard_alias:
dockyard_string += ' (alias: {dockyard_alias})'.format(**locals())
ship_string = ' on remote ship: {ship}'.format(**locals()) if ship else ' locally'
if args.rename:
print('Running microservice {name} (renamed from {image.microservice_name}) from dockyard: {dockyard_string}{ship_string}...'.format(
name=args.rename, **locals()))
else:
print('Running microservice {image.microservice_name} from dockyard: {dockyard_string}{ship_string}...'.format(
**locals()))
payload = {'image_path': image.image_path, 'environment': {}, 'ports': {}, 'volumes': {}}
if dockyard_alias and dockyard_alias != 'local':
dockyard_info = dockyard.alias.get_alias(dockyard_alias)
if not dockyard_info:
raise ArmadaCommandException("Couldn't read configuration for dockyard alias {0}.".format(dockyard_alias))
payload['dockyard_user'] = dockyard_info.get('user')
payload['dockyard_password'] = dockyard_info.get('password')
if vagrant_dev:
if not args.dynamic_ports:
payload['ports']['4999'] = '80'
payload['ports']['2999'] = '22'
if not args.use_latest_image_code:
microservice_path = '/opt/{microservice_name}'.format(**locals())
payload['volumes'][microservice_path] = microservice_path
payload['environment']['ARMADA_VAGRANT_DEV'] = '1'
hermes_env, hermes_volumes = process_hermes(image.microservice_name, args.env, args.app_id,
sum(args.configs or [], []))
payload['environment'].update(hermes_env or {})
payload['volumes'].update(hermes_volumes or {})
# --- environment
for env_var in sum(args.e or [], []):
env_key, env_value = (env_var.strip('"').split('=', 1) + [''])[:2]
payload['environment'][env_key] = env_value
# --- ports
for port_mapping in sum(args.publish or [], []):
try:
port_host, port_container = map(int, (port_mapping.split(':', 1) + [None])[:2])
payload['ports'][str(port_host)] = str(port_container)
except (ValueError, TypeError):
print('Invalid port mapping: {0}'.format(port_mapping), file=sys.stderr)
return
# --- volumes
for volume_string in sum(args.volumes or [], []):
volume = volume_string.split(':')
if len(volume) == 1:
volume *= 2
payload['volumes'][volume[0]] = volume[1]
# --- name
payload['microservice_name'] = args.rename
# --- run_arguments
run_command = 'armada ' + ' '.join(sys.argv[1:])
if vagrant_dev and '--hidden_vagrant_dev' not in run_command:
run_command += ' --hidden_vagrant_dev'
if '--hidden_is_restart' not in run_command:
run_command += ' --hidden_is_restart'
payload['run_command'] = run_command
# ---
if verbose:
print('payload: {0}'.format(payload))
warn_if_hit_crontab_environment_variable_length(payload['environment'])
result = armada_api.post('run', payload, ship_name=ship)
if result['status'] == 'ok':
container_id = result['container_id']
if args.hidden_is_restart:
print('Service has been restarted and is running in container {container_id} '
'available at addresses:'.format(**locals()))
else:
print('Service is running in container {container_id} available at addresses:'.format(**locals()))
for service_address, docker_port in result['endpoints'].iteritems():
print(' {0} ({1})'.format(service_address, docker_port))
else:
print('ERROR: {0}'.format(result['error']))
sys.exit(1)
def command_name(args):
if args.name:
result = armada_api.post('name', {'name': args.name})
else:
result = armada_api.get('name')
print(result)
