"""
lmc - lustre configurtion data manager
-
- Basic plan for lmc usage:
-# create nodes
-./lmc --output config.xml --node server --net server1 tcp
-./lmc --merge config.xml --node client --net client1 tcp
-./lmc --merge config.xml --node client --route gw lo [hi]
-./lmc --merge config.xml --router --node gw1 --net gw1 tcp
-./lmc --merge config.xml --node gw1 --net 1 elan
-./lmc --merge config.xml --route elan 1 1 100
-./lmc --merge config.xml --route tcp gw1 ba1
-
-
-
-# configure server
-./lmc --merge config.xml --node server --mds mds1 /tmp/mds1 50000
-
-# create lov
-./lmc --merge config.xml --lov lov1 mds1 65536 0 0
-./lmc --merge config.xml --node server --lov lov1 --ost /tmp/ost1 100000
-./lmc --merge config.xml --node server --lov lov1 --ost /tmp/ost2 100000
-
-# create client config
-./lmc --merge config.xml --node client --mtpt /mnt/lustre mds1 lov1
+ See lustre book for documentation for lmc.
"""
-import sys, os, getopt, string
+import sys, os, getopt, string, exceptions
import xml.dom.minidom
from xml.dom.ext import PrettyPrint
-
-DEFAULT_PORT = 988 # XXX What is the right default acceptor port to use?
+DEFAULT_PORT = 988
def usage():
- print """usage: lmc [--node --ost | --mtpt | --lov] args
-Commands:
---node node_name
- Node_name by itself it will create a new node. If the --router
- option is used when creating a new node, then that node will also
- be configured as a router. When used with other commands it
- specifies the node to modify.
-
---net hostname nettype [port, recv_buf, send_buf]
- Nettype is either tcp, elan, or gm.
- Requires --node
-
---route net gw lo [hi]
- This command is used to create routes. NET is the
- network type this route will be used on. The GW is an address of
- one of the local interfaces. LO and HI represent a range of
- addresses that can be reached through the gateway. If HI is not
- set, then a route to the specific host in LO is created.
-
---mds device [size]
- Create a MDS using the device
- Requires --node
-
---lov lov_name [mds_name stripe_sz stripe_off pattern]
- Creates a logical volume
- When used with other commands, it specifics the lov to modify
-
---ost device [size]
- Creates an OBD/OST/OSC configuration triplet for a new device.
- When used on "host", the device will be initialized and the OST
- will be enabled. On client nodes, the OSC will be avaiable.
- Requires --node
- If --lov lov_name is used, this device is added to lov.
-
---mtpt /mnt/point mds_name lov_name|osc_name
- Creates a client mount point.
- Requires --node
-
-Options:
---merge="xml file" Add the new objects to an existing file
---format Format the partitions if unformated
- NB: The autoformat option has been disabled until a safe
- method is implemented to determine if a block device has a
- filesystem.
---reformat Reformat partitions (this should be an lconf arg,
- I think)
---obdtype="obdtype" Specifiy obdtype: valid ones are obdecho and obdfilter.
- This is only useful for the --ost command.
- The device parameters are ignored for the obdecho type.
+ print """usage: lmc --add object [object parameters]
+
+Object creation command summary:
+
+--add node
+ --node node_name
+ --timeout num
+ --recovery_upcall path
+
+--add net
+ --node node_name
+ --nid addr
+ --nettype tcp|elan|toe|gm
+ --port port
+ --tcpbuf size
+ --router
+
+--add mds
+ --node node_name
+ --mds mds_name
+ --dev path
+ --fstype extN|ext3
+ --size size
+
+--add lov
+ --lov lov_name
+ --mds mds_name
+ --stripe_sz num
+ --stripe_cnt num
+ --stripe_pattern num
+
+-add ost
+ --node node_name
+ --obd obd_name
+ --lov lov_name
+ --dev path
+ --size size
+ --fstype extN|ext3
+ --obduuid uuid
+
+--add mtpt - Mountpoint
+ --node node_name
+ --path /mnt/point
+ --mds mds_name
+ --obd obd_name OR --lov lovname
"""
sys.exit(1)
def error(*args):
msg = string.join(map(str,args))
+ raise OptionError("Error: " + msg)
+
+def panic(cmd, msg):
+ print "! " + cmd
print msg
sys.exit(1)
+
+
+def warning(*args):
+ msg = string.join(map(str,args))
+ print "Warning: ", msg
#
# manage names and uuids
def newService(self, tag, name, uuid):
""" create a new service elmement, which requires name and uuid attributes """
new = self.doc.createElement(tag)
- new.setAttribute("name", name);
new.setAttribute("uuid", uuid);
+ new.setAttribute("name", name);
return new
def addText(self, node, str):
def network(self, name, uuid, hostname, net, port=0, tcpbuf=0):
"""create <network> node"""
network = self.newService("network", name, uuid)
- network.setAttribute("type", net);
- self.addElement(network, "server", hostname)
+ network.setAttribute("nettype", net);
+ self.addElement(network, "nid", hostname)
if port:
self.addElement(network, "port", "%d" %(port))
if tcpbuf:
- self.addElement(network, "send_mem", "%d" %(tcpbuf))
- self.addElement(network, "recv_mem", "%d" %(tcpbuf))
+ self.addElement(network, "sendmem", "%d" %(tcpbuf))
+ self.addElement(network, "recvmem", "%d" %(tcpbuf))
return network
ref.setAttribute("hi", hi)
return ref
- def node(self, name, uuid):
+ def profile(self, name, uuid):
+ """ create a host """
+ profile = self.newService("profile", name, uuid)
+ return profile
+
+ def node(self, name, uuid, prof_uuid):
""" create a host """
node = self.newService("node", name, uuid)
- self.addElement(node, 'profile')
+ node.appendChild(self.ref("profile", prof_uuid))
return node
def ldlm(self, name, uuid):
ldlm = self.newService("ldlm", name, uuid)
return ldlm
- def obd(self, name, uuid, fs, obdtype, devname, format, dev_size=0):
+ def obd(self, name, uuid, fs, obdtype, devname, format, ost_uuid, dev_size=0):
obd = self.newService("obd", name, uuid)
- obd.setAttribute('type', obdtype)
+ obd.setAttribute('obdtype', obdtype)
+ obd.appendChild(self.ref("active", ost_uuid))
if fs:
self.addElement(obd, "fstype", fs)
if devname:
- dev = self.addElement(obd, "device", devname)
- if (dev_size):
- dev.setAttribute("size", "%s" % (dev_size))
+ dev = self.addElement(obd, "devpath", devname)
self.addElement(obd, "autoformat", format)
+ if dev_size:
+ self.addElement(obd, "devsize", "%s" % (dev_size))
return obd
- def osc(self, name, uuid, obd_uuid, net_uuid):
- osc = self.newService("osc", name, uuid)
- osc.appendChild(self.ref("ost", net_uuid))
- osc.appendChild(self.ref("obd", obd_uuid))
- return osc
+ def cobd(self, name, uuid, real_uuid, cache_uuid):
+ cobd = self.newService("cobd", name, uuid)
+ cobd.appendChild(self.ref("realobd",real_uuid))
+ cobd.appendChild(self.ref("cacheobd",cache_uuid))
+ return cobd
def ost(self, name, uuid, obd_uuid, net_uuid):
ost = self.newService("ost", name, uuid)
ost.appendChild(self.ref("obd", obd_uuid))
return ost
- def lov(self, name, uuid, mds_uuid, stripe_sz, stripe_off, pattern):
+ def lov(self, name, uuid, mds_uuid, stripe_sz, stripe_cnt, pattern):
lov = self.newService("lov", name, uuid)
lov.appendChild(self.ref("mds", mds_uuid))
- devs = self.addElement(lov, "devices" )
- devs.setAttribute("stripesize", stripe_sz)
- devs.setAttribute("stripeoffset", stripe_off)
- devs.setAttribute("pattern", pattern)
+ lov.setAttribute("stripesize", stripe_sz)
+ lov.setAttribute("stripecount", stripe_cnt)
+ lov.setAttribute("stripepattern", pattern)
return lov
def lovconfig(self, name, uuid, lov_uuid):
lovconfig.appendChild(self.ref("lov", lov_uuid))
return lovconfig
- def mds(self, name, uuid, fs, devname, format, net_uuid, node_uuid,
- failover_uuid = "", dev_size=0 ):
+ def mds(self, name, uuid, mdd_uuid):
mds = self.newService("mds", name, uuid)
- self.addElement(mds, "fstype", fs)
- dev = self.addElement(mds, "device", devname)
- if dev_size:
- dev.setAttribute("size", "%s" % (dev_size))
- self.addElement(mds, "autoformat", format)
- mds.appendChild(self.ref("network", net_uuid))
- mds.appendChild(self.ref("node", node_uuid))
- if failover_uuid:
- mds.appendChild(self.ref("failover", failover_uuid))
+ mds.appendChild(self.ref("active",mdd_uuid))
return mds
+ def mdsdev(self, name, uuid, fs, devname, format, net_uuid, node_uuid,
+ mds_uuid, dev_size=0 ):
+ mdd = self.newService("mdsdev", name, uuid)
+ self.addElement(mdd, "fstype", fs)
+ dev = self.addElement(mdd, "devpath", devname)
+ self.addElement(mdd, "autoformat", format)
+ if dev_size:
+ self.addElement(mdd, "devsize", "%s" % (dev_size))
+ mdd.appendChild(self.ref("network", net_uuid))
+ mdd.appendChild(self.ref("mds", mds_uuid))
+ return mdd
+
def mountpoint(self, name, uuid, mds_uuid, osc_uuid, path):
mtpt = self.newService("mountpoint", name, uuid)
mtpt.appendChild(self.ref("mds", mds_uuid))
- mtpt.appendChild(self.ref("osc", osc_uuid))
+ mtpt.appendChild(self.ref("obd", osc_uuid))
self.addElement(mtpt, "path", path)
return mtpt
+ def echo_client(self, name, uuid, osc_uuid):
+ ec = self.newService("echoclient", name, uuid)
+ ec.appendChild(self.ref("obd", osc_uuid))
+ return ec
+
############################################################
# Utilities to query a DOM tree
# Using this functions we can treat use config information
n = lookup(n, uuid)
if n: return n
return None
-
-
-def mds2node(lustre, mds_name):
- """ Find the node a MDS is configured on """
- mds = findByName(lustre, mds_name, 'mds')
- ref = mds.getElementsByTagName('node_ref')
- if not ref:
- error("no node found for:", mds_name)
- node_uuid = ref[0].getAttribute('uuidref')
- node = lookup(lustre, node_uuid)
- if not node:
- error("no node found for :", mds_name)
- return node
def name2uuid(lustre, name, tag="", fatal=1):
ret = findByName(lustre, name, tag)
if not ret:
if fatal:
- error('name2uuid:', name, "not found.")
+ error('name2uuid:', '"'+name+'"', tag, 'element not found.')
else:
return ""
return getUUID(ret)
""" get a network uuid for a node_name """
node = findByName(lustre, node_name, "node")
if not node:
- error ("node not found:", node_name)
+ error ('get_net_uuid:', '"'+node_name+'"', "node element not found.")
net = node.getElementsByTagName('network')
if net:
return getUUID(net[0])
return None
-def lov_add_osc(gen, lov, osc_uuid):
- devs = lov.getElementsByTagName('devices')
- if len(devs) == 1:
- devs[0].appendChild(gen.ref("osc", osc_uuid))
- else:
- error("No devices element found for LOV:", lov)
-
+def lov_add_obd(gen, lov, osc_uuid):
+ lov.appendChild(gen.ref("obd", osc_uuid))
def node_add_profile(gen, node, ref, uuid):
- ret = node.getElementsByTagName('profile')
+ refname = "%s_ref" % "profile"
+ ret = node.getElementsByTagName(refname)
if not ret:
- error('node has no profile:', node)
- ret[0].appendChild(gen.ref(ref, uuid))
+ error('node has no profile ref:', node)
+ prof_uuid = ret[0].getAttribute('uuidref')
+ profile = lookup(node.parentNode, prof_uuid)
+ profile.appendChild(gen.ref(ref, uuid))
def get_attr(dom_node, attr, default=""):
v = dom_node.getAttribute(attr)
#
def do_add_node(gen, lustre, options, node_name):
uuid = new_uuid(node_name)
- node = gen.node(node_name, uuid)
+ prof_name = new_name("PROFILE_" + node_name)
+ prof_uuid = new_uuid(prof_name)
+ profile = gen.profile(prof_name, prof_uuid)
+ node = gen.node(node_name, uuid, prof_uuid)
+ lustre.appendChild(node)
+ lustre.appendChild(profile)
+
node_add_profile(gen, node, 'ldlm', ldlm_uuid)
- if options.has_key('router'):
+ if has_option(options, 'router'):
node.setAttribute('router', '1')
- lustre.appendChild(node)
+ if has_option(options, 'timeout'):
+ node.setAttribute('timeout', get_option(options, 'timeout'))
+ if has_option(options, 'recovery_upcall'):
+ node.setAttribute('recovery_upcall', get_option(options, 'recovery_upcall'))
return node
-def add_node(gen, lustre, options, args):
+def add_node(gen, lustre, options):
""" create a node with a network config """
- if len(args) > 1:
- usage()
-
- node_name = options['node']
+ node_name = get_option(options, 'node')
ret = findByName(lustre, node_name, "node")
if ret:
print "Node:", node_name, "exists."
do_add_node(gen, lustre, options, node_name)
-def add_net(gen, lustre, options, args):
+def add_net(gen, lustre, options):
""" create a node with a network config """
- if len(args) < 2:
- usage()
- node_name = options['node']
- nid = args[0]
- net_type = args[1]
- port = 0
- tcpbuf = 0
+ node_name = get_option(options, 'node')
+ nid = get_option(options, 'nid')
+ net_type = get_option(options, 'nettype')
if net_type == 'tcp':
- if len(args) > 2:
- port = int(args[2])
- else:
- port = DEFAULT_PORT
- if options.has_key('tcpbuf'):
- tcpbuf = int(options['tcpbuf'])
+ port = get_option_int(options, 'port', DEFAULT_PORT)
+ tcpbuf = get_option_int(options, 'tcpbuf', 0)
elif net_type in ('elan', 'gm'):
port = 0
+ tcpbuf = 0
else:
print "Unknown net_type: ", net_type
sys.exit(2)
node_add_profile(gen, node, "network", net_uuid)
-def add_route(gen, lustre, options, args):
+def add_route(gen, lustre, options):
""" create a node with a network config """
- if len(args) < 3:
- usage()
- node_name = options['node']
- net_type= args[0]
- gw = args[1]
- lo = args[2]
- hi = ''
-
- if len(args) > 3:
- hi = args[3]
+ node_name = get_option(options, 'node')
+ net_type = get_option(options, 'nettype')
+ gw = get_option(options, 'gw')
+ lo = get_option(options, 'lo')
+ hi = get_option(options, 'hi', '')
node = findByName(lustre, node_name, "node")
if not node:
netlist = node.getElementsByTagName('network')
net = netlist[0]
- rlist = net.getElementsByTagName('route_tbl')
+ rlist = net.getElementsByTagName('routetbl')
if len(rlist) > 0:
rtbl = rlist[0]
else:
- rtbl = gen.addElement(net, 'route_tbl')
+ rtbl = gen.addElement(net, 'routetbl')
rtbl.appendChild(gen.route(net_type, gw, lo, hi))
-def add_mds(gen, lustre, options, args):
- if len(args) < 1:
- usage()
-
- if options.has_key('node'):
- node_name = options['node']
- else:
- error("--mds requires a --node argument")
+def add_mds(gen, lustre, options):
+ node_name = get_option(options, 'node')
+ mds_name = get_option(options, 'mds')
+ mdd_name = new_name("MDD_" + mds_name +"_" + node_name)
+ mdd_uuid = new_uuid(mdd_name)
- mds_name = new_name(options['mds'])
- devname = args[0]
- if len(args) > 1:
- size = args[1]
- else:
- size = 0
-
- mds_uuid = new_uuid(mds_name)
+ mds_uuid = name2uuid(lustre, mds_name, fatal=0)
+ if not mds_uuid:
+ mds_uuid = new_uuid(mds_name)
+ mds = gen.mds(mds_name, mds_uuid, mdd_uuid)
+ lustre.appendChild(mds)
+
+ devname = get_option(options, 'dev')
+ size = get_option(options, 'size', 0)
+ fstype = get_option(options, 'fstype', 'extN')
- node_uuid = name2uuid(lustre, node_name)
+ node_uuid = name2uuid(lustre, node_name, 'node')
node = findByName(lustre, node_name, "node")
- node_add_profile(gen, node, "mds", mds_uuid)
+ node_add_profile(gen, node, "mdsdev", mdd_uuid)
net_uuid = get_net_uuid(lustre, node_name)
if not net_uuid:
error("NODE: ", node_name, "not found")
-
- mds = gen.mds(mds_name, mds_uuid, "extN", devname, get_format_flag(options),
- net_uuid, node_uuid, dev_size=size)
- lustre.appendChild(mds)
+ mdd = gen.mdsdev(mdd_name, mdd_uuid, fstype, devname, get_format_flag(options),
+ net_uuid, node_uuid, mds_uuid, dev_size=size)
+ lustre.appendChild(mdd)
-def add_ost(gen, lustre, options, args):
- lovname = ''
- obdtype = 'obdfilter'
- devname = ''
- size = 0
- fstype = 'extN'
-
- if options.has_key('node'):
- node_name = options['node']
- else:
- error("--ost requires a --node argument")
-
- if options.has_key('lov'):
- lovname = options['lov']
-
- if options.has_key('obdtype'):
- obdtype = options['obdtype']
+def add_ost(gen, lustre, options):
+ node_name = get_option(options, 'node')
+ lovname = get_option(options, 'lov', '')
+ obdtype = get_option(options, 'obdtype', 'obdfilter')
if obdtype == 'obdecho':
fstype = ''
+ devname = ''
+ size = 0
+ fstype = ''
else:
- if len(args) < 1:
- usage()
- devname = args[0]
- if len(args) > 1:
- size = args[1]
+ devname = get_option(options, 'dev', '') # can be unset for bluearcs
+ size = get_option(options, 'size', 0)
+ fstype = get_option(options, 'fstype', 'extN')
- obdname = new_name('OBD_'+ node_name)
- oscname = new_name('OSC_'+ node_name)
- ostname = new_name('OST_'+ node_name)
- obd_uuid = new_uuid(obdname)
+ obdname = get_option(options, 'obd', 'OBD_'+ node_name)
+ obdname = new_name(obdname)
+ ostname = new_name('OST_'+ obdname)
+ if options.has_key('obduuid'):
+ obd_uuid = options['obduuid']
+ obd = lookup(lustre, obd_uuid)
+ if obd:
+ error("Duplicate OBD UUID:", obd_uuid)
+ else:
+ obd_uuid = new_uuid(obdname)
ost_uuid = new_uuid(ostname)
- osc_uuid = new_uuid(oscname)
net_uuid = get_net_uuid(lustre, node_name)
if not net_uuid:
error("NODE: ", node_name, "not found")
- obd = gen.obd(obdname, obd_uuid, fstype, obdtype, devname, get_format_flag(options), size)
+ obd = gen.obd(obdname, obd_uuid, fstype, obdtype, devname, get_format_flag(options), ost_uuid,
+ size)
ost = gen.ost(ostname, ost_uuid, obd_uuid, net_uuid)
- osc = gen.osc(oscname, osc_uuid, obd_uuid, ost_uuid)
if lovname:
lov = findByName(lustre, lovname, "lov")
if not lov:
- error("LOV:", lovname, "not found.")
- lov_add_osc(gen, lov, osc_uuid)
+ error('add_ost:', '"'+lovname+'"', "lov element not found.")
+ lov_add_obd(gen, lov, obd_uuid)
node = findByName(lustre, node_name, "node")
node_add_profile(gen, node, 'obd', obd_uuid)
node_add_profile(gen, node, 'ost', ost_uuid)
lustre.appendChild(obd)
- lustre.appendChild(osc)
lustre.appendChild(ost)
-# this is generally only used by llecho.sh
-def add_osc(gen, lustre, options, args):
- """ add the osc to the profile for this node. """
- if len(args) < 1:
- usage()
- osc_name = args[0]
- if options.has_key('node'):
- node_name = options['node']
- else:
- error("--osc requires a --node argument")
- osc_uuid = name2uuid(lustre, osc_name)
+def add_cobd(gen, lustre, options):
+ node_name = get_option(options, 'node')
+ name = new_name('COBD_' + node_name)
+ uuid = new_uuid(name)
+
+ real_name = get_option(options, 'real_obd')
+ cache_name = get_option(options, 'cache_obd')
+
+ real_uuid = name2uuid(lustre, real_name, tag='obd')
+ cache_uuid = name2uuid(lustre, cache_name, tag='obd')
+
node = findByName(lustre, node_name, "node")
- node_add_profile(gen, node, 'osc', osc_uuid)
+ node_add_profile(gen, node, "cobd", uuid)
+ cobd = gen.cobd(name, uuid, real_uuid, cache_uuid)
+ lustre.appendChild(cobd)
+
+
+def add_echo_client(gen, lustre, options):
+ """ add an echo client to the profile for this node. """
+ node_name = get_option(options, 'node')
+ lov_name = get_option(options, 'obd')
+
+ node = findByName(lustre, node_name, 'node')
+
+ echoname = new_name('ECHO_'+ node_name)
+ echo_uuid = new_uuid(echoname)
+ node_add_profile(gen, node, 'echoclient', echo_uuid)
+
+ lov_uuid = name2uuid(lustre, lov_name, tag='lov', fatal=0)
+ if not lov_uuid:
+ lov_uuid = name2uuid(lustre, lov_name, tag='obd', fatal=1)
+ echo = gen.echo_client(echoname, echo_uuid, lov_uuid)
+ lustre.appendChild(echo)
-def add_lov(gen, lustre, options, args):
+
+def add_lov(gen, lustre, options):
""" create a lov """
- if len(args) < 4:
- usage()
-
- name = options['lov']
- mds_name = args[0]
- stripe_sz = args[1]
- stripe_off = args[2]
- pattern = args[3]
+
+ lov_orig = get_option(options, 'lov')
+ name = new_name(lov_orig)
+ if name != lov_orig:
+ warning("name:", lov_orig, "already used. using:", name)
+
+ mds_name = get_option(options, 'mds')
+ stripe_sz = get_option(options, 'stripe_sz')
+ stripe_cnt = get_option(options, 'stripe_cnt', 0)
+ pattern = get_option(options, 'stripe_pattern', 0)
uuid = new_uuid(name)
ret = findByName(lustre, name, "lov")
if ret:
error("LOV: ", name, " already exists.")
- mds_uuid = name2uuid(lustre, mds_name)
- lov = gen.lov(name, uuid, mds_uuid, stripe_sz, stripe_off, pattern)
+ mds_uuid = name2uuid(lustre, mds_name, 'mds')
+ lov = gen.lov(name, uuid, mds_uuid, stripe_sz, stripe_cnt, pattern)
lustre.appendChild(lov)
- # add an lovconfig entry to the mds profile
+ # add an lovconfig entry to the active mdsdev profile
lovconfig_name = new_name('LVCFG_' + name)
lovconfig_uuid = new_uuid(lovconfig_name)
- node = mds2node(lustre, mds_name)
- node_add_profile(gen, node, "lovconfig", lovconfig_uuid)
+ mds = findByName(lustre, mds_name)
+ mds.appendChild(gen.ref("lovconfig", lovconfig_uuid))
lovconfig = gen.lovconfig(lovconfig_name, lovconfig_uuid, uuid)
lustre.appendChild(lovconfig)
-
-def add_mtpt(gen, lustre, options, args):
+def add_mtpt(gen, lustre, options):
""" create mtpt on a node """
- if len(args) < 3:
- usage()
+ node_name = get_option(options, 'node')
- if options.has_key('node'):
- node_name = options['node']
- else:
- error("--mtpt requires a --node argument")
-
- path = args[0]
- mds_name = args[1]
- lov_name = args[2]
+ path = get_option(options, 'path')
+ mds_name = get_option(options, 'mds')
+ lov_name = get_option(options, 'lov', '')
+ if lov_name == '':
+ lov_name = get_option(options, 'obd', '')
+ if lov_name == '':
+ error("--add mtpt requires either --lov lov_name or --obd obd_name")
name = new_name('MNT_'+ node_name)
if ret:
error("MOUNTPOINT: ", name, " already exists.")
- mds_uuid = name2uuid(lustre, mds_name)
+ mds_uuid = name2uuid(lustre, mds_name, tag='mds')
lov_uuid = name2uuid(lustre, lov_name, tag='lov', fatal=0)
if not lov_uuid:
- lov_uuid = name2uuid(lustre, lov_name, tag='osc', fatal=1)
+ lov_uuid = name2uuid(lustre, lov_name, tag='obd', fatal=1)
uuid = new_uuid(name)
mtpt = gen.mountpoint(name, uuid, mds_uuid, lov_uuid, path)
node_add_profile(gen, node, "mountpoint", uuid)
lustre.appendChild(mtpt)
+def add_oscref(gen, lustre, options):
+ """ create mtpt on a node """
+ node_name = get_option(options, 'node')
+ osc_name = get_option(options, 'osc')
+
+ osc_uuid = name2uuid(lustre, osc_name, tag='osc')
+ node = findByName(lustre, node_name, "node")
+ if not node:
+ error('node:', node_name, "not found")
+ node_add_profile(gen, node, "osc",osc_uuid)
############################################################
# Command line processing
#
+class OptionError (exceptions.Exception):
+ def __init__(self, args):
+ self.args = args
+
+def has_option(options, tag):
+ """Look for tag in options hash and return the true if set"""
+ if options.has_key(tag):
+ return 1
+ return 0
+
+def get_option(options, tag, default = None):
+ """Look for tag in options hash and return the value if set. If not
+ set, then if return default it is set, otherwise exception."""
+ if options.has_key(tag):
+ return options[tag]
+ elif default != None:
+ return default
+ else:
+ raise OptionError("--add %s requires --%s value" % (options['add'], tag))
+ # this exception should print an error like '--add blah requires --<tag> value'
+
+def get_option_int(options, tag, default = None):
+ """Return an integer option. Raise exception if the value is not an int"""
+ val = get_option(options, tag, default)
+ return int(val)
+
def parse_cmdline(argv):
short_opts = "ho:i:m:"
- long_opts = ["ost", "osc", "mtpt", "lov=", "node=", "mds=", "net", "tcpbuf=",
- "route", "router", "merge=", "format", "reformat", "output=",
- "obdtype=", "in=", "help"]
+ long_opts = ["add=", "node=", "nettype=", "nid=", "tcpbuf=", "port=",
+ "echo_client=", "stripe_sz=", "stripe_cnt=", "stripe_pattern=",
+ "mds=", "route", "router", "merge=", "format", "reformat", "output=",
+ "dev=", "size=", "obd=", "obdtype=", "obduuid=", "in=",
+ "path=", "help", "batch=", "lov=", "gw=", "lo=", "hi=",
+ "oscref", "osc=", "real_obd=", "cache_obd=", "fstype=",
+ "timeout=", "recovery_upcall="]
opts = []
args = []
options = {}
try:
opts, args = getopt.getopt(argv, short_opts, long_opts)
- except getopt.error:
- print "invalid opt"
- usage()
+ except getopt.error, e:
+ panic(string.join(sys.argv), e)
for o, a in opts:
- if o in ("-h", "--help"):
- usage()
- if o in ("-o", "--output"):
- options['output'] = a
- if o == "--ost":
- options['ost'] = 1
- if o == "--osc":
- options['osc'] = 1
+ # Commands to create new devices
+ if o == "--add":
+ options['add'] = a
+
+ if o == "--node":
+ options['node'] = a
+
+ # devices names
+ if o == "--lov":
+ options['lov'] = a
if o == "--mds":
options['mds'] = a
+ if o == "--obd":
+ options['obd'] = a
+
+ # node options
+ if o == "--timeout":
+ options['timeout'] = a
+ if o == "--recovery_upcall":
+ options['recovery_upcall'] = a
+ if o == "--router":
+ options['router'] = 1
+
+ # network options
+ if o == "--nid":
+ options['nid'] = a
+ if o == "--nettype":
+ options['nettype'] = a
if o == "--net":
- options['net'] = 1
+ options[''] = a
+ if o == "--tcpbuf":
+ options['tcpbuf'] = a
+ if o == "--port":
+ options['port'] = a
if o == "--mtpt":
options['mtpt'] = 1
- if o == "--node":
- options['node'] = a
if o == "--route":
options['route'] = 1
- if o == "--router":
- options['router'] = 1
- if o == "--lov":
- options['lov'] = a
- if o in ("-m", "--merge"):
- options['merge'] = a
+
+ # ost options
+ if o == "--dev":
+ options['dev'] = a
+ if o == "--size":
+ options['size'] = a
+ if o == "--path":
+ options['path'] = a
+ if o == "--osc":
+ options['osc'] = a
if o == "--obdtype":
options['obdtype'] = a
- if o == "--tcpbuf":
- options['tcpbuf'] = a
+ if o == "--fstype":
+ options['fstype'] = a
+ if o == "--obduuid":
+ options['obduuid'] = a
+
+ # lov options
+ if o == "--stripe_sz":
+ options['stripe_sz'] = a
+ if o == "--stripe_cnt":
+ options['stripe_cnt'] = a
+ if o == "--stripe_pattern":
+ options['stripe_pattern'] = a
+ if o == "--gw":
+ options['gw'] = a
+ if o == "--lo":
+ options['lo'] = a
+ if o == "--hi":
+ options['hi'] = a
+
+ # cobd
+ if o == "--cache_obd":
+ options['cache_obd'] = a
+ if o == "--real_obd":
+ options['real_obd'] = a
+
+ # lmc options
+ if o in ("-h", "--help"):
+ usage()
+ if o in ("-o", "--output"):
+ options['output'] = a
+ if o in ("-m", "--merge"):
+ options['merge'] = a
if o == "--format":
options['format'] = 1
if o == "--reformat":
options['reformat'] = 1
+ if o == "--batch":
+ options['batch'] = a
if o in ("--in" , "-i"):
options['in'] = a
str = '%s: %g secs' % (msg, d)
print str
+
+
############################################################
# Main
#
+
+def add(devtype, gen, lustre, options):
+ if devtype == 'net':
+ add_net(gen, lustre, options)
+ elif devtype =='osc':
+ add_osc(gen, lustre, options)
+ elif devtype == 'mtpt':
+ add_mtpt(gen, lustre, options)
+ elif devtype == 'mds':
+ add_mds(gen, lustre, options)
+ elif devtype == 'ost':
+ add_ost(gen, lustre, options)
+ elif devtype == 'lov':
+ add_lov(gen, lustre, options)
+ elif devtype == 'route':
+ add_route(gen, lustre, options)
+ elif devtype == 'node':
+ add_node(gen, lustre, options)
+ elif devtype == 'echo_client':
+ add_echo_client(gen, lustre, options)
+ elif devtype == 'oscref':
+ add_oscref(gen, lustre, options)
+ elif devtype == 'cobd':
+ add_cobd(gen, lustre, options)
+ else:
+ error("unknown device type:", devtype)
+
+def do_command(gen, lustre, options, args):
+ if options.has_key('add'):
+ add(options['add'], gen, lustre, options)
+ else:
+ error("Missing command")
+
def main():
options, args = parse_cmdline(sys.argv[1:])
outFile = '-'
sys.exit(1)
gen = GenConfig(doc)
- if options.has_key('ost'):
- add_ost(gen, lustre, options, args)
- elif options.has_key('osc'):
- add_osc(gen, lustre, options, args)
- elif options.has_key('mtpt'):
- add_mtpt(gen, lustre, options, args)
- elif options.has_key('mds'):
- add_mds(gen, lustre, options, args)
- elif options.has_key('net'):
- add_net(gen, lustre, options, args)
- elif options.has_key('lov'):
- add_lov(gen, lustre, options, args)
- elif options.has_key('route'):
- add_route(gen, lustre, options, args)
- elif options.has_key('node'):
- add_node(gen, lustre, options, args)
+
+ if options.has_key('batch'):
+ fp = open(options['batch'])
+ batchCommands = fp.readlines()
+ fp.close()
+ for cmd in batchCommands:
+ options, args = parse_cmdline(string.split(cmd))
+ try:
+ do_command(gen, lustre, options, args)
+ except OptionError, e:
+ panic(cmd, e)
else:
- print "Missing command"
- usage()
+ try:
+ do_command(gen, lustre, options, args)
+ except OptionError, e:
+ panic(string.join(sys.argv),e)
if outFile == '-':
PrettyPrint(doc)
if __name__ == "__main__":
main()
-
-