cimprovidercommand.cpp

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

            //cerr << ERR_MODULE_NOT_REGISTERED << endl;
            cerr << localizeMessage(MSG_PATH,
                ERR_MODULE_NOT_REGISTERED_KEY,
                ERR_MODULE_NOT_REGISTERED) << endl;
            exit(-1);
        }
        else
        {
            // List all the registered provider modules
            for (Uint32 i = 0; i < moduleInstances.size(); i++)
            {
                CIMInstance& instance = moduleInstances[i];
                instance.getProperty(
                instance.findProperty(_PROPERTY_PROVIDERMODULE_NAME)).getValue().get(moduleName);
                moduleNames.append(moduleName);
                instances.append(instance);
            }

            _printList(moduleNames, instances, outPrintWriter, errPrintWriter);
        }
    }
}

// Get namedInstance for a provider module
CIMInstance CIMProviderCommand::_getModuleInstance()
{

    CIMKeyBinding kb(_PROPERTY_PROVIDERMODULE_NAME,
                     _moduleName, CIMKeyBinding::STRING);

    Array<CIMKeyBinding> kbArray;
    kbArray.append(kb);

    CIMObjectPath moduleRef("", PEGASUS_NAMESPACENAME_PROVIDERREG,
                            PEGASUS_CLASSNAME_PROVIDERMODULE,
                            kbArray);

    try
    {
        CIMInstance instance = _client->getInstance(
        PEGASUS_NAMESPACENAME_PROVIDERREG, moduleRef);
        return (instance);
    }
    catch (const CIMException&)
    {
        // Provider module was not registered yet
        //l10n
        //cerr << ERR_MODULE_NOT_REGISTERED << endl;
        cerr << localizeMessage(MSG_PATH,
            ERR_MODULE_NOT_REGISTERED_KEY,
            ERR_MODULE_NOT_REGISTERED) << endl;
        exit(-1);
    }
    catch (const Exception&)
    {
        // Provider module was not registered yet
        //l10n
        //cerr << ERR_MODULE_NOT_REGISTERED << endl;
        cerr << localizeMessage(MSG_PATH,
            ERR_MODULE_NOT_REGISTERED_KEY,
            ERR_MODULE_NOT_REGISTERED) << endl;
        exit(-1);
    }

    // Keep the compiler happy
    return CIMInstance();
}

// Get namedInstance for a provider
CIMInstance CIMProviderCommand::_getProviderInstance()
{

    CIMKeyBinding kb(_PROPERTY_PROVIDERMODULENAME,
                     _moduleName, CIMKeyBinding::STRING);

    CIMKeyBinding kb2(_PROPERTY_PROVIDER_NAME,
                     _providerName, CIMKeyBinding::STRING);

    Array<CIMKeyBinding> kbArray;
    kbArray.append(kb);
    kbArray.append(kb2);

    CIMObjectPath providerRef("", PEGASUS_NAMESPACENAME_PROVIDERREG,
                            PEGASUS_CLASSNAME_PROVIDER,
                            kbArray);

    try
    {
        CIMInstance instance = _client->getInstance(
            PEGASUS_NAMESPACENAME_PROVIDERREG, providerRef);
        return (instance);
    }
    catch (const CIMException&)
    {
        // Provider was not registered yet
        //l10n
        //cerr << ERR_PROVIDER_NOT_REGISTERED << endl;
        cerr << localizeMessage(MSG_PATH,
            ERR_PROVIDER_NOT_REGISTERED_KEY,
            ERR_PROVIDER_NOT_REGISTERED) << endl;
        exit(-1);
    }
    catch (const Exception&)
    {
        // Provider was not registered yet
        //l10n
        //cerr << ERR_PROVIDER_NOT_REGISTERED << endl;
        cerr << localizeMessage(MSG_PATH,
            ERR_PROVIDER_NOT_REGISTERED_KEY,
            ERR_PROVIDER_NOT_REGISTERED) << endl;
        exit(-1);
    }

    // Keep the compiler happy
    return CIMInstance();
}

// Print out registered modules and status
void CIMProviderCommand::_printList(Array<String> & moduleNames,
    Array<CIMInstance> & instances,
    ostream& outPrintWriter,
    ostream& errPrintWriter)
{
    Uint32 maxLength=0;
    Uint32 length=0;
    Array<Uint16> _status;
    String output;
    String statusValue;

    if (_statusSet)
    {
        // get max length of module name
        for (Uint32 i=0; i < moduleNames.size(); i++)
        {
            if (maxLength < moduleNames[i].size())
            {
                maxLength = moduleNames[i].size();
            }
        }

        output = "MODULE";

        for (Uint32 i = 0; i < maxLength; i++)
        {
            output.append(" ");
        }

        output.append("STATUS");
#ifdef PEGASUS_OS_VMS
        // 
        // When outputing to a file using outPrintWriter,
        // characters appear one per line.
        // Use printf instead.
        // 
        printf("%s\n", (const char *) output.getCString());
#else
        outPrintWriter << output << endl;
#endif

        for (Uint32 i =0; i < instances.size(); i++)
        {
            output = moduleNames[i];
            length = maxLength +6 - moduleNames[i].size();

            for (Uint32 j = 0; j < length; j++)
            {
                output.append(" ");
            }

            Uint32 pos = instances[i].findProperty(_PROPERTY_OPERATIONALSTATUS);
            if (pos == PEG_NOT_FOUND)
            {
                _status.append(0);
            }
            else
            {
                if( instances[i].getProperty(pos).getValue().isNull() ){
                    if( _status.size() == 0 )
                                _status.append(0);
                }
                else
                    instances[i].getProperty(pos).getValue().get(_status);
            }

            for (Uint32 j=0; j < _status.size(); j++)
            {
                switch ( _status[j])
                {
                    case 0:
                    {
                        statusValue = "Unknown";
                        break;
                    }

                    case 1:
                    {
                        statusValue = "Other";
                        break;
                    }

                    case 2:
                    {
                        statusValue = "OK";
                        break;
                    }

                    case 3:
                    {
                        statusValue = "Degraded";
                        break;
                    }

                    case 4:
                    {
                        statusValue = "Stressed";
                        break;
                    }

                    case 5:
                    {
                        statusValue = "Predictive Failure";
                        break;
                    }

                    case 6:
                    {
                        statusValue = "Error";
                        break;
                    }

                    case 7:
                    {
                        statusValue = "Non-Recoverable Error";
                        break;
                    }

                    case 8:
                    {
                        statusValue = "Starting";
                        break;
                    }

                    case 9:
                    {
                        statusValue = "Stopping";
                        break;
                    }

                    case 10:
                    {
                        statusValue = "Stopped";
                        break;
                    }

                    case 11:
                    {
                        statusValue = "In Service";
                        break;
                    }

                    case 12:
                    {
                        statusValue = "No Contact";
                        break;
                    }

                    case 13:
                    {
                        statusValue = "Lost Communication";
                        break;
                    }

                    default:
                        statusValue = "Not Support";
                        break;
                }
                output.append(statusValue);
                output.append(" ");
            }
#ifdef PEGASUS_OS_VMS
            // 
            // When outputing to a file using outPrintWriter,
            // characters appear one per line.
            // Use printf instead.
            // 
            printf("%s\n", (const char *) output.getCString());
#else
            outPrintWriter << output << endl;
#endif
        }

    }
    else
    {
        for (Uint32 i=0; i < moduleNames.size(); i++)
        {
#ifdef PEGASUS_OS_VMS
            // 
            // When outputing to a file using outPrintWriter,
            // characters appear one per line.
            // Use printf instead.
            // 
            printf("%s\n", (const char *) moduleNames[i].getCString());
#else
            outPrintWriter << moduleNames[i] << endl;
#endif
        }
    }
}

PEGASUS_NAMESPACE_END

//
// exclude main from the Pegasus Namespace
//
PEGASUS_USING_PEGASUS;

PEGASUS_USING_STD;

///////////////////////////////////////////////////////////////////////////////
/**
    Parses the command line, and execute the command.

    @param   args  the string array containing the command line arguments
*/
///////////////////////////////////////////////////////////////////////////////

int main (int argc, char* argv [])
{
    AutoPtr<CIMProviderCommand>  command;
    Uint32               retCode;

    MessageLoader::_useProcessLocale = true; //l10n set message loading to process locale
    MessageLoader::setPegasusMsgHomeRelative(argv[0]);

#ifdef PEGASUS_OS_OS400

    VFYPTRS_INCDCL;               // VFYPTRS local variables

  // verify pointers
#pragma exception_handler (qsyvp_excp_hndlr,qsyvp_excp_comm_area,\
    0,_C2_MH_ESCAPE)
    for( int arg_index = 1; arg_index < argc; arg_index++ ){
          VFYPTRS(VERIFY_SPP_NULL(argv[arg_index]));
    }
#pragma disable_handler

    // Convert the args to ASCII
    for(Uint32 i = 0;i< argc;++i)
    {
      EtoA(argv[i]);
    }

    // Set the stderr stream to buffered with 32k.
    // Allows utf-8 to be sent to stderr. (P9A66750)
    setvbuf(stderr, new char[32768], _IOLBF, 32768);

    // check what environment we are running in, native or qsh
    if( getenv(
#pragma convert(37)
               "SHLVL"
#pragma convert(0)
               ) == NULL ){  // native mode
      // Check to ensure the user is authorized to use the command,
      // suppress diagnostic message
      if(FALSE == ycmCheckCmdAuthorities(1)){
        exit(CPFDF80_RC);
      }
    }
    else{ // qsh mode
      // Check to ensure the user is authorized to use the command
      // ycmCheckCmdAuthorities() will send a diagnostic message to qsh
      if(FALSE == ycmCheckCmdAuthorities()){
        exit(CPFDF80_RC);
      }
    }

#endif

    command.reset(new CIMProviderCommand ());

    try
    {
        command->setCommand ( cout, cerr, argc, argv);
    }
    catch (CommandFormatException& cfe)
    {
        String msg(cfe.getMessage());

        cerr << COMMAND_NAME << ": " << msg <<  endl;

        if (msg.find(String("Unknown flag")) != PEG_NOT_FOUND)
         {
           MessageLoaderParms parms(ERR_OPTION_NOT_SUPPORTED_KEY,ERR_OPTION_NOT_SUPPORTED);
           parms.msg_src_path = MSG_PATH;
           cerr << COMMAND_NAME <<
             ": " << MessageLoader::getMessage(parms) << endl;
         }
        else
         {
           MessageLoaderParms parms(ERR_USAGE_KEY,ERR_USAGE);
           parms.msg_src_path = MSG_PATH;
           cerr << COMMAND_NAME <<
             ": " << MessageLoader::getMessage(parms) << endl;
         }

        return 1;
    }

    retCode = command->execute (cout, cerr);

    //exit(retCode);
    return (retCode);
}