deploy/reap.py

   1 #!/usr/bin/python
   2 ###############################################################################
   3 # Copyright (c) 2015 Ericsson AB and others.
   4 # szilard.cserey@ericsson.com
   5 # All rights reserved. This program and the accompanying materials
   6 # are made available under the terms of the Apache License, Version 2.0
   7 # which accompanies this distribution, and is available at
   8 # http://www.apache.org/licenses/LICENSE-2.0
   9 ###############################################################################
  10
  11
  12 import time
  13 import os
  14 import yaml
  15 import glob
  16 import shutil
  17 import tempfile
  18
  19 from common import (
  20     N,
  21     E,
  22     R,
  23     ArgParser,
  24     exec_cmd,
  25     parse,
  26     err,
  27     log,
  28     delete,
  29     commafy,
  30 )
  31
  32 DEA_1 = '''
  33 title: Deployment Environment Adapter (DEA)
  34 # DEA API version supported
  35 version: 1.1
  36 created: {date}
  37 comment: {comment}
  38 '''
  39
  40 DHA_1 = '''
  41 title: Deployment Hardware Adapter (DHA)
  42 # DHA API version supported
  43 version: 1.1
  44 created: {date}
  45 comment: {comment}
  46
  47 # Adapter to use for this definition
  48 # adapter: [ipmi|libvirt]
  49 adapter:
  50
  51 # Node list.
  52 # Mandatory properties are id and role.
  53 # All other properties are adapter specific.
  54 # For Non-Fuel nodes controlled by:
  55 #   - ipmi adapter you need to provide:
  56 #       pxeMac
  57 #       ipmiIp
  58 #       ipmiUser
  59 #       ipmiPass
  60 #   - libvirt adapter you need to provide:
  61 #       libvirtName: <whatever>
  62 #       libvirtTemplate: [libvirt/vms/controller.xml | libvirt/vms/compute.xml]
  63 #
  64 # For the Fuel Node you need to provide:
  65 #       libvirtName: <whatever>
  66 #       libvirtTemplate: libvirt/vms/fuel.xml
  67 #       isFuel: yes
  68 #       username: root
  69 #       password: r00tme
  70 '''
  71
  72 DHA_2 = '''
  73 # Adding the Fuel node as node id {node_id}
  74 # which may not be correct - please adjust as needed.
  75 '''
  76
  77 DISKS = {'fuel': '50G',
  78          'controller': '60G',
  79          'compute': '50G'}
  80
  81
  82 class Reap(object):
  83
  84     def __init__(self, dea_file, dha_file, comment):
  85         self.dea_file = dea_file
  86         self.dha_file = dha_file
  87         self.comment = comment
  88         self.temp_dir = None
  89         self.env = None
  90         self.env_id = None
  91         self.last_node = None
  92
  93     def get_env(self):
  94         env_list = parse(exec_cmd('fuel env'))
  95         if len(env_list) > 1:
  96             err('Not exactly one environment')
  97         self.env = env_list[0]
  98         self.env_id = self.env[E['id']]
  99
 100     def download_config(self, config_type):
 101         log('Download %s config for environment %s'
 102             % (config_type, self.env_id))
 103         exec_cmd('fuel %s --env %s --download --dir %s'
 104                  % (config_type, self.env_id, self.temp_dir))
 105
 106     def download_node_config(self, nodeid):
 107         log('Download node %s config for environment %s to %s'
 108             % (nodeid, self.env_id,self.temp_dir))
 109         exec_cmd('fuel deployment --node-id %s --env %s  --default --dir %s'
 110                  % (nodeid, self.env_id, self.temp_dir))
 111
 112     def write(self, file, text, newline=True):
 113         mode = 'a' if os.path.isfile(file) else 'w'
 114         with open(file, mode) as f:
 115             f.write('%s%s' % (text, ('\n' if newline else '')))
 116
 117     def write_yaml(self, file, data, newline=True):
 118         self.write(file, yaml.dump(data, default_flow_style=False).strip(),
 119                    newline)
 120
 121     def get_node_by_id(self, node_list, node_id):
 122         for node in node_list:
 123             if node[N['id']] == node_id:
 124                 return node
 125
 126     def reap_interface(self, node_id, interfaces):
 127         interface, mac = self.get_interface(node_id)
 128         if_name = None
 129         if interfaces:
 130             if_name = self.check_dict_exists(interfaces, interface)
 131         if not if_name:
 132             if_name = 'interfaces_%s' % str(len(interfaces) + 1)
 133             interfaces[if_name] = interface
 134         return if_name, mac
 135
 136     def reap_transformation(self, node_id, roles, transformations):
 137         main_role = 'controller' if 'controller' in roles else 'compute'
 138         node_file = glob.glob('%s/deployment_%s/*%s_%s.yaml'
 139                               % (self.temp_dir, self.env_id,
 140                                  main_role, node_id))
 141         tr_name = None
 142         with open(node_file[0]) as f:
 143             node_config = yaml.load(f)
 144         transformation = {'transformations':
 145                               node_config['network_scheme']['transformations']}
 146         if transformations:
 147             tr_name = self.check_dict_exists(transformations, transformation)
 148         if not tr_name:
 149             tr_name = 'transformations_%s' % str(len(transformations) + 1)
 150             transformations[tr_name] = transformation
 151         return tr_name
 152
 153     def check_dict_exists(self, main_dict, dict):
 154         for key, val in main_dict.iteritems():
 155             if cmp(dict, val) == 0:
 156                 return key
 157
 158     def reap_nodes_interfaces_transformations(self):
 159         node_list = parse(exec_cmd('fuel node'))
 160         real_node_ids = [node[N['id']] for node in node_list]
 161         real_node_ids.sort()
 162         min_node = real_node_ids[0]
 163         interfaces = {}
 164         transformations = {}
 165         dea_nodes = []
 166         dha_nodes = []
 167
 168         for real_node_id in real_node_ids:
 169             node_id = int(real_node_id) - int(min_node) + 1
 170             self.last_node = node_id
 171             node = self.get_node_by_id(node_list, real_node_id)
 172             roles = commafy(node[N['roles']])
 173             if not roles:
 174                 err('Fuel Node %s has no role' % real_node_id)
 175             dea_node = {'id': node_id,
 176                         'role': roles}
 177             dha_node = {'id': node_id}
 178             if_name, mac = self.reap_interface(real_node_id, interfaces)
 179             log('reap transformation for node %s' % real_node_id)
 180             tr_name = self.reap_transformation(real_node_id, roles,
 181                                                transformations)
 182             dea_node.update(
 183                 {'interfaces': if_name,
 184                  'transformations': tr_name})
 185
 186             dha_node.update(
 187                 {'pxeMac': mac if mac else None,
 188                  'ipmiIp': None,
 189                  'ipmiUser': None,
 190                  'ipmiPass': None,
 191                  'libvirtName': None,
 192                  'libvirtTemplate': None})
 193
 194             dea_nodes.append(dea_node)
 195             dha_nodes.append(dha_node)
 196
 197         self.write_yaml(self.dha_file, {'nodes': dha_nodes}, False)
 198         self.write_yaml(self.dea_file, {'nodes': dea_nodes})
 199         self.write_yaml(self.dea_file, interfaces)
 200         self.write_yaml(self.dea_file, transformations)
 201         self.reap_fuel_node_info()
 202         self.write_yaml(self.dha_file, {'disks': DISKS})
 203
 204     def reap_fuel_node_info(self):
 205         dha_nodes = []
 206         dha_node = {
 207             'id': self.last_node + 1,
 208             'libvirtName': None,
 209             'libvirtTemplate': None,
 210             'isFuel': True,
 211             'username': 'root',
 212             'password': 'r00tme'}
 213
 214         dha_nodes.append(dha_node)
 215
 216         self.write(self.dha_file, DHA_2.format(node_id=dha_node['id']), False)
 217         self.write_yaml(self.dha_file, dha_nodes)
 218
 219     def reap_environment_info(self):
 220         network_file = ('%s/network_%s.yaml'
 221                         % (self.temp_dir, self.env_id))
 222         network = self.read_yaml(network_file)
 223
 224         # ha_compact not understood by Fuel when deploying...OD
 225         if self.env[E['mode']] == 'ha_compact':
 226             self.env[E['mode']] = 'ha'
 227
 228         env = {'environment':
 229                    {'name': self.env[E['name']],
 230                     'mode': self.env[E['mode']],
 231                     'net_segment_type':
 232                         network['networking_parameters']['segmentation_type']}}
 233         self.write_yaml(self.dea_file, env)
 234         wanted_release = None
 235         rel_list = parse(exec_cmd('fuel release'))
 236         for rel in rel_list:
 237             if rel[R['id']] == self.env[E['release_id']]:
 238                 wanted_release = rel[R['name']]
 239         self.write_yaml(self.dea_file, {'wanted_release': wanted_release})
 240
 241     def reap_fuel_settings(self):
 242         data = self.read_yaml('/etc/fuel/astute.yaml')
 243         fuel = {}
 244         del data['ADMIN_NETWORK']['mac']
 245         del data['ADMIN_NETWORK']['interface']
 246         for key in ['ADMIN_NETWORK', 'HOSTNAME', 'DNS_DOMAIN', 'DNS_SEARCH',
 247                     'DNS_UPSTREAM', 'NTP1', 'NTP2', 'NTP3', 'FUEL_ACCESS']:
 248             fuel[key] = data[key]
 249         for key in fuel['ADMIN_NETWORK'].keys():
 250             if key not in ['ipaddress', 'netmask',
 251                            'dhcp_pool_start', 'dhcp_pool_end']:
 252                 del fuel['ADMIN_NETWORK'][key]
 253         self.write_yaml(self.dea_file, {'fuel': fuel})
 254
 255     def reap_network_settings(self):
 256         network_file = ('%s/network_%s.yaml'
 257                         % (self.temp_dir, self.env_id))
 258         data = self.read_yaml(network_file)
 259         network = {}
 260         network['networking_parameters'] = data['networking_parameters']
 261         network['networks'] = data['networks']
 262         for net in network['networks']:
 263             del net['id']
 264             del net['group_id']
 265         self.write_yaml(self.dea_file, {'network': network})
 266
 267     def reap_settings(self):
 268         settings_file = '%s/settings_%s.yaml' % (self.temp_dir, self.env_id)
 269         settings = self.read_yaml(settings_file)
 270         self.write_yaml(self.dea_file, {'settings': settings})
 271
 272     def get_interface(self, real_node_id):
 273         exec_cmd('fuel node --node-id %s --network --download --dir %s'
 274                  % (real_node_id, self.temp_dir))
 275         interface_file = ('%s/node_%s/interfaces.yaml'
 276                           % (self.temp_dir, real_node_id))
 277         interfaces = self.read_yaml(interface_file)
 278         interface_config = {}
 279         pxe_mac = None
 280         for interface in interfaces:
 281             networks = []
 282             for network in interface['assigned_networks']:
 283                 networks.append(network['name'])
 284                 if network['name'] == 'fuelweb_admin':
 285                     pxe_mac = interface['mac']
 286             if networks:
 287                 interface_config[interface['name']] = networks
 288         return interface_config, pxe_mac
 289
 290     def read_yaml(self, yaml_file):
 291         with open(yaml_file) as f:
 292             data = yaml.load(f)
 293             return data
 294
 295     def intro(self):
 296         delete(self.dea_file)
 297         delete(self.dha_file)
 298         self.temp_dir = tempfile.mkdtemp()
 299         date = time.strftime('%c')
 300         self.write(self.dea_file,
 301                    DEA_1.format(date=date, comment=self.comment), False)
 302         self.write(self.dha_file,
 303                    DHA_1.format(date=date, comment=self.comment))
 304         self.get_env()
 305
 306         # Need to download deployment with explicit node ids
 307         node_list = parse(exec_cmd('fuel node'))
 308         real_node_ids = [node[N['id']] for node in node_list]
 309         real_node_ids.sort()
 310         self.download_node_config(','.join(real_node_ids))
 311
 312         self.download_config('settings')
 313         self.download_config('network')
 314
 315     def finale(self):
 316         log('DEA file is available at %s' % self.dea_file)
 317         log('DHA file is available at %s (this is just a template)'
 318             % self.dha_file)
 319         shutil.rmtree(self.temp_dir)
 320
 321     def reap(self):
 322         self.intro()
 323         self.reap_environment_info()
 324         self.reap_nodes_interfaces_transformations()
 325         self.reap_fuel_settings()
 326         self.reap_network_settings()
 327         self.reap_settings()
 328         self.finale()
 329
 330
 331 def usage():
 332     print '''
 333     Usage:
 334     python reap.py <dea_file> <dha_file> <comment>
 335     '''
 336
 337
 338 def parse_arguments():
 339     parser = ArgParser(prog='python %s' % __file__)
 340     parser.add_argument('dea_file', nargs='?', action='store',
 341                         default='dea.yaml',
 342                         help='Deployment Environment Adapter: dea.yaml')
 343     parser.add_argument('dha_file', nargs='?', action='store',
 344                         default='dha.yaml',
 345                         help='Deployment Hardware Adapter: dha.yaml')
 346     parser.add_argument('comment', nargs='?', action='store', help='Comment')
 347     args = parser.parse_args()
 348     return (args.dea_file, args.dha_file, args.comment)
 349
 350
 351 def main():
 352     dea_file, dha_file, comment = parse_arguments()
 353
 354     r = Reap(dea_file, dha_file, comment)
 355     r.reap()
 356
 357
 358 if __name__ == '__main__':
 359     main()