def command_stop(args):
microservice_handles = args.microservice_handle or [os.environ['MICROSERVICE_NAME']]
if not microservice_handles:
raise ValueError('No microservice name or container id supplied.')
armada_utils.notify_about_detected_dev_environment(microservice_handles[0])
services = {microservice_handle: armada_utils.get_matched_containers(microservice_handle)
for microservice_handle in microservice_handles}
for microservice_handle, instances in services.items():
instances_count = len(instances)
if instances_count > 1 and not args.all:
raise armada_utils.ArmadaCommandException(
'There are too many ({instances_count}) matching containers for service: {microservice_handle}. '
'Provide more specific container_id or microservice name or use -a/--all flag.'.format(**locals()))
were_errors = False
for microservice_handle, instances in services.items():
instances_count = len(instances)
if instances_count > 1:
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()))
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}
ship_name = instance['Address']
result = armada_api.post('stop', payload, ship_name=ship_name)
if result['status'] == 'error' and result['error'].startswith(
'armada API exception: ValueError - Cannot find ship:'):
payload['force'] = True
result = armada_api.post('stop', payload)
if result['status'] == 'ok':
print('Service {container_id} has been stopped.'.format(**locals()))
print()
else:
raise ArmadaCommandException('Stopping error: {0}'.format(result['error']))
except:
traceback.print_exc()
were_errors = True
if were_errors:
sys.exit(1)
def __create_service_remote(self, restart_parameters, target_ship):
result = armada_api.post('create',
restart_parameters,
ship_name=target_ship)
if result['status'] != "ok":
raise Exception(result['error'])
return result['long_container_id']
def __start_service_remote(self, container_id, target_ship):
start_payload = {'long_container_id': container_id}
start_result = armada_api.post('start',
start_payload,
ship_name=target_ship)
if start_result['status'] != "ok":
raise Exception(start_result['error'])
return start_result['endpoints']
def _recover_container(container_parameters):
get_logger().info('Recovering: {}...\n'.format(json.dumps(container_parameters)))
recovery_result = armada_api.post('run', container_parameters)
if recovery_result.get('status') == 'ok':
get_logger().info('Recovered container: {}'.format(json.dumps(recovery_result)))
return True
else:
get_logger().error('Could not recover container: {}'.format(json.dumps(recovery_result)))
return False
def _recover_container(container_parameters):
get_logger().info('Recovering: %s ...\n', json.dumps(container_parameters))
recovery_result = armada_api.post('run', container_parameters)
if recovery_result.get('status') == 'ok':
get_logger().info('Recovered container: %s', json.dumps(recovery_result))
return True
else:
get_logger().error('Could not recover container: %s', json.dumps(recovery_result))
return False
def command_recover(args):
if not args.saved_containers_path:
payload = {'recover_from_kv': True}
else:
with open(args.saved_containers_path) as saved_containers_file:
saved_containers = json.load(saved_containers_file)
payload = {
'recover_from_kv': False,
'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_run(args):
try:
image = ArmadaImageFactory(args.microservice_name, 'local', os.environ.get('MICROSERVICE_NAME'))
except InvalidImagePathException:
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(image.image_name, is_run_locally)
notify_about_detected_dev_environment(image.image_name)
is_dev_env = _is_dev_environment(args.hidden_armada_develop, dockyard_alias, image.image_name)
dockyard_alias, image = _find_dockyard_with_image(is_dev_env, args.hidden_is_restart, dockyard_alias,
image.image_name_with_tag)
_print_run_info(image, dockyard_alias, ship, args.rename)
microservice_name = args.rename or image.image_name
payload = RunPayload()
payload.update_image_path(image.image_path_with_tag)
payload.update_dockyard(dockyard_alias)
if os.environ.get('MICROSERVICE_NAME') == image.image_name:
payload.update_armada_develop_environment(image.image_name, microservice_name, args)
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(is_dev_env, args.env, image.image_name)
payload.update_resource_limits(args.cpu_shares, args.memory, args.memory_swap, args.cgroup_parent)
payload.update_configs(args.configs)
if is_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_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.')
armada_utils.notify_about_detected_dev_environment(microservice_handle)
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 six.iteritems(
result['endpoints']):
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 __start_service_remote(self, container_id, target_ship):
start_payload = {'long_container_id': container_id}
start_result = armada_api.post('start', start_payload, ship_name=target_ship)
if start_result['status'] != "ok":
raise Exception(start_result['error'])
return start_result['endpoints']
def __create_service_remote(self, restart_parameters, target_ship):
result = armada_api.post('create', restart_parameters, ship_name=target_ship)
if result['status'] != "ok":
raise Exception(result['error'])
return result['long_container_id']
def _recover_container(container_parameters):
print_err('Recovering: {}...\n'.format(json.dumps(container_parameters)))
recovery_result = armada_api.post('run', container_parameters)
print_err('Recovered container: {}'.format(json.dumps(recovery_result)))
def command_promote(args):
result = armada_api.post('promote')
armada_api.print_result_from_armada_api(result)
def command_join(args):
result = armada_api.post('join', {'host': args.address})
armada_api.print_result_from_armada_api(result)
def _recover_container(container_parameters):
print_err('Recovering: {}...\n'.format(json.dumps(container_parameters)))
recovery_result = armada_api.post('run', container_parameters)
print_err('Recovered container: {}'.format(json.dumps(recovery_result)))
def command_shutdown(args):
result = armada_api.post('shutdown', {'keep-joined': args.keep_joined})
armada_api.print_result_from_armada_api(result)
