Exemplo n.º 1
0
def ls(deployment_id, include_system_workflows,
       sort_by=None, descending=False):
    logger = get_logger()
    rest_host = utils.get_rest_host()
    client = utils.get_rest_client(rest_host)
    try:
        if deployment_id:
            logger.info('Listing executions for deployment: \'{0}\' '
                        '[manager={1}]'.format(deployment_id, rest_host))
        else:
            logger.info(
                'Listing all executions: [manager={0}]'.format(
                    rest_host))
        executions = client.executions.list(
            deployment_id=deployment_id,
            include_system_workflows=include_system_workflows,
            sort=sort_by,
            is_descending=descending)
    except exceptions.CloudifyClientError as e:
        if e.status_code != 404:
            raise
        raise CloudifyCliError('Deployment {0} does not exist'.format(
            deployment_id))

    columns = ['id', 'workflow_id', 'deployment_id', 'status', 'created_at']
    pt = utils.table(columns, executions)
    utils.print_table('Executions:', pt)

    if any(execution.status in (execution.CANCELLING,
                                execution.FORCE_CANCELLING)
           for execution in executions):
        logger.info(_STATUS_CANCELING_MESSAGE)
Exemplo n.º 2
0
def ls(blueprint_id, sort_by=None, descending=False):
    logger = get_logger()
    rest_host = utils.get_rest_host()
    client = utils.get_rest_client(rest_host)
    if blueprint_id:
        logger.info("Listing deployments for blueprint: "
                    "'{0}'... [manager={1}]"
                    .format(blueprint_id, rest_host))
    else:
        logger.info('Listing all deployments...[manager={0}]'
                    .format(rest_host))
    deployments = client.deployments.list(
        sort=sort_by, is_descending=descending)
    if blueprint_id:
        deployments = filter(lambda deployment:
                             deployment['blueprint_id'] == blueprint_id,
                             deployments)

    pt = utils.table(
        ['id',
         'blueprint_id',
         'created_at',
         'updated_at'],
        deployments)
    utils.print_table('Deployments:', pt)
Exemplo n.º 3
0
def get(execution_id):
    logger = get_logger()
    rest_host = utils.get_rest_host()
    client = utils.get_rest_client(rest_host)

    try:
        logger.info('Getting execution: '
                    '\'{0}\' [manager={1}]'
                    .format(execution_id, rest_host))
        execution = client.executions.get(execution_id)
    except exceptions.CloudifyClientError as e:
        if e.status_code != 404:
            raise
        raise CloudifyCliError('Execution {0} not found'.format(execution_id))

    pt = utils.table(['id', 'workflow_id', 'status', 'deployment_id',
                      'created_at', 'error'],
                     [execution])
    pt.max_width = 50
    utils.print_table('Executions:', pt)

    # print execution parameters
    logger.info('Execution Parameters:')
    for param_name, param_value in utils.decode_dict(
            execution.parameters).iteritems():
        logger.info('\t{0}: \t{1}'.format(param_name, param_value))
    if execution.status in (execution.CANCELLING, execution.FORCE_CANCELLING):
        logger.info(_STATUS_CANCELING_MESSAGE)
    logger.info('')
Exemplo n.º 4
0
def get(blueprint_id):

    logger = get_logger()
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)

    logger.info('Getting blueprint: '
                '\'{0}\' [manager={1}]'.format(blueprint_id, management_ip))
    blueprint = client.blueprints.get(blueprint_id)

    deployments = client.deployments.list(_include=['id'],
                                          blueprint_id=blueprint_id)

    blueprint['#deployments'] = len(deployments)

    pt = utils.table(
        ['id', 'main_file_name', 'created_at', 'updated_at', '#deployments'],
        [blueprint])
    pt.max_width = 50
    utils.print_table('Blueprint:', pt)

    logger.info('Description:')
    logger.info('{0}\n'.format(blueprint['description'] if
                               blueprint['description'] is not None else ''))

    logger.info('Existing deployments:')
    logger.info('{0}\n'.format(json.dumps([d['id'] for d in deployments])))
Exemplo n.º 5
0
def get(node_instance_id):
    logger = get_logger()
    rest_host = utils.get_rest_host()
    client = utils.get_rest_client(rest_host)

    logger.info('Retrieving node instance with ID: \'{0}\' [manager={1}]'
                .format(node_instance_id, rest_host))
    try:
        node_instance = client.node_instances.get(node_instance_id)
    except CloudifyClientError as e:
        if e.status_code != 404:
            raise
        raise CloudifyCliError('Node instance {0} not found')

    columns = ['id', 'deployment_id', 'host_id', 'node_id', 'state']
    pt = utils.table(columns, [node_instance])
    pt.max_width = 50
    utils.print_table('Instance:', pt)

    # print node instance runtime properties
    logger.info('Instance runtime properties:')
    for prop_name, prop_value in utils.decode_dict(
            node_instance.runtime_properties).iteritems():
        logger.info('\t{0}: {1}'.format(prop_name, prop_value))
    logger.info('')
Exemplo n.º 6
0
def ls(sort_by=None, descending=False):
    logger = get_logger()
    rest_host = utils.get_rest_host()
    client = utils.get_rest_client(rest_host)
    logger.info('Getting blueprints list... [manager={0}]'
                .format(rest_host))

    def trim_description(blueprint):
        if blueprint['description'] is not None:
            if len(blueprint['description']) >= DESCRIPTION_LIMIT:
                blueprint['description'] = '{0}..'.format(
                    blueprint['description'][:DESCRIPTION_LIMIT - 2])
        else:
            blueprint['description'] = ''
        return blueprint

    blueprints = [trim_description(b)
                  for b in client.blueprints.list(
            sort=sort_by, is_descending=descending)]

    pt = utils.table(['id', 'description', 'main_file_name',
                      'created_at', 'updated_at'],
                     data=blueprints)

    utils.print_table('Available blueprints:', pt)
Exemplo n.º 7
0
def get(blueprint_id):

    logger = get_logger()
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)

    logger.info('Getting blueprint: '
                '\'{0}\' [manager={1}]'
                .format(blueprint_id, management_ip))
    blueprint = client.blueprints.get(blueprint_id)

    deployments = client.deployments.list(_include=['id'],
                                          blueprint_id=blueprint_id)

    blueprint['#deployments'] = len(deployments)

    pt = utils.table(['id', 'main_file_name', 'created_at', 'updated_at',
                      '#deployments'], [blueprint])
    pt.max_width = 50
    utils.print_table('Blueprint:', pt)

    logger.info('Description:')
    logger.info('{0}\n'.format(blueprint['description'] if
                               blueprint['description'] is not None else ''))

    logger.info('Existing deployments:')
    logger.info('{0}\n'.format(json.dumps([d['id'] for d in deployments])))
Exemplo n.º 8
0
def status():
    logger = get_logger()
    management_ip = utils.get_management_server_ip()
    logger.info('Getting management services status... [ip={0}]'
                .format(management_ip))

    client = utils.get_rest_client(management_ip)
    try:
        status_result = client.manager.get_status()
    except UserUnauthorizedError:
        logger.info("Can't query management server status: User is "
                    "unauthorized")
        return False
    except CloudifyClientError:
        logger.info('REST service at management server '
                    '{0} is not responding!'
                    .format(management_ip))
        return False

    services = []
    for service in status_result['services']:
        state = service['instances'][0]['state'] \
            if 'instances' in service and \
               len(service['instances']) > 0 else 'unknown'
        services.append({
            'service': service['display_name'].ljust(30),
            'status': state
        })
    pt = utils.table(['service', 'status'], data=services)
    utils.print_table('Services:', pt)
    return True
Exemplo n.º 9
0
def ls():
    logger = get_logger()
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)
    logger.info('Listing snapshots...')
    pt = utils.table(['id', 'created_at', 'status', 'error'],
                     data=client.snapshots.list())
    print_table('Snapshots:', pt)
Exemplo n.º 10
0
def ls():
    logger = get_logger()
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)
    logger.info(
        'Retrieving snapshots list... [manager={0}]'.format(management_ip))
    pt = utils.table(['id', 'created_at', 'status', 'error'],
                     data=client.snapshots.list())
    print_table('Snapshots:', pt)
Exemplo n.º 11
0
def ls():
    logger = get_logger()
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)

    logger.info(messages.PLUGINS_LIST.format(management_ip))
    plugins = client.plugins.list(_include=fields)

    pt = utils.table(fields, data=plugins)
    print_table('Plugins:', pt)
Exemplo n.º 12
0
def get(plugin_id):
    logger = get_logger()
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)

    logger.info(messages.PLUGINS_GET.format(plugin_id, management_ip))
    plugin = client.plugins.get(plugin_id, _include=fields)

    pt = utils.table(fields, data=[plugin])
    print_table('Plugin:', pt)
Exemplo n.º 13
0
def ls(sort_by=None, descending=False):
    logger = get_logger()
    rest_host = utils.get_rest_host()
    client = utils.get_rest_client(rest_host)
    logger.info('Listing all snapshots... [manager={0}]'
                .format(rest_host))
    pt = utils.table(['id', 'created_at', 'status', 'error'],
                     data=client.snapshots.list(
                         sort=sort_by, is_descending=descending))
    print_table('Snapshots:', pt)
Exemplo n.º 14
0
def get(plugin_id):
    logger = get_logger()
    rest_host = utils.get_rest_host()
    client = utils.get_rest_client(rest_host)

    logger.info("Retrieving plugin {0}... [manager={1}]".format(plugin_id, rest_host))
    plugin = client.plugins.get(plugin_id, _include=fields)

    pt = utils.table(fields, data=[plugin])
    print_table("Plugin:", pt)
Exemplo n.º 15
0
def ls(sort_by=None, descending=False):
    logger = get_logger()
    rest_host = utils.get_rest_host()
    client = utils.get_rest_client(rest_host)

    logger.info("Listing all plugins... [manager={0}]".format(rest_host))
    plugins = client.plugins.list(_include=fields, sort=sort_by, is_descending=descending)

    pt = utils.table(fields, data=plugins)
    print_table("Plugins:", pt)
Exemplo n.º 16
0
def ls():
    logger = get_logger()
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)

    logger.info('Listing all plugins...')
    plugins = client.plugins.list(_include=fields)

    pt = utils.table(fields, data=plugins)
    print_table('Plugins:', pt)
Exemplo n.º 17
0
def get(plugin_id):
    logger = get_logger()
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)

    logger.info('Retrieving plugin {0}...'.format(plugin_id))
    plugin = client.plugins.get(plugin_id, _include=fields)

    pt = utils.table(fields, data=[plugin])
    print_table('Plugin:', pt)
Exemplo n.º 18
0
def get(deployment_id, workflow_id):
    logger = get_logger()
    rest_host = utils.get_rest_host()
    client = utils.get_rest_client(rest_host)
    try:
        logger.info('Retrieving workflow '
                    '\'{0}\' of deployment \'{1}\' [manager={2}]'
                    .format(workflow_id, deployment_id, rest_host))
        deployment = client.deployments.get(deployment_id)
        workflow = next((wf for wf in deployment.workflows if
                         wf.name == workflow_id), None)
        if not workflow:
            raise CloudifyCliError(
                'Workflow {0} not found'.format(workflow_id, deployment_id))
    except CloudifyClientError as e:
        if e.status_code != 404:
            raise
        raise CloudifyCliError('Deployment {0} not found'.format(
            deployment_id))

    pt = utils.table(['blueprint_id', 'deployment_id',
                      'name', 'created_at'],
                     data=[workflow],
                     defaults={'blueprint_id': deployment.blueprint_id,
                               'deployment_id': deployment.id})

    utils.print_table('Workflows:', pt)

    # print workflow parameters
    mandatory_params = dict()
    optional_params = dict()
    for param_name, param in utils.decode_dict(
            workflow.parameters).iteritems():
        params_group = optional_params if 'default' in param else \
            mandatory_params
        params_group[param_name] = param

    logger.info('Workflow Parameters:')
    logger.info('\tMandatory Parameters:')
    for param_name, param in mandatory_params.iteritems():
        if 'description' in param:
            logger.info('\t\t{0}\t({1})'.format(param_name,
                                                param['description']))
        else:
            logger.info('\t\t{0}'.format(param_name))

    logger.info('\tOptional Parameters:')
    for param_name, param in optional_params.iteritems():
        if 'description' in param:
            logger.info('\t\t{0}: \t{1}\t({2})'.format(
                param_name, param['default'], param['description']))
        else:
            logger.info('\t\t{0}: \t{1}'.format(param_name,
                                                param['default']))
    logger.info('')
Exemplo n.º 19
0
def ls():
    logger = get_logger()
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)
    logger.info(
        'Getting blueprints list... [manager={0}]'.format(management_ip))

    pt = utils.table(['id', 'created_at', 'updated_at'],
                     data=client.blueprints.list())

    print_table('Blueprints:', pt)
Exemplo n.º 20
0
def ls():
    logger = get_logger()
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)
    logger.info('Getting blueprints list... [manager={0}]'
                .format(management_ip))

    pt = utils.table(['id', 'created_at', 'updated_at'],
                     data=client.blueprints.list())

    print_table('Blueprints:', pt)
Exemplo n.º 21
0
def ls(deployment_id):
    logger = get_logger()
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)

    logger.info('Listing workflows for deployment {0}...'.format(
        deployment_id))

    deployment = client.deployments.get(deployment_id)
    workflows = deployment.workflows

    pt = utils.table(['blueprint_id', 'deployment_id',
                      'name', 'created_at'],
                     data=workflows,
                     defaults={'blueprint_id': deployment.blueprint_id,
                               'deployment_id': deployment.id})
    utils.print_table('Workflows:', pt)
Exemplo n.º 22
0
def inputs(blueprint_id):
    logger = get_logger()
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)
    logger.info('Retrieving inputs for blueprint {0}...'.format(blueprint_id))

    blueprint = client.blueprints.get(blueprint_id)
    inputs = blueprint['plan']['inputs']
    data = [{'name': name,
             'type': input.get('type', '-'),
             'default': input.get('default', '-'),
             'description': input.get('description', '-')}
            for name, input in inputs.iteritems()]

    pt = utils.table(['name', 'type', 'default', 'description'],
                     data=data)

    utils.print_table('Inputs:', pt)
Exemplo n.º 23
0
def inputs(blueprint_id):
    logger = get_logger()
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)
    logger.info('Getting inputs for blueprint {0}... [manager={1}]'.format(
        blueprint_id, management_ip))

    blueprint = client.blueprints.get(blueprint_id)
    inputs = blueprint['plan']['inputs']
    data = [{
        'name': name,
        'type': input.get('type', '-'),
        'default': input.get('default', '-'),
        'description': input.get('description', '-')
    } for name, input in inputs.iteritems()]

    pt = utils.table(['name', 'type', 'default', 'description'], data=data)

    print_table('Inputs:', pt)
Exemplo n.º 24
0
def ls(deployment_id):
    logger = get_logger()
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)

    logger.info('Getting workflows list for deployment: '
                '\'{0}\'... [manager={1}]'.format(deployment_id,
                                                  management_ip))

    deployment = client.deployments.get(deployment_id)
    workflows = deployment.workflows

    pt = utils.table(['blueprint_id', 'deployment_id', 'name', 'created_at'],
                     data=workflows,
                     defaults={
                         'blueprint_id': deployment.blueprint_id,
                         'deployment_id': deployment.id
                     })
    utils.print_table('Workflows:', pt)
Exemplo n.º 25
0
def get(deployment_id, node_id):
    logger = get_logger()
    rest_host = utils.get_rest_host()
    client = utils.get_rest_client(rest_host)

    logger.info('Retrieving node: \'{0}\' for deployment with ID \'{1}\' '
                '[manager={2}]'.format(node_id, deployment_id, rest_host))
    try:
        node = client.nodes.get(deployment_id, node_id)
    except CloudifyClientError as e:
        if e.status_code != 404:
            raise
        raise CloudifyCliError('Node {0} was not found'.format(node_id))

    logger.debug('Getting node instances for node with ID \'{0}\''
                 .format(node_id))
    try:
        instances = client.node_instances.list(deployment_id, node_id)
    except CloudifyClientError as e:
        if e.status_code != 404:
            raise

    # print node parameters
    columns = ['id', 'deployment_id', 'blueprint_id', 'host_id', 'type',
               'number_of_instances', 'planned_number_of_instances']
    pt = utils.table(columns, [node])
    pt.max_width = 50
    utils.print_table('Node:', pt)

    # print node properties
    logger.info('Node properties:')
    for property_name, property_value in utils.decode_dict(
            node.properties).iteritems():
        logger.info('\t{0}: {1}'.format(property_name, property_value))
    logger.info('')

    # print node instances IDs
    logger.info('Node instance IDs:')
    if instances:
        for instance in instances:
            logger.info('\t{0}'.format(instance['id']))
    else:
        logger.info('\tNo node instances')
Exemplo n.º 26
0
def ls(deployment_id):
    logger = get_logger()
    rest_host = utils.get_rest_host()
    client = utils.get_rest_client(rest_host)

    logger.info('Listing workflows for deployment: '
                '\'{0}\'... [manager={1}]'
                .format(deployment_id, rest_host))

    deployment = client.deployments.get(deployment_id)
    workflows = deployment.workflows

    workflows = sorted(workflows, key=lambda w: w.name)

    pt = utils.table(['blueprint_id', 'deployment_id',
                      'name', 'created_at'],
                     data=workflows,
                     defaults={'blueprint_id': deployment.blueprint_id,
                               'deployment_id': deployment.id})
    utils.print_table('Workflows:', pt)
Exemplo n.º 27
0
def ls(blueprint_id):
    logger = get_logger()
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)
    if blueprint_id:
        logger.info("Getting deployments list for blueprint: "
                    "'{0}'... [manager={1}]".format(blueprint_id,
                                                    management_ip))
    else:
        logger.info(
            'Getting deployments list...[manager={0}]'.format(management_ip))
    deployments = client.deployments.list()
    if blueprint_id:
        deployments = filter(
            lambda deployment: deployment['blueprint_id'] == blueprint_id,
            deployments)

    pt = utils.table(['id', 'blueprint_id', 'created_at', 'updated_at'],
                     deployments)
    utils.print_table('Deployments:', pt)
Exemplo n.º 28
0
def ls(deployment_id):
    logger = get_logger()
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)
    try:
        if deployment_id:
            logger.info('Listing nodes for deployment {0}...'.format(
                deployment_id))
        else:
            logger.info('Listing all nodes...')
        nodes = client.nodes.list(deployment_id=deployment_id)
    except CloudifyClientError as e:
        if not e.status_code != 404:
            raise
        raise CloudifyCliError('Deployment {0} does not exist'.format(
            deployment_id))

    columns = ['id', 'deployment_id', 'blueprint_id', 'host_id', 'type',
               'number_of_instances', 'planned_number_of_instances']
    pt = utils.table(columns, nodes)
    utils.print_table('Nodes:', pt)
Exemplo n.º 29
0
def ls():
    logger = get_logger()
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)
    logger.info('Listing all blueprints...')

    def trim_description(blueprint):
        if blueprint['description'] is not None:
            if len(blueprint['description']) >= DESCRIPTION_LIMIT:
                blueprint['description'] = '{0}..'.format(
                    blueprint['description'][:DESCRIPTION_LIMIT - 2])
        else:
            blueprint['description'] = ''
        return blueprint

    blueprints = [trim_description(b) for b in client.blueprints.list()]

    pt = utils.table(['id', 'description', 'main_file_name',
                      'created_at', 'updated_at'],
                     data=blueprints)

    utils.print_table('Available blueprints:', pt)
Exemplo n.º 30
0
def _print_maintenance_mode_status(client):
    logger = get_logger()

    status_response = client.maintenance_mode.status()

    logger.info('\nMaintenance Mode Status:')
    for param_name, param_value in utils.decode_dict(
            status_response).iteritems():
        if param_value and param_name != 'remaining_executions':
            logger.info('\t{0}:\t{1}'.format(
                    param_name.title().replace("_", " "),
                    param_value))
    logger.info('')

    remaining_executions = status_response.remaining_executions
    if remaining_executions:
        if len(remaining_executions) == 1:
            logger.info(
                    'Cloudify Manager currently has one '
                    'running or pending execution. Waiting for it'
                    ' to finish before activating.')
        else:
            logger.info(
                    'Cloudify Manager currently has {0} '
                    'running or pending executions. Waiting for all '
                    'executions to finish before activating.'.format(
                            len(remaining_executions)))

        if get_global_verbosity() != NO_VERBOSE:
            pt = utils.table(['id', 'deployment_id', 'workflow_id', 'status'],
                             remaining_executions)
            pt.max_width = 50
            utils.print_table('Remaining executions:', pt)

    if status_response.status == MAINTENANCE_MODE_ACTIVE:
        logger.info('INFO - Cloudify Manager is currently under maintenance. '
                    'Most requests will be blocked '
                    'until maintenance mode is deactivated.\n')
Exemplo n.º 31
0
def ls():
    logger = get_logger()
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)
    logger.info(
        'Getting blueprints list... [manager={0}]'.format(management_ip))

    def trim_description(blueprint):
        if blueprint['description'] is not None:
            if len(blueprint['description']) >= DESCRIPTION_LIMIT:
                blueprint['description'] = '{0}..'.format(
                    blueprint['description'][:DESCRIPTION_LIMIT - 2])
        else:
            blueprint['description'] = ''
        return blueprint

    blueprints = [trim_description(b) for b in client.blueprints.list()]

    pt = utils.table(
        ['id', 'description', 'main_file_name', 'created_at', 'updated_at'],
        data=blueprints)

    print_table('Blueprints:', pt)
Exemplo n.º 32
0
def status():
    logger = get_logger()
    rest_host = utils.get_rest_host()
    logger.info('Retrieving management services status... [ip={0}]'
                .format(rest_host))

    client = utils.get_rest_client(rest_host)
    try:
        status_result = client.manager.get_status()
        maintenance_response = client.maintenance_mode.status()
    except UserUnauthorizedError:
        logger.info(
            "Failed to query manager services status: User is unauthorized")
        return False
    except CloudifyClientError as e:
        logger.info('REST service at management server '
                    '{0} is not responding! error: {1}'
                    .format(rest_host, e))
        return False

    services = []
    for service in status_result['services']:
        state = service['instances'][0]['state'] \
            if 'instances' in service and \
               len(service['instances']) > 0 else 'unknown'
        services.append({
            'service': service['display_name'].ljust(30),
            'status': state
        })
    pt = utils.table(['service', 'status'], data=services)
    utils.print_table('Services:', pt)

    maintenance_status = maintenance_response.status
    if maintenance_status != 'deactivated':
        logger.info('Maintenance mode is {0}.\n'.format(
            maintenance_response.status))
    return True
Exemplo n.º 33
0
def ls(deployment_id, sort_by=None, descending=False):
    logger = get_logger()
    rest_host = utils.get_rest_host()
    client = utils.get_rest_client(rest_host)
    try:
        if deployment_id:
            logger.info('Listing nodes for deployment: \'{0}\' '
                        '[manager={1}]'.format(deployment_id, rest_host))
        else:
            logger.info(
                'Listing all nodes: [manager={0}]'.format(
                    rest_host))
        nodes = client.nodes.list(deployment_id=deployment_id,
                                  sort=sort_by, is_descending=descending)
    except CloudifyClientError as e:
        if not e.status_code != 404:
            raise
        raise CloudifyCliError('Deployment {0} does not exist'.format(
            deployment_id))

    columns = ['id', 'deployment_id', 'blueprint_id', 'host_id', 'type',
               'number_of_instances', 'planned_number_of_instances']
    pt = utils.table(columns, nodes)
    utils.print_table('Nodes:', pt)
Exemplo n.º 34
0
def ls(blueprint_id):
    logger = get_logger()
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)
    if blueprint_id:
        logger.info("Getting deployments list for blueprint: "
                    "'{0}'... [manager={1}]"
                    .format(blueprint_id, management_ip))
    else:
        logger.info('Getting deployments list...[manager={0}]'
                    .format(management_ip))
    deployments = client.deployments.list()
    if blueprint_id:
        deployments = filter(lambda deployment:
                             deployment['blueprint_id'] == blueprint_id,
                             deployments)

    pt = utils.table(
        ['id',
         'blueprint_id',
         'created_at',
         'updated_at'],
        deployments)
    utils.print_table('Deployments:', pt)
Exemplo n.º 35
0
    client = utils.get_rest_client(management_ip)

    try:
        logger.info('Getting execution: '
                    '\'{0}\' [manager={1}]'.format(execution_id,
                                                   management_ip))
        execution = client.executions.get(execution_id)
    except exceptions.CloudifyClientError, e:
        if e.status_code != 404:
            raise
        msg = ("Execution '{0}' not found on management server".format(
            execution_id))
        raise CloudifyCliError(msg)

    pt = utils.table([
        'id', 'workflow_id', 'status', 'deployment_id', 'created_at', 'error'
    ], [execution])
    pt.max_width = 50
    utils.print_table('Executions:', pt)

    # print execution parameters
    logger.info('Execution Parameters:')
    for param_name, param_value in utils.decode_dict(
            execution.parameters).iteritems():
        logger.info('\t{0}: \t{1}'.format(param_name, param_value))
    logger.info('')


def ls(deployment_id):
    logger = get_logger()
    management_ip = utils.get_management_server_ip()
Exemplo n.º 36
0
        msg = ("Node with ID '{0}' was not found on the management server"
               .format(node_id))
        raise CloudifyCliError(msg)

    logger.debug('Getting node instances for node with ID \'{0}\''
                 .format(node_id))
    try:
        instances = client.node_instances.list(deployment_id, node_id)
    except CloudifyClientError, e:
        if e.status_code != 404:
            raise

    # print node parameters
    columns = ['id', 'deployment_id', 'blueprint_id', 'host_id', 'type',
               'number_of_instances', 'planned_number_of_instances']
    pt = utils.table(columns, [node])
    pt.max_width = 50
    utils.print_table('Node:', pt)

    # print node properties
    logger.info('Node properties:')
    for property_name, property_value in utils.decode_dict(
            node.properties).iteritems():
        logger.info('\t{0}: {1}'.format(property_name, property_value))
    logger.info('')

    # print node instances IDs
    logger.info('Node instance IDs:')
    if instances:
        for instance in instances:
            logger.info('\t{0}'.format(instance['id']))
Exemplo n.º 37
0
        raise CloudifyCliError(msg)

    logger.debug(
        'Getting node instances for node with ID \'{0}\''.format(node_id))
    try:
        instances = client.node_instances.list(deployment_id, node_id)
    except CloudifyClientError, e:
        if e.status_code != 404:
            raise

    # print node parameters
    columns = [
        'id', 'deployment_id', 'blueprint_id', 'host_id', 'type',
        'number_of_instances', 'planned_number_of_instances'
    ]
    pt = utils.table(columns, [node])
    pt.max_width = 50
    utils.print_table('Node:', pt)

    # print node properties
    logger.info('Node properties:')
    for property_name, property_value in utils.decode_dict(
            node.properties).iteritems():
        logger.info('\t{0}: {1}'.format(property_name, property_value))
    logger.info('')

    # print node instances IDs
    logger.info('Node instance IDs:')
    if instances:
        for instance in instances:
            logger.info('\t{0}'.format(instance['id']))
Exemplo n.º 38
0
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)

    logger.info('Getting node instance with ID: \'{0}\' [manager={1}]'
                .format(node_instance_id, management_ip))
    try:
        node_instance = client.node_instances.get(node_instance_id)
    except CloudifyClientError, e:
        if e.status_code != 404:
            raise
        msg = ("Node instance with ID '{0}' was not found on the management "
               "server".format(node_instance_id))
        raise CloudifyCliError(msg)

    columns = ['id', 'deployment_id', 'host_id', 'node_id', 'state']
    pt = utils.table(columns, [node_instance])
    pt.max_width = 50
    utils.print_table('Instance:', pt)

    # print node instance runtime properties
    logger.info('Instance runtime properties:')
    for prop_name, prop_value in utils.decode_dict(
            node_instance.runtime_properties).iteritems():
        logger.info('\t{0}: {1}'.format(prop_name, prop_value))
    logger.info('')


def ls(deployment_id, node_name=None):
    logger = get_logger()
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)
Exemplo n.º 39
0
        workflow = next((wf for wf in deployment.workflows if
                         wf.name == workflow_id), None)
        if not workflow:
            msg = ("Workflow '{0}' not found on management server for "
                   "deployment {1}".format(workflow_id, deployment_id))
            raise CloudifyCliError(msg)
    except CloudifyClientError, e:
        if e.status_code != 404:
            raise
        msg = ("Deployment '{0}' not found on management server"
               .format(deployment_id))
        raise CloudifyCliError(msg)

    pt = utils.table(['blueprint_id', 'deployment_id',
                      'name', 'created_at'],
                     data=[workflow],
                     defaults={'blueprint_id': deployment.blueprint_id,
                               'deployment_id': deployment.id})

    utils.print_table('Workflows:', pt)

    # print workflow parameters
    mandatory_params = dict()
    optional_params = dict()
    for param_name, param in utils.decode_dict(
            workflow.parameters).iteritems():
        params_group = optional_params if 'default' in param else \
            mandatory_params
        params_group[param_name] = param

    logger.info('Workflow Parameters:')
Exemplo n.º 40
0
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)

    logger.info('Getting node instance with ID: \'{0}\' [manager={1}]'.format(
        node_instance_id, management_ip))
    try:
        node_instance = client.node_instances.get(node_instance_id)
    except CloudifyClientError, e:
        if e.status_code != 404:
            raise
        msg = ("Node instance with ID '{0}' was not found on the management "
               "server".format(node_instance_id))
        raise CloudifyCliError(msg)

    columns = ['id', 'deployment_id', 'host_id', 'node_id', 'state']
    pt = utils.table(columns, [node_instance])
    pt.max_width = 50
    utils.print_table('Instance:', pt)

    # print node instance runtime properties
    logger.info('Instance runtime properties:')
    for prop_name, prop_value in utils.decode_dict(
            node_instance.runtime_properties).iteritems():
        logger.info('\t{0}: {1}'.format(prop_name, prop_value))
    logger.info('')


def ls(deployment_id, node_name=None):
    logger = get_logger()
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)
Exemplo n.º 41
0
            (wf for wf in deployment.workflows if wf.name == workflow_id),
            None)
        if not workflow:
            msg = ("Workflow '{0}' not found on management server for "
                   "deployment {1}".format(workflow_id, deployment_id))
            raise CloudifyCliError(msg)
    except CloudifyClientError, e:
        if e.status_code != 404:
            raise
        msg = ("Deployment '{0}' not found on management server".format(
            deployment_id))
        raise CloudifyCliError(msg)

    pt = utils.table(['blueprint_id', 'deployment_id', 'name', 'created_at'],
                     data=[workflow],
                     defaults={
                         'blueprint_id': deployment.blueprint_id,
                         'deployment_id': deployment.id
                     })

    utils.print_table('Workflows:', pt)

    # print workflow parameters
    mandatory_params = dict()
    optional_params = dict()
    for param_name, param in utils.decode_dict(
            workflow.parameters).iteritems():
        params_group = optional_params if 'default' in param else \
            mandatory_params
        params_group[param_name] = param

    logger.info('Workflow Parameters:')
Exemplo n.º 42
0
    client = utils.get_rest_client(management_ip)

    try:
        logger.info('Getting execution: '
                    '\'{0}\' [manager={1}]'
                    .format(execution_id, management_ip))
        execution = client.executions.get(execution_id)
    except exceptions.CloudifyClientError, e:
        if e.status_code != 404:
            raise
        msg = ("Execution '{0}' not found on management server"
               .format(execution_id))
        raise CloudifyCliError(msg)

    pt = utils.table(['id', 'workflow_id', 'status',
                      'created_at', 'error'],
                     [execution])
    utils.print_table('Executions:', pt)

    # print execution parameters
    logger.info('Execution Parameters:')
    for param_name, param_value in utils.decode_dict(
            execution.parameters).iteritems():
        logger.info('\t{0}: \t{1}'.format(param_name, param_value))
    logger.info('')


def ls(deployment_id):
    logger = get_logger()
    management_ip = utils.get_management_server_ip()
    client = utils.get_rest_client(management_ip)