fuel/deploy/deploy_env.py

   1 ###############################################################################
   2 # Copyright (c) 2015 Ericsson AB and others.
   3 # szilard.cserey@ericsson.com
   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 import os
  12 import io
  13 import yaml
  14 import glob
  15 import time
  16
  17 from ssh_client import SSHClient
  18 import common
  19
  20 exec_cmd = common.exec_cmd
  21 err = common.err
  22 check_file_exists = common.check_file_exists
  23 log = common.log
  24 parse = common.parse
  25 commafy = common.commafy
  26 N = common.N
  27 E = common.E
  28 R = common.R
  29 RO = common.RO
  30
  31 CLOUD_DEPLOY_FILE = 'deploy.py'
  32 BLADE_RESTART_TIMES = 3
  33 PLUGINS_DIR = '~/plugins'
  34
  35
  36 class CloudDeploy(object):
  37
  38     def __init__(self, dea, dha, fuel_ip, fuel_username, fuel_password,
  39                  dea_file, fuel_plugins_dir, work_dir, no_health_check):
  40         self.dea = dea
  41         self.dha = dha
  42         self.fuel_ip = fuel_ip
  43         self.fuel_username = fuel_username
  44         self.fuel_password = fuel_password
  45         self.dea_file = dea_file
  46         self.fuel_plugins_dir = fuel_plugins_dir
  47         self.work_dir = work_dir
  48         self.no_health_check = no_health_check
  49         self.file_dir = os.path.dirname(os.path.realpath(__file__))
  50         self.ssh = SSHClient(self.fuel_ip, self.fuel_username,
  51                              self.fuel_password)
  52         self.blade_node_file = '%s/blade_node.yaml' % self.file_dir
  53         self.node_ids = self.dha.get_node_ids()
  54         self.wanted_release = self.dea.get_property('wanted_release')
  55         self.blade_node_dict = {}
  56         self.macs_per_blade = {}
  57
  58     def upload_cloud_deployment_files(self):
  59         with self.ssh as s:
  60             s.exec_cmd('rm -rf %s' % self.work_dir, False)
  61             s.exec_cmd('mkdir %s' % self.work_dir)
  62             s.scp_put(self.dea_file, self.work_dir)
  63             s.scp_put(self.blade_node_file, self.work_dir)
  64             s.scp_put('%s/common.py' % self.file_dir, self.work_dir)
  65             s.scp_put('%s/dea.py' % self.file_dir, self.work_dir)
  66             for f in glob.glob('%s/cloud/*' % self.file_dir):
  67                 s.scp_put(f, self.work_dir)
  68
  69     def upload_plugin_files(self):
  70         with self.ssh as s:
  71             s.exec_cmd('rm -rf %s' % PLUGINS_DIR, False)
  72             s.exec_cmd('mkdir %s' % PLUGINS_DIR)
  73             if self.fuel_plugins_dir:
  74                 for f in glob.glob('%s/*.rpm' % self.fuel_plugins_dir):
  75                     s.scp_put(f, PLUGINS_DIR)
  76
  77     def power_off_nodes(self):
  78         for node_id in self.node_ids:
  79             self.dha.node_power_off(node_id)
  80
  81     def power_on_nodes(self):
  82         for node_id in self.node_ids:
  83             self.dha.node_power_on(node_id)
  84
  85     def set_boot_order(self, boot_order_list):
  86         for node_id in self.node_ids:
  87             self.dha.node_set_boot_order(node_id, boot_order_list[:])
  88
  89     def get_mac_addresses(self):
  90         self.macs_per_blade = {}
  91         for node_id in self.node_ids:
  92             self.macs_per_blade[node_id] = self.dha.get_node_pxe_mac(node_id)
  93
  94     def run_cloud_deploy(self, deploy_app):
  95         log('START CLOUD DEPLOYMENT')
  96         deploy_app = '%s/%s' % (self.work_dir, deploy_app)
  97         dea_file = '%s/%s' % (self.work_dir, os.path.basename(self.dea_file))
  98         blade_node_file = '%s/%s' % (
  99             self.work_dir, os.path.basename(self.blade_node_file))
 100         with self.ssh as s:
 101             status = s.run('python %s %s %s %s %s'
 102                            % (('-nh' if self.no_health_check else ''),
 103                               deploy_app, dea_file, blade_node_file,
 104                               PLUGINS_DIR))
 105         return status
 106
 107     def check_supported_release(self):
 108         log('Check supported release: %s' % self.wanted_release)
 109         found = False
 110         release_list = parse(self.ssh.exec_cmd('fuel release -l'))
 111         for release in release_list:
 112             if release[R['name']] == self.wanted_release:
 113                 found = True
 114                 break
 115         if not found:
 116             err('This Fuel does not contain the following release: %s'
 117                 % self.wanted_release)
 118
 119     def check_previous_installation(self):
 120         log('Check previous installation')
 121         env_list = parse(self.ssh.exec_cmd('fuel env list'))
 122         if env_list:
 123             self.cleanup_fuel_environments(env_list)
 124             node_list = parse(self.ssh.exec_cmd('fuel node list'))
 125             if node_list:
 126                 self.cleanup_fuel_nodes(node_list)
 127
 128     def cleanup_fuel_environments(self, env_list):
 129         WAIT_LOOP = 60
 130         SLEEP_TIME = 10
 131         for env in env_list:
 132             log('Deleting environment %s' % env[E['id']])
 133             self.ssh.exec_cmd('fuel env --env %s --delete --force'
 134                               % env[E['id']])
 135         all_env_erased = False
 136         for i in range(WAIT_LOOP):
 137             env_list = parse(self.ssh.exec_cmd('fuel env list'))
 138             if env_list:
 139                 time.sleep(SLEEP_TIME)
 140             else:
 141                 all_env_erased = True
 142                 break
 143         if not all_env_erased:
 144             err('Could not erase these environments %s'
 145                 % [(env[E['id']], env[E['status']]) for env in env_list])
 146
 147     def cleanup_fuel_nodes(self, node_list):
 148         for node in node_list:
 149             if node[N['status']] == 'discover':
 150                 log('Deleting node %s' % node[N['id']])
 151                 self.ssh.exec_cmd('fuel node --node-id %s --delete-from-db '
 152                                   '--force' % node[N['id']])
 153                 self.ssh.exec_cmd('cobbler system remove --name node-%s'
 154                                   % node[N['id']], False)
 155
 156     def check_prerequisites(self):
 157         log('Check prerequisites')
 158         with self.ssh:
 159             self.check_supported_release()
 160             self.check_previous_installation()
 161
 162     def wait_for_discovered_blades(self):
 163         log('Wait for discovered blades')
 164         discovered_macs = []
 165         restart_times = BLADE_RESTART_TIMES
 166
 167         for blade in self.node_ids:
 168             self.blade_node_dict[blade] = None
 169
 170         with self.ssh:
 171             all_discovered = self.discovery_waiting_loop(discovered_macs)
 172
 173         while not all_discovered and restart_times != 0:
 174             restart_times -= 1
 175             for blade in self.get_not_discovered_blades():
 176                 self.dha.node_reset(blade)
 177             with self.ssh:
 178                 all_discovered = self.discovery_waiting_loop(discovered_macs)
 179
 180         if not all_discovered:
 181             err('Not all blades have been discovered: %s'
 182                 % self.not_discovered_blades_summary())
 183
 184         with io.open(self.blade_node_file, 'w') as stream:
 185             yaml.dump(self.blade_node_dict, stream, default_flow_style=False)
 186
 187     def discovery_waiting_loop(self, discovered_macs):
 188         WAIT_LOOP = 360
 189         SLEEP_TIME = 10
 190         all_discovered = False
 191         for i in range(WAIT_LOOP):
 192             node_list = parse(self.ssh.exec_cmd('fuel node list'))
 193             if node_list:
 194                 self.node_discovery(node_list, discovered_macs)
 195             if self.all_blades_discovered():
 196                 all_discovered = True
 197                 break
 198             else:
 199                 time.sleep(SLEEP_TIME)
 200         return all_discovered
 201
 202     def node_discovery(self, node_list, discovered_macs):
 203         for node in node_list:
 204             if (node[N['status']] == 'discover' and
 205                 node[N['online']] == 'True' and
 206                 node[N['mac']] not in discovered_macs):
 207                 discovered_macs.append(node[N['mac']])
 208                 blade = self.find_mac_in_dict(node[N['mac']])
 209                 if blade:
 210                     log('Blade %s discovered as Node %s with MAC %s'
 211                         % (blade, node[N['id']], node[N['mac']]))
 212                     self.blade_node_dict[blade] = node[N['id']]
 213
 214     def find_mac_in_dict(self, mac):
 215         for blade, mac_list in self.macs_per_blade.iteritems():
 216             if mac in mac_list:
 217                 return blade
 218
 219     def all_blades_discovered(self):
 220         for blade, node_id in self.blade_node_dict.iteritems():
 221             if not node_id:
 222                 return False
 223         return True
 224
 225     def not_discovered_blades_summary(self):
 226         summary = ''
 227         for blade, node_id in self.blade_node_dict.iteritems():
 228             if not node_id:
 229                 summary += '\n[blade %s]' % blade
 230         return summary
 231
 232     def get_not_discovered_blades(self):
 233         not_discovered_blades = []
 234         for blade, node_id in self.blade_node_dict.iteritems():
 235             if not node_id:
 236                 not_discovered_blades.append(blade)
 237         return not_discovered_blades
 238
 239     def set_boot_order_nodes(self):
 240         self.power_off_nodes()
 241         self.set_boot_order(['pxe', 'disk'])
 242         self.power_on_nodes()
 243
 244     def deploy(self):
 245
 246         self.set_boot_order_nodes()
 247
 248         self.check_prerequisites()
 249
 250         self.get_mac_addresses()
 251
 252         self.wait_for_discovered_blades()
 253
 254         self.upload_cloud_deployment_files()
 255
 256         self.upload_plugin_files()
 257
 258         return self.run_cloud_deploy(CLOUD_DEPLOY_FILE)