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):
 718         cmds = """
 719   mount_option %s %s %s
 720   quit""" % (profile, osc, mdc)
 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 CONFDEV(Module):
1730     def __init__(self, db, name, target_uuid, uuid):
1731         Module.__init__(self, 'CONFDEV', db)
1732         self.devpath = self.db.get_val('devpath','')
1733         self.backdevpath = self.db.get_val('devpath','')
1734         self.size = self.db.get_val_int('devsize', 0)
1735         self.journal_size = self.db.get_val_int('journalsize', 0)
1736         self.fstype = self.db.get_val('fstype', '')
1737         self.backfstype = self.db.get_val('backfstype', '')
1738         self.mkfsoptions = self.db.get_val('mkfsoptions', '')
1739         self.mountfsoptions = self.db.get_val('mountfsoptions', '')
1740         self.target = self.db.lookup(target_uuid)
1741         self.name = "conf_%s" % self.target.getName()
1742         self.client_uuids = self.target.get_refs('client')
1743         self.obdtype = self.db.get_val('obdtype', '')
1744
1745         self.mds_sec = self.db.get_val('mds_sec', '')
1746         self.oss_sec = self.db.get_val('oss_sec', '')
1747         self.deny_sec = self.db.get_val('deny_sec', '')
1748
1749         if config.mds_mds_sec:
1750             self.mds_sec = config.mds_mds_sec
1751         if config.mds_oss_sec:
1752             self.oss_sec = config.mds_oss_sec
1753         if config.mds_deny_sec:
1754             if self.deny_sec:
1755                 self.deny_sec = "%s,%s" %(self.deny_sec, config.mds_deny_sec)
1756             else:
1757                 self.deny_sec = config.mds_deny_sec
1758
1759         if self.obdtype == None:
1760             self.obdtype = 'dumb'
1761
1762         self.conf_name = name
1763         self.conf_uuid = uuid
1764         self.realdev = self.devpath
1765
1766         self.lmv = None
1767         self.master = None
1768
1769         lmv_uuid = self.db.get_first_ref('lmv')
1770         if lmv_uuid != None:
1771             self.lmv = self.db.lookup(lmv_uuid)
1772             if self.lmv != None:
1773                 self.client_uuids = self.lmv.get_refs('client')
1774
1775         if self.target.get_class() == 'mds':
1776             if self.target.get_val('failover', 0):
1777                 self.failover_mds = 'f'
1778             else:
1779                 self.failover_mds = 'n'
1780             self.format = self.db.get_val('autoformat', "no")
1781         else:
1782             self.format = self.db.get_val('autoformat', "yes")
1783             self.osdtype = self.db.get_val('osdtype')
1784             ost = self.db.lookup(target_uuid)
1785             if ost.get_val('failover', 0):
1786                 self.failover_ost = 'f'
1787             else:
1788                 self.failover_ost = 'n'
1789
1790         self.inode_size = self.get_inode_size()
1791
1792         if self.lmv != None:
1793             client_uuid = self.name + "_lmv_UUID"
1794             self.master = LMV(self.lmv, client_uuid,
1795                               self.conf_name, self.conf_name)
1796
1797     def get_inode_size(self):
1798         inode_size = self.db.get_val_int('inodesize', 0)
1799         if inode_size == 0 and self.target.get_class() == 'mds':
1800
1801             # default inode size for case when neither LOV either
1802             # LMV is accessible.
1803             self.inode_size = 256
1804
1805             # find the LOV for this MDS
1806             lovconfig_uuid = self.target.get_first_ref('lovconfig')
1807             if lovconfig_uuid or self.lmv != None:
1808                 if self.lmv != None:
1809                     lovconfig_uuid = self.lmv.get_first_ref('lovconfig')
1810                     lovconfig = self.lmv.lookup(lovconfig_uuid)
1811                     lov_uuid = lovconfig.get_first_ref('lov')
1812                     if lov_uuid == None:
1813                         panic(self.target.getName() + ": No LOV found for lovconfig ",
1814                               lovconfig.name)
1815                 else:
1816                     lovconfig = self.target.lookup(lovconfig_uuid)
1817                     lov_uuid = lovconfig.get_first_ref('lov')
1818                     if lov_uuid == None:
1819                        panic(self.target.getName() + ": No LOV found for lovconfig ",
1820                              lovconfig.name)
1821                     if self.lmv != None:
1822                         lovconfig_uuid = self.lmv.get_first_ref('lovconfig')
1823                         lovconfig = self.lmv.lookup(lovconfig_uuid)
1824                         lov_uuid = lovconfig.get_first_ref('lov')
1825
1826                 lov = LOV(self.db.lookup(lov_uuid), lov_uuid, self.name,
1827                           config_only = 1)
1828
1829                 # default stripe count controls default inode_size
1830                 if lov.stripe_cnt > 0:
1831                     stripe_count = lov.stripe_cnt
1832                 else:
1833                     stripe_count = len(lov.devlist)
1834                 if stripe_count > 77:
1835                     inode_size = 4096
1836                 elif stripe_count > 35:
1837                     inode_size = 2048
1838                 elif stripe_count > 13:
1839                     inode_size = 1024
1840                 #elif stripe_count > 3:
1841                 #    inode_size = 512
1842                 else:
1843                     inode_size = 512
1844
1845         return inode_size
1846
1847     def get_mount_options(self, blkdev):
1848         options = def_mount_options(self.fstype,
1849                                     self.target.get_class())
1850
1851         if config.mountfsoptions:
1852             if options:
1853                 options = "%s,%s" %(options, config.mountfsoptions)
1854             else:
1855                 options = config.mountfsoptions
1856             if self.mountfsoptions:
1857                 options = "%s,%s" %(options, self.mountfsoptions)
1858         else:
1859             if self.mountfsoptions:
1860                 if options:
1861                     options = "%s,%s" %(options, self.mountfsoptions)
1862                 else:
1863                     options = self.mountfsoptions
1864
1865         if self.fstype == 'smfs':
1866             if options:
1867                 options = "%s,type=%s,dev=%s" %(options, self.backfstype,
1868                                                 blkdev)
1869             else:
1870                 options = "type=%s,dev=%s" %(self.backfstype,
1871                                              blkdev)
1872
1873         if self.target.get_class() == 'mds':
1874             if options:
1875                 options = "%s,acl,user_xattr,iopen_nopriv" %(options)
1876             else:
1877                 options = "iopen_nopriv"
1878
1879         return options
1880
1881     def prepare(self):
1882         if is_prepared(self.name):
1883             return
1884
1885         blkdev = block_dev(self.devpath, self.size, self.fstype,
1886                            config.reformat, self.format, self.journal_size,
1887                            self.inode_size, self.mkfsoptions, self.backfstype,
1888                            self.backdevpath)
1889
1890         if self.fstype == 'smfs':
1891             realdev = blkdev
1892         else:
1893             realdev = blkdev
1894
1895         mountfsoptions = self.get_mount_options(blkdev)
1896
1897         self.info(self.target.get_class(), realdev, mountfsoptions,
1898                   self.fstype, self.size, self.format)
1899
1900         lctl.newdev("confobd", self.name, self.uuid,
1901                     setup ="%s %s %s" %(realdev, self.fstype,
1902                                         mountfsoptions))
1903
1904         self.mountfsoptions = mountfsoptions
1905         self.realdev = realdev
1906
1907     def add_module(self, manager):
1908         manager.add_lustre_module('obdclass', 'confobd')
1909
1910     def write_conf(self):
1911         if self.target.get_class() == 'ost':
1912             config.record = 1
1913             lctl.clear_log(self.name, self.target.getName() + '-conf')
1914             lctl.record(self.name, self.target.getName() + '-conf')
1915             lctl.newdev(self.osdtype, self.conf_name, self.conf_uuid,
1916                         setup ="%s %s %s %s" %(self.realdev, self.fstype,
1917                                                self.failover_ost,
1918                                                self.mountfsoptions))
1919             lctl.end_record()
1920             lctl.clear_log(self.name, 'OSS-conf')
1921             lctl.record(self.name, 'OSS-conf')
1922             lctl.newdev("ost", 'OSS', 'OSS_UUID', setup ="")
1923             lctl.end_record()
1924             config.record = 0
1925             return
1926
1927         if self.target.get_class() == 'mds':
1928             if self.master != None:
1929                 master_name = self.master.name
1930             else:
1931                 master_name = 'dumb'
1932
1933             config.record = 1
1934             lctl.clear_log(self.name, self.target.getName() + '-conf')
1935             lctl.record(self.name, self.target.getName() + '-conf')
1936             lctl.attach("mds", self.conf_name, self.conf_uuid)
1937             if self.mds_sec:
1938                 lctl.set_security(self.conf_name, "mds_sec", self.mds_sec)
1939             if self.oss_sec:
1940                 lctl.set_security(self.conf_name, "oss_sec", self.oss_sec)
1941             if self.deny_sec:
1942                 for flavor in string.split(self.deny_sec, ','):
1943                     lctl.set_security(self.conf_name, "deny_sec", flavor)
1944             lctl.newdev("mds", self.conf_name, self.conf_uuid,
1945                         setup ="%s %s %s %s %s %s" %(self.realdev, self.fstype,
1946                                                      self.conf_name, self.mountfsoptions,
1947                                                      master_name, self.obdtype))
1948             lctl.end_record()
1949             config.record = 0
1950
1951         if not self.client_uuids:
1952             return 0
1953
1954         for uuid in self.client_uuids:
1955             log("recording client:", uuid)
1956             client_uuid = generate_client_uuid(self.name)
1957             client = VOSC(self.db.lookup(uuid), client_uuid,
1958                           self.target.getName(), self.name)
1959             config.record = 1
1960             lctl.clear_log(self.name, self.target.getName())
1961             lctl.record(self.name, self.target.getName())
1962             client.prepare()
1963             lctl.mount_option(self.target.getName(), client.get_name(), "")
1964             lctl.end_record()
1965
1966             config.cleanup = 1
1967             lctl.clear_log(self.name, self.target.getName() + '-clean')
1968             lctl.record(self.name, self.target.getName() + '-clean')
1969             client.cleanup()
1970             lctl.del_mount_option(self.target.getName())
1971             lctl.end_record()
1972             config.cleanup = 0
1973             config.record = 0
1974
1975         if config.record:
1976             return
1977
1978         # record logs for each client
1979         if config.ldapurl:
1980             config_options = "--ldapurl " + config.ldapurl + " --config " + config.config
1981         else:
1982             config_options = CONFIG_FILE
1983
1984         for node_db in self.db.lookup_class('node'):
1985             client_name = node_db.getName()
1986             for prof_uuid in node_db.get_refs('profile'):
1987                 prof_db = node_db.lookup(prof_uuid)
1988                 # refactor this into a funtion to test "clientness"
1989                 # of a node.
1990                 for ref_class, ref_uuid in prof_db.get_all_refs():
1991                     if ref_class in ('mountpoint','echoclient'):
1992                         debug("recording", client_name)
1993                         old_noexec = config.noexec
1994                         config.noexec = 0
1995                         noexec_opt = ('', '-n')
1996                         ret, out = run (sys.argv[0],
1997                                         noexec_opt[old_noexec == 1],
1998                                         " -v --record --nomod",
1999                                         "--record_log", client_name,
2000                                         "--record_device", self.name,
2001                                         "--node", client_name,
2002                                         config_options)
2003                         if config.verbose:
2004                             for s in out: log("record> ", string.strip(s))
2005                         ret, out = run (sys.argv[0],
2006                                         noexec_opt[old_noexec == 1],
2007                                         "--cleanup -v --record --nomod",
2008                                         "--record_log", client_name + "-clean",
2009                                         "--record_device", self.name,
2010                                         "--node", client_name,
2011                                         config_options)
2012                         if config.verbose:
2013                             for s in out: log("record> ", string.strip(s))
2014                         config.noexec = old_noexec
2015
2016     def start(self):
2017          try:
2018             lctl.start(self.name, self.conf_name)
2019          except CommandError, e:
2020             raise e
2021          if self.target.get_class() == 'ost':
2022              if not is_prepared('OSS'):
2023                  try:
2024                      lctl.start(self.name, 'OSS')
2025                  except CommandError, e:
2026                      raise e
2027
2028     def cleanup(self):
2029         if is_prepared(self.name):
2030             try:
2031                 lctl.cleanup(self.name, self.uuid, 0, 0)
2032                 clean_dev(self.devpath, self.fstype,
2033                           self.backfstype, self.backdevpath)
2034             except CommandError, e:
2035                 log(self.module_name, "cleanup failed: ", self.name)
2036                 e.dump()
2037                 cleanup_error(e.rc)
2038                 Module.cleanup(self)
2039
2040 class MDSDEV(Module):
2041     def __init__(self,db):
2042         Module.__init__(self, 'MDSDEV', db)
2043         self.devpath = self.db.get_val('devpath','')
2044         self.backdevpath = self.db.get_val('devpath','')
2045         self.size = self.db.get_val_int('devsize', 0)
2046         self.journal_size = self.db.get_val_int('journalsize', 0)
2047         self.fstype = self.db.get_val('fstype', '')
2048         self.backfstype = self.db.get_val('backfstype', '')
2049         self.nspath = self.db.get_val('nspath', '')
2050         self.mkfsoptions = self.db.get_val('mkfsoptions', '')
2051         self.mountfsoptions = self.db.get_val('mountfsoptions', '')
2052         self.obdtype = self.db.get_val('obdtype', '')
2053         self.root_squash = self.db.get_val('root_squash', '')
2054         self.no_root_squash = self.db.get_val('no_root_squash', '')
2055
2056         target_uuid = self.db.get_first_ref('target')
2057         self.target = self.db.lookup(target_uuid)
2058         self.name = self.target.getName()
2059         self.master = None
2060         self.lmv = None
2061
2062         lmv_uuid = self.db.get_first_ref('lmv')
2063         if lmv_uuid != None:
2064             self.lmv = self.db.lookup(lmv_uuid)
2065
2066         active_uuid = get_active_target(self.target)
2067         if not active_uuid:
2068             panic("No target device found:", target_uuid)
2069         if active_uuid == self.uuid:
2070             self.active = 1
2071             group = self.target.get_val('group')
2072             if config.group and config.group != group:
2073                 self.active = 0
2074         else:
2075             self.active = 0
2076
2077         self.uuid = target_uuid
2078
2079         # setup LMV
2080         if self.lmv != None:
2081             client_uuid = self.name + "_lmv_UUID"
2082             self.master = LMV(self.lmv, client_uuid,
2083                               self.name, self.name)
2084
2085         self.confobd = CONFDEV(self.db, self.name,
2086                                target_uuid, self.uuid)
2087
2088     def add_module(self, manager):
2089         if self.active:
2090             manager.add_lustre_module('mdc', 'mdc')
2091             manager.add_lustre_module('osc', 'osc')
2092             manager.add_lustre_module('ost', 'ost')
2093             manager.add_lustre_module('lov', 'lov')
2094             manager.add_lustre_module('mds', 'mds')
2095
2096             if self.fstype == 'smfs' or self.fstype == 'ldiskfs':
2097                 manager.add_lustre_module(self.fstype, self.fstype)
2098
2099             if self.fstype:
2100                 manager.add_lustre_module('lvfs', 'fsfilt_%s' % (self.fstype))
2101
2102             # if fstype is smfs, then we should also take care about backing
2103             # store fs.
2104             if self.fstype == 'smfs':
2105                 manager.add_lustre_module(self.backfstype, self.backfstype)
2106                 manager.add_lustre_module('lvfs', 'fsfilt_%s' % (self.backfstype))
2107
2108             for option in string.split(self.mountfsoptions, ','):
2109                 if option == 'snap':
2110                     if not self.fstype == 'smfs':
2111                         panic("mountoptions has 'snap', but fstype is not smfs.")
2112                     manager.add_lustre_module('lvfs', 'fsfilt_snap_%s' % (self.fstype))
2113                     manager.add_lustre_module('lvfs', 'fsfilt_snap_%s' % (self.backfstype))
2114
2115         # add LMV modules
2116         if self.master != None:
2117             self.master.add_module(manager)
2118
2119         # add CONFOBD modules
2120         if self.confobd != None:
2121             self.confobd.add_module(manager)
2122
2123     def write_conf(self):
2124         if is_prepared(self.name):
2125             return
2126         if not self.active:
2127             debug(self.uuid, "not active")
2128             return
2129         run_acceptors()
2130         self.confobd.prepare()
2131         self.confobd.write_conf()
2132         self.confobd.cleanup()
2133
2134     def prepare(self):
2135         if is_prepared(self.name):
2136             return
2137         if not self.active:
2138             debug(self.uuid, "not active")
2139             return
2140         run_acceptors()
2141
2142         self.confobd.prepare()
2143         if config.reformat:
2144             self.confobd.write_conf()
2145
2146         # prepare LMV
2147         if self.master != None:
2148              self.master.prepare()
2149
2150         if not config.record:
2151             self.confobd.start()
2152
2153         if not is_prepared('MDT'):
2154             lctl.newdev("mdt", 'MDT', 'MDT_UUID', setup ="")
2155
2156         if development_mode():
2157             procentry = "/proc/fs/lustre/mds/lsd_upcall"
2158             upcall = os.path.abspath(os.path.dirname(sys.argv[0]) + "/lsd_upcall")
2159             if not (os.access(procentry, os.R_OK) and os.access(upcall, os.R_OK)):
2160                 print "MDS Warning: failed to set lsd cache upcall"
2161             else:
2162                 run("echo ", upcall, " > ", procentry)
2163
2164         if config.root_squash == None:
2165             config.root_squash = self.root_squash
2166         if config.no_root_squash == None:
2167             config.no_root_squash = self.no_root_squash
2168         if config.root_squash:
2169             if config.no_root_squash:
2170                 nsnid = config.no_root_squash
2171             else:
2172                 nsnid = "0"
2173             lctl.root_squash(self.name, config.root_squash, nsnid)
2174
2175     def msd_remaining(self):
2176         out = lctl.device_list()
2177         for s in out:
2178             if string.split(s)[2] in ('mds',):
2179                 return 1
2180
2181     def safe_to_clean(self):
2182         return self.active
2183
2184     def safe_to_clean_modules(self):
2185         return not self.msd_remaining()
2186
2187     def cleanup(self):
2188         if not self.active:
2189             debug(self.uuid, "not active")
2190             return
2191         self.info()
2192         if is_prepared(self.name):
2193             try:
2194                 lctl.cleanup(self.name, self.uuid, config.force,
2195                              config.failover)
2196             except CommandError, e:
2197                 log(self.module_name, "cleanup failed: ", self.name)
2198                 e.dump()
2199                 cleanup_error(e.rc)
2200                 Module.cleanup(self)
2201             # cleanup LMV
2202             if self.master != None:
2203                 self.master.cleanup()
2204         if not self.msd_remaining() and is_prepared('MDT'):
2205             try:
2206                 lctl.cleanup("MDT", "MDT_UUID", config.force,
2207                              config.failover)
2208             except CommandError, e:
2209                 print "cleanup failed: ", self.name
2210                 e.dump()
2211                 cleanup_error(e.rc)
2212
2213         if self.confobd:
2214             self.confobd.cleanup()
2215
2216     def correct_level(self, level, op=None):
2217         #if self.master != None:
2218         #   level = level + 2
2219         return level
2220
2221 class OSD(Module):
2222     def __init__(self, db):
2223         Module.__init__(self, 'OSD', db)
2224         self.osdtype = self.db.get_val('osdtype')
2225         self.devpath = self.db.get_val('devpath', '')
2226         self.backdevpath = self.db.get_val('devpath', '')
2227         self.size = self.db.get_val_int('devsize', 0)
2228         self.journal_size = self.db.get_val_int('journalsize', 0)
2229         self.inode_size = self.db.get_val_int('inodesize', 0)
2230         self.mkfsoptions = self.db.get_val('mkfsoptions', '')
2231         self.mountfsoptions = self.db.get_val('mountfsoptions', '')
2232         self.fstype = self.db.get_val('fstype', '')
2233         self.backfstype = self.db.get_val('backfstype', '')
2234         self.nspath = self.db.get_val('nspath', '')
2235         target_uuid = self.db.get_first_ref('target')
2236         ost = self.db.lookup(target_uuid)
2237         self.name = ost.getName()
2238         self.format = self.db.get_val('autoformat', 'yes')
2239         if ost.get_val('failover', 0):
2240             self.failover_ost = 'f'
2241         else:
2242             self.failover_ost = 'n'
2243
2244         self.deny_sec = self.db.get_val('deny_sec', '')
2245
2246         if config.ost_deny_sec:
2247             if self.deny_sec:
2248                 self.deny_sec = "%s,%s" %(self.deny_sec, config.ost_deny_sec)
2249             else:
2250                 self.deny_sec = config.ost_deny_sec
2251
2252         active_uuid = get_active_target(ost)
2253         if not active_uuid:
2254             panic("No target device found:", target_uuid)
2255         if active_uuid == self.uuid:
2256             self.active = 1
2257             group = ost.get_val('group')
2258             if config.group and config.group != group:
2259                 self.active = 0
2260         else:
2261             self.active = 0
2262
2263         self.uuid = target_uuid
2264         self.confobd = CONFDEV(self.db, self.name,
2265                                target_uuid, self.uuid)
2266
2267     def add_module(self, manager):
2268         if not self.active:
2269             return
2270         manager.add_lustre_module('ost', 'ost')
2271
2272         if self.fstype == 'smfs' or self.fstype == 'ldiskfs':
2273             manager.add_lustre_module(self.fstype, self.fstype)
2274
2275         if self.fstype:
2276             manager.add_lustre_module('lvfs' , 'fsfilt_%s' % (self.fstype))
2277
2278         if self.fstype == 'smfs':
2279             manager.add_lustre_module(self.backfstype, self.backfstype)
2280             manager.add_lustre_module('lvfs' , 'fsfilt_%s' % (self.backfstype))
2281
2282         for option in self.mountfsoptions:
2283             if option == 'snap':
2284                 if not self.fstype == 'smfs':
2285                     panic("mountoptions with snap, but fstype is not smfs\n")
2286                 manager.add_lustre_module('lvfs', 'fsfilt_snap_%s' % (self.fstype))
2287                 manager.add_lustre_module('lvfs', 'fsfilt_snap_%s' % (self.backfstype))
2288
2289         manager.add_lustre_module(self.osdtype, self.osdtype)
2290
2291         # add CONFOBD modules
2292         if self.confobd != None:
2293             self.confobd.add_module(manager)
2294
2295     def prepare(self):
2296         if is_prepared(self.name):
2297             return
2298         if not self.active:
2299             debug(self.uuid, "not active")
2300             return
2301
2302         run_acceptors()
2303
2304         if self.osdtype == 'obdecho':
2305             self.info(self.osdtype)
2306             lctl.newdev("obdecho", self.name, self.uuid)
2307             if not is_prepared('OSS'):
2308                 lctl.newdev("ost", 'OSS', 'OSS_UUID', setup="")
2309         else:
2310             self.confobd.prepare()
2311             if config.reformat:
2312                 self.confobd.write_conf()
2313             if not config.record:
2314                 self.confobd.start()
2315
2316         if self.deny_sec:
2317             for flavor in string.split(self.deny_sec, ','):
2318                 lctl.set_security(self.name, "deny_sec", flavor)
2319
2320     def write_conf(self):
2321         if is_prepared(self.name):
2322             return
2323         if not self.active:
2324             debug(self.uuid, "not active")
2325             return
2326
2327         run_acceptors()
2328         if self.osdtype != 'obdecho':
2329             self.confobd.prepare()
2330             self.confobd.write_conf()
2331             if not config.write_conf:
2332                 self.confobd.start()
2333             self.confobd.cleanup()
2334
2335     def osd_remaining(self):
2336         out = lctl.device_list()
2337         for s in out:
2338             if string.split(s)[2] in ('obdfilter', 'obdecho'):
2339                 return 1
2340
2341     def safe_to_clean(self):
2342         return self.active
2343
2344     def safe_to_clean_modules(self):
2345         return not self.osd_remaining()
2346
2347     def cleanup(self):
2348         if not self.active:
2349             debug(self.uuid, "not active")
2350             return
2351
2352         if is_prepared(self.name):
2353             self.info()
2354             try:
2355                 lctl.cleanup(self.name, self.uuid, config.force,
2356                              config.failover)
2357             except CommandError, e:
2358                 log(self.module_name, "cleanup failed: ", self.name)
2359                 e.dump()
2360                 cleanup_error(e.rc)
2361         if not self.osd_remaining() and is_prepared('OSS'):
2362             try:
2363                 lctl.cleanup("OSS", "OSS_UUID", config.force,
2364                              config.failover)
2365             except CommandError, e:
2366                 print "cleanup failed: ", self.name
2367                 e.dump()
2368                 cleanup_error(e.rc)
2369
2370         if self.osdtype != 'obdecho':
2371             if self.confobd:
2372                 self.confobd.cleanup()
2373
2374     def correct_level(self, level, op=None):
2375         return level
2376
2377 # Generic client module, used by OSC and MDC
2378 class Client(Module):
2379     def __init__(self, tgtdb, uuid, module, fs_name,
2380                  self_name=None, module_dir=None):
2381         self.target_name = tgtdb.getName()
2382         self.target_uuid = tgtdb.getUUID()
2383         self.module_dir = module_dir
2384         self.backup_targets = []
2385         self.module = module
2386         self.db = tgtdb
2387
2388         self.tgt_dev_uuid = get_active_target(tgtdb)
2389         if not self.tgt_dev_uuid:
2390             panic("No target device found for target(1):", self.target_name)
2391
2392         self._server = None
2393         self._connected = 0
2394
2395         self.module = module
2396         self.module_name = string.upper(module)
2397         if not self_name:
2398             self.name = '%s_%s_%s_%s' % (self.module_name, socket.gethostname(),
2399                                          self.target_name, fs_name)
2400         else:
2401             self.name = self_name
2402         self.uuid = uuid
2403         self.lookup_server(self.tgt_dev_uuid)
2404         self.lookup_backup_targets()
2405         self.fs_name = fs_name
2406         if not self.module_dir:
2407             self.module_dir = module
2408
2409     def add_module(self, manager):
2410         manager.add_lustre_module(self.module_dir, self.module)
2411
2412     def lookup_server(self, srv_uuid):
2413         """ Lookup a server's network information """
2414         self._server_nets = get_ost_net(self.db, srv_uuid)
2415         if len(self._server_nets) == 0:
2416             panic ("Unable to find a server for:", srv_uuid)
2417
2418     def get_name(self):
2419         return self.name
2420
2421     def get_servers(self):
2422         return self._server_nets
2423
2424     def lookup_backup_targets(self):
2425         """ Lookup alternative network information """
2426         prof_list = toplustreDB.get_refs('profile')
2427         for prof_uuid in prof_list:
2428             prof_db = toplustreDB.lookup(prof_uuid)
2429             if not prof_db:
2430                 panic("profile:", prof_uuid, "not found.")
2431             for ref_class, ref_uuid in prof_db.get_all_refs():
2432                 if ref_class in ('osd', 'mdsdev'):
2433                     devdb = toplustreDB.lookup(ref_uuid)
2434                     uuid = devdb.get_first_ref('target')
2435                     if self.target_uuid == uuid and self.tgt_dev_uuid != ref_uuid:
2436                         self.backup_targets.append(ref_uuid)
2437
2438     def prepare(self, ignore_connect_failure = 0):
2439         self.info(self.target_uuid)
2440         if not config.record and is_prepared(self.name):
2441             self.cleanup()
2442         try:
2443             srv = choose_local_server(self.get_servers())
2444             if srv:
2445                 lctl.connect(srv)
2446             else:
2447                 routes = find_route(self.get_servers())
2448                 if len(routes) == 0:
2449                     panic ("no route to",  self.target_uuid)
2450                 for (srv, r) in routes:
2451                     lctl.add_route_host(r[0], srv.nid_uuid, r[1], r[3])
2452         except CommandError, e:
2453             if not ignore_connect_failure:
2454                 raise e
2455
2456         if srv:
2457             if self.target_uuid in config.inactive and self.permits_inactive():
2458                 debug("%s inactive" % self.target_uuid)
2459                 inactive_p = "inactive"
2460             else:
2461                 debug("%s active" % self.target_uuid)
2462                 inactive_p = ""
2463             lctl.newdev(self.module, self.name, self.uuid,
2464                         setup ="%s %s %s" % (self.target_uuid, srv.nid_uuid,
2465                                                 inactive_p))
2466         for tgt_dev_uuid in self.backup_targets:
2467             this_nets = get_ost_net(toplustreDB, tgt_dev_uuid)
2468             if len(this_nets) == 0:
2469                 panic ("Unable to find a server for:", tgt_dev_uuid)
2470             srv = choose_local_server(this_nets)
2471             if srv:
2472                 lctl.connect(srv)
2473             else:
2474                 routes = find_route(this_nets);
2475                 if len(routes) == 0:
2476                     panic("no route to", tgt_dev_uuid)
2477                 for (srv, r) in routes:
2478                     lctl.add_route_host(r[0]. srv.nid_uuid, r[1], r[3])
2479             if srv:
2480                 lctl.add_conn(self.name, srv.nid_uuid);
2481
2482     def cleanup(self):
2483         if is_prepared(self.name):
2484             Module.cleanup(self)
2485             try:
2486                 srv = choose_local_server(self.get_servers())
2487                 if srv:
2488                     lctl.disconnect(srv)
2489                 else:
2490                     for (srv, r) in find_route(self.get_servers()):
2491                         lctl.del_route_host(r[0], srv.nid_uuid, r[1], r[3])
2492             except CommandError, e:
2493                 log(self.module_name, "cleanup failed: ", self.name)
2494                 e.dump()
2495                 cleanup_error(e.rc)
2496
2497             for tgt_dev_uuid in self.backup_targets:
2498                 this_net = get_ost_net(toplustreDB, tgt_dev_uuid)
2499                 srv = choose_local_server(this_net)
2500                 if srv:
2501                     lctl.disconnect(srv)
2502                 else:
2503                     for (srv, r) in find_route(this_net):
2504                         lctl.del_route_host(r[0]. srv.nid_uuid, r[1], r[3])
2505
2506     def correct_level(self, level, op=None):
2507         return level
2508
2509     def deactivate(self):
2510         try:
2511             lctl.deactivate(self.name)
2512         except CommandError, e:
2513             log(self.module_name, "deactivate failed: ", self.name)
2514             e.dump()
2515             cleanup_error(e.rc)
2516
2517 class MDC(Client):
2518     def __init__(self, db, uuid, fs_name):
2519          Client.__init__(self, db, uuid, 'mdc', fs_name)
2520
2521     def permits_inactive(self):
2522         return 0
2523
2524 class OSC(Client):
2525     def __init__(self, db, uuid, fs_name):
2526          Client.__init__(self, db, uuid, 'osc', fs_name)
2527
2528     def permits_inactive(self):
2529         return 1
2530
2531 class CMOBD(Module):
2532     def __init__(self, db):
2533         Module.__init__(self, 'CMOBD', db)
2534         self.name = self.db.getName();
2535         self.uuid = generate_client_uuid(self.name)
2536         self.master_uuid = self.db.get_first_ref('masterobd')
2537         self.cache_uuid = self.db.get_first_ref('cacheobd')
2538
2539         master_obd = self.db.lookup(self.master_uuid)
2540         if not master_obd:
2541             panic('master obd not found:', self.master_uuid)
2542
2543         cache_obd = self.db.lookup(self.cache_uuid)
2544         if not cache_obd:
2545             panic('cache obd not found:', self.cache_uuid)
2546
2547         self.master = None
2548         self.cache = None
2549
2550         master_class = master_obd.get_class()
2551         cache_class = cache_obd.get_class()
2552
2553         if master_class == 'ost' or master_class == 'lov':
2554             client_uuid = "%s_lov_master_UUID" % (self.name)
2555             self.master = LOV(master_obd, client_uuid, self.name,
2556                               "master_%s" % (self.name));
2557         elif master_class == 'mds':
2558             self.master = get_mdc(db, self.name, self.master_uuid)
2559         elif master_class == 'lmv':
2560             client_uuid = "%s_lmv_master_UUID" % (self.name)
2561             self.master = LMV(master_obd, client_uuid, self.name,
2562                               "master_%s" % (self.name));
2563         else:
2564             panic("unknown master obd class '%s'" %(master_class))
2565
2566         if cache_class == 'ost' or cache_class == 'lov':
2567             client_uuid = "%s_lov_cache_UUID" % (self.name)
2568             self.cache = LOV(cache_obd, client_uuid, self.name,
2569                              "cache_%s" % (self.name));
2570         elif cache_class == 'mds':
2571             self.cache = get_mdc(db, self.name, self.cache_uuid)
2572         elif cache_class == 'lmv':
2573             client_uuid = "%s_lmv_cache_UUID" % (self.name)
2574             self.cache = LMV(cache_obd, client_uuid, self.name,
2575                              "cache_%s" % (self.name));
2576         else:
2577             panic("unknown cache obd class '%s'" %(cache_class))
2578
2579     def prepare(self):
2580         self.master.prepare()
2581         if not config.record and is_prepared(self.name):
2582             return
2583         self.info(self.master_uuid, self.cache_uuid)
2584         lctl.newdev("cmobd", self.name, self.uuid,
2585                     setup ="%s %s" %(self.master.uuid,
2586                                      self.cache.uuid))
2587
2588     def get_uuid(self):
2589         return self.uuid
2590
2591     def get_name(self):
2592         return self.name
2593
2594     def get_master_name(self):
2595         return self.master.name
2596
2597     def get_cache_name(self):
2598         return self.cache.name
2599
2600     def cleanup(self):
2601         if is_prepared(self.name):
2602             Module.cleanup(self)
2603         if self.master:
2604             self.master.cleanup()
2605
2606     def add_module(self, manager):
2607         manager.add_lustre_module('smfs', 'smfs')
2608         manager.add_lustre_module('cmobd', 'cmobd')
2609         self.master.add_module(manager)
2610
2611     def correct_level(self, level, op=None):
2612         return level
2613
2614 class COBD(Module):
2615     def __init__(self, db, uuid, name):
2616         Module.__init__(self, 'COBD', db)
2617         self.name = self.db.getName();
2618         self.uuid = generate_client_uuid(self.name)
2619         self.master_uuid = self.db.get_first_ref('masterobd')
2620         self.cache_uuid = self.db.get_first_ref('cacheobd')
2621
2622         master_obd = self.db.lookup(self.master_uuid)
2623         if not master_obd:
2624             panic('master obd not found:', self.master_uuid)
2625
2626         cache_obd = self.db.lookup(self.cache_uuid)
2627         if not cache_obd:
2628             panic('cache obd not found:', self.cache_uuid)
2629
2630         self.master = None
2631         self.cache = None
2632
2633         master_class = master_obd.get_class()
2634         cache_class = cache_obd.get_class()
2635
2636         if master_class == 'ost' or master_class == 'lov':
2637             client_uuid = "%s_lov_master_UUID" % (self.name)
2638             self.master = LOV(master_obd, client_uuid, name,
2639                               "master_%s" % (self.name));
2640         elif master_class == 'mds':
2641             self.master = get_mdc(db, name, self.master_uuid)
2642         elif master_class == 'lmv':
2643             client_uuid = "%s_lmv_master_UUID" % (self.name)
2644             self.master = LMV(master_obd, client_uuid, self.name,
2645                               "master_%s" % (self.name));
2646         else:
2647             panic("unknown master obd class '%s'" %(master_class))
2648
2649         if cache_class == 'ost' or cache_class == 'lov':
2650             client_uuid = "%s_lov_cache_UUID" % (self.name)
2651             self.cache = LOV(cache_obd, client_uuid, name,
2652                              "cache_%s" % (self.name));
2653         elif cache_class == 'mds':
2654             self.cache = get_mdc(db, name, self.cache_uuid)
2655         elif cache_class == 'lmv':
2656             client_uuid = "%s_lmv_cache_UUID" % (self.name)
2657             self.cache = LMV(cache_obd, client_uuid, self.name,
2658                              "cache_%s" % (self.name));
2659         else:
2660             panic("unknown cache obd class '%s'" %(cache_class))
2661
2662     def get_uuid(self):
2663         return self.uuid
2664
2665     def get_name(self):
2666         return self.name
2667
2668     def get_master_name(self):
2669         return self.master.name
2670
2671     def get_cache_name(self):
2672         return self.cache.name
2673
2674     def prepare(self):
2675         if not config.record and is_prepared(self.name):
2676             return
2677         self.master.prepare()
2678         self.cache.prepare()
2679         self.info(self.master_uuid, self.cache_uuid)
2680         lctl.newdev("cobd", self.name, self.uuid,
2681                     setup ="%s %s" %(self.master.name,
2682                                      self.cache.name))
2683
2684     def cleanup(self):
2685         if is_prepared(self.name):
2686             Module.cleanup(self)
2687         self.master.cleanup()
2688         self.cache.cleanup()
2689
2690     def add_module(self, manager):
2691         manager.add_lustre_module('cobd', 'cobd')
2692         self.master.add_module(manager)
2693
2694 # virtual interface for  OSC and LOV
2695 class VOSC(Module):
2696     def __init__(self, db, client_uuid, name, name_override = None):
2697         Module.__init__(self, 'VOSC', db)
2698         if db.get_class() == 'lov':
2699             self.osc = LOV(db, client_uuid, name, name_override)
2700             self.type = 'lov'
2701         elif db.get_class() == 'cobd':
2702             self.osc = COBD(db, client_uuid, name)
2703             self.type = 'cobd'
2704         else:
2705             self.osc = OSC(db, client_uuid, name)
2706             self.type = 'osc'
2707
2708     def get_uuid(self):
2709         return self.osc.get_uuid()
2710
2711     def get_name(self):
2712         return self.osc.get_name()
2713
2714     def prepare(self):
2715         self.osc.prepare()
2716
2717     def cleanup(self):
2718         self.osc.cleanup()
2719
2720     def add_module(self, manager):
2721         self.osc.add_module(manager)
2722
2723     def correct_level(self, level, op=None):
2724         return self.osc.correct_level(level, op)
2725
2726 # virtual interface for MDC and LMV
2727 class VMDC(Module):
2728     def __init__(self, db, client_uuid, name, name_override = None):
2729         Module.__init__(self, 'VMDC', db)
2730         if db.get_class() == 'lmv':
2731             self.mdc = LMV(db, client_uuid, name, name_override)
2732         elif db.get_class() == 'cobd':
2733             self.mdc = COBD(db, client_uuid, name)
2734         else:
2735             self.mdc = MDC(db, client_uuid, name)
2736
2737     def get_uuid(self):
2738         return self.mdc.uuid
2739
2740     def get_name(self):
2741         return self.mdc.name
2742
2743     def prepare(self):
2744         self.mdc.prepare()
2745
2746     def cleanup(self):
2747         self.mdc.cleanup()
2748
2749     def add_module(self, manager):
2750         self.mdc.add_module(manager)
2751
2752     def correct_level(self, level, op=None):
2753         return self.mdc.correct_level(level, op)
2754
2755 class ECHO_CLIENT(Module):
2756     def __init__(self,db):
2757         Module.__init__(self, 'ECHO_CLIENT', db)
2758         self.obd_uuid = self.db.get_first_ref('obd')
2759         obd = self.db.lookup(self.obd_uuid)
2760         self.uuid = generate_client_uuid(self.name)
2761         self.osc = VOSC(obd, self.uuid, self.name)
2762
2763     def prepare(self):
2764         if not config.record and is_prepared(self.name):
2765             return
2766         run_acceptors()
2767         self.osc.prepare() # XXX This is so cheating. -p
2768         self.info(self.obd_uuid)
2769
2770         lctl.newdev("echo_client", self.name, self.uuid,
2771                     setup = self.osc.get_name())
2772
2773     def cleanup(self):
2774         if is_prepared(self.name):
2775             Module.cleanup(self)
2776         self.osc.cleanup()
2777
2778     def add_module(self, manager):
2779         self.osc.add_module(manager)
2780         manager.add_lustre_module('obdecho', 'obdecho')
2781
2782     def correct_level(self, level, op=None):
2783         return level
2784
2785 def generate_client_uuid(name):
2786         client_uuid = '%05x_%.19s_%05x%05x' % (int(random.random() * 1048576),
2787                                                name,
2788                                                int(random.random() * 1048576),
2789                                                int(random.random() * 1048576))
2790         return client_uuid[:36]
2791
2792 class Mountpoint(Module):
2793     def __init__(self,db):
2794         Module.__init__(self, 'MTPT', db)
2795         self.path = self.db.get_val('path')
2796         self.clientoptions = self.db.get_val('clientoptions', '')
2797         self.fs_uuid = self.db.get_first_ref('filesystem')
2798         fs = self.db.lookup(self.fs_uuid)
2799         self.mds_uuid = fs.get_first_ref('lmv')
2800         if not self.mds_uuid:
2801             self.mds_uuid = fs.get_first_ref('mds')
2802         self.obd_uuid = fs.get_first_ref('obd')
2803         client_uuid = generate_client_uuid(self.name)
2804
2805         self.oss_sec = self.db.get_val('oss_sec','null')
2806         self.mds_sec = self.db.get_val('mds_sec','null')
2807         if config.mds_sec:
2808             self.mds_sec = config.mds_sec
2809         if config.oss_sec:
2810             self.oss_sec = config.oss_sec
2811
2812         ost = self.db.lookup(self.obd_uuid)
2813         if not ost:
2814             panic("no ost: ", self.obd_uuid)
2815
2816         mds = self.db.lookup(self.mds_uuid)
2817         if not mds:
2818             panic("no mds: ", self.mds_uuid)
2819
2820         self.vosc = VOSC(ost, client_uuid, self.name, self.name)
2821         self.vmdc = VMDC(mds, client_uuid, self.name, self.name)
2822
2823     def prepare(self):
2824         if not config.record and fs_is_mounted(self.path):
2825             log(self.path, "already mounted.")
2826             return
2827         run_acceptors()
2828
2829         self.vosc.prepare()
2830         self.vmdc.prepare()
2831
2832         self.info(self.path, self.mds_uuid, self.obd_uuid)
2833         if config.record or config.lctl_dump:
2834             lctl.mount_option(local_node_name, self.vosc.get_name(),
2835                               self.vmdc.get_name())
2836             return
2837
2838         if config.clientoptions:
2839             if self.clientoptions:
2840                 self.clientoptions = self.clientoptions + ',' + config.clientoptions
2841             else:
2842                 self.clientoptions = config.clientoptions
2843         if self.clientoptions:
2844             self.clientoptions = ',' + self.clientoptions
2845             # Linux kernel will deal with async and not pass it to ll_fill_super,
2846             # so replace it with Lustre async
2847             self.clientoptions = string.replace(self.clientoptions, "async", "lasync")
2848
2849         cmd = "mount -t lustre_lite -o osc=%s,mdc=%s,mds_sec=%s,oss_sec=%s%s %s %s" % \
2850               (self.vosc.get_name(), self.vmdc.get_name(), self.mds_sec,
2851                self.oss_sec, self.clientoptions, config.config, self.path)
2852         run("mkdir", self.path)
2853         ret, val = run(cmd)
2854         if ret:
2855             self.vmdc.cleanup()
2856             self.vosc.cleanup()
2857             panic("mount failed:", self.path, ":", string.join(val))
2858
2859     def cleanup(self):
2860         self.info(self.path, self.mds_uuid,self.obd_uuid)
2861
2862         if config.record or config.lctl_dump:
2863             lctl.del_mount_option(local_node_name)
2864         else:
2865             if fs_is_mounted(self.path):
2866                 if config.force:
2867                     (rc, out) = run("umount", "-f", self.path)
2868                 else:
2869                     (rc, out) = run("umount", self.path)
2870                 if rc:
2871                     raise CommandError('umount', out, rc)
2872
2873             if fs_is_mounted(self.path):
2874                 panic("fs is still mounted:", self.path)
2875
2876         self.vmdc.cleanup()
2877         self.vosc.cleanup()
2878
2879     def add_module(self, manager):
2880         self.vosc.add_module(manager)
2881         self.vmdc.add_module(manager)
2882         manager.add_lustre_module('llite', 'llite')
2883
2884     def correct_level(self, level, op=None):
2885         return level
2886
2887 # ============================================================
2888 # misc query functions
2889
2890 def get_ost_net(self, osd_uuid):
2891     srv_list = []
2892     if not osd_uuid:
2893         return srv_list
2894     osd = self.lookup(osd_uuid)
2895     node_uuid = osd.get_first_ref('node')
2896     node = self.lookup(node_uuid)
2897     if not node:
2898         panic("unable to find node for osd_uuid:", osd_uuid,
2899               " node_ref:", node_uuid_)
2900     for net_uuid in node.get_networks():
2901         db = node.lookup(net_uuid)
2902         srv_list.append(Network(db))
2903     return srv_list
2904
2905 # the order of iniitailization is based on level.
2906 def getServiceLevel(self):
2907     type = self.get_class()
2908     ret=0;
2909     if type in ('network',):
2910         ret = 5
2911     elif type in ('routetbl',):
2912         ret = 6
2913     elif type in ('ldlm',):
2914         ret = 20
2915     elif type in ('osd',):
2916         ret = 30
2917     elif type in ('mdsdev',):
2918         ret = 40
2919     elif type in ('lmv',):
2920         ret = 45
2921     elif type in ('cmobd', 'cobd',):
2922         ret = 60
2923     elif type in ('mountpoint', 'echoclient'):
2924         ret = 70
2925     else:
2926         panic("Unknown type: ", type)
2927
2928     if ret < config.minlevel or ret > config.maxlevel:
2929         ret = 0
2930     return ret
2931
2932 #
2933 # return list of services in a profile. list is a list of tuples
2934 # [(level, db_object),]
2935 def getServices(self):
2936     list = []
2937     for ref_class, ref_uuid in self.get_all_refs():
2938             servdb = self.lookup(ref_uuid)
2939             if servdb:
2940                 level = getServiceLevel(servdb)
2941                 if level > 0:
2942                     list.append((level, servdb))
2943             else:
2944                 panic('service not found: ' + ref_uuid)
2945
2946     list.sort()
2947     return list
2948
2949
2950 ############################################################
2951 # MDC UUID hack -
2952 # FIXME: clean this mess up!
2953 #
2954 # OSC is no longer in the xml, so we have to fake it.
2955 # this is getting ugly and begging for another refactoring
2956 def get_osc(ost_db, uuid, fs_name):
2957     osc = OSC(ost_db, uuid, fs_name)
2958     return osc
2959
2960 def get_mdc(db, fs_name, mds_uuid):
2961     mds_db = db.lookup(mds_uuid);
2962     if not mds_db:
2963         error("no mds:", mds_uuid)
2964     mdc = MDC(mds_db, mds_uuid, fs_name)
2965     return mdc
2966
2967 ############################################################
2968 # routing ("rooting")
2969
2970 # list of (nettype, cluster_id, nid)
2971 local_clusters = []
2972
2973 def find_local_clusters(node_db):
2974     global local_clusters
2975     for netuuid in node_db.get_networks():
2976         net = node_db.lookup(netuuid)
2977         srv = Network(net)
2978         debug("add_local", netuuid)
2979         local_clusters.append((srv.net_type, srv.cluster_id, srv.nid))
2980         if srv.port > 0:
2981             if not acceptors.has_key(srv.port):
2982                 acceptors[srv.port] = AcceptorHandler(srv.port, srv.net_type)
2983
2984 # This node is a gateway.
2985 is_router = 0
2986 def node_is_router():
2987     return is_router
2988
2989 # If there are any routers found in the config, then this will be true
2990 # and all nodes will load kptlrouter.
2991 needs_router = 0
2992 def node_needs_router():
2993     return needs_router or is_router
2994
2995 # list of (nettype, gw, tgt_cluster_id, lo, hi)
2996 # Currently, these local routes are only added to kptlrouter route
2997 # table if they are needed to connect to a specific server.  This
2998 # should be changed so all available routes are loaded, and the
2999 # ptlrouter can make all the decisions.
3000 local_routes = []
3001
3002 def find_local_routes(lustre):
3003     """ Scan the lustre config looking for routers .  Build list of
3004     routes. """
3005     global local_routes, needs_router
3006     local_routes = []
3007     list = lustre.lookup_class('node')
3008     for router in list:
3009         if router.get_val_int('router', 0):
3010             needs_router = 1
3011             for (local_type, local_cluster_id, local_nid) in local_clusters:
3012                 gw = None
3013                 for netuuid in router.get_networks():
3014                     db = router.lookup(netuuid)
3015                     if (local_type == db.get_val('nettype') and
3016                        local_cluster_id == db.get_val('clusterid')):
3017                         gw = db.get_val('nid')
3018                         break
3019                 if gw:
3020                     debug("find_local_routes: gw is", gw)
3021                     for route in router.get_local_routes(local_type, gw):
3022                         local_routes.append(route)
3023     debug("find_local_routes:", local_routes)
3024
3025
3026 def choose_local_server(srv_list):
3027     for srv in srv_list:
3028         if local_cluster(srv.net_type, srv.cluster_id):
3029             return srv
3030
3031 def local_cluster(net_type, cluster_id):
3032     for cluster in local_clusters:
3033         if net_type == cluster[0] and cluster_id == cluster[1]:
3034             return 1
3035     return 0
3036
3037 def local_interface(net_type, cluster_id, nid):
3038     for cluster in local_clusters:
3039         if (net_type == cluster[0] and cluster_id == cluster[1]
3040             and nid == cluster[2]):
3041             return 1
3042     return 0
3043
3044 def find_route(srv_list):
3045     result = []
3046     frm_type = local_clusters[0][0]
3047     for srv in srv_list:
3048         debug("find_route: srv:", srv.nid, "type: ", srv.net_type)
3049         to_type = srv.net_type
3050         to = srv.nid
3051         cluster_id = srv.cluster_id
3052         debug ('looking for route to', to_type, to)
3053         for r in local_routes:
3054             debug("find_route: ", r)
3055             if  (r[3] <= to and to <= r[4]) and cluster_id == r[2]:
3056                 result.append((srv, r))
3057     return result
3058
3059 def get_active_target(db):
3060     target_uuid = db.getUUID()
3061     target_name = db.getName()
3062     node_name = get_select(target_name)
3063     if node_name:
3064         tgt_dev_uuid = db.get_node_tgt_dev(node_name, target_uuid)
3065     else:
3066         tgt_dev_uuid = db.get_first_ref('active')
3067     return tgt_dev_uuid
3068
3069 def get_server_by_nid_uuid(db,  nid_uuid):
3070     for n in db.lookup_class("network"):
3071         net = Network(n)
3072         if net.nid_uuid == nid_uuid:
3073             return net
3074
3075
3076 ############################################################
3077 # lconf level logic
3078 # Start a service.
3079 def newService(db):
3080     type = db.get_class()
3081     debug('Service:', type, db.getName(), db.getUUID())
3082     n = None
3083     if type == 'ldlm':
3084         n = LDLM(db)
3085     elif type == 'lov':
3086         n = LOV(db, "YOU_SHOULD_NEVER_SEE_THIS_UUID")
3087     elif type == 'network':
3088         n = Network(db)
3089     elif type == 'routetbl':
3090         n = RouteTable(db)
3091     elif type == 'osd':
3092         n = OSD(db)
3093     elif type == 'cobd':
3094         n = COBD(db, "YOU_SHOULD_NEVER_SEE_THIS_UUID")
3095     elif type == 'cmobd':
3096         n = CMOBD(db)
3097     elif type == 'mdsdev':
3098         n = MDSDEV(db)
3099     elif type == 'mountpoint':
3100         n = Mountpoint(db)
3101     elif type == 'echoclient':
3102         n = ECHO_CLIENT(db)
3103     elif type == 'lmv':
3104         n = LMV(db)
3105     else:
3106         panic ("unknown service type:", type)
3107     return n
3108
3109 #
3110 # Prepare the system to run lustre using a particular profile
3111 # in a the configuration.
3112 #  * load & the modules
3113 #  * setup networking for the current node
3114 #  * make sure partitions are in place and prepared
3115 #  * initialize devices with lctl
3116 # Levels is important, and needs to be enforced.
3117 def for_each_profile(db, prof_list, operation):
3118     for prof_uuid in prof_list:
3119         prof_db = db.lookup(prof_uuid)
3120         if not prof_db:
3121             panic("profile:", prof_uuid, "not found.")
3122         services = getServices(prof_db)
3123         operation(services)
3124
3125 def magic_get_osc(db, rec, lov):
3126     if lov:
3127         lov_uuid = lov.get_uuid()
3128         lov_name = lov.osc.fs_name
3129     else:
3130         lov_uuid = rec.getAttribute('lov_uuidref')
3131         # FIXME: better way to find the mountpoint?
3132         filesystems = db.root_node.getElementsByTagName('filesystem')
3133         fsuuid = None
3134         for fs in filesystems:
3135             ref = fs.getElementsByTagName('obd_ref')
3136             if ref[0].getAttribute('uuidref') == lov_uuid:
3137                 fsuuid = fs.getAttribute('uuid')
3138                 break
3139
3140         if not fsuuid:
3141             panic("malformed xml: lov uuid '" + lov_uuid + "' referenced in 'add' record is not used by any filesystems.")
3142
3143         mtpts = db.root_node.getElementsByTagName('mountpoint')
3144         lov_name = None
3145         for fs in mtpts:
3146             ref = fs.getElementsByTagName('filesystem_ref')
3147             if ref[0].getAttribute('uuidref') == fsuuid:
3148                 lov_name = fs.getAttribute('name')
3149                 break
3150
3151         if not lov_name:
3152             panic("malformed xml: 'add' record references lov uuid '" + lov_uuid + "', which references filesystem uuid '" + fsuuid + "', which does not reference a mountpoint.")
3153
3154     print "lov_uuid: " + lov_uuid + "; lov_name: " + lov_name
3155
3156     ost_uuid = rec.getAttribute('ost_uuidref')
3157     obd = db.lookup(ost_uuid)
3158
3159     if not obd:
3160         panic("malformed xml: 'add' record references ost uuid '" + ost_uuid + "' which cannot be found.")
3161
3162     osc = get_osc(obd, lov_uuid, lov_name)
3163     if not osc:
3164         panic('osc not found:', obd_uuid)
3165     return osc
3166
3167 # write logs for update records.  sadly, logs of all types -- and updates in
3168 # particular -- are something of an afterthought.  lconf needs rewritten with
3169 # these as core concepts.  so this is a pretty big hack.
3170 def process_update_record(db, update, lov):
3171     for rec in update.childNodes:
3172         if rec.nodeType != rec.ELEMENT_NODE:
3173             continue
3174
3175         log("found "+rec.nodeName+" record in update version " +
3176             str(update.getAttribute('version')))
3177
3178         lov_uuid = rec.getAttribute('lov_uuidref')
3179         ost_uuid = rec.getAttribute('ost_uuidref')
3180         index = rec.getAttribute('index')
3181         gen = rec.getAttribute('generation')
3182
3183         if not lov_uuid or not ost_uuid or not index or not gen:
3184             panic("malformed xml: 'update' record requires lov_uuid, ost_uuid, index, and generation.")
3185
3186         if not lov:
3187             tmplov = db.lookup(lov_uuid)
3188             if not tmplov:
3189                 panic("malformed xml: 'delete' record contains lov UUID '" + lov_uuid + "', which cannot be located.")
3190             lov_name = tmplov.getName()
3191         else:
3192             lov_name = lov.osc.name
3193
3194         # ------------------------------------------------------------- add
3195         if rec.nodeName == 'add':
3196             if config.cleanup:
3197                 lctl.lov_del_obd(lov_name, lov_uuid, ost_uuid, index, gen)
3198                 continue
3199
3200             osc = magic_get_osc(db, rec, lov)
3201
3202             try:
3203                 # Only ignore connect failures with --force, which
3204                 # isn't implemented here yet.
3205                 osc.prepare(ignore_connect_failure=0)
3206             except CommandError, e:
3207                 print "Error preparing OSC %s\n" % osc.uuid
3208                 raise e
3209
3210             lctl.lov_add_obd(lov_name, lov_uuid, ost_uuid, index, gen)
3211
3212         # ------------------------------------------------------ deactivate
3213         elif rec.nodeName == 'deactivate':
3214             if config.cleanup:
3215                 continue
3216
3217             osc = magic_get_osc(db, rec, lov)
3218
3219             try:
3220                 osc.deactivate()
3221             except CommandError, e:
3222                 print "Error deactivating OSC %s\n" % osc.uuid
3223                 raise e
3224
3225         # ---------------------------------------------------------- delete
3226         elif rec.nodeName == 'delete':
3227             if config.cleanup:
3228                 continue
3229
3230             osc = magic_get_osc(db, rec, lov)
3231
3232             try:
3233                 config.cleanup = 1
3234                 osc.cleanup()
3235                 config.cleanup = 0
3236             except CommandError, e:
3237                 print "Error cleaning up OSC %s\n" % osc.uuid
3238                 raise e
3239
3240             lctl.lov_del_obd(lov_name, lov_uuid, ost_uuid, index, gen)
3241
3242 def process_updates(db, log_device, log_name, lov = None):
3243     updates = db.root_node.getElementsByTagName('update')
3244     for u in updates:
3245         if not u.childNodes:
3246             log("ignoring empty update record (version " +
3247                 str(u.getAttribute('version')) + ")")
3248             continue
3249
3250         version = u.getAttribute('version')
3251         real_name = "%s-%s" % (log_name, version)
3252         lctl.clear_log(log_device, real_name)
3253         lctl.record(log_device, real_name)
3254
3255         process_update_record(db, u, lov)
3256
3257         lctl.end_record()
3258
3259 def doWriteconf(services):
3260     #if config.nosetup:
3261     #    return
3262     for s in services:
3263         if s[1].get_class() == 'mdsdev' or s[1].get_class() == 'osd':
3264             n = newService(s[1])
3265             n.write_conf()
3266             n.cleanup()
3267
3268 def doSetup(services):
3269     if config.nosetup:
3270         return
3271     slist = []
3272     for s in services:
3273         n = newService(s[1])
3274         n.level = s[0]
3275         slist.append((n.level, n))
3276     nlist = []
3277     for n in slist:
3278         nl = n[1].correct_level(n[0])
3279         nlist.append((nl, n[1]))
3280     nlist.sort()
3281     for n in nlist:
3282         n[1].prepare()
3283
3284 def doLoadModules(services):
3285     if config.nomod:
3286         return
3287
3288     # adding all needed modules from all services
3289     for s in services:
3290         n = newService(s[1])
3291         n.add_module(mod_manager)
3292
3293     # loading all registered modules
3294     mod_manager.load_modules()
3295
3296 def doUnloadModules(services):
3297     if config.nomod:
3298         return
3299
3300     # adding all needed modules from all services
3301     for s in services:
3302         n = newService(s[1])
3303         if n.safe_to_clean_modules():
3304             n.add_module(mod_manager)
3305
3306     # unloading all registered modules
3307     mod_manager.cleanup_modules()
3308
3309 def doCleanup(services):
3310     if config.nosetup:
3311         return
3312     slist = []
3313
3314     for s in services:
3315         n = newService(s[1])
3316         n.level = s[0]
3317         slist.append((n.level, n))
3318     nlist = []
3319     for n in slist:
3320         nl = n[1].correct_level(n[0])
3321         nlist.append((nl, n[1]))
3322     nlist.sort()
3323     nlist.reverse()
3324
3325     for n in nlist:
3326         if n[1].safe_to_clean():
3327             n[1].cleanup()
3328
3329 #
3330 # Load profile for
3331 def doHost(lustreDB, hosts):
3332     global is_router, local_node_name
3333     node_db = None
3334     for h in hosts:
3335         node_db = lustreDB.lookup_name(h, 'node')
3336         if node_db:
3337             break
3338     if not node_db:
3339         panic('No host entry found.')
3340
3341     local_node_name = node_db.get_val('name', 0)
3342     is_router = node_db.get_val_int('router', 0)
3343     lustre_upcall = node_db.get_val('lustreUpcall', '')
3344     portals_upcall = node_db.get_val('portalsUpcall', '')
3345     timeout = node_db.get_val_int('timeout', 0)
3346     ptldebug = node_db.get_val('ptldebug', '')
3347     subsystem = node_db.get_val('subsystem', '')
3348
3349     find_local_clusters(node_db)
3350     if not is_router:
3351         find_local_routes(lustreDB)
3352
3353     # Two step process: (1) load modules, (2) setup lustre
3354     # if not cleaning, load modules first.
3355     prof_list = node_db.get_refs('profile')
3356
3357     if config.write_conf:
3358         for_each_profile(node_db, prof_list, doLoadModules)
3359         sys_make_devices()
3360         for_each_profile(node_db, prof_list, doWriteconf)
3361         for_each_profile(node_db, prof_list, doUnloadModules)
3362         lustreDB.close()
3363
3364     elif config.recover:
3365         if not (config.tgt_uuid and config.client_uuid and config.conn_uuid):
3366             raise Lustre.LconfError( "--recovery requires --tgt_uuid <UUID> " +
3367                                      "--client_uuid <UUID> --conn_uuid <UUID>")
3368         doRecovery(lustreDB, lctl, config.tgt_uuid, config.client_uuid,
3369                    config.conn_uuid)
3370     elif config.cleanup:
3371         if config.force:
3372             # the command line can override this value
3373             timeout = 5
3374         # ugly hack, only need to run lctl commands for --dump
3375         if config.lctl_dump or config.record:
3376             for_each_profile(node_db, prof_list, doCleanup)
3377             return
3378
3379         sys_set_timeout(timeout)
3380         sys_set_ptldebug(ptldebug)
3381         sys_set_subsystem(subsystem)
3382         sys_set_lustre_upcall(lustre_upcall)
3383         sys_set_portals_upcall(portals_upcall)
3384
3385         for_each_profile(node_db, prof_list, doCleanup)
3386         for_each_profile(node_db, prof_list, doUnloadModules)
3387         lustreDB.close()
3388
3389     else:
3390         # ugly hack, only need to run lctl commands for --dump
3391         if config.lctl_dump or config.record:
3392             sys_set_timeout(timeout)
3393             sys_set_lustre_upcall(lustre_upcall)
3394             for_each_profile(node_db, prof_list, doSetup)
3395             return
3396
3397         sys_make_devices()
3398         sys_set_netmem_max('/proc/sys/net/core/rmem_max', MAXTCPBUF)
3399         sys_set_netmem_max('/proc/sys/net/core/wmem_max', MAXTCPBUF)
3400
3401         for_each_profile(node_db, prof_list, doLoadModules)
3402
3403         sys_set_debug_path()
3404         sys_set_ptldebug(ptldebug)
3405         sys_set_subsystem(subsystem)
3406         script = config.gdb_script
3407         run(lctl.lctl, ' modules >', script)
3408         if config.gdb:
3409             log ("The GDB module script is in", script)
3410             # pause, so user has time to break and
3411             # load the script
3412             time.sleep(5)
3413         sys_set_timeout(timeout)
3414         sys_set_lustre_upcall(lustre_upcall)
3415         sys_set_portals_upcall(portals_upcall)
3416
3417         for_each_profile(node_db, prof_list, doSetup)
3418         lustreDB.close()
3419
3420 def doRecovery(lustreDB, lctl, tgt_uuid, client_uuid, nid_uuid):
3421     tgt = lustreDB.lookup(tgt_uuid)
3422     if not tgt:
3423         raise Lustre.LconfError("doRecovery: "+ tgt_uuid +" not found.")
3424     new_uuid = get_active_target(tgt)
3425     if not new_uuid:
3426         raise Lustre.LconfError("doRecovery: no active target found for: " +
3427                                 tgt_uuid)
3428     net = choose_local_server(get_ost_net(lustreDB, new_uuid))
3429     if not net:
3430         raise Lustre.LconfError("Unable to find a connection to:" + new_uuid)
3431
3432     log("Reconnecting", tgt_uuid, " to ",  net.nid_uuid);
3433     try:
3434         oldnet = get_server_by_nid_uuid(lustreDB, nid_uuid)
3435         lustreDB.close()
3436         if oldnet:
3437             lctl.disconnect(oldnet)
3438     except CommandError, e:
3439         log("recover: disconnect", nid_uuid, "failed: ")
3440         e.dump()
3441
3442     try:
3443         lctl.connect(net)
3444     except CommandError, e:
3445         log("recover: connect failed")
3446         e.dump()
3447
3448     lctl.recover(client_uuid, net.nid_uuid)
3449
3450
3451 def setupModulePath(cmd, portals_dir = PORTALS_DIR):
3452     base = os.path.dirname(cmd)
3453     if development_mode():
3454         if not config.lustre:
3455             debug('using objdir module paths')
3456             config.lustre = (os.path.join(base, ".."))
3457         # normalize the portals dir, using command line arg if set
3458         if config.portals:
3459             portals_dir = config.portals
3460         dir = os.path.join(config.lustre, portals_dir)
3461         config.portals = dir
3462         debug('config.portals', config.portals)
3463     elif config.lustre and config.portals:
3464         # production mode
3465         # if --lustre and --portals, normalize portals
3466         # can ignore POTRALS_DIR here, since it is probly useless here
3467         config.portals = os.path.join(config.lustre, config.portals)
3468         debug('config.portals B', config.portals)
3469
3470 def sysctl(path, val):
3471     debug("+ sysctl", path, val)
3472     if config.noexec:
3473         return
3474     try:
3475         fp = open(os.path.join('/proc/sys', path), 'w')
3476         fp.write(str(val))
3477         fp.close()
3478     except IOError, e:
3479         panic(str(e))
3480
3481
3482 def sys_set_debug_path():
3483     sysctl('portals/debug_path', config.debug_path)
3484
3485 def sys_set_lustre_upcall(upcall):
3486     # the command overrides the value in the node config
3487     if config.lustre_upcall:
3488         upcall = config.lustre_upcall
3489     elif config.upcall:
3490         upcall = config.upcall
3491     if upcall:
3492         lctl.set_lustre_upcall(upcall)
3493
3494 def sys_set_portals_upcall(upcall):
3495     # the command overrides the value in the node config
3496     if config.portals_upcall:
3497         upcall = config.portals_upcall
3498     elif config.upcall:
3499         upcall = config.upcall
3500     if upcall:
3501         sysctl('portals/upcall', upcall)
3502
3503 def sys_set_timeout(timeout):
3504     # the command overrides the value in the node config
3505     if config.timeout and config.timeout > 0:
3506         timeout = config.timeout
3507     if timeout != None and timeout > 0:
3508         lctl.set_timeout(timeout)
3509
3510 def sys_tweak_socknal ():
3511     # reserve at least 8MB, or we run out of RAM in skb_alloc under read
3512     if sys_get_branch() == '2.6':
3513         fp = open('/proc/meminfo')
3514         lines = fp.readlines()
3515         fp.close()
3516         memtotal = 131072
3517         for l in lines:
3518             a = string.split(l)
3519             if a[0] == 'MemTotal:':
3520                 memtotal = a[1]
3521                 debug("memtotal" + memtotal)
3522         if int(memtotal) < 262144:
3523             minfree = int(memtotal) / 16
3524         else:
3525             minfree = 32768
3526         debug("+ minfree ", minfree)
3527         sysctl("vm/min_free_kbytes", minfree)
3528     if config.single_socket:
3529         sysctl("socknal/typed", 0)
3530
3531 def sys_optimize_elan ():
3532     procfiles = ["/proc/elan/config/eventint_punt_loops",
3533                  "/proc/qsnet/elan3/config/eventint_punt_loops",
3534                  "/proc/qsnet/elan4/config/elan4_mainint_punt_loops"]
3535     for p in procfiles:
3536         if os.access(p, os.W_OK):
3537             run ("echo 1 > " + p)
3538
3539 def sys_set_ptldebug(ptldebug):
3540     if config.ptldebug:
3541         ptldebug = config.ptldebug
3542     if ptldebug:
3543         try:
3544             val = eval(ptldebug, ptldebug_names)
3545             val = "0x%x" % (val & 0xffffffffL)
3546             sysctl('portals/debug', val)
3547         except NameError, e:
3548             panic(str(e))
3549
3550 def sys_set_subsystem(subsystem):
3551     if config.subsystem:
3552         subsystem = config.subsystem
3553     if subsystem:
3554         try:
3555             val = eval(subsystem, subsystem_names)
3556             val = "0x%x" % (val & 0xffffffffL)
3557             sysctl('portals/subsystem_debug', val)
3558         except NameError, e:
3559             panic(str(e))
3560
3561 def sys_set_netmem_max(path, max):
3562     debug("setting", path, "to at least", max)
3563     if config.noexec:
3564         return
3565     fp = open(path)
3566     str = fp.readline()
3567     fp.close()
3568     cur = int(str)
3569     if max > cur:
3570         fp = open(path, 'w')
3571         fp.write('%d\n' %(max))
3572         fp.close()
3573
3574 def sys_make_devices():
3575     if not os.access('/dev/portals', os.R_OK):
3576         run('mknod /dev/portals c 10 240')
3577     if not os.access('/dev/obd', os.R_OK):
3578         run('mknod /dev/obd c 10 241')
3579
3580 # Add dir to the global PATH, if not already there.
3581 def add_to_path(new_dir):
3582     syspath = string.split(os.environ['PATH'], ':')
3583     if new_dir in syspath:
3584         return
3585     os.environ['PATH'] = os.environ['PATH'] + ':' + new_dir
3586
3587 def default_debug_path():
3588     path = '/tmp/lustre-log'
3589     if os.path.isdir('/r'):
3590         return '/r' + path
3591     else:
3592         return path
3593
3594 def default_gdb_script():
3595     script = '/tmp/ogdb'
3596     if os.path.isdir('/r'):
3597         return '/r' + script
3598     else:
3599         return script
3600
3601 DEFAULT_PATH = ('/sbin', '/usr/sbin', '/bin', '/usr/bin')
3602 # ensure basic elements are in the system path
3603 def sanitise_path():
3604     for dir in DEFAULT_PATH:
3605         add_to_path(dir)
3606
3607 # global hack for the --select handling
3608 tgt_select = {}
3609 def init_select(args):
3610     # args = [service=nodeA,service2=nodeB service3=nodeC]
3611     global tgt_select
3612     for arg in args:
3613         list = string.split(arg, ',')
3614         for entry in list:
3615             srv, node = string.split(entry, '=')
3616             tgt_select[srv] = node
3617
3618 def get_select(srv):
3619     if tgt_select.has_key(srv):
3620         return tgt_select[srv]
3621     return None
3622
3623
3624 FLAG = Lustre.Options.FLAG
3625 PARAM = Lustre.Options.PARAM
3626 INTPARAM = Lustre.Options.INTPARAM
3627 PARAMLIST = Lustre.Options.PARAMLIST
3628 lconf_options = [
3629     ('verbose,v', "Print system commands as they are run"),
3630     ('ldapurl',"LDAP server URL, eg. ldap://localhost", PARAM),
3631     ('config', "Cluster config name used for LDAP query", PARAM),
3632     ('select', "service=nodeA,service2=nodeB ", PARAMLIST),
3633     ('node',   "Load config for <nodename>", PARAM),
3634     ('sec',"security flavor <null|krb5i|krb5p> between this client with mds", PARAM),
3635     ('mds_sec',"security flavor <null|krb5i|krb5p> between this client with mds", PARAM),
3636     ('oss_sec',"security flavor <null|krb5i|krb5p> between this client with ost", PARAM),
3637     ('mds_mds_sec',"security flavor <null|krb5i|krb5p> between this mds with other mds", PARAM),
3638     ('mds_oss_sec',"security flavor <null|krb5i|krb5p> between this mds with ost", PARAM),
3639     ('mds_deny_sec', "security flavor <null|krb5i|krb5p> denied by this mds", PARAM),
3640     ('ost_deny_sec', "security flavor <null|krb5i|krb5p> denied by this ost", PARAM),
3641     ('cleanup,d', "Cleans up config. (Shutdown)"),
3642     ('force,f', "Forced unmounting and/or obd detach during cleanup",
3643                FLAG, 0),
3644     ('single_socket', "socknal option: only use one socket instead of bundle",
3645                FLAG, 0),
3646     ('failover',"""Used to shut down without saving state.
3647                    This will allow this node to "give up" a service to a
3648                    another node for failover purposes. This will not
3649                    be a clean shutdown.""",
3650                FLAG, 0),
3651     ('gdb', """Prints message after creating gdb module script
3652                     and sleeps for 5 seconds."""),
3653     ('noexec,n', """Prints the commands and steps that will be run for a
3654                     config without executing them. This can used to check if a
3655                     config file is doing what it should be doing"""),
3656     ('nomod', "Skip load/unload module step."),
3657     ('nosetup', "Skip device setup/cleanup step."),
3658     ('reformat', "Reformat all devices (without question)"),
3659     ('mkfsoptions', "Additional options for the mk*fs command line", PARAM),
3660     ('mountfsoptions', "Additional options for mount fs command line", PARAM),
3661     ('clientoptions', "Additional options for Lustre", PARAM),
3662     ('dump',  "Dump the kernel debug log to file before portals is unloaded",
3663                PARAM),
3664     ('write_conf', "Save all the client config information on mds."),
3665     ('record', "Write config information on mds."),
3666     ('record_log', "Name of config record log.", PARAM),
3667     ('record_device', "MDS device name that will record the config commands",
3668               PARAM),
3669     ('root_squash', "MDS squash root to appointed uid",
3670               PARAM),
3671     ('no_root_squash', "Don't squash root for appointed nid",
3672               PARAM),
3673     ('minlevel', "Minimum level of services to configure/cleanup",
3674                  INTPARAM, 0),
3675     ('maxlevel', """Maximum level of services to configure/cleanup
3676                     Levels are aproximatly like:
3677                             10 - netwrk
3678                             20 - device, ldlm
3679                             30 - osd, mdd
3680                             40 - mds, ost
3681                             70 - mountpoint, echo_client, osc, mdc, lov""",
3682                INTPARAM, 100),
3683     ('lustre', """Base directory of lustre sources. This parameter will
3684                   cause lconf to load modules from a source tree.""", PARAM),
3685     ('portals', """Portals source directory.  If this is a relative path,
3686                    then it is assumed to be relative to lustre. """, PARAM),
3687     ('timeout', "Set recovery timeout", INTPARAM),
3688     ('upcall',  "Set both portals and lustre upcall script", PARAM),
3689     ('lustre_upcall', "Set lustre upcall script", PARAM),
3690     ('portals_upcall', "Set portals upcall script", PARAM),
3691     ('lctl_dump', "Save lctl ioctls to the dumpfile argument", PARAM),
3692     ('ptldebug', "Set the portals debug level",  PARAM),
3693     ('subsystem', "Set the portals debug subsystem",  PARAM),
3694     ('gdb_script', "Fullname of gdb debug script", PARAM, default_gdb_script()),
3695     ('debug_path', "Path to save debug dumps", PARAM, default_debug_path()),
3696 # Client recovery options
3697     ('recover', "Recover a device"),
3698     ('group', "The group of devices to configure or cleanup", PARAM),
3699     ('tgt_uuid', "The failed target (required for recovery)", PARAM),
3700     ('client_uuid', "The failed client (required for recovery)", PARAM),
3701     ('conn_uuid', "The failed connection (required for recovery)", PARAM),
3702
3703     ('inactive', """The name of an inactive service, to be ignored during
3704                     mounting (currently OST-only). Can be repeated.""",
3705                 PARAMLIST),
3706     ]
3707
3708 def main():
3709     global lctl, config, toplustreDB, CONFIG_FILE, mod_manager
3710
3711     # in the upcall this is set to SIG_IGN
3712     signal.signal(signal.SIGCHLD, signal.SIG_DFL)
3713
3714     cl = Lustre.Options("lconf", "config.xml", lconf_options)
3715     try:
3716         config, args = cl.parse(sys.argv[1:])
3717     except Lustre.OptionError, e:
3718         print e
3719         sys.exit(1)
3720
3721     setupModulePath(sys.argv[0])
3722
3723     host = socket.gethostname()
3724
3725     # the PRNG is normally seeded with time(), which is not so good for starting
3726     # time-synchronized clusters
3727     input = open('/dev/urandom', 'r')
3728     if not input:
3729         print 'Unable to open /dev/urandom!'
3730         sys.exit(1)
3731     seed = input.read(32)
3732     input.close()
3733     random.seed(seed)
3734
3735     sanitise_path()
3736
3737     init_select(config.select)
3738
3739     if len(args) > 0:
3740         # allow config to be fetched via HTTP, but only with python2
3741         if sys.version[0] != '1' and args[0].startswith('http://'):
3742             import urllib2
3743             try:
3744                 config_file = urllib2.urlopen(args[0])
3745             except (urllib2.URLError, socket.error), err:
3746                 if hasattr(err, 'args'):
3747                     err = err.args[1]
3748                 print "Could not access '%s': %s" %(args[0], err)
3749                 sys.exit(1)
3750         elif not os.access(args[0], os.R_OK):
3751             print 'File not found or readable:', args[0]
3752             sys.exit(1)
3753         else:
3754             # regular file
3755             config_file = open(args[0], 'r')
3756         try:
3757             dom = xml.dom.minidom.parse(config_file)
3758         except Exception:
3759             panic("%s does not appear to be a config file." % (args[0]))
3760             sys.exit(1) # make sure to die here, even in debug mode.
3761         config_file.close()
3762         CONFIG_FILE = args[0]
3763         lustreDB = Lustre.LustreDB_XML(dom.documentElement, dom.documentElement)
3764         if not config.config:
3765             config.config = os.path.basename(args[0])# use full path?
3766             if config.config[-4:] == '.xml':
3767                 config.config = config.config[:-4]
3768     elif config.ldapurl:
3769         if not config.config:
3770             panic("--ldapurl requires --config name")
3771         dn = "config=%s,fs=lustre" % (config.config)
3772         lustreDB = Lustre.LustreDB_LDAP('', {}, base=dn, url = config.ldapurl)
3773     elif config.ptldebug or config.subsystem:
3774         sys_set_ptldebug(None)
3775         sys_set_subsystem(None)
3776         sys.exit(0)
3777     else:
3778         print 'Missing config file or ldap URL.'
3779         print 'see lconf --help for command summary'
3780         sys.exit(1)
3781
3782     toplustreDB = lustreDB
3783
3784     ver = lustreDB.get_version()
3785     if not ver:
3786         panic("No version found in config data, please recreate.")
3787     if ver != Lustre.CONFIG_VERSION:
3788         panic("Config version", ver, "does not match lconf version",
3789               Lustre.CONFIG_VERSION)
3790
3791     node_list = []
3792     if config.node:
3793         node_list.append(config.node)
3794     else:
3795         if len(host) > 0:
3796             node_list.append(host)
3797         node_list.append('localhost')
3798
3799     debug("configuring for host: ", node_list)
3800
3801     if len(host) > 0:
3802         config.debug_path = config.debug_path + '-' + host
3803         config.gdb_script = config.gdb_script + '-' + host
3804
3805     lctl = LCTLInterface('lctl')
3806
3807     if config.lctl_dump:
3808         lctl.use_save_file(config.lctl_dump)
3809
3810     if config.record:
3811         if not (config.record_device and config.record_log):
3812             panic("When recording, both --record_log and --record_device must be specified.")
3813         lctl.clear_log(config.record_device, config.record_log)
3814         lctl.record(config.record_device, config.record_log)
3815
3816     # init module manager
3817     mod_manager = kmod_manager(config.lustre, config.portals)
3818
3819     doHost(lustreDB, node_list)
3820
3821     if not config.record:
3822         return
3823
3824     lctl.end_record()
3825
3826     process_updates(lustreDB, config.record_device, config.record_log)
3827
3828 if __name__ == "__main__":
3829     try:
3830         main()
3831     except Lustre.LconfError, e:
3832         print e
3833 #        traceback.print_exc(file=sys.stdout)
3834         sys.exit(1)
3835     except CommandError, e:
3836         e.dump()
3837         sys.exit(e.rc)
3838
3839     if first_cleanup_error:
3840         sys.exit(first_cleanup_error)