1 mike 1.1 /*
2 **==============================================================================
3 **
4 ** Open Management Infrastructure (OMI)
5 **
6 ** Copyright (c) Microsoft Corporation
7 **
8 ** Licensed under the Apache License, Version 2.0 (the "License"); you may not
9 ** use this file except in compliance with the License. You may obtain a copy
10 ** of the License at
11 **
12 ** http://www.apache.org/licenses/LICENSE-2.0
13 **
14 ** THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 ** KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
16 ** WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
17 ** MERCHANTABLITY OR NON-INFRINGEMENT.
18 **
19 ** See the Apache 2 License for the specific language governing permissions
20 ** and limitations under the License.
21 **
22 mike 1.1 **==============================================================================
23 */
24
25 #include "client.h"
26 #include <base/packing.h>
27 #include <protocol/protocol.h>
|
28 krisbash 1.3 #include <pal/sleep.h>
|
29 mike 1.1 #include <base/paths.h>
|
30 krisbash 1.3 #include <pal/thread.h>
31 #include <base/log.h>
|
32 mike 1.1
33 #if 0
34 # define D(X) X
35 #else
36 # define D(X) /* empty */
37 #endif
38
|
39 krisbash 1.3 STRAND_DEBUGNAME(OmiClient);
40
|
41 mike 1.1 MI_BEGIN_NAMESPACE
42
43 //==============================================================================
44 //
45 // Local definitions.
46 //
47 //==============================================================================
48
|
49 krisbash 1.3 PAL_Uint64 _NextOperationId()
|
50 mike 1.1 {
|
51 krisbash 1.3 static volatile ptrdiff_t _operationId = 10000;
52 PAL_Uint64 x = Atomic_Inc(&_operationId);
|
53 mike 1.1
54 return x;
55 }
56
57 static char* _StringToStr(const String& str)
58 {
59 Uint32 n = str.GetSize();
60 char* r = new char[n + 1];
61
62 if (!r)
63 return NULL;
64
65 for (Uint32 i = 0; i < n; i++)
66 {
67 r[i] = char(str[i]);
68 }
69
70 r[n] = '\0';
71
72 return r;
73 }
74 mike 1.1
|
75 krisbash 1.3 static String _StrToString(const char* str)
76 {
77 String r;
78
79 while (str)
80 {
81 MI_Char c = *str++;
82 r.Append(&c, 1);
83 }
84
85 return r;
86 }
87
|
88 mike 1.1 //==============================================================================
89 //
90 // class EnvelopeHandler
91 //
92 //==============================================================================
93
94 class EnvelopeHandler : public Handler
95 {
96 public:
97
98 EnvelopeHandler(Handler* handler) : m_handler(handler)
99 {
100 }
101
102 virtual void HandleConnect()
103 {
104 if (m_handler)
105 m_handler->HandleConnect();
106 }
107
108 virtual void HandleConnectFailed()
109 mike 1.1 {
110 if (m_handler)
111 m_handler->HandleConnectFailed();
112 }
113
114 virtual void HandleDisconnect()
115 {
116 if (m_handler)
117 m_handler->HandleDisconnect();
118 }
119
|
120 krisbash 1.3 virtual void HandleNoOp(Uint64 operationId)
|
121 mike 1.1 {
122 if (m_handler)
|
123 krisbash 1.3 m_handler->HandleNoOp(operationId);
|
124 mike 1.1 }
125
|
126 krisbash 1.3 virtual void HandleInstance(Uint64 operationId, const DInstance& instance)
|
127 mike 1.1 {
128 if (m_handler)
|
129 krisbash 1.3 m_handler->HandleInstance(operationId, instance);
|
130 mike 1.1 }
131
|
132 krisbash 1.3 virtual void HandleResult(Uint64 operationId, MI_Result result)
|
133 mike 1.1 {
134 if (m_handler)
|
135 krisbash 1.3 m_handler->HandleResult(operationId, result);
136 }
137 virtual void HandleResult(Uint64 operationId, MI_Result result, const MI_Char *error, const DInstance* cimError)
138 {
139 if (m_handler)
140 m_handler->HandleResult(operationId, result, error, cimError);
|
141 mike 1.1 }
142
143 private:
144 Handler* m_handler;
145 };
146
147 //==============================================================================
148 //
149 // class NoOpHandler
150 //
151 //==============================================================================
152
153 class NoOpHandler : public EnvelopeHandler
154 {
155 public:
156
157 enum State { START, DONE, FAILED };
158
|
159 krisbash 1.3 NoOpHandler(Handler* handler, Uint64 operationId) :
160 EnvelopeHandler(handler), m_state(START), m_operationId(operationId)
|
161 mike 1.1 {
162 }
163
|
164 krisbash 1.3 virtual void HandleNoOp(Uint64 operationId)
|
165 mike 1.1 {
|
166 krisbash 1.3 if (operationId != m_operationId)
|
167 mike 1.1 {
|
168 krisbash 1.3 EnvelopeHandler::HandleNoOp(operationId);
|
169 mike 1.1 return;
170 }
171
172 if (m_state != START)
173 {
174 m_state = FAILED;
175 return;
176 }
177
178 m_state = DONE;
179 }
180
181 State m_state;
|
182 krisbash 1.3 Uint64 m_operationId;
|
183 mike 1.1 };
184
185 //==============================================================================
186 //
187 // class ResultHandler
188 //
189 //==============================================================================
190
191 class ResultHandler : public EnvelopeHandler
192 {
193 public:
194
195 enum State { START, DONE, FAILED };
196
|
197 krisbash 1.3 ResultHandler(Handler* handler, Uint64 operationId) :
|
198 mike 1.1 EnvelopeHandler(handler),
199 m_state(START),
|
200 krisbash 1.3 m_operationId(operationId),
201 m_result(MI_RESULT_OK),
202 m_cimerror(NULL),
203 m_errorMessage(NULL)
|
204 mike 1.1 {
205 }
206
|
207 krisbash 1.3 virtual void HandleResult(Uint64 operationId, Result result)
|
208 mike 1.1 {
|
209 krisbash 1.3 if (operationId != m_operationId)
|
210 mike 1.1 {
|
211 krisbash 1.3 EnvelopeHandler::HandleResult(operationId, result);
|
212 mike 1.1 return;
213 }
214
215 if (m_state != START)
216 {
217 m_state = FAILED;
218 return;
219 }
220
221 m_result = result;
222 m_state = DONE;
223 }
224
|
225 krisbash 1.3 virtual void HandleResult(Uint64 operationId, MI_Result result, const MI_Char *error, const DInstance* cimError)
226 {
227 if (operationId != m_operationId)
228 {
229 EnvelopeHandler::HandleResult(operationId, result, error, cimError);
230 return;
231 }
232
233 if (m_state != START)
234 {
235 m_state = FAILED;
236 return;
237 }
238
239 m_result = result;
240 m_cimerror = cimError;
241 m_errorMessage = error;
242 m_state = DONE;
243 }
244
|
245 mike 1.1 State m_state;
|
246 krisbash 1.3 Uint64 m_operationId;
|
247 mike 1.1 Result m_result;
|
248 krisbash 1.3 const DInstance* m_cimerror;
249 const MI_Char *m_errorMessage;
|
250 mike 1.1 };
251
252 //==============================================================================
253 //
254 // class InstanceHandler
255 //
256 //==============================================================================
257
258 class InstanceHandler : public EnvelopeHandler
259 {
260 public:
261
262 enum State { INSTANCE, RESULT, DONE, FAILED };
263
264 InstanceHandler(
265 Handler* handler,
|
266 krisbash 1.3 Uint64 operationId,
|
267 mike 1.1 DInstance& instance)
268 :
269 EnvelopeHandler(handler),
270 m_state(INSTANCE),
|
271 krisbash 1.3 m_operationId(operationId),
|
272 mike 1.1 m_instance(instance),
|
273 krisbash 1.3 m_result(MI_RESULT_OK),
274 m_errorMessage(NULL),
275 m_cimerror(NULL)
|
276 mike 1.1 {
277 }
278
|
279 krisbash 1.3 virtual void HandleInstance(Uint64 operationId, const DInstance& instance)
|
280 mike 1.1 {
|
281 krisbash 1.3 if (operationId != m_operationId)
|
282 mike 1.1 {
|
283 krisbash 1.3 EnvelopeHandler::HandleInstance(operationId, instance);
|
284 mike 1.1 return;
285 }
286
287 if (m_state != INSTANCE)
288 {
289 m_state = FAILED;
290 return;
291 }
292
293 m_instance = instance;
294 m_state = RESULT;
295 }
296
|
297 krisbash 1.3 virtual void HandleResult(Uint64 operationId, Result result)
|
298 mike 1.1 {
|
299 krisbash 1.3 if (operationId != m_operationId)
|
300 mike 1.1 {
|
301 krisbash 1.3 EnvelopeHandler::HandleResult(operationId, result);
|
302 mike 1.1 return;
303 }
304
305 if (m_state != INSTANCE && m_state != RESULT)
306 {
307 m_state = FAILED;
308 return;
309 }
310
311 m_result = result;
312 m_state = DONE;
313 }
|
314 krisbash 1.3
315 virtual void HandleResult(Uint64 operationId, MI_Result result, const MI_Char *error, const DInstance* cimError)
316 {
317 if (operationId != m_operationId)
318 {
319 EnvelopeHandler::HandleResult(operationId, result, error, cimError);
320 return;
321 }
322
323 if (m_state != INSTANCE && m_state != RESULT)
324 {
325 m_state = FAILED;
326 return;
327 }
328
329 m_result = result;
330 m_cimerror = cimError;
331 m_errorMessage = error;
332 m_state = DONE;
333 }
|
334 mike 1.1
335 State m_state;
|
336 krisbash 1.3 Uint64 m_operationId;
|
337 mike 1.1 DInstance& m_instance;
338 Result m_result;
|
339 krisbash 1.3 const MI_Char *m_errorMessage;
340 const DInstance* m_cimerror;
|
341 mike 1.1 };
342
343 //==============================================================================
344 //
345 // class InstancesHandler
346 //
347 //==============================================================================
348
349 class InstancesHandler : public EnvelopeHandler
350 {
351 public:
352
353 enum State { INSTANCES, RESULT, DONE, FAILED };
354
355 InstancesHandler(
356 Handler* handler,
|
357 krisbash 1.3 Uint64 operationId,
|
358 mike 1.1 Array<DInstance>& instances)
359 :
360 EnvelopeHandler(handler),
361 m_state(INSTANCES),
|
362 krisbash 1.3 m_operationId(operationId),
|
363 mike 1.1 m_instances(instances),
364 m_result(MI_RESULT_OK)
365 {
366 }
367
|
368 krisbash 1.3 virtual void HandleInstance(Uint64 operationId, const DInstance& instance)
|
369 mike 1.1 {
|
370 krisbash 1.3 if (operationId != m_operationId)
|
371 mike 1.1 {
|
372 krisbash 1.3 EnvelopeHandler::HandleInstance(operationId, instance);
|
373 mike 1.1 return;
374 }
375
376 if (m_state != INSTANCES)
377 {
378 m_state = FAILED;
379 return;
380 }
381
382 m_instances.PushBack(instance);
383 }
384
|
385 krisbash 1.3 virtual void HandleResult(Uint64 operationId, Result result)
386 {
387 if (operationId != m_operationId)
388 {
389 EnvelopeHandler::HandleResult(operationId, result);
390 return;
391 }
392
393 if (m_state != INSTANCES)
394 {
395 m_state = FAILED;
396 return;
397 }
398
399 m_result = result;
400 m_state = DONE;
401 }
402
403 virtual void HandleResult(Uint64 operationId, Result result, const MI_Char *error, const DInstance* cimError)
|
404 mike 1.1 {
|
405 krisbash 1.3 if (operationId != m_operationId)
|
406 mike 1.1 {
|
407 krisbash 1.3 EnvelopeHandler::HandleResult(operationId, result);
|
408 mike 1.1 return;
409 }
410
411 if (m_state != INSTANCES)
412 {
413 m_state = FAILED;
414 return;
415 }
416
417 m_result = result;
418 m_state = DONE;
419 }
420
421 State m_state;
|
422 krisbash 1.3 Uint64 m_operationId;
|
423 mike 1.1 Array<DInstance>& m_instances;
424 Result m_result;
425 };
426
427 //==============================================================================
428 //
429 // class ClientRep
430 //
431 //==============================================================================
432
433 class ClientRep
434 {
435 public:
436 enum ConnectState
437 {
438 CONNECTSTATE_PENDING,
439 CONNECTSTATE_FAILED,
440 CONNECTSTATE_CONNECTED,
441 CONNECTSTATE_DISCONNECTED
442 };
443
|
444 krisbash 1.3 ProtocolSocketAndBase* protocol;
445 Strand strand; // To manage interaction with ProtocolSocket
|
446 mike 1.1 Handler* handler;
447 ConnectState connectState;
448
|
449 krisbash 1.3 static void MessageCallback(
450 ClientRep * rep,
451 Message* msg);
|
452 mike 1.1
453 bool NoOpAsync(
|
454 krisbash 1.3 Uint64 operationId);
|
455 mike 1.1
456 bool GetInstanceAsync(
457 const String& nameSpace,
458 const DInstance& instanceName,
|
459 krisbash 1.3 Uint64 operationId);
|
460 mike 1.1
461 bool CreateInstanceAsync(
462 const String& nameSpace,
463 const DInstance& instance,
|
464 krisbash 1.3 Uint64 operationId);
|
465 mike 1.1
466 bool ModifyInstanceAsync(
467 const String& nameSpace,
468 const DInstance& instance,
|
469 krisbash 1.3 Uint64 operationId);
|
470 mike 1.1
471 bool DeleteInstanceAsync(
472 const String& nameSpace,
473 const DInstance& instanceName,
|
474 krisbash 1.3 Uint64 operationId);
|
475 mike 1.1
476 bool EnumerateInstancesAsync(
477 const String& nameSpace,
478 const String& className,
479 bool deepInheritance,
480 const String& queryLanguage,
481 const String& queryExpression,
|
482 krisbash 1.3 Uint64 operationId);
|
483 mike 1.1
484 bool InvokeAsync(
485 const String& nameSpace,
486 const DInstance& instanceName,
487 const String& methodName,
488 const DInstance& inParameters,
489 DInstance& outParameters,
|
490 krisbash 1.3 Uint64 operationId);
|
491 mike 1.1
492 bool AssociatorInstancesAsync(
493 const String& nameSpace,
494 const DInstance& instanceName,
495 const String& assocClass,
496 const String& resultClass,
497 const String& role,
498 const String& resultRole,
|
499 krisbash 1.3 Uint64& operationId);
|
500 mike 1.1
501 bool ReferenceInstancesAsync(
502 const String& nameSpace,
503 const DInstance& instanceName,
|
504 krisbash 1.3 const String& resultClass,
|
505 mike 1.1 const String& role,
|
506 krisbash 1.3 Uint64& operationId);
|
507 mike 1.1 };
508
|
509 krisbash 1.3 void ClientRep::MessageCallback(
510 ClientRep * clientRep,
511 Message* msg)
|
512 mike 1.1 {
513 Handler* handler = clientRep->handler;
514
515 DEBUG_ASSERT(msg != 0);
516
517 switch (msg->tag)
518 {
519 case NoOpRspTag:
520 {
521 D( printf("ClientRep::MessageCallback(): NoOpRspTag\n"); )
522 NoOpRsp* rsp = (NoOpRsp*)msg;
523 MI_UNUSED(rsp);
524 if (handler)
|
525 krisbash 1.3 handler->HandleNoOp(rsp->base.operationId);
|
526 mike 1.1 break;
527 }
528 case PostInstanceMsgTag:
529 {
530 D( printf("ClientRep::MessageCallback(): PostInstanceMsgTag\n"); )
531 PostInstanceMsg* rsp = (PostInstanceMsg*)msg;
532
533 if (rsp->instance)
534 {
535 DInstance di(rsp->instance, DInstance::CLONE);
536 if (handler)
|
537 krisbash 1.3 handler->HandleInstance(rsp->base.operationId, di);
|
538 mike 1.1 }
539
540 break;
541 }
542 case PostResultMsgTag:
543 {
544 D( printf("ClientRep::MessageCallback(): PostResultMsgTag\n"); )
545 PostResultMsg* rsp = (PostResultMsg*)msg;
546 if (handler)
|
547 krisbash 1.3 {
548 if (rsp->cimError)
549 {
550 DInstance di((MI_Instance*)(rsp->cimError), DInstance::CLONE);
551 handler->HandleResult(rsp->base.operationId, rsp->result, rsp->errorMessage, &di);
552 }
553 else
554 {
555 handler->HandleResult(rsp->base.operationId, rsp->result, rsp->errorMessage, NULL);
556 }
557 }
|
558 mike 1.1 break;
559 }
560 default:
561 {
562 D( printf("ClientRep::MessageCallback(): default\n"); )
563 break;
564 }
565 }
566 }
567
568 bool ClientRep::NoOpAsync(
|
569 krisbash 1.3 Uint64 operationId)
|
570 mike 1.1 {
571 NoOpReq* req = 0;
572 bool result = true;
573
574 // Fail if not connected:
|
575 krisbash 1.3 if( !protocol || !strand.info.opened )
|
576 mike 1.1 {
577 result = false;
578 goto done;
579 }
580
581 // Create request message:
582 {
|
583 krisbash 1.3 req = NoOpReq_New(operationId);
|
584 mike 1.1
585 if (!req)
586 {
587 result = false;
588 goto done;
589 }
590 }
591
592 // Send the message:
593 {
|
594 krisbash 1.3 Strand_SchedulePost(&strand,&req->base.base);
|
595 mike 1.1 }
596
597 done:
598
599 if (req)
600 NoOpReq_Release(req);
601
602 return result;
603 }
604
605 bool ClientRep::GetInstanceAsync(
606 const String& nameSpace,
607 const DInstance& instanceName,
|
608 krisbash 1.3 Uint64 operationId)
|
609 mike 1.1 {
610 GetInstanceReq* req = 0;
611 bool result = true;
612
613 // Fail if not connected.
|
614 krisbash 1.3 if( !protocol || !strand.info.opened )
|
615 mike 1.1 {
616 result = false;
617 goto done;
618 }
619
620 // Create the request message:
621 {
|
622 krisbash 1.3 req = GetInstanceReq_New(operationId, BinaryProtocolFlag);
|
623 mike 1.1
624 if (!req)
625 {
626 result = false;
627 goto done;
628 }
629 }
630
631 // Set nameSpace:
|
632 krisbash 1.3 req->nameSpace = Batch_Tcsdup(req->base.base.batch, nameSpace.Str());
633 if (!req->nameSpace)
634 {
635 result = false;
636 goto done;
637 }
|
638 mike 1.1
639 // Pack the instance name into the message's batch.
640 {
641 Result r = InstanceToBatch(
642 instanceName.m_self,
643 NULL,
644 NULL,
|
645 krisbash 1.3 req->base.base.batch,
|
646 mike 1.1 &req->packedInstanceNamePtr,
647 &req->packedInstanceNameSize);
648
649 if (r != MI_RESULT_OK)
650 {
651 result = false;
652 goto done;
653 }
654 }
655
656 // Send the messages:
657 {
|
658 krisbash 1.3 Strand_SchedulePost(&strand,&req->base.base);
|
659 mike 1.1 }
660
661 done:
662 if (req)
663 GetInstanceReq_Release(req);
664
665 return result;
666 }
667
668 bool ClientRep::CreateInstanceAsync(
669 const String& nameSpace,
670 const DInstance& instance,
|
671 krisbash 1.3 Uint64 operationId)
|
672 mike 1.1 {
673 CreateInstanceReq* req = 0;
674 bool result = true;
675
676 // Fail if not connected.
|
677 krisbash 1.3 if( !protocol || !strand.info.opened )
|
678 mike 1.1 {
679 result = false;
680 goto done;
681 }
682
683 // Create the request message:
684 {
|
685 krisbash 1.3 req = CreateInstanceReq_New(operationId, BinaryProtocolFlag);
|
686 mike 1.1
687 if (!req)
688 {
689 result = false;
690 goto done;
691 }
692 }
693
694 // Set nameSpace:
|
695 krisbash 1.3 req->nameSpace = Batch_Tcsdup(req->base.base.batch, nameSpace.Str());
696 if (!req->nameSpace)
697 {
698 result = false;
699 goto done;
700 }
|
701 mike 1.1
702 // Pack the instance name into the message's batch.
703 {
704 Result r = InstanceToBatch(
705 instance.m_self,
706 NULL,
707 NULL,
|
708 krisbash 1.3 req->base.base.batch,
|
709 mike 1.1 &req->packedInstancePtr,
710 &req->packedInstanceSize);
711
712 if (r != MI_RESULT_OK)
713 {
714 result = false;
715 goto done;
716 }
717 }
718
719 // Send the messages:
720 {
|
721 krisbash 1.3 Strand_SchedulePost(&strand,&req->base.base);
|
722 mike 1.1 }
723
724 done:
725 if (req)
726 CreateInstanceReq_Release(req);
727
728 return result;
729 }
730
731 bool ClientRep::ModifyInstanceAsync(
732 const String& nameSpace,
733 const DInstance& instance,
|
734 krisbash 1.3 Uint64 operationId)
|
735 mike 1.1 {
736 ModifyInstanceReq* req = 0;
737 bool result = true;
738
739 // Fail if not connected.
|
740 krisbash 1.3 if( !protocol || !strand.info.opened )
|
741 mike 1.1 {
742 result = false;
743 goto done;
744 }
745
746 // Create the request message:
747 {
|
748 krisbash 1.3 req = ModifyInstanceReq_New(operationId, BinaryProtocolFlag);
|
749 mike 1.1
750 if (!req)
751 {
752 result = false;
753 goto done;
754 }
755 }
756
757 // Set nameSpace:
|
758 krisbash 1.3 req->nameSpace = Batch_Tcsdup(req->base.base.batch, nameSpace.Str());
759 if (!req->nameSpace)
760 {
761 result = false;
762 goto done;
763 }
|
764 mike 1.1
765 // Pack the instance name into the message's batch.
766 {
767 Result r = InstanceToBatch(
768 instance.m_self,
769 NULL,
770 NULL,
|
771 krisbash 1.3 req->base.base.batch,
|
772 mike 1.1 &req->packedInstancePtr,
773 &req->packedInstanceSize);
774
775 if (r != MI_RESULT_OK)
776 {
777 result = false;
778 goto done;
779 }
780 }
781
782 // Send the messages:
|
783 krisbash 1.3 Strand_SchedulePost(&strand,&req->base.base);
|
784 mike 1.1
785 done:
786 if (req)
787 ModifyInstanceReq_Release(req);
788
789 return result;
790 }
791
792 bool ClientRep::DeleteInstanceAsync(
793 const String& nameSpace,
794 const DInstance& instanceName,
|
795 krisbash 1.3 Uint64 operationId)
|
796 mike 1.1 {
797 DeleteInstanceReq* req = 0;
798 bool result = true;
799
800 // Fail if not connected.
|
801 krisbash 1.3 if( !protocol || !strand.info.opened )
|
802 mike 1.1 {
803 result = false;
804 goto done;
805 }
806
807 // Create the request message:
808 {
|
809 krisbash 1.3 req = DeleteInstanceReq_New(operationId, BinaryProtocolFlag);
|
810 mike 1.1
811 if (!req)
812 {
813 result = false;
814 goto done;
815 }
816 }
817
818 // Set nameSpace:
|
819 krisbash 1.3 req->nameSpace = Batch_Tcsdup(req->base.base.batch, nameSpace.Str());
820 if (!req->nameSpace)
821 {
822 result = false;
823 goto done;
824 }
|
825 mike 1.1
826 // Pack the instance name into the message's batch.
827 {
828 Result r = InstanceToBatch(
829 instanceName.m_self,
830 NULL,
831 NULL,
|
832 krisbash 1.3 req->base.base.batch,
|
833 mike 1.1 &req->packedInstanceNamePtr,
834 &req->packedInstanceNameSize);
835
836 if (r != MI_RESULT_OK)
837 {
838 result = false;
839 goto done;
840 }
841 }
842
843 // Send the messages:
|
844 krisbash 1.3 Strand_SchedulePost(&strand,&req->base.base);
|
845 mike 1.1
846 done:
847 if (req)
848 DeleteInstanceReq_Release(req);
849
850 return result;
851 }
852
853 bool ClientRep::EnumerateInstancesAsync(
854 const String& nameSpace,
855 const String& className,
856 bool deepInheritance,
857 const String& queryLanguage,
858 const String& queryExpression,
|
859 krisbash 1.3 Uint64 operationId)
|
860 mike 1.1 {
861 EnumerateInstancesReq* req = 0;
862 bool result = true;
863
864 // Fail if not connected.
|
865 krisbash 1.3 if( !protocol || !strand.info.opened )
|
866 mike 1.1 {
867 result = false;
868 goto done;
869 }
870
871 // Create the request message:
872 {
|
873 krisbash 1.3 req = EnumerateInstancesReq_New(operationId, BinaryProtocolFlag);
|
874 mike 1.1
875 if (!req)
876 {
877 result = false;
878 goto done;
879 }
880 }
881
882 // Populate the fields of the request message:
883 {
|
884 krisbash 1.3 req->nameSpace = Batch_Tcsdup(req->base.base.batch, nameSpace.Str());
885 req->className = Batch_Tcsdup(req->base.base.batch, className.Str());
886
887 if (!req->nameSpace || !req->className)
888 {
889 result = false;
890 goto done;
891 }
|
892 mike 1.1
893 if (queryLanguage.GetSize())
894 {
895 req->queryLanguage =
|
896 krisbash 1.3 Batch_Tcsdup(req->base.base.batch, queryLanguage.Str());
897 if (!req->queryLanguage)
898 {
899 result = false;
900 goto done;
901 }
|
902 mike 1.1 }
903
904 if (queryExpression.GetSize())
905 {
906 req->queryExpression =
|
907 krisbash 1.3 Batch_Tcsdup(req->base.base.batch, queryExpression.Str());
908 if (!req->queryExpression)
909 {
910 result = false;
911 goto done;
912 }
|
913 mike 1.1 }
914
915 req->deepInheritance = deepInheritance;
916 }
917
918 // Send the messages:
|
919 krisbash 1.3 Strand_SchedulePost(&strand,&req->base.base);
|
920 mike 1.1
921 done:
922 if (req)
923 EnumerateInstancesReq_Release(req);
924
925 return result;
926 }
927
928 bool ClientRep::InvokeAsync(
929 const String& nameSpace,
930 const DInstance& instanceName,
931 const String& methodName,
932 const DInstance& inParameters,
933 DInstance& outParameters,
|
934 krisbash 1.3 Uint64 operationId)
|
935 mike 1.1 {
936 InvokeReq* req = 0;
937 bool result = true;
938
939 // Fail if not connected.
|
940 krisbash 1.3 if( !protocol || !strand.info.opened )
|
941 mike 1.1 {
942 result = false;
943 goto done;
944 }
945
946 // Create the request message:
947 {
|
948 krisbash 1.3 req = InvokeReq_New(operationId, BinaryProtocolFlag);
|
949 mike 1.1
950 if (!req)
951 {
952 result = false;
953 goto done;
954 }
955 }
956
957 // Set nameSpace:
|
958 krisbash 1.3 req->nameSpace = Batch_Tcsdup(req->base.base.batch, nameSpace.Str());
959 if (!req->nameSpace)
960 {
961 result = false;
962 goto done;
963 }
|
964 mike 1.1
965 // Set className:
|
966 krisbash 1.3 req->className = Batch_Tcsdup(req->base.base.batch,
|
967 mike 1.1 instanceName.GetClassName().Str());
|
968 krisbash 1.3 if (!req->className)
969 {
970 result = false;
971 goto done;
972 }
|
973 mike 1.1
974 // Set methodName:
|
975 krisbash 1.3 req->function = Batch_Tcsdup(req->base.base.batch, methodName.Str());
976 if (!req->function)
977 {
978 result = false;
979 goto done;
980 }
|
981 mike 1.1
982 // Pack instanceName:
983 if (instanceName.Count())
984 {
985 Result r = InstanceToBatch(
986 instanceName.m_self,
987 NULL,
988 NULL,
|
989 krisbash 1.3 req->base.base.batch,
|
990 mike 1.1 &req->packedInstancePtr,
991 &req->packedInstanceSize);
992
993 if (r != MI_RESULT_OK)
994 {
995 result = false;
996 goto done;
997 }
998 }
999
1000 // Pack inParameters:
1001 {
1002 Result r = InstanceToBatch(
1003 inParameters.m_self,
1004 NULL,
1005 NULL,
|
1006 krisbash 1.3 req->base.base.batch,
|
1007 mike 1.1 &req->packedInstanceParamsPtr,
1008 &req->packedInstanceParamsSize);
1009
1010 if (r != MI_RESULT_OK)
1011 {
1012 result = false;
1013 goto done;
1014 }
1015 }
1016
1017 // Send the messages:
|
1018 krisbash 1.3 Strand_SchedulePost(&strand,&req->base.base);
|
1019 mike 1.1
1020 done:
1021 if (req)
1022 InvokeReq_Release(req);
1023
1024 return result;
1025 }
1026
1027 bool ClientRep::AssociatorInstancesAsync(
1028 const String& nameSpace,
1029 const DInstance& instanceName,
1030 const String& assocClass,
1031 const String& resultClass,
1032 const String& role,
1033 const String& resultRole,
|
1034 krisbash 1.3 Uint64& operationId)
|
1035 mike 1.1 {
|
1036 krisbash 1.3 AssociationsOfReq* req = 0;
|
1037 mike 1.1 bool result = true;
1038
1039 // Fail if not connected.
|
1040 krisbash 1.3 if( !protocol || !strand.info.opened )
|
1041 mike 1.1 {
1042 result = false;
1043 goto done;
1044 }
1045
1046 // Create the request message:
1047 {
|
1048 krisbash 1.3 req = AssociationsOfReq_New(operationId, BinaryProtocolFlag, AssociatorsOfReqTag);
|
1049 mike 1.1
1050 if (!req)
1051 {
1052 result = false;
1053 goto done;
1054 }
1055 }
1056
1057 // Set nameSpace:
|
1058 krisbash 1.3 req->nameSpace = Batch_Tcsdup(req->base.base.batch, nameSpace.Str());
1059 if (!req->nameSpace)
1060 {
1061 result = false;
1062 goto done;
1063 }
|
1064 mike 1.1
1065 // Set assocClass:
1066 if (assocClass.GetSize())
|
1067 krisbash 1.3 {
1068 req->assocClass = Batch_Tcsdup(req->base.base.batch, assocClass.Str());
1069 if (!req->assocClass)
1070 {
1071 result = false;
1072 goto done;
1073 }
1074 }
|
1075 mike 1.1
1076 // Set resultClass:
1077 if (resultClass.GetSize())
|
1078 krisbash 1.3 {
1079 req->resultClass = Batch_Tcsdup(req->base.base.batch,resultClass.Str());
1080 if (!req->resultClass)
1081 {
1082 result = false;
1083 goto done;
1084 }
1085 }
|
1086 mike 1.1
1087 // Set role:
1088 if (role.GetSize())
|
1089 krisbash 1.3 {
1090 req->role = Batch_Tcsdup(req->base.base.batch, role.Str());
1091 if (!req->role)
1092 {
1093 result = false;
1094 goto done;
1095 }
1096 }
|
1097 mike 1.1
1098 // Set resultRole:
1099 if (resultRole.GetSize())
|
1100 krisbash 1.3 {
1101 req->resultRole = Batch_Tcsdup(req->base.base.batch, resultRole.Str());
1102 if (!req->resultRole)
1103 {
1104 result = false;
1105 goto done;
1106 }
1107 }
|
1108 mike 1.1
1109 // Pack the instance name into the message's batch.
1110 {
1111 Result r = InstanceToBatch(
1112 instanceName.m_self,
1113 NULL,
1114 NULL,
|
1115 krisbash 1.3 req->base.base.batch,
|
1116 mike 1.1 &req->packedInstancePtr,
1117 &req->packedInstanceSize);
1118
1119 if (r != MI_RESULT_OK)
1120 {
1121 result = false;
1122 goto done;
1123 }
1124 }
1125
1126 // Send the messages:
|
1127 krisbash 1.3 Strand_SchedulePost(&strand,&req->base.base);
|
1128 mike 1.1
1129 done:
1130 if (req)
1131 {
|
1132 krisbash 1.3 AssociationsOfReq_Release(req);
|
1133 mike 1.1 }
1134
1135 return result;
1136 }
1137
1138 bool ClientRep::ReferenceInstancesAsync(
1139 const String& nameSpace,
1140 const DInstance& instanceName,
|
1141 krisbash 1.3 const String& resultClass,
|
1142 mike 1.1 const String& role,
|
1143 krisbash 1.3 Uint64& operationId)
|
1144 mike 1.1 {
|
1145 krisbash 1.3 AssociationsOfReq* req = 0;
|
1146 mike 1.1 bool result = true;
1147
1148 // Fail if not connected.
|
1149 krisbash 1.3 if( !protocol || !strand.info.opened )
|
1150 mike 1.1 {
1151 result = false;
1152 goto done;
1153 }
1154
1155 // Create the request message:
1156 {
|
1157 krisbash 1.3 req = AssociationsOfReq_New(operationId, BinaryProtocolFlag, ReferencesOfReqTag);
|
1158 mike 1.1
1159 if (!req)
1160 {
1161 result = false;
1162 goto done;
1163 }
1164 }
1165
1166 // Set nameSpace:
|
1167 krisbash 1.3 req->nameSpace = Batch_Tcsdup(req->base.base.batch, nameSpace.Str());
1168 if (!req->nameSpace)
1169 {
1170 result = false;
1171 goto done;
1172 }
|
1173 mike 1.1
1174 // Set assocClass:
|
1175 krisbash 1.3 if (resultClass.GetSize())
1176 {
1177 req->resultClass = Batch_Tcsdup(req->base.base.batch, resultClass.Str());
1178 if (!req->resultClass)
1179 {
1180 result = false;
1181 goto done;
1182 }
1183 }
|
1184 mike 1.1
1185 // Set role:
1186 if (role.GetSize())
|
1187 krisbash 1.3 {
1188 req->role = Batch_Tcsdup(req->base.base.batch, role.Str());
1189 if (!req->role)
1190 {
1191 result = false;
1192 goto done;
1193 }
1194 }
|
1195 mike 1.1
1196 // Pack the instance name into the message's batch.
1197 {
1198 Result r = InstanceToBatch(
1199 instanceName.m_self,
1200 NULL,
1201 NULL,
|
1202 krisbash 1.3 req->base.base.batch,
|
1203 mike 1.1 &req->packedInstancePtr,
1204 &req->packedInstanceSize);
1205
1206 if (r != MI_RESULT_OK)
1207 {
1208 result = false;
1209 goto done;
1210 }
1211 }
1212
1213 // Send the messages:
|
1214 krisbash 1.3 Strand_SchedulePost(&strand,&req->base.base);
|
1215 mike 1.1
1216 done:
1217 if (req)
|
1218 krisbash 1.3 AssociationsOfReq_Release(req);
|
1219 mike 1.1
1220 return result;
1221 }
1222
1223 //==============================================================================
|
1224 krisbash 1.3
1225 MI_EXTERN_C void _Client_Post( _In_ Strand* self_, _In_ Message* msg)
1226 {
1227 ClientRep* rep = FromOffset(ClientRep,strand,self_);
1228
1229 trace_Client_Post(
1230 msg,
1231 msg->tag,
1232 MessageName(msg->tag),
1233 msg->operationId );
1234
1235 ClientRep::MessageCallback( rep, msg );
1236
1237 Strand_Ack(self_); // return an Ack to protocol
1238 }
1239
1240 MI_EXTERN_C void _Client_PostControl( _In_ Strand* self_, _In_ Message* msg)
1241 {
1242 ClientRep* rep = FromOffset(ClientRep,strand,self_);
1243 ProtocolEventConnect* eventMsg = (ProtocolEventConnect*)msg;
1244 Handler* handler = rep->handler;
1245 krisbash 1.3
1246 DEBUG_ASSERT( ProtocolEventConnectTag == msg->tag );
1247
1248 if( eventMsg->success )
1249 {
1250 D( printf("==== EventCallback() PROTOCOLEVENT_CONNECT\n"); )
1251 rep->connectState = ClientRep::CONNECTSTATE_CONNECTED;
1252 if (handler)
1253 handler->HandleConnect();
1254 }
1255 else
1256 {
1257 D( printf("==== EventCallback() PROTOCOLEVENT_CONNECT_FAILED\n"); )
1258 if (handler)
1259 handler->HandleConnectFailed();
1260 rep->connectState = ClientRep::CONNECTSTATE_FAILED;
1261 }
1262 }
1263
1264 MI_EXTERN_C void _Client_Ack( _In_ Strand* self )
1265 {
1266 krisbash 1.3 trace_Client_Ack();
1267 // We are not streaming any results, so no need to manage flow control on Ack
1268 }
1269
1270 MI_EXTERN_C void _Client_Cancel( _In_ Strand* self )
1271 {
1272 DEBUG_ASSERT( MI_FALSE ); // not used yet
1273 }
1274
1275 MI_EXTERN_C void _Client_Close( _In_ Strand* self_ )
1276 {
1277 ClientRep* rep = FromOffset(ClientRep,strand,self_);
1278 Handler* handler = rep->handler;
1279
1280 trace_Client_Close();
1281 // most management done by strand implementation
1282
1283 if (handler)
1284 handler->HandleDisconnect();
1285 rep->connectState = ClientRep::CONNECTSTATE_DISCONNECTED;
1286 }
1287 krisbash 1.3
1288 MI_EXTERN_C void _Client_Finish( _In_ Strand* self_ )
1289 {
1290 trace_Client_Finish();
1291 // nothing to do here, (class take care of deleting itself)
1292 }
1293
1294 /*
1295 Object that implements the C++ client endpoint.
1296 It opens an interaction to the binary protocol below
1297 to communicate on a TCP Socket.
1298
1299 Behavior:
1300 - Post just passed the operation to tries to ClientRep::MessageCallback
1301 if that fails it sends the Ack immediately
1302 - Post control is used to notify connected state (connect succeeded/failed)
1303 - Ack does not do anything at this point (as there are no secondary messages)
1304 - Cancel is not used
1305 - Puts it on disconnected state if not there already
1306 - Shutdown:
1307 The Client objects are shutdown/deleted thru the normal
1308 krisbash 1.3 Strand logic (once the interaction is closed).
1309 */
1310 StrandFT _Client_InteractionFT =
1311 {
1312 _Client_Post,
1313 _Client_PostControl,
1314 _Client_Ack,
1315 _Client_Cancel,
1316 _Client_Close,
1317 _Client_Finish,
1318 NULL,
1319 NULL,
1320 NULL,
1321 NULL,
1322 NULL,
1323 NULL
1324 };
1325
1326 //==============================================================================
|
1327 mike 1.1 //
1328 // class Client
1329 //
1330 //==============================================================================
1331
1332 Client::Client(Handler* handler)
1333 {
1334 m_rep = new ClientRep;
1335 m_rep->protocol = 0;
1336 m_rep->connectState = ClientRep::CONNECTSTATE_DISCONNECTED;
1337 m_rep->handler = handler;
|
1338 krisbash 1.3
1339 //Log_OpenStdErr();
1340 //Log_SetLevel(LOG_DEBUG);
1341
1342 Strand_Init( STRAND_DEBUG(OmiClient) &m_rep->strand, &_Client_InteractionFT, STRAND_FLAG_ENTERSTRAND, NULL ); // this is the one that Opens the interaction (not the one that receives the open)
|
1343 mike 1.1 }
1344
1345 Client::~Client()
1346 {
1347 Disconnect();
1348 delete m_rep->handler;
1349 delete m_rep;
1350 }
1351
1352 bool Client::ConnectAsync(
1353 const String& locatorIn,
1354 const String& user,
1355 const String& password)
1356 {
1357 Result r;
1358 bool result = true;
1359 String locator = locatorIn;
1360 char* locator_ = NULL;
1361 char* user_ = NULL;
1362 char* password_ = NULL;
1363
1364 mike 1.1 // Fail if already connected:
1365 if (m_rep->protocol)
1366 {
1367 result = false;
1368 goto done;
1369 }
1370
1371 // Locator defaults to SOCKETFILE:
1372 if (locator.GetSize() == 0)
1373 {
1374 #ifdef CONFIG_POSIX
|
1375 krisbash 1.3 locator = _StrToString(OMI_GetPath(ID_SOCKETFILE));
|
1376 mike 1.1 #else
1377 locator = MI_T("localhost:7777");
1378 #endif
1379 }
1380
1381 // Convert host to 'char' type:
1382 locator_ = _StringToStr(locator);
1383 if (!locator_)
1384 {
1385 goto done;
1386 }
1387 user_ = _StringToStr(user);
1388 if (!user_)
1389 {
1390 goto done;
1391 }
1392 password_ = _StringToStr(password);
1393 if (!password_)
1394 {
1395 goto done;
1396 }
1397 mike 1.1
1398 // Set connection state to pending.
1399 m_rep->connectState = ClientRep::CONNECTSTATE_PENDING;
1400
1401 // Establish connection with server:
1402 {
|
1403 krisbash 1.3 InteractionOpenParams params;
1404 ProtocolSocketAndBase* protocol = NULL;
1405
1406 Strand_OpenPrepare(&m_rep->strand,¶ms,NULL,NULL,MI_TRUE);
1407
1408 r = ProtocolSocketAndBase_New_Connector(
|
1409 mike 1.1 &protocol,
1410 NULL,
1411 locator_,
|
1412 krisbash 1.3 ¶ms,
|
1413 mike 1.1 user_,
|
1414 krisbash 1.3 password_ );
|
1415 mike 1.1
1416 if (r != MI_RESULT_OK)
1417 {
1418 result = false;
1419 goto done;
1420 }
1421
1422 m_rep->protocol = protocol;
1423 }
1424
1425 done:
1426
1427 if (locator_)
1428 delete [] locator_;
1429 if (user_)
1430 delete [] user_;
1431 if (password_)
1432 delete [] password_;
1433 return result;
1434 }
1435
1436 mike 1.1 bool Client::Connect(
1437 const String& locator,
1438 const String& user,
1439 const String& password,
1440 Uint64 timeOutUsec)
1441 {
1442 m_rep->connectState = ClientRep::CONNECTSTATE_PENDING;
1443
1444 if (!ConnectAsync(locator, user, password))
1445 return false;
1446
1447 Uint64 endTime, now;
1448
|
1449 krisbash 1.3 if (PAL_Time(&now) != PAL_TRUE)
|
1450 mike 1.1 return false;
1451
1452 endTime = now + timeOutUsec;
1453
1454 // Wait for connection establishment or timeout.
1455 for (;endTime >= now;)
1456 {
|
1457 krisbash 1.3 Protocol_Run(&m_rep->protocol->internalProtocolBase, SELECT_BASE_TIMEOUT_MSEC * 1000);
|
1458 mike 1.1
1459 if (m_rep->connectState != ClientRep::CONNECTSTATE_PENDING)
1460 break;
1461
|
1462 krisbash 1.3 if (PAL_Time(&now) != PAL_TRUE)
|
1463 mike 1.1 break;
1464 }
1465
1466 if (m_rep->connectState != ClientRep::CONNECTSTATE_CONNECTED)
1467 return false;
1468
1469 return true;
1470 }
1471
1472 bool Client::Disconnect()
1473 {
1474 bool result = true;
1475
1476 // Fail if not connected:
|
1477 krisbash 1.3 if( !m_rep->protocol || !m_rep->strand.info.opened )
|
1478 mike 1.1 {
1479 result = false;
1480 goto done;
1481 }
1482
|
1483 krisbash 1.3 if ( m_rep->strand.info.opened )
1484 {
1485 Strand_ScheduleClose( &m_rep->strand );
1486 Protocol_Run(&m_rep->protocol->internalProtocolBase, SELECT_BASE_TIMEOUT_MSEC * 1000);
1487 }
1488
|
1489 mike 1.1 // Delete the protocol object.
1490 {
|
1491 krisbash 1.3 ProtocolSocketAndBase_ReadyToFinish(m_rep->protocol);
|
1492 mike 1.1
1493 m_rep->protocol = 0;
1494 }
1495
1496 m_rep->connectState = ClientRep::CONNECTSTATE_DISCONNECTED;
1497
1498 done:
1499 return result;
1500 }
1501
1502 bool Client::Connected() const
1503 {
|
1504 krisbash 1.3 return m_rep->protocol && m_rep->strand.info.opened ? true : false;
|
1505 mike 1.1 }
1506
1507 bool Client::Run(Uint64 timeOutUsec)
1508 {
1509 bool result = true;
1510
1511 // Fail if not connected.
|
1512 krisbash 1.3 if (!m_rep->protocol || !m_rep->strand.info.opened)
|
1513 mike 1.1 {
1514 result = false;
1515 goto done;
1516 }
1517
1518 // Process events.
1519 // ATTN: what can this return?
|
1520 krisbash 1.3 Protocol_Run(&m_rep->protocol->internalProtocolBase, timeOutUsec);
|
1521 mike 1.1
1522 done:
1523 return result;
1524 }
1525
1526 bool Client::NoOpAsync(
|
1527 krisbash 1.3 Uint64& operationId)
|
1528 mike 1.1 {
|
1529 krisbash 1.3 operationId = _NextOperationId();
1530 return m_rep->NoOpAsync(operationId);
|
1531 mike 1.1 }
1532
1533 bool Client::GetInstanceAsync(
1534 const String& nameSpace,
1535 const DInstance& instanceName,
|
1536 krisbash 1.3 Uint64& operationId)
|
1537 mike 1.1 {
|
1538 krisbash 1.3 operationId = _NextOperationId();
1539 return m_rep->GetInstanceAsync(nameSpace, instanceName, operationId);
|
1540 mike 1.1 }
1541
1542 bool Client::CreateInstanceAsync(
1543 const String& nameSpace,
1544 const DInstance& instance,
|
1545 krisbash 1.3 Uint64& operationId)
|
1546 mike 1.1 {
|
1547 krisbash 1.3 operationId = _NextOperationId();
1548 return m_rep->CreateInstanceAsync(nameSpace, instance, operationId);
|
1549 mike 1.1 }
1550
1551 bool Client::ModifyInstanceAsync(
1552 const String& nameSpace,
1553 const DInstance& instance,
|
1554 krisbash 1.3 Uint64& operationId)
|
1555 mike 1.1 {
|
1556 krisbash 1.3 operationId = _NextOperationId();
1557 return m_rep->ModifyInstanceAsync(nameSpace, instance, operationId);
|
1558 mike 1.1 }
1559
1560 bool Client::DeleteInstanceAsync(
1561 const String& nameSpace,
1562 const DInstance& instanceName,
|
1563 krisbash 1.3 Uint64& operationId)
|
1564 mike 1.1 {
|
1565 krisbash 1.3 operationId = _NextOperationId();
1566 return m_rep->DeleteInstanceAsync(nameSpace, instanceName, operationId);
|
1567 mike 1.1 }
1568
1569 bool Client::EnumerateInstancesAsync(
1570 const String& nameSpace,
1571 const String& className,
1572 bool deepInheritance,
1573 const String& queryLanguage,
1574 const String& queryExpression,
|
1575 krisbash 1.3 Uint64& operationId)
|
1576 mike 1.1 {
|
1577 krisbash 1.3 operationId = _NextOperationId();
|
1578 mike 1.1 return m_rep->EnumerateInstancesAsync(nameSpace, className,
|
1579 krisbash 1.3 deepInheritance, queryLanguage, queryExpression, operationId);
|
1580 mike 1.1 }
1581
1582 bool Client::InvokeAsync(
1583 const String& nameSpace,
1584 const DInstance& instanceName,
1585 const String& methodName,
1586 const DInstance& inParameters,
1587 DInstance& outParameters,
|
1588 krisbash 1.3 Uint64 operationId)
|
1589 mike 1.1 {
|
1590 krisbash 1.3 operationId = _NextOperationId();
|
1591 mike 1.1 return m_rep->InvokeAsync(nameSpace, instanceName, methodName, inParameters,
|
1592 krisbash 1.3 outParameters, operationId);
|
1593 mike 1.1 }
1594
1595 bool Client::AssociatorInstancesAsync(
1596 const String& nameSpace,
1597 const DInstance& instanceName,
1598 const String& assocClass,
1599 const String& resultClass,
1600 const String& role,
1601 const String& resultRole,
|
1602 krisbash 1.3 Uint64& operationId)
|
1603 mike 1.1 {
|
1604 krisbash 1.3 operationId = _NextOperationId();
|
1605 mike 1.1 return m_rep->AssociatorInstancesAsync(nameSpace, instanceName, assocClass,
|
1606 krisbash 1.3 resultClass, role, resultRole, operationId);
|
1607 mike 1.1 }
1608
1609 bool Client::ReferenceInstancesAsync(
1610 const String& nameSpace,
1611 const DInstance& instanceName,
1612 const String& assocClass,
1613 const String& role,
|
1614 krisbash 1.3 Uint64& operationId)
|
1615 mike 1.1 {
|
1616 krisbash 1.3 operationId = _NextOperationId();
|
1617 mike 1.1 return m_rep->ReferenceInstancesAsync(nameSpace, instanceName, assocClass,
|
1618 krisbash 1.3 role, operationId);
|
1619 mike 1.1 }
1620
1621 bool Client::GetInstance(
1622 const String& nameSpace,
1623 const DInstance& instanceName,
1624 Uint64 timeOutUsec,
1625 DInstance& instance,
1626 Result& result)
1627 {
1628 Handler* oldHandler = m_rep->handler;
|
1629 krisbash 1.3 Uint64 operationId = _NextOperationId();
1630 InstanceHandler handler(oldHandler, operationId, instance);
|
1631 mike 1.1 m_rep->handler = &handler;
1632 bool flag = true;
1633
|
1634 krisbash 1.3 if (!m_rep->GetInstanceAsync(nameSpace, instanceName, operationId))
|
1635 mike 1.1 {
1636 flag = false;
1637 goto done;
1638 }
1639
1640 Uint64 endTime, now;
1641
|
1642 krisbash 1.3 if (PAL_Time(&now) != PAL_TRUE)
|
1643 mike 1.1 return false;
1644
1645 endTime = now + timeOutUsec;
1646
1647 for (;endTime >= now;)
1648 {
|
1649 krisbash 1.3 Protocol_Run(&m_rep->protocol->internalProtocolBase, SELECT_BASE_TIMEOUT_MSEC * 1000);
|
1650 mike 1.1
1651 if (handler.m_state == InstanceHandler::FAILED ||
1652 handler.m_state == InstanceHandler::DONE)
1653 {
1654 break;
1655 }
1656
|
1657 krisbash 1.3 if (PAL_Time(&now) != PAL_TRUE)
|
1658 mike 1.1 break;
1659 }
1660
1661 if (handler.m_state == InstanceHandler::DONE)
1662 result = handler.m_result;
1663 else
1664 flag = false;
1665
1666 done:
1667 m_rep->handler = oldHandler;
1668 return flag;
1669 }
1670
1671 bool Client::CreateInstance(
1672 const String& nameSpace,
1673 const DInstance& instance,
1674 Uint64 timeOutUsec,
1675 DInstance& instanceName,
1676 Result& result)
1677 {
1678 Handler* oldHandler = m_rep->handler;
|
1679 krisbash 1.3 Uint64 operationId = _NextOperationId();
1680 InstanceHandler handler(oldHandler, operationId, instanceName);
|
1681 mike 1.1 m_rep->handler = &handler;
1682 bool flag = true;
1683
|
1684 krisbash 1.3 if (!m_rep->CreateInstanceAsync(nameSpace, instance, operationId))
|
1685 mike 1.1 {
1686 flag = false;
1687 goto done;
1688 }
1689
1690 Uint64 endTime, now;
1691
|
1692 krisbash 1.3 if (PAL_Time(&now) != PAL_TRUE)
|
1693 mike 1.1 return false;
1694
1695 endTime = now + timeOutUsec;
1696
1697 for (;endTime >= now;)
1698 {
|
1699 krisbash 1.3 Protocol_Run(&m_rep->protocol->internalProtocolBase, SELECT_BASE_TIMEOUT_MSEC * 1000);
|
1700 mike 1.1
1701 if (handler.m_state == InstanceHandler::FAILED ||
1702 handler.m_state == InstanceHandler::DONE)
1703 {
1704 break;
1705 }
1706
|
1707 krisbash 1.3 if (PAL_Time(&now) != PAL_TRUE)
|
1708 mike 1.1 break;
1709 }
1710
1711 if (handler.m_state == InstanceHandler::DONE)
1712 result = handler.m_result;
1713 else
1714 flag = false;
1715
1716 done:
1717 m_rep->handler = oldHandler;
1718 return flag;
1719 }
1720
1721 bool Client::ModifyInstance(
1722 const String& nameSpace,
1723 const DInstance& instance,
1724 Uint64 timeOutUsec,
1725 Result& result)
1726 {
1727 Handler* oldHandler = m_rep->handler;
|
1728 krisbash 1.3 Uint64 operationId = _NextOperationId();
1729 ResultHandler handler(oldHandler, operationId);
|
1730 mike 1.1 m_rep->handler = &handler;
1731 bool flag = true;
1732
|
1733 krisbash 1.3 if (!m_rep->ModifyInstanceAsync(nameSpace, instance, operationId))
|
1734 mike 1.1 {
1735 flag = false;
1736 goto done;
1737 }
1738
1739 Uint64 endTime, now;
1740
|
1741 krisbash 1.3 if (PAL_Time(&now) != PAL_TRUE)
|
1742 mike 1.1 return false;
1743
1744 endTime = now + timeOutUsec;
1745
1746 for (;endTime >= now;)
1747 {
|
1748 krisbash 1.3 Protocol_Run(&m_rep->protocol->internalProtocolBase, SELECT_BASE_TIMEOUT_MSEC * 1000);
|
1749 mike 1.1
1750 if (handler.m_state == ResultHandler::FAILED ||
1751 handler.m_state == ResultHandler::DONE)
1752 {
1753 break;
1754 }
1755
|
1756 krisbash 1.3 if (PAL_Time(&now) != PAL_TRUE)
|
1757 mike 1.1 break;
1758 }
1759
1760 if (handler.m_state == ResultHandler::DONE)
1761 result = handler.m_result;
1762 else
1763 flag = false;
1764
1765 done:
1766 m_rep->handler = oldHandler;
1767 return flag;
1768 }
1769
1770 bool Client::DeleteInstance(
1771 const String& nameSpace,
1772 const DInstance& instanceName,
1773 Uint64 timeOutUsec,
1774 Result& result)
1775 {
1776 Handler* oldHandler = m_rep->handler;
|
1777 krisbash 1.3 Uint64 operationId = _NextOperationId();
1778 ResultHandler handler(oldHandler, operationId);
|
1779 mike 1.1 m_rep->handler = &handler;
1780 bool flag = true;
1781
|
1782 krisbash 1.3 if (!m_rep->DeleteInstanceAsync(nameSpace, instanceName, operationId))
|
1783 mike 1.1 {
1784 flag = false;
1785 goto done;
1786 }
1787
1788 Uint64 endTime, now;
1789
|
1790 krisbash 1.3 if (PAL_Time(&now) != PAL_TRUE)
|
1791 mike 1.1 return false;
1792
1793 endTime = now + timeOutUsec;
1794
1795 for (;endTime >= now;)
1796 {
|
1797 krisbash 1.3 Protocol_Run(&m_rep->protocol->internalProtocolBase, SELECT_BASE_TIMEOUT_MSEC * 1000);
|
1798 mike 1.1
1799 if (handler.m_state == ResultHandler::FAILED ||
1800 handler.m_state == ResultHandler::DONE)
1801 {
1802 break;
1803 }
1804
|
1805 krisbash 1.3 if (PAL_Time(&now) != PAL_TRUE)
|
1806 mike 1.1 break;
1807 }
1808
1809 if (handler.m_state == ResultHandler::DONE)
1810 result = handler.m_result;
1811 else
1812 flag = false;
1813
1814 done:
1815 m_rep->handler = oldHandler;
1816 return flag;
1817 }
1818
1819 bool Client::NoOp(Uint64 timeOutUsec)
1820 {
1821 Handler* oldHandler = m_rep->handler;
|
1822 krisbash 1.3 Uint64 operationId = _NextOperationId();
1823 NoOpHandler handler(oldHandler, operationId);
|
1824 mike 1.1 m_rep->handler = &handler;
1825 bool flag = true;
1826
|
1827 krisbash 1.3 if (!m_rep->NoOpAsync(operationId))
|
1828 mike 1.1 {
1829 flag = false;
1830 goto done;
1831 }
1832
1833 Uint64 endTime, now;
1834
|
1835 krisbash 1.3 if (PAL_Time(&now) != PAL_TRUE)
|
1836 mike 1.1 return false;
1837
1838 endTime = now + timeOutUsec;
1839
1840 for (;endTime >= now;)
1841 {
|
1842 krisbash 1.3 Protocol_Run(&m_rep->protocol->internalProtocolBase, SELECT_BASE_TIMEOUT_MSEC * 1000);
|
1843 mike 1.1
1844 if (handler.m_state == NoOpHandler::FAILED ||
1845 handler.m_state == NoOpHandler::DONE)
1846 {
1847 break;
1848 }
1849
|
1850 krisbash 1.3 if (PAL_Time(&now) != PAL_TRUE)
|
1851 mike 1.1 break;
1852 }
1853
1854 if (handler.m_state != NoOpHandler::DONE)
1855 flag = false;
1856
1857 done:
1858 m_rep->handler = oldHandler;
1859 return flag;
1860 }
1861
1862 bool Client::EnumerateInstances(
1863 const String& nameSpace,
1864 const String& className,
1865 bool deepInheritance,
1866 Uint64 timeOutUsec,
1867 Array<DInstance>& instances,
1868 const String& queryLanguage,
1869 const String& queryExpression,
1870 Result& result)
1871 {
1872 mike 1.1 Handler* oldHandler = m_rep->handler;
|
1873 krisbash 1.3 Uint64 operationId = _NextOperationId();
1874 InstancesHandler handler(oldHandler, operationId, instances);
|
1875 mike 1.1 m_rep->handler = &handler;
1876 bool flag = true;
1877
1878 if (!m_rep->EnumerateInstancesAsync(nameSpace, className, deepInheritance,
|
1879 krisbash 1.3 queryLanguage, queryExpression, operationId))
|
1880 mike 1.1 {
1881 flag = false;
1882 goto done;
1883 }
1884
1885 Uint64 endTime, now;
1886
|
1887 krisbash 1.3 if (PAL_Time(&now) != PAL_TRUE)
|
1888 mike 1.1 return false;
1889
1890 endTime = now + timeOutUsec;
1891
1892 for (;endTime >= now;)
1893 {
|
1894 krisbash 1.3 Protocol_Run(&m_rep->protocol->internalProtocolBase, SELECT_BASE_TIMEOUT_MSEC * 1000);
|
1895 mike 1.1
1896 if (handler.m_state == InstancesHandler::FAILED ||
1897 handler.m_state == InstancesHandler::DONE)
1898 {
1899 break;
1900 }
1901
|
1902 krisbash 1.3 if (PAL_Time(&now) != PAL_TRUE)
|
1903 mike 1.1 break;
1904 }
1905
1906 if (handler.m_state == InstancesHandler::DONE)
1907 result = handler.m_result;
1908 else
1909 flag = false;
1910
1911 done:
1912 m_rep->handler = oldHandler;
1913 return flag;
1914 }
1915
1916 bool Client::Invoke(
1917 const String& nameSpace,
1918 const DInstance& instanceName,
1919 const String& methodName,
1920 const DInstance& inParameters,
1921 Uint64 timeOutUsec,
1922 DInstance& outParameters,
1923 Result& result)
1924 mike 1.1 {
1925 Handler* oldHandler = m_rep->handler;
|
1926 krisbash 1.3 Uint64 operationId = _NextOperationId();
1927 InstanceHandler handler(oldHandler, operationId, outParameters);
|
1928 mike 1.1 m_rep->handler = &handler;
1929 bool flag = true;
1930
1931 if (!m_rep->InvokeAsync(nameSpace, instanceName, methodName, inParameters,
|
1932 krisbash 1.3 outParameters, operationId))
|
1933 mike 1.1 {
1934 flag = false;
1935 goto done;
1936 }
1937
1938 Uint64 endTime, now;
1939
|
1940 krisbash 1.3 if (PAL_Time(&now) != PAL_TRUE)
|
1941 mike 1.1 return false;
1942
1943 endTime = now + timeOutUsec;
1944
1945 for (;endTime >= now;)
1946 {
|
1947 krisbash 1.3 Protocol_Run(&m_rep->protocol->internalProtocolBase, SELECT_BASE_TIMEOUT_MSEC * 1000);
|
1948 mike 1.1
1949 if (handler.m_state == InstanceHandler::FAILED ||
1950 handler.m_state == InstanceHandler::DONE)
1951 {
1952 break;
1953 }
1954
|
1955 krisbash 1.3 if (PAL_Time(&now) != PAL_TRUE)
|
1956 mike 1.1 break;
1957 }
1958
1959 if (handler.m_state == InstanceHandler::DONE)
1960 result = handler.m_result;
1961 else
1962 flag = false;
1963
1964 done:
1965 m_rep->handler = oldHandler;
1966 return flag;
1967 }
1968
1969 bool Client::AssociatorInstances(
1970 const String& nameSpace,
1971 const DInstance& instanceName,
1972 const String& assocClass,
1973 const String& resultClass,
1974 const String& role,
1975 const String& resultRole,
1976 Uint64 timeOutUsec,
1977 mike 1.1 Array<DInstance>& instances,
1978 Result& result)
1979 {
1980 Handler* oldHandler = m_rep->handler;
|
1981 krisbash 1.3 Uint64 operationId = _NextOperationId();
1982 InstancesHandler handler(oldHandler, operationId, instances);
|
1983 mike 1.1 m_rep->handler = &handler;
1984 bool flag = true;
1985
1986 if (!m_rep->AssociatorInstancesAsync(nameSpace, instanceName, assocClass,
|
1987 krisbash 1.3 resultClass, role, resultRole, operationId))
|
1988 mike 1.1 {
1989 flag = false;
1990 goto done;
1991 }
1992
1993 Uint64 endTime, now;
1994
|
1995 krisbash 1.3 if (PAL_Time(&now) != PAL_TRUE)
|
1996 mike 1.1 return false;
1997
1998 endTime = now + timeOutUsec;
1999
2000 for (;endTime >= now;)
2001 {
|
2002 krisbash 1.3 Protocol_Run(&m_rep->protocol->internalProtocolBase, SELECT_BASE_TIMEOUT_MSEC * 1000);
|
2003 mike 1.1
2004 if (handler.m_state == InstancesHandler::FAILED ||
2005 handler.m_state == InstancesHandler::DONE)
2006 {
2007 break;
2008 }
2009
|
2010 krisbash 1.3 if (PAL_Time(&now) != PAL_TRUE)
|
2011 mike 1.1 break;
2012 }
2013
2014 if (handler.m_state == InstancesHandler::DONE)
2015 result = handler.m_result;
2016 else
2017 flag = false;
2018
2019 done:
2020 m_rep->handler = oldHandler;
2021 return flag;
2022 }
2023
2024 bool Client::ReferenceInstances(
2025 const String& nameSpace,
2026 const DInstance& instanceName,
2027 const String& assocClass,
2028 const String& role,
2029 Uint64 timeOutUsec,
2030 Array<DInstance>& instances,
2031 Result& result)
2032 mike 1.1 {
2033 Handler* oldHandler = m_rep->handler;
|
2034 krisbash 1.3 Uint64 operationId = _NextOperationId();
2035 InstancesHandler handler(oldHandler, operationId, instances);
|
2036 mike 1.1 m_rep->handler = &handler;
2037 bool flag = true;
2038
2039 if (!m_rep->ReferenceInstancesAsync(nameSpace, instanceName, assocClass,
|
2040 krisbash 1.3 role, operationId))
|
2041 mike 1.1 {
2042 flag = false;
2043 goto done;
2044 }
2045
2046 Uint64 endTime, now;
2047
|
2048 krisbash 1.3 if (PAL_Time(&now) != PAL_TRUE)
|
2049 mike 1.1 return false;
2050
2051 endTime = now + timeOutUsec;
2052
2053 for (;endTime >= now;)
2054 {
|
2055 krisbash 1.3 Protocol_Run(&m_rep->protocol->internalProtocolBase, SELECT_BASE_TIMEOUT_MSEC * 1000);
|
2056 mike 1.1
2057 if (handler.m_state == InstancesHandler::FAILED ||
2058 handler.m_state == InstancesHandler::DONE)
2059 {
2060 break;
2061 }
2062
|
2063 krisbash 1.3 if (PAL_Time(&now) != PAL_TRUE)
|
2064 mike 1.1 break;
2065 }
2066
2067 if (handler.m_state == InstancesHandler::DONE)
2068 result = handler.m_result;
2069 else
2070 flag = false;
2071
2072 done:
2073 m_rep->handler = oldHandler;
2074 return flag;
2075 }
2076
2077 MI_END_NAMESPACE
|
Return to
client.cpp
CVS log
Up to [OMI] / omi / omiclient