gowbem

package
v0.0.0-...-d7315a6 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 25, 2017 License: GPL-3.0 Imports: 11 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// A general error occurred that is not covered by a more specific error code.
	ErrFailed = 1

	// Access to a CIM resource is not available to the client.
	ErrAccessDenied = 2

	// The target namespace does not exist.
	ErrInvalidNamespace = 3

	// One or more parameter values passed to the method are not valid.
	ErrInvalidParameter = 4

	// The specified class does not exist.
	ErrInvalidClass = 5

	// The requested object cannot be found. The operation can be unsupported on behalf of the WBEM server in general or on behalf of an implementation of a management profile.
	ErrNotFound = 6

	// The requested operation is not supported on behalf of the WBEM server, or on behalf of a provided class. If the operation is supported for a provided class but is not supported for particular instances of that class, then CIM_ERR_FAILED shall be used.
	ErrNotSupported = 7

	// The operation cannot be invoked on this class because it has subclasses.
	ErrClassHasChildren = 8

	// The operation cannot be invoked on this class because one or more instances of this class exist.
	ErrClassHasInstances = 9

	// The operation cannot be invoked because the specified superclass does not exist.
	ErrInvalidSuperclass = 10

	// The operation cannot be invoked because an object already exists.
	ErrAlreadyExists = 11

	// The specified property does not exist.
	ErrNoSuchProperty = 12

	// The value supplied is not compatible with the type.
	ErrTypeMismatch = 13

	// The query language is not recognized or supported.
	ErrQueryLanguageNotSupported = 14

	// The query is not valid for the specified query language.
	ErrInvalidQuery = 15

	// The extrinsic method cannot be invoked.
	ErrMethodNotAvailable = 16

	// The specified extrinsic method does not exist.
	ErrMethodNotFound = 17

	// The specified namespace is not empty.
	ErrNameSpaceNotEmpty = 20

	// The enumeration identified by the specified context cannot be found, is in a closed state, does not exist, or is otherwise invalid.
	ErrInvalidEnumerationContext = 21

	// The specified operation timeout is not supported by the WBEM server.
	ErrInvalidOperationTimeout = 22

	// The pull operation has been abandoned due to execution of a concurrent CloseEnumeration operation on the same enumeration.
	ErrPullHasBeenAbandoned = 23

	// The attempt to abandon a concurrent pull operation on the same enumeration
	// failed. The concurrent pull operation proceeds normally.
	ErrPullCannotBeAbandoned = 24

	// Using a a filter query in pulled enumerations is not supported by the WBEM server.
	ErrFilteredEnumerationNotSupported = 25

	// The WBEM server does not support continuation on error.
	ErrContinuationOnErrorNotSupported = 26

	// The WBEM server has failed the operation based upon exceeding server limits.
	ErrServerLimitsExceeded = 27

	// The WBEM server is shutting down and cannot process the operation.
	ErrServerIsShuttingDown = 28
)
View Source 
const (
	// The CIMOperation header shall be present in all CIM Operation Request and CIM Operation Response messages. It identifies the HTTP message as carrying a CIM operation request or response.
	//      CIMOperation = "CIMOperation" ":" ("MethodCall" | "MethodResponse")
	HttpHdrOperation = "CIMOperation"

	// The CIMExport header shall be present in all CIM export request and response messages. It identifies the HTTP message as carrying a CIM export method request or response.
	//      CIMExport = "CIMExport" ":" ("MethodRequest" | "MethodResponse")
	HttpHdrExport = "CIMExport"

	// The CIMProtocolVersion header may be present in any CIM message. The header identifies the version of the CIM operations over the HTTP specification in use by the sending entity.
	//      CIMProtocolVersion = "CIMProtocolVersion" ":" 1*DIGIT "." 1*DIGIT
	HttpHdrProtocolVersion = "CIMProtocolVersion"

	// The CIMMethod header shall be present in any CIM Operation Request message that contains a Simple Operation Request.
	// The name of the CIM method within a simple operation request is the value of the NAME attribute of the <METHODCALL> or <IMETHODCALL> element.
	//      CIMMethod = "CIMMethod" ":" MethodName
	//      MethodName = CIMIdentifier
	HttpHdrMethod = "CIMMethod"

	// The CIMObject header shall be present in any CIM Operation Request message that contains a Simple Operation Request.
	//      CIMObject = "CIMObject" ":" ObjectPath
	//      ObjectPath = CIMObjectPath
	HttpHdrObject = "CIMObject"

	// The CIMExportMethod header shall be present in any CIM export request message that contains a simple export request.
	//      CIMExportMethod = "CIMExportMethod" ":" ExportMethodName
	//      ExportMethodName = CIMIdentifier
	HttpHdrExportMethod = "CIMExportMethod"

	// The CIMBatch header shall be present in any CIM Operation Request message that contains a Multiple Operation Request.
	//      CIMBatch = "CIMBatch" ":"
	HttpHdrBatch = "CIMBatch"

	// The CIMExportBatch header shall be present in any CIM export request message that contains a multiple export request.
	//      CIMExportBatch = "CIMExportBatch" ":"
	HttpHdrExportBatch = "CIMExportBatch"

	// The CIMError header may be present in any HTTP response to a CIM message request that is not a CIM message response.
	//      CIMError = "CIMError" ":" cim-error
	//      cim-error = "unsupported-protocol-version" |
	//                  "multiple-requests-unsupported" |
	//                  "unsupported-cim-version" |
	//                  "unsupported-dtd-version" |
	//                  "request-not-valid" |
	//                  "request-not-well-formed" |
	//                  "request-not-loosely-valid" |
	//                  "header-mismatch" |
	//                  "unsupported-operation"
	HttpHdrError = "CIMError"

	// A CIM server may return a CIMRoleAuthenticate header as part of the 401 Unauthorized response along with the WWW-Authenticate header. The CIMRoleAuthenticate header must meet the challenge of indicating the CIM server policy on role credentials.
	//      challenge = "credentialrequired" | "credentialoptional" | "credentialnotrequired"
	HttpHdrAuthenticate = "CIMRoleAuthenticate"

	// The CIMRoleAuthorization header is supplied along with the normal authorization header that the CIM client populates to perform user authentication. If the CIM client needs to perform role assumption and the server challenge is credentialrequired, the CIMRoleAuthorization header must be supplied with the appropriate credentials. The credentials supplied as part of the CIMRoleAuthorization header must use the same scheme as those specified for the authorization header, as specified in RFC 2617. Therefore, both Basic and Digest authentication are possible for the role credential.
	HttpHdrRoleAuthorization = "CIMRoleAuthorization"

	// If a CIM product includes the CIMStatusCode trailer, it may also include the CIMStatusCodeDescription trailer.
	HttpHdrStatusCodeDescription = "CIMStatusCodeDescription"

	// The WBEMServerResponseTime header may be present in any CIM response message.
	HttpHdrServerResponseTime = "WBEMServerResponseTime"
)
View Source 
const (
	SchemeHttp       string        = "http"
	SchemeHttps      string        = "https"
	DefaultPortHttp  int           = 5988
	DefaultPortHttps int           = 5989
	DefaultNamespace string        = "root/cimv2"
	DefaultTimeout   time.Duration = 120 * time.Second
)
View Source 
const (
	DefaultRequestURI string = "cimom"
)

Variables

This section is empty.

Functions

func IsLoggerEnabled 

func IsLoggerEnabled() bool

func SetLoggerEnabled 

func SetLoggerEnabled(enabled bool)

Types

type CIM 

type CIM struct {
	CIMVersion  string       `xml:"CIMVERSION,attr" json:",omitempty"`
	DTDVersion  string       `xml:"DTDVERSION,attr" json:",omitempty"`
	Message     *Message     `xml:"MESSAGE" json:",omitempty"`
	Declaration *Declaration `xml:"DECLARATION" json:",omitempty"`
}

<!ELEMENT CIM (MESSAGE | DECLARATION)> <!ATTLIST CIM 

CIMVERSION CDATA #REQUIRED
DTDVERSION CDATA #REQUIRED

>

type CIMErr 

type CIMErr struct {
	ErrCode int
	ErrName string
	ErrDesc string
}

func (CIMErr) Error 

func (err CIMErr) Error() string

type Class 

type Class struct {
	Name              string              `xml:"NAME,attr,omitempty" json:",omitempty"`
	SuperClass        string              `xml:"SUPERCLASS,attr,omitempty" json:",omitempty"`
	Qualifier         []Qualifier         `xml:"QUALIFIER" json:",omitempty"`
	Property          []Property          `xml:"PROPERTY" json:",omitempty"`
	PropertyArray     []PropertyArray     `xml:"PROPERTY.ARRAY" json:",omitempty"`
	PropertyReference []PropertyReference `xml:"PROPERTY.REFERENCE" json:",omitempty"`
	Method            []Method            `xml:"METHOD" json:",omitempty"`
}

<!-- ************************************************** Object definition elements ************************************************** --> <!ELEMENT CLASS (QUALIFIER*, (PROPERTY | PROPERTY.ARRAY | PROPERTY.REFERENCE)*, METHOD*)> <!ATTLIST CLASS 

%CIMName;
%SuperClass;

>

type ClassName 

type ClassName struct {
	Name string `xml:"NAME,attr,omitempty" json:",omitempty"`
}

<!ELEMENT CLASSNAME EMPTY> <!ATTLIST CLASSNAME 

%CIMName;

>

type ClassPath 

type ClassPath struct {
	NamespacePath *NamespacePath `xml:"NAMESPACEPATH" json:",omitempty"`
	ClassName     *ClassName     `xml:"CLASSNAME" json:",omitempty"`
}

<!ELEMENT CLASSPATH (NAMESPACEPATH, CLASSNAME)>

type Correlator 

type Correlator struct {
	Name  string `xml:"NAME,attr,omitempty" json:",omitempty"`
	Type  string `xml:"TYPE,attr" json:",omitempty"`
	Value *Value `xml:"VALUE" json:",omitempty"`
}

<!ELEMENT CORRELATOR (VALUE)> <!ATTLIST CORRELATOR 

%CIMName;
%CIMType; #REQUIRED

>

type DeclGroup 

type DeclGroup struct {
	LocalNamespacePath   *LocalNamespacePath    `xml:"LOCALNAMESPACEPATH" json:",omitempty"`
	NamespacePath        *NamespacePath         `xml:"NAMESPACEPATH" json:",omitempty"`
	QualifierDeclaration []QualifierDeclaration `xml:"QUALIFIER.DECLARATION" json:",omitempty"`
	ValueObject          []ValueObject          `xml:"VALUE.OBJECT" json:",omitempty"`
}

<!ELEMENT DECLGROUP ((LOCALNAMESPACEPATH | NAMESPACEPATH)?, QUALIFIER.DECLARATION*, VALUE.OBJECT*)>

type DeclGroupWithName 

type DeclGroupWithName struct {
	LocalNamespacePath   *LocalNamespacePath    `xml:"LOCALNAMESPACEPATH" json:",omitempty"`
	NamespacePath        *NamespacePath         `xml:"NAMESPACEPATH" json:",omitempty"`
	QualifierDeclaration []QualifierDeclaration `xml:"QUALIFIER.DECLARATION" json:",omitempty"`
	ValueNamedObject     []ValueNamedObject     `xml:"VALUE.NAMEDOBJECT" json:",omitempty"`
}

<!ELEMENT DECLGROUP.WITHNAME ((LOCALNAMESPACEPATH | NAMESPACEPATH)?, QUALIFIER.DECLARATION*, VALUE.NAMEDOBJECT*)>

type DeclGroupWithPath 

type DeclGroupWithPath struct {
	ValueObjectWithPath      *ValueObjectWithPath      `xml:"VALUE.OBJECTWITHPATH" json:",omitempty"`
	ValueObjectWithLocalPath *ValueObjectWithLocalPath `xml:"VALUE.OBJECTWITHLOCALPATH" json:",omitempty"`
}

<!ELEMENT DECLGROUP.WITHPATH (VALUE.OBJECTWITHPATH | VALUE.OBJECTWITHLOCALPATH)*>

type Declaration 

type Declaration struct {
	DeclGroup         []DeclGroup         `xml:"DECLGROUP" json:",omitempty"`
	DeclGroupWithName []DeclGroupWithName `xml:"DECLGROUP.WITHNAME" json:",omitempty"`
	DeclGroupWithPath []DeclGroupWithPath `xml:"DECLGROUP.WITHPATH" json:",omitempty"`
}

<!ELEMENT DECLARATION (DECLGROUP | DECLGROUP.WITHNAME | DECLGROUP.WITHPATH)+>

type Error 

type Error struct {
	Code        string `xml:"CODE,attr" json:",omitempty"`
	Description string `xml:"DESCRIPTION,attr" json:",omitempty"`
}

<!ELEMENT ERROR (INSTANCE*)> <!ATTLIST ERROR 

CODE CDATA #REQUIRED
DESCRIPTION CDATA #IMPLIED

>

type ExpMethodCall 

type ExpMethodCall struct {
	Name          string          `xml:"NAME,attr,omitempty" json:",omitempty"`
	ExpParamValue []ExpParamValue `xml:"EXPPARAMVALUE" json:",omitempty"`
}

<!ELEMENT EXPMETHODCALL (EXPPARAMVALUE*)> <!ATTLIST EXPMETHODCALL 

%CIMName;

>

type ExpMethodResponse 

type ExpMethodResponse struct {
	Name         string        `xml:"NAME,attr,omitempty" json:",omitempty"`
	Error        *Error        `xml:"ERROR" json:",omitempty"`
	IReturnValue *IReturnValue `xml:"IRETURNVALUE" json:",omitempty"`
}

<!ELEMENT EXPMETHODRESPONSE (ERROR | IRETURNVALUE?)> <!ATTLIST EXPMETHODRESPONSE 

%CIMName;

>

type ExpParamValue 

type ExpParamValue struct {
	Name     string    `xml:"NAME,attr,omitempty" json:",omitempty"`
	Instance *Instance `xml:"INSTANCE" json:",omitempty"`
}

<!ELEMENT EXPPARAMVALUE (INSTANCE?)> <!ATTLIST EXPPARAMVALUE 

%CIMName;

>

type Host 

type Host struct {
	Host string `xml:",innerxml" json:",omitempty"`
}

<!ELEMENT HOST (#PCDATA)> type Host string

type IMethodCall 

type IMethodCall struct {
	Name               string              `xml:"NAME,attr,omitempty" json:",omitempty"`
	LocalNamespacePath *LocalNamespacePath `xml:"LOCALNAMESPACEPATH" json:",omitempty"`
	IParamValue        []IParamValue       `xml:"IPARAMVALUE" json:",omitempty"`
}

<!ELEMENT IMETHODCALL (LOCALNAMESPACEPATH, IPARAMVALUE*)> <!ATTLIST IMETHODCALL 

%CIMName;

>

type IMethodResponse 

type IMethodResponse struct {
	Name         string        `xml:"NAME,attr,omitempty" json:",omitempty"`
	Error        *Error        `xml:"ERROR" json:",omitempty"`
	IReturnValue *IReturnValue `xml:"IRETURNVALUE" json:",omitempty"`
	ParamValue   []ParamValue  `xml:"PARAMVALUE" json:",omitempty"`
}

<!ELEMENT IMETHODRESPONSE (ERROR | (IRETURNVALUE?, PARAMVALUE*))> <!ATTLIST IMETHODRESPONSE 

%CIMName;

>

type IParamValue 

type IParamValue struct {
	Name                 string                `xml:"NAME,attr,omitempty" json:",omitempty"`
	Value                *Value                `xml:"VALUE" json:",omitempty"`
	ValueArray           *ValueArray           `xml:"VALUE.ARRAY" json:",omitempty"`
	ValueReference       *ValueReference       `xml:"VALUE.REFERENCE" json:",omitempty"`
	ValueRefArray        *ValueRefArray        `xml:"VALUE.REFARRAY" json:",omitempty"`
	ClassName            *ClassName            `xml:"CLASSNAME" json:",omitempty"`
	InstanceName         *InstanceName         `xml:"INSTANCENAME" json:",omitempty"`
	QualifierDeclaration *QualifierDeclaration `xml:"QUALIFIER.DECLARATION" json:",omitempty"`
	Class                *Class                `xml:"CLASS" json:",omitempty"`
	Instance             *Instance             `xml:"INSTANCE" json:",omitempty"`
	ValueNamedInstance   *ValueNamedInstance   `xml:"VALUE.NAMEDINSTANCE" json:",omitempty"`
}

<!ELEMENT IPARAMVALUE (VALUE | VALUE.ARRAY | VALUE.REFERENCE | CLASSNAME | INSTANCENAME | QUALIFIER.DECLARATION | CLASS | INSTANCE | VALUE.NAMEDINSTANCE)?> <!ATTLIST IPARAMVALUE 

%CIMName;

>

type IReturnValue 

type IReturnValue struct {
	ClassName                []ClassName
	InstanceName             []InstanceName             `xml:"INSTANCENAME" json:",omitempty"`
	Value                    []Value                    `xml:"VALUE" json:",omitempty"`
	ValueObjectWithPath      []ValueObjectWithPath      `xml:"VALUE.OBJECTWITHPATH" json:",omitempty"`
	ValueObjectWithLocalPath []ValueObjectWithLocalPath `xml:"VALUE.OBJECTWITHLOCALPATH" json:",omitempty"`
	ValueObject              []ValueObject              `xml:"VALUE.OBJECT" json:",omitempty"`
	ObjectPath               []ObjectPath               `xml:"OBJECTPATH" json:",omitempty"`
	QualifierDeclaration     []QualifierDeclaration     `xml:"QUALIFIER.DECLARATION" json:",omitempty"`
	ValueArray               *ValueArray                `xml:"VALUE.ARRAY" json:",omitempty"`
	ValueReference           *ValueReference            `xml:"VALUE.REFERENCE" json:",omitempty"`
	Class                    []Class                    `xml:"CLASS" json:",omitempty"`
	Instance                 []Instance                 `xml:"INSTANCE" json:",omitempty"`
	InstancePath             []InstancePath             `xml:"INSTANCEPATH" json:",omitempty"`
	ValueNamedInstance       []ValueNamedInstance       `xml:"VALUE.NAMEDINSTANCE" json:",omitempty"`
	ValueInstanceWithPath    []ValueInstanceWithPath    `xml:"VALUE.INSTANCEWITHPATH" json:",omitempty"`
}

<!ELEMENT IRETURNVALUE (CLASSNAME* | INSTANCENAME* | VALUE* | VALUE.OBJECTWITHPATH* | VALUE.OBJECTWITHLOCALPATH* | VALUE.OBJECT* | OBJECTPATH* | QUALIFIER.DECLARATION* | VALUE.ARRAY? | VALUE.REFERENCE? | CLASS* | INSTANCE* | INSTANCEPATH* | VALUE.NAMEDINSTANCE* | VALUE.INSTANCEWITHPATH*)>

type Instance 

type Instance struct {
	ClassName         string              `xml:"CLASSNAME,attr,omitempty" json:",omitempty"`
	Qualifier         []Qualifier         `xml:"QUALIFIER" json:",omitempty"`
	Property          []Property          `xml:"PROPERTY" json:",omitempty"`
	PropertyArray     []PropertyArray     `xml:"PROPERTY.ARRAY" json:",omitempty"`
	PropertyReference []PropertyReference `xml:"PROPERTY.REFERENCE" json:",omitempty"`
}

<!ELEMENT INSTANCE (QUALIFIER*, (PROPERTY | PROPERTY.ARRAY | PROPERTY.REFERENCE)*)> <!ATTLIST INSTANCE 

%ClassName;
xml:lang NMTOKEN #IMPLIED

>

type InstanceName 

type InstanceName struct {
	ClassName      string          `xml:"CLASSNAME,attr,omitempty",json:",omitempty" json:",omitempty"`
	KeyBinding     []KeyBinding    `xml:"KEYBINDING",json:",omitempty" json:",omitempty"`
	KeyValue       *KeyValue       `xml:"KEYVALUE",json:",omitempty" json:",omitempty"`
	ValueReference *ValueReference `xml:"VALUE.REFERENCE",json:",omitempty" json:",omitempty"`
}

<!ELEMENT INSTANCENAME (KEYBINDING* | KEYVALUE? | VALUE.REFERENCE?)> <!ATTLIST INSTANCENAME 

%ClassName;

>

type InstancePath 

type InstancePath struct {
	NamespacePath *NamespacePath `xml:"NAMESPACEPATH" json:",omitempty"`
	InstanceName  *InstanceName  `xml:"INSTANCENAME" json:",omitempty"`
}

<!ELEMENT INSTANCEPATH (NAMESPACEPATH, INSTANCENAME)>

type InstanceWithPath 

type InstanceWithPath ValueInstanceWithPath

<instanceWithPath>: VALUE.INSTANCEWITHPATH

type KeyBinding 

type KeyBinding struct {
	Name           string          `xml:"NAME,attr,omitempty",json:",omitempty" json:",omitempty"`
	KeyValue       *KeyValue       `xml:"KEYVALUE",json:",omitempty" json:",omitempty"`
	ValueReference *ValueReference `xml:"VALUE.REFERENCE",json:",omitempty" json:",omitempty"`
}

<!ELEMENT KEYBINDING (KEYVALUE | VALUE.REFERENCE)> <!ATTLIST KEYBINDING 

%CIMName;

>

type KeyValue 

type KeyValue struct {
	ValueType string `xml:"VALUETYPE,attr,omitempty" json:",omitempty"`
	Type      string `xml:"TYPE,attr,omitempty" json:",omitempty"`
	KeyValue  string `xml:",innerxml" json:",omitempty"`
}

<!ELEMENT KEYVALUE (#PCDATA)> <!ATTLIST KEYVALUE 

VALUETYPE (string | boolean | numeric) "string"
%CIMType; #REQUIRED

>

type LocalClassPath 

type LocalClassPath struct {
	LocalNamespacePath *LocalNamespacePath `xml:"LOCALNAMESPACEPATH" json:",omitempty"`
	ClassName          *ClassName          `xml:"CLASSNAME" json:",omitempty"`
}

<!ELEMENT LOCALCLASSPATH (LOCALNAMESPACEPATH, CLASSNAME)>

type LocalInstancePath 

type LocalInstancePath struct {
	LocalNamespacePath *LocalNamespacePath `xml:"LOCALNAMESPACEPATH" json:",omitempty"`
	InstanceName       *InstanceName       `xml:"INSTANCENAME" json:",omitempty"`
}

<!ELEMENT LOCALINSTANCEPATH (LOCALNAMESPACEPATH, INSTANCENAME)>

type LocalNamespacePath 

type LocalNamespacePath struct {
	Namespace []Namespace `xml:"NAMESPACE" json:",omitempty"`
}

<!ELEMENT LOCALNAMESPACEPATH (NAMESPACE+)>

type Message 

type Message struct {
	ID              string        `xml:"ID,attr" json:",omitempty"`
	ProtocolVersion string        `xml:"PROTOCOLVERSION,attr" json:",omitempty"`
	SimpleReq       *SimpleReq    `xml:"SIMPLEREQ" json:",omitempty"`
	MultiReq        *MultiReq     `xml:"MULTIREQ" json:",omitempty"`
	SimpleRsp       *SimpleRsp    `xml:"SIMPLERSP" json:",omitempty"`
	MultiRsp        *MultiRsp     `xml:"MULTIRSP" json:",omitempty"`
	SimpleExpReq    *SimpleExpReq `xml:"SIMPLEEXPREQ" json:",omitempty"`
	MultiExpReq     *MultiExpReq  `xml:"MULTIEXPREQ" json:",omitempty"`
	SimpleExpRsp    *SimpleExpRsp `xml:"SIMPLEEXPRSP" json:",omitempty"`
	MultiExpRsp     *MultiExpRsp  `xml:"MULTIEXPRSP" json:",omitempty"`
}

<!ELEMENT MESSAGE (SIMPLEREQ | MULTIREQ | SIMPLERSP | MULTIRSP | SIMPLEEXPREQ | MULTIEXPREQ | SIMPLEEXPRSP | MULTIEXPRSP)> <!ATTLIST MESSAGE 

ID CDATA #REQUIRED
PROTOCOLVERSION CDATA #REQUIRED

>

type Method 

type Method struct {
	Name               string               `xml:"NAME,attr,omitempty" json:",omitempty"`
	Type               string               `xml:"TYPE,attr,omitempty" json:",omitempty"`
	ClassOrigin        string               `xml:"CLASSORIGIN,attr,omitempty" json:",omitempty"`
	Propagated         string               `xml:"PROPAGATED,attr,omitempty" json:",omitempty"`
	Qualifier          []Qualifier          `xml:"QUALIFIER" json:",omitempty"`
	Parameter          []Parameter          `xml:"PARAMETER" json:",omitempty"`
	ParameterReference []ParameterReference `xml:"PARAMETER.REFERENCE" json:",omitempty"`
	ParameterArray     []ParameterArray     `xml:"PARAMETER.ARRAY" json:",omitempty"`
	ParameterRefArray  []ParameterRefArray  `xml:"PARAMETER.REFARRAY" json:",omitempty"`
}

<!ELEMENT METHOD (QUALIFIER*, (PARAMETER | PARAMETER.REFERENCE | PARAMETER.ARRAY | PARAMETER.REFARRAY)*)> <!ATTLIST METHOD 

%CIMName;
%CIMType; #IMPLIED
%ClassOrigin;
%Propagated;

>

type MethodCall 

type MethodCall struct {
	Name              string             `xml:"NAME,attr,omitempty" json:",omitempty"`
	LocalClassPath    *LocalClassPath    `xml:"LOCALCLASSPATH" json:",omitempty"`
	LocalInstancePath *LocalInstancePath `xml:"LOCALINSTANCEPATH" json:",omitempty"`
	ParamValue        []ParamValue       `xml:"PARAMVALUE" json:",omitempty"`
}

<!ELEMENT METHODCALL ((LOCALCLASSPATH | LOCALINSTANCEPATH), PARAMVALUE*)> <!ATTLIST METHODCALL 

%CIMName;

>

type MethodResponse 

type MethodResponse struct {
	Name        string       `xml:"NAME,attr,omitempty" json:",omitempty"`
	Error       *Error       `xml:"ERROR" json:",omitempty"`
	ReturnValue *ReturnValue `xml:"RETURNVALUE" json:",omitempty"`
	ParamValue  []ParamValue `xml:"PARAMVALUE" json:",omitempty"`
}

<!ELEMENT METHODRESPONSE (ERROR | (RETURNVALUE?, PARAMVALUE*))> <!ATTLIST METHODRESPONSE 

%CIMName;

>

type MultiExpReq 

type MultiExpReq struct {
	SimpleExpReq []SimpleExpReq `xml:"SIMPLEEXPREQ" json:",omitempty"`
}

<!ELEMENT MULTIEXPREQ (SIMPLEEXPREQ, SIMPLEEXPREQ+)>

type MultiExpRsp 

type MultiExpRsp struct {
	SimpleExpRsp []SimpleExpRsp `xml:"SIMPLEEXPRSP" json:",omitempty"`
}

<!ELEMENT MULTIEXPRSP (SIMPLEEXPRSP, SIMPLEEXPRSP+)>

type MultiReq 

type MultiReq struct {
	SimpleReq []SimpleReq `xml:"SIMPLEREQ" json:",omitempty"`
}

<!ELEMENT MULTIREQ (SIMPLEREQ, SIMPLEREQ+)>

type MultiRsp 

type MultiRsp struct {
	SimpleRsp []SimpleRsp `xml:"SIMPLERSP" json:",omitempty"`
}

<!ELEMENT MULTIRSP (SIMPLERSP, SIMPLERSP+)>

type NamedInstance 

type NamedInstance ValueNamedInstance

<namedInstance>: VALUE.NAMEDINSTANCE

type Namespace 

type Namespace struct {
	Name string `xml:"NAME,attr,omitempty" json:",omitempty"`
}

<!ELEMENT NAMESPACE EMPTY> <!ATTLIST NAMESPACE 

%CIMName;

>

type NamespacePath 

type NamespacePath struct {
	Host               *Host               `xml:"HOST" json:",omitempty"`
	LocalNamespacePath *LocalNamespacePath `xml:"LOCALNAMESPACEPATH" json:",omitempty"`
}

<!ELEMENT NAMESPACEPATH (HOST, LOCALNAMESPACEPATH)>

type Object 

type Object struct {
	ValueObject              []ValueObject
	ValueObjectWithLocalPath []ValueObjectWithLocalPath
	ValueObjectWithPath      []ValueObjectWithPath
}

<object>: VALUE.OBJECT|VALUE.OBJECTWITHLOCALPATH|VALUE.OBJECTWITHPATH

type ObjectName 

type ObjectName struct {
	ClassName    *ClassName
	InstanceName *InstanceName
}

<objectName>: (CLASSNAME|INSTANCENAME)

type ObjectPath 

type ObjectPath struct {
	InstancePath *InstancePath `xml:"INSTANCEPATH" json:",omitempty"`
	ClassPath    *ClassPath    `xml:"CLASSPATH" json:",omitempty"`
}

<!ELEMENT OBJECTPATH (INSTANCEPATH | CLASSPATH)>

type ParamValue 

type ParamValue struct {
	Name               string              `xml:"NAME,attr,omitempty" json:",omitempty"`
	ParamType          string              `xml:"PARAMTYPE,attr,omitempty" json:",omitempty"`
	EmbeddedObject     string              `xml:"EmbeddedObject,attr,omitempty" json:",omitempty"`
	Value              *Value              `xml:"VALUE" json:",omitempty"`
	ValueReference     *ValueReference     `xml:"VALUE.REFERENCE" json:",omitempty"`
	ValueArray         *ValueArray         `xml:"VALUE.ARRAY" json:",omitempty"`
	ValueRefArray      *ValueRefArray      `xml:"VALUE.REFARRAY" json:",omitempty"`
	ClassName          *ClassName          `xml:"CLASSNAME" json:",omitempty"`
	InstanceName       *InstanceName       `xml:"INSTANCENAME" json:",omitempty"`
	Class              *Class              `xml:"CLASS" json:",omitempty"`
	Instance           *Instance           `xml:"INSTANCE" json:",omitempty"`
	ValueNamedInstance *ValueNamedInstance `xml:"VALUE.NAMEDINSTANCE" json:",omitempty"`
}

<!ELEMENT PARAMVALUE (VALUE | VALUE.REFERENCE | VALUE.ARRAY | VALUE.REFARRAY | CLASSNAME | INSTANCENAME | CLASS | INSTANCE | VALUE.NAMEDINSTANCE)?> <!ATTLIST PARAMVALUE 

%CIMName;
%ParamType; #IMPLIED
%EmbeddedObject;

>

type Parameter 

type Parameter struct {
	Name      string      `xml:"NAME,attr,omitempty" json:",omitempty"`
	Type      string      `xml:"TYPE,attr" json:",omitempty"`
	Qualifier []Qualifier `xml:"QUALIFIER" json:",omitempty"`
}

<!ELEMENT PARAMETER (QUALIFIER*)> <!ATTLIST PARAMETER 

%CIMName;
%CIMType; #REQUIRED

>

type ParameterArray 

type ParameterArray struct {
	Name      string      `xml:"NAME,attr,omitempty" json:",omitempty"`
	Type      string      `xml:"TYPE,attr" json:",omitempty"`
	ArraySize string      `xml:"ARRAYSIZE,attr,omitempty" json:",omitempty"`
	Qualifier []Qualifier `xml:"QUALIFIER" json:",omitempty"`
}

<!ELEMENT PARAMETER.ARRAY (QUALIFIER*)> <!ATTLIST PARAMETER.ARRAY 

%CIMName;
%CIMType; #REQUIRED
%ArraySize;

>

type ParameterRefArray 

type ParameterRefArray struct {
	Name           string      `xml:"NAME,attr,omitempty" json:",omitempty"`
	ReferenceClass string      `xml:"REFERENCECLASS,attr,omitempty" json:",omitempty"`
	ArraySize      string      `xml:"ARRAYSIZE,attr,omitempty" json:",omitempty"`
	Qualifier      []Qualifier `xml:"QUALIFIER" json:",omitempty"`
}

<!ELEMENT PARAMETER.REFARRAY (QUALIFIER*)> <!ATTLIST PARAMETER.REFARRAY 

%CIMName;
%ReferenceClass;
%ArraySize;

>

type ParameterReference 

type ParameterReference struct {
	Name           string      `xml:"NAME,attr,omitempty" json:",omitempty"`
	ReferenceClass string      `xml:"REFERENCECLASS,attr,omitempty" json:",omitempty"`
	Qualifier      []Qualifier `xml:"QUALIFIER" json:",omitempty"`
}

<!ELEMENT PARAMETER.REFERENCE (QUALIFIER*)> <!ATTLIST PARAMETER.REFERENCE 

%CIMName;
%ReferenceClass;

>

type Property 

type Property struct {
	Name           string      `xml:"NAME,attr,omitempty" json:",omitempty"`
	Type           string      `xml:"TYPE,attr" json:",omitempty"`
	ClassOrigin    string      `xml:"CLASSORIGIN,attr,omitempty" json:",omitempty"`
	Propagated     string      `xml:"PROPAGATED,attr,omitempty" json:",omitempty"`
	EmbeddedObject string      `xml:"EmbeddedObject,attr,omitempty" json:",omitempty"`
	Qualifier      []Qualifier `xml:"QUALIFIER" json:",omitempty"`
	Value          *Value      `xml:"VALUE" json:",omitempty"`
}

<!ELEMENT PROPERTY (QUALIFIER*, VALUE?)> <!ATTLIST PROPERTY 

%CIMName;
%CIMType; #REQUIRED
%ClassOrigin;
%Propagated;
%EmbeddedObject;
xml:lang NMTOKEN #IMPLIED

>

type PropertyArray 

type PropertyArray struct {
	Name           string      `xml:"NAME,attr,omitempty" json:",omitempty"`
	Type           string      `xml:"TYPE,attr" json:",omitempty"`
	ArraySize      string      `xml:"ARRAYSIZE,attr,omitempty" json:",omitempty"`
	ClassOrigin    string      `xml:"CLASSORIGIN,attr,omitempty" json:",omitempty"`
	Propagated     string      `xml:"PROPAGATED,attr,omitempty" json:",omitempty"`
	EmbeddedObject string      `xml:"EmbeddedObject,attr,omitempty" json:",omitempty"`
	Qualifier      []Qualifier `xml:"QUALIFIER" json:",omitempty"`
	ValueArray     *ValueArray `xml:"VALUE.ARRAY" json:",omitempty"`
}

<!ELEMENT PROPERTY.ARRAY (QUALIFIER*, VALUE.ARRAY?)> <!ATTLIST PROPERTY.ARRAY 

%CIMName;
%CIMType; #REQUIRED
%ArraySize;
%ClassOrigin;
%Propagated;
%EmbeddedObject;
xml:lang NMTOKEN #IMPLIED

>

type PropertyReference 

type PropertyReference struct {
	Name           string          `xml:"NAME,attr,omitempty" json:",omitempty"`
	ReferenceClass string          `xml:"REFERENCECLASS,attr,omitempty" json:",omitempty"`
	ClassOrigin    string          `xml:"CLASSORIGIN,attr,omitempty" json:",omitempty"`
	Propagated     string          `xml:"PROPAGATED,attr,omitempty" json:",omitempty"`
	Qualifier      []Qualifier     `xml:"QUALIFIER" json:",omitempty"`
	ValueReference *ValueReference `xml:"VALUE.REFERENCE" json:",omitempty"`
}

<!ELEMENT PROPERTY.REFERENCE (QUALIFIER*, VALUE.REFERENCE?)> <!ATTLIST PROPERTY.REFERENCE 

%CIMName;
%ReferenceClass;
%ClassOrigin;
%Propagated;

>

type PropertyValue 

type PropertyValue struct {
	Value          *Value
	ValueArray     *ValueArray
	ValueReference *ValueReference
}

<propertyValue>: (VALUE|VALUE.ARRAY|VALUE.REFERENCE)

type Qualifier 

type Qualifier struct {
	Name         string      `xml:"NAME,attr,omitempty" json:",omitempty"`
	Type         string      `xml:"TYPE,attr" json:",omitempty"`
	Propagated   string      `xml:"PROPAGATED,attr,omitempty" json:",omitempty"`
	Overridable  string      `xml:"OVERRIDABLE,attr,omitempty" json:",omitempty"`
	ToSubClass   string      `xml:"TOSUBCLASS,attr,omitempty" json:",omitempty"`
	ToInstance   string      `xml:"TOINSTANCE,attr,omitempty" json:",omitempty"`
	Translatable string      `xml:"TRANSLATABLE,attr,omitempty" json:",omitempty"`
	Value        *Value      `xml:"VALUE" json:",omitempty"`
	ValueArray   *ValueArray `xml:"VALUE.ARRAY" json:",omitempty"`
}

<!ELEMENT QUALIFIER ((VALUE | VALUE.ARRAY)?)> <!ATTLIST QUALIFIER 

%CIMName;
%CIMType; #REQUIRED
%Propagated;
%QualifierFlavor;
xml:lang NMTOKEN #IMPLIED

>

type QualifierDeclaration 

type QualifierDeclaration struct {
	Name         string      `xml:"NAME,attr,omitempty" json:",omitempty"`
	Type         string      `xml:"TYPE,attr" json:",omitempty"`
	IsArray      string      `xml:"ISARRAY,attr,omitempty" json:",omitempty"`
	ArraySize    string      `xml:"ARRAYSIZE,attr,omitempty" json:",omitempty"`
	Overridable  string      `xml:"OVERRIDABLE,attr,omitempty" json:",omitempty"`
	ToSubClass   string      `xml:"TOSUBCLASS,attr,omitempty" json:",omitempty"`
	ToInstance   string      `xml:"TOINSTANCE,attr,omitempty" json:",omitempty"`
	Translatable string      `xml:"TRANSLATABLE,attr,omitempty" json:",omitempty"`
	Scope        *Scope      `xml:"SCOPE" json:",omitempty"`
	Value        *Value      `xml:"VALUE" json:",omitempty"`
	ValueArray   *ValueArray `xml:"VALUE.ARRAY" json:",omitempty"`
}

<!ELEMENT QUALIFIER.DECLARATION (SCOPE?, (VALUE | VALUE.ARRAY)?)> <!ATTLIST QUALIFIER.DECLARATION 

%CIMName;
%CIMType; #REQUIRED
ISARRAY (true|false) #IMPLIED
%ArraySize;
%QualifierFlavor;

>

type ReturnValue 

type ReturnValue struct {
	EmbeddedObject string          `xml:"EmbeddedObject,attr,omitempty" json:",omitempty"`
	ParamType      string          `xml:"PARAMTYPE,attr,omitempty" json:",omitempty"`
	Value          *Value          `xml:"VALUE" json:",omitempty"`
	ValueReference *ValueReference `xml:"VALUE.REFERENCE" json:",omitempty"`
}

<!ELEMENT RETURNVALUE (VALUE | VALUE.REFERENCE)?> <!ATTLIST RETURNVALUE 

%EmbeddedObject;
%ParamType; #IMPLIED

>

type Scope 

type Scope struct {
	Class       string `xml:"CLASS,attr,omitempty" json:",omitempty"`
	Association string `xml:"ASSOCIATION,attr,omitempty" json:",omitempty"`
	Reference   string `xml:"REFERENCE,attr,omitempty" json:",omitempty"`
	Property    string `xml:"PROPERTY,attr,omitempty" json:",omitempty"`
	Method      string `xml:"METHOD,attr,omitempty" json:",omitempty"`
	Parameter   string `xml:"PARAMETER,attr,omitempty" json:",omitempty"`
	Indication  string `xml:"INDICATION,attr,omitempty" json:",omitempty"`
}

<!ELEMENT SCOPE EMPTY> <!ATTLIST SCOPE 

CLASS (true | false) "false"
ASSOCIATION (true | false) "false"
REFERENCE (true | false) "false"
PROPERTY (true | false) "false"
METHOD (true | false) "false"
PARAMETER (true | false) "false"
INDICATION (true | false) "false"

>

type SimpleExpReq 

type SimpleExpReq struct {
	Correlator    []Correlator   `xml:"CORRELATOR" json:",omitempty"`
	ExpMethodCall *ExpMethodCall `xml:"EXPMETHODCALL" json:",omitempty"`
}

<!ELEMENT SIMPLEEXPREQ (CORRELATOR*, EXPMETHODCALL)>

type SimpleExpRsp 

type SimpleExpRsp struct {
	ExpMethodResponse *ExpMethodResponse `xml:"EXPMETHODRESPONSE" json:",omitempty"`
}

<!ELEMENT SIMPLEEXPRSP (EXPMETHODRESPONSE)>

type SimpleReq 

type SimpleReq struct {
	Correlator  []Correlator `xml:"CORRELATOR" json:",omitempty"`
	MethodCall  *MethodCall  `xml:"METHODCALL" json:",omitempty"`
	IMethodCall *IMethodCall `xml:"IMETHODCALL" json:",omitempty"`
}

<!ELEMENT SIMPLEREQ (CORRELATOR*, (METHODCALL | IMETHODCALL))>

type SimpleRsp 

type SimpleRsp struct {
	MethodResponse  *MethodResponse  `xml:"METHODRESPONSE" json:",omitempty"`
	IMethodResponse *IMethodResponse `xml:"IMETHODRESPONSE" json:",omitempty"`
}

<!ELEMENT SIMPLERSP (METHODRESPONSE | IMETHODRESPONSE)>

type Value 

type Value struct {
	Value string `xml:",innerxml" json:",omitempty"`
}

<!ELEMENT VALUE (#PCDATA)> type Value string

type ValueArray 

type ValueArray struct {
	Value     []Value     `xml:"VALUE" json:",omitempty"`
	ValueNull []ValueNull `xml:"VALUE.NULL" json:",omitempty"`
}

<!ELEMENT VALUE.ARRAY (VALUE | VALUE.NULL)*>

type ValueInstanceWithPath 

type ValueInstanceWithPath struct {
	InstancePath *InstancePath `xml:"INSTANCEPATH" json:",omitempty"`
	Instance     *Instance     `xml:"INSTANCE" json:",omitempty"`
}

<!ELEMENT VALUE.INSTANCEWITHPATH (INSTANCEPATH, INSTANCE)>

type ValueNamedInstance 

type ValueNamedInstance struct {
	InstanceName *InstanceName `xml:"INSTANCENAME" json:",omitempty"`
	Instance     *Instance     `xml:"INSTANCE" json:",omitempty"`
}

<!ELEMENT VALUE.NAMEDINSTANCE (INSTANCENAME, INSTANCE)>

type ValueNamedObject 

type ValueNamedObject struct {
	Class        *Class        `xml:"CLASS" json:",omitempty"`
	InstanceName *InstanceName `xml:"INSTANCENAME" json:",omitempty"`
	Instance     *Instance     `xml:"INSTANCE" json:",omitempty"`
}

<!ELEMENT VALUE.NAMEDOBJECT (CLASS | (INSTANCENAME, INSTANCE))>

type ValueNull 

type ValueNull struct {
}

<!ELEMENT VALUE.NULL EMPTY>

type ValueObject 

type ValueObject struct {
	Class    *Class    `xml:"CLASS" json:",omitempty"`
	Instance *Instance `xml:"INSTANCE" json:",omitempty"`
}

<!ELEMENT VALUE.OBJECT (CLASS | INSTANCE)>

type ValueObjectWithLocalPath 

type ValueObjectWithLocalPath struct {
	LocalClassPath    *LocalClassPath    `xml:"LOCALCLASSPATH" json:",omitempty"`
	Class             *Class             `xml:"CLASS" json:",omitempty"`
	LocalInstancePath *LocalInstancePath `xml:"LOCALINSTANCEPATH" json:",omitempty"`
	Instance          *Instance          `xml:"INSTANCE" json:",omitempty"`
}

<!ELEMENT VALUE.OBJECTWITHLOCALPATH ((LOCALCLASSPATH, CLASS) | (LOCALINSTANCEPATH, INSTANCE))>

type ValueObjectWithPath 

type ValueObjectWithPath struct {
	ClassPath    *ClassPath    `xml:"CLASSPATH" json:",omitempty"`
	Class        *Class        `xml:"CLASS" json:",omitempty"`
	InstancePath *InstancePath `xml:"INSTANCEPATH" json:",omitempty"`
	Instance     *Instance     `xml:"INSTANCE" json:",omitempty"`
}

<!ELEMENT VALUE.OBJECTWITHPATH ((CLASSPATH, CLASS) | (INSTANCEPATH, INSTANCE))>

type ValueRefArray 

type ValueRefArray struct {
	ValueReference []ValueReference `xml:"VALUE.REFERENCE" json:",omitempty"`
	ValueNull      []ValueNull      `xml:"VALUE.NULL" json:",omitempty"`
}

<!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE | VALUE.NULL)*>

type ValueReference 

type ValueReference struct {
	ClassPath         *ClassPath         `xml:"CLASSPATH" json:",omitempty"`
	LocalClassPath    *LocalClassPath    `xml:"LOCALCLASSPATH" json:",omitempty"`
	ClassName         *ClassName         `xml:"CLASSNAME" json:",omitempty"`
	InstancePath      *InstancePath      `xml:"INSTANCEPATH" json:",omitempty"`
	LocalInstancePath *LocalInstancePath `xml:"LOCALINSTANCEPATH" json:",omitempty"`
	InstanceName      *InstanceName      `xml:"INSTANCENAME" json:",omitempty"`
}

<!ELEMENT VALUE.REFERENCE (CLASSPATH | LOCALCLASSPATH | CLASSNAME | INSTANCEPATH | LOCALINSTANCEPATH | INSTANCENAME)>

type WBEMConnection 

type WBEMConnection struct {
	// contains filtered or unexported fields
}

func NewWBEMConn 

func NewWBEMConn(urlstr string) (*WBEMConnection, error)

func (*WBEMConnection) AssociatorNames 

func (conn *WBEMConnection) AssociatorNames(objectName *ObjectName, assocClass *ClassName, resultClass *ClassName, role, resultRole *string) ([]ObjectPath, error)

The AssociatorNames operation enumerates the names of CIM Objects (classes or instances) that are associated with a particular source CIM object: 

<objectPath>*AssociatorNames (
     [IN] <objectName> ObjectName,
     [IN,OPTIONAL,NULL] <className> AssocClass = NULL,
     [IN,OPTIONAL,NULL] <className> ResultClass = NULL,
     [IN,OPTIONAL,NULL] string Role = NULL,
     [IN,OPTIONAL,NULL] string ResultRole = NULL
)

func (*WBEMConnection) Associators 

func (conn *WBEMConnection) Associators(objectName *ObjectName, assocClass *ClassName, resultClass *ClassName, role, resultRole *string, includeClassOrigin bool, propertyList []string) ([]ValueObjectWithPath, error)

The Associators operation enumerates CIM objects (classes or instances) associated with a particular source CIM object: 

<objectWithPath>*Associators (
     [IN] <objectName> ObjectName,
     [IN,OPTIONAL,NULL] <className> AssocClass = NULL,
     [IN,OPTIONAL,NULL] <className> ResultClass = NULL,
     [IN,OPTIONAL,NULL] string Role = NULL,
     [IN,OPTIONAL,NULL] string ResultRole = NULL,
     [IN,OPTIONAL] boolean IncludeQualifiers = false, (DEPRECATED)
     [IN,OPTIONAL] boolean IncludeClassOrigin = false,
     [IN,OPTIONAL,NULL] string PropertyList [] = NULL
)

func (*WBEMConnection) CreateClass 

func (conn *WBEMConnection) CreateClass(newClass *Class) error

The CreateClass operation creates a single CIM class in the target namespace. The class shall not already exist: 

void CreateClass (
     [IN] <class> NewClass
)

func (*WBEMConnection) CreateInstance 

func (conn *WBEMConnection) CreateInstance(newInstance *Instance) error

The CreateInstance operation creates a single CIM Instance in the target namespace. The instance shall not already exist: 

<instanceName>CreateInstance (
     [IN] <instance> NewInstance
)

func (*WBEMConnection) DeleteClass 

func (conn *WBEMConnection) DeleteClass(className *ClassName) error

The DeleteClass operation deletes a single CIM class from the target namespace: 

void DeleteClass (
     [IN] <className> ClassName
)

func (*WBEMConnection) DeleteInstance 

func (conn *WBEMConnection) DeleteInstance(instanceName *InstanceName) error

The DeleteInstance operation deletes a single CIM instance from the target namespace. 

void DeleteInstance (
     [IN] <instanceName> InstanceName
)

func (*WBEMConnection) DeleteQualifier 

func (conn *WBEMConnection) DeleteQualifier(qualifierName string) error

The DeleteQualifier operation deletes a single qualifier declaration from the target namespace. 

void DeleteQualifier (
     [IN] string QualifierName
)

func (*WBEMConnection) EnumerateClassNames 

func (conn *WBEMConnection) EnumerateClassNames(className *ClassName, deepInheritance bool) ([]Class, error)

The EnumerateClassNames operation enumerates the names of subclasses of a CIM class in the target namespace: 

<className>*EnumerateClassNames (
     [IN,OPTIONAL,NULL] <className> ClassName = NULL,
     [IN,OPTIONAL] boolean DeepInheritance = false
)

func (*WBEMConnection) EnumerateClasses 

func (conn *WBEMConnection) EnumerateClasses(className *ClassName, deepInheritance bool, localOnly bool, includeQualifiers bool, includeClassOrigin bool) ([]Class, error)

The EnumerateClasses operation enumerates subclasses of a CIM class in the target namespace: 

EnumerateClasses <class>*EnumerateClasses (
     [IN,OPTIONAL,NULL] <className> ClassName=NULL,
     [IN,OPTIONAL] boolean DeepInheritance = false,
     [IN,OPTIONAL] boolean LocalOnly = true,
     [IN,OPTIONAL] boolean IncludeQualifiers = true,
     [IN,OPTIONAL] boolean IncludeClassOrigin = false
)

func (*WBEMConnection) EnumerateInstanceNames 

func (conn *WBEMConnection) EnumerateInstanceNames(className *ClassName) ([]InstanceName, error)

The EnumerateInstanceNames operation enumerates the names (model paths) of the instances of a CIM class in the target namespace, including instances in the class and any subclasses in accordance with the polymorphic nature of CIM objects: 

<instanceName>*EnumerateInstanceNames (
     [IN] <className> ClassName
)

func (*WBEMConnection) EnumerateInstances 

func (conn *WBEMConnection) EnumerateInstances(className *ClassName, deepInheritance bool, includeClassOrigin bool, propertyList []string) ([]ValueNamedInstance, error)

The EnumerateInstances operation enumerates instances of a CIM class in the target namespace, including instances in the class and any subclasses in accordance with the polymorphic nature of CIM objects: 

<namedInstance>*EnumerateInstances (
     [IN] <className> ClassName,
     [IN,OPTIONAL] boolean LocalOnly = true, (DEPRECATED)
     [IN,OPTIONAL] boolean DeepInheritance = true,
     [IN,OPTIONAL] boolean IncludeQualifiers = false, (DEPRECATED)
     [IN,OPTIONAL] boolean IncludeClassOrigin = false,
     [IN,OPTIONAL,NULL] string PropertyList [] = NULL
)

func (*WBEMConnection) EnumerateQualifiers 

func (conn *WBEMConnection) EnumerateQualifiers() ([]QualifierDeclaration, error)

The EnumerateQualifiers operation enumerates qualifier declarations from the target namespace. 

<qualifierDecl>*EnumerateQualifiers (
)

func (*WBEMConnection) ExecQuery 

func (conn *WBEMConnection) ExecQuery(queryLanguage string, query string) (*Object, error)

The ExecQuery operation executes a query against the target namespace: 

<object>*ExecQuery (
     [IN] string QueryLanguage,
     [IN] string Query
)

func (*WBEMConnection) GetClass 

func (conn *WBEMConnection) GetClass(className *ClassName, localOnly bool, includeQualifiers bool, includeClassOrigin bool, propertyList []string) ([]Class, error)

The GetClass operation returns a single CIM class from the target namespace: 

GetClass <class>GetClass (
     [IN] <className> ClassName,
     [IN,OPTIONAL] boolean LocalOnly = true,
     [IN,OPTIONAL] boolean IncludeQualifiers = true,
     [IN,OPTIONAL] boolean IncludeClassOrigin = false,
     [IN,OPTIONAL,NULL] string PropertyList [] = NULL
)

func (*WBEMConnection) GetHostAddr 

func (conn *WBEMConnection) GetHostAddr() string

func (*WBEMConnection) GetHostPort 

func (conn *WBEMConnection) GetHostPort() int

func (*WBEMConnection) GetHttpTimeout 

func (conn *WBEMConnection) GetHttpTimeout() time.Duration

func (*WBEMConnection) GetInstance 

func (conn *WBEMConnection) GetInstance(instanceName *InstanceName, includeClassOrigin bool, propertyList []string) ([]Instance, error)

The GetInstance operation returns a single CIM instance from the target namespace: 

GetInstance <instance>GetInstance (
     [IN] <instanceName> InstanceName,
     [IN,OPTIONAL] boolean LocalOnly = true, (DEPRECATED)
     [IN,OPTIONAL] boolean IncludeQualifiers = false, (DEPRECATED)
     [IN,OPTIONAL] boolean IncludeClassOrigin = false,
     [IN,OPTIONAL,NULL] string PropertyList [] = NULL
)

func (*WBEMConnection) GetNamespace 

func (conn *WBEMConnection) GetNamespace() string

func (*WBEMConnection) GetPassword 

func (conn *WBEMConnection) GetPassword() string

func (*WBEMConnection) GetProperty 

func (conn *WBEMConnection) GetProperty(instanceName *InstanceName, propertyName string) (*PropertyValue, error)

The GetProperty operation retrieves a single property value from a CIM instance in the target namespace: 

<propertyValue>GetProperty (
     [IN] <instanceName> InstanceName,
     [IN] string PropertyName
)

func (*WBEMConnection) GetQualifier 

func (conn *WBEMConnection) GetQualifier(qualifierName string) (*QualifierDeclaration, error)

The GetQualifier operation retrieves a single qualifier declaration from the target namespace. 

<qualifierDecl>GetQualifier (
     [IN] string QualifierName
)

func (*WBEMConnection) GetScheme 

func (conn *WBEMConnection) GetScheme() string

func (*WBEMConnection) GetUserName 

func (conn *WBEMConnection) GetUserName() string

func (*WBEMConnection) InvokeMethod 

func (conn *WBEMConnection) InvokeMethod(objectName *ObjectName, methodName string, paramValue []ParamValue) (int, []ParamValue, error)

The InvokeMethod operation enumerates the association objects that refer to a particular target CIM object (class or instance): 

<int> <ParamValue>*InvokeMethod (
     [IN] <objectName> ObjectName,
     [IN] <methodName> string,
     [IN] <paramValue> ParamValue
)

func (*WBEMConnection) ModifyClass 

func (conn *WBEMConnection) ModifyClass(modifiedClass *Class) error

The ModifyClass operation modifies an existing CIM class in the target namespace. The class shall already exist: 

void ModifyClass (
     [IN] <class> ModifiedClass
)

func (*WBEMConnection) ModifyInstance 

func (conn *WBEMConnection) ModifyInstance(modifiedInstance *ValueNamedInstance, propertyList []string) error

ModifyInstance 

void ModifyInstance (
     [IN] <namedInstance> ModifiedInstance,
     [IN, OPTIONAL] boolean IncludeQualifiers = true, (DEPRECATED)
     [IN, OPTIONAL, NULL] string propertyList[] = NULL
)

func (*WBEMConnection) ReferenceNames 

func (conn *WBEMConnection) ReferenceNames(objectName *ObjectName, assocClass *ClassName, role *string) ([]ObjectPath, error)

The ReferenceNames operation enumerates the association objects that refer to a particular target CIM object (class or instance): 

<objectPath>*ReferenceNames (
     [IN] <objectName> ObjectName,
     [IN,OPTIONAL,NULL] <className> ResultClass = NULL,
     [IN,OPTIONAL,NULL] string Role = NULL
)

func (*WBEMConnection) References 

func (conn *WBEMConnection) References(objectName *ObjectName, resultClass *ClassName, role *string, includeClassOrigin bool, propertyList []string) ([]ValueObjectWithPath, error)

The References operation enumerates the association objects that refer to a particular target CIM object (class or instance). 

<objectWithPath>*References (
     [IN] <objectName> ObjectName,
     [IN,OPTIONAL,NULL] <className> ResultClass = NULL,
     [IN,OPTIONAL,NULL] string Role = NULL,
     [IN,OPTIONAL] boolean IncludeQualifiers = false, (DEPRECATED)
     [IN,OPTIONAL] boolean IncludeClassOrigin = false,
     [IN,OPTIONAL,NULL] string PropertyList [] = NULL
)

func (*WBEMConnection) SetHttpTimeout 

func (conn *WBEMConnection) SetHttpTimeout(timeout time.Duration)

func (*WBEMConnection) SetNamespace 

func (conn *WBEMConnection) SetNamespace(namespace string)

func (*WBEMConnection) SetProperty 

func (conn *WBEMConnection) SetProperty(instanceName *InstanceName, propertyName string, newValue *PropertyValue) error

The SetProperty operation sets a single property value in a CIM instance in the target namespace: 

void SetProperty (
     [IN] <instanceName> InstanceName,
     [IN] string PropertyName,
     [IN,OPTIONAL,NULL] <propertyValue> NewValue = NULL
)

func (*WBEMConnection) SetQualifier 

func (conn *WBEMConnection) SetQualifier(qualifierDecl *QualifierDeclaration) error

The SetQualifier operation creates or updates a single qualifier declaration in the target namespace. If the qualifier declaration already exists, it is overwritten: 

void SetQualifier (
     [IN] <qualifierDecl> QualifierDeclaration
)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.