From f0de56c3d20d72aa38f685dee79486da967863fb Mon Sep 17 00:00:00 2001 From: Tomas Smetana Date: Wed, 23 Oct 2013 11:57:07 +0200 Subject: Make the new registration script the default one. --- openlmi-mof-register | 760 ++++++++++++++++++++++++++++++++++----------------- 1 file changed, 512 insertions(+), 248 deletions(-) (limited to 'openlmi-mof-register') diff --git a/openlmi-mof-register b/openlmi-mof-register index 6107503..f04d8f8 100755 --- a/openlmi-mof-register +++ b/openlmi-mof-register @@ -1,4 +1,4 @@ -#!/bin/sh +#!/usr/bin/python # # Copyright (C) 2012-2013 Red Hat, Inc. All rights reserved. # @@ -18,273 +18,537 @@ # # Authors: Radek Novacek # Jan Safranek +# Tomas Smetana # -pegasus_repository="/var/lib/Pegasus/" -default_namespace="root/cimv2" - -function log() -{ - printf "%(%Y-%m-%d %H:%M:%S)T " -1 >&2 - printf "$*\n" >&2 +import getopt +import sys +import os +import subprocess +import datetime +import re +import sqlite3 +from tempfile import NamedTemporaryFile +from shutil import copyfile + +global PEGASUS_REPOSITORY +global DEFAULT_NAMESPACE +global REG_DB_PATH +global REG_DB_NAME + +PEGASUS_REPOSITORY = "/var/lib/Pegasus" +DEFAULT_NAMESPACE = "root/cimv2" +REG_DB_PATH = "/var/lib/openlmi-registration" +REG_DB_NAME = "regdb.sqlite" + +reg_parse = re.compile(r"\[([^\]]+)\]\s+" +"provider: ([^\s]+)\s+" +"location: (\w+)\s+" +"type: ([^\n]+)\s+" +"namespace: ([^\n]+)\s+" +"(group: ([^\n]+)|)") # the group is optional + +Types = { + 'instance': '2', + 'association': '3', + 'indication': '4', + 'method': '5', + 'consumer': '6', + 'instanceQuery': '7' } -function log_command() -{ - log "COMMAND:" "$*" >&2 - "$@" - code=$? - log "EXIT CODE:" "$code" >&2 - return $code -} +def usage(): + print """ +Usage: %(progname)s [ --just-mofs ] [ -n namespace ] [ -c cimom ] [-v version] + CMD [mof] [...] [reg] + CMD is one of [ register, unregister ] -trap 'log "DONE WITH EXIT CODE:" "$?"' EXIT + %(progname)s reregister [ -c cimom ] -function start_pegasus() -{ - # Start Pegasus CIMOM in restricted mode, listening only on its unix socket - log_command /usr/sbin/cimserver daemon=true \ - enableHttpConnection=false \ - enableHttpsConnection=false \ - enableRemotePrivilegedUserAccess=false \ - slp=false - - if [ "$?" != "0" ]; then - echo "Cannot start Pegasus" >&2 - exit 1 - fi -} + %(progname)s list -function stop_pegasus() -{ - log_command /usr/sbin/cimserver -s -} + Registration/unregistreation: -function usage() -{ - printf "Usage: $0 [ --just-mofs ] [ -n namespace ] [ -c cimom ] [-v version] - CMD [mof] [...] [reg] - CMD is one of [ register, unregister ] - - Default namespace is $default_namespace, which can be changed with '-n' option. + Default namespace is %(default_ns)s, which can be changed with '-n' option. If a registration file is provided, '-v' parameter is mandatory and specifies version of the provider API. - Supported cimoms are sfcbd and tog-pegasus. Without \"-c\" argument, the + Supported CIMOMs are sfcbd and tog-pegasus. Without \"-c\" argument, the operation is processed for any cimom present on system (all of them). --just-mofs option causes that all arguments after CMD will be treated as mof files - no registration file is expected. usage with --just-mofs: - $0 --just-mofs CMD [mof] [...] + %(progname)s --just-mofs CMD [mof] [...] usage without: - $0 -v CMD [mof] [...] \n" - -} - -function register() + %(progname)s -v CMD [mof] [...] + + + Re-registration + + Re-does all the known registrations for all the found or the specified + CIMOM. + + The list command allows for listing the known registrations and their + parameters. +""" % { 'progname': sys.argv[0], 'default_ns': DEFAULT_NAMESPACE } + +def log_msg(msg): + sys.stderr.write(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')) + sys.stderr.write(" " + msg + "\n") + sys.stderr.flush() + +def log_command(cmd, args): + log_msg("COMMAND: " + cmd + " " + " ".join(args)) + try: + rv = subprocess.check_call([cmd] + args) + except subprocess.CalledProcessError as e: + log_msg(str(e)) + rv = e.returncode + log_msg("EXIT CODE: " + str(rv)) + return rv + +def db_init(): + if not os.path.isdir(REG_DB_PATH): + os.makedirs(REG_DB_PATH + "/mof") + os.makedirs(REG_DB_PATH + "/reg") + db = sqlite3.connect(REG_DB_PATH + "/" + REG_DB_NAME) + dbc = db.cursor() + dbc.execute("PRAGMA foreign_keys = ON") + dbc.executescript(""" + CREATE TABLE IF NOT EXISTS registration ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + ctime varchar(23) NOT NULL DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')) + ); + CREATE TABLE IF NOT EXISTS mof ( + fname VARCHAR PRIMARY KEY, + registration_id INTEGER REFERENCES registration(id) ON DELETE CASCADE + ); + CREATE TABLE IF NOT EXISTS reg ( + fname VARCHAR PRIMARY KEY, + registration_id INTEGER REFERENCES registration(id) ON DELETE CASCADE + ); + CREATE TABLE IF NOT EXISTS cimom_opts ( + cimom VARCHAR NOT NULL, + registration_id INTEGER REFERENCES registration(id) ON DELETE CASCADE, + namespace VARCHAR NOT NULL, + version VARCHAR, + PRIMARY KEY (cimom, registration_id) + );""") + db.commit() + return db + +def db_close(db): + db.close() + +def define_module(location, group, version): + return """instance of PG_ProviderModule { - if [ $JUST_MOFS -eq 0 ]; then - reg=$1 - shift - fi - mofs="$@" - if [ $HAS_SFCBD -eq 1 ] && echo $cimom | grep -q 'all\|sfcbd'; - then - log_command /usr/bin/sfcbstage -n $namespace ${reg:+-r} $reg $mofs - log_command /usr/bin/sfcbrepos -f - log_command /usr/bin/systemctl reload-or-try-restart sblim-sfcb.service - fi - - if [ $HAS_PEGASUS -eq 1 ] && echo $cimom | grep -q 'all\|tog-pegasus'; - then - /usr/sbin/cimserver --status > /dev/null 2>&1 - if [ $? -eq 0 ]; - then - CIMMOF="/usr/bin/cimmof -aEV -n $namespace" - else - CIMMOF="/usr/bin/cimmofl -aEV -R $pegasus_repository -n $namespace" - fi - - log_command $CIMMOF -uc $mofs - if [ $JUST_MOFS -eq 0 ]; then - if [ -x $(dirname $0)/openlmi-register-pegasus ]; - then - log "COMMAND: cat \"$reg\" | $(dirname $0)/openlmi-register-pegasus -v \"$version\" | $CIMMOF -uc -n root/interop" - cat "$reg" | $(dirname $0)/openlmi-register-pegasus -v "$version" | $CIMMOF -uc -n root/interop - log "EXIT CODE:" "$?" - else - log "COMMAND: cat \"$reg\" | /usr/libexec/openlmi-register-pegasus -v \"$version\" | $CIMMOF -uc -n root/interop" - cat "$reg" | /usr/libexec/openlmi-register-pegasus -v "$version" | $CIMMOF -uc -n root/interop - log "EXIT CODE:" "$?" - fi - fi - fi -} + Name = "%(group)s"; + Location = "%(location)s"; + Vendor = "OpenLMI"; + Version = "%(version)s"; + InterfaceType = "CMPI"; + InterfaceVersion = "2.0.0"; + ModuleGroupName = "%(group)s"; +}; +""" % { 'location': location, 'group': group, 'version': version } + +def get_types(types): + l = [] + for key, value in Types.items(): + if key in types: + l.append(value) + return ",".join(l) + +def define_capability(location, provider, cls, types, group): + return """instance of PG_Provider +{ + Name = "%(provider)s"; + ProviderModuleName = "%(group)s"; +}; -function unregister() +instance of PG_ProviderCapabilities { - if [ $JUST_MOFS -eq 0 ]; then - reg=$1 - shift - fi - - declare -a mofs=("$@") - if [ $HAS_SFCBD -eq 1 ] && echo $cimom | grep -q 'all\|sfcbd'; - then - # convert mofs to `basename mof` - declare -a bmofs - for ((i=0; i<${#mofs[@]}; i++)); do - bmofs[$i]=$(basename "${mofs[$i]}") - done - log_command /usr/bin/sfcbunstage -n $namespace ${reg:+-r} $(basename "$reg") ${bmofs[@]} - log_command /usr/bin/sfcbrepos -f - log_command /usr/bin/systemctl reload-or-try-restart sblim-sfcb.service - fi - - if [ $HAS_PEGASUS -eq 1 ] && echo $cimom | grep -q 'all\|tog-pegasus'; - then - # Pegasus must be running when removing MOF files and providers - if ! /usr/sbin/cimserver --status &>/dev/null; then - CUSTOM_PEGASUS=1 - start_pegasus - fi - if [ -n "$reg" ]; - then - providers=$(sed -n 's/ *group: *//p' "$reg" | sort | uniq) - if [ -z "$providers" ]; then - # fall back to location if group: is not present - providers=$(sed -n 's/ *location: *//p' "$reg" | sort | uniq) - fi - for provider in $providers; - do - log_command /usr/bin/cimprovider -d -m ${provider} - log_command /usr/bin/cimprovider -r -m ${provider} - done - fi - mofcomp -n $namespace -r ${mofs[@]} - if [ -n "$CUSTOM_PEGASUS" ]; then - stop_pegasus - fi - fi -} + ProviderModuleName = "%(group)s"; + ProviderName = "%(provider)s"; + CapabilityID = "%(class)s"; + ClassName = "%(class)s"; + Namespaces = { "root/cimv2" }; + ProviderType = { %(types)s }; + SupportedProperties = NULL; + SupportedMethods = NULL; +}; +""" % { 'location': location, 'provider': provider, 'class': cls, 'types': get_types(types), 'group': group } + +def start_pegasus(): + if log_command("/usr/sbin/cimserver", ["daemon=true", + "enableHttpConnection=false", + "enableHttpsConnection=false", + "enableRemotePrivilegedUserAccess=false", + "slp=false"]) != 0: + log_msg("Cannot start Pegasus") + sys.exit(1) + +def stop_pegasus(): + log_command("/usr/sbin/cimserver", ["-s"]) + +def find_pegasus_interop(): + # try to guess the interop namespace: root/interop is present only + # in the newer Pegasus versions so start with that one + if os.path.isdir(PEGASUS_REPOSITORY + "/repository/root#interop"): + ret = "root/interop" + elif os.path.isdir(PEGASUS_REPOSITORY + "/repository/root#PG_InterOp"): + ret = "root/PG_InterOp" + else: + log_msg("ERROR: Could not find the Pegasus interop namespace: Exiting") + sys.exit(1) + return ret + +def register_pegasus(reg, version, cimmof, cm_args): + modules_defined = {} + with open(reg, "r") as regfile: + reg_data = regfile.read() + tmpfile = NamedTemporaryFile() + for record in reg_parse.findall(reg_data): + cls, provider, location, types, namespace, _unused, group = record + + if not group: + group = location + + if group not in modules_defined: + tmpfile.write(define_module(location, group, version)) + modules_defined[group] = True + + tmpfile.write(define_capability(location, provider, cls, types, group)) + tmpfile.flush() + interop_ns = find_pegasus_interop() + cm_args += ["-uc", "-n", interop_ns, tmpfile.name] + log_command(cimmof, cm_args) + tmpfile.close() # deletes the file + +def cimom_register(mofs, reg, version, namespace, cimom): + if cimom['sfcbd']: + args = ["-n", namespace] + if reg: + args += ["-r", reg] + args += mofs + log_command("/usr/bin/sfcbstage", args) + log_command("/usr/bin/sfcbrepos", ["-f"]) + log_command("/usr/bin/systemctl", ["reload-or-try-restart", "sblim-sfcb.service"]) + if cimom['tog-pegasus']: + args = ["-aEV", "-n", namespace] + with open("/dev/null", "w") as devnull: + if subprocess.call(["/usr/sbin/cimserver", "--status"], + stdout = devnull, stderr = devnull) == 0: + cimmof = "/usr/bin/cimmof" + repo_args = [] + else: + cimmof = "/usr/bin/cimmofl" + repo_args = ["-R", PEGASUS_REPOSITORY] + args += repo_args + ["-uc"] + mofs + log_command(cimmof, args) + if reg: + register_pegasus(reg, version, cimmof, repo_args) + +def cimom_unregister(mofs, reg, version, namespace, cimom): + if cimom['sfcbd']: + args = ["-n", namespace] + if reg: + args += ["-r", os.path.basename(reg)] + args += [os.path.basename(f) for f in mofs] + log_command("/usr/bin/sfcbunstage", args) + log_command("/usr/bin/sfcbrepos", ["-f"]) + log_command("/usr/bin/systemctl", ["reload-or-try-restart", "sblim-sfcb.service"]) + if cimom['tog-pegasus']: + custom_pegasus = False + with open("/dev/null", "w") as devnull: + if subprocess.call(["/usr/sbin/cimserver", "--status"], + stdout = devnull, stderr = devnull) != 0: + custom_pegasus = True + start_pegasus() + if reg: + pattern = re.compile(r"^\s*group:\s*(\w+)\s*$") + with open(reg, "r") as regfile: + providers = set() + for rline in regfile.readlines(): + p = pattern.sub(r'\1', rline) + if p != rline: + providers.add(p) + if len(providers) == 0: + pattern = re.compile(r"^\s*location:\s*(\w+)\s*$") + regfile.seek(0) + for rline in regfile.readlines(): + p = pattern.sub(r'\1', rline) + if p != rline: + providers.add(p) + for p in providers: + log_command("/usr/bin/cimprovider", ["-d", "-m", p]) + log_command("/usr/bin/cimprovider", ["-r", "-m", p]) + log_command("/usr/bin/mofcomp", ["-n", namespace] + mofs) + if custom_pegasus: + stop_pegasus() + +def db_get_registrations(cursor, mofs, reg): + bmofs = [os.path.basename(f) for f in mofs] + if (reg): + qry = "SELECT mof.registration_id FROM mof JOIN reg \ + ON mof.registration_id = reg.registration_id \ + WHERE (mof.fname in ('%(mofs)s') or reg.fname = '%(reg)s') \ + GROUP BY mof.registration_id" \ + % { 'mofs': "','".join(bmofs), 'reg': reg } + else: + qry = "SELECT mof.registration_id FROM mof \ + WHERE (mof.fname in ('%(mofs)s')) GROUP BY mof.registration_id" \ + % { 'mofs': "','".join(bmofs) } + cursor.execute(qry) + ret = cursor.fetchall() + return ret + +def db_register(mofs, reg, version, namespace, cimom): + db = db_init() + dbc = db.cursor() + rows = db_get_registrations(dbc, mofs, reg) + if (len(rows) == 1): + # updating existing registration + reg_id = rows[0][0] + dbc.execute("DELETE FROM reg WHERE (registration_id = ?)", (reg_id,)) + dbc.execute("DELETE FROM mof WHERE (registration_id = ?)", (reg_id,)) + dbc.execute("DELETE FROM cimom_opts WHERE (registration_id = ?)", (reg_id,)) + elif (len(rows) == 0): + # new registration + dbc.execute("INSERT INTO registration DEFAULT VALUES") + reg_id = dbc.lastrowid + else: + # not supported... + log_msg("ERROR: Cannot update multiple registrations") + db_close(db) + return + for moffile in mofs: + # backup the mof file and create the database record + bmof = os.path.basename(moffile) + copyfile(moffile, REG_DB_PATH + "/mof/" + bmof) + dbc.execute("INSERT INTO mof (fname, registration_id) VALUES (?, ?)", + (bmof, reg_id)) + if reg: + # backup the reg file and create the database record + copyfile(reg, REG_DB_PATH + "/reg/" + os.path.basename(reg)) + dbc.execute("INSERT INTO reg (fname, registration_id) VALUES (?, ?)", + (os.path.basename(reg), reg_id)) + if cimom['sfcbd']: + dbc.execute("INSERT INTO cimom_opts (cimom, registration_id, namespace, version) \ + VALUES (?, ?, ?, ?)", ('sfcbd', reg_id, namespace, version)) + if cimom['tog-pegasus']: + dbc.execute("INSERT INTO cimom_opts (cimom, registration_id, namespace, version) \ + VALUES (?, ?, ?, ?)", ('tog-pegasus', reg_id, namespace, version)) + db.commit() + db_close(db) + +def db_unregister(mofs, reg, version, namespace, cimom): + db = db_init() + dbc = db.cursor() + rows = db_get_registrations(dbc, mofs, reg) + if (len(rows) == 1): + # ok. just one registration, remove it + reg_id = str(rows[0][0]) + for bmof in dbc.execute("SELECT fname FROM mof WHERE (registration_id = ?)", (reg_id,)): + try: + os.unlink(REG_DB_PATH + "/mof/" + bmof[0]) + except OSError as e: + log_msg("Error deleting " + bmof[0] + ": " + e.strerror) + dbc.execute("SELECT fname FROM reg WHERE registration_id = ?", (reg_id,)) + breg = dbc.fetchone() + if breg: + try: + os.unlink(REG_DB_PATH + "/reg/" + breg[0]) + except OSError as e: + log_msg("Error deleting " + breg[0] + ": " + e.strerror) + dbc.execute("DELETE FROM registration WHERE (id = ?)", (reg_id,)) + elif (len(rows) == 0): + log_msg("WARNING: No registration found in the database") + else: + log_msg("ERROR: Cannot delete multiple registrations") + db.commit() + db_close(db) + +def db_get_cimom_opts(cursor, cimom, reg_id): + cur = cursor.execute("SELECT namespace, version FROM cimom_opts \ + WHERE (cimom = ? and registration_id = ?)", (cimom, reg_id)) + row = cur.fetchone() + namespace = row[0] + version = row[1] + return (namespace, version) + +def reregister(cimom): + db = db_init() + dbc_1 = db.cursor() + dbc_2 = db.cursor() + for reg_id_row in dbc_1.execute("SELECT id FROM registration ORDER BY ctime"): + reg_id = str(reg_id_row[0]) + mofs = [] + for row in dbc_2.execute("SELECT fname FROM mof WHERE (registration_id = ?)", (reg_id,)): + mofs.append(REG_DB_PATH + "/mof/" + row[0]) + cur = dbc_2.execute("SELECT fname FROM reg WHERE (registration_id = ?)", (reg_id,)) + row = cur.fetchone() + if row: + reg = REG_DB_PATH + "/reg/" + row[0] + else: + reg = None + if cimom['sfcbd']: + (namespace, version) = db_get_cimom_opts(dbc_2, 'sfcbd', reg_id) + if not namespace is None: + cimom_sel = {'sfcbd': True, 'tog-pegasus': False} + cimom_register(mofs, reg, version, namespace, cimom_sel) + if cimom['tog-pegasus']: + (namespace, version) = db_get_cimom_opts(dbc_2, 'tog-pegasus', reg_id) + if not namespace is None: + cimom_sel = {'sfcbd': False, 'tog-pegasus': True} + cimom_register(mofs, reg, version, namespace, cimom_sel) + db_close(db) + +def list_db(): + db = db_init() + dbc_1 = db.cursor() + dbc_2 = db.cursor() + reg_count = 1 + print "" + for reg_row in dbc_1.execute("SELECT id, ctime FROM registration ORDER BY ctime"): + reg_id = str(reg_row[0]) + ctime = str(reg_row[1]) + print "Registration %(num)s (%(date)s)" % { 'num': reg_count, 'date': ctime } + cur = dbc_2.execute("SELECT group_concat(fname) FROM mof \ + WHERE (registration_id = ?) ORDER BY fname", (reg_id,)) + row = cur.fetchone() + mofs_str = str(row[0]) + print "MOF files: " + mofs_str + cur = dbc_2.execute("SELECT fname FROM reg WHERE (registration_id = ?)", (reg_id,)) + row = cur.fetchone() + if row: + reg_str = str(row[0]) + print "REG file: " + reg_str + else: + print "No REG file." + print "CIMOM specific options" + for row in dbc_2.execute("SELECT cimom, namespace, version FROM cimom_opts \ + WHERE (registration_id = ?) ORDER BY cimom", (reg_id,)): + print "%(cimom)s: Namespace %(ns)s, Registered version %(ver)s" \ + % {'cimom': row[0], 'ns': row[1], 'ver': row[2] } + reg_count += 1 + print "" + db_close(db) + +def main(): + if (len(sys.argv) == 1): + usage() + sys.exit(0) + + try: + opts, args = getopt.gnu_getopt(sys.argv[1:], "hn:c:v:", ["just-mofs", "help"]) + except getopt.GetoptError as e: + print(e) + usage() + sys.exit(1) + + version = None + namespace = DEFAULT_NAMESPACE + cimom_sel = {'sfcbd': False, 'tog-pegasus': False} + db_sel = {'sfcbd': True, 'tog-pegasus': True} + cimom_found = {'sfcbd': False, 'tog-pegasus': False} + just_mofs = False + + for o, a in opts: + if o == "-v": + version = a + elif o == "-n": + namespace = a + elif o == "-c": + if a not in ("sfcbd", "tog-pegasus"): + sys.stderr.write("Not supported cimom: " + a + "\n") + sys.exit(1) + else: + cimom_sel[a] = True + elif o in ("-h", "--help"): + usage() + sys.exit() + elif o == "--just-mofs": + just_mofs = True + else: + assert False, "unhandled option" + + cmd = args[0] + if cmd == "register" or cmd == "unregister": + if (just_mofs and (len(args) < 2)) or ((not just_mofs) and (len(args) < 3)): + sys.stderr.write("Not enough parameters.\n" ) + usage() + sys.exit(1) + if (not just_mofs) and (version is None): + print "Missing -v option" + usage() + sys.exit(1) + elif cmd == "reregister": + if len(args) > 2: + usage() + sys.exit(1) + elif cmd == "list": + if len(args) > 2: + usage() + sys.exit(1) + else: + sys.stderr.write("Unknown command: %s\n" % cmd) + usage() + sys.exit(1) + + # if the user selected a particular cimom and it can't be found + # spit an error and give up + if os.path.isfile("/usr/sbin/sfcbd"): + cimom_found['sfcbd'] = True + elif cimom_sel['sfcbd']: + sys.stderr.write("Sfcbd not detected on system!\n") + sys.exit(1) + if os.path.isfile("/usr/sbin/cimserver"): + cimom_found['tog-pegasus'] = True + elif cimom_sel['tog-pegasus']: + sys.stderr.write("Pegasus not detected on system!\n") + sys.exit(1) + + if just_mofs: + mofs = args[1:] + reg = None + else: + mofs = args[1:-1] + reg = args[-1] + + if not cimom_found['tog-pegasus'] and not cimom_found['sfcbd']: + sys.stderr.write("No cimom installed on the system\n") + sys.exit(1) + + # the user did not select the cimom: lets use all the found ones + if not cimom_sel['sfcbd'] and not cimom_sel['tog-pegasus']: + cimom_sel = cimom_found + else: + # the user has selected some CIMOM: all the registrations including + # the database will happen only for the selected CIMOM + db_sel = cimom_sel + + if cmd == "register": + log_msg("Registering mofs: " + " ".join(mofs) + ", reg: " + str(reg)) + cimom_register(mofs, reg, version, namespace, cimom_sel) + db_register(mofs, reg, version, namespace, db_sel) + elif cmd == "unregister": + log_msg("Unregistering mofs: " + " ".join(mofs) + ", reg: " + str(reg)) + cimom_unregister(mofs, reg, version, namespace, cimom_sel) + db_unregister(mofs, reg, version, namespace, db_sel) + elif cmd == "reregister": + log_msg("Re-registering mofs: " + " ".join(mofs) + ", reg: " + str(reg)) + reregister(cimom_sel) + elif cmd == "list": + list_db() + else: + usage() + sys.exit(1) + +if __name__ == "__main__": + main() -log "STARTING" "$0" "$@" - -JUST_MOFS=0 -optspec=":hn:c:v:-:" - -while getopts "$optspec" optchar; do - case "$optchar" in - -) # long options parsing - case "$OPTARG" in - just-mofs) - JUST_MOFS=1 - ;; - help) - usage; - exit 0; - ;; - *) - if [ "$OPTERR" != 1 ] || [ "${optspec:0:1}" = ":" ]; then - echo "Unknown option --${OPTARG}" >&2 - exit 1 - fi - ;; - esac - ;; - n) - namespace="$OPTARG" - ;; - c) - cimom="$OPTARG" - if [ "$cimom" != "sfcbd" -a "$cimom" != "tog-pegasus" ]; then - echo "Not supported cimom: $cimom" >&2 - exit 1 - fi - ;; - h) - usage; - exit 0; - ;; - v) - version="$OPTARG" - ;; - *) - if [ "$OPTERR" != 1 ] || [ "${optspec:0:1}" = ":" ]; then - echo "Non-option argument: '-${OPTARG}'" >&2 - exit 1 - fi - ;; - esac -done - - -shift $(($OPTIND - 1)) -namespace=${namespace:-$default_namespace} -cimom=${cimom:-all} - -if [ "$JUST_MOFS" -eq 0 -a -z "$version" ]; then - echo "Missing -v option" - usage - exit 1 -fi - -if [ $# -lt 2 ]; -then - usage - exit 1 -fi - -if [ -e /usr/sbin/sfcbd ]; -then - HAS_SFCBD=1 -else - HAS_SFCBD=0 - if [ $cimom = "sfcbd" ]; then - echo "Sfcbd not detected on system!" >&2 - exit 1 - fi -fi - -if [ -e /usr/sbin/cimserver ]; -then - HAS_PEGASUS=1 -else - HAS_PEGASUS=0 - if [ $cimom = "tog-pegasus" ]; then - echo "Pegasus not detected on system!" >&2 - exit 1 - fi -fi - -# TODO: check if at least one server is installed -CMD=$1 -shift - -# parse the reg and mofs - use $@ and remove the last item -declare -a ARGS=("$@") -if [ $JUST_MOFS -eq 0 ]; -then - LEN=$(( ${#ARGS[@]} -1 )) - REG=${ARGS[$LEN]} - MOFS=(${ARGS[@]:0:$(($LEN))}) -else - MOFS=("$@") -fi - -case $CMD in - register) - register $REG ${MOFS[@]} - ;; - unregister) - unregister $REG ${MOFS[@]} - ;; - **) - usage - exit 1 -esac - -exit 0 -- cgit