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