system/TestResources.py

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