Whamcloud - gitweb
Branch: HEAD
[fs/lustre-release.git] / lustre / utils / lconf
1 #!/usr/bin/env python
2 #
3 #  Copyright (C) 2002-2003 Cluster File Systems, Inc.
4 #   Authors: Robert Read <rread@clusterfs.com>
5 #            Mike Shaver <shaver@clusterfs.com>
6 #   This file is part of Lustre, http://www.lustre.org.
7 #
8 #   Lustre is free software; you can redistribute it and/or
9 #   modify it under the terms of version 2 of the GNU General Public
10 #   License as published by the Free Software Foundation.
11 #
12 #   Lustre is distributed in the hope that it will be useful,
13 #   but WITHOUT ANY WARRANTY; without even the implied warranty of
14 #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 #   GNU General Public License for more details.
16 #
17 #   You should have received a copy of the GNU General Public License
18 #   along with Lustre; if not, write to the Free Software
19 #   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 #
21 # lconf - lustre configuration tool
22 #
23 # lconf is the main driver script for starting and stopping
24 # lustre filesystem services.
25 #
26 # Based in part on the XML obdctl modifications done by Brian Behlendorf 
27
28 import sys, getopt, types
29 import string, os, stat, popen2, socket, time, random, fcntl, select
30 import re, exceptions, signal, traceback
31 import xml.dom.minidom
32
33 if sys.version[0] == '1':
34     from FCNTL import F_GETFL, F_SETFL
35 else:
36     from fcntl import F_GETFL, F_SETFL
37
38 PYMOD_DIR = "/usr/lib/lustre/python"
39
40 def development_mode():
41     base = os.path.dirname(sys.argv[0])
42     if os.access(base+"/Makefile", os.R_OK):
43         return 1
44     return 0
45
46 if development_mode():
47     sys.path.append('../utils')
48 else:
49     sys.path.append(PYMOD_DIR)
50
51 import Lustre
52
53 # Global parameters
54 MAXTCPBUF = 16777216
55 DEFAULT_TCPBUF = 8388608
56 DEFAULT_PORT = 988
57 #
58 # Maximum number of devices to search for.
59 # (the /dev/loop* nodes need to be created beforehand)
60 MAX_LOOP_DEVICES = 256
61 PORTALS_DIR = '../portals'
62
63 # Needed to call lconf --record
64 CONFIG_FILE = "" 
65
66 # Please keep these in sync with the values in portals/kp30.h
67 ptldebug_names = { 
68     "trace" :     (1 << 0),
69     "inode" :     (1 << 1),
70     "super" :     (1 << 2),
71     "ext2" :      (1 << 3),
72     "malloc" :    (1 << 4),
73     "cache" :     (1 << 5),
74     "info" :      (1 << 6),
75     "ioctl" :     (1 << 7),
76     "blocks" :    (1 << 8),
77     "net" :       (1 << 9),
78     "warning" :   (1 << 10),
79     "buffs" :     (1 << 11),
80     "other" :     (1 << 12),
81     "dentry" :    (1 << 13),
82     "portals" :   (1 << 14),
83     "page" :      (1 << 15),
84     "dlmtrace" :  (1 << 16),
85     "error" :     (1 << 17),
86     "emerg" :     (1 << 18),
87     "ha" :        (1 << 19),
88     "rpctrace" :  (1 << 20),
89     "vfstrace" :  (1 << 21),
90     "reada" :     (1 << 22),
91     "mmap" :      (1 << 23),
92     "config" :    (1 << 24),
93     "console" :   (1 << 25),
94     "quota" :     (1 << 26),
95     "sec" :       (1 << 27),
96 }
97
98 subsystem_names = {
99     "undefined" :    (1 << 0),
100     "mdc" :          (1 << 1),
101     "mds" :          (1 << 2),
102     "osc" :          (1 << 3),
103     "ost" :          (1 << 4),
104     "class" :        (1 << 5),
105     "log" :          (1 << 6),
106     "llite" :        (1 << 7),
107     "rpc" :          (1 << 8),
108     "mgmt" :         (1 << 9),
109     "portals" :      (1 << 10),
110     "nal" :          (1 << 11),
111     "pinger" :       (1 << 12),
112     "filter" :       (1 << 13),
113     "ptlbd" :        (1 << 14),
114     "echo" :         (1 << 15),
115     "ldlm" :         (1 << 16),
116     "lov" :          (1 << 17),
117     "ptlrouter" :    (1 << 18),
118     "cobd" :         (1 << 19),
119     "sm" :           (1 << 20),
120     "asobd" :        (1 << 21),
121     "confobd" :      (1 << 22),
122     "lmv" :          (1 << 23),
123     "cmobd" :        (1 << 24),
124     "sec" :          (1 << 25),
125     }
126
127
128 first_cleanup_error = 0
129 def cleanup_error(rc):
130     global first_cleanup_error
131     if not first_cleanup_error:
132         first_cleanup_error = rc
133
134 # ============================================================ 
135 # debugging and error funcs
136
137 def fixme(msg = "this feature"):
138     raise Lustre.LconfError, msg + ' not implemented yet.'
139
140 def panic(*args):
141     msg = string.join(map(str,args))
142     if not config.noexec:
143         raise Lustre.LconfError(msg)
144     else:
145         print "! " + msg
146
147 def log(*args):
148     msg = string.join(map(str,args))
149     print msg
150
151 def logall(msgs):
152     for s in msgs:
153         print string.strip(s)
154
155 def debug(*args):
156     if config.verbose:
157         msg = string.join(map(str,args))
158         print msg
159
160 # ack, python's builtin int() does not support '0x123' syntax.
161 # eval can do it, although what a hack!
162 def my_int(s):
163     try:
164         if s[0:2] == '0x':
165             return eval(s, {}, {})
166         else:
167             return int(s)
168     except SyntaxError, e:
169         raise ValueError("not a number")
170     except NameError, e:
171         raise ValueError("not a number")
172
173 # ============================================================
174 # locally defined exceptions
175 class CommandError (exceptions.Exception):
176     def __init__(self, cmd_name, cmd_err, rc=None):
177         self.cmd_name = cmd_name
178         self.cmd_err = cmd_err
179         self.rc = rc
180
181     def dump(self):
182         import types
183         if type(self.cmd_err) == types.StringType:
184             if self.rc:
185                 print "! %s (%d): %s" % (self.cmd_name, self.rc, self.cmd_err)
186             else:
187                 print "! %s: %s" % (self.cmd_name, self.cmd_err)
188         elif type(self.cmd_err) == types.ListType:
189             if self.rc:
190                 print "! %s (error %d):" % (self.cmd_name, self.rc)
191             else:
192                 print "! %s:" % (self.cmd_name)
193             for s in self.cmd_err:
194                 print "> %s" %(string.strip(s))
195         else:
196             print self.cmd_err
197
198
199 # ============================================================
200 # handle daemons, like the acceptor
201 class DaemonHandler:
202     """ Manage starting and stopping a daemon. Assumes daemon manages
203     it's own pid file. """
204
205     def __init__(self, cmd):
206         self.command = cmd
207         self.path =""
208
209     def start(self):
210         if self.running():
211             log(self.command, "already running.")
212         if not self.path:
213             self.path = find_prog(self.command)
214             if not self.path:
215                 panic(self.command, "not found.")
216         ret, out = runcmd(self.path +' '+ self.command_line())
217         if ret:
218             raise CommandError(self.path, out, ret)
219
220     def stop(self):
221         if self.running():
222             pid = self.read_pidfile()
223             try:
224                 if pid != 1:
225                     log ("killing process", pid)
226                     os.kill(pid, 15)
227                 else:
228                     log("was unable to find pid of " + self.command)
229                 #time.sleep(1) # let daemon die
230             except OSError, e:
231                 log("unable to kill", self.command, e)
232             if self.running():
233                 log("unable to kill", self.command)
234
235     def running(self):
236         pid = self.read_pidfile()
237         if pid:
238             try:
239                 if pid != 1:
240                     os.kill(pid, 0)
241                 else:
242                     log("was unable to find pid of " + self.command)
243             except OSError:
244                 self.clean_pidfile()
245             else:
246                 return 1
247         return 0
248
249     def read_pidfile(self):
250         try:
251             fp = open(self.pidfile(), 'r')
252             val = fp.read()
253             if val == '':
254                 val = '1'
255             pid = int(val)
256             fp.close()
257             return pid
258         except IOError:
259             return 0
260         
261     def clean_pidfile(self):
262         """ Remove a stale pidfile """
263         log("removing stale pidfile:", self.pidfile())
264         try:
265             os.unlink(self.pidfile())
266         except OSError, e:
267             log(self.pidfile(), e)
268             
269 class AcceptorHandler(DaemonHandler):
270     def __init__(self, port, net_type):
271         DaemonHandler.__init__(self, "acceptor")
272         self.port = port
273         self.flags = ''
274
275     def pidfile(self):
276         return "/var/run/%s-%d.pid" % (self.command, self.port)
277
278     def command_line(self):
279         return string.join(map(str,(self.flags, self.port)))
280     
281 acceptors = {}
282
283 # start the acceptors
284 def run_acceptors():
285     if config.lctl_dump or config.record:
286         return
287     for port in acceptors.keys():
288         daemon = acceptors[port]
289         if not daemon.running():
290             daemon.start()
291
292 def run_one_acceptor(port):
293     if config.lctl_dump or config.record:
294         return
295     if acceptors.has_key(port):
296         daemon = acceptors[port]
297         if not daemon.running():
298             daemon.start()
299     else:
300          panic("run_one_acceptor: No acceptor defined for port:", port)   
301         
302 def stop_acceptor(port):
303     if acceptors.has_key(port):
304         daemon = acceptors[port]
305         if daemon.running():
306             daemon.stop()
307         
308
309 # ============================================================
310 # handle lctl interface
311 class LCTLInterface:
312     """
313     Manage communication with lctl
314     """
315
316     def __init__(self, cmd):
317         """
318         Initialize close by finding the lctl binary.
319         """
320         self.lctl = find_prog(cmd)
321         self.save_file = ''
322         self.record_device = ''
323         if not self.lctl:
324             if config.noexec:
325                 debug('! lctl not found')
326                 self.lctl = 'lctl'
327             else:
328                 raise CommandError('lctl', "unable to find lctl binary.")
329
330     def use_save_file(self, file):
331         self.save_file = file
332         
333     def record(self, dev_name, logname):
334         log("Recording log", logname, "on", dev_name)
335         self.record_device = dev_name
336         self.record_log = logname
337
338     def end_record(self):
339         log("End recording log", self.record_log, "on", self.record_device)
340         self.record_device = None
341         self.record_log = None
342
343     def set_nonblock(self, fd):
344         fl = fcntl.fcntl(fd, F_GETFL)
345         fcntl.fcntl(fd, F_SETFL, fl | os.O_NDELAY)
346
347     def run(self, cmds):
348         """
349         run lctl
350         the cmds are written to stdin of lctl
351         lctl doesn't return errors when run in script mode, so
352         stderr is checked
353         should modify command line to accept multiple commands, or
354         create complex command line options
355         """
356         cmd_line = self.lctl
357         if self.save_file:
358             cmds = '\n  dump ' + self.save_file + '\n' + cmds
359         elif self.record_device:
360             cmds = """
361     device $%s
362     record %s
363     %s""" % (self.record_device, self.record_log, cmds)
364             
365         debug("+", cmd_line, cmds)
366         if config.noexec: return (0, [])
367
368         child = popen2.Popen3(cmd_line, 1) # Capture stdout and stderr from command
369         child.tochild.write(cmds + "\n")
370         child.tochild.close()
371 #       print "LCTL:", cmds
372
373         # From "Python Cookbook" from O'Reilly
374         outfile = child.fromchild
375         outfd = outfile.fileno()
376         self.set_nonblock(outfd)
377         errfile = child.childerr
378         errfd = errfile.fileno()
379         self.set_nonblock(errfd)
380
381         outdata = errdata = ''
382         outeof = erreof = 0
383         while 1:
384             ready = select.select([outfd,errfd],[],[]) # Wait for input
385             if outfd in ready[0]:
386                 outchunk = outfile.read()
387                 if outchunk == '': outeof = 1
388                 outdata = outdata + outchunk
389             if errfd in ready[0]:
390                 errchunk = errfile.read()
391                 if errchunk == '': erreof = 1
392                 errdata = errdata + errchunk
393             if outeof and erreof: break
394         # end of "borrowed" code
395
396         ret = child.wait()
397         if os.WIFEXITED(ret):
398             rc = os.WEXITSTATUS(ret)
399         else:
400             rc = 0
401         if rc or len(errdata):
402             raise CommandError(self.lctl, errdata, rc)
403         return rc, outdata
404
405     def runcmd(self, *args):
406         """
407         run lctl using the command line
408         """
409         cmd = string.join(map(str,args))
410         debug("+", self.lctl, cmd)
411         rc, out = run(self.lctl, cmd)
412         if rc:
413             raise CommandError(self.lctl, out, rc)
414         return rc, out
415
416     def clear_log(self, dev, log):
417         """ clear an existing log """
418         cmds =  """
419   device $%s
420   probe
421   clear_log %s
422   quit """ % (dev, log)
423         self.run(cmds)
424
425     def root_squash(self, name, uid, nid):
426         cmds = """
427   device $%s
428   root_squash %s %s
429   quit""" % (name, uid, nid)
430         self.run(cmds)
431
432     def network(self, net, nid):
433         """ set mynid """
434         cmds =  """
435   network %s
436   mynid %s
437   quit """ % (net, nid)
438         self.run(cmds)
439
440     # add an interface
441     def add_interface(self, net, ip, netmask = ""):
442         """ add an interface """
443         cmds = """
444   network %s
445   add_interface %s %s
446   quit """ % (net, ip, netmask)
447         self.run(cmds)
448
449     # delete an interface
450     def del_interface(self, net, ip):
451         """ delete an interface """
452         cmds = """
453   network %s
454   del_interface %s
455   quit """ % (net, ip)
456         self.run(cmds)
457
458     # create a new connection
459     def add_uuid(self, net_type, uuid, nid):
460         cmds = "\n  add_uuid %s %s %s" %(uuid, nid, net_type)
461         self.run(cmds)
462
463     def add_peer(self, net_type, nid, hostaddr, port):
464         if net_type  in ('tcp','openib','ra') and not config.lctl_dump:
465             cmds =  """
466   network %s
467   add_peer %s %s %d
468   quit""" % (net_type,
469              nid, hostaddr, port )
470             self.run(cmds)
471         elif net_type in ('iib',) and not config.lctl_dump:
472             cmds =  """
473   network %s
474   add_peer %s
475   quit""" % (net_type,
476              nid )
477             self.run(cmds)
478         elif net_type in ('vib',) and not config.lctl_dump:
479             cmds =  """
480   network %s
481   add_peer %s %s
482   quit""" % (net_type,
483              nid, hostaddr )
484             self.run(cmds)
485     
486     def connect(self, srv):
487         self.add_uuid(srv.net_type, srv.nid_uuid, srv.nid)
488         if srv.net_type  in ('tcp','openib','iib','vib','ra') and not config.lctl_dump:
489             if srv.hostaddr[0]:
490                 hostaddr = string.split(srv.hostaddr[0], '/')[0]
491             self.add_peer(srv.net_type, srv.nid, hostaddr, srv.port)
492
493     # Recover a device
494     def recover(self, dev_name, new_conn):
495         cmds = """
496     device $%s
497     recover %s""" %(dev_name, new_conn)
498         self.run(cmds)
499                 
500     # add a route to a range
501     def add_route(self, net, gw, lo, hi):
502         cmds =  """
503   network %s
504   add_route %s %s %s
505   quit  """ % (net,
506                gw, lo, hi)
507         try:
508             self.run(cmds)
509         except CommandError, e:
510             log ("ignore: ")
511             e.dump()
512                 
513     def del_route(self, net, gw, lo, hi):
514         cmds =  """
515   ignore_errors
516   network %s
517   del_route %s %s %s
518   quit  """ % (net, gw, lo, hi)
519         self.run(cmds)
520
521     # add a route to a host
522     def add_route_host(self, net, uuid, gw, tgt):
523         self.add_uuid(net, uuid, tgt)
524         cmds =  """
525   network %s
526   add_route %s %s
527   quit """ % (net,
528               gw, tgt)
529         try:
530             self.run(cmds)
531         except CommandError, e:
532             log ("ignore: ")
533             e.dump()
534
535     # add a route to a range
536     def del_route_host(self, net, uuid, gw, tgt):
537         self.del_uuid(uuid)
538         cmds =  """
539   ignore_errors
540   network %s
541   del_route %s %s
542   quit  """ % (net, gw, tgt)
543         self.run(cmds)
544
545
546     def del_peer(self, net_type, nid, hostaddr):
547         if net_type  in ('tcp',) and not config.lctl_dump:
548                 cmds =  """
549   ignore_errors
550   network %s
551   del_peer %s %s single_share
552   quit""" % (net_type,
553              nid, hostaddr)
554                 self.run(cmds)
555         elif net_type  in ('openib','iib','vib','ra') and not config.lctl_dump:
556                 cmds =  """
557   ignore_errors
558   network %s
559   del_peer %s single_share
560   quit""" % (net_type,
561              nid)
562                 self.run(cmds)
563         
564     # disconnect one connection
565     def disconnect(self, srv):
566         self.del_uuid(srv.nid_uuid)
567         if srv.net_type  in ('tcp','openib','iib','vib','ra') and not config.lctl_dump:
568             if srv.hostaddr[0]:
569                 hostaddr = string.split(srv.hostaddr[0], '/')[0]
570             self.del_peer(srv.net_type, srv.nid, hostaddr)
571
572     def del_uuid(self, uuid):
573         cmds =  """
574   ignore_errors
575   del_uuid %s
576   quit""" % (uuid,)
577         self.run(cmds)
578
579     # disconnect all
580     def disconnectAll(self, net):
581         cmds =  """
582   ignore_errors
583   network %s
584   disconnect
585   quit""" % (net)
586         self.run(cmds)
587
588     def attach(self, type, name, uuid):
589         cmds = """
590   attach %s %s %s
591   quit""" % (type, name, uuid)
592         self.run(cmds)
593         
594     def detach(self, name):
595         cmds = """
596   cfg_device %s
597   detach
598   quit""" % (name)
599         self.run(cmds)
600         
601     def set_security(self, name, key, value):
602         cmds = """
603   cfg_device %s
604   set_security %s %s
605   quit""" % (name, key, value)
606         self.run(cmds)
607
608     def setup(self, name, setup = ""):
609         cmds = """
610   cfg_device %s
611   setup %s
612   quit""" % (name, setup)
613         self.run(cmds)
614         
615     def add_conn(self, name, conn_uuid):
616         cmds = """
617   cfg_device %s
618   add_conn %s
619   quit""" % (name, conn_uuid)
620         self.run(cmds)
621
622     def start(self, name, conf_name):
623         cmds = """
624   device $%s
625   start %s
626   quit""" % (name, conf_name)
627         self.run(cmds)
628
629     # create a new device with lctl
630     def newdev(self, type, name, uuid, setup = ""):
631         if type != 'mds':
632             self.attach(type, name, uuid);
633         try:
634             self.setup(name, setup)
635         except CommandError, e:
636             self.cleanup(name, uuid, 0)
637             raise e
638         
639     # cleanup a device
640     def cleanup(self, name, uuid, force, failover = 0):
641         if failover: force = 1
642         cmds = """
643   ignore_errors
644   cfg_device $%s
645   cleanup %s %s
646   detach
647   quit""" % (name, ('', 'force')[force],
648              ('', 'failover')[failover])
649         self.run(cmds)
650
651     # create an lov
652     def lov_setup(self, name, uuid, desc_uuid, stripe_cnt,
653                   stripe_sz, stripe_off, pattern, devlist = None):
654         cmds = """
655   attach lov %s %s
656   lov_setup %s %d %d %d %s %s
657   quit""" % (name, uuid, desc_uuid, stripe_cnt, stripe_sz, stripe_off,
658              pattern, devlist)
659         self.run(cmds)
660
661     # add an OBD to a LOV
662     def lov_add_obd(self, name, uuid, obd_uuid, index, gen):
663         cmds = """
664   lov_modify_tgts add %s %s %s %s
665   quit""" % (name, obd_uuid, index, gen)
666         self.run(cmds)
667
668     # create an lmv
669     def lmv_setup(self, name, uuid, desc_uuid, devlist):
670         cmds = """
671   attach lmv %s %s
672   lmv_setup %s %s
673   quit""" % (name, uuid, desc_uuid, devlist)
674         self.run(cmds)
675
676     # delete an OBD from a LOV
677     def lov_del_obd(self, name, uuid, obd_uuid, index, gen):
678         cmds = """
679   lov_modify_tgts del %s %s %s %s
680   quit""" % (name, obd_uuid, index, gen)
681         self.run(cmds)
682
683     # deactivate an OBD
684     def deactivate(self, name):
685         cmds = """
686   device $%s
687   deactivate
688   quit""" % (name)
689         self.run(cmds)
690
691     # dump the log file
692     def dump(self, dump_file):
693         cmds = """
694   debug_kernel %s 1
695   quit""" % (dump_file)
696         self.run(cmds)
697
698     # get list of devices
699     def device_list(self):
700         devices = '/proc/fs/lustre/devices'
701         ret = []
702         if os.access(devices, os.R_OK):
703             try:
704                 fp = open(devices, 'r')
705                 ret =  fp.readlines()
706                 fp.close()
707             except IOError, e:
708                 log(e)
709         return ret
710
711     # get lustre version
712     def lustre_version(self):
713         rc, out = self.runcmd('version')
714         return out
715
716     # dump mount options
717     def mount_option(self, profile, osc, mdc, gkc):
718         cmds = """
719   mount_option %s %s %s %s
720   quit""" % (profile, osc, mdc, gkc)
721         self.run(cmds)
722
723     # delete mount options
724     def del_mount_option(self, profile):
725         cmds = """
726   del_mount_option %s
727   quit""" % (profile,)
728         self.run(cmds)
729
730     def set_timeout(self, timeout):
731         cmds = """
732   set_timeout %s
733   quit""" % (timeout,)
734         self.run(cmds)
735
736     def set_lustre_upcall(self, upcall):
737         cmds = """
738   set_lustre_upcall %s
739   quit""" % (upcall,)
740         self.run(cmds)
741 # ============================================================
742 # Various system-level functions
743 # (ideally moved to their own module)
744
745 # Run a command and return the output and status.
746 # stderr is sent to /dev/null, could use popen3 to
747 # save it if necessary
748 def runcmd(cmd):
749     debug ("+", cmd)
750     if config.noexec: return (0, [])
751     f = os.popen(cmd + ' 2>&1')
752     out = f.readlines()
753     ret = f.close()
754     if ret:
755         ret = ret >> 8
756     else:
757         ret = 0
758     return (ret, out)
759
760 def run(*args):
761     cmd = string.join(map(str,args))
762     return runcmd(cmd)
763
764 # Run a command in the background.
765 def run_daemon(*args):
766     cmd = string.join(map(str,args))
767     debug ("+", cmd)
768     if config.noexec: return 0
769     f = os.popen(cmd + ' 2>&1')
770     ret = f.close()
771     if ret:
772         ret = ret >> 8
773     else:
774         ret = 0
775     return ret
776
777 # Determine full path to use for an external command
778 # searches dirname(argv[0]) first, then PATH
779 def find_prog(cmd):
780     syspath = string.split(os.environ['PATH'], ':')
781     cmdpath = os.path.dirname(sys.argv[0])
782     syspath.insert(0, cmdpath);
783     if config.portals:
784         syspath.insert(0, os.path.join(config.portals, 'utils/'))
785     for d in syspath:
786         prog = os.path.join(d,cmd)
787         if os.access(prog, os.X_OK):
788             return prog
789     return ''
790
791 # Recursively look for file starting at base dir
792 def do_find_file(base, mod):
793     fullname = os.path.join(base, mod)
794     if os.access(fullname, os.R_OK):
795         return fullname
796     for d in os.listdir(base):
797         dir = os.path.join(base,d)
798         if os.path.isdir(dir):
799             module = do_find_file(dir, mod)
800             if module:
801                 return module
802
803 # is the path a block device?
804 def is_block(path):
805     s = ()
806     try:
807         s =  os.stat(path)
808     except OSError:
809         return 0
810     return stat.S_ISBLK(s[stat.ST_MODE])
811
812 # find the journal device from mkfs options
813 def jdev(opts):
814     if opts == None:
815         return ''
816     x=string.split(opts)
817     i=0
818     while i < len(x) - 1:
819         if x[i] == '-J' and x[i+1].startswith('device='):
820             str=x[i+1]
821             return str[7:]
822         i=i+1
823     return ''
824
825 # build fs according to type
826 # fixme: dangerous
827 def mkfs(dev, devsize, fstype, jsize, isize, mkfsoptions, isblock=1):
828     block_cnt = ''
829     jopt = ''
830     iopt = ''
831     if devsize:
832         if devsize < 8000:
833             panic("size of filesystem on '%s' must be larger than 8MB, but is set to %s"%
834                   (dev, devsize))
835         # devsize is in 1k, and fs block count is in 4k
836         block_cnt = devsize/4
837
838     if fstype in ('ext3', 'extN', 'ldiskfs'):
839         # ext3 journal size is in megabytes
840         # but don't set jsize if mkfsoptions indicates a separate journal device
841         if jsize == 0 and jdev(mkfsoptions) == '':
842             if devsize == 0:
843                 if not is_block(dev):
844                     ret, out = runcmd("ls -l %s" %dev)
845                     devsize = int(string.split(out[0])[4]) / 1024
846                 else:
847                     # sfdisk works for symlink, hardlink, and realdev
848                     ret, out = runcmd("sfdisk -s %s" %dev)
849                     if not ret:
850                         devsize = int(out[0])
851                     else:
852                         # sfdisk -s will fail for too large block device,
853                         # then, read the size of partition from /proc/partitions
854
855                         # get the realpath of the device
856                         # it may be the real device, such as /dev/hda7
857                         # or the hardlink created via mknod for a device
858                         if 'realpath' in dir(os.path):
859                             real_dev = os.path.realpath(dev)
860                         else:
861                             real_dev = dev
862                             link_count = 0
863                             while os.path.islink(real_dev) and (link_count < 20):
864                                 link_count = link_count + 1
865                                 dev_link = os.readlink(real_dev)
866                                 if os.path.isabs(dev_link):
867                                     real_dev = dev_link
868                                 else:
869                                     real_dev = os.path.join(os.path.dirname(real_dev), dev_link)
870                                 if link_count > 19:
871                                     panic("Entountered too many symbolic links resolving block device:", dev)
872
873                         # get the major and minor number of the realpath via ls
874                         # it seems python(os.stat) does not return 
875                         # the st_rdev member of the stat structure
876                         ret, out = runcmd("ls -l %s" %real_dev)
877                         major = string.split(string.split(out[0])[4], ",")[0]
878                         minor = string.split(out[0])[5]
879
880                         # get the devsize from /proc/partitions with the major and minor number
881                         ret, out = runcmd("cat /proc/partitions")
882                         for line in out:
883                             if len(line) > 1:
884                                 if string.split(line)[0] == major and string.split(line)[1] == minor:
885                                     devsize = int(string.split(line)[2])
886                                     break
887
888             if devsize > 1024 * 1024:
889                 jsize = ((devsize / 102400) * 4)
890             if jsize > 400:
891                 jsize = 400        
892         if jsize:  jopt = "-J size=%d" %(jsize,)
893         if isize:  iopt = "-I %d" %(isize,)
894         mkfs = 'mkfs.ext2 -j -b 4096 '
895         if not isblock or config.force:
896             mkfs = mkfs + ' -F '
897         if jdev(mkfsoptions) != '':
898             jmkfs = 'mkfs.ext2 -b 4096 -O journal_dev '
899             if config.force:
900                 jmkfs = jmkfs + '-F '
901             jmkfs = jmkfs + jdev(mkfsoptions)                
902             (ret, out) = run (jmkfs)
903             if ret:
904                 panic("Unable format journal device:", jdev(mkfsoptions), string.join(out))
905     elif fstype == 'reiserfs':
906         # reiserfs journal size is in blocks
907         if jsize:  jopt = "--journal_size %d" %(jsize,)
908         mkfs = 'mkreiserfs -ff'
909     else:
910         panic('unsupported fs type: ', fstype)
911
912     if config.mkfsoptions != None:
913         mkfs = mkfs + ' ' + config.mkfsoptions
914     if mkfsoptions != None:
915         mkfs = mkfs + ' ' + mkfsoptions
916     (ret, out) = run (mkfs, jopt, iopt, dev, block_cnt)
917     if ret:
918         panic("Unable to build fs:", dev, string.join(out))
919     # enable hash tree indexing on fsswe
920     if fstype in ('ext3', 'extN', 'ldiskfs'):
921         htree = 'echo "feature FEATURE_C5" | debugfs -w'
922         (ret, out) = run (htree, dev)
923         if ret:
924             panic("Unable to enable htree:", dev)
925
926 # some systems use /dev/loopN, some /dev/loop/N
927 def loop_base():
928     import re
929     loop = '/dev/loop'
930     if not os.access(loop + str(0), os.R_OK):
931         loop = loop + '/'
932         if not os.access(loop + str(0), os.R_OK):
933             panic ("can't access loop devices")
934     return loop
935     
936 # find loop device assigned to the file
937 def find_assigned_loop(file):
938     loop = loop_base()
939     for n in xrange(0, MAX_LOOP_DEVICES):
940         dev = loop + str(n)
941         if os.access(dev, os.R_OK):
942             (stat, out) = run('losetup', dev)
943             if out and stat == 0:
944                 m = re.search(r'\((.*)\)', out[0])
945                 if m and file == m.group(1):
946                     return dev
947     return ''
948
949 # find free loop device
950 def find_free_loop(file):
951     loop = loop_base()
952     
953     # find next free loop
954     for n in xrange(0, MAX_LOOP_DEVICES):
955         dev = loop + str(n)
956         if os.access(dev, os.R_OK):
957             (stat, out) = run('losetup', dev)
958             if stat:
959                 return dev
960     return ''
961
962 # create file if necessary and assign the first free loop device
963 def init_loop(file, size, fstype, journal_size, inode_size, 
964               mkfsoptions, reformat, autoformat, backfstype, backfile):
965     if fstype == 'smfs':
966         realfile = backfile
967         realfstype = backfstype
968         if is_block(backfile):
969             if reformat or (need_format(realfstype, backfile) and autoformat == 'yes'):
970                 mkfs(realfile, size, realfstype, journal_size, inode_size, mkfsoptions, isblock=0)
971             return realfile
972     else:
973         realfile = file
974         realfstype = fstype
975             
976     dev = find_assigned_loop(realfile)
977     if dev:
978         print 'WARNING: file', realfile, 'already mapped to', dev
979         return dev
980             
981     if reformat or not os.access(realfile, os.R_OK | os.W_OK):
982         (ret, out) = run("dd if=/dev/zero bs=1k count=0 seek=%d of=%s" %(size, realfile))
983         if ret:
984             panic("Unable to create backing store:", realfile)
985         mkfs(realfile, size, realfstype, journal_size, inode_size, 
986              mkfsoptions, isblock=0)
987
988     dev = find_free_loop(realfile)
989     if dev:
990         print "attach " + realfile + " <-> " + dev                  
991         run('losetup', dev, realfile)
992         return dev
993
994     print "out of loop devices"
995     return ''
996
997 # undo loop assignment
998 def clean_loop(dev, fstype, backfstype, backdev):
999     if fstype == 'smfs':
1000         realfile = backdev
1001     else:
1002         realfile = dev
1003     if not is_block(realfile):
1004         dev = find_assigned_loop(realfile)
1005         if dev:
1006             print "detach " + dev + " <-> " + realfile
1007             ret, out = run('losetup -d', dev)
1008             if ret:
1009                 log('unable to clean loop device', dev, 'for file', realfile)
1010                 logall(out)
1011
1012 # finilizes passed device
1013 def clean_dev(dev, fstype, backfstype, backdev):
1014     if fstype == 'smfs' or not is_block(dev):
1015         clean_loop(dev, fstype, backfstype, backdev)
1016         
1017 # determine if dev is formatted as a <fstype> filesystem
1018 def need_format(fstype, dev):
1019     # FIXME don't know how to implement this    
1020     return 0
1021
1022 # initialize a block device if needed
1023 def block_dev(dev, size, fstype, reformat, autoformat, journal_size,
1024               inode_size, mkfsoptions, backfstype, backdev):
1025     if config.noexec: 
1026         return dev
1027         
1028     if fstype == 'smfs' or not is_block(dev):
1029         dev = init_loop(dev, size, fstype, journal_size, inode_size,
1030                         mkfsoptions, reformat, autoformat, backfstype, backdev)
1031     elif reformat or (need_format(fstype, dev) and autoformat == 'yes'):
1032         mkfs(dev, size, fstype, journal_size, inode_size, mkfsoptions,
1033              isblock=0)
1034 #    else:
1035 #        panic("device:", dev,
1036 #              "not prepared, and autoformat is not set.\n",
1037 #              "Rerun with --reformat option to format ALL filesystems")
1038         
1039     return dev
1040
1041 def if2addr(iface):
1042     """lookup IP address for an interface"""
1043     rc, out = run("/sbin/ifconfig", iface)
1044     if rc or not out:
1045        return None
1046     addr = string.split(out[1])[1]
1047     ip = string.split(addr, ':')[1]
1048     return ip
1049
1050 def def_mount_options(fstype, target):
1051     """returns deafult mount options for passed fstype and target (mds, ost)"""
1052     if fstype == 'ext3' or fstype == 'ldiskfs':
1053         mountfsoptions = "errors=remount-ro"
1054         if target == 'ost' and sys_get_branch() == '2.4':
1055             mountfsoptions = "%s,asyncdel" % (mountfsoptions)
1056         if target == 'ost' and sys_get_branch() == '2.6':
1057             mountfsoptions = "%s,extents,mballoc" % (mountfsoptions)
1058         return mountfsoptions
1059     return ""
1060         
1061 def sys_get_elan_position_file():
1062     procfiles = ["/proc/elan/device0/position",
1063                  "/proc/qsnet/elan4/device0/position",
1064                  "/proc/qsnet/elan3/device0/position"]
1065     for p in procfiles:
1066         if os.access(p, os.R_OK):
1067             return p
1068     return ""
1069
1070 def sys_get_local_nid(net_type, wildcard, cluster_id):
1071     """Return the local nid."""
1072     local = ""
1073     if sys_get_elan_position_file():
1074         local = sys_get_local_address('elan', '*', cluster_id)
1075     else:
1076         local = sys_get_local_address(net_type, wildcard, cluster_id)
1077     return local
1078         
1079 def sys_get_local_address(net_type, wildcard, cluster_id):
1080     """Return the local address for the network type."""
1081     local = ""
1082     if net_type in ('tcp','openib','iib','vib','ra'):
1083         if  ':' in wildcard:
1084             iface, star = string.split(wildcard, ':')
1085             local = if2addr(iface)
1086             if not local:
1087                 panic ("unable to determine ip for:", wildcard)
1088         else:
1089             host = socket.gethostname()
1090             local = socket.gethostbyname(host)
1091     elif net_type == 'elan':
1092         # awk '/NodeId/ { print $2 }' 'sys_get_elan_position_file()'
1093         f = sys_get_elan_position_file()
1094         if not f:
1095             panic ("unable to determine local Elan ID")
1096         try:
1097             fp = open(f, 'r')
1098             lines = fp.readlines()
1099             fp.close()
1100             for l in lines:
1101                 a = string.split(l)
1102                 if a[0] == 'NodeId':
1103                     elan_id = a[1]
1104                     break
1105             try:
1106                 nid = my_int(cluster_id) + my_int(elan_id) 
1107                 local = "%d" % (nid)
1108             except ValueError, e:
1109                 local = elan_id
1110         except IOError, e:
1111             log(e)
1112     elif net_type == 'lo':
1113         fixme("automatic local address for loopback")
1114     elif net_type == 'gm':
1115         fixme("automatic local address for GM")
1116
1117     return local
1118
1119 def sys_get_branch():
1120     """Returns kernel release"""
1121     try:
1122         fp = open('/proc/sys/kernel/osrelease')
1123         lines = fp.readlines()
1124         fp.close()
1125         
1126         for l in lines:
1127             version = string.split(l)
1128             a = string.split(version[0], '.')
1129             return a[0] + '.' + a[1]
1130     except IOError, e:
1131         log(e)
1132     return ""
1133
1134 # XXX: instead of device_list, ask for $name and see what we get
1135 def is_prepared(name):
1136     """Return true if a device exists for the name"""
1137     if config.lctl_dump:
1138         return 0
1139     if (config.noexec or config.record) and config.cleanup:
1140         return 1
1141     try:
1142         # expect this format:
1143         # 1 UP ldlm ldlm ldlm_UUID 2
1144         out = lctl.device_list()
1145         for s in out:
1146             if name == string.split(s)[3]:
1147                 return 1
1148     except CommandError, e:
1149         e.dump()
1150     return 0
1151
1152 def net_is_prepared():
1153     """If the any device exists, then assume that all networking
1154        has been configured"""
1155     out = lctl.device_list()
1156     return len(out) > 0
1157
1158 def fs_is_mounted(path):
1159     """Return true if path is a mounted lustre filesystem"""
1160     try:
1161         fp = open('/proc/mounts')
1162         lines = fp.readlines()
1163         fp.close()
1164         for l in lines:
1165             a = string.split(l)
1166             if a[1] == path and a[2] == 'lustre_lite':
1167                 return 1
1168     except IOError, e:
1169         log(e)
1170     return 0
1171
1172 def kmod_find(src_dir, dev_dir, modname):
1173     modbase = src_dir +'/'+ dev_dir +'/'+ modname
1174     for modext in '.ko', '.o':
1175         module = modbase + modext
1176         try:
1177             if os.access(module, os.R_OK):
1178                 return module
1179         except OSError:
1180                pass
1181     return None
1182
1183 def kmod_info(modname):
1184     """Returns reference count for passed module name."""
1185     try:
1186         fp = open('/proc/modules')
1187         lines = fp.readlines()
1188         fp.close()
1189         
1190         # please forgive my tired fingers for this one
1191         ret = filter(lambda word, mod = modname: word[0] == mod,
1192                      map(lambda line: string.split(line), lines))
1193         if not ret:
1194             return ''
1195         return ret[0]
1196     except Exception, e:
1197         return 0
1198
1199 class kmod:
1200     """Presents kernel module"""
1201     def __init__(self, src_dir, dev_dir, name):
1202         self.src_dir = src_dir
1203         self.dev_dir = dev_dir
1204         self.name = name
1205
1206     # FIXME we ignore the failure of loading gss module, because we might
1207     # don't need it at all.
1208     def load(self):
1209         """Load module"""
1210         log ('loading module:', self.name, 'srcdir',
1211              self.src_dir, 'devdir', self.dev_dir)
1212         if self.src_dir:
1213             module = kmod_find(self.src_dir, self.dev_dir,
1214                                self.name)
1215             if not module and self.name != 'ptlrpcs_gss':
1216                 panic('module not found:', self.name)
1217             (rc, out)  = run('/sbin/insmod', module)
1218             if rc:
1219                 if self.name == 'ptlrpcs_gss':
1220                     print "Warning: not support gss security!"
1221                 else:
1222                     raise CommandError('insmod', out, rc)
1223         else:
1224             (rc, out) = run('/sbin/modprobe', self.name)
1225             if rc:
1226                 if self.name == 'ptlrpcs_gss':
1227                     print "Warning: not support gss security!"
1228                 else:
1229                     raise CommandError('modprobe', out, rc)
1230
1231     def cleanup(self):
1232         """Unload module"""
1233         log('unloading module:', self.name)
1234         (rc, out) = run('/sbin/rmmod', self.name)
1235         if rc:
1236             log('unable to unload module:', self.name +
1237                 "(" + self.refcount() + ")")
1238             logall(out)
1239
1240     def info(self):
1241         """Returns module info if any."""
1242         return kmod_info(self.name)
1243
1244     def loaded(self):
1245         """Returns 1 if module is loaded. Otherwise 0 is returned."""
1246         if self.info():
1247             return 1
1248         else:
1249             return 0
1250
1251     def refcount(self):
1252         """Returns module refcount."""
1253         info = self.info()
1254         if not info:
1255             return ''
1256         return info[2]
1257
1258     def used(self):
1259         """Returns 1 if module is used, otherwise 0 is returned."""
1260         info = self.info()
1261         if not info:
1262             return 0
1263         if len(info) > 3:
1264             users = info[3]
1265             if users and users != '(unused)' and users != '-':
1266                 return 1
1267             else:
1268                 return 0
1269         else:
1270             return 0
1271
1272     def busy(self):
1273         """Returns 1 if module is busy, otherwise 0 is returned."""
1274         if self.loaded() and (self.used() or self.refcount() != '0'):
1275             return 1
1276         else:
1277             return 0
1278
1279 class kmod_manager:
1280     """Manage kernel modules"""
1281     def __init__(self, lustre_dir, portals_dir):
1282         self.lustre_dir = lustre_dir
1283         self.portals_dir = portals_dir
1284         self.kmodule_list = []
1285
1286     def find_module(self, modname):
1287         """Find module by module name"""
1288         for mod in self.kmodule_list:
1289             if mod.name == modname:
1290                 return mod
1291         return ''
1292         
1293     def add_portals_module(self, dev_dir, modname):
1294         """Append a module to list of modules to load."""
1295
1296         mod = self.find_module(modname)
1297         if not mod:
1298             mod = kmod(self.portals_dir, dev_dir, modname)
1299             self.kmodule_list.append(mod)
1300
1301     def add_lustre_module(self, dev_dir, modname):
1302         """Append a module to list of modules to load."""
1303
1304         mod = self.find_module(modname)
1305         if not mod:
1306             mod = kmod(self.lustre_dir, dev_dir, modname)
1307             self.kmodule_list.append(mod)
1308         
1309     def load_modules(self):
1310         """Load all the modules in the list in the order they appear."""
1311         for mod in self.kmodule_list:
1312             if mod.loaded() and not config.noexec:
1313                 continue
1314             mod.load()
1315
1316     def cleanup_modules(self):
1317         """Unload the modules in the list in reverse order."""
1318         rev = self.kmodule_list
1319         rev.reverse()
1320         for mod in rev:
1321             if (not mod.loaded() or mod.busy()) and not config.noexec:
1322                 continue
1323             # debug hack
1324             if mod.name == 'portals' and config.dump:
1325                 lctl.dump(config.dump)
1326             mod.cleanup()
1327             
1328 # ============================================================
1329 # Classes to prepare and cleanup the various objects
1330 #
1331 class Module:
1332     """ Base class for the rest of the modules. The default cleanup method is
1333     defined here, as well as some utilitiy funcs.
1334     """
1335     def __init__(self, module_name, db):
1336         self.db = db
1337         self.module_name = module_name
1338         self.name = self.db.getName()
1339         self.uuid = self.db.getUUID()
1340         self._server = None
1341         self._connected = 0
1342
1343     def info(self, *args):
1344         msg = string.join(map(str,args))
1345         print self.module_name + ":", self.name, self.uuid, msg
1346
1347     def cleanup(self):
1348         """ default cleanup, used for most modules """
1349         self.info()
1350         try:
1351             lctl.cleanup(self.name, self.uuid, config.force)
1352         except CommandError, e:
1353             log(self.module_name, "cleanup failed: ", self.name)
1354             e.dump()
1355             cleanup_error(e.rc)
1356
1357     def add_module(self, manager):
1358         """Adds all needed modules in the order they appear."""
1359         return
1360
1361     def safe_to_clean(self):
1362         return 1
1363
1364     def safe_to_clean_modules(self):
1365         return self.safe_to_clean()
1366         
1367 class Network(Module):
1368     def __init__(self,db):
1369         Module.__init__(self, 'NETWORK', db)
1370         self.net_type = self.db.get_val('nettype')
1371         self.nid = self.db.get_val('nid', '*')
1372         self.cluster_id = self.db.get_val('clusterid', "0")
1373         self.port = self.db.get_val_int('port', 0)
1374
1375         if '*' in self.nid:
1376             self.nid = sys_get_local_nid(self.net_type, self.nid, self.cluster_id)
1377             if not self.nid:
1378                 panic("unable to set nid for", self.net_type, self.nid, cluster_id)
1379             self.generic_nid = 1
1380             debug("nid:", self.nid)
1381         else:
1382             self.generic_nid = 0
1383
1384         self.nid_uuid = self.nid_to_uuid(self.nid)
1385         self.hostaddr = self.db.get_hostaddr()
1386         if len(self.hostaddr) == 0:
1387             self.hostaddr.append(self.nid)
1388         if '*' in self.hostaddr[0]:
1389             self.hostaddr[0] = sys_get_local_address(self.net_type, self.hostaddr[0], self.cluster_id)
1390             if not self.hostaddr[0]:
1391                 panic("unable to set hostaddr for", self.net_type, self.hostaddr[0], self.cluster_id)
1392             debug("hostaddr:", self.hostaddr[0])
1393
1394     def add_module(self, manager):
1395         manager.add_portals_module("libcfs", 'libcfs')
1396         manager.add_portals_module("portals", 'portals')
1397         
1398         if node_needs_router():
1399             manager.add_portals_module("router", 'kptlrouter')
1400         if self.net_type == 'tcp':
1401             manager.add_portals_module("knals/socknal", 'ksocknal')
1402         if self.net_type == 'elan':
1403             manager.add_portals_module("knals/qswnal", 'kqswnal')
1404         if self.net_type == 'gm':
1405             manager.add_portals_module("knals/gmnal", 'kgmnal')
1406         if self.net_type == 'openib':
1407             manager.add_portals_module("knals/openibnal", 'kopenibnal')
1408         if self.net_type == 'iib':
1409             manager.add_portals_module("knals/iibnal", 'kiibnal')
1410         if self.net_type == 'vib':
1411             self.add_portals_module("knals/vibnal", 'kvibnal')
1412         if self.net_type == 'lo':
1413             manager.add_portals_module("knals/lonal", 'klonal')
1414         if self.net_type == 'ra':
1415             manager.add_portals_module("knals/ranal", 'kranal')
1416
1417     def nid_to_uuid(self, nid):
1418         return "NID_%s_UUID" %(nid,)
1419
1420     def prepare(self):
1421         if not config.record and net_is_prepared():
1422             return
1423         self.info(self.net_type, self.nid, self.port)
1424         if not (config.record and self.generic_nid):
1425             lctl.network(self.net_type, self.nid)
1426         if self.net_type == 'tcp':
1427             sys_tweak_socknal()
1428             for hostaddr in self.db.get_hostaddr():
1429                 ip = string.split(hostaddr, '/')[0]
1430                 if len(string.split(hostaddr, '/')) == 2:
1431                     netmask = string.split(hostaddr, '/')[1]
1432                 else:
1433                     netmask = ""
1434                 lctl.add_interface(self.net_type, ip, netmask)
1435         if self.net_type == 'elan':
1436             sys_optimize_elan()
1437         if self.port and  node_is_router():
1438             run_one_acceptor(self.port)
1439             self.connect_peer_gateways()
1440
1441     def connect_peer_gateways(self):
1442         for router in self.db.lookup_class('node'):
1443             if router.get_val_int('router', 0):
1444                 for netuuid in router.get_networks():
1445                     net = self.db.lookup(netuuid)
1446                     gw = Network(net)
1447                     if (gw.cluster_id == self.cluster_id and
1448                         gw.net_type == self.net_type):
1449                         if gw.nid != self.nid:
1450                             lctl.connect(gw)
1451
1452     def disconnect_peer_gateways(self):
1453         for router in self.db.lookup_class('node'):
1454             if router.get_val_int('router', 0):
1455                 for netuuid in router.get_networks():
1456                     net = self.db.lookup(netuuid)
1457                     gw = Network(net)
1458                     if (gw.cluster_id == self.cluster_id and
1459                         gw.net_type == self.net_type):
1460                         if gw.nid != self.nid:
1461                             try:
1462                                 lctl.disconnect(gw)
1463                             except CommandError, e:
1464                                 print "disconnect failed: ", self.name
1465                                 e.dump()
1466                                 cleanup_error(e.rc)
1467
1468     def safe_to_clean(self):
1469         return not net_is_prepared()
1470
1471     def cleanup(self):
1472         self.info(self.net_type, self.nid, self.port)
1473         if self.port:
1474             stop_acceptor(self.port)
1475         if  node_is_router():
1476             self.disconnect_peer_gateways()
1477         if self.net_type == 'tcp':
1478             for hostaddr in self.db.get_hostaddr():
1479                 ip = string.split(hostaddr, '/')[0]
1480                 lctl.del_interface(self.net_type, ip)
1481
1482     def correct_level(self, level, op=None):
1483         return level
1484
1485 class RouteTable(Module):
1486     def __init__(self,db):
1487         Module.__init__(self, 'ROUTES', db)
1488
1489     def server_for_route(self, net_type, gw, gw_cluster_id, tgt_cluster_id,
1490                          lo, hi):
1491         # only setup connections for tcp, openib, and iib NALs
1492         srvdb = None
1493         if not net_type in ('tcp','openib','iib','vib','ra'):
1494             return None
1495
1496         # connect to target if route is to single node and this node is the gw
1497         if lo == hi and local_interface(net_type, gw_cluster_id, gw):
1498             if not local_cluster(net_type, tgt_cluster_id):
1499                 panic("target", lo, " not on the local cluster")
1500             srvdb = self.db.nid2server(lo, net_type, gw_cluster_id)
1501         # connect to gateway if this node is not the gw
1502         elif (local_cluster(net_type, gw_cluster_id)
1503               and not local_interface(net_type, gw_cluster_id, gw)):
1504             srvdb = self.db.nid2server(gw, net_type, gw_cluster_id)
1505         else:
1506             return None
1507
1508         if not srvdb:
1509             panic("no server for nid", lo)
1510             return None
1511
1512         return Network(srvdb)
1513         
1514     def prepare(self):
1515         if not config.record and net_is_prepared():
1516             return
1517         self.info()
1518         for net_type, gw, gw_cluster_id, tgt_cluster_id, lo, hi in self.db.get_route_tbl():
1519             lctl.add_route(net_type, gw, lo, hi)
1520             srv = self.server_for_route(net_type, gw, gw_cluster_id, tgt_cluster_id, lo, hi)
1521             if srv:
1522                 lctl.connect(srv)
1523
1524     def safe_to_clean(self):
1525         return not net_is_prepared()
1526
1527     def cleanup(self):
1528         if net_is_prepared():
1529             # the network is still being used, don't clean it up
1530             return
1531         for net_type, gw, gw_cluster_id, tgt_cluster_id, lo, hi in self.db.get_route_tbl():
1532             srv = self.server_for_route(net_type, gw, gw_cluster_id, tgt_cluster_id, lo, hi)
1533             if srv:
1534                 try:
1535                     lctl.disconnect(srv)
1536                 except CommandError, e:
1537                     print "disconnect failed: ", self.name
1538                     e.dump()
1539                     cleanup_error(e.rc)
1540
1541             try:
1542                 lctl.del_route(net_type, gw, lo, hi)
1543             except CommandError, e:
1544                 print "del_route failed: ", self.name
1545                 e.dump()
1546                 cleanup_error(e.rc)
1547
1548 class Management(Module):
1549     def __init__(self, db):
1550         Module.__init__(self, 'MGMT', db)
1551
1552     def add_module(self, manager):
1553         manager.add_lustre_module('lvfs', 'lvfs')
1554         manager.add_lustre_module('obdclass', 'obdclass')
1555         manager.add_lustre_module('ptlrpc', 'ptlrpc')
1556         manager.add_lustre_module('mgmt', 'mgmt_svc')
1557
1558     def prepare(self):
1559         if not config.record and is_prepared(self.name):
1560             return
1561         self.info()
1562         lctl.newdev("mgmt", self.name, self.uuid)
1563
1564     def safe_to_clean(self):
1565         return 1
1566
1567     def cleanup(self):
1568         if is_prepared(self.name):
1569             Module.cleanup(self)
1570
1571     def correct_level(self, level, op=None):
1572         return level
1573
1574 # This is only needed to load the modules; the LDLM device
1575 # is now created automatically.
1576 class LDLM(Module):
1577     def __init__(self,db):
1578         Module.__init__(self, 'LDLM', db)
1579
1580     def add_module(self, manager):
1581         manager.add_lustre_module('lvfs', 'lvfs')
1582         manager.add_lustre_module('obdclass', 'obdclass')
1583         manager.add_lustre_module('sec', 'ptlrpcs')
1584         manager.add_lustre_module('ptlrpc', 'ptlrpc')
1585         manager.add_lustre_module('sec/gss', 'ptlrpcs_gss')
1586
1587     def prepare(self):
1588         return
1589
1590     def cleanup(self):
1591         return
1592
1593     def correct_level(self, level, op=None):
1594         return level
1595
1596 class LOV(Module):
1597     def __init__(self, db, uuid, fs_name, name_override = None, config_only = None):
1598         Module.__init__(self, 'LOV', db)
1599         if name_override != None:
1600             self.name = "lov_%s" % name_override
1601         self.mds_uuid = self.db.get_first_ref('mds')
1602         self.stripe_sz = self.db.get_val_int('stripesize', 1048576)
1603         self.stripe_off = self.db.get_val_int('stripeoffset', 0)
1604         self.pattern = self.db.get_val_int('stripepattern', 0)
1605         self.devlist = self.db.get_lov_tgts('lov_tgt')
1606         self.stripe_cnt = self.db.get_val_int('stripecount', len(self.devlist))
1607         self.osclist = []
1608         self.obdlist = []
1609         self.desc_uuid = self.uuid
1610         self.uuid = generate_client_uuid(self.name)
1611         self.fs_name = fs_name
1612         if config_only:
1613             self.config_only = 1
1614             return
1615         self.config_only = None
1616         mds = self.db.lookup(self.mds_uuid)
1617         self.mds_name = mds.getName()
1618         for (obd_uuid, index, gen, active) in self.devlist:
1619             if obd_uuid == '':
1620                 continue
1621             self.obdlist.append(obd_uuid)
1622             obd = self.db.lookup(obd_uuid)
1623             osc = get_osc(obd, self.uuid, fs_name)
1624             if osc:
1625                 self.osclist.append((osc, index, gen, active))
1626             else:
1627                 panic('osc not found:', obd_uuid)
1628     def get_uuid(self):
1629         return self.uuid
1630     def get_name(self):
1631         return self.name
1632     def prepare(self):
1633         if not config.record and is_prepared(self.name):
1634             return
1635         self.info(self.mds_uuid, self.stripe_cnt, self.stripe_sz,
1636                   self.stripe_off, self.pattern, self.devlist,
1637                   self.mds_name)
1638         lctl.lov_setup(self.name, self.uuid, self.desc_uuid,  self.stripe_cnt,
1639                        self.stripe_sz, self.stripe_off, self.pattern,
1640                        string.join(self.obdlist))
1641         for (osc, index, gen, active) in self.osclist:
1642             target_uuid = osc.target_uuid
1643             try:
1644                 # Only ignore connect failures with --force, which
1645                 # isn't implemented here yet.
1646                 osc.active = active
1647                 osc.prepare(ignore_connect_failure=0)
1648             except CommandError, e:
1649                 print "Error preparing OSC %s\n" % osc.uuid
1650                 raise e
1651             lctl.lov_add_obd(self.name, self.uuid, target_uuid, index, gen)
1652
1653     def cleanup(self):
1654         for (osc, index, gen, active) in self.osclist:
1655             target_uuid = osc.target_uuid
1656             osc.cleanup()
1657         if is_prepared(self.name):
1658             Module.cleanup(self)
1659         if self.config_only:
1660             panic("Can't clean up config_only LOV ", self.name)
1661
1662     def add_module(self, manager):
1663         if self.config_only:
1664             panic("Can't load modules for config_only LOV ", self.name)
1665         for (osc, index, gen, active) in self.osclist:
1666             osc.add_module(manager)
1667             break
1668         manager.add_lustre_module('lov', 'lov')
1669
1670     def correct_level(self, level, op=None):
1671         return level
1672
1673 class LMV(Module):
1674     def __init__(self, db, uuid, fs_name, name_override = None):
1675         Module.__init__(self, 'LMV', db)
1676         if name_override != None:
1677             self.name = "lmv_%s" % name_override
1678             
1679         self.devlist = self.db.get_lmv_tgts('lmv_tgt')
1680         if self.devlist == None:
1681             self.devlist = self.db.get_refs('mds')
1682             
1683         self.mdclist = []
1684         self.desc_uuid = self.uuid
1685         self.uuid = uuid
1686         self.fs_name = fs_name
1687         for mds_uuid in self.devlist:
1688             mds = self.db.lookup(mds_uuid)
1689             if not mds:
1690                 panic("MDS not found!")
1691             mdc = MDC(mds, self.uuid, fs_name)
1692             if mdc:
1693                  self.mdclist.append(mdc)
1694             else:
1695                  panic('mdc not found:', mds_uuid)
1696
1697     def prepare(self):
1698         if is_prepared(self.name):
1699             return
1700             
1701         self.info();
1702         for mdc in self.mdclist:
1703             try:
1704                 # Only ignore connect failures with --force, which
1705                 # isn't implemented here yet.
1706                 mdc.prepare(ignore_connect_failure=0)
1707             except CommandError, e:
1708                 print "Error preparing LMV %s\n" % mdc.uuid
1709                 raise e
1710         
1711         lctl.lmv_setup(self.name, self.uuid, self.desc_uuid,
1712                        string.join(self.devlist))
1713
1714     def cleanup(self):
1715         for mdc in self.mdclist:
1716             mdc.cleanup()
1717         if is_prepared(self.name):
1718             Module.cleanup(self)
1719
1720     def add_module(self, manager):
1721         for mdc in self.mdclist:
1722             mdc.add_module(manager)
1723             break
1724         manager.add_lustre_module('lmv', 'lmv')
1725
1726     def correct_level(self, level, op=None):
1727         return level
1728
1729 class GKD(Module):
1730     def __init__(self,db):
1731         Module.__init__(self, 'GKD', db)
1732         target_uuid = self.db.get_first_ref('target')
1733         self.target = self.db.lookup(target_uuid)
1734         self.name = self.target.getName()
1735
1736         active_uuid = get_active_target(self.target)
1737         if not active_uuid:
1738             panic("No target device found:", target_uuid)
1739         if active_uuid == self.uuid:
1740             self.active = 1
1741         else:
1742             self.active = 0
1743       
1744         self.uuid = target_uuid  
1745     def prepare(self):
1746         if is_prepared(self.name):
1747             return
1748         if not self.active:
1749             debug(self.uuid, "not active")
1750             return
1751         run_acceptors()
1752
1753         lctl.newdev("gks", self.name, self.uuid, setup ="") 
1754         if not is_prepared('GKT'):
1755             lctl.newdev("gkt", 'GKT', 'GKT_UUID', setup ="")
1756
1757     def cleanup(self):
1758         if not self.active:
1759             debug(self.uuid, "not active")
1760             return
1761         self.info()
1762         if is_prepared(self.name):
1763             try:
1764                 lctl.cleanup(self.name, self.uuid, config.force,
1765                              config.failover)
1766             except CommandError, e:
1767                 log(self.module_name, "cleanup failed: ", self.name)
1768                 e.dump()
1769                 cleanup_error(e.rc)
1770                 Module.cleanup(self)
1771         if is_prepared('GKT'):
1772             try:
1773                 lctl.cleanup("GKT", "GKT_UUID", config.force,
1774                              config.failover)
1775             except CommandError, e:
1776                 print "cleanup failed: ", self.name
1777                 e.dump()
1778                 cleanup_error(e.rc)
1779         
1780     def add_module(self, manager):
1781         if self.active:
1782             manager.add_lustre_module('sec/gks', 'gks')
1783             manager.add_lustre_module('sec/gks', 'gkc')
1784
1785     def correct_level(self, level, op=None):
1786         return level
1787
1788
1789 class CONFDEV(Module):
1790     def __init__(self, db, name, target_uuid, uuid):
1791         Module.__init__(self, 'CONFDEV', db)
1792         self.devpath = self.db.get_val('devpath','')
1793         self.backdevpath = self.db.get_val('devpath','')
1794         self.size = self.db.get_val_int('devsize', 0)
1795         self.journal_size = self.db.get_val_int('journalsize', 0)
1796         self.fstype = self.db.get_val('fstype', '')
1797         self.backfstype = self.db.get_val('backfstype', '')
1798         self.mkfsoptions = self.db.get_val('mkfsoptions', '')
1799         self.mountfsoptions = self.db.get_val('mountfsoptions', '')
1800         self.target = self.db.lookup(target_uuid)
1801         self.name = "conf_%s" % self.target.getName()
1802         self.client_uuids = self.target.get_refs('client')
1803         self.obdtype = self.db.get_val('obdtype', '')
1804         
1805         self.mds_sec = self.db.get_val('mds_sec', '')
1806         self.oss_sec = self.db.get_val('oss_sec', '')
1807         self.deny_sec = self.db.get_val('deny_sec', '')
1808
1809         if config.mds_mds_sec:
1810             self.mds_sec = config.mds_mds_sec
1811         if config.mds_oss_sec:
1812             self.oss_sec = config.mds_oss_sec
1813         if config.mds_deny_sec:
1814             if self.deny_sec:
1815                 self.deny_sec = "%s,%s" %(self.deny_sec, config.mds_deny_sec)
1816             else:
1817                 self.deny_sec = config.mds_deny_sec
1818
1819         if self.obdtype == None:
1820             self.obdtype = 'dumb'
1821         
1822         self.conf_name = name
1823         self.conf_uuid = uuid
1824         self.realdev = self.devpath
1825         
1826         self.lmv = None
1827         self.master = None
1828         
1829         lmv_uuid = self.db.get_first_ref('lmv')
1830         if lmv_uuid != None:
1831             self.lmv = self.db.lookup(lmv_uuid)
1832             if self.lmv != None:
1833                 self.client_uuids = self.lmv.get_refs('client')
1834
1835         if self.target.get_class() == 'mds':
1836             if self.target.get_val('failover', 0):
1837                 self.failover_mds = 'f'
1838             else:
1839                 self.failover_mds = 'n'
1840             self.format = self.db.get_val('autoformat', "no")
1841         else:
1842             self.format = self.db.get_val('autoformat', "yes")
1843             self.osdtype = self.db.get_val('osdtype')
1844             ost = self.db.lookup(target_uuid)
1845             if ost.get_val('failover', 0):
1846                 self.failover_ost = 'f'
1847             else:
1848                 self.failover_ost = 'n'
1849
1850         self.inode_size = self.get_inode_size()
1851
1852         if self.lmv != None:
1853             client_uuid = self.name + "_lmv_UUID"
1854             self.master = LMV(self.lmv, client_uuid, 
1855                               self.conf_name, self.conf_name)
1856
1857     def get_inode_size(self):
1858         inode_size = self.db.get_val_int('inodesize', 0)
1859         if inode_size == 0 and self.target.get_class() == 'mds':
1860         
1861             # default inode size for case when neither LOV either 
1862             # LMV is accessible.
1863             self.inode_size = 256
1864             
1865             # find the LOV for this MDS
1866             lovconfig_uuid = self.target.get_first_ref('lovconfig')
1867             if lovconfig_uuid or self.lmv != None:
1868                 if self.lmv != None:
1869                     lovconfig_uuid = self.lmv.get_first_ref('lovconfig')
1870                     lovconfig = self.lmv.lookup(lovconfig_uuid)
1871                     lov_uuid = lovconfig.get_first_ref('lov')
1872                     if lov_uuid == None:
1873                         panic(self.target.getName() + ": No LOV found for lovconfig ", 
1874                               lovconfig.name)
1875                 else:
1876                     lovconfig = self.target.lookup(lovconfig_uuid)
1877                     lov_uuid = lovconfig.get_first_ref('lov')
1878                     if lov_uuid == None:
1879                        panic(self.target.getName() + ": No LOV found for lovconfig ", 
1880                              lovconfig.name)
1881                     if self.lmv != None:
1882                         lovconfig_uuid = self.lmv.get_first_ref('lovconfig')
1883                         lovconfig = self.lmv.lookup(lovconfig_uuid)
1884                         lov_uuid = lovconfig.get_first_ref('lov')
1885
1886                 lov = LOV(self.db.lookup(lov_uuid), lov_uuid, self.name, 
1887                           config_only = 1)
1888
1889                 # default stripe count controls default inode_size
1890                 if lov.stripe_cnt > 0:
1891                     stripe_count = lov.stripe_cnt
1892                 else:
1893                     stripe_count = len(lov.devlist)
1894                 if stripe_count > 77:
1895                     inode_size = 4096
1896                 elif stripe_count > 35:
1897                     inode_size = 2048
1898                 elif stripe_count > 13:
1899                     inode_size = 1024
1900                 #elif stripe_count > 3:
1901                 #    inode_size = 512
1902                 else:
1903                     inode_size = 512
1904                     
1905         return inode_size
1906             
1907     def get_mount_options(self, blkdev):
1908         options = def_mount_options(self.fstype, 
1909                                     self.target.get_class())
1910             
1911         if config.mountfsoptions:
1912             if options:
1913                 options = "%s,%s" %(options, config.mountfsoptions)
1914             else:
1915                 options = config.mountfsoptions
1916             if self.mountfsoptions:
1917                 options = "%s,%s" %(options, self.mountfsoptions)
1918         else:
1919             if self.mountfsoptions:
1920                 if options:
1921                     options = "%s,%s" %(options, self.mountfsoptions)
1922                 else:
1923                     options = self.mountfsoptions
1924             
1925         if self.fstype == 'smfs':
1926             if options:
1927                 options = "%s,type=%s,dev=%s" %(options, self.backfstype, 
1928                                                 blkdev)
1929             else:
1930                 options = "type=%s,dev=%s" %(self.backfstype, 
1931                                              blkdev)
1932         
1933         if self.target.get_class() == 'mds':
1934             if options:
1935                 options = "%s,acl,user_xattr,iopen_nopriv" %(options)
1936             else:
1937                 options = "iopen_nopriv"
1938             
1939         return options
1940
1941     def prepare(self):
1942         if is_prepared(self.name):
1943             return
1944         
1945         blkdev = block_dev(self.devpath, self.size, self.fstype,
1946                            config.reformat, self.format, self.journal_size,
1947                            self.inode_size, self.mkfsoptions, self.backfstype,
1948                            self.backdevpath)
1949
1950         if self.fstype == 'smfs':
1951             realdev = blkdev
1952         else:
1953             realdev = blkdev
1954                 
1955         mountfsoptions = self.get_mount_options(blkdev)
1956
1957         self.info(self.target.get_class(), realdev, mountfsoptions, 
1958                   self.fstype, self.size, self.format)
1959
1960         lctl.newdev("confobd", self.name, self.uuid, 
1961                     setup ="%s %s %s" %(realdev, self.fstype, 
1962                                         mountfsoptions))
1963
1964         self.mountfsoptions = mountfsoptions
1965         self.realdev = realdev
1966
1967     def add_module(self, manager):
1968         manager.add_lustre_module('obdclass', 'confobd')
1969
1970     def write_conf(self):
1971         if self.target.get_class() == 'ost':
1972             config.record = 1
1973             lctl.clear_log(self.name, self.target.getName() + '-conf')
1974             lctl.record(self.name, self.target.getName() + '-conf')
1975             lctl.newdev(self.osdtype, self.conf_name, self.conf_uuid,
1976                         setup ="%s %s %s %s" %(self.realdev, self.fstype,
1977                                                self.failover_ost,
1978                                                self.mountfsoptions))
1979             lctl.end_record()
1980             lctl.clear_log(self.name, 'OSS-conf')
1981             lctl.record(self.name, 'OSS-conf')
1982             lctl.newdev("ost", 'OSS', 'OSS_UUID', setup ="")
1983             lctl.end_record()
1984             config.record = 0
1985             return
1986
1987         if self.target.get_class() == 'mds':
1988             if self.master != None:
1989                 master_name = self.master.name
1990             else:
1991                 master_name = 'dumb'
1992
1993             config.record = 1
1994             lctl.clear_log(self.name, self.target.getName() + '-conf')
1995             lctl.record(self.name, self.target.getName() + '-conf')
1996             lctl.attach("mds", self.conf_name, self.conf_uuid)
1997             if self.mds_sec:
1998                 lctl.set_security(self.conf_name, "mds_sec", self.mds_sec)
1999             if self.oss_sec:
2000                 lctl.set_security(self.conf_name, "oss_sec", self.oss_sec)
2001             if self.deny_sec:
2002                 for flavor in string.split(self.deny_sec, ','):
2003                     lctl.set_security(self.conf_name, "deny_sec", flavor)
2004             lctl.newdev("mds", self.conf_name, self.conf_uuid,
2005                         setup ="%s %s %s %s %s %s" %(self.realdev, self.fstype,
2006                                                      self.conf_name, self.mountfsoptions,
2007                                                      master_name, self.obdtype))
2008             lctl.end_record()
2009             config.record = 0
2010
2011         if not self.client_uuids:
2012             return 0
2013
2014         for uuid in self.client_uuids:
2015             log("recording client:", uuid)
2016             client_uuid = generate_client_uuid(self.name)
2017             client = VOSC(self.db.lookup(uuid), client_uuid, 
2018                           self.target.getName(), self.name)
2019             config.record = 1
2020             lctl.clear_log(self.name, self.target.getName())
2021             lctl.record(self.name, self.target.getName())
2022             client.prepare()
2023             lctl.mount_option(self.target.getName(), client.get_name(), "", "")
2024             lctl.end_record()
2025
2026             config.cleanup = 1
2027             lctl.clear_log(self.name, self.target.getName() + '-clean')
2028             lctl.record(self.name, self.target.getName() + '-clean')
2029             client.cleanup()
2030             lctl.del_mount_option(self.target.getName())
2031             lctl.end_record()
2032             config.cleanup = 0
2033             config.record = 0
2034
2035         if config.record:
2036             return
2037
2038         # record logs for each client
2039         if config.ldapurl:
2040             config_options = "--ldapurl " + config.ldapurl + " --config " + config.config
2041         else:
2042             config_options = CONFIG_FILE
2043
2044         for node_db in self.db.lookup_class('node'):
2045             client_name = node_db.getName()
2046             for prof_uuid in node_db.get_refs('profile'):
2047                 prof_db = node_db.lookup(prof_uuid)
2048                 # refactor this into a funtion to test "clientness"
2049                 # of a node.
2050                 for ref_class, ref_uuid in prof_db.get_all_refs():
2051                     if ref_class in ('mountpoint','echoclient'):
2052                         debug("recording", client_name)
2053                         old_noexec = config.noexec
2054                         config.noexec = 0
2055                         noexec_opt = ('', '-n')
2056                         ret, out = run (sys.argv[0],
2057                                         noexec_opt[old_noexec == 1],
2058                                         " -v --record --nomod",
2059                                         "--record_log", client_name,
2060                                         "--record_device", self.name,
2061                                         "--node", client_name,
2062                                         config_options)
2063                         if config.verbose:
2064                             for s in out: log("record> ", string.strip(s))
2065                         ret, out = run (sys.argv[0],
2066                                         noexec_opt[old_noexec == 1],
2067                                         "--cleanup -v --record --nomod",
2068                                         "--record_log", client_name + "-clean",
2069                                         "--record_device", self.name,
2070                                         "--node", client_name,
2071                                         config_options)
2072                         if config.verbose:
2073                             for s in out: log("record> ", string.strip(s))
2074                         config.noexec = old_noexec
2075
2076     def start(self):
2077          try:
2078             lctl.start(self.name, self.conf_name)
2079          except CommandError, e:
2080             raise e
2081          if self.target.get_class() == 'ost':
2082              if not is_prepared('OSS'):
2083                  try:
2084                      lctl.start(self.name, 'OSS')
2085                  except CommandError, e:
2086                      raise e
2087
2088     def cleanup(self):
2089         if is_prepared(self.name):
2090             try:
2091                 lctl.cleanup(self.name, self.uuid, 0, 0)
2092                 clean_dev(self.devpath, self.fstype, 
2093                           self.backfstype, self.backdevpath)
2094             except CommandError, e:
2095                 log(self.module_name, "cleanup failed: ", self.name)
2096                 e.dump()
2097                 cleanup_error(e.rc)
2098                 Module.cleanup(self)
2099
2100 class MDSDEV(Module):
2101     def __init__(self,db):
2102         Module.__init__(self, 'MDSDEV', db)
2103         self.devpath = self.db.get_val('devpath','')
2104         self.backdevpath = self.db.get_val('devpath','')
2105         self.size = self.db.get_val_int('devsize', 0)
2106         self.journal_size = self.db.get_val_int('journalsize', 0)
2107         self.fstype = self.db.get_val('fstype', '')
2108         self.backfstype = self.db.get_val('backfstype', '')
2109         self.nspath = self.db.get_val('nspath', '')
2110         self.mkfsoptions = self.db.get_val('mkfsoptions', '')
2111         self.mountfsoptions = self.db.get_val('mountfsoptions', '')
2112         self.obdtype = self.db.get_val('obdtype', '')
2113         self.root_squash = self.db.get_val('root_squash', '')
2114         self.no_root_squash = self.db.get_val('no_root_squash', '')
2115
2116         target_uuid = self.db.get_first_ref('target')
2117         self.target = self.db.lookup(target_uuid)
2118         self.name = self.target.getName()
2119         self.master = None
2120         self.lmv = None
2121         
2122         lmv_uuid = self.db.get_first_ref('lmv')
2123         if lmv_uuid != None:
2124             self.lmv = self.db.lookup(lmv_uuid)
2125
2126         active_uuid = get_active_target(self.target)
2127         if not active_uuid:
2128             panic("No target device found:", target_uuid)
2129         if active_uuid == self.uuid:
2130             self.active = 1
2131             group = self.target.get_val('group')
2132             if config.group and config.group != group:
2133                 self.active = 0
2134         else:
2135             self.active = 0
2136
2137         self.uuid = target_uuid
2138
2139         # setup LMV
2140         if self.lmv != None:
2141             client_uuid = self.name + "_lmv_UUID"
2142             self.master = LMV(self.lmv, client_uuid, 
2143                               self.name, self.name)
2144                               
2145         self.confobd = CONFDEV(self.db, self.name, 
2146                                target_uuid, self.uuid)
2147
2148     def add_module(self, manager):
2149         if self.active:
2150             manager.add_lustre_module('mdc', 'mdc')
2151             manager.add_lustre_module('osc', 'osc')
2152             manager.add_lustre_module('ost', 'ost')
2153             manager.add_lustre_module('lov', 'lov')
2154             manager.add_lustre_module('mds', 'mds')
2155
2156             if self.fstype == 'smfs' or self.fstype == 'ldiskfs':
2157                 manager.add_lustre_module(self.fstype, self.fstype)
2158                 
2159             if self.fstype:
2160                 manager.add_lustre_module('lvfs', 'fsfilt_%s' % (self.fstype))
2161             
2162             # if fstype is smfs, then we should also take care about backing 
2163             # store fs.
2164             if self.fstype == 'smfs':
2165                 manager.add_lustre_module(self.backfstype, self.backfstype)
2166                 manager.add_lustre_module('lvfs', 'fsfilt_%s' % (self.backfstype))
2167
2168             for option in string.split(self.mountfsoptions, ','):
2169                 if option == 'snap':
2170                     if not self.fstype == 'smfs':
2171                         panic("mountoptions has 'snap', but fstype is not smfs.")
2172                     manager.add_lustre_module('lvfs', 'fsfilt_snap_%s' % (self.fstype))
2173                     manager.add_lustre_module('lvfs', 'fsfilt_snap_%s' % (self.backfstype))
2174
2175         # add LMV modules
2176         if self.master != None:
2177             self.master.add_module(manager)
2178  
2179         # add CONFOBD modules
2180         if self.confobd != None:
2181             self.confobd.add_module(manager)
2182             
2183     def write_conf(self):
2184         if is_prepared(self.name):
2185             return
2186         if not self.active:
2187             debug(self.uuid, "not active")
2188             return
2189         run_acceptors()
2190         self.confobd.prepare()
2191         self.confobd.write_conf()
2192         self.confobd.cleanup()
2193
2194     def prepare(self):
2195         if is_prepared(self.name):
2196             return
2197         if not self.active:
2198             debug(self.uuid, "not active")
2199             return
2200         run_acceptors()
2201
2202         self.confobd.prepare()
2203         if config.reformat:
2204             self.confobd.write_conf()
2205
2206         # prepare LMV
2207         if self.master != None:
2208              self.master.prepare()
2209
2210         if not config.record:
2211             self.confobd.start()
2212         
2213         if not is_prepared('MDT'):
2214             lctl.newdev("mdt", 'MDT', 'MDT_UUID', setup ="")
2215
2216         if development_mode():
2217             # set lsd upcall path
2218             procentry = "/proc/fs/lustre/mds/lsd_upcall"
2219             upcall = os.path.abspath(os.path.dirname(sys.argv[0]) + "/lsd_upcall")
2220             if not (os.access(procentry, os.R_OK) and os.access(upcall, os.R_OK)):
2221                 print "MDS Warning: failed to set lsd cache upcall"
2222             else:
2223                 run("echo ", upcall, " > ", procentry)
2224             # set lacl upcall path
2225             procentry = "/proc/fs/lustre/mds/lacl_upcall"
2226             upcall = os.path.abspath(os.path.dirname(sys.argv[0]) + "/lacl_upcall")
2227             if not (os.access(procentry, os.R_OK) and os.access(upcall, os.R_OK)):
2228                 print "MDS Warning: failed to set remote acl upcall"
2229             else:
2230                 run("echo ", upcall, " > ", procentry)
2231
2232         if config.root_squash == None:
2233             config.root_squash = self.root_squash
2234         if config.no_root_squash == None:
2235             config.no_root_squash = self.no_root_squash
2236         if config.root_squash:
2237             if config.no_root_squash:
2238                 nsnid = config.no_root_squash
2239             else:
2240                 nsnid = "0"
2241             lctl.root_squash(self.name, config.root_squash, nsnid)
2242
2243     def msd_remaining(self):
2244         out = lctl.device_list()
2245         for s in out:
2246             if string.split(s)[2] in ('mds',):
2247                 return 1
2248
2249     def safe_to_clean(self):
2250         return self.active
2251
2252     def safe_to_clean_modules(self):
2253         return not self.msd_remaining()
2254         
2255     def cleanup(self):
2256         if not self.active:
2257             debug(self.uuid, "not active")
2258             return
2259         self.info()
2260         if is_prepared(self.name):
2261             try:
2262                 lctl.cleanup(self.name, self.uuid, config.force,
2263                              config.failover)
2264             except CommandError, e:
2265                 log(self.module_name, "cleanup failed: ", self.name)
2266                 e.dump()
2267                 cleanup_error(e.rc)
2268                 Module.cleanup(self)
2269             # cleanup LMV
2270             if self.master != None:
2271                 self.master.cleanup()
2272         if not self.msd_remaining() and is_prepared('MDT'):
2273             try:
2274                 lctl.cleanup("MDT", "MDT_UUID", config.force,
2275                              config.failover)
2276             except CommandError, e:
2277                 print "cleanup failed: ", self.name
2278                 e.dump()
2279                 cleanup_error(e.rc)
2280         
2281         if self.confobd:
2282             self.confobd.cleanup()
2283
2284     def correct_level(self, level, op=None):
2285         #if self.master != None:
2286         #   level = level + 2
2287         return level
2288         
2289 class OSD(Module):
2290     def __init__(self, db):
2291         Module.__init__(self, 'OSD', db)
2292         self.osdtype = self.db.get_val('osdtype')
2293         self.devpath = self.db.get_val('devpath', '')
2294         self.backdevpath = self.db.get_val('devpath', '')
2295         self.size = self.db.get_val_int('devsize', 0)
2296         self.journal_size = self.db.get_val_int('journalsize', 0)
2297         self.inode_size = self.db.get_val_int('inodesize', 0)
2298         self.mkfsoptions = self.db.get_val('mkfsoptions', '')
2299         self.mountfsoptions = self.db.get_val('mountfsoptions', '')
2300         self.fstype = self.db.get_val('fstype', '')
2301         self.backfstype = self.db.get_val('backfstype', '')
2302         self.nspath = self.db.get_val('nspath', '')
2303         target_uuid = self.db.get_first_ref('target')
2304         ost = self.db.lookup(target_uuid)
2305         self.name = ost.getName()
2306         self.format = self.db.get_val('autoformat', 'yes')
2307         if ost.get_val('failover', 0):
2308             self.failover_ost = 'f'
2309         else:
2310             self.failover_ost = 'n'
2311
2312         self.deny_sec = self.db.get_val('deny_sec', '')
2313
2314         if config.ost_deny_sec:
2315             if self.deny_sec:
2316                 self.deny_sec = "%s,%s" %(self.deny_sec, config.ost_deny_sec)
2317             else:
2318                 self.deny_sec = config.ost_deny_sec
2319
2320         active_uuid = get_active_target(ost)
2321         if not active_uuid:
2322             panic("No target device found:", target_uuid)
2323         if active_uuid == self.uuid:
2324             self.active = 1
2325             group = ost.get_val('group')
2326             if config.group and config.group != group:
2327                 self.active = 0
2328         else:
2329             self.active = 0
2330
2331         self.uuid = target_uuid
2332         self.confobd = CONFDEV(self.db, self.name, 
2333                                target_uuid, self.uuid)
2334
2335     def add_module(self, manager):
2336         if not self.active:
2337             return
2338         manager.add_lustre_module('ost', 'ost')
2339             
2340         if self.fstype == 'smfs' or self.fstype == 'ldiskfs':
2341             manager.add_lustre_module(self.fstype, self.fstype)
2342                 
2343         if self.fstype:
2344             manager.add_lustre_module('lvfs' , 'fsfilt_%s' % (self.fstype))
2345
2346         if self.fstype == 'smfs':
2347             manager.add_lustre_module(self.backfstype, self.backfstype)
2348             manager.add_lustre_module('lvfs' , 'fsfilt_%s' % (self.backfstype))
2349
2350         for option in self.mountfsoptions:
2351             if option == 'snap':
2352                 if not self.fstype == 'smfs':
2353                     panic("mountoptions with snap, but fstype is not smfs\n")
2354                 manager.add_lustre_module('lvfs', 'fsfilt_snap_%s' % (self.fstype))
2355                 manager.add_lustre_module('lvfs', 'fsfilt_snap_%s' % (self.backfstype))
2356
2357         manager.add_lustre_module(self.osdtype, self.osdtype)
2358         
2359         # add CONFOBD modules
2360         if self.confobd != None:
2361             self.confobd.add_module(manager)
2362
2363     def prepare(self):
2364         if is_prepared(self.name):
2365             return
2366         if not self.active:
2367             debug(self.uuid, "not active")
2368             return
2369
2370         run_acceptors()
2371
2372         if self.osdtype == 'obdecho':
2373             self.info(self.osdtype)
2374             lctl.newdev("obdecho", self.name, self.uuid)
2375             if not is_prepared('OSS'):
2376                 lctl.newdev("ost", 'OSS', 'OSS_UUID', setup="")
2377         else:
2378             self.confobd.prepare()
2379             if config.reformat:
2380                 self.confobd.write_conf()
2381             if not config.record:
2382                 self.confobd.start()        
2383
2384         if self.deny_sec:
2385             for flavor in string.split(self.deny_sec, ','):
2386                 lctl.set_security(self.name, "deny_sec", flavor)
2387
2388     def write_conf(self):
2389         if is_prepared(self.name):
2390             return
2391         if not self.active:
2392             debug(self.uuid, "not active")
2393             return
2394                                                                                                                
2395         run_acceptors()
2396         if self.osdtype != 'obdecho':
2397             self.confobd.prepare()
2398             self.confobd.write_conf()
2399             if not config.write_conf:
2400                 self.confobd.start()
2401             self.confobd.cleanup()
2402
2403     def osd_remaining(self):
2404         out = lctl.device_list()
2405         for s in out:
2406             if string.split(s)[2] in ('obdfilter', 'obdecho'):
2407                 return 1
2408
2409     def safe_to_clean(self):
2410         return self.active
2411
2412     def safe_to_clean_modules(self):
2413         return not self.osd_remaining()
2414
2415     def cleanup(self):
2416         if not self.active:
2417             debug(self.uuid, "not active")
2418             return
2419             
2420         if is_prepared(self.name):
2421             self.info()
2422             try:
2423                 lctl.cleanup(self.name, self.uuid, config.force,
2424                              config.failover)
2425             except CommandError, e:
2426                 log(self.module_name, "cleanup failed: ", self.name)
2427                 e.dump()
2428                 cleanup_error(e.rc)
2429         if not self.osd_remaining() and is_prepared('OSS'):
2430             try:
2431                 lctl.cleanup("OSS", "OSS_UUID", config.force,
2432                              config.failover)
2433             except CommandError, e:
2434                 print "cleanup failed: ", self.name
2435                 e.dump()
2436                 cleanup_error(e.rc)
2437
2438         if self.osdtype != 'obdecho':
2439             if self.confobd:
2440                 self.confobd.cleanup()
2441
2442     def correct_level(self, level, op=None):
2443         return level
2444
2445 # Generic client module, used by OSC and MDC
2446 class Client(Module):
2447     def __init__(self, tgtdb, uuid, module, fs_name, 
2448                  self_name=None, module_dir=None):
2449         self.target_name = tgtdb.getName()
2450         self.target_uuid = tgtdb.getUUID()
2451         self.module_dir = module_dir
2452         self.backup_targets = []
2453         self.module = module
2454         self.db = tgtdb
2455
2456         self.tgt_dev_uuid = get_active_target(tgtdb)
2457         if not self.tgt_dev_uuid:
2458             panic("No target device found for target(1):", self.target_name)
2459
2460         self._server = None
2461         self._connected = 0
2462
2463         self.module = module
2464         self.module_name = string.upper(module)
2465         if not self_name:
2466             self.name = '%s_%s_%s_%s' % (self.module_name, socket.gethostname(),
2467                                          self.target_name, fs_name)
2468         else:
2469             self.name = self_name
2470         self.uuid = uuid
2471         self.lookup_server(self.tgt_dev_uuid)
2472         self.lookup_backup_targets()
2473         self.fs_name = fs_name
2474         if not self.module_dir:
2475             self.module_dir = module
2476
2477     def add_module(self, manager):
2478         manager.add_lustre_module(self.module_dir, self.module)
2479
2480     def lookup_server(self, srv_uuid):
2481         """ Lookup a server's network information """
2482         self._server_nets = get_ost_net(self.db, srv_uuid)
2483         if len(self._server_nets) == 0:
2484             panic ("Unable to find a server for:", srv_uuid)
2485             
2486     def get_name(self):
2487         return self.name
2488
2489     def get_servers(self):
2490         return self._server_nets
2491
2492     def lookup_backup_targets(self):
2493         """ Lookup alternative network information """
2494         prof_list = toplustreDB.get_refs('profile')
2495         for prof_uuid in prof_list:
2496             prof_db = toplustreDB.lookup(prof_uuid)
2497             if not prof_db:
2498                 panic("profile:", prof_uuid, "not found.")
2499             for ref_class, ref_uuid in prof_db.get_all_refs():
2500                 if ref_class in ('osd', 'mdsdev'):
2501                     devdb = toplustreDB.lookup(ref_uuid)
2502                     uuid = devdb.get_first_ref('target')
2503                     if self.target_uuid == uuid and self.tgt_dev_uuid != ref_uuid:
2504                         self.backup_targets.append(ref_uuid)
2505
2506     def prepare(self, ignore_connect_failure = 0):
2507         self.info(self.target_uuid)
2508         if not config.record and is_prepared(self.name):
2509             self.cleanup()
2510         try:
2511             srv = choose_local_server(self.get_servers())
2512             if srv:
2513                 lctl.connect(srv)
2514             else:
2515                 routes = find_route(self.get_servers())
2516                 if len(routes) == 0:
2517                     panic ("no route to",  self.target_uuid)
2518                 for (srv, r) in routes:
2519                     lctl.add_route_host(r[0], srv.nid_uuid, r[1], r[3])
2520         except CommandError, e:
2521             if not ignore_connect_failure:
2522                 raise e
2523
2524         if srv:
2525             if self.target_uuid in config.inactive and self.permits_inactive():
2526                 debug("%s inactive" % self.target_uuid)
2527                 inactive_p = "inactive"
2528             else:
2529                 debug("%s active" % self.target_uuid)
2530                 inactive_p = ""
2531             lctl.newdev(self.module, self.name, self.uuid,
2532                         setup ="%s %s %s" % (self.target_uuid, srv.nid_uuid,
2533                                                 inactive_p))
2534         for tgt_dev_uuid in self.backup_targets:
2535             this_nets = get_ost_net(toplustreDB, tgt_dev_uuid)
2536             if len(this_nets) == 0:
2537                 panic ("Unable to find a server for:", tgt_dev_uuid)
2538             srv = choose_local_server(this_nets)
2539             if srv:
2540                 lctl.connect(srv)
2541             else:
2542                 routes = find_route(this_nets);
2543                 if len(routes) == 0:
2544                     panic("no route to", tgt_dev_uuid)
2545                 for (srv, r) in routes:
2546                     lctl.add_route_host(r[0]. srv.nid_uuid, r[1], r[3])
2547             if srv:
2548                 lctl.add_conn(self.name, srv.nid_uuid);
2549
2550     def cleanup(self):
2551         if is_prepared(self.name):
2552             Module.cleanup(self)
2553             try:
2554                 srv = choose_local_server(self.get_servers())
2555                 if srv:
2556                     lctl.disconnect(srv)
2557                 else:
2558                     for (srv, r) in find_route(self.get_servers()):
2559                         lctl.del_route_host(r[0], srv.nid_uuid, r[1], r[3])
2560             except CommandError, e:
2561                 log(self.module_name, "cleanup failed: ", self.name)
2562                 e.dump()
2563                 cleanup_error(e.rc)
2564
2565             for tgt_dev_uuid in self.backup_targets:
2566                 this_net = get_ost_net(toplustreDB, tgt_dev_uuid)
2567                 srv = choose_local_server(this_net)
2568                 if srv:
2569                     lctl.disconnect(srv)
2570                 else:
2571                     for (srv, r) in find_route(this_net):
2572                         lctl.del_route_host(r[0]. srv.nid_uuid, r[1], r[3])
2573
2574     def correct_level(self, level, op=None):
2575         return level
2576
2577     def deactivate(self):
2578         try:
2579             lctl.deactivate(self.name)
2580         except CommandError, e:
2581             log(self.module_name, "deactivate failed: ", self.name)
2582             e.dump()
2583             cleanup_error(e.rc)
2584
2585 class GKC(Client):
2586     def __init__(self, db, uuid, fs_name):
2587          Client.__init__(self, db, uuid, 'gkc', fs_name)
2588
2589     def permits_inactive(self):
2590         return 0
2591
2592 class MDC(Client):
2593     def __init__(self, db, uuid, fs_name):
2594          Client.__init__(self, db, uuid, 'mdc', fs_name)
2595
2596     def permits_inactive(self):
2597         return 0
2598
2599 class OSC(Client):
2600     def __init__(self, db, uuid, fs_name):
2601          Client.__init__(self, db, uuid, 'osc', fs_name)
2602
2603     def permits_inactive(self):
2604         return 1
2605
2606 class CMOBD(Module):
2607     def __init__(self, db):
2608         Module.__init__(self, 'CMOBD', db)
2609         self.name = self.db.getName(); 
2610         self.uuid = generate_client_uuid(self.name)
2611         self.master_uuid = self.db.get_first_ref('masterobd')
2612         self.cache_uuid = self.db.get_first_ref('cacheobd')
2613
2614         master_obd = self.db.lookup(self.master_uuid)
2615         if not master_obd:
2616             panic('master obd not found:', self.master_uuid)
2617
2618         cache_obd = self.db.lookup(self.cache_uuid)
2619         if not cache_obd:
2620             panic('cache obd not found:', self.cache_uuid)
2621             
2622         self.master = None
2623         self.cache = None
2624             
2625         master_class = master_obd.get_class()
2626         cache_class = cache_obd.get_class()
2627
2628         if master_class == 'ost' or master_class == 'lov':
2629             client_uuid = "%s_lov_master_UUID" % (self.name)
2630             self.master = LOV(master_obd, client_uuid, self.name,
2631                               "master_%s" % (self.name));
2632         elif master_class == 'mds':
2633             self.master = get_mdc(db, self.name, self.master_uuid) 
2634         elif master_class == 'lmv':
2635             client_uuid = "%s_lmv_master_UUID" % (self.name)
2636             self.master = LMV(master_obd, client_uuid, self.name, 
2637                               "master_%s" % (self.name));
2638         else:
2639             panic("unknown master obd class '%s'" %(master_class))
2640             
2641         if cache_class == 'ost' or cache_class == 'lov':
2642             client_uuid = "%s_lov_cache_UUID" % (self.name)
2643             self.cache = LOV(cache_obd, client_uuid, self.name,
2644                              "cache_%s" % (self.name));
2645         elif cache_class == 'mds':
2646             self.cache = get_mdc(db, self.name, self.cache_uuid)
2647         elif cache_class == 'lmv':
2648             client_uuid = "%s_lmv_cache_UUID" % (self.name) 
2649             self.cache = LMV(cache_obd, client_uuid, self.name, 
2650                              "cache_%s" % (self.name));
2651         else:
2652             panic("unknown cache obd class '%s'" %(cache_class))
2653
2654     def prepare(self):
2655         self.master.prepare()
2656         if not config.record and is_prepared(self.name):
2657             return
2658         self.info(self.master_uuid, self.cache_uuid)
2659         lctl.newdev("cmobd", self.name, self.uuid,
2660                     setup ="%s %s" %(self.master.uuid,
2661                                      self.cache.uuid))
2662
2663     def get_uuid(self):
2664         return self.uuid
2665         
2666     def get_name(self):
2667         return self.name
2668         
2669     def get_master_name(self):
2670         return self.master.name
2671             
2672     def get_cache_name(self):
2673         return self.cache.name
2674
2675     def cleanup(self):
2676         if is_prepared(self.name):
2677             Module.cleanup(self)
2678         if self.master:
2679             self.master.cleanup()
2680
2681     def add_module(self, manager):
2682         manager.add_lustre_module('smfs', 'smfs')
2683         manager.add_lustre_module('cmobd', 'cmobd')
2684         self.master.add_module(manager)
2685
2686     def correct_level(self, level, op=None):
2687         return level
2688
2689 class COBD(Module):
2690     def __init__(self, db, uuid, name):
2691         Module.__init__(self, 'COBD', db)
2692         self.name = self.db.getName(); 
2693         self.uuid = generate_client_uuid(self.name)
2694         self.master_uuid = self.db.get_first_ref('masterobd')
2695         self.cache_uuid = self.db.get_first_ref('cacheobd')
2696
2697         master_obd = self.db.lookup(self.master_uuid)
2698         if not master_obd:
2699             panic('master obd not found:', self.master_uuid)
2700
2701         cache_obd = self.db.lookup(self.cache_uuid)
2702         if not cache_obd:
2703             panic('cache obd not found:', self.cache_uuid)
2704             
2705         self.master = None
2706         self.cache = None
2707
2708         master_class = master_obd.get_class()
2709         cache_class = cache_obd.get_class()
2710
2711         if master_class == 'ost' or master_class == 'lov':
2712             client_uuid = "%s_lov_master_UUID" % (self.name)
2713             self.master = LOV(master_obd, client_uuid, name,
2714                               "master_%s" % (self.name));
2715         elif master_class == 'mds':
2716             self.master = get_mdc(db, name, self.master_uuid) 
2717         elif master_class == 'lmv':
2718             client_uuid = "%s_lmv_master_UUID" % (self.name)
2719             self.master = LMV(master_obd, client_uuid, self.name, 
2720                               "master_%s" % (self.name));
2721         else:
2722             panic("unknown master obd class '%s'" %(master_class))
2723             
2724         if cache_class == 'ost' or cache_class == 'lov':
2725             client_uuid = "%s_lov_cache_UUID" % (self.name)
2726             self.cache = LOV(cache_obd, client_uuid, name,
2727                              "cache_%s" % (self.name));
2728         elif cache_class == 'mds':
2729             self.cache = get_mdc(db, name, self.cache_uuid)
2730         elif cache_class == 'lmv':
2731             client_uuid = "%s_lmv_cache_UUID" % (self.name)
2732             self.cache = LMV(cache_obd, client_uuid, self.name, 
2733                              "cache_%s" % (self.name));
2734         else:
2735             panic("unknown cache obd class '%s'" %(cache_class))
2736             
2737     def get_uuid(self):
2738         return self.uuid
2739
2740     def get_name(self):
2741         return self.name
2742
2743     def get_master_name(self):
2744         return self.master.name
2745
2746     def get_cache_name(self):
2747         return self.cache.name
2748
2749     def prepare(self):
2750         if not config.record and is_prepared(self.name):
2751             return
2752         self.master.prepare()
2753         self.cache.prepare()
2754         self.info(self.master_uuid, self.cache_uuid)
2755         lctl.newdev("cobd", self.name, self.uuid,
2756                     setup ="%s %s" %(self.master.name,
2757                                      self.cache.name))
2758
2759     def cleanup(self):
2760         if is_prepared(self.name):
2761             Module.cleanup(self)
2762         self.master.cleanup()
2763         self.cache.cleanup()
2764
2765     def add_module(self, manager):
2766         manager.add_lustre_module('cobd', 'cobd')
2767         self.master.add_module(manager)
2768
2769 # virtual interface for  OSC and LOV
2770 class VOSC(Module):
2771     def __init__(self, db, client_uuid, name, name_override = None):
2772         Module.__init__(self, 'VOSC', db)
2773         if db.get_class() == 'lov':
2774             self.osc = LOV(db, client_uuid, name, name_override)
2775             self.type = 'lov'
2776         elif db.get_class() == 'cobd':
2777             self.osc = COBD(db, client_uuid, name)
2778             self.type = 'cobd'
2779         else:
2780             self.osc = OSC(db, client_uuid, name)
2781             self.type = 'osc'
2782             
2783     def get_uuid(self):
2784         return self.osc.get_uuid()
2785
2786     def get_name(self):
2787         return self.osc.get_name()
2788
2789     def prepare(self):
2790         self.osc.prepare()
2791         
2792     def cleanup(self):
2793         self.osc.cleanup()
2794         
2795     def add_module(self, manager):
2796         self.osc.add_module(manager)
2797         
2798     def correct_level(self, level, op=None):
2799         return self.osc.correct_level(level, op)
2800
2801 # virtual interface for MDC and LMV
2802 class VMDC(Module):
2803     def __init__(self, db, client_uuid, name, name_override = None):
2804         Module.__init__(self, 'VMDC', db)
2805         if db.get_class() == 'lmv':
2806             self.mdc = LMV(db, client_uuid, name, name_override)
2807         elif db.get_class() == 'cobd':
2808             self.mdc = COBD(db, client_uuid, name)
2809         else:
2810             self.mdc = MDC(db, client_uuid, name)
2811             
2812     def get_uuid(self):
2813         return self.mdc.uuid
2814
2815     def get_name(self):
2816         return self.mdc.name
2817
2818     def prepare(self):
2819         self.mdc.prepare()
2820         
2821     def cleanup(self):
2822         self.mdc.cleanup()
2823         
2824     def add_module(self, manager):
2825         self.mdc.add_module(manager)
2826         
2827     def correct_level(self, level, op=None):
2828         return self.mdc.correct_level(level, op)
2829
2830 class ECHO_CLIENT(Module):
2831     def __init__(self,db):
2832         Module.__init__(self, 'ECHO_CLIENT', db)
2833         self.obd_uuid = self.db.get_first_ref('obd')
2834         obd = self.db.lookup(self.obd_uuid)
2835         self.uuid = generate_client_uuid(self.name)
2836         self.osc = VOSC(obd, self.uuid, self.name)
2837
2838     def prepare(self):
2839         if not config.record and is_prepared(self.name):
2840             return
2841         run_acceptors()
2842         self.osc.prepare() # XXX This is so cheating. -p
2843         self.info(self.obd_uuid)
2844
2845         lctl.newdev("echo_client", self.name, self.uuid,
2846                     setup = self.osc.get_name())
2847
2848     def cleanup(self):
2849         if is_prepared(self.name):
2850             Module.cleanup(self)
2851         self.osc.cleanup()
2852
2853     def add_module(self, manager):
2854         self.osc.add_module(manager)
2855         manager.add_lustre_module('obdecho', 'obdecho')
2856
2857     def correct_level(self, level, op=None):
2858         return level
2859
2860 def generate_client_uuid(name):
2861         client_uuid = '%05x_%.19s_%05x%05x' % (int(random.random() * 1048576),
2862                                                name,
2863                                                int(random.random() * 1048576),
2864                                                int(random.random() * 1048576))
2865         return client_uuid[:36]
2866
2867 class Mountpoint(Module):
2868     def __init__(self,db):
2869         Module.__init__(self, 'MTPT', db)
2870         self.path = self.db.get_val('path')
2871         self.clientoptions = self.db.get_val('clientoptions', '')
2872         self.fs_uuid = self.db.get_first_ref('filesystem')
2873         fs = self.db.lookup(self.fs_uuid)
2874         self.mds_uuid = fs.get_first_ref('lmv')
2875         if not self.mds_uuid:
2876             self.mds_uuid = fs.get_first_ref('mds')
2877         self.obd_uuid = fs.get_first_ref('obd')
2878         self.gks_uuid =fs.get_first_ref('gks')
2879         client_uuid = generate_client_uuid(self.name)
2880
2881         self.oss_sec = self.db.get_val('oss_sec','null')
2882         self.mds_sec = self.db.get_val('mds_sec','null')
2883         if config.mds_sec:
2884             self.mds_sec = config.mds_sec
2885         if config.oss_sec:
2886             self.oss_sec = config.oss_sec
2887
2888         self.oss_sec = self.db.get_val('oss_sec','null')
2889         self.mds_sec = self.db.get_val('mds_sec','null')
2890         if config.mds_sec:
2891             self.mds_sec = config.mds_sec
2892         if config.oss_sec:
2893             self.oss_sec = config.oss_sec
2894
2895         ost = self.db.lookup(self.obd_uuid)
2896         if not ost:
2897             panic("no ost: ", self.obd_uuid)
2898             
2899         mds = self.db.lookup(self.mds_uuid)
2900         if not mds:
2901             panic("no mds: ", self.mds_uuid)
2902        
2903         self.vosc = VOSC(ost, client_uuid, self.name, self.name)
2904         self.vmdc = VMDC(mds, client_uuid, self.name, self.name)
2905
2906         if self.gks_uuid:
2907             self.gkc = get_gkc(db, client_uuid, self.name, self.gks_uuid)      
2908     def prepare(self):
2909         if not config.record and fs_is_mounted(self.path):
2910             log(self.path, "already mounted.")
2911             return
2912         run_acceptors()
2913
2914         self.vosc.prepare()
2915         self.vmdc.prepare()
2916         if self.gks_uuid:
2917            self.gkc.prepare()
2918
2919         self.info(self.path, self.mds_uuid, self.obd_uuid)
2920         if config.record or config.lctl_dump:
2921             if self.gks_uuid:
2922                 lctl.mount_option(local_node_name, self.vosc.get_name(), 
2923                                   self.vmdc.get_name(), self.gkc.get_name())
2924             else:
2925                 lctl.mount_option(local_node_name, self.vosc.get_name(), 
2926                                   self.vmdc.get_name(), "")
2927             return
2928
2929         if config.clientoptions:
2930             if self.clientoptions:
2931                 self.clientoptions = self.clientoptions + ',' + config.clientoptions
2932             else:
2933                 self.clientoptions = config.clientoptions
2934         if self.clientoptions:
2935             self.clientoptions = ',' + self.clientoptions
2936             # Linux kernel will deal with async and not pass it to ll_fill_super,
2937             # so replace it with Lustre async
2938             self.clientoptions = string.replace(self.clientoptions, "async", "lasync")
2939
2940         if self.gks_uuid:
2941             gkc_name = self.gkc.get_name();
2942         else:
2943             gkc_name = "null"   
2944         cmd = "mount -t lustre_lite -o osc=%s,mdc=%s,gkc=%s,mds_sec=%s,oss_sec=%s%s %s %s" % \
2945               (self.vosc.get_name(), self.vmdc.get_name(), gkc_name, self.mds_sec,
2946                self.oss_sec, self.clientoptions, config.config, self.path)
2947         run("mkdir", self.path)
2948         ret, val = run(cmd)
2949         if ret:
2950             self.vmdc.cleanup()            
2951             self.vosc.cleanup()
2952             panic("mount failed:", self.path, ":", string.join(val))
2953
2954     def cleanup(self):
2955         self.info(self.path, self.mds_uuid,self.obd_uuid)
2956
2957         if config.record or config.lctl_dump:
2958             lctl.del_mount_option(local_node_name)
2959         else:
2960             if fs_is_mounted(self.path):
2961                 if config.force:
2962                     (rc, out) = run("umount", "-f", self.path)
2963                 else:
2964                     (rc, out) = run("umount", self.path)
2965                 if rc:
2966                     raise CommandError('umount', out, rc)
2967
2968             if fs_is_mounted(self.path):
2969                 panic("fs is still mounted:", self.path)
2970
2971         self.vmdc.cleanup()
2972         self.vosc.cleanup()
2973         if self.gks_uuid:
2974             self.gkc.cleanup()    
2975
2976     def add_module(self, manager):
2977         self.vosc.add_module(manager)
2978         self.vmdc.add_module(manager)
2979         manager.add_lustre_module('llite', 'llite')
2980         if self.gks_uuid:
2981             manager.add_lustre_module('sec/gks', 'gkc')
2982     def correct_level(self, level, op=None):
2983         return level
2984
2985 # ============================================================
2986 # misc query functions
2987
2988 def get_ost_net(self, osd_uuid):
2989     srv_list = []
2990     if not osd_uuid:
2991         return srv_list
2992     osd = self.lookup(osd_uuid)
2993     node_uuid = osd.get_first_ref('node')
2994     node = self.lookup(node_uuid)
2995     if not node:
2996         panic("unable to find node for osd_uuid:", osd_uuid,
2997               " node_ref:", node_uuid_)
2998     for net_uuid in node.get_networks():
2999         db = node.lookup(net_uuid)
3000         srv_list.append(Network(db))
3001     return srv_list
3002
3003 # the order of iniitailization is based on level. 
3004 def getServiceLevel(self):
3005     type = self.get_class()
3006     ret=0;
3007     if type in ('network',):
3008         ret = 5
3009     elif type in ('routetbl',):
3010         ret = 6
3011     elif type in ('ldlm',):
3012         ret = 20
3013     elif type in ('osd',):
3014         ret = 30
3015     elif type in ('mdsdev',):
3016         ret = 40
3017     elif type in ('lmv', 'cobd',):
3018         ret = 45
3019     elif type in ('gkd'):
3020         ret = 50
3021     elif type in ('cmobd', 'cobd',):
3022         ret = 60 
3023     elif type in ('mountpoint', 'echoclient'):
3024         ret = 70
3025     else:
3026         panic("Unknown type: ", type)
3027
3028     if ret < config.minlevel or ret > config.maxlevel:
3029         ret = 0
3030     return ret
3031
3032 #
3033 # return list of services in a profile. list is a list of tuples
3034 # [(level, db_object),]
3035 def getServices(self):
3036     list = []
3037     for ref_class, ref_uuid in self.get_all_refs():
3038             servdb = self.lookup(ref_uuid)
3039             if servdb:
3040                 level = getServiceLevel(servdb)
3041                 if level > 0:
3042                     list.append((level, servdb))
3043             else:
3044                 panic('service not found: ' + ref_uuid)
3045
3046     list.sort()
3047     return list
3048
3049
3050 ############################################################
3051 # MDC UUID hack -
3052 # FIXME: clean this mess up!
3053 #
3054 # OSC is no longer in the xml, so we have to fake it.
3055 # this is getting ugly and begging for another refactoring
3056 def get_osc(ost_db, uuid, fs_name):
3057     osc = OSC(ost_db, uuid, fs_name)
3058     return osc
3059
3060 def get_mdc(db, fs_name, mds_uuid):
3061     mds_db = db.lookup(mds_uuid);
3062     if not mds_db:
3063         error("no mds:", mds_uuid)
3064     mdc = MDC(mds_db, mds_uuid, fs_name)
3065     return mdc
3066
3067 def get_gkc(db, uuid, fs_name, gks_uuid):
3068     gks_db = db.lookup(gks_uuid);
3069     if not gks_db:
3070         error("no gks:", gks_uuid)
3071     gkc = GKC(gks_db, uuid, fs_name)
3072     return gkc
3073
3074 ############################################################
3075 # routing ("rooting")
3076
3077 # list of (nettype, cluster_id, nid)
3078 local_clusters = []
3079
3080 def find_local_clusters(node_db):
3081     global local_clusters
3082     for netuuid in node_db.get_networks():
3083         net = node_db.lookup(netuuid)
3084         srv = Network(net)
3085         debug("add_local", netuuid)
3086         local_clusters.append((srv.net_type, srv.cluster_id, srv.nid))
3087         if srv.port > 0:
3088             if not acceptors.has_key(srv.port):
3089                 acceptors[srv.port] = AcceptorHandler(srv.port, srv.net_type)
3090
3091 # This node is a gateway.
3092 is_router = 0
3093 def node_is_router():
3094     return is_router
3095
3096 # If there are any routers found in the config, then this will be true
3097 # and all nodes will load kptlrouter.
3098 needs_router = 0
3099 def node_needs_router():
3100     return needs_router or is_router
3101
3102 # list of (nettype, gw, tgt_cluster_id, lo, hi)
3103 # Currently, these local routes are only added to kptlrouter route
3104 # table if they are needed to connect to a specific server.  This
3105 # should be changed so all available routes are loaded, and the
3106 # ptlrouter can make all the decisions.
3107 local_routes = []
3108
3109 def find_local_routes(lustre):
3110     """ Scan the lustre config looking for routers .  Build list of
3111     routes. """
3112     global local_routes, needs_router
3113     local_routes = []
3114     list = lustre.lookup_class('node')
3115     for router in list:
3116         if router.get_val_int('router', 0):
3117             needs_router = 1
3118             for (local_type, local_cluster_id, local_nid) in local_clusters:
3119                 gw = None
3120                 for netuuid in router.get_networks():
3121                     db = router.lookup(netuuid)
3122                     if (local_type == db.get_val('nettype') and
3123                        local_cluster_id == db.get_val('clusterid')):
3124                         gw = db.get_val('nid')
3125                         break
3126                 if gw:
3127                     debug("find_local_routes: gw is", gw)
3128                     for route in router.get_local_routes(local_type, gw):
3129                         local_routes.append(route)
3130     debug("find_local_routes:", local_routes)
3131
3132
3133 def choose_local_server(srv_list):
3134     for srv in srv_list:
3135         if local_cluster(srv.net_type, srv.cluster_id):
3136             return srv
3137
3138 def local_cluster(net_type, cluster_id):
3139     for cluster in local_clusters:
3140         if net_type == cluster[0] and cluster_id == cluster[1]:
3141             return 1
3142     return 0
3143
3144 def local_interface(net_type, cluster_id, nid):
3145     for cluster in local_clusters:
3146         if (net_type == cluster[0] and cluster_id == cluster[1]
3147             and nid == cluster[2]):
3148             return 1
3149     return 0
3150
3151 def find_route(srv_list):
3152     result = []
3153     frm_type = local_clusters[0][0]
3154     for srv in srv_list:
3155         debug("find_route: srv:", srv.nid, "type: ", srv.net_type)
3156         to_type = srv.net_type
3157         to = srv.nid
3158         cluster_id = srv.cluster_id
3159         debug ('looking for route to', to_type, to)
3160         for r in local_routes:
3161             debug("find_route: ", r)
3162             if  (r[3] <= to and to <= r[4]) and cluster_id == r[2]:
3163                 result.append((srv, r))
3164     return result
3165            
3166 def get_active_target(db):
3167     target_uuid = db.getUUID()
3168     target_name = db.getName()
3169     node_name = get_select(target_name)
3170     if node_name:
3171         tgt_dev_uuid = db.get_node_tgt_dev(node_name, target_uuid)
3172     else:
3173         tgt_dev_uuid = db.get_first_ref('active')
3174     return tgt_dev_uuid
3175
3176 def get_server_by_nid_uuid(db,  nid_uuid):
3177     for n in db.lookup_class("network"):
3178         net = Network(n)
3179         if net.nid_uuid == nid_uuid:
3180             return net
3181         
3182
3183 ############################################################
3184 # lconf level logic
3185 # Start a service.
3186 def newService(db):
3187     type = db.get_class()
3188     debug('Service:', type, db.getName(), db.getUUID())
3189     n = None
3190     if type == 'ldlm':
3191         n = LDLM(db)
3192     elif type == 'lov':
3193         n = LOV(db, "YOU_SHOULD_NEVER_SEE_THIS_UUID")
3194     elif type == 'network':
3195         n = Network(db)
3196     elif type == 'routetbl':
3197         n = RouteTable(db)
3198     elif type == 'osd':
3199         n = OSD(db)
3200     elif type == 'cobd':
3201         n = COBD(db, "YOU_SHOULD_NEVER_SEE_THIS_UUID")
3202     elif type == 'cmobd':
3203         n = CMOBD(db)
3204     elif type == 'mdsdev':
3205         n = MDSDEV(db)
3206     elif type == 'mountpoint':
3207         n = Mountpoint(db)
3208     elif type == 'echoclient':
3209         n = ECHO_CLIENT(db)
3210     elif type == 'lmv':
3211         n = LMV(db)
3212     elif type == 'gkd':
3213         n = GKD(db)
3214     else:
3215         panic ("unknown service type:", type)
3216     return n
3217
3218 #
3219 # Prepare the system to run lustre using a particular profile
3220 # in a the configuration. 
3221 #  * load & the modules
3222 #  * setup networking for the current node
3223 #  * make sure partitions are in place and prepared
3224 #  * initialize devices with lctl
3225 # Levels is important, and needs to be enforced.
3226 def for_each_profile(db, prof_list, operation):
3227     for prof_uuid in prof_list:
3228         prof_db = db.lookup(prof_uuid)
3229         if not prof_db:
3230             panic("profile:", prof_uuid, "not found.")
3231         services = getServices(prof_db)
3232         operation(services)
3233
3234 def magic_get_osc(db, rec, lov):
3235     if lov:
3236         lov_uuid = lov.get_uuid()
3237         lov_name = lov.osc.fs_name
3238     else:
3239         lov_uuid = rec.getAttribute('lov_uuidref')
3240         # FIXME: better way to find the mountpoint?
3241         filesystems = db.root_node.getElementsByTagName('filesystem')
3242         fsuuid = None
3243         for fs in filesystems:
3244             ref = fs.getElementsByTagName('obd_ref')
3245             if ref[0].getAttribute('uuidref') == lov_uuid:
3246                 fsuuid = fs.getAttribute('uuid')
3247                 break
3248
3249         if not fsuuid:
3250             panic("malformed xml: lov uuid '" + lov_uuid + "' referenced in 'add' record is not used by any filesystems.")
3251
3252         mtpts = db.root_node.getElementsByTagName('mountpoint')
3253         lov_name = None
3254         for fs in mtpts:
3255             ref = fs.getElementsByTagName('filesystem_ref')
3256             if ref[0].getAttribute('uuidref') == fsuuid:
3257                 lov_name = fs.getAttribute('name')
3258                 break
3259
3260         if not lov_name:
3261             panic("malformed xml: 'add' record references lov uuid '" + lov_uuid + "', which references filesystem uuid '" + fsuuid + "', which does not reference a mountpoint.")
3262
3263     print "lov_uuid: " + lov_uuid + "; lov_name: " + lov_name
3264
3265     ost_uuid = rec.getAttribute('ost_uuidref')
3266     obd = db.lookup(ost_uuid)
3267
3268     if not obd:
3269         panic("malformed xml: 'add' record references ost uuid '" + ost_uuid + "' which cannot be found.")
3270
3271     osc = get_osc(obd, lov_uuid, lov_name)
3272     if not osc:
3273         panic('osc not found:', obd_uuid)
3274     return osc
3275
3276 # write logs for update records.  sadly, logs of all types -- and updates in
3277 # particular -- are something of an afterthought.  lconf needs rewritten with
3278 # these as core concepts.  so this is a pretty big hack.
3279 def process_update_record(db, update, lov):
3280     for rec in update.childNodes:
3281         if rec.nodeType != rec.ELEMENT_NODE:
3282             continue
3283
3284         log("found "+rec.nodeName+" record in update version " +
3285             str(update.getAttribute('version')))
3286
3287         lov_uuid = rec.getAttribute('lov_uuidref')
3288         ost_uuid = rec.getAttribute('ost_uuidref')
3289         index = rec.getAttribute('index')
3290         gen = rec.getAttribute('generation')
3291
3292         if not lov_uuid or not ost_uuid or not index or not gen:
3293             panic("malformed xml: 'update' record requires lov_uuid, ost_uuid, index, and generation.")
3294
3295         if not lov:
3296             tmplov = db.lookup(lov_uuid)
3297             if not tmplov:
3298                 panic("malformed xml: 'delete' record contains lov UUID '" + lov_uuid + "', which cannot be located.")
3299             lov_name = tmplov.getName()
3300         else:
3301             lov_name = lov.osc.name
3302
3303         # ------------------------------------------------------------- add
3304         if rec.nodeName == 'add':
3305             if config.cleanup:
3306                 lctl.lov_del_obd(lov_name, lov_uuid, ost_uuid, index, gen)
3307                 continue
3308
3309             osc = magic_get_osc(db, rec, lov)
3310
3311             try:
3312                 # Only ignore connect failures with --force, which
3313                 # isn't implemented here yet.
3314                 osc.prepare(ignore_connect_failure=0)
3315             except CommandError, e:
3316                 print "Error preparing OSC %s\n" % osc.uuid
3317                 raise e
3318
3319             lctl.lov_add_obd(lov_name, lov_uuid, ost_uuid, index, gen)
3320
3321         # ------------------------------------------------------ deactivate
3322         elif rec.nodeName == 'deactivate':
3323             if config.cleanup:
3324                 continue
3325
3326             osc = magic_get_osc(db, rec, lov)
3327
3328             try:
3329                 osc.deactivate()
3330             except CommandError, e:
3331                 print "Error deactivating OSC %s\n" % osc.uuid
3332                 raise e
3333
3334         # ---------------------------------------------------------- delete
3335         elif rec.nodeName == 'delete':
3336             if config.cleanup:
3337                 continue
3338
3339             osc = magic_get_osc(db, rec, lov)
3340
3341             try:
3342                 config.cleanup = 1
3343                 osc.cleanup()
3344                 config.cleanup = 0
3345             except CommandError, e:
3346                 print "Error cleaning up OSC %s\n" % osc.uuid
3347                 raise e
3348
3349             lctl.lov_del_obd(lov_name, lov_uuid, ost_uuid, index, gen)
3350
3351 def process_updates(db, log_device, log_name, lov = None):
3352     updates = db.root_node.getElementsByTagName('update')
3353     for u in updates:
3354         if not u.childNodes:
3355             log("ignoring empty update record (version " +
3356                 str(u.getAttribute('version')) + ")")
3357             continue
3358
3359         version = u.getAttribute('version')
3360         real_name = "%s-%s" % (log_name, version)
3361         lctl.clear_log(log_device, real_name)
3362         lctl.record(log_device, real_name)
3363
3364         process_update_record(db, u, lov)
3365
3366         lctl.end_record()
3367
3368 def doWriteconf(services):
3369     #if config.nosetup:
3370     #    return
3371     for s in services:
3372         if s[1].get_class() == 'mdsdev' or s[1].get_class() == 'osd':
3373             n = newService(s[1])
3374             n.write_conf()
3375             n.cleanup()
3376
3377 def doSetup(services):
3378     if config.nosetup:
3379         return
3380     slist = []
3381     for s in services:
3382         n = newService(s[1])
3383         n.level = s[0]
3384         slist.append((n.level, n))
3385     nlist = []
3386     for n in slist:
3387         nl = n[1].correct_level(n[0])
3388         nlist.append((nl, n[1]))
3389     nlist.sort()
3390     for n in nlist:
3391         n[1].prepare()
3392
3393 def doLoadModules(services):
3394     if config.nomod:
3395         return
3396         
3397     # adding all needed modules from all services
3398     for s in services:
3399         n = newService(s[1])
3400         n.add_module(mod_manager)
3401     
3402     # loading all registered modules
3403     mod_manager.load_modules()
3404
3405 def doUnloadModules(services):
3406     if config.nomod:
3407         return
3408         
3409     # adding all needed modules from all services
3410     for s in services:
3411         n = newService(s[1])
3412         if n.safe_to_clean_modules():
3413             n.add_module(mod_manager)
3414     
3415     # unloading all registered modules
3416     mod_manager.cleanup_modules()
3417
3418 def doCleanup(services):
3419     if config.nosetup:
3420         return
3421     slist = []
3422
3423     for s in services:
3424         n = newService(s[1])
3425         n.level = s[0]
3426         slist.append((n.level, n))
3427     nlist = []
3428     for n in slist:
3429         nl = n[1].correct_level(n[0])
3430         nlist.append((nl, n[1]))
3431     nlist.sort()
3432     nlist.reverse()
3433
3434     for n in nlist:
3435         if n[1].safe_to_clean():
3436             n[1].cleanup()
3437
3438 #
3439 # Load profile for 
3440 def doHost(lustreDB, hosts):
3441     global is_router, local_node_name
3442     node_db = None
3443     for h in hosts:
3444         node_db = lustreDB.lookup_name(h, 'node')
3445         if node_db:
3446             break
3447   &nb