test

WBEMfor Solaris on Sun Developer's Guide

Advanced Programming Topics

This section describes advanced programming operations and operations that you would use less frequently.

Creating a Namespace

The installation compiles the standard CIM MOF files into the default namespaces, /root/cimv2 and /root/security. If you create a new namespace, you must compile the appropriate CIM MOF files into the new namespace before creating objects in it. For example, if you plan to create classes that use the standard CIM elements, compile the CIM Core Schema into the namespace. If you plan to create classes that extend the CIM Application Schema, compile the CIM Application into the namespace.

Example -- Creating a Namespace

The code segment in Example 6-14 uses a two-step process to create a namespace within an existing namespace.

Example 6-14 Creating a Namespace (CIMNameSpace)

{
/*Creates a namespace object on the client, which stores the 
parameters passed to it. args[0] contains the host name (for example,
myhost); args[1] contains the namespace (for example,
the toplevel directory.) */
CIMNameSpace cns = new CIMNameSpace (args[0], args[1]); 
/* Connects to the CIM Object Manager and passes it the 
namespace object (cns) containing the namespace parameters. */
CIMClient cc = new CIMClient (cns);	
/* Passes to the CIM Object Manager another namespace object that 
contains a null string (host name) and args[2], the name of a name 
space (for example, secondlevel). */
CIMNameSpace cop = new CIMNameSpace("", args[2]);
/* Creates a new namespace called secondlevel under the
toplevel namespace on myhost./*
cc.createNameSpace(cop);
}

Deleting a Namespace

Use the deleteNameSpace method to delete a namespace.

Example -- Deleting a Namespace

The code segment in Example 6-15 first creates a namespace and then uses the deleteNameSpace method to delete it.

Example 6-15 Deleting a Namespace (deleteNameSpace)

{
/* Creates a namespace object on the client to contain the 
namespace parameters, args[0] (host name) and args[1] 
(namespace name). */ 
 
CIMNameSpace cns = new CIMNameSpace (args[0], args[1]);
 
/* Connects to the CIM Object Manager and passes it 
the namespace object. */
 
CIMClient cc = new CIMClient (cns); 
 
/* Passes the CIM Object Manager a namespace object containing a null
host argument (we are not changing the CIM Object Manager host) and
the name of the namespace to be deleted. */
 
CIMNameSpace cop = new CIMNameSpace("", args[2]); 
 
/* Delete namespace cop. */
 
cc.deleteNameSpace(cop);

Creating a Base Class

Applications can create classes using either the MOF language or the client APIs. If you are familiar with MOF syntax, use a text editor to create a MOF file and then use the MOF Compiler to compile it into Java classes. This section describes how to use the client APIs to create a base class.

Use the CIMClass class to create a Java class representing a CIM class. To declare the most basic class, you need only specify the class name. Most classes include properties that describe the data of the class. To declare a property, include the property's data type, name, and an optional default value. The property data type must be an instance of CIMDataType (one of the predefined CIM data types).

A property can have a key qualifier, which identifies it as a key property. A key property uniquely defines the instances of the class. Only keyed classes can have instances. Therefore, if you do not define a key property in a class, the class can only be used as an abstract class.

If you define a key property in a class in a new namespace, you must first compile the core MOF files into the namespace. The core MOF files contain the declarations of the standard CIM qualifiers, such as the key qualifier. For more information on MOF files, see Chapter 3, MOF Compiler.

Class definitions can be more complicated, including such MOF features as aliases, qualifiers, and qualifier flavors.

Example -- Creating a CIM Class

The example in Example 6-16 creates a new CIM class in the default namespace (/root/cimv2) on the local host. This class has two properties, one of which is the key property for the class. The example then uses the newInstance method to create an instance of the new class.

Example 6-16 Creating a CIM Class (CIMClass)

{
/* Connect to the /root/cimv2 namespace 
on the local host and create a new class called myclass */
// Connect to the default namespace on local host.
CIMClient cc = new CIMClient(); 
// Construct a new CIMClass object 
CIMClass cimclass = new CIMClass();
// Set CIM class name to myclass. 
cimclass.setName("myclass"); 
// Construct a new CIM property object
CIMProperty cp = new CIMProperty(); 
// Set property name
cp.setName("keyprop"); 
// Set property type
cp.setType(CIMDatatype.getpredefined(CIMDataType.STRING); 
// Construct a new CIM Qualifier object
CIMQualifier cq = new CIMQualifier(); 
// Set the qualifier name
cq.setName("key"); 
// Add the new key qualifier to the property
cp.addQualfiier(cq); 
/* Create an integer property initialized to 10 */
// Construct a new CIM property object
CIMProperty mp = new CIMProperty(); 
// Set property name to myprop
mp.setName("myprop"); 
// Set property type
mp.setType(CIMDatatype.getpredefined(CIMDataType.INTEGER); 
// Initialize myprop to 10 
mp.setValue(CIMValue.setValue(10));
 
/* Add the new properties to myclass and call the CIM Object Manager 
to create the class. */
// Add the key property to class object
cimclass.addProperty(cp); 
// Add the integer property to class object
cimclass.addProperty(mp); 
 
/* Connect to the CIM Object Manager and pass the new class */
cc.setClass(new CIMObjectPath(),cimclass); 
// Pass the new class to the CIM Object Manager
ci = cc.newInstance(); 
// Create a new CIM instance of myclass
// If the client connection is open, close it.
		if(cc != null) {
            cc.close();
}

Deleting a Class

Use the CIMClient deleteClass method to delete a class. Deleting a class removes the class, its subclasses, and all instances of the class; it does not delete any associations that refer to the deleted class.

Example -- Deleting a Class

The example in Example 6-17 uses the deleteClass interface to delete a class.

Example 6-17 Deleting a Class (deleteClass)

 
import java.rmi.*;
import com.sun.wbem.client.CIMClient;
import com.sun.wbem.cim.CIMInstance;
import com.sun.wbem.cim.CIMValue;
import com.sun.wbem.cim.CIMProperty;
import com.sun.wbem.cim.CIMNameSpace;
import com.sun.wbem.cim.CIMObjectPath;
import com.sun.wbem.cim.CIMClass;
import com.sun.wbem.cim.CIMException;
import java.util.Enumeration;
 
/**
 * Deletes the class specified in the command line. Works in the default
 * namespace root\cimv2.
 */
public class DeleteClass {
    public static void main(String args[]) throws CIMException {
        CIMClient cc = null;
        try {
            CIMNameSpace cns = new CIMNameSpace(args[0]);
 
            cc = new CIMClient(cns);
 
            CIMObjectPath cop = new CIMObjectPath(args[1]);
            cc.deleteClass(cop);
        }
        catch (Exception e) {
            System.out.println("Exception: "+e);
        }
        if(cc != null) {
            cc.close();
        }
    }
}

Working with Qualifier Types and Qualifiers

A CIM qualifier is an element that characterizes a CIM class, instance, property, method, or parameter. Qualifiers have the following attributes:

In Managed Object Format syntax, each CIM qualifier must have a CIM qualifier type declared in the same MOF file. Qualifiers do not have a scope attribute. Scope indicates which CIM elements can use the qualifier. Scope can only be defined in the qualifier type declaration; it cannot be changed in a qualifier.

The following sample code shows the MOF syntax for a CIM qualifier type declaration. This statement defines a qualifier type named key, with a Boolean data type (default value false), which can describe only a property and a reference to an object. The DisableOverride flavor means that key qualifiers cannot change their value. 

Qualifier Key : boolean = false, Scope(property, reference), 
								Flavor(DisableOverride);

The following sample code shows the MOF syntax for a CIM qualifier. In this sample MOF file, key and description are qualifiers for the property test. The property data type is an integer with the value a. 

{
[key, Description("test")]
int a
}

Example -- Getting CIM Qualifiers

The code segment in Example 6-18 uses the CIMQualifier class to identify the CIM qualifiers in a vector of CIM elements. The example returns the property name, value, and type for each CIM Qualifier.

A qualifier flavor is a flag that governs the use of a qualifier. Flavors describe rules that specify whether a qualifier can be propagated to derived classes and instances and whether or not a derived class or instance can override the qualifier's original value.

Example 6-18 Getting CIM Qualifiers (CIMQualifier)

	
...
 
    } else if (tableType == QUALIFIER_TABLE) {
		CIMQualifier prop = (CIMQualifier)cimElements.elementAt(row);
		if (prop != null) {
		    if (col == nameColumn) {
			return prop.getName();
		    } else if (col == typeColumn) {
			CIMValue cv = prop.getValue();
			if (cv != null) {
			    return cv.getType().toString();
			} else {
			    return "NULL";			      }
		  } 
 
...

Example -- Setting CIM Qualifiers

Example 6-19 is a code segment that sets a list of CIM qualifiers for a new class to the qualifiers in its superclass.

Example 6-19 Set Qualifiers (setQualifiers)

   ...
	try 	{
	    	cimSuperClass = cimClient.getClass(new CIMObjectPath(scName));
	    	Vector v = new Vector();
	    	for (Enumeration e = cimSuperClass.getQualifiers().elements();
					e.hasMoreElements();) { 
					CIMQualifier qual = (CIMQualifier)((CIMQualifier)e.nextElement()).clone();
					v.addElement(qual);
	    	}
	    	cimClass.setQualifiers(v);
		} catch (CIMException exc) {
	    	return;
		}
}