Пример #1
0
void IndicationFormatter::validateTextFormatParameters (
    const CIMPropertyList & propertyList,
    const CIMClass & indicationClass,
    const Array<String> & textFormatParams)
{
    PEG_METHOD_ENTER (TRC_IND_FORMATTER,
	"IndicationFormatter::validateTextFormatParameters");

    Array <String> indicationClassProperties;
    String exceptionStr;

    // All the properties are selected
    if (propertyList.isNull ())
    {
       for (Uint32 i = 0; i < indicationClass.getPropertyCount (); i++)
       {
	   indicationClassProperties.append(
	       indicationClass.getProperty (i).getName ().getString());
       }
    }
    // partial properties are selected
    else
    {
        Array<CIMName> propertyNames = propertyList.getPropertyNameArray();

	for (Uint32 j = 0; j < propertyNames.size(); j++)
	{
	    indicationClassProperties.append(propertyNames[j].getString());
	}
    }

    // check if the textFormatParams is contained in the
    // indicationClassProperties
    for (Uint32 k = 0; k < textFormatParams.size(); k++)
    {
        if (!Contains(indicationClassProperties, textFormatParams[k]))
	{
	    // The property name in TextFormatParameters is not
	    // included in the select clause of the associated filter query
	    MessageLoaderParms parms(
	    "IndicationFormatter.IndicationFormatter._MSG_MISS_MATCHED_PROPERTY_NAME",
	    "The property name $0 in $1 does not match the properties in the select clause",
	    textFormatParams[k],
	    _PROPERTY_TEXTFORMATPARAMETERS.getString());

	    exceptionStr.append(MessageLoader::getMessage(parms));

	    PEG_METHOD_EXIT();
	    throw PEGASUS_CIM_EXCEPTION (
		CIM_ERR_INVALID_PARAMETER, exceptionStr);
	}
    }

    PEG_METHOD_EXIT();
}
Пример #2
0
static CIMPropertyList getList(const char** l) {
  CIMPropertyList pl;
  if (l) {
    Array<CIMName> n;
    while (*l) {
      n.append(*l++);
    }
    pl.set(n);
  }
  return pl;
}
Пример #3
0
void test03()
{
    //
    // Define query:
    //
    
    const char TEXT[] = 
	"SELECT *\n"
	"FROM AnotherClass\n";

    //
    //  Will test WQLParser::parse(const String&, WQLSelectStatement&)
    //  and WQLParser::parse(const char*, WQLSelectStatement&) forms
    //
    String text (TEXT);
    if (verbose)
    {
        cout << text << endl;
    }

    // 
    // Parse the text:
    //

    WQLSelectStatement statement;

    try
    {
	WQLParser::parse(text, statement);
        if (verbose)
        {
	    statement.print();
        }

        //
        //  Test WQLSelectStatement functions
        //
        assert (statement.getClassName().equal ("AnotherClass"));
        assert (statement.getAllProperties());
        CIMPropertyList propList = statement.getSelectPropertyList();
        assert (propList.isNull());
        assert (!statement.hasWhereClause());
        assert (statement.getWherePropertyNameCount() == 0);
        CIMPropertyList wherePropList = statement.getWherePropertyList();
        assert (!wherePropList.isNull());
        assert (wherePropList.size() == 0);
    }
    catch (Exception& e)
    {
	cerr << "Exception: " << e.getMessage() << endl;
	exit(1);
    }
}
CIMPropertyList WQLSelectStatementRep::getPropertyList(
        const CIMObjectPath& inClassName)
{
    if(_ctx == NULL){
        MessageLoaderParms parms(
            "WQL.WQLSelectStatementRep.QUERY_CONTEXT_IS_NULL",
            "Trying to process a query with a NULL Query Context.");
      throw QueryRuntimeException(parms);
    }

    if(_allProperties)
     return CIMPropertyList();

    CIMName className = inClassName.getClassName();
    if (className.isNull())
    {
     // If the caller passed in an empty className, then the
     // FROM class is to be used.
     className = _className;
    }

    // check if inClassName is the From class
    if(!(className == _className)){
        // check if inClassName is a subclass of the From class
        if(!_ctx->isSubClass(_className,className)){
            MessageLoaderParms parms(
                "WQL.WQLSelectStatementRep.CLASS_NOT_FROM_LIST_CLASS",
                "Class $0 does not match the FROM class or any of its"
                    " subclasses.",
                className.getString());
            throw QueryRuntimeException(parms);
        }
    }

    Array<CIMName> names =
            getWherePropertyList(inClassName).getPropertyNameArray();
    Array<CIMName> selectList =
            getSelectPropertyList(inClassName).getPropertyNameArray();

    // check for duplicates and remove them
    for(Uint32 i = 0; i < names.size(); i++){
        for(Uint32 j = 0; j < selectList.size(); j++){
            if(names[i] == selectList[j])
                selectList.remove(j);
            }
    }

    names.appendArray(selectList);
    CIMPropertyList list = CIMPropertyList();
    list.set(names);
    return list;
}
Пример #5
0
void PG_TestPropertyTypes::modifyInstance(
    const OperationContext& context,
    const CIMObjectPath& instanceReference,
    const CIMInstance& instanceObject,
    const Boolean includeQualifiers,
    const CIMPropertyList& propertyList,
    ResponseHandler& handler)
{
    // This provider only allows partial instance modification for the
    // PropertyUint8 property.
    if (!(propertyList.isNull() ||
          ((propertyList.size() == 1) &&
           (propertyList[0].equal("PropertyUint8")))))
    {
        throw CIMException(CIM_ERR_NOT_SUPPORTED);
    }

    // synchronously get references
    Array<CIMObjectPath> references =
        _enumerateInstanceNames(context, instanceReference);

    // ensure the Namespace is valid
    if (!instanceReference.getNameSpace().equal("test/static"))
    {
        throw CIMException(CIM_ERR_INVALID_NAMESPACE);
    }

    // ensure the class existing in the specified namespace
    if (!instanceReference.getClassName().equal("PG_TestPropertyTypes"))
    {
        throw CIMException(CIM_ERR_INVALID_CLASS);
    }

    // ensure the property values are valid
    _testPropertyTypesValue(instanceObject);

    // ensure the request object exists
    Uint32 index = findObjectPath(references, instanceReference);
    if (index == PEG_NOT_FOUND)
    {
        throw CIMException(CIM_ERR_NOT_FOUND);
    }

    // begin processing the request
    handler.processing();

    // We do nothing here since we like to have static result
    // complete processing the request
    handler.complete();
}
Пример #6
0
void _printPropertyList(CIMPropertyList& propList)
{
    if (propList.isNull())
    {
        cout << "-----all properties required" << endl;
    }
    else if (propList.size() == 0)
    {
        cout << "-----no properties required" << endl;
    }
    else
    {
        for (Uint32 n = 0; n < propList.size(); n++)
        {
            cout << "-----Required property " << propList[n].getString() << endl;
        }
    }
}
Пример #7
0
// KS Mar 05 - The following removal functions are very inefficient and should
// be optimized to avoid the multiple memory moves.  Actually, the remove
// qualifiers should be added as a function and optimized that once.
void CIMInstanceRep::filter(
    Boolean includeQualifiers,
    Boolean includeClassOrigin,
    const CIMPropertyList& propertyList)
{
    // Filter any qualifiers from this instance.
    if (!includeQualifiers && _qualifiers.getCount() > 0)
    {
        while (_qualifiers.getCount())
        {
            _qualifiers.removeQualifier(0);
        }
    }

    // For each property, remove if not in propertylist
    for (Uint32 i = 0 ; i < _properties.size(); i++)
    {
        CIMConstProperty p = getProperty(i);
        CIMName name = p.getName();
        Array<CIMName> pl = propertyList.getPropertyNameArray();
        if (propertyList.isNull() || Contains(pl, name))
        {
            // test ClassOrigin and possibly remove
            if (!includeClassOrigin)
            {
                _properties[i].setClassOrigin(CIMName());
            }
            // remove qualifiers if required.
            if (!includeQualifiers && _properties[i].getQualifierCount() > 0)
            {
                while (_properties[i].getQualifierCount() > 0)
                {
                    _properties[i].removeQualifier(0);
                }
            }
        }
        else
        {
            _properties.remove(i--);
        }
    }
    return;
}
// ===========================================================================
// Main
// Options:
//  Test or show - TBD
// ===========================================================================
int main()
{
    //verbose = getenv("PEGASUS_TEST_VERBOSE");
    verbose = "test";
    cout << "+++++ Testing AssociationTest Provider" << endl;

    // Build array of classes
    Array<CIMName> Classes;
    Classes.append("TST_ClassA");
    Classes.append("TST_ClassB");
    Classes.append("TST_ClassC");
    Classes.append("TST_ClassD");
    Classes.append("TSTDY_ClassA");
    Classes.append("TSTDY_ClassB");
    Classes.append("TSTDY_ClassC");
    Classes.append("TSTDY_ClassD");

    Array<CIMName> AssocClasses;
    AssocClasses.append("TST_AssocI1");
    AssocClasses.append("TST_AssocI2");
    AssocClasses.append("TST_AssocI3");
    AssocClasses.append("TST_AssocI4");
    AssocClasses.append("TST_AssocI5");
    AssocClasses.append("TST_AssocI6");

    AssocClasses.append("TST_AssocNI1");
    AssocClasses.append("TST_AssocNI2");
    AssocClasses.append("TST_AssocNI3");
    AssocClasses.append("TST_AssocNI4");
    AssocClasses.append("TST_AssocNI5");
    AssocClasses.append("TST_AssocNI6");

    // Connect
    try
    {
        c.connect (HOST, PORTNUMBER, String::EMPTY, String::EMPTY);
    }
    catch (Exception& e)
    {
        errorExit(e);
    }

    int rc;
    // Start by confirming the existence of the classes, etc.
    if ((rc = testClassList(Classes)) != 0) return rc;
    if ((rc = testClassList(AssocClasses)) != 0) return rc;
    // Now start the association tests.
    // Reference Names Test

    // Class A Refrence Names Test

    ASRT(testReferenceNames(CIMObjectPath("TST_ClassA"), CIMName(), "", 2));
    ASRT(testReferenceNames(CIMObjectPath("TST_ClassA"), CIMName(), "to", 2));
    ASRT(testReferenceNames(CIMObjectPath("TST_ClassA"), CIMName(), "from", 2));

    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassA"), CIMName("TST_AssocI1"), "", 1));
    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassA"), CIMName("TST_AssocI1"), "to", 1));
    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassA"), CIMName("TST_AssocI1"), "from", 1));

    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassA"), CIMName("TST_AssocI3"), "", 1));
    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassA"), CIMName("TST_AssocI3"), "to", 0));
    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassA"), CIMName("TST_AssocI3"), "from", 1));

    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassA"), CIMName("TST_AssocI5"), "", 0));
    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassA"), CIMName("TST_AssocI5"), "to", 0));
    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassA"), CIMName("TST_AssocI5"), "from", 0));

    // Class B Refrence Names Test
    ASRT(testReferenceNames(CIMObjectPath("TST_ClassB"), CIMName(), "", 4));
    ASRT(testReferenceNames(CIMObjectPath("TST_ClassB"), CIMName(), "to", 2));
    ASRT(testReferenceNames(CIMObjectPath("TST_ClassB"), CIMName(), "from", 4));

    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassB"), CIMName("TST_AssocI2"), "", 1));
    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassB"), CIMName("TST_AssocI2"), "to", 1));
    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassB"), CIMName("TST_AssocI2"), "from", 1));

    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassB"), CIMName("TST_AssocI2"), "", 1));
    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassB"), CIMName("TST_AssocI2"), "to", 0));
    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassB"), CIMName("TST_AssocI2"), "from", 1));

    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassB"), CIMName("TST_AssocI5"), "", 1));
    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassB"), CIMName("TST_AssocI5"), "to", 1));
    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassB"), CIMName("TST_AssocI5"), "from", 1));

    // TODO TestReferences for class c and class d

    // testRefernceName Instances from static store
    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassA.name=\"InstanceA1\""), CIMName(), "", 2));
    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassA.name=\"InstanceA1\""), CIMName(), "to", 2));
    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassA.name=\"InstanceA1\""), CIMName(), "from", 2));

    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassA.name=\"InstanceA1\""),
        CIMName("TST_AssocI1"), "", 1));
    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassA.name=\"InstanceA1\""),
        CIMName("TST_AssocI1"), "to", 1));
    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassA.name=\"InstanceA1\""),
        CIMName("TST_AssocI1"), "from", 1));

    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassA.name=\"InstanceA1\""),
        CIMName("TST_AssocI3"), "", 1));
    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassA.name=\"InstanceA1\""),
        CIMName("TST_AssocI3"), "to", 0));
    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassA.name=\"InstanceA1\""),
        CIMName("TST_AssocI3"), "from", 1));

    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassA.name=\"InstanceA1\""),
        CIMName("TST_AssocI5"), "", 0));
    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassA.name=\"InstanceA1\""),
        CIMName("TST_AssocI5"), "to", 0));
    ASRT(testReferenceNames(
        CIMObjectPath("TST_ClassA.name=\"InstanceA1\""),
        CIMName("TST_AssocI5"), "from", 0));

    // Lets make the previous a common test between ref and ref names.

    // References
    // Limited test since we learned most in the previous test of reference
    // names
    CIMPropertyList NullPL;

    CIMPropertyList emptyPL;

    CIMPropertyList fullPL;
    Array<CIMName> fullPLinput;
    fullPLinput.append("name");
    fullPL.set(fullPLinput);


    CIMPropertyList errorPL;
    Array<CIMName> errorPLinput;
    errorPLinput.append("junk");
    errorPL.set(errorPLinput);

    ASRT(testReferences(CIMObjectPath("TST_ClassA"), CIMName(), "", emptyPL,2));

    ASRT(testReferences(
        CIMObjectPath("TST_ClassA.name=\"InstanceA1\""),
        CIMName(), "", fullPL,2));

    // Testing associators and and associator names functions.

    ASRT(testAssocNames(
        CIMObjectPath("TST_ClassA"), CIMName(), CIMName(), "", "", 3));

    cout << "+++++ passed all tests" << endl;
    return 0;
}
Пример #9
0
Boolean _getPropertyList(QueryExpression& qe,
                         Array<CIMInstance>& _instances,
                         CIMNamespaceName ns,
                         String testOption,
                         String lang)
{
    if(testOption == String::EMPTY || testOption == "3")
    {
        for(Uint32 j = 0; j < _instances.size(); j++)
        {
            cout << endl << lang << " ========Get Property List Results=======" << endl;
            cout << qe.getQuery() << endl;

            try
            {
                cout << endl << "Get Class Path List" << endl;
                Array<CIMObjectPath> fromPaths = qe.getClassPathList();
                for (Uint32 k = 0; k < fromPaths.size(); k++)
                {
                    cout << "-----" << fromPaths[k].toString() << endl;
                }
            }
            catch(Exception& e) {
                cout << "-----" << e.getMessage() << endl;
            }
            catch(...) {
                cout << "Unknown Exception" << endl;
            }

            CIMName className = _instances[j].getClassName();
            CIMObjectPath classPath (String::EMPTY,
                                     ns,
                                     className);

            CIMPropertyList propList;
            try
            {
                cout << "Property List for the FROM class" << endl;
                propList = qe.getPropertyList();
                _printPropertyList(propList);
            }
            catch(Exception& e) {
                cout << "-----" << e.getMessage() << endl;
            }
            catch(...) {
                cout << "Unknown Exception" << endl;
            }

            try
            {
                cout << "Property List for " << className.getString() << endl;
                propList = qe.getPropertyList(classPath);
                _printPropertyList(propList);
            }
            catch(Exception& e) {
                cout << "-----" << e.getMessage() << endl;
            }
            catch(...) {
                cout << "Unknown Exception" << endl;
            }

            try
            {
                propList.clear();
                cout << "SELECT Property List for the FROM class" << endl;
                propList = qe.getSelectPropertyList();
                _printPropertyList(propList);
            }
            catch(Exception& e) {
                cout << "-----" << e.getMessage() << endl;
            }
            catch(...) {
                cout << "Unknown Exception" << endl;
            }

            try
            {
                propList.clear();
                cout << "SELECT Property List for " << className.getString() << endl;
                propList = qe.getSelectPropertyList(classPath);
                _printPropertyList(propList);
            }
            catch(Exception& e) {
                cout << "-----" << e.getMessage() << endl;
            }
            catch(...) {
                cout << "Unknown Exception" << endl;
            }

            try
            {
                propList.clear();
                cout << "WHERE Property List for the FROM class" << endl;
                propList = qe.getWherePropertyList();
                _printPropertyList(propList);
            }
            catch(Exception& e) {
                cout << "-----" << e.getMessage() << endl;
            }
            catch(...) {
                cout << "Unknown Exception" << endl;
            }

            try
            {
                propList.clear();
                cout << "WHERE Property List for " << className.getString() << endl;
                propList = qe.getWherePropertyList(classPath);
                _printPropertyList(propList);
            }
            catch(Exception& e) {
                cout << "-----" << e.getMessage() << endl;
            }
            catch(...) {
                cout << "Unknown Exception" << endl;
            }
        }
    }

    return true;
}
PEGASUS_NAMESPACE_BEGIN

void SCMOInternalXmlEncoder::_putXMLInstance(
    CIMBuffer& out,
    const SCMOInstance& ci,
    const CIMPropertyList& propertyList )
{

    if (ci.isUninitialized())
    {
        out.putUint32(0);
        out.putUint32(0);
        out.putString(String());
        out.putNamespaceName(CIMNamespaceName());
    }
    else
    {
        Buffer buf(4096);

        // Serialize instance as XML.
        if (propertyList.isNull())
        {
            Array<Uint32> emptyNodes;
            SCMOXmlWriter::appendInstanceElement(
                buf,
                ci,
                false,
                emptyNodes);
        }
        else
        {
            Array<propertyFilterNodesArray_t> propFilterNodesArrays;
            // This searches for an already created array of nodes,
            // if not found, creates it inside propFilterNodesArrays
            const Array<Uint32> & nodes=
                SCMOXmlWriter::getFilteredNodesArray(
                    propFilterNodesArrays,
                    ci,
                    propertyList);
            SCMOXmlWriter::appendInstanceElement(
                buf,
                ci,
                true,
                nodes);
        }
        buf.append('\0');

        out.putUint32(buf.size());
        out.putBytes(buf.getData(), buf.size());
        buf.clear();

        if (0 == ci.getClassName())
        {
            out.putUint32(0);
            out.putString(String());
            out.putNamespaceName(CIMNamespaceName());
        }
        else
        {
            // Serialize object path as XML.
            SCMOXmlWriter::appendValueReferenceElement(buf, ci);
            buf.append('\0');

            out.putUint32(buf.size());
            out.putBytes(buf.getData(), buf.size());

            // Write hostname and namespace in UTF-16 format
            Uint32 len=0;
            const char* hn = ci.getHostName_l(len);
            out.putUTF8AsString(hn, len);
            const char * ns = ci.getNameSpace_l(len);
            out.putUTF8AsString(ns, len);
        }
    }
}
Пример #11
0
//
// Local version of enumerateInstances to be used by other functions in the
// provider. Note that this delivers instances as a group rather than one
// at a time. This design point may need to be revisited if this provider
// is used in environments such that returning segmented responses would have
// significant performance advantages. For now, that doesn't seem to be the
// case.
//
Array<CIMInstance> InteropProvider::localEnumerateInstances(
    const OperationContext & context,
    const CIMObjectPath & ref,
    const CIMPropertyList& propertyList)
{
    PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,
                     "InteropProvider::localEnumerateInstances()");

    const CIMName & className = ref.getClassName();
    PEG_TRACE((TRC_CONTROLPROVIDER, Tracer::LEVEL4,
               "%s enumerateInstances. referenc= %s , PropertyList= %s",
               thisProvider,
               (const char *)className.getString().getCString(),
               (const char *)propertyList.toString().getCString()));

    // Verify that ClassName is correct and get its enum value
    TARGET_CLASS classEnum = translateClassInput(className);

    Array<CIMInstance> instances;
    switch(classEnum)
    {
    case PG_OBJECTMANAGER:
    {
        instances.append(getObjectManagerInstance());
        break;
    }
    case PG_CIMXMLCOMMUNICATIONMECHANISM:
    {
        instances = enumCIMXMLCommunicationMechanismInstances();
        break;
    }
    case PG_NAMESPACEINMANAGER:
    {
        instances = enumNamespaceInManagerInstances();
        break;
    }
    case PG_COMMMECHANISMFORMANAGER:
    {
        instances = enumCommMechanismForManagerInstances();
        break;
    }
    case PG_NAMESPACE:
    {
        instances = enumNamespaceInstances();
        break;
    }
    case PG_REGISTEREDPROFILE:
    {
        instances = enumRegisteredProfileInstances();
        break;
    }
    case PG_REGISTEREDSUBPROFILE:
    {
        instances = enumRegisteredSubProfileInstances();
        break;
    }
    case PG_REFERENCEDPROFILE:
    {
        instances = enumReferencedProfileInstances();
        break;
    }
    case PG_ELEMENTCONFORMSTOPROFILE:
    {
        instances = enumElementConformsToProfileInstances(context,
                    ref.getNameSpace());
        break;
    }
    case PG_ELEMENTCONFORMSTOPROFILE_RP_RP:
    {
        instances = enumElementConformsToProfileRPRPInstances(
                        context,
                        ref.getNameSpace());
        break;
    }
    case PG_SUBPROFILEREQUIRESPROFILE:
    {
        instances = enumSubProfileRequiresProfileInstances();
        break;
    }
    case PG_SOFTWAREIDENTITY:
    {
        instances = enumSoftwareIdentityInstances();
        break;
    }
    case PG_ELEMENTSOFTWAREIDENTITY:
    {
        instances = enumElementSoftwareIdentityInstances();
        break;
    }
    case PG_INSTALLEDSOFTWAREIDENTITY:
    {
        instances = enumInstalledSoftwareIdentityInstances(context);
        break;
    }
    case PG_COMPUTERSYSTEM:
    {
        instances.append(getComputerSystemInstance(context));
        break;
    }
    case PG_HOSTEDOBJECTMANAGER:
    {
        instances.append(getHostedObjectManagerInstance(context));
        break;
    }
    case PG_HOSTEDACCESSPOINT:
    {
        instances = enumHostedAccessPointInstances(context);
        break;
    }
    //We don't support enumerate CIM_Namespace instances. PG_Namespace is
    //supported.
    case CIM_NAMESPACE:
    {
        break;
    }
    case PG_PROVIDERPROFILECAPABILITIES:
    {
        instances = enumProviderProfileCapabilityInstances(false);
        break;
    }

#ifdef PEGASUS_ENABLE_DMTF_INDICATION_PROFILE_SUPPORT
    case PG_ELEMENTCAPABILITIES:
    {
        instances = enumElementCapabilityInstances(context);
        break;
    }
    case PG_HOSTEDINDICATIONSERVICE:
    {
        instances = enumHostedIndicationServiceInstances(context);
        break;
    }
    case PG_SERVICEAFFECTSELEMENT:
    {
        instances = enumServiceAffectsElementInstances(context);
        break;
    }
    case CIM_INDICATIONSERVICE:
    {
        instances = enumIndicationServiceInstances(context);
        break;
    }
#endif
    default:
        PEG_METHOD_EXIT();
        throw CIMNotSupportedException(className.getString() +
                                       " not supported by Interop Provider enumerate");
    }

    // Filter and deliver the resulting instances
    for (Uint32 i = 0 ; i < instances.size() ; i++)
    {
        normalizeInstance(instances[i], ref, false,
                          false, propertyList);
    }

    PEG_METHOD_EXIT();
    return instances;
}
Пример #12
0
//
// Local version of getInstance to be used by other functions in the the
// provider. Returns a single instance. Note that it always returns an
// instance. If none was found, it is uninialitized.
//
CIMInstance InteropProvider::localGetInstance(
    const OperationContext & context,
    const CIMObjectPath & instanceName,
    const CIMPropertyList & propertyList)
{
    PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::localGetInstance");

    PEG_TRACE((TRC_CONTROLPROVIDER, Tracer::LEVEL4,
               "%s getInstance. instanceName= %s , PropertyList= %s",
               thisProvider,
               (const char *)instanceName.toString().getCString(),
               (const char *)propertyList.toString().getCString()));

    // Test if we're looking for something outside of our namespace. This will
    // happen during associators calls from PG_RegisteredProfile instances
    // through the PG_ElementConformsToProfile association
    CIMNamespaceName opNamespace = instanceName.getNameSpace();
    CIMName opClass = instanceName.getClassName();
    if((opNamespace != PEGASUS_NAMESPACENAME_INTEROP &&
            opClass != PEGASUS_CLASSNAME_PG_ELEMENTCONFORMSTOPROFILE)
            // Get CIM_IndicationService instance from IndicationService.
#ifdef PEGASUS_ENABLE_DMTF_INDICATION_PROFILE_SUPPORT
            || opClass == PEGASUS_CLASSNAME_CIM_INDICATIONSERVICE
#endif
      )
    {
        AutoMutex mut(interopMut);
        CIMInstance gotInstance = cimomHandle.getInstance(
                                      context,
                                      opNamespace,
                                      instanceName,
                                      false,
                                      false,
                                      false,
                                      propertyList);
        PEG_METHOD_EXIT();
        return gotInstance;
    }

    TARGET_CLASS classEnum  = translateClassInput(opClass);
    CIMInstance retInstance;
    switch(classEnum)
    {
    case PG_SOFTWAREIDENTITY:
    {
        retInstance = getSoftwareIdentityInstance(instanceName);
        normalizeInstance(
            retInstance, instanceName, false, false, propertyList);
    }
    break;
    case PG_NAMESPACE:
    {
        retInstance = getNameSpaceInstance(instanceName);
        normalizeInstance(
            retInstance, instanceName, false, false, propertyList);
    }
    break;
    // ATTN: Implement getIntstance for all other classes. Currently
    // this method calls localEnumerateInstances() to select instance
    // which is too expensive.
    default:
    {
        // Create reference from host, namespace, class components of
        // instance name
        CIMObjectPath ref;
        ref.setHost(instanceName.getHost());
        ref.setClassName(opClass);
        ref.setNameSpace(opNamespace);

        // Enumerate instances for this class. Returns all instances
        // Note that this returns paths setup and instances already
        // filtered per the input criteria.
        Array<CIMInstance> instances =  localEnumerateInstances(
                                            context,
                                            ref,
                                            propertyList);
        ConstArrayIterator<CIMInstance> instancesIter(instances);

        // deliver a single instance if found.
        bool found = false;
        for(Uint32 i = 0; i < instancesIter.size(); i++)
        {
            CIMObjectPath currentInstRef = instancesIter[i].getPath();
            currentInstRef.setHost(instanceName.getHost());
            currentInstRef.setNameSpace(instanceName.getNameSpace());
            if(instanceName == currentInstRef)
            {
                retInstance = instancesIter[i];
                found = true;
                break;
            }
        }

        if (!found)
        {
            PEG_METHOD_EXIT();
            throw CIMObjectNotFoundException(instanceName.toString());
        }
    }
    }

    PEG_METHOD_EXIT();
    return retInstance;
}
Пример #13
0
void test01()
{
    //
    // Create a property source (a place for the evaluate to get the
    // values of properties from):
    //

    WQLSimplePropertySource source;
    assert(source.addValue("x", WQLOperand(10, WQL_INTEGER_VALUE_TAG)));
    assert(source.addValue("y", WQLOperand(20, WQL_INTEGER_VALUE_TAG)));
    assert(source.addValue("z", WQLOperand(1.5, WQL_DOUBLE_VALUE_TAG)));

    //
    // Define query:
    //
    
    const char TEXT[] = 
	"SELECT x,y,z\n"
	"FROM MyClass\n"
	"WHERE x > 5 AND y < 25 AND z > 1.2";

    //
    //  Will test WQLParser::parse(const Array<Sint8>&, WQLSelectStatement&)
    //  and WQLParser::parse(const char*, WQLSelectStatement&) forms
    //
    Array<char> text;
    text.append(TEXT, sizeof(TEXT));
    if (verbose)
    {
        cout << text.getData() << endl;
    }

    // 
    // Parse the text:
    //

    WQLSelectStatement statement;

    try
    {
	WQLParser::parse(text, statement);
        if (verbose)
        {
	    statement.print();
        }

        //
        //  Test WQLSelectStatement functions
        //
        assert (statement.getClassName().equal ("MyClass"));
        assert (!statement.getAllProperties());
        assert (statement.getSelectPropertyNameCount() == 3);
        CIMName propName = statement.getSelectPropertyName (0);
        assert ((propName.equal ("x")) || (propName.equal ("y")) || 
                (propName.equal ("z")));
        CIMPropertyList propList = statement.getSelectPropertyList();
        assert (!propList.isNull());
        assert (propList.size() == 3);
        assert ((propList[0].equal ("x")) || (propList[0].equal ("y")) || 
                (propList[0].equal ("z")));
        assert (statement.hasWhereClause());
        assert (statement.getWherePropertyNameCount() == 3);
        CIMName wherePropName = statement.getWherePropertyName (0);
        assert ((wherePropName.equal ("x")) || (wherePropName.equal ("y")) || 
                (wherePropName.equal ("z")));
        CIMPropertyList wherePropList = statement.getWherePropertyList();
        assert (!wherePropList.isNull());
        assert (wherePropList.size() == 3);
        assert ((wherePropList[0].equal ("x")) || 
                (wherePropList[0].equal ("y")) || 
                (wherePropList[0].equal ("z")));
        assert (statement.evaluateWhereClause(&source));
    }
    catch (Exception& e)
    {
	cerr << "Exception: " << e.getMessage() << endl;
	exit(1);
    }
}
Пример #14
0
void test02()
{
    //
    // Create a property source (a place for the evaluate to get the
    // values of properties from):
    //

    WQLSimplePropertySource source;
    assert(source.addValue("a", WQLOperand(5, WQL_INTEGER_VALUE_TAG)));
    assert(source.addValue("b", WQLOperand(25, WQL_INTEGER_VALUE_TAG)));
    assert(source.addValue("c", WQLOperand(0.9, WQL_DOUBLE_VALUE_TAG)));
    assert(source.addValue("d", WQLOperand("Test", WQL_STRING_VALUE_TAG)));

    //
    // Define query:
    //
    
    const char TEXT[] = 
	"SELECT a,c,d\n"
	"FROM YourClass\n"
	"WHERE a > 5 AND b < 25 AND c > 1.2 AND d = \"Pass\"";

    //
    //  Will test WQLParser::parse(const String&, WQLSelectStatement&)
    //  and WQLParser::parse(const char*, WQLSelectStatement&) forms
    //
    String text (TEXT);
    if (verbose)
    {
        cout << text << endl;
    }

    // 
    // Parse the text:
    //

    WQLSelectStatement statement;

    try
    {
	WQLParser::parse(text, statement);
        if (verbose)
        {
	    statement.print();
        }

        //
        //  Test WQLSelectStatement functions
        //
        assert (statement.getClassName().equal ("YourClass"));
        assert (!statement.getAllProperties());
        assert (statement.getSelectPropertyNameCount() == 3);
        CIMName propName = statement.getSelectPropertyName (2);
        assert ((propName.equal ("a")) || (propName.equal ("c")) || 
                (propName.equal ("d")));
        CIMPropertyList propList = statement.getSelectPropertyList();
        assert (!propList.isNull());
        assert (propList.size() == 3);
        assert ((propList[2].equal ("a")) || (propList[2].equal ("c")) || 
                (propList[2].equal ("d")));
        assert (statement.hasWhereClause());
        assert (statement.getWherePropertyNameCount() == 4);
        CIMName wherePropName = statement.getWherePropertyName (3);
        assert ((wherePropName.equal ("a")) || (wherePropName.equal ("b")) || 
                (wherePropName.equal ("c")) || (wherePropName.equal ("d")));
        CIMPropertyList wherePropList = statement.getWherePropertyList();
        assert (!wherePropList.isNull());
        assert (wherePropList.size() == 4);
        assert ((wherePropList[3].equal ("a")) || 
                (wherePropList[3].equal ("b")) || 
                (wherePropList[3].equal ("c")) || 
                (wherePropList[3].equal ("d")));
        assert (!statement.evaluateWhereClause(&source));
    }
    catch (Exception& e)
    {
	cerr << "Exception: " << e.getMessage() << endl;
	exit(1);
    }
}
Пример #15
0
void ConfigSettingProvider::_modifyInstance(
    const OperationContext & context,
    const CIMObjectPath & instanceReference,
    const CIMInstance& modifiedIns,
    const CIMPropertyList& propertyList,
    Uint32 timeoutSeconds)
    {
        PEG_METHOD_ENTER(TRC_CONFIG,
            "ConfigSettingProvider::_modifyInstance()");

        //
        // get userName
        //
        String userName;
        try
        {
            IdentityContainer container = context.get(IdentityContainer::NAME);
            userName = container.getUserName();
        }
        catch (...)
        {
            userName = String::EMPTY;
        }

        //
        // verify user authorizations
        // z/OS: authorization check is done in CIMOpReqAuth already
        //
#ifndef PEGASUS_OS_ZOS
        if (userName != String::EMPTY)
        {
            _verifyAuthorization(userName);
        }
#endif
        // NOTE: Qualifiers are not processed by this provider, so the
        // IncludeQualifiers flag is ignored.

        //
        // check if the class name requested is PG_ConfigSetting
        //
        if (!instanceReference.getClassName().equal (PG_CONFIG_SETTING))
        {
            PEG_METHOD_EXIT();
            throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
                instanceReference.getClassName().getString());
        }

        //
        // validate key bindings
        //
        Array<CIMKeyBinding> kbArray = instanceReference.getKeyBindings();
        if ( (kbArray.size() != 1) ||
             (!kbArray[0].getName().equal (PROPERTY_NAME)))
        {
            PEG_METHOD_EXIT();
            throw PEGASUS_CIM_EXCEPTION_L(
                CIM_ERR_INVALID_PARAMETER,
                MessageLoaderParms(
                    "ControlProviders.ConfigSettingProvider."
                        "ConfigSettingProvider."
                        "INVALID_INSTANCE_NAME",
                    "Invalid instance name"));

        }

        String configPropertyName = kbArray[0].getValue();

        // Modification of the entire instance is not supported by this provider
        if (propertyList.isNull())
        {
            PEG_METHOD_EXIT();
            //l10n
            //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
            //"Modification of entire instance");
            throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,
                  MessageLoaderParms(
                      "ControlProviders.ConfigSettingProvider."
                          "ConfigSettingProvider."
                          "MODIFICATION_OF_ENTIRE_INSTANCE",
                     "Modification of entire instance"));
        }

        Boolean currentValueModified = false;
        Boolean plannedValueModified = false;

        for (Uint32 i = 0; i < propertyList.size(); ++i)
        {
            CIMName propertyName = propertyList[i];
            if (propertyName.equal (CURRENT_VALUE))
            {
                currentValueModified = true;
            }
            else if (propertyName.equal (PLANNED_VALUE))
            {
                plannedValueModified = true;
            }
            else
            {
                PEG_METHOD_EXIT();

                throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,
                    MessageLoaderParms(
                        "ControlProviders.ConfigSettingProvider."
                            "ConfigSettingProvider."
                            "MODIFICATION_NOT_SUPPORTED",
                        "Modification of property \"$0\"",
                        propertyName.getString()));
            }
        }

        String preValue;
        String currentValue;
        String plannedValue;
        Boolean currentValueIsNull = false;
        Boolean plannedValueIsNull = false;

        //
        // Get the current value from the instance
        //
        Uint32 pos = modifiedIns.findProperty(CURRENT_VALUE);
        if (pos == PEG_NOT_FOUND)
        {
            currentValueIsNull = true;
        }
        else
        {
            CIMConstProperty prop = modifiedIns.getProperty(pos);
            try
            {
                prop.getValue().get(currentValue);
            }
            catch (Exception& e)
            {
                PEG_METHOD_EXIT();
                throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, e.getMessage());
            }
        }

        //
        // Get the planned value from the instance
        //
        pos = modifiedIns.findProperty(PLANNED_VALUE);
        if (pos == PEG_NOT_FOUND)
        {
            plannedValueIsNull = true;
        }
        else
        {
            CIMConstProperty prop = modifiedIns.getProperty(pos);
            try
            {
                prop.getValue().get(plannedValue);
            }
            catch (Exception& e)
            {
                PEG_METHOD_EXIT();
                throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, e.getMessage());
            }
        }

        try
        {
            //
            // Update the current value, if requested
            //
            if (currentValueModified)
            {
                preValue = _configManager->getCurrentValue(configPropertyName);

                if ( !_configManager->updateCurrentValue(
                    configPropertyName,
                    currentValue,
                    userName,
                    timeoutSeconds,
                    currentValueIsNull))
                {
                    PEG_METHOD_EXIT();

                    throw PEGASUS_CIM_EXCEPTION_L(
                        CIM_ERR_FAILED,
                        MessageLoaderParms(
                            "ControlProviders.ConfigSettingProvider."
                                "ConfigSettingProvider."
                                "UPDATE_CURRENT_VALUE_FAILED",
                            "Failed to update the current value."));
                }

                // It is unset, get current value which is default
                if (currentValueIsNull)
                {
                    currentValue = _configManager->getCurrentValue(
                        configPropertyName);
                }

               // send notify config change message to Handler Service
               if(String::equal(configPropertyName,
                      "maxIndicationDeliveryRetryAttempts")||
                  String::equal(configPropertyName,
                      "minIndicationDeliveryRetryInterval"))
               {
                   _sendNotifyConfigChangeMessage(
                       configPropertyName,
                       currentValue,
                       userName,
                       PEGASUS_QUEUENAME_INDHANDLERMANAGER,
                       true);
               }

                // send notify config change message to ProviderManager Service
                _sendNotifyConfigChangeMessage(
                    configPropertyName,
                    currentValue,
                    userName,
                    PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP,
                    true);

               PEG_AUDIT_LOG(logSetConfigProperty(userName, configPropertyName,
                   preValue, currentValue, false));
            }

            //
            // Update the planned value, if requested
            //
            if (plannedValueModified)
            {
                preValue = _configManager->getPlannedValue(configPropertyName);

                if ( !_configManager->updatePlannedValue(
                    configPropertyName, plannedValue, plannedValueIsNull) )
                {
                    PEG_METHOD_EXIT();

                    throw PEGASUS_CIM_EXCEPTION_L(
                        CIM_ERR_FAILED,
                        MessageLoaderParms(
                            "ControlProviders.ConfigSettingProvider."
                                "ConfigSettingProvider."
                                "UPDATE_PLANNED_VALUE_FAILED",
                            "Failed to update the planned value."));
                }

                // It is unset, get planned value which is default
                if (plannedValueIsNull)
                {
                    plannedValue = _configManager->getPlannedValue(
                        configPropertyName);

                    if (String::equal(configPropertyName,
                           "maxIndicationDeliveryRetryAttempts") ||
                        String::equal(configPropertyName,
                            "minIndicationDeliveryRetryInterval"))
                    {
                        _sendNotifyConfigChangeMessage(
                            configPropertyName,
                            plannedValue,
                            userName,
                            PEGASUS_QUEUENAME_INDHANDLERMANAGER,
                            false);
                    }
                }

                // send notify config change message to ProviderManager Service
                _sendNotifyConfigChangeMessage(
                    configPropertyName,
                    plannedValue,
                    userName,
                    PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP,
                    false);

               PEG_AUDIT_LOG(logSetConfigProperty(userName, configPropertyName,
                   preValue, plannedValue, true));
            }
        }
        catch (const NonDynamicConfigProperty& ndcp)
        {
            PEG_METHOD_EXIT();
            throw PEGASUS_CIM_EXCEPTION(
                CIM_ERR_NOT_SUPPORTED, ndcp.getMessage());
        }
        catch (const InvalidPropertyValue& ipv)
        {
            PEG_METHOD_EXIT();
            throw PEGASUS_CIM_EXCEPTION(
                CIM_ERR_FAILED, ipv.getMessage());
        }
        catch (const UnrecognizedConfigProperty&)
        {
            PEG_METHOD_EXIT();
            throw PEGASUS_CIM_EXCEPTION_L(
                CIM_ERR_NOT_FOUND,
                MessageLoaderParms(
                    "ControlProviders.ConfigSettingProvider."
                        "ConfigSettingProvider."
                        "CONFIG_PROPERTY_NOT_FOUND",
                    "Configuration property \"$0\"",
                    configPropertyName));
        }

        PEG_METHOD_EXIT();
        return;
    }
Пример #16
0
/////////////////////////////////////////////////////////////////////////////
// WMIInstanceProvider::modifyInstance
//
// ///////////////////////////////////////////////////////////////////////////
void WMIInstanceProvider::modifyInstance(
    const String& nameSpace,
    const String& userName,
    const String& password,
    const CIMInstance& modifiedInstance,
    Boolean includeQualifiers,
    const CIMPropertyList& propertylist)
{
    PEG_METHOD_ENTER(TRC_WMIPROVIDER,"WMIClassProvider::modifyInstance()");

    HRESULT hr;
    CComPtr<IWbemClassObject> pClass;
    CComPtr<IWbemClassObject> pInstance;

    setup(nameSpace, userName, password);

    PEG_TRACE((TRC_WMIPROVIDER,
                  Tracer::LEVEL3,
                  "ModifyInstance() - nameSpace %s, userName %s",
                  nameSpace.getCString(),
                  userName.getCString()));

    if (!m_bInitialized)
    {
        PEG_TRACE((TRC_WMIPROVIDER, Tracer::LEVEL1,
            "WMIInstanceProvider::ModifyInstance - m_bInitilized= %x, "
            "throw CIM_ERR_FAILED exception",
            m_bInitialized));

        throw CIMException(CIM_ERR_FAILED);
    }

    // Check if the instance's class is valid.
    String className = modifiedInstance.getClassName().getString();

    if (!(_collector->getObject(&pClass, className)))
    {
        if (pClass)
            pClass.Release();

        throw CIMException(CIM_ERR_INVALID_CLASS);
    }
    else if (_collector->isInstance(pClass))
    {
        if (pClass)
            pClass.Release();

        throw CIMException(CIM_ERR_INVALID_PARAMETER);
    }

    if (pClass)
        pClass.Release();

    // Get the instance path
    CIMObjectPath objPath = modifiedInstance.getPath();

    // Get the name of the instance
    String instanceName = getObjectName(objPath);

    // Check if the instance exists
    if (!(_collector->getObject(&pInstance, instanceName)))
    {
        if (pInstance)
            pInstance.Release();

        throw CIMException(CIM_ERR_NOT_FOUND);
    }
    else if (!(_collector->isInstance(pInstance)))
    {
        if (pInstance)
            pInstance.Release();

        throw CIMException(CIM_ERR_INVALID_PARAMETER);
    }

    // Set the properties that are into propertylist
    Array<CIMName> listNames;
    listNames = propertylist.getPropertyNameArray();

    bool foundInArray;
    bool bPropertySet = false;

    for(Uint32 i = 0; i < modifiedInstance.getPropertyCount(); i++)
    {
        CComVariant v;
        CIMProperty property = modifiedInstance.getProperty(i).clone();
        String sPropName = property.getName().getString();

        // change only the properties defined into the array
        // if the array is null, change all properties
        if (propertylist.isNull())
        {
            foundInArray = true;
        }
        else
        {
            foundInArray = false;
            for (Uint32 j = 0; (j < listNames.size()) && !foundInArray; j++)
                //if (listNames[j].getString() == str)
                if (String::equalNoCase(listNames[j].getString(), sPropName))
                    foundInArray = true;
        }

        if (foundInArray)
        {
            WMIValue propertyValue = property.getValue();

            try
            {
                propertyValue.getAsVariant(&v,nameSpace, userName, password);
            }
            catch (CIMException&)
            {
                if (pInstance)
                    pInstance.Release();

                v.Clear();

                throw;
            }

            CComBSTR bs = sPropName.getCString();
            hr = pInstance->Put(bs, 0, &v, 0);
            v.Clear();

            // If we fail to set one property, we must assure
            // that the others will be processed
            if(SUCCEEDED(hr))
            {
                // Mark that at least one property was set
                bPropertySet = true;
            }
        }
    }

    // Check if at least one property was set
    // otherwise throw invalid parameter error
    if(!bPropertySet)
    {
        PEG_TRACE((TRC_WMIPROVIDER,
                      Tracer::LEVEL1,
                      "modifyInstance() - Put Failed hr=0x%x.",
                      hr));

        throw CIMException(CIM_ERR_FAILED);
    }

    // Connect to the server
    CComPtr<IWbemServices> pServices;
    bool bConnected = _collector->Connect(&pServices);

    if (!bConnected)
    {
        throw CIMException(CIM_ERR_ACCESS_DENIED);
    }

    // Write the instance to WMI.
    hr = pServices->PutInstance(pInstance,
                                WBEM_FLAG_UPDATE_ONLY,
                                NULL,
                                NULL);

    if (pInstance)
        pInstance.Release();

    if (pServices)
        pServices.Release();

    if(FAILED(hr))
    {
        switch(hr)
        {
            case E_ACCESSDENIED:
                throw CIMException(CIM_ERR_ACCESS_DENIED);
                break;
            case WBEM_E_ACCESS_DENIED:
                throw CIMException(CIM_ERR_ACCESS_DENIED);
                break;
            case WBEM_E_NOT_FOUND:
                throw CIMException(CIM_ERR_NOT_FOUND);
                break;
            case WBEM_E_INVALID_CLASS:
                throw CIMException(CIM_ERR_INVALID_CLASS);
                break;
            case WBEM_E_INVALID_OBJECT:
                throw CIMException(CIM_ERR_INVALID_PARAMETER);
                break;
            default:
                throw CIMException(CIM_ERR_FAILED);
        }
    }

    PEG_METHOD_EXIT();

    return;
}