fuel/deploy/cloud_deploy/cloud/deploy.py

   1 import time
   2 import yaml
   3 import io
   4 import os
   5
   6 import common
   7 from dea import DeploymentEnvironmentAdapter
   8 from configure_environment import ConfigureEnvironment
   9 from deployment import Deployment
  10
  11 SUPPORTED_RELEASE = 'Juno on CentOS 6.5'
  12
  13 N = common.N
  14 E = common.E
  15 R = common.R
  16 RO = common.RO
  17 exec_cmd = common.exec_cmd
  18 parse = common.parse
  19 err = common.err
  20 check_file_exists = common.check_file_exists
  21 LOG = common.LOG
  22
  23 class Deploy(object):
  24
  25     def __init__(self, yaml_config_dir):
  26         self.supported_release = None
  27         self.yaml_config_dir = yaml_config_dir
  28         self.macs_per_shelf_dict = {}
  29         self.node_ids_dict = {}
  30         self.node_id_roles_dict = {}
  31         self.env_id = None
  32         self.shelf_blades_dict = {}
  33
  34     def cleanup_fuel_environments(self, env_list):
  35         WAIT_LOOP = 60
  36         SLEEP_TIME = 10
  37         for env in env_list:
  38             LOG.debug('Deleting environment %s\n' % env[E['id']])
  39             exec_cmd('fuel env --env %s --delete' % env[E['id']])
  40         all_env_erased = False
  41         for i in range(WAIT_LOOP):
  42             env_list = parse(exec_cmd('fuel env list'))
  43             if env_list[0][0]:
  44                time.sleep(SLEEP_TIME)
  45             else:
  46                all_env_erased = True
  47                break
  48         if not all_env_erased:
  49             err('Could not erase these environments %s'
  50                 % [(env[E['id']], env[E['status']]) for env in env_list])
  51
  52     def cleanup_fuel_nodes(self, node_list):
  53         for node in node_list:
  54             if node[N['status']] == 'discover':
  55                 LOG.debug('Deleting node %s\n' % node[N['id']])
  56                 exec_cmd('fuel node --node-id %s --delete-from-db'
  57                          % node[N['id']])
  58                 exec_cmd('cobbler system remove --name node-%s'
  59                          % node[N['id']])
  60
  61     def check_previous_installation(self):
  62         LOG.debug('Check previous installation\n')
  63         env_list = parse(exec_cmd('fuel env list'))
  64         if env_list[0][0]:
  65             self.cleanup_fuel_environments(env_list)
  66             node_list = parse(exec_cmd('fuel node list'))
  67             if node_list[0][0]:
  68                 self.cleanup_fuel_nodes(node_list)
  69
  70     def check_supported_release(self):
  71         LOG.debug('Check supported release: %s\n' % SUPPORTED_RELEASE)
  72         release_list = parse(exec_cmd('fuel release -l'))
  73         for release in release_list:
  74             if release[R['name']] == SUPPORTED_RELEASE:
  75                 self.supported_release = release
  76                 break
  77         if not self.supported_release:
  78             err('This Fuel does not contain the following '
  79                 'release: %s\n' % SUPPORTED_RELEASE)
  80
  81     def check_prerequisites(self):
  82         LOG.debug('Check prerequisites\n')
  83         self.check_supported_release()
  84         self.check_previous_installation()
  85
  86     def find_mac_in_dict(self, mac):
  87         for shelf, blade_dict in self.macs_per_shelf_dict.iteritems():
  88             for blade, mac_list in blade_dict.iteritems():
  89                 if mac in mac_list:
  90                     return shelf, blade
  91
  92     def all_blades_discovered(self):
  93         for shelf, blade_dict in self.node_ids_dict.iteritems():
  94             for blade, node_id in blade_dict.iteritems():
  95                 if not node_id:
  96                     return False
  97         return True
  98
  99     def not_discovered_blades_summary(self):
 100         summary = ''
 101         for shelf, blade_dict in self.node_ids_dict.iteritems():
 102             for blade, node_id in blade_dict.iteritems():
 103                 if not node_id:
 104                     summary += '[shelf %s, blade %s]\n' % (shelf, blade)
 105         return summary
 106
 107     def collect_blade_ids_per_shelves(self, dea):
 108         self.shelf_blades_dict = dea.get_blade_ids_per_shelves()
 109
 110     def node_discovery(self, node_list, discovered_macs):
 111         for node in node_list:
 112             if (node[N['status']] == 'discover' and
 113                 node[N['online']] == 'True' and
 114                 node[N['mac']] not in discovered_macs):
 115                 discovered_macs.append(node[N['mac']])
 116                 shelf_blade = self.find_mac_in_dict(node[N['mac']])
 117                 if shelf_blade:
 118                     self.node_ids_dict[shelf_blade[0]][shelf_blade[1]] = \
 119                         node[N['id']]
 120
 121     def discovery_waiting_loop(self, discovered_macs):
 122         WAIT_LOOP = 180
 123         SLEEP_TIME = 10
 124         all_discovered = False
 125         for i in range(WAIT_LOOP):
 126             node_list = parse(exec_cmd('fuel node list'))
 127             if node_list[0][0]:
 128                 self.node_discovery(node_list, discovered_macs)
 129             if self.all_blades_discovered():
 130                 all_discovered = True
 131                 break
 132             else:
 133                 time.sleep(SLEEP_TIME)
 134         return all_discovered
 135
 136     def wait_for_discovered_blades(self):
 137         LOG.debug('Wait for discovered blades\n')
 138         discovered_macs = []
 139         for shelf, blade_list in self.shelf_blades_dict.iteritems():
 140             self.node_ids_dict[shelf] = {}
 141             for blade in blade_list:
 142                 self.node_ids_dict[shelf][blade] = None
 143         all_discovered = self.discovery_waiting_loop(discovered_macs)
 144         if not all_discovered:
 145             err('Not all blades have been discovered: %s\n'
 146                 % self.not_discovered_blades_summary())
 147
 148     def get_mac_addresses(self, macs_yaml):
 149         with io.open(macs_yaml, 'r') as stream:
 150             self.macs_per_shelf_dict = yaml.load(stream)
 151
 152     def assign_roles_to_cluster_node_ids(self, dea):
 153         self.node_id_roles_dict = {}
 154         for shelf, blades_dict in self.node_ids_dict.iteritems():
 155             for blade, node_id in blades_dict.iteritems():
 156                 role_list = []
 157                 if dea.has_role('controller', shelf, blade):
 158                     role_list.extend(['controller', 'mongo'])
 159                     if dea.has_role('cinder', shelf, blade):
 160                         role_list.extend(['cinder'])
 161                 elif dea.has_role('compute', shelf, blade):
 162                     role_list.extend(['compute'])
 163                 self.node_id_roles_dict[node_id] = (role_list, shelf, blade)
 164
 165     def configure_environment(self, dea):
 166         config_env = ConfigureEnvironment(dea, self.yaml_config_dir,
 167                                           self.supported_release[R['id']],
 168                                           self.node_id_roles_dict)
 169         config_env.configure_environment()
 170         self.env_id = config_env.env_id
 171
 172     def deploy(self, dea):
 173         dep = Deployment(dea, self.yaml_config_dir, self.env_id,
 174                          self.node_id_roles_dict)
 175         dep.deploy()
 176
 177
 178 def main():
 179
 180     base_dir = os.path.dirname(os.path.realpath(__file__))
 181     dea_yaml = base_dir + '/dea.yaml'
 182     check_file_exists(dea_yaml)
 183     macs_yaml = base_dir + '/macs.yaml'
 184     check_file_exists(macs_yaml)
 185
 186     yaml_config_dir = '/var/lib/opnfv/pre_deploy'
 187
 188     deploy = Deploy(yaml_config_dir)
 189     dea = DeploymentEnvironmentAdapter()
 190     dea.parse_yaml(dea_yaml)
 191
 192     deploy.get_mac_addresses(macs_yaml)
 193
 194     deploy.collect_blade_ids_per_shelves(dea)
 195
 196     deploy.check_prerequisites()
 197
 198     deploy.wait_for_discovered_blades()
 199
 200     deploy.assign_roles_to_cluster_node_ids(dea)
 201
 202     deploy.configure_environment(dea)
 203
 204     deploy.deploy(dea)
 205
 206
 207 if __name__ == '__main__':
 208     main()