WWNDescription.java

Go to the documentation of this file.

/* smallfoot.org is owned by allan.clark */
package org.smallfoot.wwn;

import gnu.getopt.Getopt;
import gnu.getopt.LongOpt;

/**
 * @file
 */

/**
 * In situations where nicknames simply are not present, but we need descriptors in short-order,
 * the "--wwn=" or "-w" ooption can be used to get a description of what the most likely Nickname
 * would be.  For example, "java -jar wwndesc.jar -w 5006048ACCC86A32" results in "Symm-182500953-05bA"
 * matching http://www.emcstorageinfo.com/2007/08/how-to-decode-symmetrix-world-wide.html
 * Note that --briefestimate and --nobriefestimate configure for more brief estimate/suggested nicknames
 *
 * @section Examples
 *
 *  java -jar vict.jar --wwn 500610601234567
 *
 *  java -jar vict.jar --briefestimate --wwn 500610601234567
 *
 *  java -jar vict.jar --nobriefestimate --wwn 5000097301234564
 *
 * @section Known Issues
 */

public class WWNDescription
{
    public boolean briefWWNEstimate = false;    /**< setting to "true" via the "--briefestimate" commandline causes all descriptions later requested in getWWNDescriptor(String) to be "brief" (more concise)  @see WWNDesc#toString() */

    /** test case: this matches a single item known to exist in the Demo Database */
    public class DemoTestDesc extends WWNDesc
    {
        /** @copydoc WWNDesc#WWNDesc(String) */
        public DemoTestDesc(String wwn)
        {
            super(wwn);
        }
        /**
             * generates a test description or alias for this test class
         *
         * @returns "TestDevice" always
             */
        public String toString()
        {
            String res = super.toString();
            if (null == res) res = "";

            return res + "TestDevice";
        }
    }

    /**
     * Iterates WWNDescription decendents looking for which will accept responsibility, and if so, returns the instance it generates as a descriptor
     *
     * @return new instance of WWNDesc descendent, or null if no descendents accept responsibility to describe or provide an alias for that WWN
     *
     * @param val WWN to check
     */
    public WWNDesc getWWNDescriptor(String val)
    {
        return getWWNDescriptor(val,true);
    }

    /**
     * Iterates WWNDescription decendents looking for which will accept responsibility, and if so, returns the instance it generates as a descriptor
     *
     * @return new instance of WWNDesc descendent, or null if no descendents accept responsibility to describe or provide an alias for that WWN
     *
     * @param val WWN to check
     * @param provideBase whether to provide a bogus WWNDesc instance rather than a null
     */
    public WWNDesc getWWNDescriptor(String val, boolean provideBase)
    {
        return getWWNDescriptor(val, provideBase, DevRole.TARGETbit);
    }
    /**
     * @copydoc #getWWNDescriptor(String, boolean)
     *
     * @param role DevRole to check for
     */
    public WWNDesc getWWNDescriptor(String val, boolean provideBase, DevRole role)
    {
        return getWWNDescriptor(val, provideBase, role.value);
    }
    /**
     * @copydoc #getWWNDescriptor(String, boolean, DevRole)
     */
    public WWNDesc getWWNDescriptor(String val, boolean provideBase, int role)
    {
        val = val.replaceAll(":","").toLowerCase();
        WWNDesc d = null;

        if (null != (d = EMCSymmetrixDescription.getDesc(/* strong*/ false, briefWWNEstimate, val, role)))
            return d;
        else if (null != (d = EMCClariionDescription.getDesc(/* strong*/ false, briefWWNEstimate, val, role)))
            return d;
        else if (null != (d = EMCVMAXDescription.getDesc(/* strong*/ false, briefWWNEstimate, val, role)))
            return d;
        else if (null != (d = EMCVPLEXDescription.getDesc(/* strong*/ false, briefWWNEstimate, val, role)))
            return d;
        else if (null != (d = PureStorageDescription.getDesc(/* strong*/ false, briefWWNEstimate, val, role)))
            return d;
        else if (null != (d = NetAppDescription.getDesc(/* strong*/ false, briefWWNEstimate, val, role)))
            return d;
        else if (null != (d = HDSVSPDescription.getDesc(/* strong*/ false, briefWWNEstimate, val, role)))
            return d;
        else if (null != (d = IBMDescription.getDesc(/* strong*/ false, briefWWNEstimate, val, role)))
            return d;
        else if (null != (d = HP3ParDescription.getDesc(/* strong*/ false, briefWWNEstimate, val, role)))
            return d;
        else if (null != (d = HPDotHillDescription.getDesc(/* strong*/ false, briefWWNEstimate, val, role)))
            return d;
        else if (null != (d = OraclePillarDescription.getDesc(/* strong*/ false, briefWWNEstimate, val, role)))
            return d;
        else if (null != (d = SymbiosDescription.getDesc(/* strong*/ false, briefWWNEstimate, val, role)))
            return d;

        else if (null != (d = CiscoSwitchDescription.getDesc(/* strong*/ false, briefWWNEstimate, val, role)))
            return d;
        else if (null != (d = CiscoUCSServerDescription.getDesc(/* strong*/ false, briefWWNEstimate, val, role)))
            return d;
        else if (null != (d = AIXLPARServerDescription.getDesc(/* strong*/ false, briefWWNEstimate, val, role)))
            return d;
        else if (null != (d = HPVirtualServerDescription.getDesc(/* strong*/ false, briefWWNEstimate, val, role)))
            return d;

        else if (val.toLowerCase().equalsIgnoreCase("200100110d123400"))
            return new DemoTestDesc(val);

        else if (provideBase)
            return new WWNDesc(val);
        else
            return null;
    }



    /** usage messages are useful to those of us with short memories as well (hey, I just need to add swap!)
     *
     * @param proc name of the process or program (ie wwndesc)
     */
    public void usage(String proc)
    {
        System.out.println("Usage: "+proc+" -V|--version|-H|--help");

        System.out.println("     : "+proc+" [--briefestimate] [--device[=switch|initiator|target] [--wwn|-w <WWN> [--port|-p <WWN>] [--wwn|-w <WWN> [--wwn|-w <WWN>]]]");
        System.out.println("   ie: "+proc+" -w 2100000b08123450");
        System.out.println("   ie: "+proc+" --wwn 2100000b08123450");
        System.out.println("   ie: "+proc+" --briefestimate -w 2100000b08123450");
        System.out.println("   ie: "+proc+" -w 21:00:00:0b:08:12:34:50");
        System.out.println("   ie: "+proc+" -w 21:00:000b08:123450");
        System.out.println("   ie: "+proc+" -p 21:00:00:0b:08:12:34:50");
        System.out.println("   ie: "+proc+" --device=switch --port 21:00:000b08:123450");
    }



    /**
     * Main function, as you can tell.
     *
     * this function merely parses the command-line to dispatch actions to the meat of the meal above.
     * I'm using an actual GetOpt because, yes, I'm a UNIX/C hack, re-using 3-decades-old knowledge,
     * but this also preserves both extensibility and the ability to use longopts in scripts as a
     * way to self-document what the tool's doing.
     *
     * No real intelligence herein except the parse-and-redirect action.
     *
     * @param args commandline arguments passed in by the JRE
     */
    public static void main(String args[])
    {
        WWNDescription m = new WWNDescription();
        int role = DevRole.TARGETbit;

        java.util.Vector<LongOpt> options = new java.util.Vector();
        /**
         * Always always ALWAYS provide a quick reference and a version output
         *
         * @cmdopt -H|--help Show a simple help screen as a reminder of options which are understood by the application
         * @cmdopt @code java -jar wwndesc.jar --help @endcode
         *
         * @cmdopt -V|--version Show the current release version for reference
         * @cmdopt @code java -jar wwndesc.jar --version
         *  1.0-76 @endcode
         */

        /* Always always ALWAYS provide a quick reference and a version output */
        options.add(new LongOpt("help", LongOpt.NO_ARGUMENT, null, 'H'));
        options.add(new LongOpt("version", LongOpt.NO_ARGUMENT, null, 'V'));

        options.add(new LongOpt("device", LongOpt.REQUIRED_ARGUMENT, null, 'd'));
        options.add(new LongOpt("port", LongOpt.REQUIRED_ARGUMENT, null, 'p'));
        options.add(new LongOpt("wwn", LongOpt.REQUIRED_ARGUMENT, null, 'w'));
        options.add(new LongOpt("briefestimate", LongOpt.NO_ARGUMENT, null, 0x1000));
        options.add(new LongOpt("nobriefestimate", LongOpt.NO_ARGUMENT, null, 0x1001));

        org.smallfoot.getopt.GetOpt g = new org.smallfoot.getopt.GetOpt("wwndesc", args, options);

        int c;
        while ((c = g.getopt()) != -1)
        {
            switch(c)
            {
            /**
            * @cmdopt --briefestimate change to shorter, more brief estimates or descriptions
            * @cmdopt --nobriefestimate change to longer, more detailed estimates (default)
            */
            case 0x1000: /* switch to brief WWNDescs */
                m.briefWWNEstimate = true;
                break;
            case 0x1001: /* switch to verbose WWNDescs */
                m.briefWWNEstimate = false;
                break;

            /**
            * @cmdopt -d|--device(=) used mainly in testing, this option allows setting a device type
            * @cmdopt { init(iator) | server | storage | switch | targ(et) }
            */
            case 'd': /* set a device type */
            {
                if (null == g.getOptarg()) role = DevRole.TARGETbit;

                else if (g.getOptarg().toLowerCase().startsWith("targ")) role = DevRole.TARGETbit;
                else if (g.getOptarg().equalsIgnoreCase("storage")) role = DevRole.TARGETbit;
                else if (g.getOptarg().equalsIgnoreCase("server")) role = DevRole.INITIATORbit;
                else if (g.getOptarg().toLowerCase().startsWith("init")) role = DevRole.TARGETbit;
                else if (g.getOptarg().equalsIgnoreCase("switch")) role = DevRole.SWITCHbit;
            }
            break;

            /**
            * @cmdopt -p|--port used mainly in testing, this option shows the port-uniqueness of a device (which can be leveraged for de-duping an alias)
            */
            case 'p': /* inspect a WWPN's unique port */
            {
                WWNDesc wwn;
                if ((null == g.getOptarg()) || (16 != g.getOptarg().replaceAll(":","").length()))
                    System.out.println("no result: parameter "+g.getOptarg()+" needs to be a 16-digit hexadecimal");
                else if (null == (wwn = m.getWWNDescriptor(g.getOptarg(),true,role)))
                    System.out.println("no result: WWN "+g.getOptarg()+" has no descriptor");
                else System.out.println(wwn.descPort());
            }
            break;

            /**
            * @cmdopt -w|--wwn query for a description of a WWPN
            * @cmdopt @code java -jar wwndesc.jar --wwn 5000097201234567
            * VMax-HK194618641-10fD @endcode
            * @cmdopt @code java -jar wwndesc.jar --briefestimate --wwn 5000097201234567
            * VMax-18641-10fD @endcode
            */
            case 'w': /* inspect a WWN */
            {
                WWNDesc wwn;
                if ((null == g.getOptarg()) || (16 != g.getOptarg().replaceAll(":","").length()))
                    System.out.println("no result: parameter "+g.getOptarg()+" needs to be a 16-digit hexadecimal");
                else if (null == (wwn = m.getWWNDescriptor(g.getOptarg(),true,role)))
                    System.out.println("no result: WWN "+g.getOptarg()+" has no descriptor");
                else System.out.println(wwn.toString());
            }
            break;

            /*
             * Follows is the "house-keeping": versions, usage, and the catch-all for bad options.
             */
            case 'V':   // print the version and quit
            {
                System.out.println(g.consistentVersion("1.0-76"));
                return;
            }

            default:
            case '?':
            // during build, this is just a dump of options; in shipping, this falls-thru to usage.
            //System.out.println("option \""+c+"\" selected");
            //System.out.println("long index = "+g.getLongind());

            case 'H':
                m.usage(g.progname());
                break;
            }
        }

        /*
         * I had to add this since there seems to be a lack of dropping out when the options are done,
         * or a delay huge enough that my impatience is triggered (ie 2 seconds or more!).  Maybe
         * invesitgate this further when there's more time, as this is redundant.
         */
        java.lang.System.exit(0);
    }
}