cimmofparser.cpp

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

    cimmofMessages::getMessage(message,
        cimmofMessages::UNINITIALIZED_PROPERTY_ERROR,
        arglist);
    maybeThrowParseError(message);
  } catch(AlreadyExistsException&) {
    cimmofMessages::getMessage(message,
        cimmofMessages::PROPERTY_ALREADY_EXISTS_WARNING,
        arglist);
    wlog(message);
  } catch(Exception &e) {
    arglist.append(e.getMessage());
    cimmofMessages::getMessage(message,
        cimmofMessages::APPLYING_PROPERTY_ERROR,
        arglist);
    maybeThrowParseError(message);
  }

  return 0;
}

//-----------------------------------------------------------------------
// When a property production is complete, apply it to the
// instance being declared.
//-----------------------------------------------------------------------
int
cimmofParser::applyProperty(CIMInstance &i, CIMProperty &p)
{
  cimmofMessages::arglist arglist;
  const CIMName &propertyName = p.getName();
  arglist.append(i.getClassName().getString());
  arglist.append(propertyName.getString());
  String message;
  Boolean err_out = false;
  try {
    Uint32 pos = i.findProperty(propertyName);
    if (pos == (Uint32)-1) {
      i.addProperty(p);   // Add the property
    } else {
      // ATTN: 2001 There doesn't seem to be a way to change a property value
      // yet.
    }
  } catch (CIMException &e) {
    if (e.getCode() == CIM_ERR_ALREADY_EXISTS) {
      cimmofMessages::getMessage(message,
          cimmofMessages::INSTANCE_PROPERTY_EXISTS_WARNING,
          arglist);
      wlog(message);
    } else {
      arglist.append(e.getMessage());
      err_out = true;
    }
  } catch (Exception &e) {
    arglist.append(e.getMessage());
    err_out = true;
  }
  if (err_out) {
    cimmofMessages::getMessage(message,
        cimmofMessages::APPLY_INSTANCE_PROPERTY_ERROR,
        arglist);
    maybeThrowParseError(message);
  }
  return 0;
}

//----------------------------------------------------------------------
// When a property object's value changes, create a clone of the
// property object with a new value
//----------------------------------------------------------------------
CIMProperty *
cimmofParser::copyPropertyWithNewValue(const CIMProperty &p,
    const CIMValue &v) const
{
  cimmofMessages::arglist arglist;
  String message;
  CIMProperty *newprop = 0;
  arglist.append(p.getName().getString());
  try {
    newprop = new CIMProperty(p);
    newprop->setValue(v);
  } catch (Exception &e) {
    arglist.append(e.getMessage());
    cimmofMessages::getMessage(message,
        cimmofMessages::CLONING_PROPERTY_ERROR,
        arglist);
    maybeThrowParseError(message);
  }
  return newprop;
}

//----------------------------------------------------------------------
// When a method of a class being declared is discovered, create the
// new CIMMethod object.
//----------------------------------------------------------------------
CIMMethod *
cimmofParser::newMethod(const CIMName &name, const CIMType type)
{
  CIMMethod *m = 0;
  try {
    m = new CIMMethod(name, type);
  } catch(Exception &e) {
    cimmofMessages::arglist arglist;
    String message;
    arglist.append(name.getString());
    arglist.append(e.getMessage());
    cimmofMessages::getMessage(message, cimmofMessages::NEW_METHOD_ERROR,
        arglist);
    maybeThrowParseError(message);
  }
  return m;
}

//-----------------------------------------------------------------------
// When a method production is complete, apply it to the
// class being declared.
//-----------------------------------------------------------------------
int
cimmofParser::applyMethod(CIMClass &c, CIMMethod &m) {
  cimmofMessages::arglist arglist;
  String message;
  arglist.append(m.getName().getString());
  arglist.append(c.getClassName().getString());
  try {
    c.addMethod(m);
  } catch(UninitializedObjectException&) {
    cimmofMessages::getMessage(message,
        cimmofMessages::UNINITIALIZED_PARAMETER_ERROR,
        arglist);
    maybeThrowParseError(message);
  } catch(AlreadyExistsException&) {
    cimmofMessages::getMessage(message,
        cimmofMessages::METHOD_ALREADY_EXISTS_WARNING,
        arglist);
    wlog(message);
  } catch(Exception &e) {
    arglist.append(e.getMessage());
    cimmofMessages::getMessage(message,
        cimmofMessages::APPLY_METHOD_ERROR,
        arglist);
    maybeThrowParseError(message);
  }

  return 0;
}

CIMParameter *
cimmofParser::newParameter(const CIMName &name, const CIMType type,
    Boolean isArray, Uint32 array, const CIMName &objName)
{
  CIMParameter *p = 0;
  try {
    p = new CIMParameter(name, type, isArray, array, objName);
  } catch(Exception &e) {
    cimmofMessages::arglist arglist;
    arglist.append(name.getString());
    arglist.append(e.getMessage());
    String message;
    cimmofMessages::getMessage(message, cimmofMessages::NEW_PARAMETER_ERROR,
        arglist);
    maybeThrowParseError(message);
  }
  return p;
}

int
cimmofParser::applyParameter(CIMMethod &m, CIMParameter &p) {
  try {
    m.addParameter(p);
  } catch(CIMException &e) {
    cimmofMessages::arglist arglist;
    String message;
    arglist.append(p.getName().getString());
    arglist.append(m.getName().getString());
    arglist.append(e.getMessage());
    cimmofMessages::getMessage(message, cimmofMessages::APPLY_PARAMETER_ERROR,
        arglist);
    maybeThrowParseError(message);
  }
  return 0;
}



CIMValue *
cimmofParser::QualifierValue(const CIMName &qualifierName,
                             Boolean isNull,
                             const String &valstr)
{
  CIMQualifierDecl q;
  try {
    q = _repository.getQualifierDecl(getNamespacePath(), qualifierName);
  }
  catch (CIMException &e) {
    cimmofMessages::arglist arglist;
    String message;
    arglist.append(qualifierName.getString());
    arglist.append(e.getMessage());
    cimmofMessages::getMessage(message,
        cimmofMessages::GET_QUALIFIER_DECL_ERROR,
        arglist);
    maybeThrowParseError(message);
  }

  CIMValue v = q.getValue();
  Uint32 asize = v.getArraySize();

  if (isNull && (v.getType() == CIMTYPE_BOOLEAN))
  {
    // From CIM Specification version 2.2 section 4.5.4:
    //   If only the qualifier name is listed for a boolean qualifier,
    //   it is implicitly set to TRUE.
    return new CIMValue(Boolean(true));
  }
  return valueFactory::createValue(v.getType(),
      v.isArray() ? (int)asize : -1,
      isNull,
      &valstr);
}

CIMProperty *
cimmofParser::PropertyFromInstance(CIMInstance &instance,
    const CIMName &propertyName) const
{
  cimmofMessages::arglist arglist;
  arglist.append(propertyName.getString());
  CIMName className;
  String message;
  try {
    Uint32 pos = instance.findProperty(propertyName);
    if (pos != (Uint32)-1) {
      //ATTN: P2 2001 There doesn't seem to be a way to get a copy of an
      // instance's properties (or to change them if you got one)
      CIMProperty oldp = instance.getProperty(pos);
      //CIMProperty *p = new CIMProperty(oldp);
      //return p;
    }
  } catch (Exception &e) {
    arglist.append(e.getMessage());
    cimmofMessages::getMessage(message,
        cimmofMessages::GET_INSTANCE_PROPERTY_ERROR,
        arglist);
    maybeThrowParseError(message);
  }
  // That didn't work.  Try getting the property from the class decl
  try {
    className = instance.getClassName();
  } catch (Exception &e) {
    arglist.append(className.getString());
    arglist.append(e.getMessage());
    cimmofMessages::getMessage(message,
        cimmofMessages::FIND_CLASS_OF_INSTANCE_ERROR,
        arglist);
    maybeThrowParseError(message);
  }
  // OK, we got the className.  Use it to find the class object.
  try {
    Array<String> propertyList;
    propertyList.append(propertyName.getString());
    CIMClass c = _repository.getClass(getNamespacePath(), className);
    Uint32 pos = c.findProperty(propertyName);
    if (pos != (Uint32)-1) {
      return new CIMProperty(c.getProperty(pos));
    }
  } catch (Exception &e) {
    arglist.append(className.getString());
    arglist.append(getNamespacePath());
    arglist.append(e.getMessage());
    cimmofMessages::getMessage(message,
        cimmofMessages::GET_CLASS_ERROR,
        arglist);
    maybeThrowParseError(message);
  }
  const CIMValue defaultValue(false);
  // KS 8 Mar add the values for isArray and arraysize (defaults)
  CIMProperty *p = newProperty(propertyName, defaultValue, false, 0);
  return p;
}

CIMValue *
cimmofParser::ValueFromProperty(const CIMProperty &prop) const
{
  CIMName propname;
  try {
    propname = prop.getName();
    const CIMValue &v = prop.getValue();
    return new CIMValue(v);
  } catch (Exception &e) {
    cimmofMessages::arglist arglist;
    String message;
    arglist.append(propname.getString());
    arglist.append(e.getMessage());
    cimmofMessages::getMessage(message,
        cimmofMessages::GET_PROPERTY_VALUE_ERROR,
        arglist);
    maybeThrowParseError(message);
  }
  return new CIMValue();
}


CIMValue *
cimmofParser::PropertyValueFromInstance(CIMInstance &instance,
    const CIMName &propertyName)const
{
  CIMProperty *prop = PropertyFromInstance(instance, propertyName);
  CIMValue *value = ValueFromProperty(*prop);
  delete prop;
  return value;
}

CIMObjectPath *
cimmofParser::newReference(const objectName &oname)
{
  String nameSpaceString = oname.handle();
  CIMNamespaceName nameSpace;
  if (nameSpaceString != String::EMPTY)
  {
    nameSpace = nameSpaceString;
  }

  CIMObjectPath *ref = 0;
  try {
    ref = new CIMObjectPath(oname.host(), nameSpace, oname.className(),
        oname.KeyBindings());
  } catch(Exception &e) {
    cimmofMessages::arglist arglist;
    arglist.append(oname.className());
    arglist.append(e.getMessage());
    String message;
    cimmofMessages::getMessage(message, cimmofMessages::NEW_REFERENCE_ERROR,
        arglist);
    maybeThrowParseError(message);
  }
  return ref;
}

void
cimmofParser::addClassAlias(const String &alias, const CIMClass *cd,
    Boolean isInstance)
{
  // ATTN: P3 BB 2001 ClassAlias - to be deprecated.  Simply warning here
}


Array <String> aliasName;
Array <CIMObjectPath> aliasObjPath;


Uint32
cimmofParser::addInstanceAlias(const String &alias, const CIMInstance *cd,
    Boolean isInstance)
{

  CIMObjectPath objpath;

#ifdef DEBUG_cimmofParser
  printf("addInstanceAlias: aliasName.size = %d\n", aliasName.size());
  cout << "addInstanceAlias: alias = " << alias << endl;
  cout << "addInstanceAlias class name = " << cd->getClassName().getString() << endl;
#endif // DEBUG_cimmofParser


  // verify new alias doesn't already exists
  CIMObjectPath tmpobjpath;
  if (getInstanceAlias(alias, tmpobjpath) == 1)
    {
      return (0);
    }


  // Get the class from the repository
  CIMClass classrep;
  Boolean classExist = true;

  try
  {
    classrep = _repository.getClass(getNamespacePath(), cd->getClassName());
  }
  catch (const CIMException &e)
  {
    if (e.getCode() == CIM_ERR_NOT_FOUND)
    {
        classExist = false;
    }
    else
    if (e.getCode() == CIM_ERR_INVALID_CLASS)
    {
        /* Note:  this is where cimmofl and cimmof fall into */
        classExist = false;
    }
    else
    {
        throw;
    }
  }

  objpath = cd->buildPath(classrep);

#ifdef DEBUG_cimmofParser
  cout << "addInstance objPath = " << objpath.toString() << endl;
#endif // DEBUG_cimmofParser

  aliasName.append(alias);
  aliasObjPath.append(objpath);

  return(1);
}

Uint32
cimmofParser::getInstanceAlias(const String &alias, CIMObjectPath &ObjPath)
{
  for (Uint32 i=0; i < aliasName.size(); i++)
    {

#ifdef DEBUG_cimmofParser
      cout << "getInstanceAlias: aliasName[" << i << "] = " << aliasName[i].getCString() << endl;
      cout << "getInstanceAlias: aliasObjPath[" << i << "] = " << aliasObjPath[i].toString() << endl;
#endif // DEBUG_cimmofParser

      if (alias == aliasName[i])
	{
	  ObjPath = aliasObjPath[i];

#ifdef DEBUG_cimmofParser
	  cout << "getInstanceAlias: alias found = " << aliasName[i] << endl;
          cout << "getInstanceAlias: aliasObjPath found = " << aliasObjPath[i].toString() << endl;
#endif // DEBUG_cimmofParser

	  return (1);
	}
    }

#ifdef DEBUG_cimmofParser
  cout << "getInstanceAlias: alias NOT found" << endl;
#endif // DEBUG_cimmofParser

  return (0);
}



    //-------------------------------------------------------------------
    //  Class Private methods
    //-------------------------------------------------------------------
//--------------------------------------------------------------------
// Error logging
//--------------------------------------------------------------------
void
cimmofParser::elog(const String &msg) const
{
  if (_cmdline)
    if (!_cmdline->suppress_all_messages() && !_cmdline->suppress_warnings())
      _cmdline->erroros() << msg << endl;
}

//----------------------------------------------------------------------
// Warning logging
//----------------------------------------------------------------------
void
cimmofParser::wlog(const String &msg) const
{
  if (_cmdline)
    if (!_cmdline->suppress_all_messages())
      if (!_cmdline->suppress_warnings())
        _cmdline->warningos() << msg << endl;
}

//-------------------------------------------------------------------
// Tracing
//-------------------------------------------------------------------
void
cimmofParser::trace(const String &head, const String &tail) const
{
  if (_cmdline)
    _cmdline->traceos() << head << " " << tail << endl;