fuel/deploy/cloud/deploy.py

   1 import time
   2 import yaml
   3 import io
   4 import sys
   5
   6 import common
   7 from dea import DeploymentEnvironmentAdapter
   8 from configure_environment import ConfigureEnvironment
   9 from deployment import Deployment
  10
  11 YAML_CONF_DIR = '/var/lib/opnfv'
  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, dea_file, macs_file):
  26         self.dea = DeploymentEnvironmentAdapter(dea_file)
  27         self.macs_file = macs_file
  28         self.macs_per_blade = {}
  29         self.blades = self.dea.get_node_ids()
  30         self.node_ids_dict = {}
  31         self.node_id_roles_dict = {}
  32         self.supported_release = None
  33         self.env_id = None
  34         self.wanted_release = self.dea.get_wanted_release()
  35
  36     def cleanup_fuel_environments(self, env_list):
  37         WAIT_LOOP = 60
  38         SLEEP_TIME = 10
  39         for env in env_list:
  40             log('Deleting environment %s' % env[E['id']])
  41             exec_cmd('fuel env --env %s --delete' % env[E['id']])
  42         all_env_erased = False
  43         for i in range(WAIT_LOOP):
  44             env_list = parse(exec_cmd('fuel env list'))
  45             if env_list:
  46                time.sleep(SLEEP_TIME)
  47             else:
  48                all_env_erased = True
  49                break
  50         if not all_env_erased:
  51             err('Could not erase these environments %s'
  52                 % [(env[E['id']], env[E['status']]) for env in env_list])
  53
  54     def cleanup_fuel_nodes(self, node_list):
  55         for node in node_list:
  56             if node[N['status']] == 'discover':
  57                 log('Deleting node %s' % node[N['id']])
  58                 exec_cmd('fuel node --node-id %s --delete-from-db'
  59                          % node[N['id']])
  60                 exec_cmd('dockerctl shell cobbler cobbler system remove '
  61                          '--name node-%s' % node[N['id']])
  62
  63     def check_previous_installation(self):
  64         log('Check previous installation')
  65         env_list = parse(exec_cmd('fuel env list'))
  66         if env_list:
  67             self.cleanup_fuel_environments(env_list)
  68             node_list = parse(exec_cmd('fuel node list'))
  69             if node_list:
  70                 self.cleanup_fuel_nodes(node_list)
  71
  72     def check_supported_release(self):
  73         log('Check supported release: %s' % self.wanted_release)
  74         release_list = parse(exec_cmd('fuel release -l'))
  75         for release in release_list:
  76             if release[R['name']] == self.wanted_release:
  77                 self.supported_release = release
  78                 break
  79         if not self.supported_release:
  80             err('This Fuel does not contain the following release: %s'
  81                 % self.wanted_release)
  82
  83     def check_prerequisites(self):
  84         log('Check prerequisites')
  85         self.check_supported_release()
  86         self.check_previous_installation()
  87
  88     def get_mac_addresses(self):
  89         with io.open(self.macs_file, 'r') as stream:
  90             self.macs_per_blade = yaml.load(stream)
  91
  92     def find_mac_in_dict(self, mac):
  93         for blade, mac_list in self.macs_per_blade.iteritems():
  94             if mac in mac_list:
  95                 return blade
  96
  97     def all_blades_discovered(self):
  98         for blade, node_id in self.node_ids_dict.iteritems():
  99             if not node_id:
 100                 return False
 101         return True
 102
 103     def not_discovered_blades_summary(self):
 104         summary = ''
 105         for blade, node_id in self.node_ids_dict.iteritems():
 106             if not node_id:
 107                 summary += '\n[blade %s]' % blade
 108         return summary
 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                 blade = self.find_mac_in_dict(node[N['mac']])
 117                 if blade:
 118                     log('Blade %s discovered as Node %s with MAC %s'
 119                         % (blade, node[N['id']], node[N['mac']]))
 120                     self.node_ids_dict[blade] = node[N['id']]
 121
 122     def discovery_waiting_loop(self, discovered_macs):
 123         WAIT_LOOP = 180
 124         SLEEP_TIME = 10
 125         all_discovered = False
 126         for i in range(WAIT_LOOP):
 127             node_list = parse(exec_cmd('fuel node list'))
 128             if node_list:
 129                 self.node_discovery(node_list, discovered_macs)
 130             if self.all_blades_discovered():
 131                 all_discovered = True
 132                 break
 133             else:
 134                 time.sleep(SLEEP_TIME)
 135         return all_discovered
 136
 137     def wait_for_discovered_blades(self):
 138         log('Wait for discovered blades')
 139         discovered_macs = []
 140         for blade in self.blades:
 141             self.node_ids_dict[blade] = None
 142         all_discovered = self.discovery_waiting_loop(discovered_macs)
 143         if not all_discovered:
 144             err('Not all blades have been discovered: %s'
 145                 % self.not_discovered_blades_summary())
 146
 147     def assign_roles_to_cluster_node_ids(self):
 148         self.node_id_roles_dict = {}
 149         for blade, node_id in self.node_ids_dict.iteritems():
 150             role_list = []
 151             role = self.dea.get_node_role(blade)
 152             if role == 'controller':
 153                 role_list.extend(['controller', 'mongo'])
 154             elif role == 'compute':
 155                 role_list.extend(['compute'])
 156             self.node_id_roles_dict[node_id] = (role_list, blade)
 157
 158     def configure_environment(self):
 159         config_env = ConfigureEnvironment(self.dea, YAML_CONF_DIR,
 160                                           self.supported_release[R['id']],
 161                                           self.node_id_roles_dict)
 162         config_env.configure_environment()
 163         self.env_id = config_env.env_id
 164
 165     def deploy_cloud(self):
 166         dep = Deployment(self.dea, YAML_CONF_DIR, self.env_id,
 167                          self.node_id_roles_dict)
 168         dep.deploy()
 169
 170     def deploy(self):
 171         self.get_mac_addresses()
 172         self.check_prerequisites()
 173         self.wait_for_discovered_blades()
 174         self.assign_roles_to_cluster_node_ids()
 175         self.configure_environment()
 176         self.deploy_cloud()
 177
 178 def usage():
 179     print '''
 180     Usage:
 181     python deploy.py <dea_file> <macs_file>
 182
 183     Example:
 184             python deploy.py dea.yaml macs.yaml
 185     '''
 186
 187 def parse_arguments():
 188     if len(sys.argv) != 3:
 189         log('Incorrect number of arguments')
 190         usage()
 191         sys.exit(1)
 192     dea_file = sys.argv[-2]
 193     macs_file = sys.argv[-1]
 194     check_file_exists(dea_file)
 195     check_file_exists(macs_file)
 196     return dea_file, macs_file
 197
 198 def main():
 199
 200     dea_file, macs_file = parse_arguments()
 201
 202     deploy = Deploy(dea_file, macs_file)
 203     deploy.deploy()
 204
 205 if __name__ == '__main__':
 206     main()