# Copyright (c) 2014 Mirantis, Inc. # # 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. import json from django.template import loader from django.templatetags.static import static from django.urls import reverse from muranodashboard.api import packages as pkg_cli from muranodashboard.environments import consts def get_app_image(request, app_fqdn, status=None): if '@' in app_fqdn: class_fqn, package_fqn = app_fqdn.split('@') if '/' in class_fqn: class_fqn, version = class_fqn.split('/') else: version = None else: package_fqn = app_fqdn version = None package = pkg_cli.app_by_fqn(request, package_fqn, version=version) if status in [ consts.STATUS_ID_DEPLOY_FAILURE, consts.STATUS_ID_DELETE_FAILURE, ]: url = static('dashboard/img/stack-red.svg') elif status == consts.STATUS_ID_READY: url = static('dashboard/img/stack-green.svg') else: url = static('dashboard/img/stack-gray.svg') if package: app_id = package.id url = reverse("horizon:app-catalog:catalog:images", args=(app_id,)) return url def _get_environment_status_message(entity): if hasattr(entity, 'status'): status = entity.status else: status = entity['?']['status'] in_progress = True status_message = '' if status in (consts.STATUS_ID_PENDING, consts.STATUS_ID_READY): in_progress = False if status == consts.STATUS_ID_PENDING: status_message = 'Waiting for deployment' elif status == consts.STATUS_ID_READY: status_message = 'Deployed' elif status == consts.STATUS_ID_DEPLOYING: status_message = 'Deployment is in progress' elif status == consts.STATUS_ID_DEPLOY_FAILURE: status_message = 'Deployment failed' return in_progress, status_message def _truncate_type(type_str, num_of_chars): if len(type_str) < num_of_chars: return type_str else: parts = type_str.split('.') type_str, type_len = parts[-1], len(parts[-1]) for part in reversed(parts[:-1]): if type_len + len(part) + 1 > num_of_chars: return '...' + type_str else: type_str = part + '.' + type_str type_len += len(part) + 1 return type_str def _application_info(application, app_image, status): name = application['?'].get('name') if not name: name = application.get('name') context = {'name': name, 'type': _truncate_type(application['?']['type'], 45), 'status': status, 'app_image': app_image} return loader.render_to_string('services/_application_info.html', context) def _network_info(name, image): context = {'name': name, 'image': image} return loader.render_to_string('services/_network_info.html', context) def _unit_info(unit, unit_image): data = dict(unit) data['type'] = _truncate_type(data['type'], 45) context = {'data': data, 'unit_image': unit_image} return loader.render_to_string('services/_unit_info.html', context) def _environment_info(environment, status): context = {'name': environment.name, 'status': status} return loader.render_to_string('services/_environment_info.html', context) def _create_empty_node(): node = { 'name': '', 'status': 'ready', 'image': '', 'image_size': 60, 'required_by': [], 'image_x': -30, 'image_y': -30, 'text_x': 40, 'text_y': ".35em", 'link_type': "relation", 'in_progress': False, 'info_box': '' } return node def _create_ext_network_node(name): node = _create_empty_node() node.update({'id': name, 'image': static('muranodashboard/images/ext-net.png'), 'link_type': 'relation', 'info_box': _network_info(name, static( 'dashboard/img/lb-green.svg'))} ) return node def _convert_lists(node_data): for key, value in node_data.items(): if isinstance(value, list) and all( map(lambda s: not isinstance(s, (dict, list)), value)): new_value = ', '.join(str(v) for v in value) node_data[key] = new_value def _split_seq_by_predicate(seq, predicate): holds, not_holds = [], [] for elt in seq: if predicate(elt): holds.append(elt) else: not_holds.append(elt) return holds, not_holds def _is_atomic(elt): key, value = elt return not isinstance(value, (dict, list)) def render_d3_data(request, environment): if not (environment and environment.services): return None ext_net_name = None d3_data = {"nodes": [], "environment": {}} in_progress, status_message = _get_environment_status_message(environment) environment_node = _create_empty_node() environment_node.update({ 'id': environment.id, 'name': environment.name, 'status': status_message, 'image': static('dashboard/img/stack-green.svg'), 'in_progress': in_progress, 'info_box': _environment_info(environment, status_message) }) d3_data['environment'] = environment_node unit_image_active = static('dashboard/img/server-green.svg') unit_image_non_active = static('dashboard/img/server-gray.svg') node_refs = {} def get_image(fqdn, node_data): if fqdn.startswith('io.murano.resources'): if len(node_data.get('ipAddresses', [])) > 0: image = unit_image_active else: image = unit_image_non_active else: image = get_app_image(request, fqdn) return image def rec(node_data, node_key, parent_node=None): if not isinstance(node_data, dict): return _convert_lists(node_data) node_type = node_data.get('?', {}).get('type') node_id = node_data.get('?', {}).get('id') atomics, containers = _split_seq_by_predicate( node_data.items(), _is_atomic) if node_type and node_data is not parent_node: node = _create_empty_node() node_refs[node_id] = node atomics.extend([('id', node_data['?']['id']), ('type', node_type), ('name', node_data.get('name', node_key))]) image = get_image(node_type, node_data) node.update({ 'id': node_id, 'info_box': _unit_info(atomics, image), 'image': image, 'link_type': 'unit', 'in_progress': in_progress}) d3_data['nodes'].append(node) for key, value in containers: if key == '?': continue if isinstance(value, dict): rec(value, key, node_data) elif isinstance(value, list): for index, val in enumerate(value): rec(val, '{0}[{1}]'.format(key, index), node_data) def build_links_rec(node_data, parent_node=None): if not isinstance(node_data, dict): return node_id = node_data.get('?', {}).get('id') if not node_id: return node = node_refs[node_id] atomics, containers = _split_seq_by_predicate( node_data.items(), _is_atomic) # the actual second pass of node linking if parent_node is not None: node['required_by'].append(parent_node['?']['id']) node['link_type'] = 'aggregation' for key, value in atomics: if value in node_refs: remote_node = node_refs[value] if node_id not in remote_node['required_by']: remote_node['required_by'].append(node_id) remote_node['link_type'] = 'reference' for key, value in containers: if key == '?': continue if isinstance(value, dict): build_links_rec(value, node_data) elif isinstance(value, list): for val in value: build_links_rec(val, node_data) for service in environment.services: in_progress, status_message = _get_environment_status_message(service) required_by = None if 'instance' in service and service['instance'] is not None: if service['instance'].get('assignFloatingIp', False): if ext_net_name: required_by = ext_net_name else: ext_net_name = 'External_Network' ext_network_node = _create_ext_network_node(ext_net_name) d3_data['nodes'].append(ext_network_node) required_by = ext_net_name service_node = _create_empty_node() service_image = get_app_image(request, service['?']['type'], service['?']['status']) node_id = service['?']['id'] node_refs[node_id] = service_node service_node.update({ 'name': service.get('name', ''), 'status': status_message, 'image': service_image, 'id': node_id, 'link_type': 'relation', 'in_progress': in_progress, 'info_box': _application_info( service, service_image, status_message) }) if required_by: service_node['required_by'].append(required_by) d3_data['nodes'].append(service_node) rec(service, None, service) for service in environment.services: build_links_rec(service) return json.dumps(d3_data)