system/TestPlc.py

   1 # $Id$
   2 import os, os.path
   3 import sys
   4 import xmlrpclib
   5 import datetime
   6 import traceback
   7 from types import StringTypes
   8
   9 import utils
  10 from TestSite import TestSite
  11 from TestNode import TestNode
  12 from TestUser import TestUser
  13 from TestKey import TestKey
  14
  15 # step methods must take (self, options) and return a boolean
  16
  17 class TestPlc:
  18
  19     def __init__ (self,plc_spec):
  20         self.plc_spec=plc_spec
  21         self.path=os.path.dirname(sys.argv[0])
  22         try:
  23             self.vserverip=plc_spec['vserverip']
  24             self.vservername=plc_spec['vservername']
  25             self.url="https://%s:443/PLCAPI/"%plc_spec['vserverip']
  26             self.vserver=True
  27         except:
  28             self.vserver=False
  29             self.url="https://%s:443/PLCAPI/"%plc_spec['hostname']
  30         utils.header('Using API url %s'%self.url)
  31         self.server=xmlrpclib.Server(self.url,allow_none=True)
  32
  33     def name(self):
  34         name=self.plc_spec['name']
  35         if self.vserver:
  36             return name+"[%s]"%self.vservername
  37         else:
  38             return name+"[chroot]"
  39
  40     def is_local (self):
  41         return self.plc_spec['hostname'] == 'localhost'
  42
  43     # define the API methods on this object through xmlrpc
  44     # would help, but not strictly necessary
  45     def connect (self):
  46         pass
  47
  48     # build the full command so command gets run in the chroot/vserver
  49     def run_command(self,command):
  50         if self.vserver:
  51             return "vserver %s exec %s"%(self.vservername,command)
  52         else:
  53             return "chroot /plc/root %s"%command
  54
  55     def ssh_command(self,command):
  56         if self.is_local():
  57             return command
  58         else:
  59             return "ssh %s sh -c '\"%s\"'"%(self.plc_spec['hostname'],command)
  60
  61     def full_command(self,command):
  62         return self.ssh_command(self.run_command(command))
  63
  64     def run_in_guest (self,command):
  65         return utils.system(self.full_command(command))
  66     def run_in_host (self,command):
  67         return utils.system(self.ssh_command(command))
  68
  69     # xxx quick n dirty
  70     def run_in_guest_piped (self,local,remote):
  71         return utils.system(local+" | "+self.full_command(remote))
  72
  73     def auth_root (self):
  74         return {'Username':self.plc_spec['PLC_ROOT_USER'],
  75                 'AuthMethod':'password',
  76                 'AuthString':self.plc_spec['PLC_ROOT_PASSWORD'],
  77                 'Role' : self.plc_spec['role']
  78                 }
  79     def locate_site (self,sitename):
  80         for site in self.plc_spec['sites']:
  81             if site['site_fields']['name'] == sitename:
  82                 return site
  83             if site['site_fields']['login_base'] == sitename:
  84                 return site
  85         raise Exception,"Cannot locate site %s"%sitename
  86
  87     def locate_key (self,keyname):
  88         for key in self.plc_spec['keys']:
  89             if key['name'] == keyname:
  90                 return key
  91         raise Exception,"Cannot locate key %s"%keyname
  92
  93     def kill_all_vmwares(self):
  94         utils.header('Killing any running vmware or vmplayer instance')
  95         utils.system('pgrep vmware | xargs -r kill')
  96         utils.system('pgrep vmplayer | xargs -r kill ')
  97         utils.system('pgrep vmware | xargs -r kill -9')
  98         utils.system('pgrep vmplayer | xargs -r kill -9')
  99
 100     def kill_all_qemus(self):
 101         for site_spec in self.plc_spec['sites']:
 102             test_site = TestSite (self,site_spec)
 103             for node_spec in site_spec['nodes']:
 104                 test_node=TestNode (self,test_site,node_spec)
 105                 model=node_spec['node_fields']['model']
 106                 host_machine=node_spec['node_fields']['host_machine']
 107                 hostname=node_spec['node_fields']['hostname']
 108                 print model
 109                 if model.find("qemu") >= 0:
 110                     utils.system('ssh root@%s  killall qemu'%host_machine)
 111                     test_node.stop_qemu(host_machine,hostname)
 112
 113     #################### step methods
 114
 115     ### uninstall
 116     def uninstall_chroot(self,options):
 117         self.run_in_host('service plc safestop')
 118         #####detecting the last myplc version installed and remove it
 119         self.run_in_host('rpm -e myplc')
 120         ##### Clean up the /plc directory
 121         self.run_in_host('rm -rf  /plc/data')
 122         return True
 123
 124     def uninstall_vserver(self,options):
 125         self.run_in_host("vserver --silent %s delete"%self.vservername)
 126         return True
 127
 128     def uninstall(self,options):
 129         if self.vserver:
 130             return self.uninstall_vserver(options)
 131         else:
 132             return self.uninstall_chroot(options)
 133
 134     ### install
 135     def install_chroot(self,options):
 136         # nothing to do
 137         return True
 138
 139     # xxx this would not work with hostname != localhost as mylc-init-vserver was extracted locally
 140     def install_vserver(self,options):
 141         # we need build dir for vtest-init-vserver
 142         if self.is_local():
 143             # a full path for the local calls
 144             build_dir=self.path+"/build"
 145         else:
 146             # use a standard name - will be relative to HOME
 147             build_dir="tests-system-build"
 148         build_checkout = "svn checkout %s %s"%(options.build_url,build_dir)
 149         if self.run_in_host(build_checkout) != 0:
 150             raise Exception,"Cannot checkout build dir"
 151         # the repo url is taken from myplc-url
 152         # with the last two steps (i386/myplc...) removed
 153         repo_url = options.myplc_url
 154         repo_url = os.path.dirname(repo_url)
 155         repo_url = os.path.dirname(repo_url)
 156         create_vserver="%s/vtest-init-vserver.sh %s %s -- --interface eth0:%s"%\
 157             (build_dir,self.vservername,repo_url,self.vserverip)
 158         if self.run_in_host(create_vserver) != 0:
 159             raise Exception,"Could not create vserver for %s"%self.vservername
 160         return True
 161
 162     def install(self,options):
 163         if self.vserver:
 164             return self.install_vserver(options)
 165         else:
 166             return self.install_chroot(options)
 167
 168     ### install_rpm
 169     def install_rpm_chroot(self,options):
 170         utils.header('Installing from %s'%options.myplc_url)
 171         url=options.myplc_url
 172         self.run_in_host('rpm -Uvh '+url)
 173         self.run_in_host('service plc mount')
 174         return True
 175
 176     def install_rpm_vserver(self,options):
 177         self.run_in_guest("yum -y install myplc-native")
 178         return True
 179
 180     def install_rpm(self,options):
 181         if self.vserver:
 182             return self.install_rpm_vserver(options)
 183         else:
 184             return self.install_rpm_chroot(options)
 185
 186     ###
 187     def configure(self,options):
 188         tmpname='%s/%s.plc-config-tty'%(options.path,self.name())
 189         fileconf=open(tmpname,'w')
 190         for var in [ 'PLC_NAME',
 191                      'PLC_ROOT_PASSWORD',
 192                      'PLC_ROOT_USER',
 193                      'PLC_MAIL_ENABLED',
 194                      'PLC_MAIL_SUPPORT_ADDRESS',
 195                      'PLC_DB_HOST',
 196                      'PLC_API_HOST',
 197                      'PLC_WWW_HOST',
 198                      'PLC_BOOT_HOST',
 199                      'PLC_NET_DNS1',
 200                      'PLC_NET_DNS2']:
 201             fileconf.write ('e %s\n%s\n'%(var,self.plc_spec[var]))
 202         fileconf.write('w\n')
 203         fileconf.write('q\n')
 204         fileconf.close()
 205         utils.system('cat %s'%tmpname)
 206         self.run_in_guest_piped('cat %s'%tmpname,'plc-config-tty')
 207         utils.system('rm %s'%tmpname)
 208         return True
 209
 210     # the chroot install is slightly different to this respect
 211     def start(self, options):
 212         if self.vserver:
 213             self.run_in_guest('service plc start')
 214         else:
 215             self.run_in_host('service plc start')
 216         return True
 217
 218     def stop(self, options):
 219         if self.vserver:
 220             self.run_in_guest('service plc stop')
 221         else:
 222             self.run_in_host('service plc stop')
 223         return True
 224
 225     # could use a TestKey class
 226     def store_keys(self, options):
 227         for key_spec in self.plc_spec['keys']:
 228             TestKey(self,key_spec).store_key()
 229         return True
 230
 231     def clean_keys(self, options):
 232         utils.system("rm -rf %s/keys/"%self.path)
 233
 234     def sites (self,options):
 235         return self.do_sites(options)
 236
 237     def clean_sites (self,options):
 238         return self.do_sites(options,action="delete")
 239
 240     def do_sites (self,options,action="add"):
 241         for site_spec in self.plc_spec['sites']:
 242             test_site = TestSite (self,site_spec)
 243             if (action != "add"):
 244                 utils.header("Deleting site %s in %s"%(test_site.name(),self.name()))
 245                 test_site.delete_site()
 246                 # deleted with the site
 247                 #test_site.delete_users()
 248                 continue
 249             else:
 250                 utils.header("Creating site %s & users in %s"%(test_site.name(),self.name()))
 251                 test_site.create_site()
 252                 test_site.create_users()
 253         return True
 254
 255     def nodes (self, options):
 256         return self.do_nodes(options)
 257     def clean_nodes (self, options):
 258         return self.do_nodes(options,action="delete")
 259
 260     def do_nodes (self, options,action="add"):
 261         for site_spec in self.plc_spec['sites']:
 262             test_site = TestSite (self,site_spec)
 263             if action != "add":
 264                 utils.header("Deleting nodes in site %s"%test_site.name())
 265                 for node_spec in site_spec['nodes']:
 266                     test_node=TestNode(self,test_site,node_spec)
 267                     utils.header("Deleting %s"%test_node.name())
 268                     test_node.delete_node()
 269             else:
 270                 utils.header("Creating nodes for site %s in %s"%(test_site.name(),self.name()))
 271                 for node_spec in site_spec['nodes']:
 272                     utils.show_spec('Creating node %s'%node_spec,node_spec)
 273                     test_node = TestNode (self,test_site,node_spec)
 274                     test_node.create_node ()
 275         return True
 276
 277     # create nodegroups if needed, and populate
 278     # no need for a clean_nodegroups if we are careful enough
 279     def nodegroups (self, options):
 280         # 1st pass to scan contents
 281         groups_dict = {}
 282         for site_spec in self.plc_spec['sites']:
 283             test_site = TestSite (self,site_spec)
 284             for node_spec in site_spec['nodes']:
 285                 test_node=TestNode (self,test_site,node_spec)
 286                 if node_spec.has_key('nodegroups'):
 287                     nodegroupnames=node_spec['nodegroups']
 288                     if isinstance(nodegroupnames,StringTypes):
 289                         nodegroupnames = [ nodegroupnames ]
 290                     for nodegroupname in nodegroupnames:
 291                         if not groups_dict.has_key(nodegroupname):
 292                             groups_dict[nodegroupname]=[]
 293                         groups_dict[nodegroupname].append(test_node.name())
 294         auth=self.auth_root()
 295         for (nodegroupname,group_nodes) in groups_dict.iteritems():
 296             try:
 297                 self.server.GetNodeGroups(auth,{'name':nodegroupname})[0]
 298             except:
 299                 self.server.AddNodeGroup(auth,{'name':nodegroupname})
 300             for node in group_nodes:
 301                 self.server.AddNodeToNodeGroup(auth,node,nodegroupname)
 302         return True
 303
 304     def bootcd (self, options):
 305         for site_spec in self.plc_spec['sites']:
 306             test_site = TestSite (self,site_spec)
 307             for node_spec in site_spec['nodes']:
 308                 test_node=TestNode (self,test_site,node_spec)
 309                 test_node.create_boot_cd(options.path)
 310         return True
 311
 312     def initscripts (self, options):
 313         for initscript in self.plc_spec['initscripts']:
 314             utils.show_spec('Adding Initscript in plc %s'%self.plc_spec['name'],initscript)
 315             self.server.AddInitScript(self.auth_root(),initscript['initscript_fields'])
 316         return True
 317
 318     def slices (self, options):
 319         return self.do_slices()
 320
 321     def clean_slices (self, options):
 322         return self.do_slices("delete")
 323
 324     ### would need a TestSlice class
 325     def do_slices (self, add_or_delete="add"):
 326         for slice in self.plc_spec['slices']:
 327             site_spec = self.locate_site (slice['sitename'])
 328             test_site = TestSite(self,site_spec)
 329             owner_spec = test_site.locate_user(slice['owner'])
 330             auth = TestUser(self,test_site,owner_spec).auth()
 331             slice_fields = slice['slice_fields']
 332             slice_name = slice_fields['name']
 333             if (add_or_delete == "delete"):
 334                 self.server.DeleteSlice(auth,slice_fields['name'])
 335                 utils.header("Deleted slice %s"%slice_fields['name'])
 336                 continue
 337             utils.show_spec("Creating slice",slice_fields)
 338             self.server.AddSlice(auth,slice_fields)
 339             utils.header('Created Slice %s'%slice_fields['name'])
 340             for username in slice['usernames']:
 341                 user_spec=test_site.locate_user(username)
 342                 test_user=TestUser(self,test_site,user_spec)
 343                 self.server.AddPersonToSlice(auth, test_user.name(), slice_name)
 344
 345             hostnames=[]
 346             for nodename in slice['nodenames']:
 347                 node_spec=test_site.locate_node(nodename)
 348                 test_node=TestNode(self,test_site,node_spec)
 349                 hostnames += [test_node.name()]
 350             utils.header("Adding %r in %s"%(hostnames,slice_name))
 351             self.server.AddSliceToNodes(auth, slice_name, hostnames)
 352             if slice.has_key('initscriptname'):
 353                 isname=slice['initscriptname']
 354                 utils.header("Adding initscript %s in %s"%(isname,slice_name))
 355                 self.server.AddSliceAttribute(self.auth_root(), slice_name,
 356                                               'initscript',isname)
 357         return True
 358
 359     def start_nodes (self, options):
 360         self.kill_all_vmwares()
 361         self.kill_all_qemus()
 362         utils.header("Starting vmware nodes")
 363         for site_spec in self.plc_spec['sites']:
 364             TestSite(self,site_spec).start_nodes (options)
 365         return True
 366
 367     def stop_nodes (self, options):
 368         self.kill_all_vmwares ()
 369         self.kill_all_qemus()
 370         return True
 371
 372     # returns the filename to use for sql dump/restore, using options.dbname if set
 373     def dbfile (self, database, options):
 374         # uses options.dbname if it is found
 375         try:
 376             name=options.dbname
 377             if not isinstance(name,StringTypes):
 378                 raise Exception
 379         except:
 380             t=datetime.datetime.now()
 381             d=t.date()
 382             name=str(d)
 383         return "/root/%s-%s.sql"%(database,name)
 384
 385     def db_dump(self, options):
 386
 387         dump=self.dbfile("planetab4",options)
 388         self.run_in_guest('pg_dump -U pgsqluser planetlab4 -f '+ dump)
 389         utils.header('Dumped planetlab4 database in %s'%dump)
 390         return True
 391
 392     def db_restore(self, options):
 393         dump=self.dbfile("planetab4",options)
 394         ##stop httpd service
 395         self.run_in_guest('service httpd stop')
 396         # xxx - need another wrapper
 397         self.run_in_guest_piped('echo drop database planetlab4','psql --user=pgsqluser template1')
 398         self.run_in_guest('createdb -U postgres --encoding=UNICODE --owner=pgsqluser planetlab4')
 399         self.run_in_guest('psql -U pgsqluser planetlab4 -f '+dump)
 400         ##starting httpd service
 401         self.run_in_guest('service httpd start')
 402
 403         utils.header('Database restored from ' + dump)