7 from types import StringTypes
10 from TestSite import TestSite
11 from TestNode import TestNode
12 from TestUser import TestUser
13 from TestKey import TestKey
15 # step methods must take (self, options) and return a boolean
19 def __init__ (self,plc_spec):
20 self.plc_spec=plc_spec
21 self.path=os.path.dirname(sys.argv[0])
23 self.vserverip=plc_spec['vserverip']
24 self.vservername=plc_spec['vservername']
25 self.url="https://%s:443/PLCAPI/"%plc_spec['vserverip']
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)
34 name=self.plc_spec['name']
36 return name+"[%s]"%self.vservername
38 return name+"[chroot]"
41 return self.plc_spec['hostname'] == 'localhost'
43 # define the API methods on this object through xmlrpc
44 # would help, but not strictly necessary
48 # build the full command so command gets run in the chroot/vserver
49 def run_command(self,command):
51 return "vserver %s exec %s"%(self.vservername,command)
53 return "chroot /plc/root %s"%command
55 def ssh_command(self,command):
59 return "ssh %s sh -c '\"%s\"'"%(self.plc_spec['hostname'],command)
61 def full_command(self,command):
62 return self.ssh_command(self.run_command(command))
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))
70 def run_in_guest_piped (self,local,remote):
71 return utils.system(local+" | "+self.full_command(remote))
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']
79 def locate_site (self,sitename):
80 for site in self.plc_spec['sites']:
81 if site['site_fields']['name'] == sitename:
83 if site['site_fields']['login_base'] == sitename:
85 raise Exception,"Cannot locate site %s"%sitename
87 def locate_key (self,keyname):
88 for key in self.plc_spec['keys']:
89 if key['name'] == keyname:
91 raise Exception,"Cannot locate key %s"%keyname
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')
100 #################### step methods
103 def uninstall_chroot(self,options):
104 self.run_in_host('service plc safestop')
105 #####detecting the last myplc version installed and remove it
106 self.run_in_host('rpm -e myplc')
107 ##### Clean up the /plc directory
108 self.run_in_host('rm -rf /plc/data')
111 def uninstall_vserver(self,options):
112 self.run_in_host("vserver --silent %s delete"%self.vservername)
115 def uninstall(self,options):
117 return self.uninstall_vserver(options)
119 return self.uninstall_chroot(options)
122 def install_chroot(self,options):
126 # xxx this would not work with hostname != localhost as mylc-init-vserver was extracted locally
127 def install_vserver(self,options):
128 # we need build dir for vtest-init-vserver
130 # a full path for the local calls
131 build_dir=self.path+"/build"
133 # use a standard name - will be relative to HOME
134 build_dir="tests-system-build"
135 build_checkout = "svn checkout %s %s"%(options.build_url,build_dir)
136 if self.run_in_host(build_checkout) != 0:
137 raise Exception,"Cannot checkout build dir"
138 # the repo url is taken from myplc-url
139 # with the last two steps (i386/myplc...) removed
140 repo_url = options.myplc_url
141 repo_url = os.path.dirname(repo_url)
142 repo_url = os.path.dirname(repo_url)
143 create_vserver="%s/vtest-init-vserver.sh %s %s -- --interface eth0:%s"%\
144 (build_dir,self.vservername,repo_url,self.vserverip)
145 if self.run_in_host(create_vserver) != 0:
146 raise Exception,"Could not create vserver for %s"%self.vservername
149 def install(self,options):
151 return self.install_vserver(options)
153 return self.install_chroot(options)
156 def install_rpm_chroot(self,options):
157 utils.header('Installing from %s'%options.myplc_url)
158 url=options.myplc_url
159 self.run_in_host('rpm -Uvh '+url)
160 self.run_in_host('service plc mount')
163 def install_rpm_vserver(self,options):
164 self.run_in_guest("yum -y install myplc-native")
167 def install_rpm(self,options):
169 return self.install_rpm_vserver(options)
171 return self.install_rpm_chroot(options)
174 def configure(self,options):
175 tmpname='%s/%s.plc-config-tty'%(options.path,self.name())
176 fileconf=open(tmpname,'w')
177 for var in [ 'PLC_NAME',
181 'PLC_MAIL_SUPPORT_ADDRESS',
188 fileconf.write ('e %s\n%s\n'%(var,self.plc_spec[var]))
189 fileconf.write('w\n')
190 fileconf.write('q\n')
192 utils.system('cat %s'%tmpname)
193 self.run_in_guest_piped('cat %s'%tmpname,'plc-config-tty')
194 utils.system('rm %s'%tmpname)
197 # the chroot install is slightly different to this respect
198 def start(self, options):
200 self.run_in_guest('service plc start')
202 self.run_in_host('service plc start')
205 def stop(self, options):
207 self.run_in_guest('service plc stop')
209 self.run_in_host('service plc stop')
212 # could use a TestKey class
213 def store_keys(self, options):
214 for key_spec in self.plc_spec['keys']:
215 TestKey(self,key_spec).store_key()
218 def clean_keys(self, options):
219 utils.system("rm -rf %s/keys/"%self.path)
221 def sites (self,options):
222 return self.do_sites(options)
224 def clean_sites (self,options):
225 return self.do_sites(options,action="delete")
227 def do_sites (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 site %s in %s"%(test_site.name(),self.name()))
232 test_site.delete_site()
233 # deleted with the site
234 #test_site.delete_users()
237 utils.header("Creating site %s & users in %s"%(test_site.name(),self.name()))
238 test_site.create_site()
239 test_site.create_users()
242 def nodes (self, options):
243 return self.do_nodes(options)
244 def clean_nodes (self, options):
245 return self.do_nodes(options,action="delete")
247 def do_nodes (self, options,action="add"):
248 for site_spec in self.plc_spec['sites']:
249 test_site = TestSite (self,site_spec)
251 utils.header("Deleting nodes in site %s"%test_site.name())
252 for node_spec in site_spec['nodes']:
253 test_node=TestNode(self,test_site,node_spec)
254 utils.header("Deleting %s"%test_node.name())
255 test_node.delete_node()
257 utils.header("Creating nodes for site %s in %s"%(test_site.name(),self.name()))
258 for node_spec in site_spec['nodes']:
259 utils.show_spec('Creating node %s'%node_spec,node_spec)
260 test_node = TestNode (self,test_site,node_spec)
261 test_node.create_node ()
264 # create nodegroups if needed, and populate
265 # no need for a clean_nodegroups if we are careful enough
266 def nodegroups (self, options):
267 # 1st pass to scan contents
269 for site_spec in self.plc_spec['sites']:
270 test_site = TestSite (self,site_spec)
271 for node_spec in site_spec['nodes']:
272 test_node=TestNode (self,test_site,node_spec)
273 if node_spec.has_key('nodegroups'):
274 nodegroupnames=node_spec['nodegroups']
275 if isinstance(nodegroupnames,StringTypes):
276 nodegroupnames = [ nodegroupnames ]
277 for nodegroupname in nodegroupnames:
278 if not groups_dict.has_key(nodegroupname):
279 groups_dict[nodegroupname]=[]
280 groups_dict[nodegroupname].append(test_node.name())
281 auth=self.auth_root()
282 for (nodegroupname,group_nodes) in groups_dict.iteritems():
284 self.server.GetNodeGroups(auth,{'name':nodegroupname})[0]
286 self.server.AddNodeGroup(auth,{'name':nodegroupname})
287 for node in group_nodes:
288 self.server.AddNodeToNodeGroup(auth,node,nodegroupname)
291 def bootcd (self, options):
292 for site_spec in self.plc_spec['sites']:
293 test_site = TestSite (self,site_spec)
294 for node_spec in site_spec['nodes']:
295 test_node=TestNode (self,test_site,node_spec)
296 test_node.create_boot_cd(options.path)
299 def initscripts (self, options):
300 for initscript in self.plc_spec['initscripts']:
301 utils.show_spec('Adding Initscript in plc %s'%self.plc_spec['name'],initscript)
302 self.server.AddInitScript(self.auth_root(),initscript['initscript_fields'])
305 def slices (self, options):
306 return self.do_slices()
308 def clean_slices (self, options):
309 return self.do_slices("delete")
311 ### would need a TestSlice class
312 def do_slices (self, add_or_delete="add"):
313 for slice in self.plc_spec['slices']:
314 site_spec = self.locate_site (slice['sitename'])
315 test_site = TestSite(self,site_spec)
316 owner_spec = test_site.locate_user(slice['owner'])
317 auth = TestUser(self,test_site,owner_spec).auth()
318 slice_fields = slice['slice_fields']
319 slice_name = slice_fields['name']
320 if (add_or_delete == "delete"):
321 self.server.DeleteSlice(auth,slice_fields['name'])
322 utils.header("Deleted slice %s"%slice_fields['name'])
324 utils.show_spec("Creating slice",slice_fields)
325 self.server.AddSlice(auth,slice_fields)
326 utils.header('Created Slice %s'%slice_fields['name'])
327 for username in slice['usernames']:
328 user_spec=test_site.locate_user(username)
329 test_user=TestUser(self,test_site,user_spec)
330 self.server.AddPersonToSlice(auth, test_user.name(), slice_name)
333 for nodename in slice['nodenames']:
334 node_spec=test_site.locate_node(nodename)
335 test_node=TestNode(self,test_site,node_spec)
336 hostnames += [test_node.name()]
337 utils.header("Adding %r in %s"%(hostnames,slice_name))
338 self.server.AddSliceToNodes(auth, slice_name, hostnames)
339 if slice.has_key('initscriptname'):
340 isname=slice['initscriptname']
341 utils.header("Adding initscript %s in %s"%(isname,slice_name))
342 self.server.AddSliceAttribute(self.auth_root(), slice_name,
346 def start_nodes (self, options):
347 self.kill_all_vmwares()
348 utils.header("Starting vmware nodes")
349 for site_spec in self.plc_spec['sites']:
350 TestSite(self,site_spec).start_nodes (options)
353 def stop_nodes (self, options):
354 self.kill_all_vmwares ()
357 # returns the filename to use for sql dump/restore, using options.dbname if set
358 def dbfile (self, database, options):
359 # uses options.dbname if it is found
362 if not isinstance(name,StringTypes):
365 t=datetime.datetime.now()
368 return "/root/%s-%s.sql"%(database,name)
370 def db_dump(self, options):
372 dump=self.dbfile("planetab4",options)
373 self.run_in_guest('pg_dump -U pgsqluser planetlab4 -f '+ dump)
374 utils.header('Dumped planetlab4 database in %s'%dump)
377 def db_restore(self, options):
378 dump=self.dbfile("planetab4",options)
380 self.run_in_guest('service httpd stop')
381 # xxx - need another wrapper
382 self.run_in_guest_piped('echo drop database planetlab4','psql --user=pgsqluser template1')
383 self.run_in_guest('createdb -U postgres --encoding=UNICODE --owner=pgsqluser planetlab4')
384 self.run_in_guest('psql -U pgsqluser planetlab4 -f '+dump)
385 ##starting httpd service
386 self.run_in_guest('service httpd start')
388 utils.header('Database restored from ' + dump)