testindications.java

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

//%2006////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation, The Open Group.
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// EMC Corporation; Symantec Corporation; The Open Group.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//%/////////////////////////////////////////////////////////////////////////////
package Client;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Enumeration;
import java.util.Vector;
import org.pegasus.jmpi.CIMClass;
import org.pegasus.jmpi.CIMClient;
import org.pegasus.jmpi.CIMException;
import org.pegasus.jmpi.CIMInstance;
import org.pegasus.jmpi.CIMNameSpace;
import org.pegasus.jmpi.CIMObjectPath;
import org.pegasus.jmpi.CIMProperty;
import org.pegasus.jmpi.CIMValue;
import org.pegasus.jmpi.UnsignedInt16;
import org.pegasus.jmpi.UnsignedInt32;
import org.pegasus.jmpi.UnsignedInt64;

public class testIndications
{
   private final static String className           = "JMPIExpIndication";
   private final static String nameSpaceClass      = "root/SampleProvider";
   private final static String nameSpaceInterOp    = "root/PG_InterOp";
   private final static String nameSpaceCIMV2      = "root/cimv2";

   private static boolean      DEBUG               = false;
   private static int          iNumIndications     = 10;
   private static boolean      DELETE              = true;

   private static boolean      fBugExistsExecQuery = false;

   /**
    * This returns the group name.
    *
    * @return String "class" testcase belongs in.
    */
   public String getGroup ()
   {
      return "instances";
   }

   public void setDebug (boolean fDebug)
   {
      DEBUG = fDebug;
   }

   public boolean main (String args[], CIMClient cimClient)
   {
      boolean fExecuted = false;

      for (int i = 0; i < args.length; i++)
      {
         if (args[i].equalsIgnoreCase ("debug"))
         {
            setDebug (true);
         }
         else if (args[i].equalsIgnoreCase ("noDebug"))
         {
            DEBUG = false;
         }
         else if (args[i].equalsIgnoreCase ("numIndications"))
         {
            if (i + 1 < args.length)
            {
               iNumIndications = new Integer (args[i+1]).intValue ();

               i++;
            }
         }
         else if (args[i].equalsIgnoreCase ("delete"))
         {
            DELETE = true;
         }
         else if (args[i].equalsIgnoreCase ("noDelete"))
         {
            DELETE = false;
         }
         else if (args[i].equalsIgnoreCase ("BugExistsExecQuery"))
         {
            fBugExistsExecQuery = true;
         }
      }

      if (!fExecuted)
          return runTests (cimClient);

      return false;
   }

   private static CIMObjectPath createInstance (CIMClient   cc,
                                                CIMInstance ciToCreate,
                                                String      nameSpace)
      throws Exception
   {
      CIMObjectPath copToCreate   = null;
      Vector        keyValuePairs = null;
      CIMInstance   ciToReturn    = null;
      CIMObjectPath copToReturn   = null;

      try
      {
         if (DEBUG)
         {
            System.err.println ("testIndications::createInstance: ciToCreate = " + ciToCreate);
         }

         keyValuePairs = ciToCreate.getKeyValuePairs ();

         if (DEBUG)
         {
            System.err.println ("testIndications::createInstance: keyValuePairs = " + keyValuePairs);
         }

         if (keyValuePairs.size () == 0)
         {
////////////@BUG
////////////throw new Exception ("No keys returned for " + ciToCreate.getClassName ());

            keyValuePairs = ciToCreate.getProperties ();

            if (DEBUG)
            {
               System.err.println ("testIndications::createInstance: no keyValuePairs returned.  switching to keyValuePairs = " + keyValuePairs);
            }

            for (int i = 0; i < keyValuePairs.size (); i++)
            {
               CIMProperty cp = (CIMProperty)keyValuePairs.elementAt (i);
               CIMValue    cv = cp.getValue ();
               System.err.println (cv.isArray ());
            }
         }

/////////@BUG
/////////copToCreate = new CIMObjectPath (ciToCreate,
/////////                                 nameSpace);

         copToCreate = new CIMObjectPath (ciToCreate.getClassName (),
                                          keyValuePairs);

         copToCreate.setNameSpace (nameSpace);

         if (DEBUG)
         {
            System.err.println ("testIndications::createInstance: copToCreate = " + copToCreate);
         }

         cc.createInstance (copToCreate,
                            ciToCreate);
      }
      catch (CIMException e)
      {
         if (e.getID ().equals ("CIM_ERR_ALREADY_EXISTS"))
         {
            if (DEBUG)
            {
               System.err.println ("testIndications::createInstance: Instance already exists calling getInstance (" + copToCreate + ")");
            }
         }
         else
         {
            System.err.println ("testIndications::createInstance: Caught " + e);

            throw e;
         }
      }

      ciToReturn = cc.getInstance (copToCreate,
                                   false);

      keyValuePairs = ciToReturn.getKeyValuePairs ();
      if (keyValuePairs.size () == 0)
      {
         keyValuePairs = ciToReturn.getProperties ();
      }

      copToReturn = new CIMObjectPath (ciToReturn.getClassName (),
                                       keyValuePairs);

      copToReturn.setNameSpace (nameSpace);

      return copToReturn;
   }

   private static String getHostname ()
   {
      try
      {
         InetAddress addr = InetAddress.getLocalHost ();

         // Get IP Address
         byte[] ipAddr = addr.getAddress ();

         // Get the canonical hostname
         return addr.getCanonicalHostName ();
      }
      catch (UnknownHostException e)
      {
      }

      return "localhost";
   }

   private static String getSystemName (CIMClient cc)
   {
      Enumeration   enm;
      CIMObjectPath cop;

      try
      {
         cop = new CIMObjectPath ("PG_NameSpace", "root/PG_InterOp");
         enm = cc.enumInstances (cop,
                                 true,   // deepInheritance
                                 true);  // localOnly

         if (DEBUG)
         {
            System.out.println ("testIndications::getSystemName cop = " + cop);
            System.out.println ("testIndications::getSystemName enm = " + enm);
         }

         if (  enm != null
            && enm.hasMoreElements ()
            )
         {
            CIMInstance ci = (CIMInstance)enm.nextElement ();
            CIMProperty cp = null;
            CIMValue    cv = null;

            if (DEBUG)
            {
               System.out.println ("testIndications::getSystemName ci = " + ci);
            }

            if (ci != null)
            {
               cp = ci.getProperty ("SystemName");
            }

            if (DEBUG)
            {
               System.out.println ("testIndications::getSystemName cp = " + cp);
            }

            if (cp != null)
            {
               cv = cp.getValue ();
            }

            if (DEBUG)
            {
               System.out.println ("testIndications::getSystemName cv = " + cv);
            }

            if (cv != null)
            {
               return (String)cv.getValue ();
            }
         }
      }
      catch (Exception e)
      {
         e.printStackTrace ();
      }

      return getHostname ();
   }

   private static UnsignedInt64 findNextIndicationNumber (CIMClient cc)
      throws CIMException
   {
      for (int i = 1; i < 1000; i++)
      {
         UnsignedInt64 ui64ToTry = new UnsignedInt64 (new Integer (i).toString ());
         try
         {
            CIMObjectPath copInstance   = null;
            CIMInstance   ciIndication  = null;
            Vector        keyValuePairs = new Vector ();

            keyValuePairs.addElement (new CIMProperty ("InstanceId",
                                                       new CIMValue (ui64ToTry)));

            copInstance = new CIMObjectPath (className,
                                             keyValuePairs);
            copInstance.setNameSpace (nameSpaceClass);

            ciIndication = cc.getInstance (copInstance,
                                           false);
         }
         catch (CIMException e)
         {
            if (e.getID ().equals ("CIM_ERR_NOT_FOUND"))
            {
               return ui64ToTry;
            }
            else if (!e.getID ().equals ("CIM_ERR_ALREADY_EXISTS"))
            {
               throw e;
            }
         }
      }

      return new UnsignedInt64 ("1000");
   }

   private static CIMObjectPath testCreateClassIndicationFilter (CIMClient cc)
      throws Exception
   {
      CIMClass      ccFilter  = cc.getClass (new CIMObjectPath ("CIM_IndicationFilter",
                                                                nameSpaceInterOp),
                                             false);
      CIMInstance   ciFilter  = ccFilter.newInstance ();
      CIMObjectPath copFilter = null;

      ciFilter.setProperty ("CreationClassName",
                            new CIMValue ("CIM_IndicationFilter"));
      ciFilter.setProperty ("SystemCreationClassName",
                            new CIMValue ("CIM_ComputerSystem"));
      ciFilter.setProperty ("Name",
                            new CIMValue ("classCreationFilter"));
      ciFilter.setProperty ("SystemName", new CIMValue (getSystemName (cc)));
      ciFilter.setProperty ("SourceNamespace", new CIMValue (nameSpaceClass));
      ciFilter.setProperty ("Query",
                            new CIMValue ("SELECT * FROM " + className));
//////                      new CIMValue ("SELECT * FROM CIM_ClassCreation WHERE ClassDefinition ISA " + className));
      ciFilter.setProperty ("QueryLanguage",
                            new CIMValue ("DMTF:CQL"));

      try
      {
         copFilter = createInstance (cc,
                                     ciFilter,
                                     nameSpaceInterOp);
      }
      catch (Exception e)
      {
         System.err.println ("testIndications::testCreateClassIndicationFilter: Exception: " + e);

         e.printStackTrace ();
      }

      if (DEBUG)
      {
         System.err.println ("testIndications::testCreateClassIndicationFilter: copFilter = " + copFilter);
      }

      if (copFilter != null)
      {
         System.out.println ("SUCCESS: testCreateClassIndicationFilter");
      }
      else
      {
         System.out.println ("FAIL: testCreateClassIndicationFilter");
      }

      return copFilter;
   }

   private static CIMObjectPath testCreateClassIndicationHandler (CIMClient cc)
      throws Exception
   {
      CIMClass      ccHandler  = null;
      CIMInstance   ciHandler  = null;
      CIMObjectPath copHandler = null;

      if (true)
      {
         // CIM_IndicationHandlerCIMXML
         ccHandler = cc.getClass (new CIMObjectPath ("CIM_IndicationHandlerCIMXML",
                                                     nameSpaceInterOp),
                                  false);
         ciHandler = ccHandler.newInstance ();

         ciHandler.setProperty ("CreationClassName",
                                new CIMValue ("CIM_IndicationHandlerCIMXML"));
         ciHandler.setProperty ("SystemName", new CIMValue (getSystemName (cc)));
         ciHandler.setProperty ("Destination", new CIMValue ("http://" + getHostname () + ":2005/CIMListener/Pegasus_SimpleDisplayConsumer"));
      }
      else if (false)
      {
         // CIM_ListenerDestinationCIMXML
      }
      else if (false)
      {
         // PG_IndicationHandlerSNMPMapper
      }
      else if (false)
      {
         // PG_ListenerDestinationSystemLog
         ccHandler = cc.getClass (new CIMObjectPath ("PG_ListenerDestinationSystemLog",
                                                     nameSpaceInterOp),
                                  false);
         ciHandler = ccHandler.newInstance ();

         ciHandler.setProperty ("CreationClassName",
                                new CIMValue ("PG_ListenerDestinationSystemLog"));