system/TestResources.py

   1 # Thierry Parmentelat <thierry.parmentelat@inria.fr>
   2 # Copyright (C) 2010 INRIA
   3 #
   4 import sys
   5 import traceback
   6
   7 import utils
   8 from TestMapper import TestMapper
   9 from TestPool import TestPoolQemu, TestPoolIP
  10 from Trackers import TrackerPlc, TrackerQemu
  11
  12 class TestResources:
  13
  14     # need more specialization, see an example in OnelabTestResources
  15
  16     ##########
  17     def localize (self,plcs,options):
  18         try:
  19             plcs = self.localize_qemus(plcs,options)
  20         except Exception, e:
  21             print '* Could not localize qemus','--',e,'--','exiting'
  22             traceback.print_exc()
  23             sys.exit(1)
  24         try:
  25             plcs = self.localize_nodes(plcs,options)
  26         except Exception,e:
  27             print '* Could not localize nodes','--',e,'--','exiting'
  28             sys.exit(1)
  29         try:
  30             plcs = self.localize_plcs(plcs,options)
  31         except Exception,e:
  32             print '* Could not localize plcs','--',e,'--','exiting'
  33             sys.exit(1)
  34         try:
  35             plcs = self.localize_rspec(plcs,options)
  36         except Exception,e:
  37             print '* Could not localize RSpec','--',e,'--','exiting'
  38             sys.exit(1)
  39         return plcs
  40
  41     def localize_qemus (self,plcs,options):
  42
  43         # all plcs on the same vserver box
  44         plc_box = self.plc_boxes()[0]
  45
  46         # informative
  47         label=options.personality.replace("linux","")
  48
  49         node_map = []
  50         qemu_pool = TestPoolQemu (self.qemus_ip_pool(), options)
  51
  52         for index in range(options.size):
  53             index += 1
  54             if options.ips_qemu:
  55                 ip_or_hostname=options.ips_qemu.pop()
  56                 (hostname,ip,unused)=qemu_pool.locate_entry(ip_or_hostname)
  57             else:
  58                 tracker=TrackerQemu(options,instances=self.max_qemus()-1)
  59                 (hostname,ip,unused) = qemu_pool.next_free(tracker.hostnames())
  60
  61             node_map += [ ('node%d'%index, {'host_box':hostname},) ]
  62
  63         mapper = {'plc': [ ('*' , {'hostname':plc_box,
  64                                    'PLC_DB_HOST':plc_box,
  65                                    'PLC_API_HOST':plc_box,
  66                                    'PLC_BOOT_HOST':plc_box,
  67                                    'PLC_WWW_HOST':plc_box,
  68                                    'name':'%s-'+label } )
  69                            ],
  70                   'node': node_map,
  71                   }
  72
  73         return TestMapper(plcs,options).map(mapper)
  74
  75
  76     def localize_nodes (self, plcs, options):
  77
  78         ip_pool = TestPoolIP (self.nodes_ip_pool(),options)
  79         network_dict = self.network_dict()
  80
  81         test_mapper = TestMapper (plcs, options)
  82
  83         all_nodenames = test_mapper.node_names()
  84         maps = []
  85         for nodename in all_nodenames:
  86             if options.ips_node:
  87                 ip_or_hostname=options.ips_node.pop()
  88                 (hostname,ip,mac)=ip_pool.locate_entry(ip_or_hostname)
  89             else:
  90                 tracker=TrackerQemu(options,instances=self.max_qemus()-1)
  91                 (hostname,ip,mac) = ip_pool.next_free(tracker.nodenames())
  92             utils.header('Attaching node %s to %s (%s)'%(nodename,hostname,ip))
  93             node_dict= {'node_fields:hostname':hostname,
  94                         'interface_fields:ip':ip,
  95                         'interface_fields:mac':mac,
  96                         }
  97
  98             node_dict.update(network_dict)
  99             maps.append ( ( nodename, node_dict) )
 100
 101         plc_map = [ ( '*' , { 'PLC_NET_DNS1' : network_dict [ 'interface_fields:dns1' ],
 102                               'PLC_NET_DNS2' : network_dict [ 'interface_fields:dns2' ], } ) ]
 103
 104         return test_mapper.map ({'node': maps, 'plc' : plc_map } )
 105
 106
 107     def localize_plcs (self,plcs,options):
 108
 109         ip_pool = TestPoolIP (self.plcs_ip_pool(),options)
 110
 111         plc_counter=0
 112         for plc in plcs:
 113             if options.ips_plc :
 114                 ip_or_hostname=options.ips_plc.pop()
 115                 (hostname,ip,mac)=ip_pool.locate_entry(ip_or_hostname)
 116                 if options.verbose:
 117                     utils.header("Using user-provided %s %s for plc %s"%(
 118                             hostname,ip_or_hostname,plc['name']))
 119             else:
 120                 tracker = TrackerPlc(options,instances=self.max_plcs())
 121                 (hostname,ip,mac)=ip_pool.next_free(tracker.plcnames())
 122                 if options.verbose:
 123                     utils.header("Using auto-allocated %s %s for plc %s"%(
 124                             hostname,ip,plc['name']))
 125
 126             ### rewrite fields in plc
 127             # compute a helpful vserver name - remove domain in hostname
 128             simplehostname = hostname.split('.')[0]
 129             preferred_hostname = self.preferred_hostname()
 130             vservername = options.buildname
 131             if len(plcs) == 1 :
 132                 vservername = "%s-%s" % (vservername,simplehostname)
 133                 #ugly hack for "vuname: vc_set_vhi_name(): Arg list too long" errors
 134                 if len(vservername) > 38 and preferred_hostname is not None:
 135                     vservername = "%s-%s" % (options.buildname,preferred_hostname)
 136             else:
 137                 plc_counter += 1
 138                 vservername = "%s-%d-%s" % (vservername,plc_counter,simplehostname)
 139                 #ugly hack for "vuname: vc_set_vhi_name(): Arg list too long" errors
 140                 if len(vservername) > 38 and preferred_hostname is not None:
 141                     vservername = "%s-%d-%s" % (options.buildname,plc_counter,preferred_hostname)
 142
 143             # apply
 144             plc['vservername']=vservername
 145             plc['vserverip']=ip
 146             plc['name'] = "%s_%s"%(plc['name'],simplehostname)
 147             utils.header("Attaching plc %s to vserver %s (%s)"%(
 148                     plc['name'],plc['vservername'],plc['vserverip']))
 149             for key in [ 'PLC_DB_HOST', 'PLC_API_HOST', 'PLC_WWW_HOST', 'PLC_BOOT_HOST',]:
 150                 plc[key] = hostname
 151
 152         return plcs
 153
 154     # as a plc step this should return a boolean
 155     def step_pre (self,plc):
 156         return self.trqemu_record (plc) and self.trqemu_make_space(plc) \
 157            and self.trplc_record (plc) and self.trplc_make_space(plc)
 158
 159     def step_post (self,plc):
 160         return True
 161
 162     def step_release (self,plc):
 163         return self.trqemu_release(plc) and self.trplc_release(plc)
 164
 165     def step_release_plc (self,plc):
 166         return self.trplc_release(plc)
 167
 168     def step_release_qemu (self,plc):
 169         return self.trqemu_release(plc)
 170
 171     def step_list (self,plc):
 172         return self.trqemu_list(plc) and self.trplc_list(plc)
 173
 174     ####################
 175     def trplc_record (self,plc):
 176         tracker = TrackerPlc(plc.options,instances=self.max_plcs())
 177         tracker.record(plc.test_ssh.hostname,plc.vservername)
 178         tracker.store()
 179         return True
 180
 181     def trplc_release (self,plc):
 182         tracker = TrackerPlc(plc.options,instances=self.max_plcs())
 183         tracker.release(plc.test_ssh.hostname,plc.vservername)
 184         tracker.store()
 185         return True
 186
 187     def trplc_make_space (self,plc):
 188         tracker = TrackerPlc(plc.options,instances=self.max_plcs())
 189         tracker.make_space()
 190         tracker.store()
 191         return True
 192
 193     def trplc_list (self,plc):
 194         TrackerPlc(plc.options,instances=self.max_plcs()).list()
 195         return True
 196
 197     ###
 198     def trqemu_record (self,plc):
 199         tracker=TrackerQemu(plc.options,instances=self.max_qemus()-1)
 200         for site_spec in plc.plc_spec['sites']:
 201             for node_spec in site_spec['nodes']:
 202                 tracker.record(node_spec['host_box'],plc.options.buildname,node_spec['node_fields']['hostname'])
 203         tracker.store()
 204         return True
 205
 206     def trqemu_release (self,plc):
 207         tracker=TrackerQemu(plc.options,instances=self.max_qemus()-1)
 208         for site_spec in plc.plc_spec['sites']:
 209             for node_spec in site_spec['nodes']:
 210                 tracker.release(node_spec['host_box'],plc.options.buildname,node_spec['node_fields']['hostname'])
 211         tracker.store()
 212         return True
 213
 214     def trqemu_make_space (self,plc):
 215         tracker=TrackerQemu(plc.options,instances=self.max_qemus()-1)
 216         for site_spec in plc.plc_spec['sites']:
 217             for node_spec in site_spec['nodes']:
 218                 tracker.make_space()
 219         tracker.store()
 220         return True
 221
 222     def trqemu_list (self,plc):
 223         TrackerQemu(plc.options,instances=self.max_qemus()-1).list()
 224         return True
 225
 226     ###
 227     def localize_rspec (self,plcs,options):
 228
 229         utils.header ("Localize SFA Slice RSpec")
 230
 231         for plc in plcs:
 232             for site in plc['sites']:
 233                 for node in site['nodes']:
 234                     plc['sfa']['sfa_slice_rspec']['part4'] = node['node_fields']['hostname']
 235             plc['sfa']['SFA_REGISTRY_HOST'] = plc['PLC_DB_HOST']
 236             plc['sfa']['SFA_AGGREGATE_HOST'] = plc['PLC_DB_HOST']
 237             plc['sfa']['SFA_SM_HOST'] = plc['PLC_DB_HOST']
 238             plc['sfa']['SFA_PLC_DB_HOST'] = plc['PLC_DB_HOST']
 239             plc['sfa']['SFA_PLC_URL'] = 'https://' + plc['PLC_API_HOST'] + ':443/PLCAPI/'
 240
 241         return plcs