1 krisbash 1.1 #include "/usr/include/python2.6/Python.h"
2 #include "MI.h"
3 #include <string.h>
4 #include "structmember.h"
5 #include "PMI_Session.c"
6
7 /*Define a static MI Exception type*/
8 static PyObject *MIError;
9
10 PyObject* CleanupApplication(MI_DestinationOptions miDestinationOptions,
11 MI_Application miApplication, MI_Result miResult) {
12 if (miDestinationOptions.ft) {
13 MI_DestinationOptions_Delete(&miDestinationOptions);
14 }
15
16 MI_Application_Close(&miApplication);
17 char str[80];
18 strcpy(str,"MI_Application_NewSession failed, error = ");
19 strcat(str,MI_Result_To_String(miResult));
20 PyErr_SetString(MIError,str);
21 return NULL;
22 krisbash 1.1 }
23
24 PyObject* CleanupSession(MI_DestinationOptions miDestinationOptions,
25 MI_Application miApplication, MI_Result miResult, MI_Session miSession) {
26 MI_Session_Close(&miSession, NULL, NULL);
27 return CleanupApplication(miDestinationOptions, miApplication, miResult);
28 }
29
30 static PyObject* Connect(PyObject* self, PyObject* args){
31 //initiazlie the python module first
32 Py_Initialize();
33 initPMI_Session();
34 initPMI_Instance();
35 initPMI_Class();
36 PMI_Session* session = (PMI_Session*) InitSession();
37 MI_Application miApplication = MI_APPLICATION_NULL;
38 MI_Session miSession = MI_SESSION_NULL;
39 MI_Result miResult;
40 MI_DestinationOptions miDestinationOptions = MI_DESTINATIONOPTIONS_NULL;
41 MI_UserCredentials miUserCreds = {0};
42
43 krisbash 1.1 char* domain, *username, *password;
44 if(!PyArg_ParseTuple(args,"sss",&domain,&username,&password))
45 {
46 PyErr_SetString(MIError,"Connection failed: please input the correct domian, username and password");
47 return NULL;
48 }
49
50 miUserCreds.authenticationType = MI_AUTH_TYPE_BASIC;
51 miUserCreds.credentials.usernamePassword.domain = MI_T(domain);
52 miUserCreds.credentials.usernamePassword.username = username;
53 miUserCreds.credentials.usernamePassword.password = password;
54
55 miResult = MI_Application_Initialize(0, NULL, NULL, &miApplication);
56 if (miResult != MI_RESULT_OK)
57 {
58 PyErr_SetString(MIError,"MI_Application_Initialize failed");
59 return NULL;
60 }
61
62 miResult = MI_Application_NewDestinationOptions(&miApplication, &miDestinationOptions);
63 if (miResult != MI_RESULT_OK)
64 krisbash 1.1 {
65 return CleanupApplication(miDestinationOptions, miApplication, miResult);
66 }
67
68 miResult = MI_DestinationOptions_AddDestinationCredentials(&miDestinationOptions, &miUserCreds);
69 if (miResult != MI_RESULT_OK)
70 {
71 return CleanupApplication(miDestinationOptions, miApplication, miResult);
72 }
73
74 miResult = MI_Application_NewSession(&miApplication, NULL, NULL, &miDestinationOptions, NULL, NULL, &miSession);
75 if (miResult != MI_RESULT_OK)
76 {
77 return CleanupApplication(miDestinationOptions, miApplication, miResult);
78 }
79 /*Make sure the connection is successful */
80 miResult = TestConnection(&miSession);
81 if(miResult != MI_RESULT_OK)
82 {
83 PyErr_SetString(MIError,"Connection failed.Check the server status and credentials");
84 return NULL;
85 krisbash 1.1 }
86
87 session->miSession = miSession;
88 Py_INCREF(session);
89 return (PyObject *)session;
90 }
91
92
93 static PyObject *CreateLocalInstance(PyObject *self, PyObject *args, PyObject *kwds)
94 {
95 char *className;
96 PyObject *propertyDict;
97 PyObject *propertyTypes = NULL;
98 PyObject *propertyFlags = NULL;
99 static char *kwlist[] = {"className","propertyValues","propertyTypes","propertyFlags",NULL};
100 if(!PyArg_ParseTupleAndKeywords(args,kwds,"sO!|OO",kwlist,&className,&PyDict_Type, &propertyDict,&propertyTypes,&propertyFlags))
101 {
102 PyErr_SetString(MIError,"Please input correct classname and property dictionaries");
103 return NULL;
104 }
105
106 krisbash 1.1 MI_Result miResult;
107 MI_Application miApplication = MI_APPLICATION_NULL;
108 MI_Instance *miInstance = NULL;
109
110 miResult = MI_Application_Initialize(0, NULL, NULL, &miApplication);
111 if (miResult != MI_RESULT_OK)
112 {
113 PyErr_SetString(MIError,"MI_Application Initialize failed");
114 return NULL;
115 }
116
117 miResult = MI_Application_NewInstance(&miApplication,className,NULL,&miInstance);
118 if(miResult != MI_RESULT_OK)
119 {
120 char error[200];
121 strcpy(error,"Failed to create an instance of class ");
122 strcat(error,className);
123 strcat(error,", error = ");
124 strcat(error,MI_Result_To_String(miResult));
125 PyErr_SetString(MIError,error);
126 return NULL;
127 krisbash 1.1 }
128
129 //Iterate the dictionary and add property values to the instance
130 PyObject *key, *value;
131 Py_ssize_t pos = 0;
132 while (PyDict_Next(propertyDict, &pos, &key, &value))
133 {
134 MI_Value miValue;
135 MI_Type miType;
136 MI_Uint32 miFlag;
137 char *propertyName;
138 PyObject *propertyValue;
139
140 if(!PyArg_Parse(key,"s",&propertyName))
141 {
142 PyErr_SetString(MIError,"Property name is not correct");
143 return NULL;
144 }
145 if(!PyArg_Parse(value,"O",&propertyValue))
146 {
147 PyErr_SetString(MIError,"Property value is not correct");
148 krisbash 1.1 return NULL;
149 }
150 /*If the user doesn't specify property type, set the default type to be string */
151 if(propertyTypes != NULL)
152 {
153 PyObject *typeValue = PyDict_GetItemString(propertyTypes,propertyName);
154 if(typeValue != NULL)
155 {
156 miType = PyInt_AsLong(typeValue);
157 SetPropertyValues(miType,propertyValue,&miValue);
158 }
159 else
160 {
161 /*Need to check if it's datetime object otherwise server always expects interval for datetime object*/
162 if (PyDateTime_Check(propertyValue) || PyDelta_Check(propertyValue))
163 {
164 miType = MI_DATETIME;
165 SetPropertyValues(miType,propertyValue,&miValue);
166 }
167 else
168 {
169 krisbash 1.1 miValue.string = PyString_AsString(propertyValue);
170 miType = MI_STRING;
171 }
172 }
173 }
174 if(propertyFlags != NULL)
175 {
176 PyObject *flagValue = PyDict_GetItemString(propertyFlags,propertyName);
177 if(flagValue != NULL)
178 {
179 long value = PyInt_AsLong(flagValue);
180 miFlag = (MI_Uint32)value;
181 }
182 }
183 miResult = MI_Instance_AddElement(miInstance,propertyName,&miValue,miType,miFlag);
184
185 if(miResult != MI_RESULT_OK)
186 {
187 char error[200];
188 strcpy(error,"MI_Instance_AddElement failed, error =");
189 strcat(error,MI_Result_To_String(miResult));
190 krisbash 1.1 PyErr_SetString(MIError,error);
191 return NULL;
192 }
193 }
194
195 PMI_Instance* pmiInstance = (PMI_Instance*) initPMI();
196 pmiInstance->miInstance = miInstance;
197 pmiInstance->propertyValues = propertyDict;
198 pmiInstance->propertyTypes = propertyTypes;
199 pmiInstance->propertyFlags = propertyFlags;
200 return (PyObject *)pmiInstance;
201 }
202
203 void DatetimeToStr(const MI_Datetime* x, _Out_writes_z_(26) MI_Char buf[26])
204 {
205 if (x->isTimestamp)
206 {
207 const MI_Char FMT[] = "%04d%02d%02d%02d%02d%02d.%06d%c%03d";
208 MI_Sint32 utc = x->u.timestamp.utc;
209
210 sprintf(buf,FMT,
211 krisbash 1.1 x->u.timestamp.year,
212 x->u.timestamp.month,
213 x->u.timestamp.day,
214 x->u.timestamp.hour,
215 x->u.timestamp.minute,
216 x->u.timestamp.second,
217 x->u.timestamp.microseconds,
218 utc < 0 ? '-' : '+',
219 utc < 0 ? -utc : utc);
220 }
221 else
222 {
223 const MI_Char FMT[] = "%08u%02u%02u%02u.%06u:000";
224 sprintf(buf,FMT,
225 x->u.interval.days,
226 x->u.interval.hours,
227 x->u.interval.minutes,
228 x->u.interval.seconds,
229 x->u.interval.microseconds);
230 }
231 }
232 krisbash 1.1
233 static char* MI_Type_To_String(MI_Type miType)
234 {
235 switch (miType)
236 {
237 case MI_BOOLEAN:
238 {
239 return "MI_BOOLEAN";
240 }
241 case MI_UINT8:
242 {
243 return "MI_UINT8";
244 }
245 case MI_SINT8:
246 {
247 return "MI_SINT8";
248 }
249 case MI_UINT16:
250 {
251 return "MI_UINT16";
252 }
253 krisbash 1.1 case MI_SINT16:
254 {
255 return "MI_SINT16";
256 }
257 case MI_UINT32:
258 {
259 return "MI_UINT32";
260 }
261 case MI_SINT32:
262 {
263 return "MI_SINT32";
264 }
265 case MI_UINT64:
266 {
267 return "MI_UINT64";
268 }
269 case MI_SINT64:
270 {
271 return "MI_SINT64";
272 }
273 case MI_REAL32:
274 krisbash 1.1 {
275 return "MI_REAL32";
276 }
277 case MI_REAL64:
278 {
279 return "MI_REAL64";
280 }
281 case MI_CHAR16:
282 {
283 return "MI_CHAR16";
284 }
285 case MI_DATETIME:
286 {
287 return "MI_DATETIME";
288 }
289 case MI_STRING:
290 {
291 return "MI_STRING";
292 }
293 case MI_REFERENCE:
294 {
295 krisbash 1.1 return "MI_REFERENCE";
296 }
297 case MI_INSTANCE:
298 {
299 return "MI_INSTANCE";
300 }
301 case MI_BOOLEANA:
302 {
303 return "MI_BOOLEANA";
304 }
305 case MI_UINT8A:
306 {
307 return "MI_UINT8A";
308 }
309 case MI_SINT8A:
310 {
311 return "MI_SINT8A";
312 }
313 case MI_UINT16A:
314 {
315 return "MI_UINT16A";
316 krisbash 1.1 }
317 case MI_SINT16A:
318 {
319 return "MI_SINT16A";
320 }
321 case MI_UINT32A:
322 {
323 return "MI_UINT32A";
324 }
325 case MI_SINT32A:
326 {
327 return "MI_SINT32A";
328 }
329 case MI_UINT64A:
330 {
331 return "MI_UINT64A";
332 }
333 case MI_SINT64A:
334 {
335 return "MI_SINT64A";
336 }
337 krisbash 1.1 case MI_REAL32A:
338 {
339 return "MI_REAL32A";
340 }
341 case MI_REAL64A:
342 {
343 return "MI_REAL64A";
344 }
345 case MI_CHAR16A:
346 {
347 return "MI_CHAR16A";
348 }
349 case MI_DATETIMEA:
350 {
351 return "MI_DATETIMEA";
352 }
353 case MI_STRINGA:
354 {
355 return "MI_STRINGA";
356 }
357 case MI_REFERENCEA:
358 krisbash 1.1 {
359 return "MI_REFERENCEA";
360 }
361 case MI_INSTANCEA:
362 {
363 return "MI_INSTANCEA";
364 }
365 }
366 return "";
367 }
368
369 //forward declaration
370 void Print_Element_Value( const MI_Value *elementValue, MI_Type elementType, size_t level);
371
372 void Indent(size_t level)
373 {
374 size_t n = level *4;
375 while(n--)
376 PySys_WriteStdout(" ");
377 }
378
379 krisbash 1.1 /* Print an element */
380 void Print_Element(
381 const MI_Char *elementName,
382 const MI_Value *elementValue,
383 MI_Type elementType,
384 MI_Uint32 elementFlags,
385 size_t level)
386 {
387 Indent(level);
388 PySys_WriteStdout("%s [%s", elementName, MI_Type_To_String(elementType));
389
390 if (elementFlags & MI_FLAG_KEY)
391 {
392 PySys_WriteStdout(", MI_FLAG_KEY");
393 }
394
395 if ((elementFlags & MI_FLAG_NULL) || (elementValue == NULL))
396 {
397 PySys_WriteStdout(", NULL]");
398 return;
399 }
400 krisbash 1.1 else
401 {
402 PySys_WriteStdout("] ");
403
404 Print_Element_Value(elementValue, elementType, level);
405 }
406 }
407
408
409
410 void Dump_MI_Instance(MI_Instance *miInstance, MI_Boolean keysOnly, size_t level)
411 {
412 if(miInstance == NULL)
413 {
414 PyErr_SetString(MIError,"MI_Instance is null");
415 return;
416 }
417
418 MI_Uint32 elementCount;
419 MI_Result miResult;
420 MI_Uint32 elementIndex;
421 krisbash 1.1
422 miResult = MI_Instance_GetElementCount(miInstance, &elementCount);
423 if (miResult != MI_RESULT_OK)
424 {
425 PyErr_SetString(MIError,"MI_Instance_GetElementCount failed");
426 }
427 Indent(level);
428 PySys_WriteStdout("Class %s\n", miInstance->classDecl->name);
429 Indent(level);
430 PySys_WriteStdout("{\n");
431 Indent(level);
432
433 for (elementIndex = 0; elementIndex != elementCount; elementIndex++)
434 {
435 const MI_Char *elementName;
436 MI_Value elementValue;
437 MI_Type elementType;
438 MI_Uint32 elementFlags;
439
440 miResult = MI_Instance_GetElementAt(miInstance, elementIndex, &elementName, &elementValue, &elementType, &elementFlags);
441 if (miResult != MI_RESULT_OK)
442 krisbash 1.1 {
443 PyErr_SetString(MIError,"MI_Instance_GetElementCount failed");
444 }
445 if ((keysOnly && (elementFlags & MI_FLAG_KEY)) ||
446 !keysOnly)
447 {
448 Print_Element(elementName, &elementValue, elementType, elementFlags, level+1);
449 PySys_WriteStdout("\n");
450 }
451 }
452 Indent(level);
453 PySys_WriteStdout("}\n");
454 }
455
456 void Print_Element_Value(
457 const MI_Value *elementValue,
458 MI_Type elementType,
459 size_t level)
460 {
461 switch (elementType)
462 {
463 krisbash 1.1 case MI_BOOLEAN:
464 {
465 PySys_WriteStdout("%s", elementValue->boolean ? "True" : "False");
466 break;
467 }
468 case MI_SINT8:
469 {
470 PySys_WriteStdout("%hd", elementValue->sint8);
471 break;
472 }
473 case MI_UINT8:
474 {
475 PySys_WriteStdout("%hu", elementValue->uint8);
476 break;
477 }
478 case MI_SINT16:
479 {
480 PySys_WriteStdout("%d", elementValue->sint16);
481 break;
482 }
483 case MI_UINT16:
484 krisbash 1.1 {
485 PySys_WriteStdout("%u", elementValue->uint16);
486 break;
487 }
488 case MI_SINT32:
489 {
490 PySys_WriteStdout("%i", elementValue->sint32);
491 break;
492 }
493 case MI_UINT32:
494 {
495 PySys_WriteStdout("%u", elementValue->uint32);
496 break;
497 }
498 case MI_SINT64:
499 {
500 PySys_WriteStdout("%lld", elementValue->sint64);
501 break;
502 }
503 case MI_UINT64:
504 {
505 krisbash 1.1 PySys_WriteStdout("%llu", elementValue->uint64);
506 break;
507 }
508 case MI_REAL32:
509 {
510 PySys_WriteStdout("%g", elementValue->real32);
511 break;
512 }
513 case MI_REAL64:
514 {
515 PySys_WriteStdout("%lg", elementValue->real64);
516 break;
517 }
518 case MI_CHAR16:
519 {
520 PySys_WriteStdout("%u", elementValue->char16);
521 break;
522 }
523 case MI_DATETIME:
524 {
525 MI_Char buf[26];
526 krisbash 1.1 DatetimeToStr(&elementValue->datetime, buf);
527 PySys_WriteStdout("%s", buf);
528 break;
529 }
530 case MI_STRING:
531 {
532 PySys_WriteStdout("%s", elementValue->string);
533 break;
534 }
535 case MI_BOOLEANA:
536 {
537 MI_Uint32 i;
538 MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY));
539
540 PySys_WriteStdout("{");
541
542 for (i = 0; i < elementValue->booleana.size; i++)
543 {
544 MI_Value value;
545 value.boolean = elementValue->booleana.data[i];
546 Print_Element_Value(&value, nonArrayType, level);
547 krisbash 1.1 if (i + 1 != elementValue->datetimea.size)
548 PySys_WriteStdout(", ");
549 }
550 PySys_WriteStdout("}");
551 break;
552 }
553 case MI_SINT8A:
554 {
555 MI_Uint32 i;
556 MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY));
557
558 PySys_WriteStdout("{");
559
560 for (i = 0; i < elementValue->sint8a.size; i++)
561 {
562 MI_Value value;
563 value.sint8 = elementValue->sint8a.data[i];
564 Print_Element_Value(&value, nonArrayType, level);
565 if (i + 1 != elementValue->datetimea.size)
566 PySys_WriteStdout(", ");
567 }
568 krisbash 1.1 PySys_WriteStdout("}");
569 break;
570 }
571 case MI_UINT8A:
572 {
573 MI_Uint32 i;
574 MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY));
575
576 PySys_WriteStdout("{");
577
578 for (i = 0; i < elementValue->uint8a.size; i++)
579 {
580 MI_Value value;
581 value.uint8 = elementValue->uint8a.data[i];
582 Print_Element_Value(&value, nonArrayType, level);
583 if (i + 1 != elementValue->datetimea.size)
584 PySys_WriteStdout(", ");
585 }
586 PySys_WriteStdout("}");
587 break;
588 }
589 krisbash 1.1 case MI_SINT16A:
590 {
591 MI_Uint32 i;
592 MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY));
593
594 PySys_WriteStdout("{");
595
596 for (i = 0; i < elementValue->sint16a.size; i++)
597 {
598 MI_Value value;
599 value.sint16 = elementValue->sint16a.data[i];
600 Print_Element_Value(&value, nonArrayType, level);
601 if (i + 1 != elementValue->datetimea.size)
602 PySys_WriteStdout(", ");
603 }
604 PySys_WriteStdout("}");
605 break;
606 }
607 case MI_UINT16A:
608 {
609 MI_Uint32 i;
610 krisbash 1.1 MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY));
611
612 PySys_WriteStdout("{");
613
614 for (i = 0; i < elementValue->uint16a.size; i++)
615 {
616 MI_Value value;
617 value.uint16 = elementValue->uint16a.data[i];
618 Print_Element_Value(&value, nonArrayType, level);
619 if (i + 1 != elementValue->datetimea.size)
620 PySys_WriteStdout(", ");
621 }
622 PySys_WriteStdout("}");
623 break;
624 }
625 case MI_SINT32A:
626 {
627 MI_Uint32 i;
628 MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY));
629
630 PySys_WriteStdout("{");
631 krisbash 1.1
632 for (i = 0; i < elementValue->sint32a.size; i++)
633 {
634 MI_Value value;
635 value.sint32 = elementValue->sint32a.data[i];
636 Print_Element_Value(&value, nonArrayType, level);
637 if (i + 1 != elementValue->datetimea.size)
638 PySys_WriteStdout(", ");
639 }
640 PySys_WriteStdout("}");
641 break;
642 }
643 case MI_UINT32A:
644 {
645 MI_Uint32 i;
646 MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY));
647
648 PySys_WriteStdout("{");
649
650 for (i = 0; i < elementValue->uint32a.size; i++)
651 {
652 krisbash 1.1 MI_Value value;
653 value.uint32 = elementValue->uint32a.data[i];
654 Print_Element_Value(&value, nonArrayType, level);
655 if (i + 1 != elementValue->datetimea.size)
656 PySys_WriteStdout(", ");
657 }
658 PySys_WriteStdout("}");
659 break;
660 }
661 case MI_SINT64A:
662 {
663 MI_Uint32 i;
664 MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY));
665
666 PySys_WriteStdout("{");
667
668 for (i = 0; i < elementValue->sint64a.size; i++)
669 {
670 MI_Value value;
671 value.sint64 = elementValue->sint64a.data[i];
672 Print_Element_Value(&value, nonArrayType, level);
673 krisbash 1.1 if (i + 1 != elementValue->datetimea.size)
674 PySys_WriteStdout(", ");
675 }
676 PySys_WriteStdout("}");
677 break;
678 }
679 case MI_UINT64A:
680 {
681 MI_Uint32 i;
682 MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY));
683
684 PySys_WriteStdout("{");
685
686 for (i = 0; i < elementValue->uint64a.size; i++)
687 {
688 MI_Value value;
689 value.uint64 = elementValue->uint64a.data[i];
690 Print_Element_Value(&value, nonArrayType, level);
691 if (i + 1 != elementValue->datetimea.size)
692 PySys_WriteStdout(", ");
693 }
694 krisbash 1.1 PySys_WriteStdout("}");
695 break;
696 }
697 case MI_REAL32A:
698 {
699 MI_Uint32 i;
700 MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY));
701
702 PySys_WriteStdout("{");
703
704 for (i = 0; i < elementValue->real32a.size; i++)
705 {
706 MI_Value value;
707 value.real32 = elementValue->real32a.data[i];
708 Print_Element_Value(&value, nonArrayType, level);
709 if (i + 1 != elementValue->datetimea.size)
710 PySys_WriteStdout(", ");
711 }
712 PySys_WriteStdout("}");
713 break;
714 }
715 krisbash 1.1 case MI_REAL64A:
716 {
717 MI_Uint32 i;
718 MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY));
719
720 PySys_WriteStdout("{");
721
722 for (i = 0; i < elementValue->real64a.size; i++)
723 {
724 MI_Value value;
725 value.real64 = elementValue->real64a.data[i];
726 Print_Element_Value(&value, nonArrayType, level);
727 if (i + 1 != elementValue->datetimea.size)
728 PySys_WriteStdout(", ");
729 }
730 PySys_WriteStdout("}");
731 break;
732 }
733 case MI_CHAR16A:
734 {
735 MI_Uint32 i;
736 krisbash 1.1 MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY));
737
738 PySys_WriteStdout("{");
739
740 for (i = 0; i < elementValue->char16a.size; i++)
741 {
742 MI_Value value;
743 value.char16 = elementValue->char16a.data[i];
744 Print_Element_Value(&value, nonArrayType, level);
745 if (i + 1 != elementValue->datetimea.size)
746 PySys_WriteStdout(", ");
747 }
748 PySys_WriteStdout("}");
749 break;
750 }
751 case MI_DATETIMEA:
752 {
753 MI_Uint32 i;
754 MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY));
755
756 PySys_WriteStdout("{");
757 krisbash 1.1
758 for (i = 0; i < elementValue->datetimea.size; i++)
759 {
760 MI_Value value;
761 value.datetime = elementValue->datetimea.data[i];
762 Print_Element_Value(&value, nonArrayType, level);
763 if (i + 1 != elementValue->datetimea.size)
764 PySys_WriteStdout(", ");
765 }
766 PySys_WriteStdout("}");
767 break;
768 }
769 case MI_STRINGA:
770 {
771 MI_Uint32 i;
772
773 PySys_WriteStdout("{");
774
775 for (i = 0; i < elementValue->stringa.size; i++)
776 {
777 MI_Char *value;
778 krisbash 1.1 value = elementValue->stringa.data[i];
779 PySys_WriteStdout(value);
780 if (i + 1 != elementValue->stringa.size)
781 PySys_WriteStdout(", ");
782 }
783 PySys_WriteStdout("}");
784 break;
785 }
786 case MI_INSTANCE:
787 {
788 MI_Instance* inst = elementValue->instance;
789
790 Dump_MI_Instance(inst, MI_FALSE, level);
791 break;
792 }
793 case MI_REFERENCE:
794 {
795 MI_Instance* inst = elementValue->reference;
796
797 PySys_WriteStdout(" REF ");
798
799 krisbash 1.1 Dump_MI_Instance(inst, MI_TRUE, level);
800 break;
801 }
802 case MI_INSTANCEA:
803 {
804 const MI_InstanceA* inst = &elementValue->instancea;
805 MI_Uint32 i;
806
807 PySys_WriteStdout("\n");
808
809 Indent(level);
810 PySys_WriteStdout("{\n");
811
812 for (i = 0; i < inst->size; i++)
813 {
814 Dump_MI_Instance(inst->data[i], MI_TRUE, level + 1);
815 }
816
817 Indent(level);
818 PySys_WriteStdout("}");
819
820 krisbash 1.1 break;
821 }
822 case MI_REFERENCEA:
823 {
824 const MI_InstanceA* inst = &elementValue->instancea;
825 MI_Uint32 i;
826
827 PySys_WriteStdout(" REF ");
828
829 PySys_WriteStdout("\n");
830
831 Indent(level);
832 PySys_WriteStdout("{\n");
833
834 for (i = 0; i < inst->size; i++)
835 {
836 Dump_MI_Instance(inst->data[i], MI_FALSE, level + 1);
837 }
838
839 Indent(level);
840 PySys_WriteStdout("}");
841 krisbash 1.1
842 break;
843 }
844 default:
845 break;
846 }
847 }
848
849
850
851 static PyObject *Print(PyObject *self,PyObject *args)
852 {
853 PyObject *instance;
854 if(!PyArg_ParseTuple(args,"O",&instance))
855 {
856 PyErr_SetString(MIError,"Please input correct MI_Instance");
857 return NULL;
858 }
859 PMI_Instance *pmiInstance = (PMI_Instance *)instance;
860 MI_Instance *miInstance;
861 if(pmiInstance != NULL && (PyObject_Compare((PyObject *)pmiInstance,Py_None)))
862 krisbash 1.1 {
863 miInstance = pmiInstance->miInstance;
864 }
865 else
866 {
867 PyErr_SetString(MIError,"MI_Instance cannot be null!");
868 return NULL;
869 }
870
871 Dump_MI_Instance(miInstance,MI_FALSE,0);
872 Py_INCREF(Py_None);
873 return Py_None;
874 }
875
876 static PyMethodDef mi_funcs[] = {
877 {"connect",(PyCFunction)Connect,METH_VARARGS,NULL},
878 {"create_local_instance",(PyCFunction)CreateLocalInstance,METH_VARARGS|METH_KEYWORDS,NULL},
879 {"print_instance",(PyCFunction)Print,METH_VARARGS,NULL},
880 {NULL}
881 };
882
883 krisbash 1.1 void initmi(void) {
884 PyObject *m;
885 m = Py_InitModule3("mi", mi_funcs, "MI module that wraps up the MI operation from client API");
886 /*Add the exception type to the module */
887 MIError = PyErr_NewException("mi.error",NULL,NULL);
888 Py_INCREF(MIError);
889 PyModule_AddObject(m,"MIError",MIError);
890
891 /*enum types */
892 PyModule_AddIntConstant(m, "BOOLEAN",0);
893 PyModule_AddIntConstant(m,"UINT8",1);
894 PyModule_AddIntConstant(m, "SINT8",2);
895 PyModule_AddIntConstant(m,"UINT16",3);
896 PyModule_AddIntConstant(m,"SINT16",4);
897 PyModule_AddIntConstant(m, "UINT32",5);
898 PyModule_AddIntConstant(m,"SINT32",6);
899 PyModule_AddIntConstant(m, "UINT64",7);
900 PyModule_AddIntConstant(m,"SINT64",8);
901 PyModule_AddIntConstant(m,"REAL32",9);
902 PyModule_AddIntConstant(m, "REAL64",10);
903 PyModule_AddIntConstant(m,"CHAR16",11);
904 krisbash 1.1 PyModule_AddIntConstant(m, "DATETIME",12);
905 PyModule_AddIntConstant(m,"STRING",13);
906 PyModule_AddIntConstant(m,"REFERENCE",14);
907 PyModule_AddIntConstant(m, "INSTANCE",15);
908 PyModule_AddIntConstant(m,"BOOLEANA",16);
909 PyModule_AddIntConstant(m, "UINT8A",17);
910 PyModule_AddIntConstant(m,"SINT8A",18);
911 PyModule_AddIntConstant(m,"UINT16A",19);
912 PyModule_AddIntConstant(m, "SINT16A",20);
913 PyModule_AddIntConstant(m,"UINT32A",21);
914 PyModule_AddIntConstant(m, "SINT32A",22);
915 PyModule_AddIntConstant(m,"UINT64A",23);
916 PyModule_AddIntConstant(m,"SINT64A",24);
917 PyModule_AddIntConstant(m, "REAL32A",25);
918 PyModule_AddIntConstant(m,"REAL64A",26);
919 PyModule_AddIntConstant(m, "CHAR16A",27);
920 PyModule_AddIntConstant(m,"DATETIMEA",28);
921 PyModule_AddIntConstant(m,"STRINGA",29);
922 PyModule_AddIntConstant(m,"REFERENCEA",30);
923 PyModule_AddIntConstant(m,"INSTANCEA",31);
924
925 krisbash 1.1 /*CIM meta types */
926 PyModule_AddIntConstant(m,"FLAG_CLASS",1 << 0);
927 PyModule_AddIntConstant(m,"FLAG_METHOD",1 << 1);
928 PyModule_AddIntConstant(m,"FLAG_PROPERTY",1 << 2);
929 PyModule_AddIntConstant(m,"FLAG_PARAMETER", 1 << 3);
930 PyModule_AddIntConstant(m,"FLAG_ASSOCIATION",1 << 4);
931 PyModule_AddIntConstant(m,"FLAG_INDICATION", 1 << 5);
932 PyModule_AddIntConstant(m,"FLAG_REFERENCE", 1 << 6);
933 PyModule_AddIntConstant(m,"FLAG_ANY",1|2|4|8|16|32|64);
934
935 /*Qualifier flavors */
936 PyModule_AddIntConstant(m,"FLAG_ENABLEOVERRIDE",1 << 7);
937 PyModule_AddIntConstant(m,"FLAG_DISABLEOVERRIDE",1 << 8);
938 PyModule_AddIntConstant(m,"FLAG_RESTRICTED",1 << 9);
939 PyModule_AddIntConstant(m,"FLAG_TOSUBCLASS",1 << 10);
940 PyModule_AddIntConstant(m,"FLAG_PARAMETER", 1 << 11);
941
942 /*Select boolean qualifiers */
943 PyModule_AddIntConstant(m,"FLAG_KEY",1 << 12);
944 PyModule_AddIntConstant(m,"FLAG_IN",1 << 13);
945 PyModule_AddIntConstant(m,"FLAG_OUT",1 << 14);
946 krisbash 1.1 PyModule_AddIntConstant(m,"FLAG_REQUIRED",1 << 15);
947 PyModule_AddIntConstant(m,"FLAG_STATIC", 1 << 16);
948 PyModule_AddIntConstant(m,"FLAG_ABSTRACT",1 << 17);
949 PyModule_AddIntConstant(m,"FLAG_TERMINAL",1 << 18);
950 PyModule_AddIntConstant(m,"FLAG_EXPENSIVE",1 << 19);
951 PyModule_AddIntConstant(m,"FLAG_STREAM",1 << 20);
952 PyModule_AddIntConstant(m,"FLAG_READONLY", 1 << 21);
953
954 /* Special flags */
955 PyModule_AddIntConstant(m,"FLAG_NOT_MODIFIED",1 << 25);
956 PyModule_AddIntConstant(m,"FLAG_VERSION",1<<26|1<<27|1<<28);
957 PyModule_AddIntConstant(m,"FLAG_NULL",1 << 29);
958 PyModule_AddIntConstant(m,"FLAG_BORROW",1 << 30);
959 PyModule_AddIntConstant(m,"FLAG_ADOPT", 1 << 31);
960 }
961
|
Return to
PythonBinding.c
CVS log
Up to [OMI] / omi / scriptext / py