1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import sys
23 import os
24 from getpass import getpass
25
26 from pywbem import lex, yacc, cim_obj
27 from pywbem.cim_obj import CIMInstance, CIMInstanceName, CIMClass, \
28 CIMProperty, CIMMethod, CIMParameter, \
29 CIMQualifier, CIMQualifierDeclaration, NocaseDict
30 from pywbem.cim_operations import CIMError, WBEMConnection
31 from pywbem.cim_constants import *
32
33 __all__ = ['MOFParseError', 'MOFWBEMConnection', 'MOFCompiler']
34
35 _optimize = 1
36 _tabmodule = 'mofparsetab'
37 _lextab = 'moflextab'
38 _outputdir = 'pywbem'
39
40 reserved = {
41 'any':'ANY',
42 'as':'AS',
43 'association':'ASSOCIATION',
44 'class':'CLASS',
45 'disableoverride':'DISABLEOVERRIDE',
46 'boolean':'DT_BOOL',
47 'char16':'DT_CHAR16',
48 'datetime':'DT_DATETIME',
49 'pragma':'PRAGMA',
50 'real32':'DT_REAL32',
51 'real64':'DT_REAL64',
52 'sint16':'DT_SINT16',
53 'sint32':'DT_SINT32',
54 'sint64':'DT_SINT64',
55 'sint8':'DT_SINT8',
56 'string':'DT_STR',
57 'uint16':'DT_UINT16',
58 'uint32':'DT_UINT32',
59 'uint64':'DT_UINT64',
60 'uint8':'DT_UINT8',
61 'enableoverride':'ENABLEOVERRIDE',
62 'false':'FALSE',
63 'flavor':'FLAVOR',
64 'indication':'INDICATION',
65 'instance':'INSTANCE',
66 'method':'METHOD',
67 'null':'NULL',
68 'of':'OF',
69 'parameter':'PARAMETER',
70 'property':'PROPERTY',
71 'qualifier':'QUALIFIER',
72 'ref':'REF',
73 'reference':'REFERENCE',
74 'restricted':'RESTRICTED',
75 'schema':'SCHEMA',
76 'scope':'SCOPE',
77 'tosubclass':'TOSUBCLASS',
78 'translatable':'TRANSLATABLE',
79 'true':'TRUE',
80 }
81
82 tokens = reserved.values() + [
83 'IDENTIFIER',
84 'stringValue',
85 'floatValue',
86 'charValue',
87 'binaryValue',
88 'octalValue',
89 'decimalValue',
90 'hexValue',
91 ]
92
93 literals = '#(){};[],$:='
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108 utf8_2 = r'[\xC2-\xDF][\x80-\xBF]'
109 utf8_3_1 = r'\xE0[\xA0-\xBF][\x80-\xBF]'
110 utf8_3_2 = r'[\xE1-\xEC][\x80-\xBF][\x80-\xBF]'
111 utf8_3_3 = r'\xED[\x80-\x9F][\x80-\xBF]'
112 utf8_3_4 = r'[\xEE-\xEF][\x80-\xBF][\x80-\xBF]'
113 utf8_4_1 = r'\xF0[\x90-\xBF][\x80-\xBF][\x80-\xBF]'
114 utf8_4_2 = r'[\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF]'
115 utf8_4_3 = r'\xF4[\x80-\x8F][\x80-\xBF][\x80-\xBF]'
116
117 utf8Char = r'(%s)|(%s)|(%s)|(%s)|(%s)|(%s)|(%s)|(%s)' % \
118 (utf8_2, utf8_3_1, utf8_3_2, utf8_3_3, utf8_3_4, utf8_4_1,
119 utf8_4_2, utf8_4_3)
124
128
129
130 t_binaryValue = r'[+-]?[01]+[bB]'
131 t_octalValue = r'[+-]?0[0-7]+'
132 t_decimalValue = r'[+-]?([1-9][0-9]*|0)'
133 t_hexValue = r'[+-]?0[xX][0-9a-fA-F]+'
134 t_floatValue = r'[+-]?[0-9]*\.[0-9]+([eE][+-]?[0-9]+)?'
135
136 simpleEscape = r"""[bfnrt'"\\]"""
137 hexEscape = r'x[0-9a-fA-F]{1,4}'
138 escapeSequence = r'[\\]((%s)|(%s))' % (simpleEscape, hexEscape)
139 cChar = r"[^'\\\n\r]|(%s)" % escapeSequence
140 sChar = r'[^"\\\n\r]|(%s)' % escapeSequence
141 charValue = r"'%s'" % cChar
142
143 t_stringValue = r'"(%s)*"' % sChar
144
145 identifier_re = r'([a-zA-Z_]|(%s))([0-9a-zA-Z_]|(%s))*' % (utf8Char, utf8Char)
149
150 t.type = reserved.get(t.value.lower(), 'IDENTIFIER')
151 return t
152
155 r'\n+'
156 t.lexer.lineno += len(t.value)
157 t.lexer.linestart = t.lexpos
158
159 t_ignore = ' \r\t'
163 msg = "Illegal character '%s' " % t.value[0]
164 msg += "Line %d, col %d" % (t.lineno, _find_column(t.lexer.parser.mof, t))
165 t.lexer.parser.log(msg)
166 t.lexer.skip(1)
167
170
172 ex = MOFParseError()
173 if p is None:
174 ex.args = ('Unexpected end of file',)
175 raise ex
176 ex.file = p.lexer.parser.file
177 ex.lineno = p.lineno
178 ex.column = _find_column(p.lexer.parser.mof, p)
179 ex.context = _get_error_context(p.lexer.parser.mof, p)
180 raise ex
181
184 """mofSpecification : mofProductionList"""
185
187 """mofProductionList : empty
188 | mofProductionList mofProduction
189 """
190
192 """mofProduction : compilerDirective
193 | mp_createClass
194 | mp_setQualifier
195 | mp_createInstance
196 """
197
200
201 cimom_type = None
202 ns = ns.strip('/')
203 try:
204 inames = handle.EnumerateInstanceNames('__Namespace', namespace='root')
205 inames = [x['name'] for x in inames]
206 if 'PG_InterOp' in inames:
207 cimom_type = 'pegasus'
208 except CIMError, ce:
209 if ce.args[0] != CIM_ERR_NOT_FOUND:
210 ce.file_line = (p.parser.file, p.lexer.lineno)
211 raise
212 if not cimom_type:
213 try:
214 inames = handle.EnumerateInstanceNames('CIM_Namespace',
215 namespace='Interop')
216 inames = [x['name'] for x in inames]
217 cimom_type = 'proper'
218 except CIMError, ce:
219 ce.file_line = (p.parser.file, p.lexer.lineno)
220 raise
221
222 if not cimom_type:
223 ce = CIMError(CIM_ERR_FAILED,
224 'Unable to determine CIMOM type')
225 ce.file_line = (p.parser.file, p.lexer.lineno)
226 raise ce
227 if cimom_type == 'pegasus':
228
229
230
231 inst = CIMInstance(
232 '__Namespace',
233 properties={'Name':''},
234 path=CIMInstanceName(
235 '__Namespace',
236 keybindings={'Name':''},
237 namespace=ns))
238 try:
239 handle.CreateInstance(inst)
240 except CIMError, ce:
241 if ce.args[0] != CIM_ERR_ALREADY_EXISTS:
242 ce.file_line = (p.parser.file, p.lexer.lineno)
243 raise
244
245 elif cimom_type == 'proper':
246 inst = CIMInstance(
247 'CIM_Namespace',
248 properties={'Name': ns},
249 path=CIMInstanceName(
250 'CIM_Namespace',
251 namespace='root',
252 keybindings={'Name':ns}))
253 handle.CreateInstance(inst)
254
259 """mp_createClass : classDeclaration
260 | assocDeclaration
261 | indicDeclaration
262 """
263 ns = p.parser.handle.default_namespace
264 cc = p[1]
265 try:
266 fixedNS = fixedRefs = fixedSuper = False
267 while not fixedNS or not fixedRefs or not fixedSuper:
268 try:
269 if p.parser.verbose:
270 p.parser.log('Creating class %s:%s' % (ns, cc.classname))
271 p.parser.handle.CreateClass(cc)
272 if p.parser.verbose:
273 p.parser.log('Created class %s:%s' % (ns, cc.classname))
274 p.parser.classnames[ns].append(cc.classname.lower())
275 break
276 except CIMError, ce:
277 ce.file_line = (p.parser.file, p.lexer.lineno)
278 errcode = ce.args[0]
279 if errcode == CIM_ERR_INVALID_NAMESPACE:
280 if fixedNS:
281 raise
282 if p.parser.verbose:
283 p.parser.log('Creating namespace ' + ns)
284 _create_ns(p, p.parser.handle, ns)
285 fixedNS = True
286 continue
287 if not p.parser.search_paths:
288 raise
289 if errcode == CIM_ERR_INVALID_SUPERCLASS:
290 if fixedSuper:
291 raise
292 moffile = p.parser.mofcomp.find_mof(cc.superclass)
293 if not moffile:
294 raise
295 p.parser.mofcomp.compile_file(moffile, ns)
296 fixedSuper = True
297 elif errcode in [CIM_ERR_INVALID_PARAMETER,
298 CIM_ERR_NOT_FOUND,
299 CIM_ERR_FAILED]:
300 if fixedRefs:
301 raise
302 if not p.parser.qualcache[ns]:
303 for fname in ['qualifiers', 'qualifiers_optional']:
304 qualfile = p.parser.mofcomp.find_mof(fname)
305 if qualfile:
306 p.parser.mofcomp.compile_file(qualfile, ns)
307 if not p.parser.qualcache[ns]:
308
309 raise
310 objects = cc.properties.values()
311 for meth in cc.methods.values():
312 objects += meth.parameters.values()
313 dep_classes = []
314 for obj in objects:
315 if obj.type not in ['reference', 'string']:
316 continue
317 if obj.type == 'reference':
318 if obj.reference_class.lower() not in dep_classes:
319 dep_classes.append(obj.reference_class.lower())
320 continue
321
322 try:
323 embedded_inst = obj.qualifiers['embeddedinstance']
324 except KeyError:
325 continue
326 embedded_inst = embedded_inst.value.lower()
327 if embedded_inst not in dep_classes:
328 dep_classes.append(embedded_inst)
329 continue
330 for klass in dep_classes:
331 if klass in p.parser.classnames[ns]:
332 continue
333 try:
334
335
336
337
338
339 p.parser.handle.GetClass(klass,
340 LocalOnly=False,
341 IncludeQualifiers=True)
342 p.parser.classnames[ns].append(klass)
343 except CIMError:
344 moffile = p.parser.mofcomp.find_mof(klass)
345 if not moffile:
346 raise
347 p.parser.mofcomp.compile_file(moffile, ns)
348 p.parser.classnames[ns].append(klass)
349 fixedRefs = True
350 else:
351 raise
352
353 except CIMError, ce:
354 ce.file_line = (p.parser.file, p.lexer.lineno)
355 if ce.args[0] != CIM_ERR_ALREADY_EXISTS:
356 raise
357 if p.parser.verbose:
358 p.parser.log('Class %s already exist. Modifying...' % cc.classname)
359 try:
360 p.parser.handle.ModifyClass(cc, ns)
361 except CIMError, ce:
362 p.parser.log('Error Modifying class %s: %s, %s' % \
363 (cc.classname, ce.args[0], ce.args[1]))
364
366 """mp_createInstance : instanceDeclaration"""
367 inst = p[1]
368 if p.parser.verbose:
369 p.parser.log('Creating instance of %s.' % inst.classname)
370 try:
371 p.parser.handle.CreateInstance(inst)
372 except CIMError, ce:
373 if ce.args[0] == CIM_ERR_ALREADY_EXISTS:
374 if p.parser.verbose:
375 p.parser.log('Instance of class %s already exist. ' \
376 'Modifying...' % inst.classname)
377 try:
378 p.parser.handle.ModifyInstance(inst)
379 except CIMError, ce:
380 if ce.args[0] == CIM_ERR_NOT_SUPPORTED:
381 if p.parser.verbose:
382 p.parser.log('ModifyInstance not supported. ' \
383 'Deleting instance of %s: %s' % \
384 (inst.classname, inst.path))
385 p.parser.handle.DeleteInstance(inst.path)
386 if p.parser.verbose:
387 p.parser.log('Creating instance of %s.' % \
388 inst.classname)
389 p.parser.handle.CreateInstance(inst)
390 else:
391 ce.file_line = (p.parser.file, p.lexer.lineno)
392 raise
393
395 """mp_setQualifier : qualifierDeclaration"""
396 qualdecl = p[1]
397 ns = p.parser.handle.default_namespace
398 if p.parser.verbose:
399 p.parser.log('Setting qualifier %s' % qualdecl.name)
400 try:
401 p.parser.handle.SetQualifier(qualdecl)
402 except CIMError, ce:
403 if ce.args[0] == CIM_ERR_INVALID_NAMESPACE:
404 if p.parser.verbose:
405 p.parser.log('Creating namespace ' + ns)
406 _create_ns(p, p.parser.handle, ns)
407 if p.parser.verbose:
408 p.parser.log('Setting qualifier %s' % qualdecl.name)
409 p.parser.handle.SetQualifier(qualdecl)
410 elif ce.args[0] == CIM_ERR_NOT_SUPPORTED:
411 if p.parser.verbose:
412 p.parser.log('Qualifier %s already exists. Deleting...' % \
413 qualdecl.name)
414 p.parser.handle.DeleteQualifier(qualdecl.name)
415 if p.parser.verbose:
416 p.parser.log('Setting qualifier %s' % qualdecl.name)
417 p.parser.handle.SetQualifier(qualdecl)
418 else:
419 ce.file_line = (p.parser.file, p.lexer.lineno)
420 raise
421 p.parser.qualcache[ns][qualdecl.name] = qualdecl
422
424 """compilerDirective : '#' PRAGMA pragmaName '(' pragmaParameter ')'"""
425 directive = p[3].lower()
426 param = p[5]
427 if directive == 'include':
428 fname = param
429
430 fname = os.path.dirname(p.parser.file) + '/' + fname
431 p.parser.mofcomp.compile_file(fname, p.parser.handle.default_namespace)
432 elif directive == 'namespace':
433 p.parser.handle.default_namespace = param
434 if param not in p.parser.qualcache:
435 p.parser.qualcache[param] = NocaseDict()
436
437 p[0] = None
438
440 """pragmaName : identifier"""
441 p[0] = p[1]
442
444 """pragmaParameter : stringValue"""
445 p[0] = _fixStringValue(p[1])
446
448 """classDeclaration :
449 CLASS className '{' classFeatureList '}' ';'
450 | CLASS className superClass '{' classFeatureList '}' ';'
451 | CLASS className alias '{' classFeatureList '}' ';'
452 | CLASS className alias superClass '{' classFeatureList '}' ';'
453 | qualifierList CLASS className '{' classFeatureList '}' ';'
454 | qualifierList CLASS className superClass '{' classFeatureList '}' ';'
455 | qualifierList CLASS className alias '{' classFeatureList '}' ';'
456 | qualifierList CLASS className alias superClass '{'
457 classFeatureList '}' ';'
458 """
459 superclass = None
460 alias = None
461 quals = []
462 if isinstance(p[1], basestring):
463 cname = p[2]
464 if p[3][0] == '$':
465 alias = p[3]
466 if p[4] == '{':
467 cfl = p[5]
468 else:
469 superclass = p[4]
470 cfl = p[6]
471 else:
472 if p[3] == '{':
473 cfl = p[4]
474 else:
475 superclass = p[3]
476 cfl = p[5]
477 else:
478 quals = p[1]
479 cname = p[3]
480 if p[4][0] == '$':
481 alias = p[4]
482 if p[5] == '{':
483 cfl = p[6]
484 else:
485 superclass = p[5]
486 cfl = p[7]
487 else:
488 if p[4] == '{':
489 cfl = p[5]
490 else:
491 superclass = p[4]
492 cfl = p[6]
493 quals = dict([(x.name, x) for x in quals])
494 methods = {}
495 props = {}
496 for item in cfl:
497 item.class_origin = cname
498 if isinstance(item, CIMMethod):
499 methods[item.name] = item
500 else:
501 props[item.name] = item
502 p[0] = CIMClass(cname, properties=props, methods=methods,
503 superclass=superclass, qualifiers=quals)
504 if alias:
505 p.parser.aliases[alias] = p[0]
506
508 """classFeatureList : empty
509 | classFeatureList classFeature
510 """
511 if len(p) == 2:
512 p[0] = []
513 else:
514 p[0] = p[1] + [p[2]]
515
517 """assocDeclaration :
518 '[' ASSOCIATION qualifierListEmpty ']' CLASS className '{'
519 associationFeatureList '}' ';'
520 | '[' ASSOCIATION qualifierListEmpty ']' CLASS className superClass '{'
521 associationFeatureList '}' ';'
522 | '[' ASSOCIATION qualifierListEmpty ']' CLASS className alias '{'
523 associationFeatureList '}' ';'
524 | '[' ASSOCIATION qualifierListEmpty ']' CLASS className alias
525 superClass '{' associationFeatureList '}' ';'
526 """
527 aqual = CIMQualifier('ASSOCIATION', True, type='boolean')
528
529 quals = [aqual] + p[3]
530 p[0] = _assoc_or_indic_decl(quals, p)
531
533 """indicDeclaration :
534 '[' INDICATION qualifierListEmpty ']' CLASS className '{'
535 classFeatureList '}' ';'
536 | '[' INDICATION qualifierListEmpty ']' CLASS className superClass '{'
537 classFeatureList '}' ';'
538 | '[' INDICATION qualifierListEmpty ']' CLASS className alias '{'
539 classFeatureList '}' ';'
540 | '[' INDICATION qualifierListEmpty ']' CLASS className alias
541 superClass '{' classFeatureList '}' ';'
542 """
543 iqual = CIMQualifier('INDICATION', True, type='boolean')
544
545 quals = [iqual] + p[3]
546 p[0] = _assoc_or_indic_decl(quals, p)
547
549 """(refer to grammer rules on p_assocDeclaration and p_indicDeclaration)"""
550 superclass = None
551 alias = None
552 cname = p[6]
553 if p[7] == '{':
554 cfl = p[8]
555 elif p[7][0] == '$':
556 alias = p[7]
557 if p[8] == '{':
558 cfl = p[9]
559 else:
560 superclass = p[8]
561 cfl = p[10]
562 else:
563 superclass = p[7]
564 cfl = p[9]
565 props = {}
566 methods = {}
567 for item in cfl:
568 item.class_origin = cname
569 if isinstance(item, CIMMethod):
570 methods[item.name] = item
571 else:
572 props[item.name] = item
573 quals = dict([(x.name, x) for x in quals])
574 cc = CIMClass(cname, properties=props, methods=methods,
575 superclass=superclass, qualifiers=quals)
576 if alias:
577 p.parser.aliases[alias] = cc
578 return cc
579
581 """qualifierListEmpty : empty
582 | qualifierListEmpty ',' qualifier
583 """
584 if len(p) == 2:
585 p[0] = []
586 else:
587 p[0] = p[1] + [p[3]]
588
590 """associationFeatureList : empty
591 | associationFeatureList associationFeature
592 """
593 if len(p) == 2:
594 p[0] = []
595 else:
596 p[0] = p[1] + [p[2]]
597
599 """className : identifier"""
600 p[0] = p[1]
601
603 """alias : AS aliasIdentifier"""
604 p[0] = p[2]
605
607 """aliasIdentifier : '$' identifier"""
608 p[0] = '$%s' % p[2]
609
611 """superClass : ':' className"""
612 p[0] = p[2]
613
615 """classFeature : propertyDeclaration
616 | methodDeclaration
617 | referenceDeclaration
618 """
619 p[0] = p[1]
620
622 """associationFeature : classFeature"""
623 p[0] = p[1]
624
626 """qualifierList : '[' qualifier qualifierListEmpty ']'"""
627 p[0] = [p[2]] + p[3]
628
630 """qualifier : qualifierName
631 | qualifierName ':' flavorList
632 | qualifierName qualifierParameter
633 | qualifierName qualifierParameter ':' flavorList
634 """
635 qname = p[1]
636 ns = p.parser.handle.default_namespace
637 qval = None
638 flavorlist = []
639 if len(p) == 3:
640 qval = p[2]
641 elif len(p) == 4:
642 flavorlist = p[3]
643 elif len(p) == 5:
644 qval = p[2]
645 flavorlist = p[4]
646 try:
647 qualdecl = p.parser.qualcache[ns][qname]
648 except KeyError:
649 try:
650 quals = p.parser.handle.EnumerateQualifiers()
651 except CIMError, ce:
652 if ce.args[0] != CIM_ERR_INVALID_NAMESPACE:
653 ce.file_line = (p.parser.file, p.lexer.lineno)
654 raise
655 _create_ns(p, p.parser.handle, ns)
656 quals = None
657
658 if quals:
659 for qual in quals:
660 p.parser.qualcache[ns][qual.name] = qual
661 else:
662 for fname in ['qualifiers', 'qualifiers_optional']:
663 qualfile = p.parser.mofcomp.find_mof(fname)
664 if qualfile:
665 p.parser.mofcomp.compile_file(qualfile, ns)
666 try:
667 qualdecl = p.parser.qualcache[ns][qname]
668 except KeyError:
669 ce = CIMError(CIM_ERR_FAILED, 'Unknown Qualifier: %s' % qname)
670 ce.file_line = (p.parser.file, p.lexer.lineno)
671 raise ce
672
673 flavors = _build_flavors(flavorlist, qualdecl)
674 if qval is None:
675 if qualdecl.type == 'boolean':
676 qval = True
677 else:
678 qval = qualdecl.value
679 else:
680 qval = cim_obj.tocimobj(qualdecl.type, qval)
681 p[0] = CIMQualifier(qname, qval, type=qualdecl.type, **flavors)
682
685 """flavorList : flavor
686 | flavorList flavor
687 """
688 if len(p) == 2:
689 p[0] = [p[1]]
690 else:
691 p[0] = p[1] + [p[2]]
692
694 """qualifierParameter : '(' constantValue ')'
695 | arrayInitializer
696 """
697 if len(p) == 2:
698 p[0] = p[1]
699 else:
700 p[0] = p[2]
701
703 """flavor : ENABLEOVERRIDE
704 | DISABLEOVERRIDE
705 | RESTRICTED
706 | TOSUBCLASS
707 | TRANSLATABLE
708 """
709 p[0] = p[1].lower()
710
712 """propertyDeclaration : propertyDeclaration_1
713 | propertyDeclaration_2
714 | propertyDeclaration_3
715 | propertyDeclaration_4
716 | propertyDeclaration_5
717 | propertyDeclaration_6
718 | propertyDeclaration_7
719 | propertyDeclaration_8
720 """
721 p[0] = p[1]
722
724 """propertyDeclaration_1 : dataType propertyName ';'"""
725 p[0] = CIMProperty(p[2], None, type=p[1])
726
728 """propertyDeclaration_2 : dataType propertyName defaultValue ';'"""
729 p[0] = CIMProperty(p[2], p[3], type=p[1])
730
732 """propertyDeclaration_3 : dataType propertyName array ';'"""
733 p[0] = CIMProperty(p[2], None, type=p[1], is_array=True,
734 array_size=p[3])
735
737 """propertyDeclaration_4 : dataType propertyName array defaultValue ';'"""
738 p[0] = CIMProperty(p[2], p[4], type=p[1], is_array=True,
739 array_size=p[3])
740
742 """propertyDeclaration_5 : qualifierList dataType propertyName ';'"""
743 quals = dict([(x.name, x) for x in p[1]])
744 p[0] = CIMProperty(p[3], None, type=p[2], qualifiers=quals)
745
747 """propertyDeclaration_6 : qualifierList dataType propertyName
748 defaultValue ';'"""
749 quals = dict([(x.name, x) for x in p[1]])
750 p[0] = CIMProperty(p[3], cim_obj.tocimobj(p[2], p[4]),
751 type=p[2], qualifiers=quals)
752
754 """propertyDeclaration_7 : qualifierList dataType propertyName array ';'"""
755 quals = dict([(x.name, x) for x in p[1]])
756 p[0] = CIMProperty(p[3], None, type=p[2], qualifiers=quals,
757 is_array=True, array_size=p[4])
758
760 """propertyDeclaration_8 : qualifierList dataType propertyName array
761 defaultValue ';'"""
762 quals = dict([(x.name, x) for x in p[1]])
763 p[0] = CIMProperty(p[3], cim_obj.tocimobj(p[2], p[5]),
764 type=p[2], qualifiers=quals, is_array=True,
765 array_size=p[4])
766
768 """referenceDeclaration :
769 objectRef referenceName ';'
770 | objectRef referenceName defaultValue ';'
771 | qualifierList objectRef referenceName ';'
772 | qualifierList objectRef referenceName defaultValue ';'
773 """
774 quals = []
775 dv = None
776 if isinstance(p[1], list):
777 quals = p[1]
778 cname = p[2]
779 pname = p[3]
780 if len(p) == 6:
781 dv = p[4]
782 else:
783 cname = p[1]
784 pname = p[2]
785 if len(p) == 5:
786 dv = p[3]
787 quals = dict([(x.name, x) for x in quals])
788 p[0] = CIMProperty(pname, dv, type='reference',
789 reference_class=cname, qualifiers=quals)
790
792 """methodDeclaration :
793 dataType methodName '(' ')' ';'
794 | dataType methodName '(' parameterList ')' ';'
795 | qualifierList dataType methodName '(' ')' ';'
796 | qualifierList dataType methodName '(' parameterList ')' ';'
797 """
798 paramlist = []
799 quals = []
800 if isinstance(p[1], basestring):
801 dt = p[1]
802 mname = p[2]
803 if p[4] != ')':
804 paramlist = p[4]
805 else:
806 quals = p[1]
807 dt = p[2]
808 mname = p[3]
809 if p[5] != ')':
810 paramlist = p[5]
811 params = dict([(param.name, param) for param in paramlist])
812 quals = dict([(q.name, q) for q in quals])
813 p[0] = CIMMethod(mname, return_type=dt, parameters=params,
814 qualifiers=quals)
815
819 """propertyName : identifier"""
820 p[0] = p[1]
821
823 """referenceName : identifier"""
824 p[0] = p[1]
825
827 """methodName : identifier"""
828 p[0] = p[1]
829
831 """dataType : DT_UINT8
832 | DT_SINT8
833 | DT_UINT16
834 | DT_SINT16
835 | DT_UINT32
836 | DT_SINT32
837 | DT_UINT64
838 | DT_SINT64
839 | DT_REAL32
840 | DT_REAL64
841 | DT_CHAR16
842 | DT_STR
843 | DT_BOOL
844 | DT_DATETIME
845 """
846 p[0] = p[1].lower()
847
849 """objectRef : className REF"""
850 p[0] = p[1]
851
853 """parameterList : parameter
854 | parameterList ',' parameter
855 """
856 if len(p) == 2:
857 p[0] = [p[1]]
858 else:
859 p[0] = p[1] + [p[3]]
860
862 """parameter : parameter_1
863 | parameter_2
864 | parameter_3
865 | parameter_4
866 """
867 p[0] = p[1]
868
870 """parameter_1 : dataType parameterName
871 | dataType parameterName array
872 """
873 args = {}
874 if len(p) == 4:
875 args['is_array'] = True
876 args['array_size'] = p[3]
877 p[0] = CIMParameter(p[2], p[1], **args)
878
880 """parameter_2 : qualifierList dataType parameterName
881 | qualifierList dataType parameterName array
882 """
883 args = {}
884 if len(p) == 5:
885 args['is_array'] = True
886 args['array_size'] = p[4]
887 quals = dict([(x.name, x) for x in p[1]])
888 p[0] = CIMParameter(p[3], p[2], qualifiers=quals, **args)
889
891 """parameter_3 : objectRef parameterName
892 | objectRef parameterName array
893 """
894 args = {}
895 if len(p) == 4:
896 args['is_array'] = True
897 args['array_size'] = p[3]
898 p[0] = CIMParameter(p[2], 'reference', reference_class=p[1],
899 **args)
900
902 """parameter_4 : qualifierList objectRef parameterName
903 | qualifierList objectRef parameterName array
904 """
905 args = {}
906 if len(p) == 5:
907 args['is_array'] = True
908 args['array_size'] = p[4]
909 quals = dict([(x.name, x) for x in p[1]])
910 p[0] = CIMParameter(p[3], 'reference', qualifiers=quals,
911 reference_class=p[2], **args)
912
914 """parameterName : identifier"""
915 p[0] = p[1]
916
918 """array : '[' ']'
919 | '[' integerValue ']'
920 """
921 if len(p) == 3:
922 p[0] = None
923 else:
924 p[0] = p[2]
925
927 """defaultValue : '=' initializer"""
928 p[0] = p[2]
929
931 """initializer : constantValue
932 | arrayInitializer
933 | referenceInitializer
934 """
935 p[0] = p[1]
936
938 """arrayInitializer : '{' constantValueList '}'
939 | '{' '}'
940 """
941 if len(p) == 3:
942 p[0] = []
943 else:
944 p[0] = p[2]
945
947 """constantValueList : constantValue
948 | constantValueList ',' constantValue
949 """
950 if len(p) == 2:
951 p[0] = [p[1]]
952 else:
953 p[0] = p[1] + [p[3]]
954
956 s = s[1:-1]
957 rv = ''
958 esc = False
959 i = -1
960 while i < len(s) -1:
961 i += 1
962 ch = s[i]
963 if ch == '\\' and not esc:
964 esc = True
965 continue
966 if not esc:
967 rv += ch
968 continue
969
970 if ch == '"': rv += '"'
971 elif ch == 'n': rv += '\n'
972 elif ch == 't': rv += '\t'
973 elif ch == 'b': rv += '\b'
974 elif ch == 'f': rv += '\f'
975 elif ch == 'r': rv += '\r'
976 elif ch == '\\': rv += '\\'
977 elif ch in ['x', 'X']:
978 hexc = 0
979 j = 0
980 i += 1
981 while j < 4:
982 c = s[i+j];
983 c = c.upper()
984 if not c.isdigit() and not c in 'ABCDEF':
985 break;
986 hexc <<= 4
987 if c.isdigit():
988 hexc |= ord(c) - ord('0')
989 else:
990 hexc |= ord(c) - ord('A') + 0XA
991 j += 1
992 rv += chr(hexc)
993 i += j-1
994
995 esc = False
996
997 return rv
998
1002 """stringValueList : stringValue
1003 | stringValueList stringValue
1004 """
1005 if len(p) == 2:
1006 p[0] = _fixStringValue(p[1])
1007 else:
1008 p[0] = p[1] + _fixStringValue(p[2])
1009
1012 """constantValue : integerValue
1013 | floatValue
1014 | charValue
1015 | stringValueList
1016 | booleanValue
1017 | nullValue
1018 """
1019 p[0] = p[1]
1020
1022 """integerValue : binaryValue
1023 | octalValue
1024 | decimalValue
1025 | hexValue
1026 """
1027 p[0] = int(p[1])
1028
1031 """referenceInitializer : objectHandle
1032 | aliasIdentifier
1033 """
1034 if p[1][0] == '$':
1035 try:
1036 p[0] = p.parser.aliases[p[1]]
1037 except KeyError:
1038 ce = CIMError(CIM_ERR_FAILED,
1039 'Unknown alias: ' + p[0])
1040 ce.file_line = (p.parser.file, p.lexer.lineno)
1041 raise ce
1042 else:
1043 p[0] = p[1]
1044
1046 """objectHandle : identifier"""
1047 p[0] = p[1]
1048
1050 """qualifierDeclaration :
1051 QUALIFIER qualifierName qualifierType scope ';'
1052 | QUALIFIER qualifierName qualifierType scope defaultFlavor ';'
1053 """
1054 qualtype = p[3]
1055 dt, is_array, array_size, value = qualtype
1056 qualname = p[2]
1057 scopes = p[4]
1058 if len(p) == 5:
1059 flist = []
1060 else:
1061 flist = p[5]
1062 flavors = _build_flavors(flist)
1063
1064 p[0] = CIMQualifierDeclaration(
1065 qualname, dt, value=value, is_array=is_array, array_size=array_size,
1066 scopes=scopes, **flavors)
1067
1069 flavors = {}
1070 if qualdecl is not None:
1071 flavors = {'overridable':qualdecl.overridable,
1072 'translatable':qualdecl.translatable,
1073 'toinstance':qualdecl.toinstance,
1074 'tosubclass':qualdecl.tosubclass}
1075 if 'disableoverride' in flist:
1076 flavors['overridable'] = False
1077 if 'enableoverride' in flist:
1078 flavors['overridable'] = True
1079 if 'translatable' in flist:
1080 flavors['translatable'] = True
1081 if 'restricted' in flist:
1082 flavors['tosubclass'] = False
1083 if 'tosubclass' in flist:
1084 flavors['tosubclass'] = True
1085 try:
1086 if flavors['tosubclass']:
1087 flavors['toinstance'] = True
1088 except KeyError:
1089 pass
1090 return flavors
1091
1093 """qualifierName : identifier
1094 | ASSOCIATION
1095 | INDICATION
1096 """
1097 p[0] = p[1]
1098
1100 """qualifierType : qualifierType_1
1101 | qualifierType_2
1102 """
1103 p[0] = p[1]
1104
1106 """qualifierType_1 : ':' dataType array
1107 | ':' dataType array defaultValue
1108 """
1109 dv = None
1110 if len(p) == 5:
1111 dv = p[4]
1112 p[0] = (p[2], True, p[3], dv)
1113
1115 """qualifierType_2 : ':' dataType
1116 | ':' dataType defaultValue
1117 """
1118 dv = None
1119 if len(p) == 4:
1120 dv = p[3]
1121 p[0] = (p[2], False, None, dv)
1122
1124 """scope : ',' SCOPE '(' metaElementList ')'"""
1125 slist = p[4]
1126 scopes = {}
1127 for i in ('CLASS',
1128 'ASSOCIATION',
1129 'INDICATION',
1130 'PROPERTY',
1131 'REFERENCE',
1132 'METHOD',
1133 'PARAMETER',
1134 'ANY'):
1135 scopes[i] = i in slist
1136 p[0] = scopes
1137
1146
1160
1162 """defaultFlavor : ',' FLAVOR '(' flavorListWithComma ')'"""
1163 flist = p[4]
1164 flavors = {'ENABLEOVERRIDE':True,
1165 'TOSUBCLASS':True,
1166 'DISABLEOVERRIDE':False,
1167 'RESTRICTED':False,
1168 'TRANSLATABLE':False}
1169 for i in flist:
1170 flavors[i] = True
1171 p[0] = flavors
1172
1175 """flavorListWithComma : flavor
1176 | flavorListWithComma ',' flavor
1177 """
1178 if len(p) == 2:
1179 p[0] = [p[1]]
1180 else:
1181 p[0] = p[1] + [p[3]]
1182
1184 """instanceDeclaration :
1185 INSTANCE OF className '{' valueInitializerList '}' ';'
1186 | INSTANCE OF className alias '{' valueInitializerList '}' ';'
1187 | qualifierList INSTANCE OF className '{' valueInitializerList '}' ';'
1188 | qualifierList INSTANCE OF className alias '{'
1189 valueInitializerList '}' ';'
1190 """
1191 alias = None
1192 quals = {}
1193 ns = p.parser.handle.default_namespace
1194 if isinstance(p[1], basestring):
1195 cname = p[3]
1196 if p[4] == '{':
1197 props = p[5]
1198 else:
1199 props = p[6]
1200 alias = p[4]
1201 else:
1202 cname = p[4]
1203
1204 if p[5] == '{':
1205 props = p[6]
1206 else:
1207 props = p[7]
1208 alias = p[5]
1209
1210 try:
1211 cc = p.parser.handle.GetClass(cname, LocalOnly=False,
1212 IncludeQualifiers=True)
1213 p.parser.classnames[ns].append(cc.classname.lower())
1214 except CIMError, ce:
1215 ce.file_line = (p.parser.file, p.lexer.lineno)
1216 if ce.args[0] == CIM_ERR_NOT_FOUND:
1217 file_ = p.parser.mofcomp.find_mof(cname)
1218 if p.parser.verbose:
1219 p.parser.log('Class %s does not exist' % cname)
1220 if file_:
1221 p.parser.mofcomp.compile_file(file_, ns)
1222 cc = p.parser.handle.GetClass(cname, LocalOnly=False,
1223 IncludeQualifiers=True)
1224 else:
1225 if p.parser.verbose:
1226 p.parser.log("Can't find file to satisfy class")
1227 ce = CIMError(CIM_ERR_INVALID_CLASS, cname)
1228 ce.file_line = (p.parser.file, p.lexer.lineno)
1229 raise ce
1230 else:
1231 raise
1232 path = CIMInstanceName(cname, namespace=ns)
1233 inst = CIMInstance(cname, properties=cc.properties,
1234 qualifiers=quals, path=path)
1235 for prop in props:
1236 pname = prop[1]
1237 pval = prop[2]
1238 try:
1239 cprop = inst.properties[pname]
1240 cprop.value = cim_obj.tocimobj(cprop.type, pval)
1241 except KeyError:
1242 ce = CIMError(CIM_ERR_INVALID_PARAMETER,
1243 'Invalid property: %s' % pname)
1244 ce.file_line = (p.parser.file, p.lexer.lineno)
1245 raise ce
1246 except ValueError, ve:
1247 ce = CIMError(CIM_ERR_INVALID_PARAMETER,
1248 'Invalid value for property: %s: %s' % \
1249 (pname, ve.message))
1250 ce.file_line = (p.parser.file, p.lexer.lineno)
1251 raise ce
1252
1253 for prop in inst.properties.values():
1254 if 'key' not in prop.qualifiers or not prop.qualifiers['key']:
1255 continue
1256 if prop.value is None:
1257 ce = CIMError(CIM_ERR_FAILED,
1258 'Key property %s.%s is not set' % (cname, prop.name))
1259 ce.file_line = (p.parser.file, p.lexer.lineno)
1260 raise ce
1261 inst.path.keybindings[prop.name] = prop.value
1262
1263 if alias:
1264 p.parser.aliases[alias] = inst.path
1265 p[0] = inst
1266
1268 """valueInitializerList : valueInitializer
1269 | valueInitializerList valueInitializer
1270 """
1271 if len(p) == 2:
1272 p[0] = [p[1]]
1273 else:
1274 p[0] = p[1] + [p[2]]
1275
1278 """valueInitializer : identifier defaultValue ';'
1279 | qualifierList identifier defaultValue ';'
1280 """
1281 if len(p) == 4:
1282 id_ = p[1]
1283 val = p[2]
1284 quals = []
1285 else:
1286 quals = p[1]
1287 id_ = p[2]
1288 val = p[3]
1289 p[0] = (quals, id_, val)
1290
1292 """booleanValue : FALSE
1293 | TRUE
1294 """
1295 p[0] = p[1].lower() == 'true'
1296
1298 """nullValue : NULL"""
1299 p[0] = None
1300
1302 """identifier : IDENTIFIER
1303 | ANY
1304 | AS
1305 | CLASS
1306 | DISABLEOVERRIDE
1307 | dataType
1308 | ENABLEOVERRIDE
1309 | FLAVOR
1310 | INSTANCE
1311 | METHOD
1312 | OF
1313 | PARAMETER
1314 | PRAGMA
1315 | PROPERTY
1316 | QUALIFIER
1317 | REFERENCE
1318 | RESTRICTED
1319 | SCHEMA
1320 | SCOPE
1321 | TOSUBCLASS
1322 | TRANSLATABLE
1323 """
1324
1325
1326 p[0] = p[1]
1327
1331
1333 i = token.lexpos
1334 while i > 0:
1335 if input[i] == '\n':
1336 break
1337 i -= 1
1338 column = (token.lexpos - i)+1
1339 return column
1340
1341 -def _get_error_context(input, token):
1342 try:
1343 line = input[token.lexpos : input.index('\n', token.lexpos)]
1344 except ValueError:
1345 line = input[token.lexpos:]
1346 i = input.rfind('\n', 0, token.lexpos)
1347 if i < 0:
1348 i = 0
1349 line = input[i:token.lexpos] + line
1350 lines = [line.strip('\r\n')]
1351 col = token.lexpos - i
1352 while len(lines) < 5 and i > 0:
1353 end = i
1354 i = input.rfind('\n', 0, i)
1355 if i < 0:
1356 i = 0
1357 lines.insert(0, input[i:end].strip('\r\n'))
1358 pointer = ''
1359 for ch in token.value:
1360 pointer += '^'
1361 pointline = ''
1362 i = 0
1363 while i < col -1:
1364 if lines[-1][i].isspace():
1365 pointline += lines[-1][i]
1366
1367 else:
1368 pointline += ' '
1369 i += 1
1370 lines.append(pointline + pointer)
1371 return lines
1372
1375
1379 self.conn = conn
1380 self.class_names = {}
1381 self.qualifiers = {}
1382 self.instances = {}
1383 self.classes = {}
1384 if conn is None:
1385 self.__default_namespace = 'root/cimv2'
1386
1387 - def setns(self, value):
1388 if self.conn is not None:
1389 self.conn.default_namespace = value
1390 else:
1391 self.__default_namespace = value
1392
1394 if self.conn is not None:
1395 return self.conn.default_namespace
1396 else:
1397 return self.__default_namespace
1398
1399 default_namespace = property(getns, setns, None,
1400 "default_namespace property")
1401
1403 cname = len(args) > 0 and args[0] or kwargs['ClassName']
1404 try:
1405 cc = self.classes[self.default_namespace][cname]
1406 except KeyError:
1407 if self.conn is None:
1408 ce = CIMError(CIM_ERR_NOT_FOUND, cname)
1409 raise ce
1410 cc = self.conn.GetClass(*args, **kwargs)
1411 try:
1412 self.classes[self.default_namespace][cc.classname] = cc
1413 except KeyError:
1414 self.classes[self.default_namespace] = \
1415 NocaseDict({cc.classname:cc})
1416 if 'LocalOnly' in kwargs and not kwargs['LocalOnly']:
1417 if cc.superclass:
1418 try:
1419 del kwargs['ClassName']
1420 except KeyError:
1421 pass
1422 if len(args) > 0:
1423 args = args[1:]
1424 super_ = self.GetClass(cc.superclass, *args, **kwargs)
1425 for prop in super_.properties.values():
1426 if prop.name not in cc.properties:
1427 cc.properties[prop.name] = prop
1428 for meth in super_.methods.values():
1429 if meth.name not in cc.methods:
1430 cc.methods[meth.name] = meth
1431 return cc
1432
1434 cc = len(args) > 0 and args[0] or kwargs['NewClass']
1435 if cc.superclass:
1436 try:
1437 super_ = self.GetClass(cc.superclass, LocalOnly=True,
1438 IncludeQualifiers=False)
1439 except CIMError, ce:
1440 if ce.args[0] == CIM_ERR_NOT_FOUND:
1441 ce.args = (CIM_ERR_INVALID_SUPERCLASS, cc.superclass)
1442 raise
1443 else:
1444 raise
1445
1446 try:
1447 self.classes[self.default_namespace][cc.classname] = cc
1448 except KeyError:
1449 self.classes[self.default_namespace] = \
1450 NocaseDict({cc.classname:cc})
1451
1452
1453
1454
1455 try:
1456 self.class_names[self.default_namespace].append(cc.classname)
1457 except KeyError:
1458 self.class_names[self.default_namespace] = [cc.classname]
1459
1463
1467
1469 qualname = len(args) > 0 and args[0] or kwargs['QualifierName']
1470 try:
1471 qual = self.qualifiers[self.default_namespace][qualname]
1472 except KeyError:
1473 if self.conn is None:
1474 raise CIMError(CIM_ERR_NOT_FOUND, qualname)
1475 qual = self.conn.GetQualifier(*args, **kwargs)
1476 return qual
1477
1479 qual = len(args) > 0 and args[0] or kwargs['QualifierDeclaration']
1480 try:
1481 self.qualifiers[self.default_namespace][qual.name] = qual
1482 except KeyError:
1483 self.qualifiers[self.default_namespace] = \
1484 NocaseDict({qual.name:qual})
1485
1487 if self.conn is not None:
1488 rv = self.conn.EnumerateQualifiers(*args, **kwargs)
1489 else:
1490 rv = []
1491 try:
1492 rv += self.qualifiers[self.default_namespace].values()
1493 except KeyError:
1494 pass
1495 return rv
1496
1497
1499 inst = len(args) > 0 and args[0] or kwargs['NewInstance']
1500 try:
1501 self.instances[self.default_namespace].append(inst)
1502 except KeyError:
1503 self.instances[self.default_namespace] = [inst]
1504 return inst.path
1505
1507 for ns, insts in self.instances.items():
1508 insts.reverse()
1509 for inst in insts:
1510 try:
1511 if verbose:
1512 print 'Deleting instance', inst.path
1513 self.conn.DeleteInstance(inst.path)
1514 except CIMError, ce:
1515 print 'Error deleting instance', inst.path
1516 print ' ', '%s %s' % (ce.args[0], ce.args[1])
1517 for ns, cnames in self.class_names.items():
1518 self.default_namespace = ns
1519 cnames.reverse()
1520 for cname in cnames:
1521 try:
1522 if verbose:
1523 print 'Deleting class %s:%s' % (ns, cname)
1524 self.conn.DeleteClass(cname)
1525 except CIMError, ce:
1526 print 'Error deleting class %s:%s' % (ns, cname)
1527 print ' ', '%s %s' % (ce.args[0], ce.args[1])
1528
1532 d = {
1533 CIM_ERR_FAILED : 'A general error occurred',
1534 CIM_ERR_ACCESS_DENIED : 'Resource not available',
1535 CIM_ERR_INVALID_NAMESPACE : 'The target namespace does not exist',
1536 CIM_ERR_INVALID_PARAMETER : 'Parameter value(s) invalid',
1537 CIM_ERR_INVALID_CLASS : 'The specified Class does not exist',
1538 CIM_ERR_NOT_FOUND : 'Requested object could not be found',
1539 CIM_ERR_NOT_SUPPORTED : 'Operation not supported',
1540 CIM_ERR_CLASS_HAS_CHILDREN : 'Class has subclasses',
1541 CIM_ERR_CLASS_HAS_INSTANCES : 'Class has instances',
1542 CIM_ERR_INVALID_SUPERCLASS : 'Superclass does not exist',
1543 CIM_ERR_ALREADY_EXISTS : 'Object already exists',
1544 CIM_ERR_NO_SUCH_PROPERTY : 'Property does not exist',
1545 CIM_ERR_TYPE_MISMATCH : 'Value incompatible with type',
1546 CIM_ERR_QUERY_LANGUAGE_NOT_SUPPORTED : 'Query language not supported',
1547 CIM_ERR_INVALID_QUERY : 'Query not valid',
1548 CIM_ERR_METHOD_NOT_AVAILABLE : 'Extrinsic method not executed',
1549 CIM_ERR_METHOD_NOT_FOUND : 'Extrinsic method does not exist',
1550 }
1551 try:
1552 s = d[code]
1553 except KeyError:
1554 s = 'Unknown Error'
1555 return s
1556
1558 - def __init__(self, handle, search_paths=[], verbose=False,
1559 log_func=_print_logger):
1560 """Initialize the compiler.
1561
1562 Keyword arguments:
1563 handle -- A WBEMConnection or similar object. The following
1564 attributes and methods need to be present, corresponding to the
1565 the attributes and methods on pywbem.WBEMConnection having
1566 the same names:
1567 - default_namespace
1568 - EnumerateInstanceNames()
1569 - CreateClass()
1570 - GetClass()
1571 - ModifyClass()
1572 - DeleteInstance()
1573 - CreateInstance()
1574 - ModifyInstance()
1575 - DeleteQualifier()
1576 - EnumerateQualifiers()
1577 - SetQualifier()
1578 search_paths -- A list of file system paths specifying where
1579 missing schema elements should be looked for.
1580 verbose -- True if extra messages should be printed.
1581 log_func -- A callable that takes a single string argument.
1582 The default logger prints to stdout.
1583 """
1584
1585 self.parser = yacc.yacc(tabmodule=_tabmodule, optimize=_optimize)
1586 self.parser.search_paths = search_paths
1587 self.handle = handle
1588 self.parser.handle = handle
1589 self.lexer = lex.lex(lextab=_lextab, optimize=_optimize)
1590 self.lexer.parser = self.parser
1591 self.parser.qualcache = {handle.default_namespace: NocaseDict()}
1592 self.parser.classnames = {handle.default_namespace: []}
1593 self.parser.mofcomp = self
1594 self.parser.verbose = verbose
1595 self.parser.log = log_func
1596 self.parser.aliases = {}
1597
1599 """Compile a string of MOF.
1600
1601 Arguments:
1602 mof -- The string of MOF
1603 ns -- The CIM namespace
1604
1605 Keyword arguments:
1606 filename -- The name of the file that the MOF was read from. This
1607 is used in status and error messages.
1608 """
1609
1610 lexer = self.lexer.clone()
1611 lexer.parser = self.parser
1612 try:
1613 oldfile = self.parser.file
1614 except AttributeError:
1615 oldfile = None
1616 self.parser.file = filename
1617 try:
1618 oldmof = self.parser.mof
1619 except AttributeError:
1620 oldmof = None
1621 self.parser.mof = mof
1622 self.parser.handle.default_namespace = ns
1623 if ns not in self.parser.qualcache:
1624 self.parser.qualcache[ns] = NocaseDict()
1625 if ns not in self.parser.classnames:
1626 self.parser.classnames[ns] = []
1627 try:
1628 rv = self.parser.parse(mof, lexer=lexer)
1629 self.parser.file = oldfile
1630 self.parser.mof = oldmof
1631 return rv
1632 except MOFParseError, pe:
1633 self.parser.log('Syntax error:')
1634 if hasattr(pe, 'file') and hasattr(pe, 'lineno'):
1635 self.parser.log('%s:%s:' % (pe.file, pe.lineno))
1636 if hasattr(pe, 'context'):
1637 self.parser.log('\n'.join(pe.context))
1638 if str(pe):
1639 self.parser.log(str(pe))
1640 raise
1641 except CIMError, ce:
1642 if hasattr(ce, 'file_line'):
1643 self.parser.log('Fatal Error: %s:%s' % (ce.file_line[0],
1644 ce.file_line[1]))
1645 else:
1646 self.parser.log('Fatal Error:')
1647 self.parser.log('%s%s' % (_errcode2string(ce.args[0]),
1648 ce.args[1] and ': '+ce.args[1] or ''))
1649 raise
1650
1652 """Compile MOF from a file.
1653
1654 Arguments:
1655 filename -- The file to read MOF from
1656 ns -- The CIM namespace
1657 """
1658
1659 if self.parser.verbose:
1660 self.parser.log('Compiling file ' + filename)
1661 f = open(filename, 'r')
1662 mof = f.read()
1663 f.close()
1664
1665 return self.compile_string(mof, ns, filename=filename)
1666
1668 """Find a MOF file corresponding to a CIM class name. The search_paths
1669 provided to __init__() are searched recursively.
1670
1671 Arguments:
1672 classname -- The name of the class to look for
1673 """
1674
1675 classname = classname.lower()
1676 for search in self.parser.search_paths:
1677 for root, dirs, files in os.walk(search):
1678 for file_ in files:
1679 if file_.endswith('.mof') and \
1680 file_[:-4].lower() == classname:
1681 return root + '/' + file_
1682 return None
1683
1685 self.handle.rollback(verbose=verbose)
1686
1690
1691
1692 if __name__ == '__main__':
1693 from optparse import OptionParser
1694 usage = 'usage: %prog -n <namespace> [options] <MOF file> ...'
1695 oparser = OptionParser(usage=usage)
1696 oparser.add_option('-s', '--search', dest='search',
1697 help='Search path to find missing schema elements. ' \
1698 'This option can be present multiple times.',
1699 metavar='Path', action='append')
1700 oparser.add_option('-n', '--namespace', dest='ns',
1701 help='Specify the namespace', metavar='Namespace')
1702 oparser.add_option('-u', '--url', dest='url',
1703 help='URL to the CIM Server', metavar='URL',
1704 default='/var/run/tog-pegasus/cimxml.socket')
1705 oparser.add_option('-v', '--verbose',
1706 action='store_true', dest='verbose', default=False,
1707 help='Print more messages to stdout')
1708 oparser.add_option('-r', '--remove',
1709 action='store_true', dest='remove', default=False,
1710 help='Remove elements found in MOF, instead of ' \
1711 'create them')
1712 oparser.add_option('-l', '--username',
1713 dest='username', metavar='Username',
1714 help='Specify the username')
1715 oparser.add_option('-p', '--password',
1716 dest='password', metavar='Password',
1717 help='Specify the password')
1718 oparser.add_option('-d', '--dry-run',
1719 dest='dry_run', default=False, action='store_true',
1720 help="Don't actually modify the repository, just " \
1721 "check mof file syntax. Connection to CIMOM is " \
1722 "still required to check qualifiers.")
1723
1724 (options, args) = oparser.parse_args()
1725 search = options.search
1726 if not args:
1727 oparser.error('No input files given for parsing')
1728 if options.ns is None:
1729 oparser.error('No namespace given')
1730
1731 passwd = options.password
1732 if options.username and not passwd:
1733 passwd = getpass('Enter password for %s: ' % options.username)
1734 if options.username:
1735 conn = WBEMConnection(options.url, (options.username, passwd))
1736 else:
1737 conn = WBEMConnection(options.url)
1738 if options.remove or options.dry_run:
1739 conn = MOFWBEMConnection(conn=conn)
1740
1741 conn.default_namespace = options.ns
1742 if search is None:
1743 search = []
1744
1745 search = [os.path.abspath(x) for x in search]
1746 for fname in args:
1747 path = os.path.abspath(os.path.dirname(fname))
1748 for spath in search:
1749 if path.startswith(spath):
1750 break
1751 else:
1752 search.append(path)
1753
1754
1755
1756 verbose = options.verbose and not options.remove
1757
1758 mofcomp = MOFCompiler(handle=conn, search_paths=search,
1759 verbose=verbose)
1760
1761 try:
1762 for fname in args:
1763 if fname[0] != '/':
1764 fname = os.path.curdir + '/' + fname
1765 mofcomp.compile_file(fname, options.ns)
1766 except MOFParseError, pe:
1767 sys.exit(1)
1768 except CIMError, ce:
1769 sys.exit(1)
1770
1771 if options.remove and not options.dry_run:
1772 conn.rollback(verbose=options.verbose)
1773