1cimcli(1)                   General Commands Manual                  cimcli(1)
2
3
4

NAME

6       cimcli - command line WBEM Client
7

SYNOPSIS

9       cimcli Operation [OperationTarget] [ValueParameter ...]  [-hc]
10              [-h operationName] [-ho] [--help] [-n namespace] [-l location]
11              [-u user] [-p password] [-s] [--cert certFilePath]
12              [--key keyFilePath] [--truststore clientTrustStorePath] [--sort]
13              [--r repeat] [-delay seconds] [--sum] [--count object]
14              [--timeout seconds] [-o XML|MOF|TABLE] [--verbose]
15              [-pl propertyList] [-niq] [-di] [-ic] [-ac associationClassName]
16              [-rc resultClassName] [-r role] [-rr resultRole] [-f filter]
17              [-ql query] [--version] [--expExit exitCode] [ -pt pullTimeout]
18              [-mr maxObjectsToReceive] [-pullDelay pullDelayinSec]
19              [-mo maxObjectCount]
20
21

DESCRIPTION

23       cimcli is a command line tool for executing CIM client operations using
24       the CIM/XML protocol.  It implements all of  the  DMTF  CIM  operations
25       defined  in  the  DMTF specification DSP0200 (CIM Operations over HTTP)
26       except for the modify and create class/instance operations and includes
27       several other operations that are useful in working with CIM Servers.
28
29       cimcli  is  available  for  all  platforms that support the Pegasus CIM
30       Server.
31
32       For the execution of the DMTF defined CIM operations (ex.  enumerateIn‐
33       stances  CIM/XML  operation).   cimcli includes as command line options
34       all of the parameters defined in the DMTF specification.  (ex.  -di for
35       deep inheritance for the enumerateInstances operation).
36
37       Effective  OpenPegasus  2.14  cimcli  incorporates  the pull operations
38       defined by DMTF into its operations list .  See  the  section  on  Pull
39       Client Operations
40
41       In  addition  to  the  CIM Operations defined in the DMTF specification
42       DMTF DSP0200, cimcli implements a number of other operations that  sup‐
43       port  testing  and  querying  CIM  servers  (ex. operation to query for
44       namespaces and another to get  all  instances  in  a  namespace)  which
45       require multiple CIM Operations.  The additional operations include:
46
47
48       1.     Enumerate  namespaces  (ns)  -  Returns a list of the namespaces
49              available from the CIMOM.
50
51       2.     Enumerate all instance names (niall) - Returns  a  list  of  all
52              instance names in a single defined namespace.
53
54       3.     Turn  CIM  Server statistics on and off (DEPRECATED) - Turns the
55              statistics flag in the Server CIMObjectManager Class on  or  off
56              for the OpenPegasus server.  This enables and disables execution
57              of statistics gathering in the server.  This command is retained
58              for  compatibility  but is DEPRECATED and will be removed when a
59              real alternative is included in the Pegasus release.
60
61              NOTE: This operation may be CIMServer type  specific  since  not
62              all CIM servers implement the statistics functions.
63
64       4.     Test  instances  (ti) - Executes tests of the characteristics of
65              an instance requested  from  the  CIM  Server.   This  operation
66              extends  the capabilities of cimcli to actually compare informa‐
67              tion from the server with information in the command line input.
68
69       5.     classtree (ct) - Display a tree of either superclasses  or  sub‐
70              classes of defined classes in the repository.
71
72       6.     countinstance  (cci) - Count the number of instances by class in
73              a namespace.
74
75              WARNING: This operation could cause problems if executed against
76              a  server which returns very large numbers of instances since it
77              retrieves all of the instances and counts them in cimcli.
78
79       The format of the cimcli command is:
80
81       cimcli [Operation] [OperationTarget] [options] [ValueParameters]
82
83       Options may be interspersed with the  [OperationTarget]  parameter  but
84       the  ordering  and  position on the command line of [Operation] [Opera‐
85       tionTarget] is fixed and any [value parameters] MUST  occur  after  the
86       [OperationTarget] parameter.
87
88
89   [Operation]
90       Defines  the operation to be executed.  cimcli executes all of the DMTF
91       CIM Operations (ex.  getclass) and a set of compound  operations  (enu‐
92       meratenamespaces).   There  are  two forms for each [Operation] defini‐
93       tion:
94
95       * a short form typically two characters (i.e.  gc for getclass) and
96
97       * a long form which is the full name of the operation (i.e.  getclass).
98
99       The complete set of operations can be viewed by calling cimcli with the
100       option -hc.
101
102
103   [OperationTarget]
104       The [OperationTarget] is the name of the object for which the the oper‐
105       ation is requested.
106
107       This parameter is operation dependent.  For example, with the  getClass
108       operation  the  [OperationTarget]  is  a  CIM  class  name.   With  the
109       getInstance operation the object is a CIM  instance  name.   Note  that
110       some  of  the  commands  do not require an [OperationTarget] parameter.
111       Thus, for example, the [OperationTarget] is optional with  the  enumer‐
112       ateClasses  operation  as it is with the equivalent enumerateClassNames
113       CIM operation.  Normally this is either a CIM class name or an instance
114       name (classname plus keybindings).  In some operations one or the other
115       is required.  In other operations, the behavior  of  the  operation  is
116       dependent  on  whether class name or instance name is supplied. See the
117       definition of each operation for detailed requirements for the  [Opera‐
118       tionTarget]
119
120       The  format  for <instancename> (CIMObjectPath) is defined as the model
121       path in the CIM Specification(DMTF DSP0004) and has the form:
122
123       <classname>.<keyPropertyName>=<value>[,<keypropertyName>=<value>]*
124
125       where:
126
127
128              <keyPropertyName> is the name of a property in <className>
129
130              <value> is a string that represents either a numeric value or  a
131              string  value  (enveloped  in  quotes).  Quote marks surrounding
132              string values are required.
133
134       To simplify inputting command line object names, cimcli offers a second
135       option for defining the object name as [OperationTarget].  In this sec‐
136       ond form, the [OperationTarget] object is the class name  and  zero  or
137       more <value parameter>s are used to define each feature/value.  In this
138       case, the quotation marks around string property  values  are  optional
139       and  are  required  only  in  the  case  where quotation marks would be
140       required to define a value such as a  string  that  includes  quotation
141       marks or spaces.
142
143       The syntax for this form is:
144
145       <classname> <keyPropertyName>=<value> [,<keypropertyName>=<value>]*
146
147       where:
148
149              <keyPropertyName> is the name of a property in <className>
150
151              <value>  is  either a numeric value or a string value (enveloped
152              in quotes only if there are spaces in the string).
153
154       Note that each name/value definition is treated  as  a  single  command
155       line  parameter  so  that  MUST not include spaces between the name and
156       value components. (ex. name=fred, not  name  =  fred  and  name=\"freds
157       name\")
158
159       As an example, the input for a getInstance might be:
160
161                cimcli gi TennisPlayer.first=\"Patrick\",last=\"Rafter\"
162                or
163                cimcli gi 'TennisPlayer.first="Patrick",last="Rafter"'
164                or the simplified form:
165                cimcli gi TennisPlayer first=Patrick last=Rafter
166
167       In  the second case, cimcli gets the class from the CIM Server and uses
168       the parameters to form a correct CIMObjectPath.   In  the  first  case,
169       generally cimcli uses the input path directly without getting the class
170       from the server.  The quotation marks in the first case are required by
171       the CIMObjectPath format defined by the DMTF.
172
173
174   [options...]
175       Options  are  identified on the command line with the - or -- notation.
176       They are identified in a cimcli config file with the form  <name>=value
177       where  name is a long name for the option.  Each cimcli option has both
178       a short name for command line use and a  long  name  for  configuration
179       file use.  There are several types of options:
180
181
182       1.     Execution  Modification Options - Options that are universal and
183              modify or define the execution of the command or the form of the
184              return.   This  includes  options like setting the output format
185              for object responses or requesting only summary operation.
186
187
188       2.     Connection Options - Options that define the connection for  the
189              operation.   This  includes  options for defining the CIM server
190              address, namespace, and security  options  such  as  user  name,
191              password and SSL settings.
192
193
194       3.     Operation   Parameter  Options  -  Options  that  represent  the
195              optional  input  parameters  for  operations.   The  [operation]
196              defines  the CIM Operation that will be executed and the options
197              define the optional request parameters.  Typical context options
198              might  be  -n namespace (used on most but not all operations) or
199              -niq which sets includequalifiers to false for  operations  that
200              use the includeQualifiers optional parameter.
201
202
203       4.     Help  Options - Options to display help (-h, --help, --ho to get
204              a list of all options, and -hc to get a list of all operations).
205              When these options are requested, no server request is executed.
206
207
208   [value-parameter]
209       Some  of  the operations allow or require extra parameters, for example
210       to supply property value definitions for create  and  modify  instance.
211       These  are typically keywords or keyword/value pairs and are defined as
212       part of the particular operation that use them.
213
214       Any extra parameter entities on the command line that occur  after  the
215       [Operation]  and  [Operation  Target]  and  are not proceeded by "-" to
216       indicate an option are considered value parameters.  These are used  in
217       some  of  the  operations to provide additional information required or
218       optionally desired by the operation.  See each operation definition  to
219       determine  if  extra  parameters are required or allowed.  These may be
220       either keyname/value pairs in some cases or simply strings depending on
221       the operation.
222
223       NOTE:  cimcli does not protect the user against inputting extra options
224       or parameters.  Since the options are heavily dependent on  the  opera‐
225       tion  to  be executed, it ignores options that are not used with a par‐
226       ticular operation.  Thus, entering the -r option (role) with a getClass
227       operation is syntactically allowed but cimcli ignores the parameter.
228
229

OPTIONS

231       There are 4 types of options
232
233       Boolean  where the option sets some condition (ex. -verbose).
234
235       String   requires  a  string  parameter  following  the  option (ex. -n
236                root/test).
237
238       Integer  requires an integer following the option (ex. --delay 4).
239
240       Keyword  requires a defined keyword following the option.
241
242
243   CONNECTION OPTIONS
244       The following set of options re general to all of  the  CIM  Operations
245       and  most  of  the  compound operations They provide parameters for the
246       initiation or execution of the  operations  (ie.  identify  the  target
247       server and namespace and set connection security parameters).
248
249       These include:
250
251       -n [namespace]
252              String  option  where [namespace] defines the namespace name for
253              this  operation  (ex.   -n  root).   The  default  namespace  is
254              root/cimv2 if this parameter is not entered
255
256       -l [location]
257              String  option  where  [location]  defines  the  host name or IP
258              address and optionally port for this operation.  The default for
259              this  command if the -n option is not used is to use the OpenPe‐
260              gasus connectLocal() function to connect to  the  server.   Note
261              that  this  means that a command like cimcli gc CIM_Door may not
262              work when trying to connect to a server other  than  Pegasus  on
263              the  same  system.   If cimcli is to be used to connect to a CIM
264              Server other than Pegasus on the same system use -l localhost or
265              -l  127.0.0.1 or the actual name or IP address.  This will force
266              cimcli to make the connection in the normal way, not using  con‐
267              nectLocal().
268
269       -u [user-name]
270              String  option where [user-name] defines he user name to be used
271              in the connection to the CIM server for the command.
272
273       -p [password]
274              String option where [password] defines the password to  be  used
275              in the connection to the CIM server for the command.
276
277       -s     Connect  with SSL - Specifies that cimcli should attempt to con‐
278              nect over a secure connection using  SSL.   This  option  causes
279              cimcli  to  modify the client connect call to set the SSLContext
280              option to the certificate defined  with  the  --cert  and  --key
281              options.   If this option is set but neither the --cert or --key
282              options are included, the SSLContext for  the  connect  call  is
283              submitted with the Cert and key marked NULL.
284
285              NOTE  Since  SSL  is  a  compile  cimcli  compile option, the -s
286              options and following options will not even exist  in  a  cimcli
287              that was compiled with the SSL capabilities disabled.
288
289       --cert [certificate file path]
290              String options.  [certificate-file path defines the file name of
291              a certificate to be used with  the  client  connect  if  the  -s
292              option  is  set.  This is optional and used only with the -s and
293              --key options. If exits, the client key (--key option) must also
294              exist
295
296       --key [client key file path]
297              Defines the file name of a Client private key.  This is optional
298              and only has an effect on connections made over HTTPS using  the
299              -s option. If exists the client certificate (--cert option) must
300              also exist.
301
302
303       --truststore [clientTrustStorePath]
304              Defines a file or directory containing  a  truststore  that  the
305              client  uses  to  verify server certificates. Default is that no
306              trust store exists
307
308
309   CIMCLI OPERATION MODIFICATION OPTIONS
310       A set of options that modifies the manner in which the command is  exe‐
311       cuted  or  the display of information on response including the follow‐
312       ing:
313
314       --t    When set measures time for the operation  to  be  completed  and
315              report  it  upon command completion.  If this option is set, the
316              time for the operation is recorded upon completion of the opera‐
317              tion.   In  addition,  the  client  infrastructure is queried to
318              determine if the operation execution times  optionally  measured
319              in  the  infrastructure and at the server are available.  If so,
320              they are displayed also.  This would allow the user  to  see  a)
321              time  spent in the server, b) round trip time for the operation,
322              c) application round trip time for  the  operation.   Note  that
323              when  combined with the repeat option, the output includes maxi‐
324              mum, minimum, and average times for the operation.  There are  a
325              specific operations in cimcli to turn control statistics genera‐
326              tion (See son and soff operations) at least for the Pegasus  CIM
327              server.
328
329       --sort Requests  cimcli  to sort the returned entities for multi-entity
330              operations (ex. enumerate, reference, associator). Normally  the
331              order of returned entities is random from most CIM Servers; set‐
332              ting this option outputs the objects in a  defined  order.   The
333              order  is  based  on  the name element for classes and qualifier
334              declarations and on the object path returned for  CIM  instances
335              and CIM objects.
336
337       --r [repeat_count]
338              Repeat  the  operation  [repeat_count]  times.  This repeats the
339              operation without disconnecting.   This  option  is  useful  for
340              defining tests that load the server with repeated calls and also
341              for getting average times for an operation by taking the average
342              of  a  number  of  calls (when used with the summary information
343              option (--sum) and the measure time option (--t)).
344
345       -delay [seconds]
346              Delay [seconds] seconds between connect and issuing  the  opera‐
347              tion request.
348
349       --sum  When  set,  cimcli  presents  only summary information, not full
350              output.  Generally cimcli presents counts of objects returned in
351              place  of  the  names  or objects themselves when this option is
352              set.  See also the repeat (--r) and measure time (--t) options.
353
354       --count [object_count]
355              Defines an expected count of  objects  to  be  returned  in  the
356              response.  cimcli is terminated with an error exit if the number
357              of objects returned does not  match  the  object_count  supplied
358              with  the  option.   This can be used in batch files to test for
359              number of objects returned by an operation.  In addition to  the
360              error status code, a message of the general form:
361                   "Failed  count  test. Expected= xx. Received= yy" is output
362              to cerr.
363       Example:
364          cimcli en CIM_ManagedElement -count 100
365
366              If the count of instances returned is not equal to 100,
367              cimcli exits with error code 60 and the Failed count test
368              error message.
369
370       --timeout [seconds]
371              When defined, set the connect timeout [seconds]  seconds  rather
372              than the default timeout.
373
374       -o [ xml | mof | table ]
375              KeyWord  option.  Output  type for commands that output objects.
376              Used with commands that present CIM objects in  their  response.
377              Presents  the  output  in  the form of xml corresponding to DMTF
378              CIM/XML specification, mof, or for instances a table of the data
379              in each property.
380
381       -verbose
382              When set cimcli displays details on the input options and execu‐
383              tion of cimcli for the operation.
384
385       --setRtnHostNames [SubstituteHostName]
386              String option with a required parameter that  set  a  substitute
387              host  name  which  cimcli  will  insert into returned objects to
388              replace host names returned from the server.   This  option  was
389              defined  because the object paths/references returned by the CIM
390              Server may include the host name as part of the returned  object
391              path which makes it difficult to compare the returned paths to a
392              defined path.  Using this option forces any returned host  names
393              to be changed to the string parameter supplied with the option.
394
395       --expExit [exitCode]
396              Integer  option  that defines an exit code that is expected when
397              cimcli terminates.  If cimcli tries to  exit  with  the  defined
398              code,  the code is changed to 0 (OK). Any other exit code gener‐
399              ates an error exit code.
400
401
402   OPERATION PARAMETER OPTIONS
403       Options that define request parameters for  specific  cimcli  Operation
404       requests.  These are typically optional parameters on the CIM operation
405       request that modify the behavior of the server to  the  request.   This
406       includes things like requesting localonly, deep inheritance, etc.  Note
407       that the actual behavior may be dependent on the  particular  operation
408       request  type.   The full definition of these options is below here and
409       their use with each specific cimcli operation is defined with the oper‐
410       ations.
411
412       -pl [propertylist]
413              String  Option.  Set the propertylist parameter for those opera‐
414              tions that allow this parameter.   The  propertylist  value  for
415              this  parameter  is  a  comma-separated list of class properties
416              (without spaces between items).  This sets  the  optionsl  prop‐
417              ertylist  parameter  on  those  CIM  operations  that allow this
418              parameter including: getClass, getInstance, modifyInstance, enu‐
419              merateInstances,   associators,   references,   OpenEnumerateIn‐
420              stances,  OpenReferenceInstances,  and  OpenAssociatorInstances.
421              If  this  option is not defined on the execution of one of these
422              operations, cimcli sets the propertylist parameter to NULL indi‐
423              cating that all properties should be returned.
424
425              If  a  comma-separated list of one or more properties is defined
426              as the value for this option, a propertylist with  these  values
427              is set on the CIM request operation.
428
429              Since  this CIM request parameter specifically allows 3 options:
430              1) list of properties, 2) NULL which is the indicator  that  all
431              properties are to be returned, and 3) Empty which is the indica‐
432              tor that no properties are to be include in  the  response,  the
433              cimcli  options specifically allows defining the empty option by
434              setting propertylist to  either  ""  or  \"\".   cimcli  accepts
435              either  an  input  that  the  command processor interprets as an
436              empty string or as a string consisting of two quotation marks.
437
438              The syntax of propertylist is:
439
440              <propertyName>[,<propertyName>]* |
441
442              Examples:
443                      cimcli gc CIM_ManagedElement -pl Caption
444                           getclass with a propertylist with one property
445
446                      cimcli gc CIM_ManagedElement -pl Caption,Description
447                           getClass with a propertylist with two properties
448
449                      cimcli gc CIM_ManagedElement -pl \"\"
450                          gc operation with empty property list (return no
451                       properties)
452
453       -niq   Boolean (not_include_Qualifiers) that sets the operation parame‐
454              ter  for  include_qualifiers  to  false.  Note that this form is
455              required because the default for this option  in  the  DMTF  CIM
456              Operations  is  true  (include  qualifiers).  Not including this
457              option sets the request to include qualifiers on those  commands
458              to which this option applies.
459
460       -nlo   Boolean  that  defines  whether properties from superclasses are
461              included in the response.  the -nlo option turns this  parameter
462              off.   The  default  if  this  parameter  is  not included is to
463              request that the server return only local properties and  ignore
464              those from superclasses.
465
466       -di    Boolean  to  set the deep inheritance CIM operation parameter to
467              true.
468
469       -ic    Boolean parameter sets the CIM operation  parameter  classOrigin
470              in  the  operation request to true. the CIMServer is expected to
471              return classOrigin information as part of the response.
472
473       -ac [assocatonClassName]
474              String defining the association  Class  parameter  for  the  CIM
475              Operation.  Used with reference and association operations.
476
477       -rc [resultClassName]
478              String defining the resultClass parameter for the CIM associator
479              and reference operations.
480
481       -r [role]
482              String defining the role parameter for the  CIM  associator  and
483              reference operations.
484
485       -rr [resultrole]
486              String  defining the resultrole parameter for the CIM associator
487              and reference operations.
488
489

OPERATIONS

491       This section defines the individual  operations  supported  by  cimcli.
492       Note  that  either  the  names (ex. EnumerateInstances) or the shortcut
493       (ei) may be used in defining an [Operation] on  the  command  line  and
494       they are case independent.
495
496
497   Pull  Client  Operations  and OpenPegasus Overview (OpenPegasus 2.14 exten‐
498       sion)
499       The DMTF has extended the client xml protocol with new operations  that
500       return  multiple instance or path responses to allow the client to pull
501       the responses as components of an enumeration sequence  rather  than  a
502       single  monolothic  operation.  This allows the server improved manage‐
503       ment of operation resources and allows the client to control its memory
504       use.  cimcli  has  created  a  set of new operations that use this pull
505       model. cimcli did not create an operation corresponding to each  client
506       api  but  one that uses the client apis and a set of options to execute
507       complete pull enumertation sequences.
508
509       These operations correspond directly  to  the  original  operations  as
510       shown  in  the table below but with extra cimcli options to control the
511       enumeration sequence parameters.
512
513       OriginalOperation    shortcut    PullOperation              shortcut
514       enumerateInstances         ei    PullEnumerateInstances         pei
515       enumerateInstanceNames     ni    PullEnumerateInstancePaths     pni
516       references                  r    PullReferenceInstances         pr
517       referenceNames             rn    PullReferenceNames             prn
518       associators                 a    PullAssociators                pa
519       associatorNames            an    PullAssociatorPaths            pan
520       execQuery                  xq    pullExecQuery                  pxq
521
522       The pull operations generally duplicate the parameters of the  original
523       operations  with  some  options  to allow the new arguments required to
524       define the enumeration context,  control  of  the  size  of  individual
525       responses, timing, and maximum size.
526
527       The  pull  operations have a common set of options including: -ql [fil‐
528       terQueryLanguage] Optional definition of the filter query language used
529       for this operation.
530
531       This  option  allows  specification  of filter query languages like the
532       DMTF FQL which apply specifically to filtering instances from  enumera‐
533       tions.
534
535       WQL  and CQL are not allowed with this parameter in the pull operations
536       except for pullExecQuery. FQL is the  single  normalized  filter  query
537       language for the pull operations.
538
539       Since  FQL  is  a  required query language for systems that support the
540       pull operations, it is the definition normally  used  for  this  option
541       ("DMTF:FQL")
542
543       -f [filter] Optional filter for the language defined in the -ql option.
544       The response is filtered using this filter specification. The  required
545       query  language  is FQL (Filter Query Language) which is a simple query
546       language that allows  only  comparison  between  properties  within  an
547       instance and literals boolean combinations of these property comparison
548       expressions with AND and OR documented in detail in the DMTF specifica‐
549       tion DSP0212 and generally is of the form:
550          property comparison expression:
551             Scalarproperty operation scalarliteral or ScalarProperty
552             ArrayProperty operation arrayLiteral or ArrayProperty
553             ArrayProperty arrayOps scalarProperty or scalarLiteral
554             Arrayproperty[index] operation (scalarLiteral or scalarProprty or
555                                 ArrayProperty[index])
556
557          literals:
558            ScalarLteral which may be:
559                integer (decimal, hex, octal) 123, 0123, 0X1abc
560                String "'" chars "'"
561                real
562                DateTime
563                Reference
564            ArrayLiteral:
565               "{" scalarLiteral * ("," ScalarLiteral ) "}"
566
567           Operation:
568            where the operations allowed are dependent on the
569            left argument of the expression and may include:
570                 * equality comparison "=" "<>" "LIKE" "NOT LIKE"
571              * ordering  ">=" "<=" ">" "<"
572              * arrayOps "ANY", "EVERY"
573
574
575       -pt [pullTimeout]
576              The timeout value that cimcli sends to the server as part of the
577              open request.  This is the minimum  time  in  seconds  that  the
578              server  will keep the enumeration context open between sending a
579              response and receiving the next request  within  a  single  pull
580              sequence.
581
582       -mr [maxObjectsToReceive]
583              The  maximum  number of instances or paths that will be accepted
584              by cimcli before issuing a close operation.
585
586       -pullDelay [pullDelayinSec]
587              Delay in seconds that cimcli will execute between  each  of  the
588              operations  of  the  pullsequence.  The  primary use for this is
589              testing delay issues.
590
591       -mo [maxObjectCount]
592              The maximum object count that cimcli sends  to  the  server  for
593              each  request  in an enumeration context.  The server returns no
594              more than this number of instances or paths
595
596
597   ci CreateInstance Operation
598       The CreateInstance operation executes the DMTF  CIM/XML  createInstance
599       operation  request.   It builds an instance of the class defined on the
600       command line building the properties of the instance from a combination
601       of  the  class  retrieved from the CIM server and value parameters pro‐
602       vided with the input.  cimcli issues the CIM  operation  createInstance
603       with  the created instance  It requires the [OperationTarget] parameter
604       defining the class  for  which  the  instance  is  to  be  created  and
605       optional set of property definition (name=value) parameters that define
606       properties and their values for the created instance.
607
608       CreateInstance returns the object path of the created instance  if  the
609       call to the CIM server was executed successfully.  Otherwise it returns
610       the exception from the server.
611
612       cimcli can define property values for either scalar or array properties
613       for  any of the CIM Data types including embedded instance and embedded
614       object types
615
616       The syntax for createInstance is:
617
618           cimcli ci <className> <propertyDef[,<propertyDef>]*
619
620           where <propertyDef> is defined as follows:
621
622
623           <propertyName>=<scalarValueString>
624                  Defines a value for  a  property  where  propertyName  is  a
625                  scalar  property  of  any type except the types representing
626                  embedded instances or embedded  objects  (i.e.  String  with
627                  EmbeddedInstance  or  EmbeddedObject qualifier). The scalal‐
628                  ValueString may represent any CIM Data type  (string,  inte‐
629                  ger,  datatime,  real)with  the  same  syntax  as MOF input.
630                  Strings with embedded spaces must be enclosed  in  quotation
631                  marks.
632
633           <propertyName>=<scalarValueString>[,<scalarValueString>]*
634                  Defines  an array of values for a property which is an array
635                  property and each valueString is one value in the array.
636
637           <propertyName>!
638                  Defines a value of NULL for a String property.
639
640           <propertyName]>=
641                  Defines a property with NULL value.
642
643           <propertyName>={<embeddedClassName> [<propertyDef>]* }
644                  Defines a property that is an  embedded  instance,  embedded
645                  object,  or  reference(CIMObjectPath)  where <embeddedClass‐
646                  Name> is the class name for the embedded object or  instance
647                  and <propertyDefinition>.
648                   This  syntax  is  recursive  so  that instances of embedded
649                  classes can be embedded in properties  that  are  themselves
650                  embedded instance types.
651
652           <propertyName>={<embeddedClassName> [<propertyDef>]* [}.{ [<proper‐
653           tyDef>]*]*
654                  Defines a property that is an array of embedded instances or
655                  embedded  objects  <embeddedClassName> is the class name for
656                  the embedded object or instance and <propertyDefinition>
657
658       NOTE: The value of array properties may also be  defined  by  repeating
659       the  property  multiple  times  with the different values.  cimcli will
660       consolidate these multiple property definitions into an array
661
662       The use of the value parameters is further  defined  in  the  following
663       paragraphs.   Note  that  the syntax for value parameters for DMTF data
664       types differes from  the  syntax  for  value  parameters  for  embedded
665       instances and objects.
666
667
668       1.  Scalar property values - The string form of the property similar to
669       MOF input of constant values is  used  to  input  scalar  values.   The
670       scalar value input includes all CIM Types.  Numeric values may be input
671       in hex, octal, decimal or binary in the same form as the DMTF  specifi‐
672       cation  for MOF.  Quotations are not required surrounding values unless
673       the value includes spaces.  Quote marks can  be  embedded  by  escaping
674       them (ex. ab\"cd) with whatever the shell uses as an escape character..
675
676       2.  Array property values - Array property values are defined by defin‐
677       ing a string that is comma-separated scalar  value  entities.   of  the
678       form :
679
680                   <scalarvalueString>[,<scalarvalueString>]*
681
682       The  array  MUST  NOT include any spaces between the scalar value enti‐
683       ties.  It must appear to cimcli as a single input parameter.  In  addi‐
684       tion,  array  value can be input by repeating the complete parameter so
685       that values input will be appended to an already created array.
686
687       3.  If the propertyName  parameter  is  provided  with  no  value,  the
688       default value or NULL if there is no default value is inserted.
689
690       4.   String  property values are special because there are two concepts
691       that must be covered when there is no value,  1)  Empty  String  or  2.
692       NULL/default value. These are different for CIM Strings.
693
694       When  a property that requires an empty string is to be input, the user
695       will specify it with no value after the = sign.  If, a NULL or  default
696       value  is desired, the = sign terminator is replaced with the ! (excla‐
697       mation mark).
698
699       5.  The value defined in the name/value pair must be decodable into the
700       CIMType  of  the CIMClass for which the instance is being created.  For
701       example a String cannot be supplied for a  property  that  is  of  type
702       Uint32.   cimcli  get  the CIMType for the property from the server and
703       checks this against the data input.
704
705       The execution of this operation first accesses the CIM server  for  the
706       class  definition  and  uses this information to build the proper value
707       types and values for the instance. This means that values  that  cannot
708       be  decoded  with  values  to  match  the CIM Type in the class will be
709       rejected.
710
711       This command builds the instance with all of the properties  for  which
712       name/value  pairs  representing  the properties of the class are input.
713       It does not include any properties that are not defined on the  command
714       line.
715
716       To create an instance with less than the full set of properties, supply
717       only those properties that are to be submitted to the CIM Server.
718
719       The command will be rejected if the class does not exist in the  names‐
720       pace or if the input includes property names that are not in the class.
721
722       6.   If  the  property  defines an embedded instance or embedded object
723       (defined in MOF as a CIMTYpe String but with the qualifer  "embeddedIn‐
724       stance" or "embeddedObject" the embedded instance can be built directly
725       from the command line by supplying the class name and property  defini‐
726       tions  for  the  embedded  instance.   Note that cimcli builds embedded
727       instances in any case (It cannot build embedded classes) but sends them
728       to  the server as either embedded instances or embedded objects per the
729       MOF definiton.
730
731       An embedded instance definition is delineated by  either  "{"  or  "={"
732       separating the property name and value definition "}" to end the embed‐
733       ded instance definition as shown below:
734
735                <propertyName>={<embeddedClassName> [<propertyDef>]* }
736
737       The embedded instance termination marker "}" must be separated by  spa‐
738       ces from other parameters.
739
740       Arrays  of embedded instances can also be created following the pattern
741       for arrays of properties of other CIM types as follows:
742
743
744       ·   Define the property multiple times.   Each  time  the  property  is
745           defined  for  an embedded instance (with the same property name and
746           same class name) the new definition is appended to the array.
747
748
749       ·   Use the special terminator "},{" which allows cimcli to start a new
750           instance  definition (in effect using the comma separated values as
751           in the arrays of other CIM types.
752
753       Examples:
754           cimcli ci CIM_xxxx ID=abc size=32 age=O12
755               Creates an instance of CIM_xxxx with
756                  property ID value = abc,
757                  property size with value 32
758                  property age with value octal 012
759
760           cimcli ci CIM_xxxx ID=grrrr \
761                  arrayParam={abc,def,ghi,"jkl mno" \
762                  numArray=1,2,3,4
763               Creates an instance of CIM_xxxx with
764                  property ID with value = grrr
765                  property arrayParam (a String array property)
766                      with the values
767                           abc
768                           def
769                           ghi
770                           jkl mno
771                  property numArray (Uint32 array) with
772                      the values  1, 2, 3, 4
773
774            cimcli ci CIM_xxxx ID=blah \
775                 numArray=1,2,3 numArray=4,5
776               Creates an instance with the ID property and
777               the numArray property having the  values
778                   1,2,3,4,5
779
780            cimcli ci  Test_yyy id=301 \
781                   comment="test with multiple embedded instances" \
782                   embeddedInst{Test_CLITestEmbedded1 Id=302 \
783                       comment="First property with embedded instance" } \
784                   embeddedInst2{Test_CLITestEmbedded2 Id=303 name=fred \
785                       comment="Second property with embedded instance" }
786               Creates an instance of class Test_yyy with a single scalar
787               property (comment) and two embedded instance properties
788               (embeddedInst and embeddedInst2). Each of the embedded
789               instances contains 3 properties (Id, name, and comment).
790
791            // create an association with two REF properties, parent and child
792            cimcli ci Test_assoc \
793                parent={Test_target id=301 } \
794             child={Test_associated id=972 }
795
796            same as defining the
797            cimcli ci Test_assoc \
798                parent=Test_target.id=301 } \
799             child=Test_associated.id=972 }
800
801
802   mi ModifyInstance Operation
803       This operation allows the modification of  existing  instances  in  the
804       target server by building the properties from a combination of the tar‐
805       get Class and properties provided with the input.  The  command  issues
806       the CIM operation modifyInstance with an instance built from the param‐
807       eters provided.  It requires the [OperationTarget]  parameter  defining
808       the  class  for  which the instance is to be created and a set of value
809       parameters that  define  properties  to  be  provided  in  the  created
810       instance  in the format defined for CreateInstance above.  The modified
811       instance may also be built from a combination of the CIMObjectPath  for
812       the instance to be modified and value parameters for other properties.
813
814       In  the  same manner as the createInstance, this command first acquires
815       the class or objectPath definition for the server and uses the property
816       type  information  from the class to properly create the property value
817       types from the input property values.
818
819       This operation also allows the  specific  interactive  mode  where  the
820       classname and properties to be modified (minus key properties) are sup‐
821       plied and cimcli presents a selection of instance  names  that  can  be
822       modified.
823
824       For  a  detailed  definition  of the name/value input see the createIn‐
825       stance description.
826
827       In addition to the property definitions, this command allows the  prop‐
828       erty  list  option (-pl) that defines a property list to be supplied to
829       the target server with the modifyInstance CIM Operation.
830
831       NOTE: For some versions of Pegasus the -pl option may  be  required  to
832       allow  the  server  to correctly modify the instance since without this
833       option the pegasus server may remove properties that  are  not  in  the
834       modified instance.
835
836       The syntax for the modifyInstance operation is as follows:
837
838           cimcli mi <className> [<propertyDef>]* [-pl <propertyList]
839                       where the properties defined MUST include the key
840                       properties
841               or
842
843           cimcli mi <objectPath> [<propertyDef>]* [-pl <propertyList]
844                       where the properties defined do not include the key
845                       properties
846
847       See  createInstance  operation for detailed definition of <propertyDef>
848       and more examples:
849
850       Examples:
851           cimcli mi CIM_xxxx name=abc size=zyx
852           or
853           cimcli mi 'CIM_xxx.name="abc"' size=zyx
854           or
855           cimcli mi CIM_xxxx name=abc arrayParam= \
856                 {abc,def,ghi,"jkl mno" \
857                 numericArray=1,2,3,4
858
859
860   ec EnumerateClasses Operation
861       Issues the enumerateClasses CIM operation which  enumerates  the  class
862       hierarchy starting at the level defined by <classname>.
863
864       The syntax for this operation is:
865
866       cimcli ec [<classname>] [options]
867
868       where  classname  is not required.  If it is omitted, cimcli inserts an
869       empty classname into the CIM operation which tells the  CIM  Server  to
870       start  at  the top of the class inheritance tree.  The possible options
871       that represent the parameters of the enumerateClasses operation are:
872
873
874       -niq Boolean (not_include_Qualifiers) that sets the operation parameter
875       for include_qualifiers to false.
876
877       -nlo  Boolean  that  defines  whether  properties from superclasses are
878       included in the response. the -nlo option turns this parameter off
879
880       -ic Boolean parameter sets the operation  parameter  includeClassOrigin
881       in  the operation request. the CIM server is expected to return classO‐
882       rigin information as part of the response.
883
884       -pl [propertyList] Optional property list for the operation.
885
886       Example:
887          cimcli ec CIM_ManagedElement -di -nlo
888
889
890   nc EnumerateClassNames Operation
891       The EnumerateClassNames cimcli operation issues the enumerateClassNames
892       CIM Operation.
893
894       The syntax for this operation is:
895
896       cimcli nc [<classname>] [options]
897
898       The  classname parameter optional and the default it is not provided is
899       to return the class names of the top level classes.
900
901       The options specific to this operation include;
902
903       -di set the operation deepInheritance parameter = true not localOnly
904
905       Examples:
906               cimcli nc CIM_door
907                   Issue getClass CIM Operation for the class CIM_Door.
908
909
910       ni EnumerateInstanceNames Operation
911              Execute the enumerateInstanceNames CIM Operation. The syntax for
912              this operation is:
913
914              cimcli ni <classname> [<option>]*
915
916              Where:
917
918              <classname>  - classname for which instance names are to be enu‐
919              merated.
920
921              It displays the instances names that were returned  by  the  CIM
922              server  in response to the enumerateInstances CIM operation with
923              the defined input parameters.
924
925              Examples:
926                  cimcli ni CIM_ManagedElement -p password -n name \
927                      -n root/PG_Interop --sort
928
929                      Execute the enumerateInstanceNames operation on
930                      CIM_ManagedElement in the root/PG_Interop namespace.
931                      Sort the returned list of instance paths.
932
933                  cimcli ni CIM_Door --sum
934                      Execute the enumerateInstanceNames operation on the class
935                      CIM_Door and return the count of instance paths returned.
936
937
938   ei EnumerateInstances Operation
939       Execute the CIM operation enumerateInstances. The syntax for this oper‐
940       ation is:
941
942       cimcli ei [className] [<option>]*
943
944       This  operation requests instances from the CIM server and displays the
945       returned instances in a user selected format.
946
947       The following options represent specific parameters for this operation:
948
949       -nlo not local only operation parameter to false.  Note that this nega‐
950       tive  form  for  the  option is used because the default for local only
951       parameter is true.  Thus, not including this parameter means  that  the
952       parameter is not set.
953
954       -iq  Boolean (include_Qualifiers) that sets the operation parameter for
955       include_qualifiers to true,
956
957       -ic Boolean to set include class origin operation parameter to true.
958
959       -di Set deep inheritance operation parameter to true.
960
961       -o [xml|mof|table] Set the output format for the instances  to  display
962       the returns as mof
963
964       -pl [propertyList] Optional property list for the operation
965
966       It  returns the instances found either as MOF, XML, or a table of prop‐
967       erty values with each property a column in the table depending  on  the
968       output options parameter.
969
970       Examples:
971           cimcli ei CIM_ComputerSystem -niq -di
972               This example enumerates CIM_ComputerSystem in the
973               namespace root/CIMV2 (default) requesting without
974               qualifiers (-niq) with deepInheritance (-di).
975
976
977   niall enumerateallinstanceNames Operation
978       Execute an enumerateinstancenames on all classes to get all class names
979       within the defined namespace or class hiearchy below the  target  input
980       class.  if no class name is psecified on input this function enumerates
981       the complete set of classes namespace to get the classes and  the  enu‐
982       merateInstanceNames  command to enumerate all of the instances for each
983       class.  It returns the list of all of the instance names found  in  the
984       namespace  and  a summary of the number of instances of each class that
985       has instances.
986
987       The syntax for this operation is:
988
989       cimcli niall [className] [options]
990
991       where the options include any of the universal options (ex.  namespace,
992       location,  etc.).  Specifically  the --sum option allows returning only
993       the summary information including count of  instances  for  each  class
994       that has instances in the namespace.
995
996       Examples:
997           cimcli niall -n test/testproviders
998
999               Returns all instancenames in the namespace
1000               test/testproviders by executing
1001               enumerateinstancenames on each class in
1002               the namespace.
1003           cimcli niall CIM_OperatingSystem
1004               Returns all instance names in the namespace root/cimv2 for
1005               classes in the hiearchy starting at PG_OperatingSystem.
1006
1007
1008   gi GetInstance Operation
1009       Gets  the  instance defined by the instance name parameter and displays
1010       it in the format chosen for this operation (xml, mof, or table).
1011
1012       The syntax for this operation is:
1013
1014       cimcli gi [objectname] [<option>]*
1015
1016       which causes execution of the CIM getinstance operation.  OR
1017
1018       cimcli gi [classname] [<option>]*
1019
1020       which presents a list of possible instances to the user from which  one
1021       can  be  selected for the getinstance.  In this case, the command actu‐
1022       ally executes an enumerateInstanceNames to get the  list  of  instances
1023       that  is presented to the user for selection of a single instance.  The
1024       getInstance is executed after the user makes a selection.
1025
1026       This command requires the [objectname] parameter.  If the parameter  is
1027       an  instance with keys defined (a CIMObjectPath), the a getInstance CIM
1028       operation is executed and the return from the CIM Server presented  (in
1029       either  xml  or mof depending on the output option).  If the input is a
1030       class name, a enumerateinstanceNames CIM Operation is executed  and  if
1031       any  instance names are returned the result is presented to the console
1032       for the user to select one of the instances to be deleted.
1033
1034       If there are no instances, the return from this command is normally  an
1035       exception as defined in the DMTF CIM Operations specification..
1036
1037       The possible options specific to this operation are:
1038
1039       -iq  include  qualifiers.   The default for getInstance is includQuali‐
1040       fiers=false so use of this parameter is  required  if  the  user  wants
1041       qualifiers  returned.   NOTE:  The  use of the parameter in CIM/XML has
1042       been deprecated so the provider  may  not  return  qualifiers  even  if
1043       requested.
1044
1045       -nlo
1046
1047       localonly
1048
1049       -pl [propertyList] Optional property list for the operation
1050
1051       Examples:
1052           cimcli gi cim_ManagedElement
1053
1054               This is an interactive request that returns a list of
1055                   CIMObjectPaths from an enumerateInstance of
1056                   CIM_ManagedElement from which the user can select
1057                   one path which cimcli will uses as the [objectname]
1058                   to execute a getInstance operation returning the
1059                   instance.
1060
1061
1062   di deleteInstance Operation
1063       Delete  instance  executed  a  single deleteInstance command to the CIM
1064       Server.  The syntax is:
1065
1066       cimcli di [objectname] [<option>]*
1067
1068       This command requires the [objectname] parameter.  If this parameter is
1069       a  full  instance  name  with className and key bindings, the deleteIn‐
1070       stance CIM Operation is executed directly.  If it is a class name  with
1071       no  keybindings,  the  enumerateInstances CIM Operation is executed and
1072       the list of returned instance paths presented to the  console  for  the
1073       user  to senroff manpages html tablect one to delete.  cimcli then exe‐
1074       cutes CIM deleteInstance operation with the selected  [objectname]  and
1075       returns the response.
1076
1077       The  response  to  this  operation  is  either an empty response if the
1078       instance was successfully deleted or an exception return if there  were
1079       any errors.
1080
1081       Examples:
1082           cimcli di President."name=fred" -n test/testnamespace
1083
1084               Attempt to delete the instance of President with the key
1085               property name(fred) from the test/testnamespace namespace.
1086
1087           cimcli di President  -n test/testnamespace
1088
1089               cimcli requests instance paths for the President class in
1090               the test/testnamespace and puts the complete list on the
1091               console for the user to select one instance to delete.
1092
1093
1094   gq getQualifier Operation
1095       getQualifier displays the target qualifier. The syntax is:
1096
1097       cimcli gq [qualifier name] [<option>]*
1098
1099       Examples:
1100           cimcli gq abstract
1101
1102               returns the mof or XML for the abstract qualifier.
1103
1104
1105   sq setQualifier Operation
1106       This  command  is  not  implemented. We do not intend to implement this
1107       operation in cimcli because of the syntax complexity.  Use a  mof  com‐
1108       piler to create new qualifiers in the CIM server
1109
1110
1111   eq enumeratequalifiers Operation
1112       Issues  the CIM Operation to enumerate all of the qualifiers defined in
1113       the target namespace. The syntax is:
1114
1115       cimcli eq [<option>]*
1116
1117       There are no special options for this operation.
1118
1119
1120   dq deletequalifier Operation
1121       Issues the CIM operation to delete  the  target  qualifier  defined  by
1122       qualifier_name in the target namespace.  The Syntax is:
1123
1124       cimcli dq [qualifier_name] [<option>]*
1125
1126       NOTE:  This  operation  should be used with great caution as it removes
1127       qualifier declarations that may be used  by  other  components  of  the
1128       model.
1129
1130
1131   a associators Operation
1132       Execute  the  CIM Operation enumerate associators for the target object
1133       name.  The syntax for this operation is:
1134
1135       cimcli a [objectname] [<option>]*
1136
1137       Note that the objectname may be either a classname or an  instancename.
1138       If classname is supplied, the return is a set of classes that match the
1139       objectname supplied unless the -i (interactive) parameter is used.   If
1140       objectname  is  used, the response is instances of the association that
1141       matches the classname.
1142
1143       The options provide the various operation parameters including;
1144
1145       -ac [assocatonClassName] association Class parameter
1146
1147       -rc [resultClassName] resultClass parameter
1148
1149       -r [role] String defining the role parameter for the CIM Operation
1150
1151       -rr [resultrole] resultrole parameter
1152
1153       -ic Set includeClassOrigin input parameter true
1154
1155       -pl [properytlist] Optional PropertyList
1156
1157       -i Interactive request - If this parameter is supplied and the  object‐
1158       name  is a classname, the environment performs an enumerateInstances on
1159       the objectname and presents the list of  possible  instances  for  user
1160       selection
1161
1162
1163   an associatornames Operation
1164       Enumerate  the  associator names for the target object.  The syntax for
1165       this operation is:
1166
1167       cimcli an [objectname] [<option>]*
1168
1169       where objectname can be either a class name or an instance name.
1170
1171       The following options provide the various operation parameters;
1172
1173       -ac [assocatonClassName] association Class parameter
1174
1175       -rc [resultClassName] resultClass parameter
1176
1177       -r [role] String defining the role parameter for the CIM Operation
1178
1179       -rr [resultrole] resultrole parameter
1180
1181       -i Interactive request - If this parameter is supplied and the  object‐
1182       name  is a classname, the environment performs an enumerateinstances on
1183       the objectname and presents the list of  possible  instances  for  user
1184       selection
1185
1186
1187   r references Operation
1188       Executes  the CIM references Operation. Which returns CIM Objects.  The
1189       syntax for this the operation is:
1190
1191       cimcli r [objectname] [<option>]*
1192
1193       Note that the objectname may be either a  class  name  or  an  instance
1194       name.  If a class name is supplied, the return is a set of classes that
1195       of the association. If the -i (interactive) parameter is  used  with  a
1196       class name input, the user is queried for the objectname parameter.  If
1197       objectname is used, the response is instances of the associations  that
1198       match the classname
1199
1200       The options specifically used by this operation are:
1201
1202       -r [role] role parameter for the CIM Operation.
1203
1204       -rc [resultClassName] resultClass parameter for the CIM Operation
1205
1206       -iq includeQualifiers (The default is false)
1207
1208       -ic Boolean to set include class origin operation parameter to true.
1209
1210       -pl [propertyList] Optional property list for the operation
1211
1212       -i  Interactive  request  - This option is used only with commands that
1213       will accept either classname or object name as input (reference, refer‐
1214       encenames,  associatiors,  associatornames).  It allows the interactive
1215       mode where the user picks an instance from a list  returned  by  cimcli
1216       (similar  to  gi  where if only the classname is supplied, cimcli knows
1217       that the user wants to pick from a list) with these commands.  If  this
1218       parameter  is  supplied and the objectname is a classname, the environ‐
1219       ment performs an enumerateinstances on the objectname and presents  the
1220       list  of possible instances for user selection. Thus, the user can exe‐
1221       cute interactive reference, etc. operations
1222
1223       Examples:
1224            cimcli a CIM_ManagedElement
1225                 would return classs that associate with
1226                 CIM_ManagedElement
1227
1228            cimcli a CIM_ManagedElement -i
1229                 executes an enumerateInstanceNames on
1230                 CIM_ManagedElement and presents the user with
1231                 a list of instances names so that the user can
1232                 pick an instance name that will be used for
1233                 the associator request.
1234
1235
1236   rn referencenames Operation
1237       Executes the CIM Operation referencenames that returns CIMObject  paths
1238       of the references of the objectname parameter.
1239
1240       The syntax for this operation is:
1241
1242       cimcli rn [objectname] [<option>]*
1243
1244       Note  that  the  objectname  may  be  either a class name or a specific
1245       instance name.  If classname is supplied, the return is a set of class‐
1246       names that are references of the objectname supplied.  If the -i param‐
1247       eter is used with a class name as objectname, the user  is  queried  to
1248       select  an  instance  name  for the objectname input.  If objectname is
1249       used, the response is instance names of the associations  that  matches
1250       the classname.
1251
1252       The options specifically used by this operation are:
1253
1254       -r [role] role parameter for the CIM Operation
1255
1256       -rc [resultClassName] resultClass parameter for the CIM Operation
1257
1258       -i  Interactive request - If this parameter is supplied and the object‐
1259       name is a classname, the environment performs an enumerateinstances  on
1260       the  objectname  and  presents  the list of possible instances for user
1261       selection
1262
1263
1264   im invokeMethod Operation
1265       This operation sends a CIM extrinsic operation to  the  CIM  server  to
1266       execute a method on a CIM class or instance.
1267
1268       The syntax of the command is:
1269       cimcli im [objectname] [methodname] [<parameDef>]* [<option>]*
1270       Note  that  there  are  two  required  parameters  to this command, the
1271       [objectname] and the [methodname]. Parameter definitions <paramDef> are
1272       optional.
1273
1274       NOTE:  Earlier  versions  of cimcli allowed only String values and used
1275       the -ip option. This option has been removed.  Parameters are input  in
1276       the form:
1277
1278       <paramName>=<scalarValueString>
1279              Defines  a  value  for  a  parameter where paramName is a scalar
1280              parameter of any type except  the  types  representing  embedded
1281              instances or embedded objects (i.e. String with EmbeddedInstance
1282              or EmbeddedObject qualifier).
1283
1284       <paramName>=<scalarValueString>[,<scalarValueString>]*
1285              Defines an array of values for a parameter  which  is  an  array
1286              parameter and each valueString is one value in the array.
1287
1288       <paramName>!
1289              Defines a value of NULL for a String parameter
1290
1291       <paramName>=
1292              Defines a parameter with NULL value
1293
1294       <paramName>={<className> [<paramDef>]* }
1295              Defines  a  parameter  that  is an embedded instance or embedded
1296              object where <className> is the  class  name  for  the  embedded
1297              object  or  instance and <paramDef>. This syntax is recursive so
1298              that instances of embedded classes can be embedded in properties
1299              that are themselves embedded instance types.
1300
1301       <paramName>={<className> [<paramDef>]*[}.{ [<paramDef>]*]*
1302              Defines  a  parameter  that is an array of embedded instances or
1303              embedded objects <className> is the class name for the  embedded
1304              object or instance and <paramDefinition>
1305
1306       NOTE:  The  value  of  array  prammeters  may also be defined by simply
1307       repeating the prameter definition multiple  times  with  the  different
1308       values.   cimcli  will  consolidate these multiple property definitions
1309       into an array
1310
1311       The completed operations displays the return code from the command  and
1312       any returned parameters that are qualified as OUT parameters.
1313
1314       Example:
1315               cimcli PG_WBEMSLPTemplate register -n root/PG_Interop
1316                   Calls PG_WBEMSLPTemplate class with the method named
1317                   register
1318
1319               cimcli PG_XXX dosomething input1=true input2=1111
1320                   Calls PG_XXX class method dosomething with two
1321                   parameters:
1322                   input1 is boolean parameter with value true
1323                   input2 is Uint32 parameter with value 1111
1324
1325               The completed operation displays the return code from the
1326                command and any returned parameters that are qualified as
1327                OUT parameters.
1328
1329
1330   gp getProperty Operation
1331       Executes  the  getProperty  CIM  operation which gets a single property
1332       from the server.  Note that this operation has been deprecated  in  the
1333       DMTF  specifications  because  a)  it is effectively redundant with the
1334       getInstance operation and property lists b) there was an error  in  the
1335       design such that the CIM data type is not returned with the response so
1336       the client does not know what data type  is  being  returned  from  the
1337       response data.
1338
1339       It is implemented in cimcli but simply tries to convert the response to
1340       a string which means that it would get confused with a  CIMInstance  or
1341       CIMObject response.
1342
1343       The syntax of this operation is:
1344           gp <objectPath> <propertyName>
1345
1346
1347   sp setProperty Operation
1348       The  setProperty  executes  the setProperty operation which attempts to
1349       set a single property on an instance in the CIM Server.
1350
1351       The syntax of this operation is:
1352
1353           sp <objectPath> <propertyName=<<value>
1354
1355
1356   xq execQuery Operation
1357       The execQuery operation directly executes the CIM  Operation  execQuery
1358       with  the  input parameter supplied either by direct parameter input or
1359       the options for filter and querylanguage. The syntax of  the  operation
1360       is
1361
1362             cimcli xq <query_filter> <query_language> [<option>]*
1363       The query_filter and the query_language may be supplied directly on the
1364       command line as parameter or as options (-f for the  query  filter  and
1365       -ql for query language.
1366
1367       The execQuery CIM Operation is executed directly with the input parame‐
1368       ters or options.  If neither a query_filter  parameter  or  option  are
1369       supplied cimcli returns an error. If the query_language parameter (-ql)
1370       is omitted the default is "WQL". The operation does  not  validate  the
1371       query  language  parameter but simply passes the input string on to the
1372       CIM server
1373
1374       Examples
1375               cimcli xq "Select * from CIM_Something" CQL
1376
1377               cimcli xq "Select * from CIM_blah"
1378                    uses WQL as default query language
1379
1380
1381
1382   pei pullEnumerateInstances Operation
1383       Execute the CIM enumeration sequence to pull instances from the server.
1384       This   compromises  the  openEnumerateInstances  possible  followed  by
1385       pullInstancesWithPath operations. This cimcli  operation  executes  the
1386       complete sequence. The syntax for this operation is:
1387
1388       cimcli pei [className] [<option>]*
1389
1390       This  enumeration  sequence  requests instances from the CIM server and
1391       displays the returned instances in a user selected format. This is  the
1392       pull  equivalent  to  the  enumerateInstances operation and matches its
1393       format but with extra options.
1394
1395       The following options represent specific parameters for this operation:
1396
1397       -nlo not local only operation parameter to false.  Note that this nega‐
1398       tive  form  for  the  option is used because the default for local only
1399       parameter is true.  Thus, not including this parameter means  that  the
1400       parameter is not set.
1401
1402       -iq  Boolean (include_Qualifiers) that sets the operation parameter for
1403       include_qualifiers to true,
1404
1405       -ic Boolean to set include class origin operation parameter to true.
1406
1407       -di Set deep inheritance operation parameter to true.
1408
1409       -o [xml|mof|table] Set the output format for the instances  to  display
1410       the returns as mof
1411
1412       -pl [propertyList] Optional property list for the operation
1413
1414       -ql  [filterQueryLanguage] Optional definition of the filter query lan‐
1415       guage used for this operation
1416
1417       -f [filter] Optional filter for the language defined in the -ql option.
1418       The  response is filtered using this filter specification. See the sec‐
1419       tion Pull Client Operations for more information on query language syn‐
1420       tax.
1421
1422       -pt  [pullTimeout] The timeout value that cimcli sends to the server as
1423       part of the open request.  This is the minimum time in seconds that the
1424       server  will  keep  the  enumeration  context  open  between  sending a
1425       response and receiving the next request within a single pull sequence.
1426
1427       -mr [maxObjectsToReceive] The maximum number of instances or paths that
1428       will be accepted by cimcli before issuing a close operation.
1429
1430       -pullDelay  [pullDelayinSec]  Delay in seconds that cimcli will execute
1431       between each of the operations of the pullsequence. The primary use for
1432       this is testing delay issues.
1433
1434       -mo  [maxObjectCount]  The maximum object count that cimcli ends to the
1435       server for each request in an enumeration context.  The server  returns
1436       no more than this number of instances or paths
1437
1438       It  returns the instances found either as MOF, XML, or a table of prop‐
1439       erty values with each property a column in the table depending  on  the
1440       output options parameter.
1441
1442       Example:
1443           cimcli pei CIM_ComputerSystem -niq -di -mo 100
1444               This example enumerates CIM_ComputerSystem in the
1445               namespace root/CIMV2 (default) requesting without
1446               qualifiers (-niq) with deepInheritance (-di). Each response to
1447                cimcli will contain no more than 100 instances
1448
1449           cimcli pei CIM_ComputerSystem -ql "DMTF:FQL" -f "Dedicated = 3"
1450               Enumerate CIM_Computer system in root/CIMV2 and return any
1451                instances where the dedicated property equals 3
1452
1453
1454
1455   pni pullEnumerateInstancePaths Operation
1456       Execute  the  CIM  enumeration sequence to pull instance paths from the
1457       server.  This compromises the openEnumerateInstancePaths possibly  fol‐
1458       lowed  by  pullInstancePaths operations. This cimcli operation executes
1459       the complete sequence. The syntax for this operation is:
1460
1461       cimcli pni [className] [<option>]*
1462
1463       This enumeration sequence requests instance paths from the  CIM  server
1464       and displays the returned instances in a user selected format.
1465
1466       The following options represent specific parameters for this operation:
1467
1468       -nlo not local-only operation parameter to false.  Note that this nega‐
1469       tive form for the option is used because  the  default  for  local-only
1470       parameter  is  true.  Thus, not including this parameter means that the
1471       parameter is not set.
1472
1473       -ql [filterQueryLanguage] Optional definition of the filter query  lan‐
1474       guage used for this operation.  Required if the -f option is specified.
1475
1476       -f [filter] Optional filter for the language defined in the -ql option.
1477       The response is filtered using this  filter  specification.  The  query
1478       language  syntax  is documented in the general section above. NOTE: The
1479       filter may not be allowed for the paths operations  for  some  servers,
1480       specifically OpenPegasus.
1481
1482       -pt  [pullTimeout] The timeout value that cimcli sends to the server as
1483       part of the open request.  This is the minimum time in seconds that the
1484       server  will  keep  the  enumeration  context  open  between  sending a
1485       response and receiving the next request within a single pull sequence.
1486
1487       -mr [maxObjectsToReceive] The maximum number of instances or paths that
1488       will be accepted by cimcli before issuing a close operation.
1489
1490       -pullDelay  [pullDelayinSec]  Delay in seconds that cimcli will execute
1491       between each of the operations of the pullsequence. The primary use for
1492       this is testing delay issues.
1493
1494       -mo  [maxObjectCount] The maximum object count that cimcli sends to the
1495       server for each request in an enumeration context.  The server  returns
1496       no more than this number of instances or paths
1497
1498       It  returns the instances found either as MOF, XML, or a table of prop‐
1499       erty values with each property a column in the table depending  on  the
1500       output options parameter.
1501
1502       Example:
1503           cimcli pni CIM_ComputerSystem -n root/testproviders -mo 100
1504               This example enumerates the paths of CIM_ComputerSystem in the
1505               namespace root/testProviders (default). Each response to
1506                cimcli will contain no more than 100 paths
1507
1508
1509
1510   pa pullAssociators Operation
1511       Execute  the  enumeration  context  that  starts with openAssociatorIn‐
1512       stances and may continue  with  pullInstancesWithPath  for  the  target
1513       object name. This is similar to the associators operation.
1514
1515       The syntax for this operation is:
1516
1517       cimcli pa [objectname] [<option>]*
1518
1519       Note  that the objectname may be either a classname or an instancename.
1520       If classname is supplied, the interactive mode is used and  a  list  of
1521       possible  objectnames for the target of the association is presented to
1522       the user.  If objectname is used, the  response  is  instances  of  the
1523       association that matches the classname.
1524
1525       The options provide the various operation parameters including;
1526
1527       -ac [assocatonClassName] association Class parameter
1528
1529       -rc [resultClassName] resultClass parameter
1530
1531       -r [role] String defining the role parameter for the CIM Operation
1532
1533       -rr [resultrole] resultrole parameter
1534
1535       -ic includeClassOrigin The -ic parameter
1536
1537       -pl [properytlist] Optional PropertyList
1538
1539       -ql  [filterQueryLanguage] Optional definition of the filter query lan‐
1540       guage used for this operation.  Required if the -f option is specified.
1541
1542       -f [filter] Optional filter for the language defined in the -ql option.
1543       The  response  is  filtered  using this filter specification. The query
1544       language syntax is documented in the general section above.  NOTE:  The
1545       filter  may  not  be allowed for the paths operations for some servers,
1546       specifically OpenPegasus.
1547
1548       -pt [pullTimeout] The timeout value that cimcli sends to the server  as
1549       part of the open request.  This is the minimum time in seconds that the
1550       server will  keep  the  enumeration  context  open  between  sending  a
1551       response and receiving the next request within a single pull sequence.
1552
1553       -mr [maxObjectsToReceive] The maximum number of instances or paths that
1554       will be accepted by cimcli before issuing a close operation.
1555
1556       -pullDelay [pullDelayinSec] Delay in seconds that cimcli  will  execute
1557       between each of the operations of the pullsequence. The primary use for
1558       this is testing delay issues.
1559
1560       -mo [maxObjectCount] The maximum object count that cimcli sends to  the
1561       server  for each request in an enumeration context.  The server returns
1562       no more than this number of instances or paths
1563
1564       Example:
1565           cimcli pa -n test/providers Test_CLITestProviderClass.Id=
1566                -ac Test_CLITestProviderLinkClass -rc Test_CLITestProviderClass       -r child -rr parent -pl requestInputParameters
1567
1568           defines an associators request where the target object is:
1569               Test_CLITestProviderClass.Id="Mike"
1570           the associated class is: Test_CLITestProviderLinkClass
1571           the associated role is: child
1572           the reference role is: parent
1573           and the propertylist includes a single property: requestInputParameters
1574
1575
1576
1577   pan pullAssociatorPaths Operation
1578       Execute the enumeration context that starts with  openAssociatorInstan‐
1579       cePaths  and may continue with pullInstancesPaths for the target object
1580       name. This is similar  to  the  associators  operation  associatorPaths
1581       except that only instances are returned.
1582
1583       The syntax for this operation is:
1584
1585       cimcli pan [objectname] [<option>]*
1586
1587       where  objectname can be either a class name or an instance name. If it
1588       is a class name, the cimcli interactive mode is used to present a  list
1589       of possible object paths for the class to the user.
1590
1591       The following options provide the various operation parameters;
1592
1593       -ac [assocatonClassName] association Class parameter
1594
1595       -rc [resultClassName] resultClass parameter
1596
1597       -r [role] String defining the role parameter for the CIM Operation
1598
1599       -rr [resultrole] resultrole parameter
1600
1601       -ql  [filterQueryLanguage] Optional definition of the filter query lan‐
1602       guage used for this operation.  Required if the -f option is specified.
1603
1604       -f [filter] Optional filter for the language defined in the -ql option.
1605       The  response  is  filtered  using this filter specification. The query
1606       language syntax is documented in the general section above.  NOTE:  The
1607       filter  may  not  be allowed for the paths operations for some servers,
1608       specifically OpenPegasus.
1609
1610       -pt [pullTimeout] The timeout value that cimcli sends to the server  as
1611       part of the open request.  This is the minimum time in seconds that the
1612       server will  keep  the  enumeration  context  open  between  sending  a
1613       response and receiving the next request within a single pull sequence.
1614
1615       -mr [maxObjectsToReceive] The maximum number of instances or paths that
1616       will be accepted by cimcli before issuing a close operation.
1617
1618       -pullDelay [pullDelayinSec] Delay in seconds that cimcli  will  execute
1619       between each of the operations of the pullsequence. The primary use for
1620       this is testing delay issues.
1621
1622       -mo [maxObjectCount] The maximum object count that cimcli sends to  the
1623       server  for each request in an enumeration context.  The server returns
1624       no more than this number of instances or paths
1625
1626
1627   pr pullreferenceInstances Operation
1628       Executes the an enumeration sequence that starts with  OpenReferenceIn‐
1629       stances  and  may  continue  with  pullReferenceInstances. the sequence
1630       returns CIM Instances. It is similar to  the  references  operation  in
1631       basic  parameters  except  that  it returns instances only (it does not
1632       return classes as does the references operation).
1633
1634       The syntax for this the operation is:
1635
1636       cimcli pr [objectname] [<option>]*
1637
1638       Note that the objectname may be either a  class  name  or  an  instance
1639       name.  If a class name is supplied, the user is queried for the object‐
1640       name parameter.  If objectname is used, the response  is  instances  of
1641       the references that match the objectname.
1642
1643       The options specifically used by this operation are:
1644
1645       -r [role] role parameter for the CIM Operation.
1646
1647       -rc [resultClassName] resultClass parameter for the CIM Operation
1648
1649       -iq includeQualifiers (The default is false)
1650
1651       -ic Boolean to set include class origin operation parameter to true.
1652
1653       -pl [propertyList] Optional property list for the operation
1654
1655       -ql  [filterQueryLanguage] Optional definition of the filter query lan‐
1656       guage used for this operation.  Required if the -f option is specified.
1657
1658       -f [filter] Optional filter for the language defined in the -ql option.
1659       The  response  is  filtered  using this filter specification. The query
1660       language syntax is documented in the general section above.  NOTE:  The
1661       filter  may  not  be allowed for the paths operations for some servers,
1662       specifically OpenPegasus.
1663
1664       -pt [pullTimeout] The timeout value that cimcli sends to the server  as
1665       part of the open request.  This is the minimum time in seconds that the
1666       server will  keep  the  enumeration  context  open  between  sending  a
1667       response and receiving the next request within a single pull sequence.
1668
1669       -mr [maxObjectsToReceive] The maximum number of instances or paths that
1670       will be accepted by cimcli before issuing a close operation.
1671
1672       -pullDelay [pullDelayinSec] Delay in seconds that cimcli  will  execute
1673       between each of the operations of the pullsequence. The primary use for
1674       this is testing delay issues.
1675
1676       -mo [maxObjectCount] The maximum object count  thatcimclisends  to  the
1677       server  for each request in an enumeration context.  The server returns
1678       no more than this number of instances or paths
1679
1680       Examples:
1681           cimcli pr CIM_ManagedElement
1682                 enter the interactive mode and presents the cimcli user with a
1683              list of all objectPaths for CIM_ManagedElement from which it
1684              builds the openReferenceInstances request.
1685
1686
1687   prn pullreferencePaths Operation
1688       Executes an enumeration sequence that startes  with  openReferencePaths
1689       and continues with pullInstancePaths. This operation is the pull paral‐
1690       lel of the referenceNames operation.
1691
1692       The syntax for this operation is:
1693
1694       cimcli prn [objectname] [<option>]*
1695
1696       Note that the objectname may be either  a  class  name  or  a  specific
1697       instance  name.   If  classname  is  supplied,   the user is queried to
1698       select an instance name for the clas  name  input.   If  objectname  is
1699       used, the response is instance names of the references that matches the
1700       objectname.
1701
1702       The options specifically used by this operation are:
1703
1704       -r [role] role parameter for the CIM Operation
1705
1706       -rc [resultClassName] resultClass parameter for the CIM Operation
1707
1708       -ql [filterQueryLanguage] Optional definition of the filter query  lan‐
1709       guage used for this operation.  Required if the -f option is specified.
1710
1711       -f [filter] Optional filter for the language defined in the -ql option.
1712       The response is filtered using this  filter  specification.  The  query
1713       language  syntax  is documented in the general section above. NOTE: The
1714       filter may not be allowed for the paths operations  for  some  servers,
1715       specifically OpenPegasus.
1716
1717       -pt  [pullTimeout] The timeout value that cimcli sends to the server as
1718       part of the open request.  This is the minimum time in seconds that the
1719       server  will  keep  the  enumeration  context  open  between  sending a
1720       response and receiving the next request within a single pull sequence.
1721
1722       -mr [maxObjectsToReceive] The maximum number of instances or paths that
1723       will be accepted by cimcli before issuing a close operation.
1724
1725       -pullDelay  [pullDelayinSec]  Delay in seconds that cimcli will execute
1726       between each of the operations of the pullsequence. The primary use for
1727       this is testing delay issues.
1728
1729       -mo  [maxObjectCount] The maximum object count that cimcli sends to the
1730       server for each request in an enumeration context.  The server  returns
1731       no more than this number of instances or paths
1732
1733
1734   pxq pullExecQuery Operation
1735       The  pullExecQuery executes an enumeration sequence that opens with the
1736       openQueryInstances client request and continues with  pullInstances  if
1737       required.   This  operation  is parallel to the execQuery cimcli opera‐
1738       tion.
1739
1740       Example:
1741             cimcli pxq <query_filter> <query_language> [<option>]*
1742       The query_filter and the query_language may be supplied directly on the
1743       command  line  as  parameter or as options (-f for the query filter and
1744       -ql for query language.
1745
1746       The query languages used for this operation are languages like WQL  and
1747       CQL.   they  are NOT FQL which supports only the enumerate, associator,
1748       and reference type operations.
1749
1750       The pullExecQuery CIM Operation is executed  directly  with  the  input
1751       parameters  or  options.  If neither a query_filter parameter or option
1752       are supplied cimcli returns an error. If the  query_language  parameter
1753       (-ql)  is omitted the default is "WQL". The operation does not validate
1754       the query language parameter but simply passes the input string  on  to
1755       the CIM server.
1756
1757       Today  this  operation  does  not support the openQueryInstances client
1758       request parameter  returnQueryResultClass that requests that  the  cim‐
1759       server generate a class corresponding to the returned objects.
1760
1761       Examples
1762               cimcli pxq "Select * from CIM_Something" CQL
1763
1764               cimcli pxq "Select * from CIM_blah"
1765                    uses WQL as default query language
1766
1767
1768   son Operation (Deprecated)
1769       Set  the CIM server statistics to enabled by doing a modify instance of
1770       the CIM_ObjectManager instance that defines the server. This depends on
1771       the  server  having  implemented statistics and having also implemented
1772       the functionality of enabling and disabling statistics through  setting
1773       this property in CIM_ObjectManager.  This should be considered a tempo‐
1774       rary operation in cimcli until a more  permanent  utility  is  provided
1775       with OpenPegasus to manage this type of functionality.  The correspond‐
1776       ing operation soff will attempt to disable statistics  on  the  server.
1777       This works with OpenPegasus servers starting with version 2.5.1.
1778
1779       DEPRECATED to be replaced at some time in the future.
1780
1781       The syntax of the operation is:
1782
1783       cimcli son
1784
1785
1786   soff Operation (Deprecated)
1787       See the operation son.  This is the corresponding operation to turn off
1788       statistics in the server.
1789
1790       DEPRECATED to be replaced by at some time in the future.
1791
1792       The syntax of the operation is:
1793
1794       cimcli soff
1795
1796
1797   ns enumeratenamespaces Operation
1798       Request an Enumeration of all the namespaces in the target CIM  Server.
1799       This  command  uses both the CIM_Namespace class and if that fails, the
1800       __Namespace class to determine the list of namespaces.
1801
1802       RETURN - It displays a list of the namespace names returned by the  CIM
1803       Server.
1804
1805       The syntax for this operation is:
1806
1807       cimcli ns [<option>]*
1808
1809       Note  that  since  this  operation enumerates namespaces, the namespace
1810       option (-n) is not used.
1811
1812       Examples
1813          cimcli ns
1814              request list of all namespaces from the CIM server
1815
1816
1817   cci countInstances Operation
1818       Counts the number of instances by class in a namespace (if  no  [Opera‐
1819       tionTarget] is specified or of the subclasses of the class specified by
1820       [OperationTarget].
1821
1822       WARNING: This operation could cause  problems  if  executed  against  a
1823       server which returns very large numbers of instances since it retrieves
1824       all of the instances and counts them in cimcli.
1825
1826       This operation counts the number of instances  of  each  class  in  the
1827       class  hiearchy.   Note that an enumerateInstances returns instances of
1828       all classes in a hiearchy but that this operation actually  counts  the
1829       number of instances of each class separately.
1830
1831       The syntax for this operation is:
1832           cimcli cci <[targetClass]> [option]...
1833
1834       The  output option does not apply.  The output is always a text display
1835       of classes with instances and count of number of instances. All associ‐
1836       ation class instances are suffixed with an asterick(*).
1837
1838       Examples
1839           cimcli cci
1840
1841           cimcli cci CIM_ComputerSystem -n PG_InterOp -l localhost
1842
1843
1844   ct classtree Operation
1845       Display  the  class hiearchy for the class provided as a parameter with
1846       the operation request.
1847
1848       This operation can display either the subclass tree or if the -nlo  (no
1849       local  only)  option  is specified, the superclass tree for the defined
1850       class.  Note that the class parameter is  required  if  the  superclass
1851       tree is requested but not if the subclass tree is requested.
1852
1853       In  addition,  if  the  class  is  an  association class, the reference
1854       classes are included in the display if text output is requested (-di).
1855
1856       The syntax is as follows:
1857           cimcli ct <classname> [<option>]*
1858
1859       Examples
1860           cimcli ct
1861               displays class tree for one namespace
1862           cimcli ct CIM_ComputerSystem
1863               displays class tree starting at CIM_ComputerSystem
1864           cimcli ct CIM_ComputerSystem -nlo
1865               displays a tree of the superclasses of CIM_ComputerSystem
1866           cimcli ct CIM_ComputerSystem -o txt
1867               displays class tree startign at CIM_Computer system and for
1868               any association class displays the class defined for each
1869               reference property
1870
1871

OPTIONS LIST

1873       There are a significant number of options  to  this  utility,  some  if
1874       which provide specific information for one or more commands and some of
1875       which are universal across all of the commands.   In general, the  pro‐
1876       gram does not check for spurious options so that if you input an option
1877       that is not used by a particular operation, it is simply ignored.  Note
1878       that some of the options require parameters.
1879
1880       The following is an alphabetic list of the options:
1881
1882       -ac [assocatonClassName]
1883              The  association  class  name  parameter  defines  an assocClass
1884              string for Associator calls (associators  and  associatornames).
1885              Default().
1886
1887              Example:
1888                    -ac CIM_ManagedElement
1889
1890       -ar association_role_name
1891              Defines  an association role for associator operations. Example:
1892              -ar dependent. This optional parameter is  used  only  with  the
1893              association CIM Operations.
1894
1895
1896       --cert [certificateFilePath]
1897              Defines  a certificate to be used with the client connect if the
1898              -s option is set. This is optional and used only   with  the  -s
1899              and  --key  options.  The parameter value certificateFilePath is
1900              required with the parameter and defined the file containing  the
1901              certificate.   If this parameter exists the --key parameter must
1902              also exist to be a valid SSL request. This represents  the  X509
1903              certificate of the client that will be sent to the server during
1904              an SLL handshake if the server requests it.
1905
1906
1907       --count [object_count]
1908              Defines an expected count of  objects  to  be  returned  in  the
1909              response.  cimcli is terminated with an error exit if the number
1910              of objects returned does not  match  the  object_count  supplied
1911              with  the  option.  This test can be used in batch files to test
1912              for number of objects returned by an operation.  In addition  to
1913              the error status code, a message of the general form:
1914                   "Failed count test. Expected= xx. Received= yy"
1915              is output to cerr.
1916
1917              Example:
1918                 cimcli en CIM_ManagedElement -count 100
1919
1920                     If the count of instances returned is not equal to 100,
1921                     cimcli exits with error code 60 and the Failed count test
1922                     error message.
1923
1924       -delay [time in seconds]
1925              Delay  between  connection  and  request  .  Default(0). example
1926              -delay 3 delays 3 seconds between the call and the  transmission
1927              of  the actual CIM operation.  This is used only in some testing
1928              environments.
1929
1930       -di    Specifies the boolean parameter  deepInheritance  parameter  for
1931              selected  commands.  Setting this options causes the deepinheri‐
1932              tance=true to be transmitted for the operation.  Note that  this
1933              means  different  things  to different commands and is used only
1934              with the enumerate commands.
1935
1936
1937       -d     More detailed debug messages from cimcli. This can be useful  in
1938              the case where the user is debugging CIM functionality.
1939
1940
1941       -h <command-name>
1942              Prints the help for a particular operation including the defini‐
1943              tion of the  operation,  applicable  options,  and  examples  of
1944              usage.
1945           cimcli -h gc
1946
1947               show information on the getclass operation
1948
1949       --help Prints full help message with commands, options, examples.
1950
1951
1952       -ho    Prints list of cimcli options with definitions.
1953
1954
1955       -hc    Print cimcli Operation command list.  This list includes the CIM
1956              Operatons defined by the CIM Operations specification and  other
1957              operations  that  were felt to be useful in testing CIM environ‐
1958              ments. It includes defintion and examples of each operation.
1959
1960
1961       -ic    Boolean to set include class origin operation parameter to true.
1962
1963
1964       -f [filter]
1965              Defines a filter to use for query. One String input . Default()
1966
1967
1968       -o [ xml | mof | table ]
1969              Output in xml, mof, or table  format.  Default(mof)  if  the  -o
1970              options is not included. Note that the output formatting is only
1971              for CIM objects (classes and instances). Object paths are always
1972              displayed as strings.
1973
1974              The meaning of the keywords is:
1975
1976              /fBxml.fR  Display class or instance in CIM-XML format /fBmof/fR
1977              Display class or instance as MOF /fBtable/fR Display instance as
1978              a  table with one column per property an a row for each instance
1979              returned. This format does NOT wrap at 80 columns or  wrap  long
1980              strings.
1981
1982                  -o xml
1983                  display the output in xml
1984
1985
1986       -iq    Specifies  the  includeQualifiers  operation input parameter for
1987              selected commands.Since the CIM/XML default for  this  parameter
1988              is  true  for  some  operations (class operations) and false for
1989              others (instance operations), the  option  is  useful  only  for
1990              instance  operations.   Also the includeQualifiers parameter has
1991              been deprecated in the CIM/XML specification so the results  for
1992              instance  operations  is  undetermined.   See  also -niq for the
1993              includeQualifiers parameter for class operations.
1994
1995
1996       --key [client key file path]
1997              Defines a Client private key. This is optional and only  has  an
1998              effect on connections made over HTTPS using the -ssl option.  If
1999              this parameter exists the client certificate parameter  (--cert)
2000              must also exist to be usable.
2001
2002
2003       -l [location]
2004              Define CIM Server host address for the operation.  This includes
2005              either  name  or  IP  address  and  optional  port  number(Host‐
2006              Name:port).   The  default  is  localhost:5988.  If name is used
2007              without port, port 5988 is assumed.  Examples include  -l  fred,
2008              -l fred:9999, -l 10.1.134.66 -l 10.1.134.123:5977
2009
2010
2011       -lo    Specifies  the  localOnly  operation parameter for selected com‐
2012              mands if the option is set.  See the commands for more  informa‐
2013              tion. This option is Deprecated in favor of the -nlo because the
2014              default for local only is on so that generally the -lo is simply
2015              the default.  We recommend using -nlo to turn off local only.
2016
2017
2018       -n [namespace]
2019              Defines  the  namespace for the operation.host name. The default
2020              is   root/cimv2.   Example   -n   root/PG_Interop    sets    the
2021              root/PG_Interop namespace as the namespace for the current oper‐
2022              ation.
2023
2024
2025       -p [password]
2026              Allows input of a password for server authentication of the com‐
2027              mand.  (  ex.  -p  12345678). The default is that the command is
2028              submitted with no password.
2029
2030
2031       -u [User]
2032              Defines user name for CIM Server authentication. Default  is  no
2033              user  name  and  no authentication.  ( ex -u john) Default is no
2034              user name and no authentication from the client.
2035
2036
2037       -lo    DEPRECATED.  This was used to set LocalOnly.   However,  default
2038              should  be  true  and  we cannot use True as default.  See -nlo.
2039              Default(true).
2040
2041
2042       -nlo   When set,  sets  LocalOnly  =  false  on  the  CIM  operation  .
2043              Default(false)  meaning  that  the  operation  sets  LocalOnly =
2044              true..
2045
2046
2047       -ic    Sets includeClassOrigin = true for operation that  support  this
2048              parameter (i.e. get and enumerate classes and instances, associ‐
2049              ators, and references operations).  Note that the  class  origin
2050              information is only output for the -o xml output operation since
2051              class origin is not part of the MOF format.
2052
2053       -niq   Sets includeQualifiers = false on operations. Default(false).
2054
2055
2056       -pl [propertyList]
2057              Defines a propertyName List which is an optional  parameter  for
2058              some  CIM  Operations.  Format  is  p1,p2,p3  (without  spaces).
2059              Default is that the property list is set to NULL indicating nor‐
2060              mally  that  the  operation  should  return all properties.  The
2061              property list typically has 3 possibilities 1) empty which means
2062              return  no  properties, 2) list of properties to be returned, 3)
2063              NULL which means return all properties.  Since  the  default  is
2064              NULL,  not  applying  the  option  means that all properties are
2065              being requested.  To set this parameter to empty  use  the  form
2066              -pl "".
2067
2068
2069       -r [role]
2070              Defines a role string for reference role parameter. Default()
2071
2072
2073       -rc [resultClassName]
2074              Defines  a  resultClass  string  for References and Associators.
2075              Default()
2076
2077
2078       -rr [resultRole]
2079              Defines a  role  string  for  associators  operation  resultRole
2080              parameter.
2081
2082
2083       --setRtnHostNames [SubstituteHostName]
2084              String  option  with  a required parameter that set a substitute
2085              host name which cimcli will  insert  into  returned  objects  to
2086              replace  host  names  returned from the server.  This option was
2087              defined because the object paths/references returned by the  CIM
2088              Server  may include the host name as part of the returned object
2089              path which makes it difficult to compare the returned paths to a
2090              defined  path.  Using this option forces any returned host names
2091              to be changed to the string parameter supplied with the option.
2092
2093
2094       --sum  Displays only  summary  counts  for  enumerations,  associators,
2095              etc.This  option  is used to with the repeat option to repeat an
2096              operation without getting the full return display.   It  reduces
2097              the  display  to summary information.  It is often used with the
2098              time option --t to generate time for  execution  information  on
2099              many repetitions of a command.
2100
2101
2102       --timeout [seconds]
2103              Set  the  connection timeout in seconds. If not set, the timeout
2104              is the default Pegasus client timeout which for Pegasus is  nor‐
2105              mally  to about 30 seconds. This option executes the client call
2106              to set timeout.
2107
2108
2109       -trace [trace_level]
2110              Set Pegasus Common Components Trace.  Sets the Trace  level.   0
2111              is  off.  Default(0).  The trace level can be set to 0 - 5. Note
2112              that since mose trace definitions have been removed from cimcli,
2113              this is of little value.
2114
2115
2116       --truststore [clientTrustStorePath]
2117              The  value  of this parameter specifies a file or directory that
2118              is the truststore that the client uses to verify server certifi‐
2119              cates.  The  default  is  that  no  truststore is defined so the
2120              client does not  verify  certificates  from  the  server.   This
2121              parameter  is  used  only if cimcli is compiled with SSL enabled
2122              and the -s option (use SSL) is specified for the request.
2123
2124
2125       --v    Displays cimcli and Pegasus software Version.
2126
2127
2128       -v     Verbose Display. Includes Detailed parameter Input  display  and
2129              display  of  each  operation  in  an enumeration sequence (open,
2130              pull, close).  Default(false). Outputs extra  information  about
2131              the  parameters actually used in the request and the return from
2132              the operation.  This is primarily a debugging tool. for enumera‐
2133              tion  context it outputs information on each request/response in
2134              the sequence including timing information.
2135
2136
2137       --r [repeat_count]
2138              Number of times to repeat the function. Zero means one time. The
2139              option  can  be used to repeat an operation within a single call
2140              to cimcli.  It simply repeats the operation defined  the  number
2141              of times defined by the repeat_count within the same connection.
2142              Thus, it  establishes  the  connection  executes  the  operation
2143              repeat_count times and then terminates.  It can be used with the
2144              --time option to measure execution times for many repetitions of
2145              an operation.
2146
2147
2148       -s     Boolean  option that specifies that the Client should attempt to
2149              connect over the secure connection using SSL. This option causes
2150              cimcli  to  modify the client connect call to set the SSLContext
2151              option to the certificate defined  with  the  --cert  and  --key
2152              options.   If this option is set but neither the --cert or --key
2153              options are included, the SSLContext for  the  connect  call  is
2154              submitted with the Cert and key marked NULL.
2155
2156              NOTE:  since  SSL is considered a compilable option with cimcli,
2157              these options may not even exist in a Pegasus  environment  that
2158              was compiled with the SSL capabilities disabled.
2159
2160
2161       --sort Sort  the output objects before display for multi-object outputs
2162              such  as  enumerates,  references,   associations,   and   their
2163              corrsponding  ...names  operations  and  for the enumerateQuali‐
2164              fierDecls.  Whereever cimcli delivers multiple entities  in  the
2165              response, the use of this option tells cimcli to attempt to sort
2166              the output entities.  Generally  the  sort  order  is  assending
2167              order  using   a)  class name for operations that return classes
2168              and b) CIM Object Path for operations that return instances.
2169
2170
2171       --t    Measure time for the operation and present results. When set the
2172              response  time  for  the operation is presented with the command
2173              output.  If the --r (repeat) option is  set,  minimum,  maximum,
2174              and  average  times  are  presented.  Note that the time for the
2175              operation itself is presented in addition to  the  overall  time
2176              for connect, operation, and disconnect.  If statistics are being
2177              gathered by the server, setting this option  also  presents  the
2178              server time, and the client round trip time which are calculated
2179              by the server and client infrastructure.
2180
2181
2182       -x     Output objects in xml instead of mof format. Default(false)
2183
2184
2185       -pt [pullTimeout]
2186              The timeout value that cimcli sends to the server as part of the
2187              open  request.   This  is  the  minimum time in seconds that the
2188              server will keep the enumeration context open between sending  a
2189              response  and  receiving  the  next request within a single pull
2190              sequence.
2191
2192
2193       -mr [maxObjectsToReceive]
2194              The maximum number of instances or paths that will  be  accepted
2195              by cimcli before issuing a close operation.
2196
2197
2198       -pullDelay [pullDelayinSec]
2199              Delay  in  seconds  that cimcli will execute between each of the
2200              operations of the pull sequence. The primary  use  for  this  is
2201              testing delay issues.
2202
2203
2204       -mo [maxObjectCount]
2205              The  maximum  object  count  that cimcli sends to the server for
2206              each request in an enumeration context (one of the pull... oper‐
2207              ations.   The  server  returns  no  more  than  this  number  of
2208              instances or paths
2209
2210
2211

EXAMPLES

2213       NOTE: Many examples are available for each  operation  through  the  -h
2214       command line options.
2215
2216       Execute an enumerateinstancenames CIM operation for the pg_computersys‐
2217       tem Class:
2218
2219           cimcli enumerateinstancenames pg_computersystem
2220          or
2221           cimcli ei pg_computersystem
2222
2223       Enumerate the class names from the default namespace "root/cimv2":
2224           cimcli enumerateclassnames -- Enumerate classnames from root/cimv2.
2225
2226       Enumerate class names from the namespace "root":
2227           cimcli ec /n root -- Enumerate classnames from namespace root.
2228
2229           cimcli ec -o xml   -- Enumerate classes with XML output starting at
2230       root.
2231
2232           cimcli enumerateclasses CIM_ComputerSystem -di
2233              -- Enumerate classes starting at CIM_ComputerSystem and the
2234                 remainder of the class hiearchy (-di) with mof output of the
2235                 classes.
2236
2237           cimcli getclass CIM_door -a -u guest -p guest
2238           --  Get  class with authentication set and user = guest, password =
2239       guest.
2240
2241           cimcli  rn  TST_Person.name=@MIKE@   -n   root/sampleprovider   -rc
2242       TST_Lineage.
2243
2244           cimcli  ec  -o  XML -- enumerate classes and output XML rather than
2245       MOF.
2246
2247           cimcli getqualifiers -- Get the qualifiers in mof output format
2248
2249

RETURN VALUE

2251       cimcli returns a significant number of error codes as follows:
2252
2253       0 Successful execution of the operation.
2254
2255       1-49 A CIM Operation executed as part of the cimcli operation  returned
2256       a  CIM Exception as defined in the DMTF CIM Operations over HTTP speci‐
2257       fication.  The status code of the error is returned. While  today  only
2258       not  all  of  the  numbers from 1 to 49 are used for CIM Status errors,
2259       cimcli has reserved this set of numbers with the expectation that  this
2260       list will expand in the future.
2261
2262       cimcli  will  not  return  any  error  codes in this range that are not
2263       specifically defined by DMTF error status codes and  generated  by  the
2264       CIM Operation calls.
2265
2266       50 Pegasus Exception encountered during execution of Pegasus Functions
2267
2268       51 cimcli general error not covered by other errors
2269
2270       52 Unknown exception occurred during execution of the operation
2271
2272       53 Command line or configuration file input parsing error.
2273
2274       54 Connection to server failed error.
2275
2276       60  cimcli  failed  a  compare  with one of the test operations such as
2277       testInstance. The returned entity did not match the properties  of  the
2278       object defined by the input parameters.
2279
2280       70  cimcli  internal error that cannot be attributed to external issues
2281       such as commmand line input or server response.  This usually indicates
2282       a bug in cimcli.
2283
2284

AUTHOR

2286       Karl Schopmeyer k.schopmeyer@opengroup.org
2287
2288
2289
2290                                     LOCAL                           cimcli(1)
Impressum