cimsub.cpp

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

    _addStringProperty(filter11a, "SourceNamespace",
        SOURCENAMESPACE.getString());
    _addStringProperty(filter11a, PEGASUS_PROPERTYNAME_QUERY.getString(),
        query);
    _addStringProperty(filter11a, "QueryLanguage", qlang);
    CIMObjectPath fPath2 = client.createInstance(NAMESPACE2, filter11a);
    fPath2.setNameSpace(NAMESPACE2);

    //
    //  Create a second handler in different namespace
    //
    CIMInstance listenerdestination05a(PEGASUS_CLASSNAME_LSTNRDST_CIMXML);
    _addStringProperty(listenerdestination05a,
        PEGASUS_PROPERTYNAME_NAME.getString(),
        "ListenerDestination05");
    _addStringProperty(listenerdestination05a,
        PEGASUS_PROPERTYNAME_LSTNRDST_DESTINATION.getString(),
        "localhost/CIMListener/test6");
    CIMObjectPath hPath2 = client.createInstance(NAMESPACE1,
        listenerdestination05a);
    hPath2.setNameSpace(NAMESPACE1);

    //
    //  Create Filter for remove filter test
    //
    CIMInstance filter13(PEGASUS_CLASSNAME_INDFILTER);
    query = "SELECT * FROM CIM_ProcessIndication";
    _addStringProperty(filter13,
        PEGASUS_PROPERTYNAME_NAME.getString(),
        "Filter13");
    _addStringProperty(filter13, "SourceNamespace",
        SOURCENAMESPACE.getString());
    _addStringProperty(filter13, PEGASUS_PROPERTYNAME_QUERY.getString(),
        query);
    _addStringProperty(filter13, "QueryLanguage", qlang);
    fPath = client.createInstance(NAMESPACE1, filter13);
    fPath.setNameSpace(NAMESPACE1);

    //
    //  Create Subscription with Filter and Handler in different namespaces
    //
    CIMInstance filter12(PEGASUS_CLASSNAME_INDFILTER);
    query = "SELECT * FROM CIM_ProcessIndication";
    _addStringProperty(filter12,
        PEGASUS_PROPERTYNAME_NAME.getString(),
        "Filter12");
    _addStringProperty(filter12, "SourceNamespace",
        SOURCENAMESPACE.getString());
    _addStringProperty(filter12, PEGASUS_PROPERTYNAME_QUERY.getString(),
        query);
    _addStringProperty(filter12, "QueryLanguage", qlang);
    fPath = client.createInstance(NAMESPACE1, filter12);
    fPath.setNameSpace(NAMESPACE1);

    CIMInstance listenerdestination08(PEGASUS_CLASSNAME_LSTNRDST_CIMXML);
    _addStringProperty(listenerdestination08,
        PEGASUS_PROPERTYNAME_NAME.getString(),
        "ListenerDestination08");
    _addStringProperty(listenerdestination08,
        PEGASUS_PROPERTYNAME_LSTNRDST_DESTINATION.getString(),
        "localhost/CIMListener/test6");
    hPath = client.createInstance(NAMESPACE2, listenerdestination08);
    hPath.setNameSpace(NAMESPACE2);

    //
    //  Create transient CIMXML listener destination
    //
    CIMInstance listenerdestination06(PEGASUS_CLASSNAME_LSTNRDST_CIMXML);
    _addStringProperty(listenerdestination06,
        PEGASUS_PROPERTYNAME_NAME.getString(),
        "ListenerDestination06");
    _addUint16Property(listenerdestination06,
        PEGASUS_PROPERTYNAME_PERSISTENCETYPE.getString(),
        PERSISTENCE_TRANSIENT);
    _addStringProperty(listenerdestination06,
        PEGASUS_PROPERTYNAME_LSTNRDST_DESTINATION.getString(),
        "localhost/CIMListener/test7");
    hPath = client.createInstance(NAMESPACE2, listenerdestination06);
    hPath.setNameSpace(NAMESPACE2);

    //
    //  Create subscription with transient handler
    //
    CIMInstance subscription14 = _buildSubscriptionInstance(
        fPath, PEGASUS_CLASSNAME_LSTNRDST_CIMXML, hPath);
    sPath = client.createInstance(NAMESPACE3, subscription14);

    //
    //  Create another transient CIMXML listener destination in a different
    //  namespace
    //
    CIMInstance listenerdestination06a(PEGASUS_CLASSNAME_LSTNRDST_CIMXML);
    _addStringProperty(listenerdestination06a,
        PEGASUS_PROPERTYNAME_NAME.getString(),
        "ListenerDestination06");
    _addUint16Property(listenerdestination06a,
        PEGASUS_PROPERTYNAME_PERSISTENCETYPE.getString(),
        PERSISTENCE_TRANSIENT);
    _addStringProperty(listenerdestination06a,
        PEGASUS_PROPERTYNAME_LSTNRDST_DESTINATION.getString(),
        "localhost/CIMListener/test7");
    hPath = client.createInstance(NAMESPACE3, listenerdestination06a);
    hPath.setNameSpace(NAMESPACE3);

    //
    //  Create subscription with transient handler
    //
    CIMInstance subscription14a = _buildSubscriptionInstance(
        fPath, PEGASUS_CLASSNAME_LSTNRDST_CIMXML, hPath);
    CIMObjectPath sPath14a = client.createInstance(NAMESPACE2,
        subscription14a);

    //
    //  Create subscription with transient handler
    //
    CIMObjectPath sPath14b = client.createInstance(NAMESPACE, subscription14);
    //
    //  Create expired subscription
    //
    CIMInstance filter15(PEGASUS_CLASSNAME_INDFILTER);
    query = "SELECT * FROM CIM_ProcessIndication";
    _addStringProperty(filter15,
        PEGASUS_PROPERTYNAME_NAME.getString(),
        "Filter15");
    _addStringProperty(filter15, "SourceNamespace",
        SOURCENAMESPACE.getString());
    _addStringProperty(filter15, PEGASUS_PROPERTYNAME_QUERY.getString(),
        query);
    _addStringProperty(filter15, "QueryLanguage", qlang);
    fPath = client.createInstance(NAMESPACE, filter15);
    fPath.setNameSpace(NAMESPACE);

    CIMInstance handler15(PEGASUS_CLASSNAME_LSTNRDST_CIMXML);
    _addStringProperty(handler15,
        PEGASUS_PROPERTYNAME_NAME.getString(),
        "Handler15");
    _addUint16Property(handler15,
        PEGASUS_PROPERTYNAME_PERSISTENCETYPE.getString(),
        PERSISTENCE_TRANSIENT);
    _addStringProperty(handler15,
        PEGASUS_PROPERTYNAME_LSTNRDST_DESTINATION.getString(),
        "localhost/CIMListener/test7");
    hPath = client.createInstance(NAMESPACE, handler15);
    hPath.setNameSpace(NAMESPACE);

    CIMInstance subscription15 = _buildSubscriptionInstance(
        _buildFilterOrHandlerPath(PEGASUS_CLASSNAME_INDFILTER, "Filter15"),
        PEGASUS_CLASSNAME_LSTNRDST_CIMXML,
        _buildFilterOrHandlerPath(PEGASUS_CLASSNAME_LSTNRDST_CIMXML,
        "Handler15"));
    _addUint16Property(subscription15, "OnFatalErrorPolicy", 2);
    _addStringProperty(subscription15, "OtherOnFatalErrorPolicy",
        String::EMPTY, true);
    _addUint64Property(subscription15, "FailureTriggerTimeInterval", 60);
    _addUint16Property(subscription15, "SubscriptionState", 2);
    _addStringProperty(subscription15, "OtherSubscriptionState",
        String::EMPTY,
        true);
    _addUint64Property(subscription15, "SubscriptionDuration",
        PEGASUS_UINT64_LITERAL(1));
    _addUint16Property(subscription15, "RepeatNotificationPolicy", 1);
    _addStringProperty(subscription15, "OtherRepeatNotificationPolicy",
        "another policy");
    _addUint64Property(subscription15, "RepeatNotificationInterval", 60);
    _addUint64Property(subscription15, "RepeatNotificationGap", 30);
    _addUint16Property(subscription15, "RepeatNotificationCount", 5);
    path = client.createInstance(NAMESPACE, subscription15);
    System::sleep(2);
}

void _delete (CIMClient & client)
{
    //
    //  Delete subscription instances
    //
    _deleteSubscriptionInstance(client, "Filter01",
        PEGASUS_CLASSNAME_INDHANDLER_CIMXML, "Handler01");
    _deleteSubscriptionInstance(client, "Filter02",
        PEGASUS_CLASSNAME_INDHANDLER_CIMXML, "Handler01");
    _deleteSubscriptionInstance(client, "Filter03",
        PEGASUS_CLASSNAME_INDHANDLER_CIMXML, "Handler01");
    _deleteSubscriptionInstance(client, "Filter04",
        PEGASUS_CLASSNAME_INDHANDLER_CIMXML, "Handler01");
    _deleteSubscriptionInstance(client, "Filter05",
        PEGASUS_CLASSNAME_INDHANDLER_CIMXML, "Handler01");
    _deleteSubscriptionInstance(client, "Filter06",
        PEGASUS_CLASSNAME_INDHANDLER_CIMXML, "Handler01");
    _deleteSubscriptionInstance(client, "Filter01",
        PEGASUS_CLASSNAME_INDHANDLER_CIMXML, "Handler02p");
    _deleteSubscriptionInstance(client, "Filter01",
        PEGASUS_CLASSNAME_INDHANDLER_SNMP, "Handler03");
    _deleteSubscriptionInstance(client, "Filter01",
        PEGASUS_CLASSNAME_LSTNRDST_CIMXML, "ListenerDestination01");
    _deleteSubscriptionInstance(client, "Filter11",
        PEGASUS_CLASSNAME_LSTNRDST_CIMXML, "ListenerDestination06");

    //
    //  Delete handler instances
    //
    _deleteHandlerInstance(client, PEGASUS_CLASSNAME_INDHANDLER_CIMXML,
        "Handler01");
    _deleteHandlerInstance(client, PEGASUS_CLASSNAME_INDHANDLER_CIMXML,
        "Handler02p");
    _deleteHandlerInstance(client, PEGASUS_CLASSNAME_INDHANDLER_SNMP,
        "Handler03");
    _deleteHandlerInstance(client, PEGASUS_CLASSNAME_LSTNRDST_CIMXML,
        "ListenerDestination01");
    _deleteHandlerInstance(client, PEGASUS_CLASSNAME_LSTNRDST_EMAIL,
        "EmailHandler01");
    _deleteHandlerInstance(client, PEGASUS_CLASSNAME_LSTNRDST_EMAIL,
        "EmailHandler02");

    //
    //  Delete filter instances
    //
    _deleteFilterInstance(client, "Filter01");
    _deleteFilterInstance(client, "Filter02");
    _deleteFilterInstance(client, "Filter03");
    _deleteFilterInstance(client, "Filter04");
#ifndef PEGASUS_DISABLE_CQL
    _deleteFilterInstance(client, "Filter04a");
#endif
    _deleteFilterInstance(client, "Filter05");
    _deleteFilterInstance(client, "Filter06");
}

void _test(CIMClient & client)
{
    try
    {
         String wql("WQL");
         String cql("DMTF:CQL");

        _createCimsubTests(client, wql);
        //        _delete(client);

#ifndef PEGASUS_DISABLE_CQL
        //        _createCimsubTests(client, cql);
        //        _delete(client);
#endif
    }

    catch (Exception & e)
    {
        cerr << "test failed: " << e.getMessage() << endl;
        exit (-1);
    }
}

#ifdef PEGASUS_ENABLE_SYSTEM_LOG_HANDLER

//
//  Creates filters, handlers, and subscriptions for syslog handler
//
void _createCimsubSyslogTests(CIMClient & client, String& qlang)
{
    CIMObjectPath path;
    String query;

    CIMInstance syslogfilter01(PEGASUS_CLASSNAME_INDFILTER);
    query = "SELECT * FROM CIM_ProcessIndication";
    _addStringProperty(syslogfilter01, "SystemCreationClassName",
         System::getSystemCreationClassName());
    _addStringProperty(syslogfilter01, "SystemName",
         System::getFullyQualifiedHostName());
    _addStringProperty(syslogfilter01,
         PEGASUS_PROPERTYNAME_CREATIONCLASSNAME.getString(),
         PEGASUS_CLASSNAME_INDFILTER.getString());
    _addStringProperty(syslogfilter01,
        PEGASUS_PROPERTYNAME_NAME.getString(),
        "SyslogFilter01");
    _addStringProperty(syslogfilter01, "SourceNamespace",
        SOURCENAMESPACE.getString ());
    _addStringProperty(syslogfilter01, PEGASUS_PROPERTYNAME_QUERY.getString(),
        query);
    _addStringProperty(syslogfilter01, "QueryLanguage", qlang);
    path = client.createInstance(NAMESPACE, syslogfilter01);

    //
    //  Create persistent syslog listener destination
    //
    CIMInstance syslogHandler01(PEGASUS_CLASSNAME_LSTNRDST_SYSTEM_LOG);
    _addStringProperty(syslogHandler01, "SystemCreationClassName",
         System::getSystemCreationClassName());
    _addStringProperty(syslogHandler01, "SystemName",
         System::getFullyQualifiedHostName());
    _addStringProperty(syslogHandler01,
         PEGASUS_PROPERTYNAME_CREATIONCLASSNAME.getString(),
         PEGASUS_CLASSNAME_LSTNRDST_SYSTEM_LOG.getString());
    _addStringProperty(syslogHandler01,
        PEGASUS_PROPERTYNAME_NAME.getString(),
        "SyslogHandler01");
    _addUint16Property(syslogHandler01,
        PEGASUS_PROPERTYNAME_PERSISTENCETYPE.getString(),
        PERSISTENCE_PERMANENT);
    _addStringProperty(syslogHandler01, "OtherPersistenceType",
        String::EMPTY, true);
    path = client.createInstance(NAMESPACE, syslogHandler01);

    //
    //  Create subscription with syslog handler
    //
    CIMInstance subscription_syslog1 = _buildSubscriptionInstance(
           _buildFilterOrHandlerPath(PEGASUS_CLASSNAME_INDFILTER,
               "SyslogFilter01",
               String::EMPTY,NAMESPACE),
               PEGASUS_CLASSNAME_LSTNRDST_SYSTEM_LOG,
               _buildFilterOrHandlerPath(PEGASUS_CLASSNAME_LSTNRDST_SYSTEM_LOG,
                 "SyslogHandler01"));
    path = client.createInstance(NAMESPACE, subscription_syslog1);
}

void _testSyslog(CIMClient & client)
{
    try
    {
         String wql("WQL");
         String cql("DMTF:CQL");

        _createCimsubSyslogTests(client, wql);
        //        _delete(client);

#ifndef PEGASUS_DISABLE_CQL
        //        _createCimsubSyslogTests(client, cql);
        //        _delete(client);
#endif
    }
    catch (Exception & e)
    {
        cerr << "setup failed: " << e.getMessage() << endl;
        exit (-1);
    }

    cout << "+++++ setup completed successfully" << endl;
}
#endif

#ifdef PEGASUS_ENABLE_EMAIL_HANDLER

//
//  Creates filters, handlers, and subscriptions for email handler