From 46678deac9977f6dc9134bcdca0e06bdece2e01a Mon Sep 17 00:00:00 2001 From: sravi Date: Wed, 18 Dec 2002 12:17:02 +0000 Subject: [PATCH] This is library file for LDAP related routines and using by lmc --- lustre/utils/lustreLdap.py | 1799 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1799 insertions(+) create mode 100755 lustre/utils/lustreLdap.py diff --git a/lustre/utils/lustreLdap.py b/lustre/utils/lustreLdap.py new file mode 100755 index 0000000..b3438d7 --- /dev/null +++ b/lustre/utils/lustreLdap.py @@ -0,0 +1,1799 @@ +#!/usr/bin/env python +# +# Author: Ravindranadh Chowdary Sahukara +# This file is part of Lustre, http://www.lustre.org. +# +# Lustre is free software; you can redistribute it and/or +# modify it under the terms of version 2 of the GNU General Public +# License as published by the Free Software Foundation. +# +# Lustre is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Lustre; if not, write to the Free Software +# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +# +# lconf - lustre configuration tool +# +# lconf is the main driver script for starting and stopping +# lustre filesystem services. +# +# Based in part on the XML obdctl modifications done by Brian Behlendorf + +from types import DictType, ListType, TupleType, StringType +import string, os, stat, popen2, socket, time, random +import sys, getopt +import re, exceptions +import xml.dom.minidom +from sys import exit +from string import split,join + + +# Global parameters +DEFAULT_TCPBUF = 0 + + +def panic(*args): + msg = string.join(map(str,args)) + print "! " + msg + exit(1) + +def debug(*args): + msg = string.join(map(str,args)) + print msg + + +names = {} +uuids = {} + + +def new_name(bas): + ctr = 2 + ret = bas + while names.has_key(ret): + ret = "%s_%d" % (bas, ctr) + ctr = 1 + ctr + names[ret] = 1 + return str(ret) + +def new_uuid(name): + return "%s_UUID" % (name) + + +def getServices(lustreNode, profileNode): + list = [] + for n in profileNode.childNodes: + if n.nodeType == n.ELEMENT_NODE: + servNode = lookup(lustreNode, getRef(n)) + if not servNode: + print n + panic('service not found: ' + getRef(n)) + list.append((servNode)) + #list.sort() + return list + +def getByName(lustreNode, name, tag): + ndList = lustreNode.getElementsByTagName(tag) + for nd in ndList: + if getName(nd) == name: + return nd + return None + + + +class Module: + """ Base class for the rest of the modules. """ + def __init__(self, module_name, dom_node): + self.dom_node = dom_node + self.module_name = module_name + self.name = get_attr(dom_node, 'name') + self.uuid = get_attr(dom_node, 'uuid') + self.kmodule_list = [] + self._server = None + self._connected = 0 + + def info(self, *args): + msg = string.join(map(str,args)) + print self.module_name + ":", self.name, self.uuid, msg + + + def lookup_server(self, srv_uuid): + """ Lookup a servers network information """ + net = get_ost_net(self.dom_node.parentNode, srv_uuid) + if not net: + panic ("Unable to find a server for:", srv_uuid) + self._server = Network(net) + + def get_server(self): + return self._server + + +class Network(Module): + def __init__(self,dom_node): + Module.__init__(self, 'NETWORK', dom_node) + self.net_type = get_attr(dom_node,'type') + self.nid = get_text(dom_node, 'server', '*') + self.port = get_text_int(dom_node, 'port', 0) + self.send_mem = get_text_int(dom_node, 'send_mem', DEFAULT_TCPBUF) + self.recv_mem = get_text_int(dom_node, 'recv_mem', DEFAULT_TCPBUF) + if '*' in self.nid: + self.nid = get_local_address(self.net_type, self.nid) + if not self.nid: + panic("unable to set nid for", self.net_type, self.nid) + debug("nid:", self.nid) + + +class LDLM(Module): + def __init__(self,dom_node): + Module.__init__(self, 'LDLM', dom_node) + +class LOV(Module): + def __init__(self,dom_node): + Module.__init__(self, 'LOV', dom_node) + self.mds_uuid = get_first_ref(dom_node, 'mds') + mds= lookup(dom_node.parentNode, self.mds_uuid) + self.mds_name = getName(mds) + devs = dom_node.getElementsByTagName('devices') + if len(devs) > 0: + dev_node = devs[0] + self.stripe_sz = get_attr_int(dev_node, 'stripesize', 65536) + self.stripe_off = get_attr_int(dev_node, 'stripeoffset', 0) + self.pattern = get_attr_int(dev_node, 'pattern', 0) + self.devlist = get_all_refs(dev_node, 'osc') + self.stripe_cnt = get_attr_int(dev_node, 'stripecount', len(self.devlist)) + +class LOVConfig(Module): + def __init__(self,dom_node): + Module.__init__(self, 'LOVConfig', dom_node) + self.lov_uuid = get_first_ref(dom_node, 'lov') + l = lookup(dom_node.parentNode, self.lov_uuid) + self.lov = LOV(l) + + +class MDS(Module): + def __init__(self,dom_node): + Module.__init__(self, 'MDS', dom_node) + self.devname, self.size = get_device(dom_node) + self.fstype = get_text(dom_node, 'fstype') + # FIXME: if fstype not set, then determine based on kernel version + self.format = get_text(dom_node, 'autoformat', "no") + self.lookup_server(self.uuid) + +# Very unusual case, as there is no MDC element in the XML anymore +# Builds itself from an MDS node +class OBD(Module): + def __init__(self, dom_node): + Module.__init__(self, 'OBD', dom_node) + self.obdtype = get_attr(dom_node, 'type') + self.devname, self.size = get_device(dom_node) + self.fstype = get_text(dom_node, 'fstype') + # FIXME: if fstype not set, then determine based on kernel version + self.format = get_text(dom_node, 'autoformat', 'yes') + +class OST(Module): + def __init__(self,dom_node): + Module.__init__(self, 'OST', dom_node) + self.obd_uuid = get_first_ref(dom_node, 'obd') + + +# virtual interface for OSC and LOV +class VOSC(Module): + def __init__(self,dom_node): + Module.__init__(self, 'VOSC', dom_node) + if dom_node.nodeName == 'lov': + self.osc = LOV(dom_node) + else: + self.osc = OSC(dom_node) + +class OSC(Module): + def __init__(self,dom_node): + Module.__init__(self, 'OSC', dom_node) + self.obd_uuid = get_first_ref(dom_node, 'obd') + self.ost_uuid = get_first_ref(dom_node, 'ost') + self.lookup_server(self.ost_uuid) + +class Mountpoint(Module): + def __init__(self,dom_node): + Module.__init__(self, 'MTPT', dom_node) + self.path = get_text(dom_node, 'path') + self.mds_uuid = get_first_ref(dom_node, 'mds') + self.lov_uuid = get_first_ref(dom_node, 'osc') + l = lookup(self.dom_node.parentNode, self.lov_uuid) + self.osc = VOSC(l) + +# ============================================================ + +def get_device(obd): + list = obd.getElementsByTagName('device') + if len(list) > 0: + dev = list[0] + dev.normalize(); + size = get_attr_int(dev, 'size', 0) + return str(dev.firstChild.data), str(size) + return '', 0 + +# Get the text content from the first matching child +# If there is no content (or it is all whitespace), return +# the default +def get_text(dom_node, tag, default=""): + list = dom_node.getElementsByTagName(tag) + if len(list) > 0: + dom_node = list[0] + dom_node.normalize() + if dom_node.firstChild: + txt = string.strip(dom_node.firstChild.data) + if txt: + return txt + return default + +def get_text_int(dom_node, tag, default=0): + list = dom_node.getElementsByTagName(tag) + n = default + if len(list) > 0: + dom_node = list[0] + dom_node.normalize() + if dom_node.firstChild: + txt = string.strip(dom_node.firstChild.data) + if txt: + try: + n = int(txt) + except ValueError: + panic("text value is not integer:", txt) + return n + +def get_attr(dom_node, attr, default=""): + v = dom_node.getAttribute(attr) + if v: + return str(v) + return str(default) + +def get_attr_int(dom_node, attr, default=0): + n = default + v = dom_node.getAttribute(attr) + if v: + try: + n = int(v) + except ValueError: + panic("attr value is not integer", v) + return n + +def get_first_ref(dom_node, tag): + """ Get the first uuidref of the type TAG. Used one only + one is expected. Returns the uuid.""" + uuid = None + refname = '%s_ref' % tag + list = dom_node.getElementsByTagName(refname) + if len(list) > 0: + uuid = getRef(list[0]) + return uuid + +def get_all_refs(dom_node, tag): + """ Get all the refs of type TAG. Returns list of uuids. """ + uuids = [] + refname = '%s_ref' % tag + list = dom_node.getElementsByTagName(refname) + if len(list) > 0: + for i in list: + uuids.append(getRef(i)) + return uuids + +def get_ost_net(dom_node, uuid): + ost = lookup(dom_node, uuid) + uuid = get_first_ref(ost, 'network') + if not uuid: + return None + return lookup(dom_node, uuid) + +def lookup(dom_node, uuid): + for n in dom_node.childNodes: + if n.nodeType == n.ELEMENT_NODE: + if getUUID(n) == uuid: + return n + else: + n = lookup(n, uuid) + if n: return n + return None + +# Get name attribute of dom_node +def getName(dom_node): + return str(dom_node.getAttribute('name')) + +def getRef(dom_node): + return dom_node.getAttribute('uuidref') + +# Get name attribute of dom_node +def getUUID(dom_node): + return str(dom_node.getAttribute('uuid')) + +# the tag name is the service type +def getServiceType(dom_node): + return dom_node.nodeName + + + +############################################################################## +# LDAP related stuff tarts here... + +import ldap +import _ldap + +#returns the lustre ldap specific filters + +class lustre_ldap: + def __init__(self): + self.filter=0 + + def get_filter(self,lustreRdn): + filter="(&"+lustreRdn+")" + return filter + +# make a connection to LDAP server and abd bind +class MyConn: + def __init__(self,host,port): + self.id = 0 + self.host = host + self.port = port + self.base = "fs=lustre" + + def open(self): + self.id = ldap.open(self.host) + if self.id == None: + print "unable to open a connection" + + try: + # lustre tree starts from here...the DN is (cn=Manager ,fs=lustre) + status = self.id.simple_bind("cn=Manager, fs=lustre","secret") + except _ldap.LDAPError: + print "unable to bind" + + + +# Lustre Node object class definition as per defined in the lustre.schema + +class LustreNode: + def __init__(self, nodename): + self.objectClass = "lustreNode" + self.nodeUUID = 0 + self.id = nodename + self.netUUIDs = [] + self.profileUUID = 0 + self.routerUUID = 0 + self.ldlmUUID = 0 + + self.lustreNet = {} + self.lustreNodeProfile = 0 + self.lustreLdlm = 0 + + self.nodeUUID_str = "nodeUUID" + self.id_str = "id" + self.netUUIDs_str = "netUUIDs" + self.ldlmUUID_str = "ldlmUUID" + self.profileUUID_str = "profileUUID" + self.routerUUID_str = "routerUUID" + self.node_str = "node" + + def get_object_class(self): + return self.objectClass + + def get_rdn(self): + retval = "(objectClass="+self.objectClass+") (id="+self.id+")" + return retval + + # Initilize lustre Node Object class after read drom LDAP server + def init_node(self, node_entry): + self.id = node_entry[0][1][self.id_str][0] + self.nodeUUID = node_entry[0][1][self.nodeUUID_str][0] + for i in range(len(node_entry[0][1][self.netUUIDs_str])): + self.netUUIDs.append(node_entry[0][1][self.netUUIDs_str][i]) + if node_entry[0][1].has_key(self.profileUUID_str): + self.profileUUID = node_entry[0][1][self.profileUUID_str][0] + if node_entry[0][1].has_key(self.ldlmUUID_str): + self.ldlmUUID = node_entry[0][1][self.ldlmUUID_str][0] + + if node_entry[0][1].has_key(self.routerUUID_str): + self.routerUUID = node_entry[0][1][self.routerUUID_str][0] + + # Brings the lustre Node object entries from LDAP server + def getEntry_from_ldap(self, conn_id, base): + try: + lustre_util = lustre_ldap() + # the filter has id=,type=node,fs=lustre + # base is "fs=lustre" + filter = lustre_util.get_filter(self.get_rdn()) + result = conn_id.search_s(base, ldap.SCOPE_SUBTREE, filter) + if result == []: + print "Error No Results found" + sys.exit(1) + self.init_node(result) + #network object class + if self.netUUIDs: + for netuuid in self.netUUIDs: + # loading the network object class from LDAP, since this related to lustre node class + self.lustreNet[netuuid] = LustreNet() + self.lustreNet[netuuid].getEntry_from_ldap(conn_id, base, netuuid) + + # The ldlm object class + if self.ldlmUUID: + # loading the ldlm object class from LDAP, since this related to lustre node class + self.lustreLdlm = LustreLdlm() + self.lustreLdlm.getEntry_from_ldap(conn_id, base, self.ldlmUUID) + + # The lustre node profile object class + if self.profileUUID: + # loading the node profile object class from LDAP, since this related to lustre node class + # The node profile contains the clientUUID, mdsUUIDs (multiple) and ostUUIDs(multiple) + # the rest of the object class queried from LDAP server useing above UUIDs + self.lustreNodeProfile = LustreNodeProfile() + self.lustreNodeProfile.getEntry_from_ldap(conn_id, base, self.profileUUID) + + except ldap.NO_SUCH_OBJECT: + print "no results Found" + exit(1) + + def get_dn(self,id): + return self.id_str+"="+id+",type="+self.node_str+",fs=lustre" + + # add entries into LDAP server, All of them are must fields + def addEntry_into_ldap(self, conn_id, id, nodeUUID, netUUIDs, profileUUID, routerUUID, ldlmUUID): + modlist = [] + dn = self.get_dn(self.id) + modlist.append(("objectClass", [self.objectClass])) + modlist.append((self.id_str, id)) + modlist.append((self.nodeUUID_str, nodeUUID)) + modlist.append((self.netUUIDs_str, netUUIDs)) + modlist.append((self.profileUUID_str, profileUUID)) + modlist.append((self.routerUUID_str, routerUUID)) + modlist.append((self.ldlmUUID_str, ldlmUUID)) + modlist.append(("fs", ["lustre"])) + status = 0 + try: + conn_id.add_s(dn,modlist) + except _ldap.LDAPError: + print "not added" + return status + + def initobj(self,*args): + print "init obj :", args + # print values of object class + def print_node(self): + print "lustre Node Attributes......" + print "objectClass: %s" % self.objectClass + print "node UUID: %s" % self.nodeUUID + print "node name: %s" % self.id + for i in range(len(self.netUUIDs)): + print "network UUID%d: %s" % (i,self.netUUIDs[i]) + print "Node Profile UUID: %s" % self.profileUUID + print "Router UUID: %s" % self.routerUUID + print "Ldlm UUID: %s" % self.ldlmUUID + print + for i in range(len(self.netUUIDs)): + self.lustreNet[i].print_net() + + self.lustreNodeProfile.print_profile() + self.lustreLdlm.print_ldlm() + + + +# lustre Client object class It have mount uuid and net uuid, but the net uuid may not required at present. +class LustreClient: + def __init__(self,lustreNode): + self.objectClass = "lustreClient" + self.clientUUID = 0 + self.mountUUIDs = [] + self.netUUID = 0 + + self.lustreNode = lustreNode + self.lustreNet = 0 + self.lustreMount = {} + + + self.clientUUID_attr = "clientUUID" + self.mountUUID_attr = "mountUUIDs" + self.netUUID_attr = "netUUID" + self.client_attr = "client" + + def ge_object_class(self): + return self.objectClass + + def get_rdn(self,attr_value): + retval = "(objectClass="+self.objectClass+") (clientUUID="+attr_value+")" + return retval + + + # load the object class with client config params + def init_node(self,node_entry): + self.clientUUID = node_entry[0][1][self.clientUUID_attr][0] + for i in range(len(node_entry[0][1][self.mountUUID_attr])): + self.mountUUIDs.append(node_entry[0][1][self.mountUUID_attr][i]) + self.netUUID = node_entry[0][1][self.netUUID_attr][0] + + + # brings the client config params from LDAP, here the search criteria is clientUUID=lustre1_client_UUID,type=client,fs=lustre, this is called as dn + def getEntry_from_ldap(self,conn_id,base,attr_val): + lustre_util = lustre_ldap() + # filter has "clientUUID=lustre1_client_UUID,type=client,fs=lustre" + # the base is "fs=lustre" + filter = lustre_util.get_filter(self.get_rdn(attr_val)) + result = conn_id.search_s(base, ldap.SCOPE_SUBTREE, filter) + if result == []: + print "Client Error No Results found" + sys.exit(1) + + self.init_node(result) + + if self.netUUID: + self.lustreNet = LustreNet() + self.lustreNet.getEntry_from_ldap(conn_id, base, self.netUUID) + else: + print "Unable to find the LDLM uuid in Client Object Class..." + + if self.mountUUIDs: + for mntuuid in self.mountUUIDs: + self.lustreMount[mntuuid] = LustreMount() + self.lustreMount[mntuuid].getEntry_from_ldap(conn_id, base, mntuuid) + + + def get_dn(self, uuid): + retval = self.clientUUID_attr+"="+uuid+",type="+self.client_attr+",fs=lustre" + return retval + + def addEntry_into_ldap(self,conn_id, clientUUID, mountUUIDs, netUUID): + modlist = [] + dn = self.get_dn(clientUUID) + modlist.append(("objectClass", [self.objectClass])) + modlist.append((self.clientUUID_attr, clientUUID)) + modlist.append((self.mountUUID_attr, mountUUIDs)) + modlist.append((self.netUUID_attr, netUUID[0])) + modlist.append(("fs", ["lustre"])) + status = 0 + try: + conn_id.add_s(dn, modlist) + except _ldap.LDAPError: + print "not added" + sys.exit(1) + return status + + def initobj(self,*args): + print "init obj :", args + + def print_client(self): + print "Lustre Client Configurations..............." + print "client Object Calss: %s" % self.objectClass + print "client UUID: %s" % self.clientUUID + print "This client supporting %d file systems" % len(self.mountUUIDs) + if self.lustreNet: + self.lustreNet.print_net() + + if self.mountUUIDs: + for mntuuid in self.mountUUIDs: + self.lustreMount[mntuuid].print_mount() + + + + +class LustreMount: + def __init__(self): + self.objectClass = "lustreMount" + self.mountUUID = 0 + self.mdsUUID = 0 + self.lovUUID = 0 + self.mountPath = "" + self.default = 0 + + self.lustreMds = 0 + self.lustreLov = 0 + + self.mountUUID_attr = "mountUUID" + self.mdsUUID_attr = "mdsUUID" + self.lovUUID_attr = "lovUUID" + self.mountPath_attr = "mountPath" + self.default_attr = "default" + self.type = "mountPoint" + + + def get_object_class(self): + return self.objectCalss + + def get_rdn(self, attr_value): + retval = "(objectClass="+self.objectClass+") (mountUUID="+attr_value+")" + return retval + + + def init_node(self, record): + self.mdsUUID = record[0][1][self.mdsUUID_attr][0] + self.mountUUID = record[0][1][self.mountUUID_attr][0] + self.lovUUID = record[0][1][self.lovUUID_attr][0] + self.mountPath = record[0][1][self.mountPath_attr][0] + self.default = record[0][1][self.default_attr][0] + + def getEntry_from_ldap(self, conn_id, base, attr_val): + lustre_util = lustre_ldap() + filter = lustre_util.get_filter(self.get_rdn(attr_val)) + result = conn_id.search_s(base, ldap.SCOPE_SUBTREE, filter) + if result == []: + print "Mount Error No Results found" + sys.exit(1) + self.init_node(result) + + if self.mdsUUID: + self.lustreMds = LustreMds() + self.lustreMds.getEntry_from_ldap(conn_id, base, self.mdsUUID) + + if self.lovUUID: + self.lustreLov = LustreLov() + self.lustreLov.getEntry_from_ldap(conn_id, base, self.lovUUID) + + def get_dn(self, uuid): + retval = self.mountUUID_attr+"="+uuid+",type="+self.type+",fs=lustre" + return retval + + def addEntry_into_ldap(self, conn_id, mountUUID, mdsUUID, lovUUID, mountPath, default = 0): + modlist = [] + dn=self.get_dn(mountUUID) + modlist.append(("objectClass", [self.objectClass])) + modlist.append((self.mountUUID_attr, mountUUID)) + modlist.append((self.mdsUUID_attr, mdsUUID)) + modlist.append((self.lovUUID_attr, lovUUID)) + modlist.append((self.mountPath_attr, mountPath)) + modlist.append((self.default_attr, default)) + modlist.append(("fs", ["lustre"])) + status = 0 + try: + conn_id.add_s(dn,modlist) + except _ldap.LDAPError: + print "not added" + sys.exit(1) + return status + + def initobj(self,*args): + print "init obj :", args + + def print_mount(self): + + print "Lustre mount point attributes......" + print "mount object class: %s" % self.objectClass + print "mount UUID: %s" % self.mountUUID + print "mds UUID: %s" % self.mdsUUID + print "lov UUID: %s" % self.lovUUID + print "mount point: %s" % self.mountPath + if self.default: + print "This file system is default file system for this cleint" + else: + print "This file system is not a default file system for this cleint" + + if self.lustreMds: + self.lustreMds.print_mds() + if self.lustreLov: + self.lustreLov.print_lov() + + +class LustreOsc: + def __init__(self): + self.objectClass = "lustreOSC" + self.oscUUID = 0 + self.devName = "" + self.obdUUID = 0 + self.ostUUID = 0 + + self.lustreObd = 0 + self.lustreOst = 0 + + self.oscUUID_attr = "oscUUID" + self.devName_attr = "devName" + self.obdUUID_attr = "obdUUID" + self.ostUUID_attr = "ostUUID" + self.type = "OSC" + + def get_object_class(self): + return self.objectCalss + + def get_rdn(self, attr_value): + retval = "(objectClass="+self.objectClass+") (oscUUID="+attr_value+")" + return retval + + + def init_node(self, record): + self.oscUUID=record[0][1][self.oscUUID_attr][0] + self.obdUUID=record[0][1][self.obdUUID_attr][0] + self.ostUUID=record[0][1][self.ostUUID_attr][0] + self.devName=record[0][1][self.devName_attr][0] + + + def getEntry_from_ldap(self, conn_id, base, attr_val): + lustre_util = lustre_ldap() + filter = lustre_util.get_filter(self.get_rdn(attr_val)) + result = conn_id.search_s(base, ldap.SCOPE_SUBTREE, filter) + if result == []: + print "Error No Results found" + sys.exit(1) + self.init_node(result) + + if self.obdUUID: + self.lustreObd = LustreObd() + self.lustreObd.getEntry_from_ldap(conn_id, base, self.obdUUID) + + if self.ostUUID: + self.lustreOst = LustreOst() + self.lustreOst.getEntry_from_ldap(conn_id, base, self.ostUUID) + + def get_dn(self, uuid): + retval = self.oscUUID_attr+"="+uuid+",type="+self.type+",fs=lustre" + return retval + + def addEntry_into_ldap(self, conn_id, oscUUID, devName, obdUUID, ostUUID): + modlist = [] + dn=self.get_dn(oscUUID) + modlist.append(("objectClass", [self.objectClass])) + modlist.append((self.oscUUID_attr, oscUUID)) + modlist.append((self.devName_attr, devName)) + modlist.append((self.obdUUID_attr, obdUUID)) + modlist.append((self.ostUUID_attr, ostUUID)) + modlist.append(("fs", ["lustre"])) + status = 0 + try: + conn_id.add_s(dn,modlist) + except _ldap.LDAPError: + print "not added" + sys.exit(1) + return status + + def initobj(self,*args): + print "init obj :", args + + def print_osc(self): + print "Lustre Osc Attrributes.." + print "object class: %s" % self.objectClass + print "oscUUID: %s" % self.oscUUID + print "devName: %s" % self.devName + print "obdUUID: %s" % self.obdUUID + print "ostUUID: %s" % self.ostUUID + print + if self.lustreObd: + self.lustreObd.print_obd() + print + if self.lustreOst: + self.lustreOst.print_ost() + print + + +class LustreMdc: + def __init__(self): + self.objectClass="lustreMDC" + self.mdcUUID=0 + self.devName="" + self.mdsUUID=0 + + self.lustreMds=0 + + self.mdcUUID_attr="mdcUUID" + self.devName_attr="devName" + self.mdsUUID_attr="mdsUUID" + self.type="MDC" + + def get_object_class(self): + return self.objectCalss + + def get_rdn(self,attr_value): + retval="(objectClass="+self.objectClass+") (mdcUUID="+attr_value+")" + return retval + + + def init_node(self,record): + self.mdcUUID=record[0][1][self.mdcUUID_attr][0] + self.mdsUUID=record[0][1][self.mdsUUID_attr][0] + self.devName=record[0][1][self.devName_attr][0] + + def getEntry_from_ldap(self,conn_id,base,attr_val): + lustre_util=lustre_ldap() + filter=lustre_util.get_filter(self.get_rdn(attr_val)) + result=conn_id.search_s(base,ldap.SCOPE_SUBTREE,filter) + if result == []: + print "Error No Results found" + sys.exit(1) + self.init_node(result) + + if self.mdsUUID: + self.lustreMds=LustreMds() + self.lustreMds.getEntry_from_ldap(conn_id,base,self.mdsUUID) + + + def get_dn(self,uuid): + retval=self.mdcUUID_attr+"="+uuid+",type="+self.type+",fs=lustre" + return retval + + def addEntry_into_ldap(self,conn_id): + modlist=[] + dn=self.get_dn(self.mdcUUID) + modlist.append(("objectClass",[self.objectClass])) + modlist.append((self.mdcUUID_attr,[self.mdcUUID])) + modlist.append((self.devName_attr,self.devName)) + modlist.append((self.mdsUUID_attr,[self.mdsUUID])) + modlist.append(("fs",["lustre"])) + status=0 + try: + conn_id.add_s(dn,modlist) + except _ldap.LDAPError: + print "not added" + sys.exit(1) + return status + + def initobj(self,*args): + print "init obj :", args + + def print_mdc(self): + print "Lustre Mdc attributes....." + print "Mdc UUID: %s" % self.mdcUUID + print "dev name: %s" % self.devName + print "Mds UUId: %s" % self.mdsUUID + print + if self.lustreMds: + self.lustreMds.print_mds() + + + +class LustreOst: + def __init__(self): + self.objectClass = "lustreOST" + self.ostUUID = 0 + self.devName = "" + self.obdUUID = 0 + + self.lustreObd = 0 + + self.ostUUID_attr = "ostUUID" + self.devName_attr = "devName" + self.obdUUID_attr = "obdUUID" + self.type = "OST" + + def get_object_class(self): + return self.objectCalss + + def get_rdn(self,attr_value): + retval = "(objectClass="+self.objectClass+") (ostUUID="+attr_value+")" + return retval + + def init_node(self, record): + self.ostUUID = record[0][1][self.ostUUID_attr][0] + self.obdUUID = record[0][1][self.obdUUID_attr][0] + self.devName = record[0][1][self.devName_attr][0] + + def getEntry_from_ldap(self, conn_id, base, attr_val): + lustre_util = lustre_ldap() + filter = lustre_util.get_filter(self.get_rdn(attr_val)) + result = conn_id.search_s(base, ldap.SCOPE_SUBTREE, filter) + if result == []: + print "Error No Results found" + sys.exit(1) + self.init_node(result) + + if self.obdUUID: + self.lustreObd = LustreObd() + self.lustreObd.getEntry_from_ldap(conn_id, base, self.obdUUID) + + + def get_dn(self,uuid): + retval = self.ostUUID_attr+"="+uuid+",type="+self.type+",fs=lustre" + return retval + + def addEntry_into_ldap(self, conn_id, ostUUID, devName, obdUUID): + modlist = [] + dn=self.get_dn(ostUUID) + modlist.append(("objectClass", [self.objectClass])) + modlist.append((self.ostUUID_attr, ostUUID)) + modlist.append((self.devName_attr, devName)) + modlist.append((self.obdUUID_attr, obdUUID)) + modlist.append(("fs", ["lustre"])) + status=0 + try: + conn_id.add_s(dn, modlist) + except _ldap.LDAPError: + print "not added" + sys.exit(1) + return status + + def initobj(self,*args): + print "init obj :", args + + def print_ost(self): + print "Lustre Ost Attributes...." + print "object class: %s" % self.objectClass + print "ostUUID: %s" % self.ostUUID + print "devName: %s" % self.devName + print "obdUUID: %s" % self.obdUUID + print + if self.lustreObd: + self.lustreObd.print_obd() + + + +class LustreMds: + def __init__(self): + self.objectClass = "lustreMDS" + self.mdsUUID = 0 + self.devName = "" + self.devUUID = 0 + self.lovUUID = 0 + self.fUUID = 0 + + self.lustreDev = 0 + self.lustreLov = 0 + + self.mdsUUID_attr = "mdsUUID" + self.devName_attr = "devName" + self.devUUID_attr = "devUUID" + self.lovUUID_attr = "lovUUID" + self.fUUID_attr = "fUUID" + self.type = "MDS" + + def get_object_class(self): + return self.objectCalss + + def get_rdn(self, attr_value): + retval = "(objectClass="+self.objectClass+") (mdsUUID="+attr_value+")" + return retval + + + def init_node(self,record): + self.mdsUUID = record[0][1][self.mdsUUID_attr][0] + self.devUUID = record[0][1][self.devUUID_attr][0] + self.lovUUID = record[0][1][self.lovUUID_attr][0] + #self.fUUID = record[0][1][self.fUUID_attr][0] + self.devName = record[0][1][self.devName_attr][0] + + def getEntry_from_ldap(self, conn_id, base, attr_val): + lustre_util = lustre_ldap() + filter = lustre_util.get_filter(self.get_rdn(attr_val)) + result = conn_id.search_s(base, ldap.SCOPE_SUBTREE, filter) + if result == []: + print "Error No Results found" + sys.exit(1) + self.init_node(result) + + + if self.devUUID: + self.lustreDev = LustreDevice() + self.lustreDev.getEntry_from_ldap(conn_id, base, self.devUUID) + + if self.lovUUID: + self.lustreLov = LustreLov() + self.lustreLov.getEntry_from_ldap(conn_id, base, self.lovUUID) + + + def get_dn(self, uuid): + retval = self.mdsUUID_attr+"="+uuid+",type="+self.type+",fs=lustre" + return retval + + def addEntry_into_ldap(self, conn_id, mdsUUID, devName, devUUID, lovUUID, fUUID): + modlist = [] + dn = self.get_dn(mdsUUID) + modlist.append(("objectClass", [self.objectClass])) + modlist.append((self.mdsUUID_attr, mdsUUID)) + modlist.append((self.devName_attr, devName)) + modlist.append((self.devUUID_attr, devUUID)) + if lovUUID: + modlist.append((self.lovUUID_attr, lovUUID)) + modlist.append((self.fUUID_attr, fUUID)) + modlist.append(("fs", ["lustre"])) + status = 0 + + try: + conn_id.add_s(dn,modlist) + except _ldap.LDAPError: + print "not added" + sys.exit(1) + return status + + def initobj(self,*args): + print "init obj :", args + + def print_mds(self): + print "Lustre Mds Attributes..." + print "object Class: %s" % self.objectClass + print "mdsUUID: %s" % self.mdsUUID + print "devName: %s" % self.devName + print "devUUID: %s" % self.devUUID + #print "fUUID: %s" % self.fUUID + print "lovUUID: %s" % self.lovUUID + print + if self.lustreLov: + self.lustreLov.print_lov() + print + + +class LustreLov: + def __init__(self): + self.objectClass = "lustreLOV" + self.lovUUID = 0 + self.devName = "" + self.oscUUIDs = [] + self.stripeOffset = 0 + self.stripeSize = 0 + self.stripeCount = 0 + self.pattern = 0 + + self.lustreOsc = {} + + self.lovUUID_attr = "lovUUID" + self.devName_attr = "devName" + self.oscUUID_attr = "oscUUIDs" + self.stripeOffset_attr = "stripeOffset" + self.stripeSize_attr = "stripeSize" + self.stripeCount_attr = "stripeCount" + self.pattern_attr = "pattern" + self.type = "LOV" + + def get_object_class(self): + return self.objectCalss + + + + def get_rdn(self,attr_value): + retval = "(objectClass="+self.objectClass+") (lovUUID="+attr_value+")" + return retval + + + def init_node(self, record): + nofvals = len(record[0][1][self.oscUUID_attr]) + for i in range(nofvals): + self.oscUUIDs.append(record[0][1][self.oscUUID_attr][i]) + + self.stripeOffset = record[0][1][self.stripeOffset_attr][0] + self.lovUUID = record[0][1][self.lovUUID_attr][0] + self.devName = record[0][1][self.devName_attr][0] + self.stripeSize = record[0][1][self.stripeSize_attr][0] + self.stripeCount = record[0][1][self.stripeCount_attr][0] + self.pattern = record[0][1][self.pattern_attr][0] + + def getEntry_from_ldap(self, conn_id, base, attr_val): + lustre_util = lustre_ldap() + filter = lustre_util.get_filter(self.get_rdn(attr_val)) + result = conn_id.search_s(base, ldap.SCOPE_SUBTREE, filter) + if result == []: + print "Error No Results found" + sys.exit(1) + self.init_node(result) + + + if self.oscUUIDs: + for uuid in self.oscUUIDs: + self.lustreOsc[uuid] = LustreOsc() + self.lustreOsc[uuid].getEntry_from_ldap(conn_id, base, uuid) + + def get_dn(self,uuid): + retval = self.lovUUID_attr+"="+uuid+",type="+self.type+",fs=lustre" + return retval + + def addEntry_into_ldap(self, conn_id, lovUUID, devName, oscUUIDs, stripeOffset, stripeSize, stripeCount, pattern): + modlist = [] + dn=self.get_dn(lovUUID) + modlist.append(("objectClass", [self.objectClass])) + modlist.append((self.lovUUID_attr, lovUUID)) + modlist.append((self.devName_attr, devName)) + modlist.append((self.oscUUID_attr, oscUUIDs)) + modlist.append((self.stripeOffset_attr, stripeOffset)) + modlist.append((self.stripeSize_attr, stripeSize)) + modlist.append((self.stripeCount_attr, stripeCount)) + modlist.append((self.pattern_attr, pattern)) + modlist.append(("fs", ["lustre"])) + status = 0 + try: + conn_id.add_s(dn,modlist) + except _ldap.LDAPError: + print "not added" + sys.exit(1) + return status + + def initobj(self,*args): + print "init obj :", args + + def print_lov(self): + print "Lustre LOV attributes..." + print "object class: %s" % self.objectClass + print "lovUUID: %s" % self.lovUUID + print "devName: %s" % self.devName + print "oscUUIDs are" + for i in range(len(self.oscUUIDs)): + print "oscUUID[%d]: %s" % (i,self.oscUUIDs[i]) + print "stripeOffset: %s" % self.stripeOffset + print "stripe Size: %s" % self.stripeSize + print "stripe Count: %s" % self.stripeCount + print "pattern: %s" % self.pattern + + print + if self.oscUUIDs: + for uuid in self.oscUUIDs: + if self.lustreOsc: + self.lustreOsc[uuid].print_osc() + print + + +class LustreDevice: + def __init__(self): + self.objectClass = "lustreDevice" + self.id = "" + self.fid = "" + self.devUUID = 0 + self.netUUID = 0 + self.fnetUUID = 0 + self.device = "" + self.auto = 0 + self.fsType = "" + self.size = 0 + + self.id_attr = "id" + self.fid_attr = "fid" + self.devUUID_attr = "devUUID" + self.netUUID_attr = "netUUID" + self.fnetUUID_attr = "fnetUUID" + self.device_attr = "device" + self.auto_attr = "auto" + self.fsType_attr = "fsType" + self.size_attr = "size" + self.type = "device" + + def get_object_class(self): + return self.objectCalss + + def get_rdn(self, attr_value): + retval = "(objectClass="+self.objectClass+") (devUUID="+attr_value+")" + return retval + + def init_node(self, record): + self.devUUID = record[0][1][self.devUUID_attr][0] + self.netUUID = record[0][1][self.netUUID_attr][0] + self.fnetUUID = record[0][1][self.fnetUUID_attr][0] + self.id = record[0][1][self.id_attr][0] + self.fid = record[0][1][self.fid_attr][0] + self.device = record[0][1][self.device_attr][0] + self.auto = record[0][1][self.auto_attr][0] + self.fsType = record[0][1][self.fsType_attr][0] + self.size = record[0][1][self.size_attr][0] + + def getEntry_from_ldap(self, conn_id, base, attr_val): + lustre_util = lustre_ldap() + filter = lustre_util.get_filter(self.get_rdn(attr_val)) + result = conn_id.search_s(base, ldap.SCOPE_SUBTREE, filter) + if result == []: + print "Error No Results found" + sys.exit(1) + self.init_node(result) + + def get_dn(self,uuid): + retval = self.devUUID_attr+"="+uuid+",type="+self.type+",fs=lustre" + return retval + + def addEntry_into_ldap(self, conn_id, devUUID, netUUID, fnetUUID, id, fid, device, auto, fsType, size): + modlist = [] + dn = self.get_dn(devUUID) + modlist.append(("objectClass", [self.objectClass])) + modlist.append((self.devUUID_attr, devUUID)) + modlist.append((self.netUUID_attr, netUUID)) + modlist.append((self.fnetUUID_attr, fnetUUID)) + modlist.append((self.id_attr, id)) + modlist.append((self.fid_attr, fid)) + modlist.append((self.device_attr, device)) + modlist.append((self.auto_attr, auto)) + modlist.append((self.fsType_attr, fsType)) + modlist.append((self.size_attr, size)) + modlist.append(("fs", ["lustre"])) + status = 0 + try: + conn_id.add_s(dn,modlist) + except _ldap.LDAPError: + print "not added" + #sys.exit(1) + return status + + def initobj(self,*args): + print "init obj :", args + + def print_device(self): + print "lustre Device object...." + print "object Calss: %s" % self.objectClass + print "node name: %s" % self.id + print "failover node name: %s" % self.fid + print "devUUID: %s" % self.devUUID + print "netUUID: %s" % self.netUUID + print "failover netUUID: %s" % self.fnetUUID + print "device: %s" % self.device + print "autoformat: %s" % self.auto + print "fs type: %s" % self.fsType + print "size of device: %s" % self.size + + + +class LustreObd: + def __init__(self): + self.objectClass = "lustreOBD" + self.obdUUID = 0 + self.devName = "" + self.devUUID = 0 + self.fUUID = 0 + + self.lustreDev = 0 + + self.obdUUID_attr = "obdUUID" + self.devName_attr = "devName" + self.devUUID_attr = "devUUID" + self.fUUID_attr = "fUUID" + self.type = "OBD" + + def get_object_class(self): + return self.objectCalss + + def get_rdn(self,attr_value): + retval = "(objectClass="+self.objectClass+") (obdUUID="+attr_value+")" + return retval + + def init_node(self, record): + self.obdUUID = record[0][1][self.obdUUID_attr][0] + self.devName = record[0][1][self.devName_attr][0] + self.devUUID = record[0][1][self.devUUID_attr][0] + self.fUUID = record[0][1][self.fUUID_attr][0] + + def getEntry_from_ldap(self, conn_id, base, attr_val): + lustre_util = lustre_ldap() + filter = lustre_util.get_filter(self.get_rdn(attr_val)) + result = conn_id.search_s(base, ldap.SCOPE_SUBTREE, filter) + if result == []: + print "Error No Results found" + sys.exit(1) + self.init_node(result) + + if self.devUUID: + self.lustreDev = LustreDevice() + self.lustreDev.getEntry_from_ldap(conn_id, base, self.devUUID) + + + def get_dn(self,uuid): + retval = self.obdUUID_attr+"="+uuid+",type="+self.type+",fs=lustre" + return retval + + def addEntry_into_ldap(self, conn_id, obdUUID, devName, devUUID, fUUID): + modlist = [] + dn=self.get_dn(obdUUID) + modlist.append(("objectClass", [self.objectClass])) + modlist.append((self.obdUUID_attr, obdUUID)) + modlist.append((self.devName_attr, devName)) + modlist.append((self.devUUID_attr, devUUID)) + modlist.append((self.fUUID_attr, fUUID)) + modlist.append(("fs", ["lustre"])) + status = 0 + try: + conn_id.add_s(dn, modlist) + except _ldap.LDAPError: + print "not added" + sys.exit(1) + return status + + def initobj(self,*args): + print "init obj :", args + + def print_obd(self): + print "Lustre Obd attributes...." + print "object Class: %s" % self.objectClass + print "obdUUID: %s" % self.obdUUID + print "devName: %s" % self.devName + print "devUUID: %s" % self.devUUID + print "fUUID: %s" % self.fUUID + print + if self.lustreDev: + self.lustreDev.print_device() + print + + +class LustreLdlm: + def __init__(self): + self.objectClass="lustreLDLM" + self.ldlmUUID=0 + self.devName="" + + self.ldlmUUID_attr="ldlmUUID" + self.devName_attr="devName" + self.type="LDLM" + + def get_object_class(self): + return self.objectCalss + + + def get_rdn(self,attr_value): + retval="(objectClass="+self.objectClass+") (ldlmUUID="+attr_value+")" + return retval + + def init_node(self,record): + self.ldlmUUID=record[0][1][self.ldlmUUID_attr][0] + self.devName=record[0][1][self.devName_attr][0] + + def getEntry_from_ldap(self,conn_id,base,attr_val): + lustre_util=lustre_ldap() + filter=lustre_util.get_filter(self.get_rdn(attr_val)) + result=conn_id.search_s(base,ldap.SCOPE_SUBTREE,filter) + if result == []: + print "Error No Results found" + sys.exit(1) + self.init_node(result) + + + def get_dn(self,uuid): + retval=self.ldlmUUID_attr+"="+uuid+",type="+self.type+",fs=lustre" + return retval + + def addEntry_into_ldap(self, conn_id, ldlmUUID, devName): + modlist=[] + dn=self.get_dn(ldlmUUID) + modlist.append(("objectClass", self.objectClass)) + modlist.append((self.ldlmUUID_attr, ldlmUUID)) + modlist.append((self.devName_attr, devName)) + modlist.append(("fs", "lustre")) + status=0 + try: + conn_id.add_s(dn,modlist) + except _ldap.LDAPError: + print "not added" + #sys.exit(1) + return status + + def initobj(self,*args): + print "init obj :", args + + def print_ldlm(self): + print "Printing LDLM attributes..........." + print "ldlm Object Class: %s" % self.objectClass + print "ldlm UUID: %s" % self.ldlmUUID + print "ldlm Name: %s" % self.devName + print "\n" * 5 + + +class LustreNet: + def __init__(self): + self.objectClass = "lustreNetwork" + self.netUUID = 0 + self.id = 0 + self.fnetUUID = 0 + self.netType = "" + self.netAddress = "" + self.port = 0 + self.recvMem = 0 + self.sendMem = 0 + + self.netUUID_attr = "netUUID" + self.fnetUUID_attr = "fnetUUID" + self.id_attr = "id" + self.netType_attr = "netType" + self.netAddress_attr = "netAddress" + self.port_attr = "port" + self.recvMem_attr = "recvMem" + self.sendMem_attr = "sendMem" + self.type = "net" + + def get_object_class(self): + return self.objectCalss + + def get_rdn(self, attr_value): + retval = "(objectClass="+self.objectClass+") (netUUID="+attr_value+")" + return retval + + def init_node(self, record): + self.netUUID = record[0][1][self.netUUID_attr][0] + self.fnetUUID = record[0][1][self.fnetUUID_attr][0] + self.id = record[0][1][self.id_attr][0] + self.netType = record[0][1][self.netType_attr][0] + self.netAddress = record[0][1][self.netAddress_attr][0] + self.port = record[0][1][self.port_attr][0] + self.recvMem = record[0][1][self.recvMem_attr][0] + self.sendMem = record[0][1][self.sendMem_attr][0] + + def getEntry_from_ldap(self, conn_id, base, attr_val): + lustre_util = lustre_ldap() + filter = lustre_util.get_filter(self.get_rdn(attr_val)) + result = conn_id.search_s(base, ldap.SCOPE_SUBTREE, filter) + if result == []: + print "Error No Results found" + sys.exit(1) + self.init_node(result) + + + def get_dn(self, uuid): + retval = self.netUUID_attr+"="+uuid+",type="+self.type+",fs=lustre" + return retval + + def addEntry_into_ldap(self,conn_id, id, netUUID, fnetUUID, netType, netAddress, port, recvMem, sendMem): + modlist = [] + dn=self.get_dn(netUUID) + modlist.append(("objectClass",[self.objectClass])) + modlist.append((self.netUUID_attr,[netUUID])) + modlist.append((self.fnetUUID_attr,[fnetUUID])) + modlist.append((self.id_attr,[id])) + modlist.append((self.netType_attr,[netType])) + modlist.append((self.netAddress_attr,[netAddress])) + modlist.append((self.port_attr,[port])) + modlist.append((self.recvMem_attr,[recvMem])) + modlist.append((self.sendMem_attr,[sendMem])) + modlist.append(("fs",["lustre"])) + status=0 + try: + conn_id.add_s(dn,modlist) + except _ldap.LDAPError: + print "not added" + #sys.exit(1) + return status + + def initobj(self,*args): + print "init obj :", args + + def print_net(self): + print "Lustre Network Attributes:......" + print "object Class: %s" % self.objectClass + print "network UUID: %s" % self.netUUID + print "failover network UUID: %s" % self.fnetUUID + print "node name : %s" % self.id + print "network Type: %s" % self.netType + print "IP Address: %s" % self.netAddress + print "port: %s" % self.port + print "receive memory: %s" % self.recvMem + print "send memory: %s" % self.sendMem + print + + +class LustreNodeProfile: + def __init__(self): + self.objectClass="lustreNodeProfile" + self.profileUUID=0 + self.mdsUUIDs=[] + self.ostUUIDs=[] + self.clientUUID=0 + + self.profileUUID_str="profileUUID" + self.mdsUUIDs_str="mdsUUIDs" + self.ostUUIDs_str="ostUUIDs" + self.clientUUID_str="clientUUID" + self.type="profile" + + def get_object_class(self): + return self.objectCalss + + def get_rdn(self,attr_value): + retval="(objectClass="+self.objectClass+") (profileUUID="+attr_value+")" + return retval + + def init_node(self,node_entry): + self.profileUUID=node_entry[0][1][self.profileUUID_str][0] + if node_entry[0][1].has_key(self.mdsUUIDs_str): + for i in range(len(node_entry[0][1][self.mdsUUIDs_str])): + self.mdsUUIDs.append(node_entry[0][1][self.mdsUUIDs_str][i]) + + if node_entry[0][1].has_key(self.ostUUIDs_str): + for i in range(len(node_entry[0][1][self.ostUUIDs_str])): + self.ostUUIDs.append(node_entry[0][1][self.ostUUIDs_str][i]) + + if node_entry[0][1].has_key(self.clientUUID_str): + self.clientUUID=node_entry[0][1][self.clientUUID_str][0] + + def getEntry_from_ldap(self,conn_id,base,attr_val): + lustre_util=lustre_ldap() + filter=lustre_util.get_filter(self.get_rdn(attr_val)) + result=conn_id.search_s(base,ldap.SCOPE_SUBTREE,filter) + if result == []: + print "Error No Results found" + sys.exit(1) + self.init_node(result) + + def get_dn(self,uuid): + retval=self.profileUUID_str+"="+uuid+",type="+self.type+",fs=lustre" + return retval + + def addEntry_into_ldap(self,conn_id,profileUUID,mdsUUIDs,ostUUIDs,clientUUID): + modlist=[] + dn=self.get_dn(profileUUID) + modlist.append(("objectClass",[self.objectClass])) + modlist.append((self.profileUUID_str,[profileUUID])) + if mdsUUIDs: + modlist.append((self.mdsUUIDs_str,mdsUUIDs)) + if ostUUIDs: + modlist.append((self.ostUUIDs_str,ostUUIDs)) + if clientUUID: + modlist.append((self.clientUUID_str,[clientUUID])) + modlist.append(("fs",["lustre"])) + status=0 + try: + conn_id.add_s(dn,modlist) + except _ldap.LDAPError: + print "not added" + sys.exit(1) + return status + + def initobj(self,*args): + print "init obj :", args + + def print_profile(self): + print "Lustre Node Profile Attributes:......" + print "object Class: %s" % self.objectClass + print "profile UUID: %s" % self.profileUUID + print "This node supports %d mds servers:" % len(self.mdsUUIDs) + for i in range(len(self.mdsUUIDs)): + print "Mds UUID%d: %s" % (i,self.mdsUUIDs[i]) + print "This node supports %d ost servers:" % len(self.ostUUIDs) + for i in range(len(self.ostUUIDs)): + print "Ost UUID%d: %s" % (i,self.ostUUIDs[i]) + print "Client UUID: %s" % self.clientUUID + print + + +def get_matched_osc(ConnId,ostuuid): + result = ConnId.search_s("fs=lustre",ldap.SCOPE_SUBTREE,"objectclass=lustreOSC") + lustreOSC = 0 + if result: + for i in range(len(result)): + tmpuuid = result[i][1]['ostUUID'][0] + if ostuuid == tmpuuid: + lustreOSC = LustreOsc() + lustreOSC.init_node([result[i]]) + break + + else: + print "no result" + + return lustreOSC + + +def get_matched_lov(ConnId,oscuuid): + result = ConnId.search_s("fs=lustre",ldap.SCOPE_SUBTREE,"objectclass=lustreLOV") + lustreLOV = 0 + tmpuuids = [] + if result: + for i in range(len(result)): + tmpuuids = result[i][1]['oscUUIDs'] + for uuid in tmpuuids: + if oscuuid == uuid: + lustreLOV = LustreLov() + lustreLOV.init_node([result[i]]) + return lustreLOV + return 0 + + + + + + + + +net_uuids = [] +def loadNetworkconfig(dom_node,node): + global net_uuids + node_name = get_attr(node,'name') + net = Network(dom_node) + net_uuids.append(net.uuid) + failnetUUID = net.uuid + lustreNet = LustreNet() + lustreNet.initobj(node_name,net.uuid,failnetUUID,net.net_type,net.nid,net.port,net.send_mem,net.recv_mem) + lustreNet.addEntry_into_ldap(connId, node_name, net.uuid, failnetUUID, net.net_type, str(net.nid), str(net.port), str(net.send_mem), str(net.recv_mem)) + + +ldlm_uuid = 0 +def loadLDLMconfig(dom_node,node): + "This is fill LDLM details...:" + global ldlm_uuid + ldlm = LDLM(dom_node) + ldlm_uuid = ldlm.uuid + lustreLdlm = LustreLdlm() + lustreLdlm.initobj(ldlm.uuid,ldlm.name) + lustreLdlm.addEntry_into_ldap(connId, ldlm.uuid, ldlm.name) + +lov_uuids = [] +def loadLOVconfig(dom_node,node): + global lov_uuids + lov_uuid = get_first_ref(dom_node, 'lov') + lov_node = lookup(dom_node.parentNode, lov_uuid) + lov = LOV(lov_node) + lov_uuids.append(lov.uuid) + node_name = get_attr(node,'name') + osc_uuids = [] + for uuid in lov.devlist: + osc_uuids.append(str(uuid)) + objlov = LustreLov() + objlov.initobj( lov.uuid, lov.name, osc_uuids, lov.stripe_off, lov.stripe_sz, lov.stripe_cnt, lov.pattern) + objlov.addEntry_into_ldap(connId, lov.uuid, lov.name, osc_uuids, str(lov.stripe_off), str(lov.stripe_sz), str(lov.stripe_cnt), str(lov.pattern)) + + lov_devs = lov_node.getElementsByTagName('devices') + devlist = get_all_refs(lov_devs[0], 'osc') + for osc_uuid in devlist: + osc_node = lookup(dom_node.parentNode,osc_uuid) + osc = OSC(osc_node) + lustreOsc = LustreOsc() + lustreOsc .initobj( osc.uuid, osc.name, str(osc.obd_uuid), str(osc.ost_uuid)) + lustreOsc .addEntry_into_ldap(connId, osc.uuid, osc.name, str(osc.obd_uuid), str(osc.ost_uuid)) + +mds_uuids = [] +def loadMDSconfig( dom_node,node): + global mds_uuids + node_name = getName(node) + mds = MDS(dom_node) + mds_net = mds.get_server() + + netuuid = mds_net.uuid + failnetuuid = netuuid + fid = mds_net.nid + device_name = new_name('DEVICE_'+node_name) + devuuid = new_uuid(device_name) + lov_uuid = get_first_ref(dom_node, 'lov') + + objdevice = LustreDevice() + objdevice.initobj( devuuid, netuuid, netuuid, node_name, node_name, mds.devname, str(mds.format), str(mds.fstype), str(mds.size)) + objdevice.addEntry_into_ldap(connId, devuuid, netuuid, netuuid, node_name, node_name, str(mds.devname), str(mds.format), str(mds.fstype), str(mds.size)) + + lovcfg_uuid = get_first_ref(node, 'lovconfig') + lovcfg = 0 + if lovcfg_uuid: + lovcfg_node = lookup(dom_node.parentNode, lovcfg_uuid ) + lovcfg = LOVConfig(lovcfg_node) + lov_uuid = 0 + if lovcfg: + lov_uuid = str(lovcfg.lov_uuid) + + lustreMds = LustreMds() + lustreMds.initobj(mds.uuid,mds.name,devuuid, lov_uuid, mds.uuid) + lustreMds.addEntry_into_ldap(connId, mds.uuid, mds.name, devuuid, lov_uuid, mds.uuid) + mds_uuids.append(mds.uuid) + + +def loadOBDconfig(dom_node,node): + global net_uuids + node_name = get_attr(node,'name') + obd = OBD(dom_node) + device_name = new_name('DEVICE_'+node_name) + devuuid = new_uuid(device_name) + + lustreDev = LustreDevice() + lustreDev.initobj(devuuid, net_uuids[0], net_uuids[0], node_name, node_name, str(obd.devname), str(obd.format), str(obd.fstype), str(obd.size)) + lustreDev.addEntry_into_ldap(connId, devuuid, net_uuids[0], net_uuids[0], node_name, node_name, str(obd.devname), str(obd.format), str(obd.fstype), str(obd.size)) + + lustreObd = LustreObd() + lustreObd.initobj(obd.uuid, obd.name, obd.obdtype, devuuid, obd.uuid) + lustreObd.addEntry_into_ldap(connId, obd.uuid, obd.name, devuuid, obd.uuid) + + +mount_uuids = [] +def loadMountpointconfig(dom_node,node): + global mount_uuids + node_name = get_attr(node,'name') + mount = Mountpoint(dom_node) + + mountuuid = new_uuid(mount.name) + mount_uuids.append(mountuuid) + lustreMount = LustreMount() + lustreMount.initobj( mountuuid, str(mount.mds_uuid), str(mount.lov_uuid), str(mount.path), "No") + lustreMount.addEntry_into_ldap(connId, mountuuid, str(mount.mds_uuid), str(mount.lov_uuid),str(mount.path), "No") + + + +ost_uuids = [] +def loadOSTconfig(dom_node,node): + global ost_uuids + ost = OST(dom_node) + node_name = get_attr(node,'name') + + lustreOst = LustreOst() + lustreOst.initobj(ost.uuid, ost.name, ost.obd_uuid) + lustreOst.addEntry_into_ldap(connId, ost.uuid, ost.name, str(ost.obd_uuid)) + ost_uuids.append(ost.uuid) + +############################################################ +# lconf level logic +# Start a service. + + + + +def LoadProfile(lustreNode,profileNode,node): + global mount_uuids + global profile_uuid + node_name = get_attr(node,'name') + if not profileNode: + panic("profile:",profile,"not found.") + services = getServices(lustreNode,profileNode) + if services: + for service in services: + dom_node = service + type = getServiceType(dom_node) + if type == 'ldlm': + loadLDLMconfig(dom_node,node) + elif type == 'obd': + loadOBDconfig(dom_node,node) + elif type == 'lovconfig': + loadLOVconfig(dom_node,node) + elif type == 'network': + loadNetworkconfig(dom_node,node) + elif type == 'ost': + loadOSTconfig(dom_node,node) + elif type == 'mds': + loadMDSconfig(dom_node,node) + elif type == 'mountpoint': + loadMountpointconfig(dom_node,node) + else: + panic ("unknown service type:", type) + + + clientuuid = 0 + if mount_uuids: + clientuuid = node_name + "clientUUID" + lustre_Node = LustreNode(node_name) + lustreClient = LustreClient(lustre_Node) + lustreClient.initobj(clientuuid, mount_uuids, net_uuids) + lustreClient.addEntry_into_ldap(connId, clientuuid, mount_uuids, net_uuids) + + + profile_uuid = str(node_name+"profileUUID") + nodeprofile = LustreNodeProfile() + nodeprofile.initobj(profile_uuid, mds_uuids, ost_uuids, clientuuid) + nodeprofile.addEntry_into_ldap(connId, profile_uuid, mds_uuids, ost_uuids, clientuuid) + +def Initilize_globals(): + global mds_uuids + global ost_uuids + global net_uuids + global clientuuid + global profile_uuid + global ldlm_uuid + global mount_uuids + mount_uuids = [] + mds_uuids = [] + ost_uuids = [] + net_uuids = [] + clientuuid = 0 + profile_uuid = 0 + ldlm_uuid = 0 + +def print_globals(): + global mds_uuids + global ost_uuids + global net_uuids + global clientuuid + global profile_uuid + global ldlm_uuid + print "mds_uuids :", mds_uuids + print "ost_uuids :", ost_uuids + print "net_uuids :", net_uuids + print "client uuid :", clientuuid + print "profile_uuid :", profile_uuid + print "ldlm_uuid :", ldlm_uuid + +def loadXml(lustreNode): + global net_uuids + global ldlm_uuid + global profile_uuid + dom_node = None + Initilize_globals() + + global connId + server = "blackswan.india.hp.com" + port=389 + binddn="cn=Manager,fs=lustre" + base="fs=lustre" + myCon=MyConn(server,port) + myCon.open() + connId=myCon.id + + nodelist = [] + nodelist = lustreNode.getElementsByTagName('node') + for i in range(len(nodelist)): + node_name = getName(nodelist[i]) + print "node name in loadXml :", node_name + node_uuid = getUUID(nodelist[i]) + dom_node = getByName(lustreNode, node_name, 'node') + if dom_node == None: + break + Node = LustreNode(node_name) + reflist = dom_node.getElementsByTagName('profile') + if reflist: + for profile in reflist: + LoadProfile(lustreNode,profile,dom_node) + Node.initobj(node_name,node_uuid,net_uuids,profile_uuid,net_uuids,ldlm_uuid) + Node.addEntry_into_ldap(connId,node_name,node_uuid,net_uuids,profile_uuid,net_uuids,ldlm_uuid) + Initilize_globals() + print "initilized for node:", node_name + + +connId = 0 -- 1.8.3.1