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