240 lines
8.4 KiB
Python
240 lines
8.4 KiB
Python
# Copyright 2017 AT&T Intellectual Property. All other rights reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
"""Reusable parts for outputting Shipyard results in CLI format"""
|
|
|
|
from shipyard_client.cli import format_utils
|
|
|
|
|
|
def gen_action_steps(step_list, action_id):
|
|
"""Generate a table from the list of steps.
|
|
|
|
Assumes that the input list contains dictionaries with 'id', 'index', and
|
|
'state' fields.
|
|
Returns a string representation of the table.
|
|
"""
|
|
# Generate the steps table.
|
|
steps = format_utils.table_factory(field_names=['Steps', 'Index', 'State'])
|
|
if step_list:
|
|
for step in step_list:
|
|
steps.add_row([
|
|
'step/{}/{}'.format(action_id, step.get('id')),
|
|
step.get('index'),
|
|
step.get('state')
|
|
])
|
|
else:
|
|
steps.add_row(['None', '', ''])
|
|
|
|
return format_utils.table_get_string(steps)
|
|
|
|
|
|
def gen_action_commands(command_list):
|
|
"""Generate a table from the list of commands
|
|
|
|
Assumes command_list is a list of dictionaries with 'command', 'user', and
|
|
'datetime'.
|
|
"""
|
|
cmds = format_utils.table_factory(
|
|
field_names=['Commands', 'User', 'Datetime'])
|
|
if command_list:
|
|
for cmd in command_list:
|
|
cmds.add_row(
|
|
[cmd.get('command'),
|
|
cmd.get('user'),
|
|
cmd.get('datetime')])
|
|
else:
|
|
cmds.add_row(['None', '', ''])
|
|
|
|
return format_utils.table_get_string(cmds)
|
|
|
|
|
|
def gen_action_validations(validation_list):
|
|
"""Generates a CLI formatted listing of validations
|
|
|
|
Assumes validation_list is a list of dictionaries with 'validation_name',
|
|
'action_id', 'id', and 'details'.
|
|
"""
|
|
if validation_list:
|
|
validations = []
|
|
for val in validation_list:
|
|
validations.append('{} : validation/{}/{}\n'.format(
|
|
val.get('validation_name'), val.get('action_id'), val.get(
|
|
'id')))
|
|
validations.append(val.get('details'))
|
|
validations.append('\n\n')
|
|
return 'Validations: {}'.format('\n'.join(validations))
|
|
else:
|
|
return 'Validations: {}'.format('None')
|
|
|
|
|
|
def gen_action_details(action_dict):
|
|
"""Generates the detailed information for an action
|
|
|
|
Assumes action_dict is a dictionary with 'name', 'id', 'action_lifecycle',
|
|
'parameters', 'datetime', 'dag_status', 'context_marker', and 'user'
|
|
"""
|
|
details = format_utils.table_factory()
|
|
details.add_row(['Name:', action_dict.get('name')])
|
|
details.add_row(['Action:', 'action/{}'.format(action_dict.get('id'))])
|
|
details.add_row(['Lifecycle:', action_dict.get('action_lifecycle')])
|
|
details.add_row(['Parameters:', str(action_dict.get('parameters'))])
|
|
details.add_row(['Datetime:', action_dict.get('datetime')])
|
|
details.add_row(['Dag Status:', action_dict.get('dag_status')])
|
|
details.add_row(['Context Marker:', action_dict.get('context_marker')])
|
|
details.add_row(['User:', action_dict.get('user')])
|
|
return format_utils.table_get_string(details)
|
|
|
|
|
|
def gen_action_step_details(step_dict, action_id):
|
|
"""Generates the detailed information for an action step
|
|
|
|
Assumes action_dict is a dictionary with 'index', 'state', 'start_date',
|
|
'end_date', 'duration', 'try_number', and 'operator'
|
|
"""
|
|
details = format_utils.table_factory()
|
|
details.add_row(['Name:', step_dict.get('task_id')])
|
|
details.add_row(
|
|
['Task ID:', 'step/{}/{}'.format(action_id, step_dict.get('task_id'))])
|
|
details.add_row(['Index:', step_dict.get('index')])
|
|
details.add_row(['State:', step_dict.get('state')])
|
|
details.add_row(['Start Date:', step_dict.get('start_date')])
|
|
details.add_row(['End Date:', step_dict.get('end_date')])
|
|
details.add_row(['Duration:', step_dict.get('duration')])
|
|
details.add_row(['Try Number:', step_dict.get('try_number')])
|
|
details.add_row(['Operator:', step_dict.get('operator')])
|
|
return format_utils.table_get_string(details)
|
|
|
|
|
|
def gen_action_table(action_list):
|
|
"""Generates a list of actions
|
|
|
|
Assumes action_list is a list of dictionaries with 'name', 'id', and
|
|
'action_lifecycle'
|
|
"""
|
|
actions = format_utils.table_factory(
|
|
field_names=['Name', 'Action', 'Lifecycle'])
|
|
if action_list:
|
|
# sort by id, which is ULID - chronological.
|
|
for action in sorted(action_list, key=lambda k: k['id']):
|
|
actions.add_row([
|
|
action.get('name'), 'action/{}'.format(action.get('id')),
|
|
action.get('action_lifecycle')
|
|
])
|
|
else:
|
|
actions.add_row(['None', '', ''])
|
|
|
|
return format_utils.table_get_string(actions)
|
|
|
|
|
|
def gen_collection_table(collection_list):
|
|
"""Generates a list of collections and their status
|
|
|
|
Assumes collection_list is a list of dictionares with 'collection_name',
|
|
'base_status', 'new_status', 'base_version', 'base_revision', 'new_version'
|
|
and 'new_revision'.
|
|
"""
|
|
collections = format_utils.table_factory(
|
|
field_names=['Collection',
|
|
'Base',
|
|
'New'])
|
|
|
|
if collection_list:
|
|
for collection in collection_list:
|
|
collections.add_row([
|
|
collection.get('collection_name'),
|
|
collection.get('base_status'),
|
|
collection.get('new_status')
|
|
])
|
|
|
|
collections_title = (
|
|
'Comparing Base: {} (Deckhand revision {}) \n\t to New: {} '
|
|
'(Deckhand revision {})'.format(
|
|
collection.get('base_version'),
|
|
collection.get('base_revision'),
|
|
collection.get('new_version'),
|
|
collection.get('new_revision')))
|
|
|
|
else:
|
|
collections.add_row(['None', '', ''])
|
|
collections_title = ''
|
|
|
|
return format_utils.table_get_string(table=collections,
|
|
title=collections_title,
|
|
vertical_char=' ')
|
|
|
|
|
|
def gen_workflow_table(workflow_list):
|
|
"""Generates a list of workflows
|
|
|
|
Assumes workflow_list is a list of dictionaries with 'workflow_id' and
|
|
'state'
|
|
"""
|
|
workflows = format_utils.table_factory(field_names=['Workflows', 'State'])
|
|
if workflow_list:
|
|
for workflow in workflow_list:
|
|
workflows.add_row(
|
|
[workflow.get('workflow_id'),
|
|
workflow.get('state')])
|
|
else:
|
|
workflows.add_row(['None', ''])
|
|
|
|
return format_utils.table_get_string(workflows)
|
|
|
|
|
|
def gen_workflow_details(workflow_dict):
|
|
"""Generates a workflow detail
|
|
|
|
Assumes workflow_dict has 'execution_date', 'end_date', 'workflow_id',
|
|
'start_date', 'external_trigger', 'steps', 'dag_id', 'state', 'run_id',
|
|
and 'sub_dags'
|
|
"""
|
|
details = format_utils.table_factory()
|
|
details.add_row(['Workflow:', workflow_dict.get('workflow_id')])
|
|
|
|
details.add_row(['State:', workflow_dict.get('state')])
|
|
details.add_row(['Dag ID:', workflow_dict.get('dag_id')])
|
|
details.add_row(['Execution Date:', workflow_dict.get('execution_date')])
|
|
details.add_row(['Start Date:', workflow_dict.get('start_date')])
|
|
details.add_row(['End Date:', workflow_dict.get('end_date')])
|
|
details.add_row(
|
|
['External Trigger:',
|
|
workflow_dict.get('external_trigger')])
|
|
return format_utils.table_get_string(details)
|
|
|
|
|
|
def gen_workflow_steps(step_list):
|
|
"""Generates a table of steps for a workflow
|
|
|
|
Assumes step_list is a list of dictionaries with 'task_id' and 'state'
|
|
"""
|
|
steps = format_utils.table_factory(field_names=['Steps', 'State'])
|
|
if step_list:
|
|
for step in step_list:
|
|
steps.add_row([step.get('task_id'), step.get('state')])
|
|
else:
|
|
steps.add_row(['None', ''])
|
|
|
|
return format_utils.table_get_string(steps)
|
|
|
|
|
|
def gen_sub_workflows(wf_list):
|
|
"""Generates the list of Sub Workflows
|
|
|
|
Assumes wf_list is a list of dictionaries with the same contents as a
|
|
standard workflow
|
|
"""
|
|
wfs = []
|
|
for wf in wf_list:
|
|
wfs.append(gen_workflow_details(wf))
|
|
return '\n\n'.join(wfs)
|