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