modules/opnfv/deployment/daisy/adapter.py

   1 ##############################################################################
   2 # Copyright (c) 2017 ZTE Corporation and others.
   3 #
   4 # All rights reserved. This program and the accompanying materials
   5 # are made available under the terms of the Apache License, Version 2.0
   6 # which accompanies this distribution, and is available at
   7 # http://www.apache.org/licenses/LICENSE-2.0
   8 ##############################################################################
   9
  10
  11 from opnfv.deployment import manager
  12 from opnfv.utils import opnfv_logger as logger
  13 from opnfv.utils import ssh_utils
  14
  15 logger = logger.Logger(__name__).getLogger()
  16
  17
  18 class DaisyAdapter(manager.DeploymentHandler):
  19
  20     def __init__(self, installer_ip, installer_user, installer_pwd):
  21         super(DaisyAdapter, self).__init__(installer='daisy',
  22                                            installer_ip=installer_ip,
  23                                            installer_user=installer_user,
  24                                            installer_pwd=installer_pwd,
  25                                            pkey_file=None)
  26
  27     def _get_clusters(self):
  28         clusters = []
  29         cmd = 'source /root/daisyrc_admin; daisy cluster-list | grep -v "+--"'
  30         output = self.installer_node.run_cmd(cmd)
  31         lines = output.rsplit('\n')
  32         if len(lines) < 2:
  33             logger.info("No environments found in the deployment.")
  34             return None
  35         else:
  36             fields = lines[0].rsplit('|')
  37
  38             index_id = -1
  39             index_status = -1
  40             index_name = -1
  41             index_nodes = -1
  42
  43             for i in range(len(fields)):
  44                 if "ID" in fields[i]:
  45                     index_id = i
  46                 elif "Status" in fields[i]:
  47                     index_status = i
  48                 elif "Name" in fields[i]:
  49                     index_name = i
  50                 elif "Nodes" in fields[i]:
  51                     index_nodes = i
  52
  53             # order env info
  54             for i in range(1, len(lines)):
  55                 fields = lines[i].rsplit('|')
  56                 dict = {"id": fields[index_id].strip(),
  57                         "status": fields[index_status].strip(),
  58                         "name": fields[index_name].strip(),
  59                         "nodes": fields[index_nodes].strip()}
  60                 clusters.append(dict)
  61
  62         return clusters
  63
  64     def get_nodes(self, options=None):
  65         if hasattr(self, 'nodes') and len(self.nodes) > 0:
  66             if options and 'cluster' in options and options['cluster']:
  67                 nodes = []
  68                 for node in self.nodes:
  69                     if str(node.info['cluster']) == str(options['cluster']):
  70                         nodes.append(node)
  71                 return nodes
  72             else:
  73                 return self.nodes
  74
  75         clusters = self._get_clusters()
  76         nodes = []
  77         for cluster in clusters:
  78             if options and 'cluster' in options and options['cluster']:
  79                 if cluster["id"] != options['cluster']:
  80                     continue
  81             cmd = 'source /root/daisyrc_admin; daisy host-list ' \
  82                   '--cluster-id {} | grep -v "+--"'.format(cluster["id"])
  83             output = self.installer_node.run_cmd(cmd)
  84             lines = output.rsplit('\n')
  85             if len(lines) < 2:
  86                 logger.info("No nodes found in the cluster {}".format(
  87                     cluster["id"]))
  88                 continue
  89
  90             fields = lines[0].rsplit('|')
  91             index_id = -1
  92             index_status = -1
  93             index_name = -1
  94
  95             for i in range(len(fields)):
  96                 if "ID" in fields[i]:
  97                     index_id = i
  98                 elif "Role_status" in fields[i]:
  99                     index_status = i
 100                 elif "Name" in fields[i]:
 101                     index_name = i
 102
 103             for i in range(1, len(lines)):
 104                 fields = lines[i].rsplit('|')
 105                 id = fields[index_id].strip().encode()
 106                 status_node = fields[index_status].strip().encode().lower()
 107                 name = fields[index_name].strip().encode()
 108                 ip = ".".join(name.split("-")[1:])
 109
 110                 cmd_role = 'source /root/daisyrc_admin; ' \
 111                            'daisy host-detail {} | grep "^| role"'.format(id)
 112                 output_role = self.installer_node.run_cmd(cmd_role)
 113                 role_all = output_role.rsplit('|')[2].strip().encode()
 114                 roles = []
 115                 if 'COMPUTER' in role_all:
 116                     roles.append(manager.Role.COMPUTE)
 117                 if 'CONTROLLER_LB' in role_all or 'CONTROLLER_HA' in role_all:
 118                     roles.append(manager.Role.CONTROLLER)
 119
 120                 ssh_client = None
 121                 if status_node == 'active':
 122                     status = manager.NodeStatus.STATUS_OK
 123                     proxy = {'ip': self.installer_ip,
 124                              'username': self.installer_user,
 125                              'password': self.installer_pwd,
 126                              'pkey_file': '/root/.ssh/id_dsa'}
 127                     ssh_client = ssh_utils.get_ssh_client(hostname=ip,
 128                                                           username='root',
 129                                                           proxy=proxy)
 130                 else:
 131                     status = manager.NodeStatus.STATUS_INACTIVE
 132
 133                 node = DaisyNode(id, ip, name, status, roles, ssh_client)
 134                 nodes.append(node)
 135         return nodes
 136
 137     def get_openstack_version(self):
 138         cmd = 'docker exec nova_api nova-manage version 2>/dev/null'
 139         version = None
 140         for node in self.nodes:
 141             if node.is_controller() and node.is_active():
 142                 version = node.run_cmd(cmd)
 143                 break
 144         return version
 145
 146     def get_sdn_version(self):
 147         version = None
 148         for node in self.nodes:
 149             if manager.Role.CONTROLLER in node.roles and node.is_active():
 150                 cmd = 'docker inspect --format=\'{{.Name}}\' `docker ps -q`'
 151                 output = node.run_cmd(cmd)
 152                 if '/opendaylight' in output.rsplit('\n'):
 153                     cmd2 = 'docker exec opendaylight ' \
 154                            'sudo yum info opendaylight 2>/dev/null ' \
 155                            '| grep Version | tail -1'
 156                     odl_ver = node.run_cmd(cmd2)
 157                     if odl_ver:
 158                         version = 'OpenDaylight: ' + odl_ver.split(' ')[-1]
 159                     break
 160         return version
 161
 162     def get_deployment_status(self):
 163         clusters = self._get_clusters()
 164         if clusters is None or len(clusters) == 0:
 165             return 'unknown'
 166         else:
 167             return clusters[0]['status']
 168
 169
 170 class DaisyNode(manager.Node):
 171
 172     def __init__(self,
 173                  id,
 174                  ip,
 175                  name,
 176                  status,
 177                  roles=None,
 178                  ssh_client=None,
 179                  info=None):
 180         super(DaisyNode, self).__init__(id, ip, name, status,
 181                                         roles, ssh_client, info)
 182
 183     def is_odl(self):
 184         '''
 185         Returns if the node is an opendaylight
 186         '''
 187         if manager.Role.CONTROLLER in self.roles and self.is_active():
 188             cmd = 'docker inspect --format=\'{{.Name}}\' `docker ps -q`'
 189             output = self.run_cmd(cmd)
 190             if '/opendaylight' in output.rsplit('\n'):
 191                 return True
 192         return False
 193
 194     def get_ovs_info(self):
 195         '''
 196         Returns the ovs version installed
 197         '''
 198         if self.is_active():
 199             cmd = 'docker exec openvswitch_vswitchd ' \
 200                   'ovs-vsctl --version | head -1 | awk \'{print $NF}\''
 201             return self.run_cmd(cmd)
 202         return None