示例#1
0
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)
示例#2
0
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)

            payload = {'container_id': container_id}
            print('Checking if there is new image version. May take few minutes if download is needed...')
            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)
示例#3
0
def prompt_select_instance(instances):
    print("There are multiple matching instances!")
    template = "\t{i}) {name} {address}:{port} {id} {local}"
    for i, instance in enumerate(instances):
        local = "(local)" if armada_utils.is_local_container(instance['ServiceID']) else ""
        print(template.format(i=i+1, name=instance['ServiceName'], address=instance['Address'], port=instance['ServicePort'],
                              id=instance['ServiceID'],  local=local))
    try:
        selection = int(raw_input("Please select one: "))
        if 0 >= selection > len(instances):
            raise ValueError
    except ValueError:
        raise armada_utils.ArmadaCommandException("Invalid choice!")
    except KeyboardInterrupt:
        raise armada_utils.ArmadaCommandException("Aborted.")
    selection -= 1
    return instances[selection]
示例#4
0
def prompt_select_instance(instances):
    print("There are multiple matching instances!")
    template = "\t{i}) {name} {address}:{port} {id} {local}"
    for i, instance in enumerate(instances):
        local = "(local)" if armada_utils.is_local_container(
            instance['ServiceID']) else ""
        print(
            template.format(i=i + 1,
                            name=instance['ServiceName'],
                            address=instance['Address'],
                            port=instance['ServicePort'],
                            id=instance['ServiceID'],
                            local=local))
    try:
        selection = int(raw_input("Please select one: "))
        if 0 >= selection > len(instances):
            raise ValueError
    except ValueError:
        raise armada_utils.ArmadaCommandException("Invalid choice!")
    except KeyboardInterrupt:
        raise armada_utils.ArmadaCommandException("Aborted.")
    selection -= 1
    return instances[selection]
示例#5
0
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)
示例#6
0
def command_ssh(args):
    microservice_name = args.microservice_name or os.environ[
        'MICROSERVICE_NAME']
    if not microservice_name:
        raise ValueError('No microservice name supplied.')

    instances = [
        i for i in armada_utils.get_matched_containers(microservice_name)
        if 'Status' not in i
    ]

    if args.local:
        instances = [
            i for i in instances
            if armada_utils.is_local_container(i['ServiceID'])
        ]

    instances_count = len(instances)

    if instances_count < 1:
        raise armada_utils.ArmadaCommandException(
            'There are no running containers with microservice: '
            '{microservice_name}'.format(**locals()))

    if instances_count > 1:
        if args.no_prompt:
            raise armada_utils.ArmadaCommandException(
                'There are too many ({instances_count}) matching containers. '
                'Provide more specific container_id or microservice name.'.
                format(**locals()))
        instance = prompt_select_instance(instances)
    else:
        instance = instances[0]

    if 'Status' in instance:
        raise armada_utils.ArmadaCommandException(
            'Cannot connect to not running service.')

    service_id = instance['ServiceID']
    container_id = service_id.split(':')[0]
    payload = {'container_id': container_id}

    is_local = armada_utils.is_local_container(container_id)

    if args.command:
        command = ' '.join(args.command)
    else:
        command = 'bash'
        args.tty = True
        args.interactive = True

    tty = '-t' if args.tty else ''
    interactive = '-i' if args.interactive else ''
    term = os.environ.get('TERM') or 'dummy'

    command = pipes.quote(command)
    docker_command = 'docker exec {interactive} {tty} {container_id} env TERM={term} ' \
                     'sh -c {command}'.format(**locals())

    if is_local:
        print("Connecting to {0}...".format(instance['ServiceName']))
        ssh_args = shlex.split(docker_command)
    else:
        ssh_host = instance['Address']
        docker_key_file = os.path.join(
            os.path.dirname(os.path.realpath(__file__)), '..',
            'keys/docker.key')
        remote_ssh_chunk = 'ssh -t {tty} -p 2201 -i {docker_key_file} -o StrictHostKeyChecking=no docker@{ssh_host}' \
            .format(**locals())
        ssh_args = shlex.split(remote_ssh_chunk)
        ssh_args.extend(('sudo', docker_command))
        print("Connecting to {0} on host {1}...".format(
            instance['ServiceName'], ssh_host))

    os.execvp(ssh_args[0], ssh_args)
示例#7
0
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)
示例#8
0
def command_ssh(args):
    microservice_name = args.microservice_name or os.environ['MICROSERVICE_NAME']
    if not microservice_name:
        raise ValueError('No microservice name supplied.')

    instances = [i for i in armada_utils.get_matched_containers(microservice_name) if 'kv_index' not in i]

    if args.local:
        instances = [i for i in instances if armada_utils.is_local_container(i['ServiceID'])]

    instances_count = len(instances)

    if instances_count < 1:
        raise armada_utils.ArmadaCommandException(
            'There are no running containers with microservice: '
            '{microservice_name}'.format(**locals()))

    if instances_count > 1:
        if args.no_prompt:
            raise armada_utils.ArmadaCommandException(
                'There are too many ({instances_count}) matching containers. '
                'Provide more specific container_id or microservice name.'.format(**locals()))
        instance = prompt_select_instance(instances)
    else:
        instance = instances[0]

    if 'Status' in instance:
        raise armada_utils.ArmadaCommandException('Cannot connect to not running service.')

    service_id = instance['ServiceID']
    container_id = service_id.split(':')[0]
    payload = {'container_id': container_id}

    is_local = armada_utils.is_local_container(container_id)

    if args.command:
        command = ' '.join(args.command)
    else:
        command = 'bash'
        args.tty = True
        args.interactive = True

    tty = '-t' if args.tty else ''
    interactive = '-i' if args.interactive else ''
    term = os.environ.get('TERM') or 'dummy'

    command = pipes.quote(command)
    docker_command = 'docker exec {interactive} {tty} {container_id} env TERM={term} ' \
                     'sh -c {command}'.format(**locals())

    if is_local:
        print("Connecting to {0}...".format(instance['ServiceName']))
        ssh_args = shlex.split(docker_command)
    else:
        ssh_host = instance['Address']
        docker_key_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'keys/docker.key')
        remote_ssh_chunk = 'ssh -t {tty} -p 2201 -i {docker_key_file} -o StrictHostKeyChecking=no docker@{ssh_host}' \
            .format(**locals())
        ssh_args = shlex.split(remote_ssh_chunk)
        ssh_args.extend(('sudo', docker_command))
        print("Connecting to {0} on host {1}...".format(instance['ServiceName'], ssh_host))

    os.execvp(ssh_args[0], ssh_args)