?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revert "Use a variable on the stack to not have a temporary in the call"
[ACE_TAO.git] / TAO / orbsvcs / tests / FT_Naming / FaultTolerant / client.cpp
blob9fd2d63703685673549bb6692bbdafef9d6bbcf9
1 //=============================================================================
2 /**
3 * @file client.cpp
4 *
5 * This class implements a CORBA test client for the Fault Tolerant Naming Service.
6 *
7 * @author Rich Seibel <seibel_r@ociweb.com>
8 * @author Phillip LaBanca <labancap@ociweb.com>
9 */
10 //=============================================================================
11
12 #include "TestC.h"
13 #include "test_objectS.h"
14 #include "orbsvcs/CosNamingC.h"
15 #include "orbsvcs/FT_NamingManagerC.h"
16 #include "orbsvcs/Naming/Naming_Server.h"
17 #include "tao/debug.h"
18 #include "tao/Stub.h"
19 #include "ace/Get_Opt.h"
20 #include "ace/OS_NS_stdio.h"
21 #include "ace/OS_NS_unistd.h"
22 #include "orbsvcs/Naming/FaultTolerant/nsgroup_svc.h"
23
24 #include <iostream>
25
26 #if defined (_MSC_VER)
27 # pragma warning (disable : 4250)
28 #endif /* _MSC_VER */
29
30 //==============================================================================
31 //
32 //==============================================================================
33 class My_Test_Object :
34 public virtual POA_Test_Object
35 {
36 public:
37 My_Test_Object (CORBA::Short id = 0);
38 // Constructor.
39
40 ~My_Test_Object ();
41 // Destructor.
42
43 // = Interface implementation accessor methods.
44
45 void id (CORBA::Short id);
46 // Sets id.
47
48 CORBA::Short id ();
49 // Gets id.
50
51 private:
52 short id_;
53 };
54
55 My_Test_Object::My_Test_Object (CORBA::Short id)
56 : id_ (id)
57 {
58 }
59
60 My_Test_Object::~My_Test_Object ()
61 {
62 }
63
64 CORBA::Short
65 My_Test_Object::id ()
66 {
67 return id_;
68 }
69
70 void
71 My_Test_Object::id (CORBA::Short id)
72 {
73 id_ = id;
74 }
75
76 //==============================================================================
77 //
78 //==============================================================================
79 /// Failover Name Test
80 int
81 do_failover_name_test (
82 CORBA::ORB_ptr theOrb,
83 ACE_TCHAR *ns1ref,
84 int c_breadth,
85 int c_depth,
86 int o_breadth);
87
88 /// Failover ObjectGroup Test
89 int
90 do_failover_objectgroup_test (
91 CORBA::ORB_ptr theOrb,
92 ACE_TCHAR *nm1ref,
93 int c_breadth,
94 int c_depth,
95 int o_breadth);
96
97 //==============================================================================
98 //
99 //==============================================================================
100 /// Persistence Name Test
101 int
102 do_persistence_name_test (
103 CORBA::ORB_ptr theOrb,
104 ACE_TCHAR *ns1ref,
105 int c_breadth,
106 int c_depth,
107 int o_breadth,
108 bool validate_only);
109
110 /// Persistence ObjectGroup Test
111 int
112 do_persistence_objectgroup_test (
113 CORBA::ORB_ptr theOrb,
114 ACE_TCHAR *nm1ref,
115 int c_breadth,
116 int c_depth,
117 int o_breadth,
118 bool validate_only);
119
120 //==============================================================================
121 //
122 //==============================================================================
123 /// Equivalence Name Test
124 int
125 do_equivalence_name_test (
126 CORBA::ORB_ptr theOrb,
127 ACE_TCHAR *ns1ref,
128 ACE_TCHAR *ns2ref,
129 int c_breadth,
130 int c_depth,
131 int o_breadth);
132
133 /// Equivalence ObjectGroup Test
134 int
135 do_equivalence_objectgroup_test (
136 CORBA::ORB_ptr theOrb,
137 ACE_TCHAR *nm1ref,
138 ACE_TCHAR *nm2ref,
139 int c_breadth,
140 int c_depth,
141 int o_breadth);
142
143
144 //==============================================================================
145 //
146 //==============================================================================
147 int
148 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
149 {
150 const int RC_SUCCESS = 0;
151 const int RC_ERROR = 1;
152
153 int rc = RC_SUCCESS;
154
155 int c_breadth = 4;
156 int c_depth = 4;
157 int o_breadth = 4;
158
159 ACE_TCHAR *ns1ref = 0;
160 ACE_TCHAR *ns2ref = 0;
161
162 ACE_TCHAR *nm1ref = 0;
163 ACE_TCHAR *nm2ref = 0;
164
165 typedef enum {
166 TT_FAILOVER,
167 TT_PERSISTENCE,
168 TT_EQUIVALENCE
169 } fault_tolerant_test;
170 fault_tolerant_test test_type = TT_FAILOVER;
171
172 typedef enum {
173 TT_INIT,
174 TT_CREATE,
175 TT_VALIDATE
176 } fault_tolerant_test_phase;
177 fault_tolerant_test_phase test_phase = TT_INIT;
178
179 //////////////////////////////////////////////////////////////////////////////
180 // optional
181 //////////////////////////////////////////////////////////////////////////////
182 // -b <breadth of context tree>
183 // -d <depth of context tree>
184 // -o <breadth of object tree>
185 //////////////////////////////////////////////////////////////////////////////
186 // required
187 //////////////////////////////////////////////////////////////////////////////
188 // -p <ior of first name server>
189 // -q <ior of second name server>
190 // -r <ior of first naming service>
191 // -s <ior of second naming service>
192 // --failover run fault tolerant failover test
193 // --persistence run fault tolerant persistence test
194 // --equivalence run fault tolerant equivalence test
195 //////////////////////////////////////////////////////////////////////////////
196 // required with persistance
197 //////////////////////////////////////////////////////////////////////////////
198 // --create run creation test phase
199 // --validate run validation test phase
200
201 try
202 {
203 // Initialize orb
204 CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
205
206 ACE_Get_Opt get_opts (argc, argv, ACE_TEXT ("b:d:o:p:q:r:s:"));
207 int c;
208 int i;
209 get_opts.long_option (ACE_TEXT ("failover"), ACE_Get_Opt::NO_ARG);
210 get_opts.long_option (ACE_TEXT ("persistence"), ACE_Get_Opt::NO_ARG);
211 get_opts.long_option (ACE_TEXT ("equivalence"), ACE_Get_Opt::NO_ARG);
212 get_opts.long_option (ACE_TEXT ("create"), ACE_Get_Opt::NO_ARG);
213 get_opts.long_option (ACE_TEXT ("validate"), ACE_Get_Opt::NO_ARG);
214
215 while ((c = get_opts ()) != -1)
216 switch (c)
217 {
218 case 'b':
219 i = ACE_OS::atoi(get_opts.opt_arg ());
220 if (i<2)
221 {
222 ACE_ERROR((LM_ERROR,
223 ACE_TEXT ("Invalid breadth, must be 2 or more\n")));
224 ACE_OS::exit(RC_ERROR);
225 }
226 c_breadth = i;
227 break;
228 case 'd':
229 i = ACE_OS::atoi(get_opts.opt_arg ());
230 if (i<2)
231 {
232 ACE_ERROR((LM_ERROR,
233 ACE_TEXT ("Invalid depth, must be 2 or more\n")));
234 ACE_OS::exit(RC_ERROR);
235 }
236 c_depth = i;
237 break;
238 case 'o':
239 i = ACE_OS::atoi(get_opts.opt_arg ());
240 if (i<2)
241 {
242 ACE_ERROR((LM_ERROR,
243 ACE_TEXT ("Invalid breadth, must be 2 or more\n")));
244 ACE_OS::exit(RC_ERROR);
245 }
246 o_breadth = i;
247 break;
248 case 'p':
249 ns1ref = get_opts.opt_arg ();
250 break;
251 case 'q':
252 ns2ref = get_opts.opt_arg ();
253 break;
254 case 'r':
255 nm1ref = get_opts.opt_arg ();
256 break;
257 case 's':
258 nm2ref = get_opts.opt_arg ();
259 break;
260 case 0: // A long option was found
261 {
262 const ACE_TCHAR * long_option = get_opts.long_option ();
263 if (ACE_OS::strcmp (long_option,
264 ACE_TEXT ("failover")) == 0)
265 {
266 test_type = TT_FAILOVER;
267 }
268 else if (ACE_OS::strcmp (long_option,
269 ACE_TEXT ("persistence")) == 0)
270 {
271 test_type = TT_PERSISTENCE;
272 }
273 else if (ACE_OS::strcmp (long_option,
274 ACE_TEXT ("equivalence")) == 0)
275 {
276 test_type = TT_EQUIVALENCE;
277 }
278 else if (ACE_OS::strcmp (long_option,
279 ACE_TEXT ("create")) == 0)
280 {
281 test_phase = TT_CREATE;
282 }
283 else if (ACE_OS::strcmp (long_option,
284 ACE_TEXT ("validate")) == 0)
285 {
286 test_phase = TT_VALIDATE;
287 }
288 }
289 break;
290
291 default:
292 ACE_ERROR_RETURN ((LM_ERROR,
293 ACE_TEXT ("Argument %c \n usage: %s")
294 ACE_TEXT (" [-b <breadth of context tree>]")
295 ACE_TEXT (" [-d <depth of context tree>]")
296 ACE_TEXT (" [-o <breadth of object tree>]")
297 ACE_TEXT (" -p <ior of first name server>")
298 ACE_TEXT (" -q <ior of second name server>")
299 ACE_TEXT (" -r <ior of first naming server>")
300 ACE_TEXT (" -s <ior of second naming server>")
301 ACE_TEXT ("\n")),
302 RC_ERROR);
303 }
304
305 switch(test_type) {
306 case TT_FAILOVER:
307
308 if( RC_SUCCESS != do_failover_name_test (
309 orb.in (),
310 ns1ref,
311 c_breadth,
312 c_depth,
313 o_breadth ))
314 {
315 ACE_DEBUG ((LM_DEBUG,
316 ACE_TEXT ("ERROR: Failover Name Test Failed\n")));
317 rc = RC_ERROR;
318 } else {
319 ACE_DEBUG ((LM_DEBUG,
320 ACE_TEXT ("INFO: Failover Name Test OK\n")));
321 }
322
323 if( RC_SUCCESS != do_failover_objectgroup_test (
324 orb.in (),
325 nm1ref,
326 c_breadth,
327 c_depth,
328 o_breadth ))
329 {
330 ACE_DEBUG ((LM_DEBUG,
331 ACE_TEXT ("ERROR: Failover ObjectGroup ")
332 ACE_TEXT ("Test Failed\n")));
333 rc = RC_ERROR;
334 } else {
335 ACE_DEBUG ((LM_DEBUG,
336 ACE_TEXT ("INFO: Failover ObjectGroup Test OK\n")));
337 }
338
339 break;
340
341 case TT_PERSISTENCE:
342
343 switch(test_phase){
344 case TT_CREATE:
345 if (RC_SUCCESS != do_persistence_name_test (
346 orb.in (),
347 ns1ref,
348 c_breadth,
349 c_depth,
350 o_breadth,
351 false ))
352 {
353 ACE_DEBUG ((LM_DEBUG,
354 ACE_TEXT ("ERROR: Persistence Creation Name ")
355 ACE_TEXT ("Test Failed\n")));
356 rc = RC_ERROR;
357 } else {
358 ACE_DEBUG ((LM_DEBUG,
359 ACE_TEXT ("INFO: Persistence Creation Name ")
360 ACE_TEXT ("Test OK\n")));
361 }
362 if (RC_SUCCESS != do_persistence_objectgroup_test(
363 orb.in (),
364 nm1ref,
365 c_breadth,
366 c_depth,
367 o_breadth,
368 false ))
369 {
370 ACE_DEBUG ((LM_DEBUG,
371 ACE_TEXT ("ERROR: Persistence Creation ObjectGroup ")
372 ACE_TEXT ("Test Failed\n")));
373 rc = RC_ERROR;
374 } else {
375 ACE_DEBUG ((LM_DEBUG,
376 ACE_TEXT ("INFO: Persistence Creation ObjectGroup ")
377 ACE_TEXT ("Test OK\n")));
378 }
379 break;
380
381 case TT_VALIDATE:
382 if (RC_SUCCESS != do_persistence_name_test (
383 orb.in (),
384 ns1ref,
385 c_breadth,
386 c_depth,
387 o_breadth,
388 true ))
389 {
390 ACE_DEBUG ((LM_DEBUG,
391 ACE_TEXT ("ERROR: Persistence Validation ")
392 ACE_TEXT ("Name Test Failed\n")));
393 rc = RC_ERROR;
394 } else {
395 ACE_DEBUG ((LM_DEBUG,
396 ACE_TEXT ("INFO: Persistence Validation ")
397 ACE_TEXT ("Name Test OK\n")));
398 }
399
400 if (RC_SUCCESS != do_persistence_objectgroup_test (
401 orb.in (),
402 nm1ref,
403 c_breadth,
404 c_depth,
405 o_breadth,
406 true ))
407 {
408 ACE_DEBUG ((LM_DEBUG,
409 ACE_TEXT ("ERROR: Persistence Validation ")
410 ACE_TEXT ("ObjectGroup Test Failed\n")));
411 rc = RC_ERROR;
412 } else {
413 ACE_DEBUG ((LM_DEBUG,
414 ACE_TEXT ("INFO: Persistence Validation ")
415 ACE_TEXT ("ObjectGroup Test OK\n")));
416 }
417 break;
418
419 case TT_INIT:
420 default:
421 ACE_DEBUG ((LM_DEBUG,
422 ACE_TEXT ("ERROR: Missing Required Persistence ")
423 ACE_TEXT ("Argument [--create|--validate] \n")));
424 rc = RC_ERROR;
425 break;
426 }
427 break;
428
429 case TT_EQUIVALENCE:
430
431 if (RC_SUCCESS != do_equivalence_name_test (
432 orb.in (),
433 ns1ref,
434 ns2ref,
435 c_breadth,
436 c_depth,
437 o_breadth ))
438 {
439 ACE_DEBUG ((LM_DEBUG,
440 ACE_TEXT ("ERROR: Equivalence Name Test\n")));
441 rc = RC_ERROR;
442 } else {
443 ACE_DEBUG ((LM_DEBUG,
444 ACE_TEXT ("INFO: Equivalence Name Test OK\n")));
445 }
446
447 if (RC_SUCCESS != do_equivalence_objectgroup_test(
448 orb.in (),
449 nm1ref,
450 nm2ref,
451 c_breadth,
452 c_depth,
453 o_breadth ))
454 {
455 ACE_DEBUG ((LM_DEBUG,
456 ACE_TEXT ("ERROR: Equivalence ObjectGroup Test\n")));
457 rc = RC_ERROR;
458 } else {
459 ACE_DEBUG ((LM_DEBUG,
460 ACE_TEXT ("INFO: Equivalence ObjectGroup Test OK\n")));
461 }
462 break;
463 }
464 }
465 catch (const CORBA::Exception& ex)
466 {
467 ex._tao_print_exception (
468 ACE_TEXT ("ERROR: Unable to resolve name servers"));
469 return RC_ERROR;
470 }
471
472
473 return rc;
474 }
475
476 //==============================================================================
477 //
478 //==============================================================================
479 /// Failover Name Test
480 int
481 do_failover_name_test (
482 CORBA::ORB_ptr theOrb,
483 ACE_TCHAR *ns1ref,
484 int c_breadth,
485 int c_depth,
486 int o_breadth )
487 {
488 const int RC_SUCCESS = 0;
489 const int RC_ERROR = -1;
490 CosNaming::NamingContext_var root_context_1;
491 int i;
492
493 try {
494 CORBA::ORB_var orb = CORBA::ORB::_duplicate(theOrb);
495
496 if (CORBA::is_nil (orb.in ()))
497 {
498 ACE_ERROR_RETURN (( LM_ERROR,
499 ACE_TEXT ("ERROR: invalid orb\n")),
500 RC_ERROR);
501 }
502
503 if (CORBA::is_nil (ns1ref))
504 {
505 ACE_ERROR_RETURN (( LM_ERROR,
506 ACE_TEXT ("ERROR: invalid ns1\n")),
507 RC_ERROR);
508 }
509
510 CORBA::Object_var ns1obj =
511 orb->string_to_object (ACE_TEXT_ALWAYS_CHAR (ns1ref));
512
513 if (CORBA::is_nil (ns1obj.in ()))
514 {
515 ACE_ERROR_RETURN (( LM_ERROR,
516 ACE_TEXT ("ERROR: invalid ior <%s>\n"),ns1ref),
517 RC_ERROR);
518 }
519
520 root_context_1 = CosNaming::NamingContext::_narrow (ns1obj.in ());
521
522 if (CORBA::is_nil (root_context_1.in ()))
523 {
524 ACE_ERROR_RETURN (( LM_ERROR,
525 ACE_TEXT ("ERROR: invalid ior <%s>\n"),ns1ref),
526 RC_ERROR);
527 }
528
529 }
530 catch (const CORBA::Exception& ex)
531 {
532 ex._tao_print_exception (
533 ACE_TEXT ("ERROR: Unable to resolve name servers"));
534 return RC_ERROR;
535 }
536
537 // Create a bunch of objects in one context
538 // Note: strings to the naming service must be char, not wchar
539 try
540 {
541 // Bind one context level under root.
542 CosNaming::Name level1;
543 level1.length (1);
544 level1[0].id = CORBA::string_dup ("level1_context");
545 CosNaming::NamingContext_var level1_context;
546 level1_context = root_context_1->bind_new_context (level1);
547 ACE_OS::thr_yield ();
548
549 for (i=0; i<o_breadth; i++)
550 {
551 // Instantiate a dummy object and bind it under the new context.
552 My_Test_Object *impl1 = new My_Test_Object (i+1);
553 Test_Object_var obj1 = impl1->_this ();
554
555 impl1->_remove_ref ();
556
557 level1.length (2);
558
559 char wide_name[16];
560 ACE_OS::sprintf (wide_name, "obj_%d", i);
561 level1[1].id = CORBA::string_dup (wide_name);
562
563 root_context_1->bind (level1, obj1.in ());
564 ACE_OS::thr_yield ();
565
566 // See if the newly bound object is available in the
567 // replica
568 try {
569 CORBA::Object_var obj1_on_replica = root_context_1->resolve (level1);
570 }
571 catch (const CosNaming::NamingContext::NotFound& ex)
572 {
573 ex._tao_print_exception (
574 ACE_TEXT ("INFO: Unable to resolve object from replica. Sleeping for a second.\n"));
575
576 // Give it a second to be processed
577 ACE_OS::sleep (1);
578
579 // Try again...
580 try {
581 CORBA::Object_var obj1_on_replica =
582 root_context_1->resolve (level1);
583
584 // We did find the object on the replica, but only after a wait.
585 // This would be caused by a race condition to access the variable.
586 ACE_ERROR ((LM_ERROR,
587 ACE_TEXT ("INFO: Object appeared after a short ")
588 ACE_TEXT ("wait.\n")));
589 }
590 catch (const CosNaming::NamingContext::NotFound& second_ex)
591 {
592 second_ex._tao_print_exception (
593 ACE_TEXT ("ERROR: It really is not there. Failing...\n"));
594 return RC_ERROR;
595 }
596 }
597 }
598 }
599 catch (const CORBA::Exception& ex)
600 {
601 ex._tao_print_exception (
602 ACE_TEXT ("ERROR: Unable to create a lot of objects"));
603 return RC_ERROR;
604 }
605
606 // Create a deep context tree
607 try
608 {
609 CosNaming::NamingContext_var next_context = root_context_1;
610 for (i=0; i<c_depth; i++)
611 {
612 // Bind level1 context under root.
613 CosNaming::Name deep;
614 deep.length (1);
615 char deep_name[16];
616 ACE_OS::sprintf (deep_name, "deep_%d", i);
617 deep[0].id = CORBA::string_dup (deep_name);
618 CosNaming::NamingContext_var deep_context;
619 deep_context = next_context->bind_new_context (deep);
620 ACE_OS::thr_yield ();
621 next_context = deep_context;
622 }
623 }
624 catch (const CORBA::Exception& ex)
625 {
626 ex._tao_print_exception (
627 ACE_TEXT ("ERROR: Unable to create deep context"));
628 return RC_ERROR;
629 }
630
631 // Create a wide context tree
632 try
633 {
634 for (i=0; i<c_breadth; i++)
635 {
636 // Bind all level of context under root.
637 CosNaming::Name wide;
638 wide.length (1);
639 char wide_name[16];
640 ACE_OS::sprintf (wide_name, "wide_%d", i);
641 wide[0].id = CORBA::string_dup (wide_name);
642 CosNaming::NamingContext_var wide_context;
643 wide_context = root_context_1->bind_new_context (wide);
644 ACE_OS::thr_yield ();
645
646 try {
647 // Check if the new context is available in the replica
648 CORBA::Object_var obj1_on_replica = root_context_1->resolve (wide);
649 // Make sure it is a context
650 CosNaming::NamingContext_var nc =
651 CosNaming::NamingContext::_narrow (obj1_on_replica.in ());
652 }
653 catch (const CosNaming::NamingContext::NotFound&)
654 {
655 ACE_DEBUG ((LM_DEBUG,
656 ACE_TEXT ("INFO: Unable to resolve wide context object from ")
657 ACE_TEXT ("replica. Sleeping for a second.\n")));
658
659 ACE_OS::sleep (1);
660
661 // Try again to see if it just was a race condition
662 try {
663 CORBA::Object_var obj1_on_replica = root_context_1->resolve (wide);
664 // We did find the object on the replica, but only after a wait.
665 // This would be caused by a race condition to access the variable.
666 ACE_ERROR (( LM_ERROR,
667 ACE_TEXT ("INFO: Object appeared after a short ")
668 ACE_TEXT ("wait.\n")));
669 }
670 catch (const CosNaming::NamingContext::NotFound& second_ex)
671 {
672 second_ex._tao_print_exception (
673 ACE_TEXT ("ERROR: It really is not there. Failing...\n"));
674 return RC_ERROR;
675 }
676 }
677 }
678 }
679 catch (const CORBA::Exception& ex)
680 {
681 ex._tao_print_exception (
682 ACE_TEXT ("ERROR: Unable to create wide context"));
683 return RC_ERROR;
684 }
685
686 // Delete three selected things, one from each tree
687 try {
688 // Remove the second to last object from the Naming Context
689 CosNaming::Name wide1;
690 wide1.length (2);
691 wide1[0].id = CORBA::string_dup ("level1_context");
692 char wide_name[16];
693 ACE_OS::sprintf (wide_name, "obj_%d", o_breadth-2);
694 wide1[1].id = CORBA::string_dup (wide_name);
695 root_context_1->unbind (wide1);
696 ACE_OS::thr_yield ();
697
698 bool retried = false;
699 // Make sure it is gone from the replica
700 try {
701 CORBA::Object_var obj1_on_replica = root_context_1->resolve (wide1);
702
703 // An exception should be thrown by the above or
704 // there is an error. This means the replica did
705 // not register the loss of the context.
706 ACE_ERROR ((LM_ERROR,
707 ACE_TEXT ("INFO: Unbound deep context not removed from ")
708 ACE_TEXT ("replica. Trying again...\n")));
709 retried = true; // Mark this so it can be reported in catch block.
710
711 obj1_on_replica = root_context_1->resolve (wide1);
712
713 ACE_ERROR_RETURN (( LM_ERROR,
714 ACE_TEXT ("ERROR: Unbound context not removed from ")
715 ACE_TEXT ("on retry\n")),
716 RC_ERROR);
717 }
718 catch (const CosNaming::NamingContext::NotFound&)
719 {
720 // Not on replica --- as it should be.
721 if (retried) // Was found on the retry
722 ACE_ERROR (( LM_ERROR,
723 ACE_TEXT ("INFO: Was removed after short wait.\n")));
724 }
725
726 // Remove the second to last context from the wide root Naming Context
727 CosNaming::Name wide2;
728 wide2.length (1);
729 ACE_OS::sprintf (wide_name, "wide_%d", c_breadth-2);
730 wide2[0].id = CORBA::string_dup (wide_name);
731
732 CORBA::Object_var result_obj_ref = root_context_1->resolve (wide2);
733
734 CosNaming::NamingContext_var result_object =
735 CosNaming::NamingContext::_narrow (result_obj_ref.in ());
736
737 if (CORBA::is_nil (result_object.in ()))
738 {
739 ACE_ERROR_RETURN ((LM_ERROR,
740 ACE_TEXT ("ERROR: Problems with resolving wide context ")
741 ACE_TEXT ("- nil object ref.\n")),
742 RC_ERROR);
743 }
744
745 result_object->destroy();
746 root_context_1->unbind (wide2);
747 ACE_OS::thr_yield ();
748
749 // Remove the last context from the deep Naming Context
750 CosNaming::Name deep;
751 deep.length (c_depth);
752
753 char deep_name[16];
754 for (i=0; i<c_depth; i++)
755 {
756 ACE_OS::sprintf (deep_name, "deep_%d", i);
757 deep[i].id = CORBA::string_dup (deep_name);
758 }
759
760 result_obj_ref = root_context_1->resolve (deep);
761
762 result_object = CosNaming::NamingContext::_narrow (result_obj_ref.in ());
763 if (CORBA::is_nil (result_object.in ()))
764 {
765 ACE_ERROR_RETURN ((LM_ERROR,
766 ACE_TEXT ("ERROR: Problems with resolving deep context ")
767 ACE_TEXT ("- nil object ref.\n")),
768 RC_ERROR);
769 }
770
771 result_object->destroy();
772 root_context_1->unbind (deep);
773 ACE_OS::thr_yield ();
774
775 retried = false;
776 // Make sure it is gone from the replica
777 try {
778 CORBA::Object_var obj1_on_replica = root_context_1->resolve (deep);
779
780 // An exception should be thrown by the above or
781 // there is an error. This means the replica did
782 // not register the loss of the context.
783 ACE_ERROR (( LM_ERROR,
784 ACE_TEXT ("INFO: Unbound deep context not removed from ")
785 ACE_TEXT ("replica. Trying again...\n")));
786
787 retried = true; // Mark this so it can be reported in catch block.
788 obj1_on_replica = root_context_1->resolve (deep);
789
790 ACE_ERROR_RETURN ((LM_ERROR,
791 ACE_TEXT ("ERROR: Unbound context not removed from ")
792 ACE_TEXT ("on retry\n")),
793 RC_ERROR);
794 }
795 catch (const CosNaming::NamingContext::NotFound&)
796 {
797 // Not on replica --- as it should be.
798 if (retried) // Was found on the retry
799 ACE_ERROR (( LM_ERROR,
800 ACE_TEXT ("INFO: Was removed after short wait.\n")));
801 }
802 }
803 catch (const CORBA::Exception& ex)
804 {
805 ex._tao_print_exception (
806 ACE_TEXT ("ERROR: Unable to delete objects"));
807 return RC_ERROR;
808 }
809
810 // Now use the other name server to access 3 objects next to the
811 // deleted objects and the 3 deleted objects
812 try
813 {
814 // Access the last object from the Naming Context
815 CosNaming::Name wide;
816 wide.length (2);
817 wide[0].id = CORBA::string_dup ("level1_context");
818 char wide_name[16];
819 ACE_OS::sprintf (wide_name, "obj_%d", o_breadth-1);
820 wide[1].id = CORBA::string_dup (wide_name);
821 CORBA::Object_var result_obj_ref = root_context_1->resolve (wide);
822 Test_Object_var result_object = Test_Object::_narrow (result_obj_ref.in ());
823 if (CORBA::is_nil (result_object.in ()))
824 {
825 ACE_ERROR_RETURN ((LM_ERROR,
826 ACE_TEXT ("ERROR: Problems with resolving object from ")
827 ACE_TEXT ("redundant server - nil object ref.\n")),
828 RC_ERROR);
829 }
830 }
831 catch (const CORBA::Exception& ex)
832 {
833 ex._tao_print_exception (
834 ACE_TEXT ("ERROR: Unable to resolve object from redundant server"));
835 return RC_ERROR;
836 }
837
838 try
839 {
840 // Access the deleted second to last object from the Naming Context
841 CosNaming::Name wide;
842 wide.length (2);
843 wide[0].id = CORBA::string_dup ("level1_context");
844 char wide_name[16];
845 ACE_OS::sprintf (wide_name, "obj_%d", o_breadth-2);
846 wide[1].id = CORBA::string_dup (wide_name);
847
848 CORBA::Object_var result_obj_ref = root_context_1->resolve (wide);
849
850 ACE_ERROR_RETURN ((LM_ERROR,
851 ACE_TEXT ("ERROR: Problems with resolving object from ")
852 ACE_TEXT ("redundant server - deleted object found.\n")),
853 RC_ERROR);
854 }
855 catch (const CosNaming::NamingContext::NotFound& ex)
856 {
857 // expect exception since the context was deleted.
858 // Make sure the right exception reason is provided.
859 if (ex.why != CosNaming::NamingContext::missing_node)
860 {
861 ACE_ERROR_RETURN ((LM_ERROR,
862 ACE_TEXT ("ERROR: Wrong exception returned during resolve.\n")),
863 RC_ERROR);
864 }
865 }
866 catch (const CORBA::Exception& ex)
867 {
868 ex._tao_print_exception (
869 ACE_TEXT ("ERROR: Wrong exception type returned from resolve.\n"));
870 return RC_ERROR;
871 }
872
873 try
874 {
875 // Access the last context from the wide Naming Context
876 CosNaming::Name wide;
877 wide.length (1);
878 char wide_name[16];
879 ACE_OS::sprintf (wide_name, "wide_%d", c_breadth-1);
880 wide[0].id = CORBA::string_dup (wide_name);
881
882 CORBA::Object_var result_obj_ref = root_context_1->resolve (wide);
883
884 CosNaming::NamingContext_var result_object =
885 CosNaming::NamingContext::_narrow (result_obj_ref.in ());
886
887 if (CORBA::is_nil (result_object.in ()))
888 {
889 ACE_ERROR_RETURN (( LM_ERROR,
890 ACE_TEXT ("ERROR: Problems with resolving wide context from ")
891 ACE_TEXT ("redundant server - nil object ref.\n")),
892 RC_ERROR);
893 }
894 }
895 catch (const CosNaming::NamingContext::NotFound&)
896 {
897 // Expected exception
898 }
899 catch (const CORBA::Exception& ex)
900 {
901 ex._tao_print_exception ( ACE_TEXT ("ERROR: Unexpected Exception received.\n"));
902 return RC_ERROR;
903 }
904
905 try
906 {
907 // Access the deleted second to last object from the Naming Context
908 CosNaming::Name wide;
909 wide.length (2);
910 char wide_name[16];
911 ACE_OS::sprintf (wide_name, "wide_%d", c_breadth-2);
912 wide[0].id = CORBA::string_dup (wide_name);
913
914 CORBA::Object_var result_obj_ref = root_context_1->resolve (wide);
915
916 ACE_ERROR_RETURN ((LM_ERROR,
917 ACE_TEXT ("ERROR: Problems with resolving wide context from ")
918 ACE_TEXT ("redundant server - deleted object found.\n")),
919 RC_ERROR);
920 }
921 catch (const CosNaming::NamingContext::NotFound&)
922 {
923 // Expected exception
924 }
925 catch (const CORBA::Exception& ex)
926 {
927 ex._tao_print_exception ( ACE_TEXT ("ERROR: Unexpected Exception received.\n"));
928 return RC_ERROR;
929 }
930
931 try
932 {
933 // Access the deleted last context from the deep Naming Context
934 CosNaming::Name deep;
935 deep.length (c_depth);
936 char deep_name[16];
937 for (i=0; i<c_depth; i++)
938 {
939 ACE_OS::sprintf (deep_name, "deep_%d", i);
940 deep[i].id = CORBA::string_dup (deep_name);
941 }
942
943 CORBA::Object_var result_obj_ref = root_context_1->resolve (deep);
944
945 ACE_ERROR_RETURN ((LM_ERROR,
946 ACE_TEXT ("ERROR: Problems with resolving deep context from ")
947 ACE_TEXT ("redundant server - deleted object found.\n")),
948 RC_ERROR);
949 }
950 catch (const CosNaming::NamingContext::NotFound&)
951 {
952 // Expected exception
953 }
954 catch (const CORBA::Exception& ex)
955 {
956 ex._tao_print_exception (
957 ACE_TEXT ("ERROR: Unexpected Exception received resolving ")
958 ACE_TEXT ("deep cxt from redundant server.\n"));
959 return RC_ERROR;
960 }
961
962 try
963 {
964 // Access the second to last object from the Naming Context
965 CosNaming::Name deep;
966 deep.length (c_depth-1);
967 char deep_name[16];
968 for (i=0; i<c_depth-1; i++)
969 {
970 ACE_OS::sprintf (deep_name, "deep_%d", i);
971 deep[i].id = CORBA::string_dup (deep_name);
972 }
973
974 CORBA::Object_var result_obj_ref =
975 root_context_1->resolve (deep);
976
977 CosNaming::NamingContext_var result_object =
978 CosNaming::NamingContext::_narrow (result_obj_ref.in ());
979
980 if (CORBA::is_nil (result_object.in ()))
981 {
982 ACE_ERROR_RETURN ((LM_ERROR,
983 ACE_TEXT ("ERROR: Problems with resolving deep context from ")
984 ACE_TEXT ("redundant server - nil object ref.\n")),
985 RC_ERROR);
986 }
987 }
988 catch (const CORBA::Exception& ex)
989 {
990 ex._tao_print_exception (
991 ACE_TEXT ("ERROR: Unable to resolve deep context from redundant server"));
992 return RC_ERROR;
993 }
994
995 return RC_SUCCESS;
996 }
997
998 /// Failover ObjectGroup Test
999 int
1000 do_failover_objectgroup_test (
1001 CORBA::ORB_ptr theOrb,
1002 ACE_TCHAR *nm1ref,
1003 int c_breadth,
1004 int c_depth,
1005 int o_breadth )
1006 {
1007 ACE_UNUSED_ARG (c_breadth);
1008 ACE_UNUSED_ARG (c_depth);
1009 ACE_UNUSED_ARG (o_breadth);
1010
1011 const int RC_SUCCESS = 0;
1012 const int RC_ERROR = -1;
1013
1014 FT_Naming::NamingManager_var naming_manager_1;
1015
1016 try {
1017 CORBA::ORB_var orb = CORBA::ORB::_duplicate(theOrb);
1018 if (CORBA::is_nil (orb.in ()))
1019 {
1020 ACE_ERROR_RETURN (( LM_ERROR,
1021 ACE_TEXT ("ERROR: invalid orb\n")),
1022 RC_ERROR);
1023 }
1024
1025 if (CORBA::is_nil (nm1ref))
1026 {
1027 ACE_ERROR_RETURN (( LM_ERROR,
1028 ACE_TEXT ("ERROR: invalid nm1\n")),
1029 RC_ERROR);
1030 }
1031
1032 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("INFO: nm1ref: %s\n"), nm1ref));
1033
1034 CORBA::Object_var nm1obj =
1035 orb->string_to_object (ACE_TEXT_ALWAYS_CHAR (nm1ref));
1036
1037 if (CORBA::is_nil (nm1obj.in ()))
1038 {
1039 ACE_ERROR_RETURN (( LM_ERROR,
1040 ACE_TEXT ("ERROR: invalid ior <%s>\n"),nm1ref),
1041 RC_ERROR);
1042 }
1043
1044 naming_manager_1 = FT_Naming::NamingManager::_narrow (nm1obj.in ());
1045 if (CORBA::is_nil (naming_manager_1.in ()))
1046 {
1047 ACE_ERROR_RETURN (( LM_ERROR,
1048 ACE_TEXT ("ERROR: invalid ior <%s>\n"),nm1ref),
1049 RC_ERROR);
1050 }
1051
1052 NS_group_svc svc;
1053
1054 if (RC_SUCCESS != svc.set_orb (theOrb))
1055 {
1056 ACE_ERROR_RETURN (( LM_ERROR,
1057 ACE_TEXT ("ERROR: invalid orb\n")),
1058 RC_ERROR);
1059 }
1060
1061 if (RC_SUCCESS != svc.set_naming_manager (naming_manager_1.in ()))
1062 {
1063 ACE_ERROR_RETURN (( LM_ERROR,
1064 ACE_TEXT ("ERROR: invalid ior <%s>\n"),nm1ref),
1065 RC_ERROR);
1066 }
1067
1068
1069 const ACE_TCHAR * test_group = ACE_TEXT ("test_group");
1070 const ACE_TCHAR * policy = ACE_TEXT ("round");
1071
1072 if (RC_SUCCESS != svc.group_create (test_group, policy))
1073 {
1074 ACE_ERROR_RETURN (( LM_ERROR,
1075 ACE_TEXT ("ERROR: unable to create %s\n"),test_group),
1076 RC_ERROR);
1077 }
1078
1079 if (false == svc.group_exist(test_group))
1080 {
1081 ACE_ERROR_RETURN (( LM_ERROR,
1082 ACE_TEXT ("ERROR: Object Group Not Found In Repository\n")),
1083 RC_ERROR);
1084 } else {
1085 ACE_DEBUG (( LM_DEBUG,
1086 ACE_TEXT ("INFO: Object Group Found In Repository\n")));
1087 }
1088
1089
1090 }
1091 catch (const CORBA::Exception& ex)
1092 {
1093 ex._tao_print_exception (
1094 ACE_TEXT ("ERROR: Unable to resolve name manager servers"));
1095 return RC_ERROR;
1096 }
1097
1098 return RC_SUCCESS;
1099 }
1100
1101
1102 //==============================================================================
1103 //
1104 //==============================================================================
1105 /// Persistence Name Test
1106 int
1107 do_persistence_name_test (
1108 CORBA::ORB_ptr theOrb,
1109 ACE_TCHAR *ns1ref,
1110 int c_breadth,
1111 int c_depth,
1112 int o_breadth,
1113 bool validate_only)
1114 {
1115 const int RC_ERROR = -1;
1116 const int RC_SUCCESS = 0;
1117 CosNaming::NamingContext_var root_context_1;
1118 int i;
1119
1120 try {
1121 CORBA::ORB_var orb = CORBA::ORB::_duplicate(theOrb);
1122
1123 if (CORBA::is_nil (orb.in () ))
1124 {
1125 ACE_ERROR_RETURN (( LM_ERROR,
1126 ACE_TEXT ("ERROR: invalid orb\n")),
1127 RC_ERROR);
1128 }
1129
1130 if (CORBA::is_nil (ns1ref))
1131 {
1132 ACE_ERROR_RETURN (( LM_ERROR,
1133 ACE_TEXT ("ERROR: invalid ns1\n")),
1134 RC_ERROR);
1135 }
1136
1137 CORBA::Object_var ns1obj =
1138 orb->string_to_object (ACE_TEXT_ALWAYS_CHAR (ns1ref));
1139
1140 if (CORBA::is_nil (ns1obj.in ()))
1141 {
1142 ACE_ERROR_RETURN (( LM_ERROR,
1143 ACE_TEXT ("ERROR: invalid ior <%s>\n"),ns1ref),
1144 RC_ERROR);
1145 }
1146
1147 root_context_1 = CosNaming::NamingContext::_narrow (ns1obj.in ());
1148
1149 if (CORBA::is_nil (root_context_1.in ()))
1150 {
1151 ACE_ERROR_RETURN (( LM_ERROR,
1152 ACE_TEXT ("ERROR: invalid ior <%s>\n"),ns1ref),
1153 RC_ERROR);
1154 }
1155 }
1156 catch (const CORBA::Exception& ex)
1157 {
1158 ex._tao_print_exception (ACE_TEXT ("ERROR: Unable to resolve name servers"));
1159 return RC_ERROR;
1160 }
1161
1162 // Create a bunch of objects in one context
1163 // Note: strings to the naming service must be char, not wchar
1164 try
1165 {
1166 // Bind one context level under root.
1167 CosNaming::Name level1;
1168 level1.length (1);
1169 level1[0].id = CORBA::string_dup ("level1_context");
1170
1171 if( false == validate_only ) {
1172 CosNaming::NamingContext_var level1_context;
1173 level1_context = root_context_1->bind_new_context (level1);
1174 ACE_OS::thr_yield ();
1175 }
1176
1177 for (i=0; i<o_breadth; i++)
1178 {
1179 // Instantiate a dummy object and bind it under the new context.
1180 My_Test_Object *impl1 = new My_Test_Object (i+1);
1181 Test_Object_var obj1 = impl1->_this ();
1182 impl1->_remove_ref ();
1183
1184 level1.length (2);
1185 char wide_name[16];
1186 ACE_OS::sprintf (wide_name, "obj_%d", i);
1187 level1[1].id = CORBA::string_dup (wide_name);
1188
1189 if( false == validate_only ) {
1190 root_context_1->bind (level1, obj1.in ());
1191 ACE_OS::thr_yield ();
1192 }
1193
1194
1195 // See if the newly bound object is available in the repository
1196 try {
1197 CORBA::Object_var obj1_on_replica = root_context_1->resolve (level1);
1198 }
1199 catch (const CosNaming::NamingContext::NotFound& ex)
1200 {
1201 ex._tao_print_exception (
1202 ACE_TEXT ("ERROR: Unable to resolve object from repository. Sleeping for a second.\n"));
1203
1204 ACE_OS::sleep (1);
1205
1206 // Try again...
1207 try {
1208 CORBA::Object_var obj1_on_replica = root_context_1->resolve (level1);
1209 // We did find the object on the repository, but only after a wait.
1210 // This would be caused by a race condition to access the variable.
1211 ACE_ERROR ((LM_ERROR,
1212 ACE_TEXT ("INFO: Object appeared after a short wait.\n")));
1213 }
1214 catch (const CosNaming::NamingContext::NotFound& second_ex)
1215 {
1216 second_ex._tao_print_exception (
1217 ACE_TEXT ("ERROR: It really is not there. Failing...\n"));
1218 return RC_ERROR;
1219 }
1220 }
1221 }
1222 }
1223 catch (const CORBA::Exception& ex)
1224 {
1225 ex._tao_print_exception (
1226 ACE_TEXT ("ERROR: Unable to create or validate a lot of objects"));
1227
1228 return RC_ERROR;
1229 }
1230
1231 if( false == validate_only ) {
1232 // Create a deep context tree
1233 try
1234 {
1235 CosNaming::NamingContext_var next_context = root_context_1;
1236 for (i=0; i<c_depth; i++)
1237 {
1238 // Bind level1 context under root.
1239 CosNaming::Name deep;
1240 deep.length (1);
1241 char deep_name[16];
1242 ACE_OS::sprintf (deep_name, "deep_%d", i);
1243 deep[0].id = CORBA::string_dup (deep_name);
1244
1245 CosNaming::NamingContext_var deep_context;
1246 deep_context = next_context->bind_new_context (deep);
1247 ACE_OS::thr_yield ();
1248 next_context = deep_context;
1249 }
1250 }
1251 catch (const CORBA::Exception& ex)
1252 {
1253 ex._tao_print_exception (ACE_TEXT ("ERROR: Unable to create deep context"));
1254 return RC_ERROR;
1255 }
1256 }
1257
1258 // Create a wide context tree
1259 try
1260 {
1261 for (i=0; i<c_breadth; i++)
1262 {
1263 // Bind all level of context under root.
1264 CosNaming::Name wide;
1265 wide.length (1);
1266 char wide_name[16];
1267 ACE_OS::sprintf (wide_name, "wide_%d", i);
1268 wide[0].id = CORBA::string_dup (wide_name);
1269
1270 if( false == validate_only ) {
1271 CosNaming::NamingContext_var wide_context;
1272 wide_context = root_context_1->bind_new_context (wide);
1273 ACE_OS::thr_yield ();
1274 }
1275
1276 try {
1277 // Check if the new context is available in the repository
1278 CORBA::Object_var obj1_on_replica =
1279 root_context_1->resolve (wide);
1280
1281 // Make sure it is a context
1282 CosNaming::NamingContext_var nc =
1283 CosNaming::NamingContext::_narrow (obj1_on_replica.in ());
1284 }
1285 catch (const CosNaming::NamingContext::NotFound&)
1286 {
1287 ACE_DEBUG ((LM_DEBUG,
1288 ACE_TEXT ("INFO: Unable to resolve wide context object from ")
1289 ACE_TEXT ("repository. Sleeping for a second.\n")));
1290
1291 ACE_OS::sleep (1);
1292
1293 // Try again to see if it just was a race condition
1294 try {
1295 CORBA::Object_var obj1_on_replica = root_context_1->resolve (wide);
1296 // We did find the object on the replica, but only after a wait.
1297 // This would be caused by a race condition to access the variable.
1298 ACE_ERROR (( LM_ERROR,
1299 ACE_TEXT ("INFO: Object appeared after a short ")
1300 ACE_TEXT ("wait.\n")));
1301 }
1302 catch (const CosNaming::NamingContext::NotFound& second_ex)
1303 {
1304 second_ex._tao_print_exception (
1305 ACE_TEXT ("ERROR: It really is not there. Failing...\n"));
1306 return RC_ERROR;
1307 }
1308 }
1309 }
1310 }
1311 catch (const CORBA::Exception& ex)
1312 {
1313 ex._tao_print_exception (
1314 ACE_TEXT ("ERROR: Unable to create or validate wide context"));
1315 return RC_ERROR;
1316 }
1317
1318 return RC_SUCCESS;
1319 }
1320
1321
1322 /// Persistence ObjectGroup Test
1323 int
1324 do_persistence_objectgroup_test (
1325 CORBA::ORB_ptr theOrb,
1326 ACE_TCHAR *nm1ref,
1327 int c_breadth,
1328 int c_depth,
1329 int o_breadth,
1330 bool validate_only)
1331 {
1332 ACE_UNUSED_ARG (c_breadth);
1333 ACE_UNUSED_ARG (c_depth);
1334 ACE_UNUSED_ARG (o_breadth);
1335
1336 const int RC_ERROR = -1;
1337 const int RC_SUCCESS = 0;
1338
1339 FT_Naming::NamingManager_var naming_manager_1;
1340
1341 try {
1342 CORBA::ORB_var orb = CORBA::ORB::_duplicate(theOrb);
1343
1344 if (CORBA::is_nil (orb.in ()))
1345 {
1346 ACE_ERROR_RETURN (( LM_ERROR,
1347 ACE_TEXT ("ERROR: invalid orb\n")),
1348 RC_ERROR);
1349 }
1350
1351 if (CORBA::is_nil (nm1ref))
1352 {
1353 ACE_ERROR_RETURN (( LM_ERROR,
1354 ACE_TEXT ("ERROR: invalid nm1\n")),
1355 RC_ERROR);
1356 }
1357
1358 //ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("nm1ref: %s\n"), nm1ref));
1359
1360 CORBA::Object_var nm1obj =
1361 orb->string_to_object (ACE_TEXT_ALWAYS_CHAR (nm1ref));
1362
1363 if (CORBA::is_nil (nm1obj.in ()))
1364 {
1365 ACE_ERROR_RETURN (( LM_ERROR,
1366 ACE_TEXT ("ERROR: invalid ior <%s>\n"),nm1ref),
1367 RC_ERROR);
1368 }
1369
1370 naming_manager_1 = FT_Naming::NamingManager::_narrow (nm1obj.in ());
1371 if (CORBA::is_nil (naming_manager_1.in ()))
1372 {
1373 ACE_ERROR_RETURN (( LM_ERROR,
1374 ACE_TEXT ("ERROR: invalid ior <%s>\n"),nm1ref),
1375 RC_ERROR);
1376 }
1377
1378 NS_group_svc group_svc;
1379
1380 if( RC_SUCCESS != group_svc.set_orb (theOrb) )
1381 {
1382 ACE_ERROR_RETURN (( LM_ERROR,
1383 ACE_TEXT ("ERROR: invalid orb\n")),
1384 RC_ERROR);
1385 }
1386
1387 if( RC_SUCCESS != group_svc.set_naming_manager (naming_manager_1.in ()) )
1388 {
1389 ACE_ERROR_RETURN (( LM_ERROR,
1390 ACE_TEXT ("ERROR: invalid ior <%s>\n"),nm1ref),
1391 RC_ERROR);
1392 }
1393
1394 /// get BasicGroup member object and verify that it reports the same location
1395 const ACE_TCHAR * basic_group_name = ACE_TEXT ("BasicGroup");
1396
1397 if (false == group_svc.group_exist(basic_group_name))
1398 {
1399 ACE_ERROR_RETURN (( LM_ERROR,
1400 ACE_TEXT ("ERROR: Object Group %s Not Found In Repository\n"),
1401 basic_group_name),
1402 RC_ERROR);
1403 } else {
1404 ACE_DEBUG (( LM_DEBUG,
1405 ACE_TEXT ("INFO: Object Group %s Found In Repository\n"),
1406 basic_group_name));
1407 }
1408
1409 try
1410 {
1411 PortableGroup::ObjectGroup_var group_var =
1412 naming_manager_1->get_object_group_ref_from_name (
1413 ACE_TEXT_ALWAYS_CHAR (basic_group_name));
1414
1415 PortableGroup::Locations_var locations =
1416 naming_manager_1->locations_of_members (group_var.in());
1417
1418 for (unsigned int i = 0; i < locations->length(); ++i)
1419 {
1420 const PortableGroup::Location & loc = locations[i];
1421 if (loc.length() > 0) {
1422 ACE_DEBUG (( LM_DEBUG,
1423 ACE_TEXT ("INFO: validating group member %C\n"),
1424 loc[0].id.in()));
1425
1426 try
1427 {
1428 PortableGroup::Location location_name (1);
1429 location_name.length (1);
1430 location_name[0].id = CORBA::string_dup(loc[0].id.in());
1431
1432 CORBA::Object_var ior_var =
1433 naming_manager_1->get_member_ref (group_var.in(), location_name);
1434
1435 // Narrow it to a Basic object
1436 Test::Basic_var basic = Test::Basic::_narrow (ior_var.in ());
1437 if (CORBA::is_nil (basic.in ()))
1438 {
1439 ACE_ERROR_RETURN ((LM_ERROR,
1440 ACE_TEXT ("ERROR: Unable to narrow from member ior from %C\n"),
1441 loc[0].id.in()),
1442 RC_ERROR);
1443 }
1444
1445 try
1446 {
1447 CORBA::String_var the_string = basic->get_string ();
1448
1449 ACE_DEBUG (( LM_DEBUG,
1450 ACE_TEXT ("INFO: object group member at %C reports ")
1451 ACE_TEXT ("%C\n"),
1452 loc[0].id.in(),
1453 the_string.in ()));
1454
1455 if ( ACE_OS::strcmp (the_string.in (), loc[0].id.in()) != 0 ) {
1456 ACE_ERROR_RETURN ((LM_ERROR,
1457 ACE_TEXT ("ERROR: object group member at %C reports %C\n\n"),
1458 loc[0].id.in(),
1459 the_string.in ()),
1460 RC_ERROR);
1461 }
1462 }
1463 catch (const CORBA::Exception& ex)
1464 {
1465 ex._tao_print_exception ("ERROR: invoking get_string on Basic object.\n");
1466 return RC_ERROR;
1467 }
1468 }
1469 catch (const PortableGroup::MemberNotFound&)
1470 {
1471 ACE_ERROR_RETURN ((LM_ERROR,
1472 ACE_TEXT ("ERROR: Unable to find member location %C\n"),
1473 loc[0].id.in()),
1474 RC_ERROR);
1475 }
1476 }
1477 }
1478
1479 std::string member_data_file ("member.dat");
1480
1481 // Test persisting group modification in first pass and reading
1482 // the persistent data in the second pass.
1483 // This is done by removal of a group member in first pass and
1484 // then adding it back in the second, validation, pass,
1485 // verifying that member count is what it was before the removal.
1486 // This is tracked by saving member data to a file
1487 // in the first pass and then reading it in the second pass.
1488
1489 if (!validate_only)
1490 {
1491 try
1492 {
1493 PortableGroup::Locations_var locations =
1494 naming_manager_1->locations_of_members (group_var.in());
1495 const PortableGroup::Location & loc = locations.inout ()[0];
1496 unsigned int num_locations = locations->length();
1497
1498 PortableGroup::Location location_name (1);
1499 location_name.length (1);
1500 location_name[0].id = CORBA::string_dup(loc[0].id.in());
1501
1502 CORBA::Object_var ior_var =
1503 naming_manager_1->get_member_ref (group_var.in(), location_name);
1504
1505 // Narrow it to a Basic object
1506 Test::Basic_var basic = Test::Basic::_narrow (ior_var.in ());
1507 if (CORBA::is_nil (basic.in ()))
1508 {
1509 ACE_ERROR_RETURN ((LM_ERROR,
1510 ACE_TEXT ("ERROR: Unable to narrow from ")
1511 ACE_TEXT ("member ior from %C\n"),
1512 loc[0].id.in()),
1513 RC_ERROR);
1514 }
1515 group_var =
1516 naming_manager_1->remove_member (group_var.in(),
1517 location_name);
1518
1519 // Save data for the removed member
1520 CORBA::String_var member_str = theOrb->object_to_string(basic.in ());
1521 std::ofstream out(member_data_file.c_str ());
1522 out << num_locations << std::endl;
1523 out << loc[0].id.in () << std::endl;
1524 out << member_str.in() << std::endl;
1525 }
1526 catch (const PortableGroup::ObjectGroupNotFound&)
1527 {
1528 ACE_ERROR_RETURN ((LM_ERROR,
1529 ACE_TEXT ("ERROR: Unable to find group %C\n"),
1530 basic_group_name),
1531 RC_ERROR);
1532 }
1533 catch (const CORBA::Exception&)
1534 {
1535 ACE_ERROR_RETURN ((LM_ERROR,
1536 ACE_TEXT ("ERROR: Unable to remove members ")
1537 ACE_TEXT ("for group %C\n"),
1538 basic_group_name),
1539 RC_ERROR);
1540 }
1541 } else {
1542 try
1543 {
1544 // Read in member data
1545 std::ifstream in (member_data_file.c_str ());
1546 unsigned int num_locations;
1547 in >> num_locations;
1548 std::string location_str;
1549 in >> location_str;
1550 std::string member_ior;
1551 in >> member_ior;
1552
1553 if (!in.good ())
1554 {
1555 ACE_ERROR_RETURN ((LM_ERROR,
1556 ACE_TEXT ("ERROR: Unable to read member data ")
1557 ACE_TEXT ("from file %C\n"),
1558 member_data_file.c_str ()),
1559 RC_ERROR);
1560 }
1561
1562 CORBA::Object_var member =
1563 theOrb->string_to_object(member_ior.c_str ());
1564 PortableGroup::Location location_name (1);
1565 location_name.length (1);
1566 location_name[0].id = CORBA::string_dup(location_str.c_str ());
1567 PortableGroup::ObjectGroup_var group_var =
1568 naming_manager_1->get_object_group_ref_from_name
1569 (ACE_TEXT_ALWAYS_CHAR (basic_group_name));
1570
1571 // Add back member
1572 group_var =
1573 naming_manager_1->add_member (group_var.in (),
1574 location_name,
1575 member.in ());
1576 PortableGroup::Locations_var locations =
1577 naming_manager_1->locations_of_members (group_var.in ());
1578
1579 // Verify number of locations was what it was before removing/adding
1580 if (locations->length () != num_locations)
1581 {
1582 ACE_ERROR ((LM_ERROR,
1583 ACE_TEXT ("ERROR: Expected %d members but got %d ")
1584 ACE_TEXT ("instead\n"),
1585 num_locations, locations->length ()));
1586 }
1587
1588 // Verify data wasn't corrupt so still can still get
1589 // group information
1590 FT_Naming::GroupNames_var group_names =
1591 naming_manager_1->groups (FT_Naming::ROUND_ROBIN);
1592 if (group_names->length () == 0)
1593 {
1594 ACE_ERROR ((LM_ERROR,
1595 ACE_TEXT ("ERROR: No group names found")));
1596 }
1597 }
1598 catch (const CORBA::Exception& ex)
1599 {
1600 ex._tao_print_exception ("CORBA::Exception caught:");
1601 ACE_ERROR_RETURN ((LM_ERROR,
1602 ACE_TEXT ("ERROR: Unable to remove member for group %C\n"),
1603 basic_group_name),
1604 RC_ERROR);
1605 }
1606 }
1607
1608 }
1609 catch (const PortableGroup::ObjectGroupNotFound&)
1610 {
1611 ACE_ERROR_RETURN ((LM_ERROR,
1612 ACE_TEXT ("ERROR: Unable to find group %C\n"),
1613 basic_group_name),
1614 RC_ERROR);
1615 }
1616 catch (const CORBA::Exception&)
1617 {
1618 ACE_ERROR_RETURN ((LM_ERROR,
1619 ACE_TEXT ("ERROR: Unable to list members for group %C\n"),
1620 basic_group_name),
1621 RC_ERROR);
1622 }
1623
1624 }
1625 catch (const CORBA::Exception& ex)
1626 {
1627 ex._tao_print_exception (
1628 ACE_TEXT ("ERROR: Unable To Resolve Name Manager Servers"));
1629 return RC_ERROR;
1630 }
1631
1632 return RC_SUCCESS;
1633 }
1634
1635 //==============================================================================
1636 //
1637 //==============================================================================
1638 /// Equivalence Name Test
1639 int
1640 do_equivalence_name_test (
1641 CORBA::ORB_ptr theOrb,
1642 ACE_TCHAR *ns1ref,
1643 ACE_TCHAR *ns2ref,
1644 int c_breadth,
1645 int c_depth,
1646 int o_breadth)
1647 {
1648 const int RC_SUCCESS = 0;
1649 const int RC_ERROR = -1;
1650
1651 CosNaming::NamingContext_var root_context_1;
1652 CosNaming::NamingContext_var root_context_2;
1653 int i;
1654
1655 try {
1656 CORBA::ORB_var orb = CORBA::ORB::_duplicate(theOrb);
1657
1658 if (CORBA::is_nil (orb.in ()))
1659 {
1660 ACE_ERROR_RETURN (( LM_ERROR,
1661 ACE_TEXT ("ERROR: invalid orb\n")),
1662 RC_ERROR);
1663 }
1664
1665 if (CORBA::is_nil (ns1ref))
1666 {
1667 ACE_ERROR_RETURN (( LM_ERROR,
1668 ACE_TEXT ("ERROR: invalid ns1\n")),
1669 RC_ERROR);
1670 }
1671
1672 if (CORBA::is_nil (ns2ref))
1673 {
1674 ACE_ERROR_RETURN (( LM_ERROR,
1675 ACE_TEXT ("ERROR: invalid ns2\n")),
1676 RC_ERROR);
1677 }
1678
1679 CORBA::Object_var ns1obj =
1680 orb->string_to_object (ACE_TEXT_ALWAYS_CHAR (ns1ref));
1681
1682 CORBA::Object_var ns2obj =
1683 orb->string_to_object (ACE_TEXT_ALWAYS_CHAR (ns2ref));
1684
1685 if (CORBA::is_nil (ns1obj.in ()))
1686 {
1687 ACE_ERROR_RETURN (( LM_ERROR,
1688 ACE_TEXT ("ERROR: invalid ior <%s>\n"),ns1ref),
1689 RC_ERROR);
1690 }
1691
1692 if (CORBA::is_nil (ns2obj.in ()))
1693 {
1694 ACE_ERROR_RETURN (( LM_ERROR,
1695 ACE_TEXT ("ERROR: invalid ior <%s>\n"),ns2ref),
1696 RC_ERROR);
1697 }
1698
1699 root_context_1 = CosNaming::NamingContext::_narrow (ns1obj.in ());
1700 root_context_2 = CosNaming::NamingContext::_narrow (ns2obj.in ());
1701
1702 if (CORBA::is_nil (root_context_1.in ()))
1703 {
1704 ACE_ERROR_RETURN (( LM_ERROR,
1705 ACE_TEXT ("ERROR: invalid ior <%s>\n"),ns1ref),
1706 RC_ERROR);
1707 }
1708
1709 if (CORBA::is_nil (root_context_2.in ()))
1710 {
1711 ACE_ERROR_RETURN (( LM_ERROR,
1712 ACE_TEXT ("ERROR: invalid ior <%s>\n"),ns2ref),
1713 RC_ERROR);
1714 }
1715
1716 /// Make sure the two naming manager references point to different objects
1717 if ( true == root_context_1->_stubobj ()->is_equivalent (
1718 root_context_2.in ()))
1719 {
1720 ACE_ERROR_RETURN (( LM_ERROR,
1721 ACE_TEXT ("ERROR: ns1ref is equivalent to ns2ref\n")),
1722 RC_ERROR);
1723 }
1724
1725 ACE_DEBUG ((LM_DEBUG,
1726 ACE_TEXT ("INFO: ns1ref is not equivalent to ns2ref\n")));
1727
1728 int ns1_count =
1729 root_context_1->_stubobj ()->base_profiles ().profile_count ();
1730
1731 int ns2_count =
1732 root_context_2->_stubobj ()->base_profiles ().profile_count ();
1733
1734
1735 ACE_DEBUG ((LM_DEBUG,
1736 ACE_TEXT ("INFO: ns1ref profile count: %d\n"),
1737 ns1_count));
1738
1739 ACE_DEBUG ((LM_DEBUG,
1740 ACE_TEXT ("INFO: ns2ref profile count: %d\n"),
1741 ns2_count));
1742 }
1743 catch (const CORBA::Exception& ex)
1744 {
1745 ex._tao_print_exception (ACE_TEXT ("ERROR: Unable to resolve name servers"));
1746 return RC_ERROR;
1747 }
1748
1749 // Create a bunch of objects in one context
1750 // Note: strings to the naming service must be char, not wchar
1751 try
1752 {
1753 // Bind one context level under root.
1754 CosNaming::Name level1;
1755 level1.length (1);
1756 level1[0].id = CORBA::string_dup ("level1_context");
1757 CosNaming::NamingContext_var level1_context;
1758 level1_context = root_context_1->bind_new_context (level1);
1759 ACE_OS::thr_yield ();
1760
1761 for (i=0; i<o_breadth; i++)
1762 {
1763 // Instantiate a dummy object and bind it under the new context.
1764 My_Test_Object *impl1 = new My_Test_Object (i+1);
1765 Test_Object_var obj1 = impl1->_this ();
1766 impl1->_remove_ref ();
1767
1768 level1.length (2);
1769 char wide_name[16];
1770 ACE_OS::sprintf (wide_name, "obj_%d", i);
1771 level1[1].id = CORBA::string_dup (wide_name);
1772 root_context_1->bind (level1, obj1.in ());
1773 ACE_OS::thr_yield ();
1774
1775 // See if the newly bound object is available in the
1776 // replica
1777 try {
1778 CORBA::Object_var obj1_on_replica = root_context_2->resolve (level1);
1779 }
1780 catch (const CosNaming::NamingContext::NotFound& )
1781 {
1782 ACE_DEBUG ((LM_INFO,
1783 "INFO: Unable to resolve object from replica. "
1784 "Sleeping for a second.\n"));
1785
1786 ACE_OS::sleep (1);
1787
1788 // Try again...
1789 try {
1790 CORBA::Object_var obj1_on_replica = root_context_2->resolve (level1);
1791 // We did find the object on the replica, but only after a wait.
1792 // This would be caused by a race condition to access the variable.
1793 ACE_ERROR ((LM_ERROR,
1794 ACE_TEXT ("INFO: Object appeared after a short ")
1795 ACE_TEXT ("wait.\n")));
1796 }
1797 catch (const CosNaming::NamingContext::NotFound& second_ex)
1798 {
1799 second_ex._tao_print_exception (
1800 ACE_TEXT ("ERROR: It really is not there. Failing...\n"));
1801 return RC_ERROR;
1802 }
1803 }
1804 }
1805 }
1806 catch (const CORBA::Exception& ex)
1807 {
1808 ex._tao_print_exception (
1809 ACE_TEXT ("ERROR: Unable to create a lot of objects"));
1810 return RC_ERROR;
1811 }
1812
1813 // Create a deep context tree
1814 try
1815 {
1816 CosNaming::NamingContext_var next_context = root_context_1;
1817 for (i=0; i<c_depth; i++)
1818 {
1819 // Bind level1 context under root.
1820 CosNaming::Name deep;
1821 deep.length (1);
1822 char deep_name[16];
1823 ACE_OS::sprintf (deep_name, "deep_%d", i);
1824 deep[0].id = CORBA::string_dup (deep_name);
1825 CosNaming::NamingContext_var deep_context;
1826 deep_context = next_context->bind_new_context (deep);
1827 ACE_OS::thr_yield ();
1828 next_context = deep_context;
1829 }
1830 }
1831 catch (const CORBA::Exception& ex)
1832 {
1833 ex._tao_print_exception (
1834 ACE_TEXT ("ERROR: Unable to create deep context"));
1835 return RC_ERROR;
1836 }
1837
1838 // Create a wide context tree
1839 try
1840 {
1841 for (i=0; i<c_breadth; i++)
1842 {
1843 // Bind all level of context under root.
1844 CosNaming::Name wide;
1845 wide.length (1);
1846 char wide_name[16];
1847 ACE_OS::sprintf (wide_name, "wide_%d", i);
1848 wide[0].id = CORBA::string_dup (wide_name);
1849 CosNaming::NamingContext_var wide_context;
1850 wide_context = root_context_1->bind_new_context (wide);
1851 ACE_OS::thr_yield ();
1852
1853 try {
1854 // Check if the new context is available in the replica
1855 CORBA::Object_var obj1_on_replica =
1856 root_context_2->resolve (wide);
1857
1858 // Make sure it is a context
1859 CosNaming::NamingContext_var nc =
1860 CosNaming::NamingContext::_narrow (obj1_on_replica.in ());
1861 }
1862 catch (const CosNaming::NamingContext::NotFound&)
1863 {
1864 ACE_DEBUG ((LM_DEBUG,
1865 ACE_TEXT ("INFO: Unable to resolve wide context object from ")
1866 ACE_TEXT ("replica. Sleeping for a second.\n")));
1867
1868 ACE_OS::sleep (1);
1869
1870 // Try again to see if it just was a race condition
1871 try {
1872 CORBA::Object_var obj1_on_replica =
1873 root_context_2->resolve (wide);
1874
1875 // We did find the object on the replica, but only after a wait.
1876 // This would be caused by a race condition to access the variable.
1877 ACE_ERROR ((LM_ERROR,
1878 ACE_TEXT ("INFO: Object appeared after a ")
1879 ACE_TEXT ("short wait.\n")));
1880 }
1881 catch (const CosNaming::NamingContext::NotFound& second_ex)
1882 {
1883 second_ex._tao_print_exception (
1884 ACE_TEXT ("ERROR: It really is not there. Failing...\n"));
1885 return RC_ERROR;
1886 }
1887 }
1888 }
1889 }
1890 catch (const CORBA::Exception& ex)
1891 {
1892 ex._tao_print_exception (
1893 ACE_TEXT ("ERROR: Unable to create wide context"));
1894 return RC_ERROR;
1895 }
1896
1897 // Delete three selected things, one from each tree
1898 try {
1899 // Remove the second to last object from the Naming Context
1900 CosNaming::Name wide1;
1901 wide1.length (2);
1902
1903 wide1[0].id = CORBA::string_dup ("level1_context");
1904
1905 char wide_name[16];
1906 ACE_OS::sprintf (wide_name, "obj_%d", o_breadth-2);
1907 wide1[1].id = CORBA::string_dup (wide_name);
1908 root_context_1->unbind (wide1);
1909 ACE_OS::thr_yield ();
1910
1911 bool retried = false;
1912 // Make sure it is gone from the replica
1913 try {
1914 CORBA::Object_var obj1_on_replica = root_context_2->resolve (wide1);
1915
1916 // An exception should be thrown by the above or
1917 // there is an error. This means the replica did
1918 // not register the loss of the context.
1919 ACE_ERROR (( LM_ERROR,
1920 ACE_TEXT ("INFO: Unbound deep context not removed from ")
1921 ACE_TEXT ("replica. Trying again...\n")));
1922
1923 retried = true; // Mark this so it can be reported in catch block.
1924 obj1_on_replica = root_context_2->resolve (wide1);
1925
1926 ACE_ERROR_RETURN (( LM_ERROR,
1927 ACE_TEXT ("ERROR: Unbound context not removed from ")
1928 ACE_TEXT ("on retry\n")),
1929 RC_ERROR);
1930 }
1931 catch (const CosNaming::NamingContext::NotFound&)
1932 {
1933 // Not on replica --- as it should be.
1934 if (retried) // Was found on the retry
1935 ACE_ERROR ((LM_ERROR,
1936 ACE_TEXT ("INFO: Was removed after short wait.\n")));
1937 }
1938
1939 // Remove the second to last context from the wide root Naming Context
1940 CosNaming::Name wide2;
1941 wide2.length (1);
1942 ACE_OS::sprintf (wide_name, "wide_%d", c_breadth-2);
1943 wide2[0].id = CORBA::string_dup (wide_name);
1944
1945 CORBA::Object_var result_obj_ref = root_context_1->resolve (wide2);
1946
1947 CosNaming::NamingContext_var result_object =
1948 CosNaming::NamingContext::_narrow (result_obj_ref.in ());
1949
1950 if (CORBA::is_nil (result_object.in ()))
1951 {
1952 ACE_ERROR_RETURN (( LM_ERROR,
1953 ACE_TEXT ("ERROR: Problems with resolving wide")
1954 ACE_TEXT (" context - nil object ref.\n")),
1955 RC_ERROR);
1956 }
1957
1958 result_object->destroy();
1959 root_context_1->unbind (wide2);
1960 ACE_OS::thr_yield ();
1961
1962 // Remove the last context from the deep Naming Context
1963 CosNaming::Name deep;
1964 deep.length (c_depth);
1965 char deep_name[16];
1966 for (i=0; i<c_depth; i++)
1967 {
1968 ACE_OS::sprintf (deep_name, "deep_%d", i);
1969 deep[i].id = CORBA::string_dup (deep_name);
1970 }
1971 result_obj_ref = root_context_1->resolve (deep);
1972 result_object = CosNaming::NamingContext::_narrow (result_obj_ref.in ());
1973 if (CORBA::is_nil (result_object.in ()))
1974 {
1975 ACE_ERROR_RETURN ((LM_ERROR,
1976 ACE_TEXT ("ERROR: Problems with resolving deep")
1977 ACE_TEXT (" context - nil object ref.\n")),
1978 RC_ERROR);
1979 }
1980 result_object->destroy();
1981 root_context_1->unbind (deep);
1982 ACE_OS::thr_yield ();
1983
1984 retried = false;
1985 // Make sure it is gone from the replica
1986 try {
1987 CORBA::Object_var obj1_on_replica = root_context_2->resolve (deep);
1988
1989 // An exception should be thrown by the above or
1990 // there is an error. This means the replica did
1991 // not register the loss of the context.
1992 ACE_ERROR (( LM_ERROR,
1993 ACE_TEXT ("INFO: Unbound deep context not removed from")
1994 ACE_TEXT ("replica. Trying again...\n")));
1995
1996 retried = true; // Mark this so it can be reported in catch block.
1997 obj1_on_replica = root_context_2->resolve (deep);
1998
1999 ACE_ERROR_RETURN (( LM_ERROR,
2000 ACE_TEXT ("ERROR: Unbound context not removed from")
2001 ACE_TEXT (" on retry\n")),
2002 RC_ERROR);
2003 }
2004 catch (const CosNaming::NamingContext::NotFound&)
2005 {
2006 // Not on replica --- as it should be.
2007 if (retried) // Was found on the retry
2008 ACE_ERROR (( LM_ERROR,
2009 ACE_TEXT ("INFO: Was removed after short wait.\n")));
2010 }
2011 }
2012 catch (const CORBA::Exception& ex)
2013 {
2014 ex._tao_print_exception (
2015 ACE_TEXT ("ERROR: Unable to delete objects"));
2016 return RC_ERROR;
2017 }
2018
2019 // Now use the other name server to access 3 objects next to the
2020 // deleted objects and the 3 deleted objects
2021 try
2022 {
2023 // Access the last object from the Naming Context
2024 CosNaming::Name wide;
2025 wide.length (2);
2026 wide[0].id = CORBA::string_dup ("level1_context");
2027 char wide_name[16];
2028 ACE_OS::sprintf (wide_name, "obj_%d", o_breadth-1);
2029 wide[1].id = CORBA::string_dup (wide_name);
2030 CORBA::Object_var result_obj_ref = root_context_2->resolve (wide);
2031 Test_Object_var result_object = Test_Object::_narrow (result_obj_ref.in ());
2032
2033 if (CORBA::is_nil (result_object.in ()))
2034 {
2035 ACE_ERROR_RETURN ((LM_ERROR,
2036 ACE_TEXT ("ERROR: Problems with resolving object ")
2037 ACE_TEXT ("from redundant server ")
2038 ACE_TEXT ("- nil object ref.\n")),
2039 RC_ERROR);
2040 }
2041 }
2042 catch (const CORBA::Exception& ex)
2043 {
2044 ex._tao_print_exception (
2045 ACE_TEXT ("ERROR: Unable to resolve object from redundant server"));
2046 return RC_ERROR;
2047 }
2048
2049 try
2050 {
2051 // Access the deleted second to last object from the Naming Context
2052 CosNaming::Name wide;
2053 wide.length (2);
2054 wide[0].id = CORBA::string_dup ("level1_context");
2055 char wide_name[16];
2056 ACE_OS::sprintf (wide_name, "obj_%d", o_breadth-2);
2057 wide[1].id = CORBA::string_dup (wide_name);
2058
2059 CORBA::Object_var result_obj_ref = root_context_2->resolve (wide);
2060
2061 ACE_ERROR_RETURN ((LM_ERROR,
2062 ACE_TEXT ("ERROR: Problems with resolving object from ")
2063 ACE_TEXT ("redundant server - deleted object found.\n")),
2064 RC_ERROR);
2065 }
2066 catch (const CosNaming::NamingContext::NotFound& ex)
2067 {
2068 // expect exception since the context was deleted.
2069 // Make sure the right exception reason is provided.
2070 if (ex.why != CosNaming::NamingContext::missing_node)
2071 ACE_ERROR_RETURN (( LM_ERROR,
2072 ACE_TEXT ("ERROR: Wrong exception returned during ")
2073 ACE_TEXT ("resolve.\n")),
2074 RC_ERROR);
2075 }
2076 catch (const CORBA::Exception& ex)
2077 {
2078 ex._tao_print_exception (
2079 ACE_TEXT ("ERROR: Wrong exception type returned from resolve.\n"));
2080 return RC_ERROR;
2081 }
2082
2083 try
2084 {
2085 // Access the last context from the wide Naming Context
2086 CosNaming::Name wide;
2087 wide.length (1);
2088 char wide_name[16];
2089 ACE_OS::sprintf (wide_name, "wide_%d", c_breadth-1);
2090 wide[0].id = CORBA::string_dup (wide_name);
2091 CORBA::Object_var result_obj_ref = root_context_2->resolve (wide);
2092
2093 CosNaming::NamingContext_var result_object =
2094 CosNaming::NamingContext::_narrow (result_obj_ref.in ());
2095
2096 if (CORBA::is_nil (result_object.in ()))
2097 {
2098 ACE_ERROR_RETURN ((LM_ERROR,
2099 ACE_TEXT ("ERROR: Problems with resolving wide ")
2100 ACE_TEXT ("context from redundant server ")
2101 ACE_TEXT ("- nil object ref.\n")),
2102 RC_ERROR);
2103 }
2104 }
2105 catch (const CosNaming::NamingContext::NotFound&)
2106 {
2107 // Expected exception
2108 }
2109 catch (const CORBA::Exception& ex)
2110 {
2111 ex._tao_print_exception ( ACE_TEXT ("ERROR: Unexpected Exception ")
2112 ACE_TEXT ("received.\n"));
2113 return RC_ERROR;
2114 }
2115
2116 try
2117 {
2118 // Access the deleted second to last object from the Naming Context
2119 CosNaming::Name wide;
2120 wide.length (2);
2121 char wide_name[16];
2122 ACE_OS::sprintf (wide_name, "wide_%d", c_breadth-2);
2123 wide[0].id = CORBA::string_dup (wide_name);
2124 CORBA::Object_var result_obj_ref = root_context_2->resolve (wide);
2125
2126 ACE_ERROR_RETURN ((LM_ERROR,
2127 ACE_TEXT ("ERROR: Problems with resolving wide context ")
2128 ACE_TEXT ("from redundant server ")
2129 ACE_TEXT ("- deleted object found.\n")),
2130 RC_ERROR);
2131 }
2132 catch (const CosNaming::NamingContext::NotFound&)
2133 {
2134 // Expected exception
2135 }
2136 catch (const CORBA::Exception& ex)
2137 {
2138 ex._tao_print_exception ( ACE_TEXT ("ERROR: Unexpected Exception ")
2139 ACE_TEXT ("received.\n"));
2140 return RC_ERROR;
2141 }
2142
2143 try
2144 {
2145 // Access the deleted last context from the deep Naming Context
2146 CosNaming::Name deep;
2147 deep.length (c_depth);
2148 char deep_name[16];
2149 for (i=0; i<c_depth; i++)
2150 {
2151 ACE_OS::sprintf (deep_name, "deep_%d", i);
2152 deep[i].id = CORBA::string_dup (deep_name);
2153 }
2154 CORBA::Object_var result_obj_ref = root_context_1->resolve (deep);
2155
2156 ACE_ERROR_RETURN ((LM_ERROR,
2157 ACE_TEXT ("ERROR: Problems with resolving deep context ")
2158 ACE_TEXT ("from redundant server ")
2159 ACE_TEXT ("- deleted object found.\n")),
2160 RC_ERROR);
2161 }
2162 catch (const CosNaming::NamingContext::NotFound&)
2163 {
2164 // Expected exception
2165 }
2166 catch (const CORBA::Exception& ex)
2167 {
2168 ex._tao_print_exception (
2169 ACE_TEXT ("ERROR: Unexpected Exception received resolving ")
2170 ACE_TEXT ("deep cxt from redundant server.\n"));
2171 return RC_ERROR;
2172 }
2173
2174 try
2175 {
2176 // Access the second to last object from the Naming Context
2177 CosNaming::Name deep;
2178 deep.length (c_depth-1);
2179 char deep_name[16];
2180 for (i=0; i<c_depth-1; i++)
2181 {
2182 ACE_OS::sprintf (deep_name, "deep_%d", i);
2183 deep[i].id = CORBA::string_dup (deep_name);
2184 }
2185 CORBA::Object_var result_obj_ref = root_context_1->resolve (deep);
2186
2187 CosNaming::NamingContext_var result_object =
2188 CosNaming::NamingContext::_narrow (result_obj_ref.in ());
2189
2190 if (CORBA::is_nil (result_object.in ()))
2191 {
2192 ACE_ERROR_RETURN ((LM_ERROR,
2193 ACE_TEXT ("ERROR: Problems with resolving deep ")
2194 ACE_TEXT ("context from redundant server ")
2195 ACE_TEXT ("- nil object ref.\n")),
2196 RC_ERROR);
2197 }
2198 }
2199 catch (const CORBA::Exception& ex)
2200 {
2201 ex._tao_print_exception (
2202 ACE_TEXT ("ERROR: Unable to resolve deep context from redundant server."));
2203 return RC_ERROR;
2204 }
2205
2206 return RC_SUCCESS;
2207 }
2208
2209
2210 /// Equivalence ObjectGroup Test
2211 int
2212 do_equivalence_objectgroup_test (
2213 CORBA::ORB_ptr theOrb,
2214 ACE_TCHAR *nm1ref,
2215 ACE_TCHAR *nm2ref,
2216 int c_breadth,
2217 int c_depth,
2218 int o_breadth )
2219 {
2220 ACE_UNUSED_ARG (c_breadth);
2221 ACE_UNUSED_ARG (c_depth);
2222 ACE_UNUSED_ARG (o_breadth);
2223
2224 const int RC_SUCCESS = 0;
2225 const int RC_ERROR = -1;
2226 int error_count = 0;
2227
2228
2229 FT_Naming::NamingManager_var naming_manager_1;
2230 FT_Naming::NamingManager_var naming_manager_2;
2231
2232 try {
2233 CORBA::ORB_var orb = CORBA::ORB::_duplicate(theOrb);
2234 if (CORBA::is_nil (orb.in ()))
2235 {
2236 ACE_ERROR_RETURN (( LM_ERROR,
2237 ACE_TEXT ("ERROR: invalid orb\n")),
2238 RC_ERROR);
2239 }
2240
2241 if (CORBA::is_nil (nm1ref))
2242 {
2243 ACE_ERROR_RETURN (( LM_ERROR,
2244 ACE_TEXT ("ERROR: invalid nm1\n")),
2245 RC_ERROR);
2246 }
2247
2248 ACE_DEBUG (( LM_DEBUG,
2249 ACE_TEXT ("INFO: nm1ref: %s\n"),
2250 nm1ref));
2251
2252 CORBA::Object_var nm1obj =
2253 orb->string_to_object (ACE_TEXT_ALWAYS_CHAR (nm1ref));
2254
2255 if (CORBA::is_nil (nm1obj.in ()))
2256 {
2257 ACE_ERROR_RETURN (( LM_ERROR,
2258 ACE_TEXT ("ERROR: invalid ior <%s>\n"),
2259 nm1ref),
2260 RC_ERROR);
2261 }
2262
2263 naming_manager_1 = FT_Naming::NamingManager::_narrow (nm1obj.in ());
2264 if (CORBA::is_nil (naming_manager_1.in ()))
2265 {
2266 ACE_ERROR_RETURN (( LM_ERROR,
2267 ACE_TEXT ("ERROR: invalid ior <%s>\n"),
2268 nm1ref),
2269 RC_ERROR);
2270 }
2271
2272 if (CORBA::is_nil (nm2ref))
2273 {
2274 ACE_ERROR_RETURN (( LM_ERROR,
2275 ACE_TEXT ("ERROR: invalid nm2\n")),
2276 RC_ERROR);
2277 }
2278
2279 ACE_DEBUG (( LM_DEBUG,
2280 ACE_TEXT ("INFO: nm2ref: %s\n"),
2281 nm2ref));
2282
2283 CORBA::Object_var nm2obj =
2284 orb->string_to_object (ACE_TEXT_ALWAYS_CHAR (nm2ref));
2285
2286 if (CORBA::is_nil (nm2obj.in ()))
2287 {
2288 ACE_ERROR_RETURN (( LM_ERROR,
2289 ACE_TEXT ("ERROR: invalid ior <%s>\n"),
2290 nm2ref),
2291 RC_ERROR);
2292 }
2293
2294 naming_manager_2 = FT_Naming::NamingManager::_narrow (nm2obj.in ());
2295
2296 if (CORBA::is_nil (naming_manager_2.in ()))
2297 {
2298 ACE_ERROR_RETURN (( LM_ERROR,
2299 ACE_TEXT ("ERROR: invalid ior <%s>\n"),
2300 nm2ref),
2301 RC_ERROR);
2302 }
2303
2304 /// Make sure the two naming manager references point to different objects
2305 if ( true == naming_manager_1->_stubobj ()->is_equivalent (
2306 naming_manager_2.in ()))
2307 {
2308 ACE_ERROR_RETURN (( LM_ERROR,
2309 ACE_TEXT ("ERROR: nm1ref is equivalent to nm2ref\n")),
2310 RC_ERROR);
2311 }
2312
2313 ACE_DEBUG ((LM_DEBUG,
2314 ACE_TEXT ("INFO: nm1ref is not equivalent to nm2ref\n")));
2315 int nm1_count =
2316 naming_manager_1->_stubobj ()->base_profiles ().profile_count ();
2317
2318 int nm2_count =
2319 naming_manager_2->_stubobj ()->base_profiles ().profile_count ();
2320
2321
2322 ACE_DEBUG ((LM_DEBUG,
2323 ACE_TEXT ("INFO: nm1ref profile count: %d\n"),
2324 nm1_count));
2325
2326 ACE_DEBUG ((LM_DEBUG,
2327 ACE_TEXT ("INFO: nm2ref profile count: %d\n"),
2328 nm2_count));
2329
2330
2331 /// Setup 1st NS_group_svc with 1st Naming Manager
2332 NS_group_svc svc1;
2333 if (RC_SUCCESS != svc1.set_orb (theOrb))
2334 {
2335 ACE_ERROR_RETURN (( LM_ERROR,
2336 ACE_TEXT ("ERROR: invalid orb\n")),
2337 RC_ERROR);
2338 }
2339
2340 if (RC_SUCCESS != svc1.set_naming_manager (naming_manager_1.in ()))
2341 {
2342 ACE_ERROR_RETURN (( LM_ERROR,
2343 ACE_TEXT ("ERROR: invalid ior <%s>\n"),
2344 nm1ref),
2345 RC_ERROR);
2346 }
2347
2348 /// Setup 2nd NS_group_svc with 2nd Naming Manager
2349 NS_group_svc svc2;
2350 if (RC_SUCCESS != svc2.set_orb (theOrb))
2351 {
2352 ACE_ERROR_RETURN (( LM_ERROR,
2353 ACE_TEXT ("ERROR: invalid orb\n")),
2354 RC_ERROR);
2355 }
2356
2357 if (RC_SUCCESS != svc2.set_naming_manager (naming_manager_2.in ()))
2358 {
2359 ACE_ERROR_RETURN (( LM_ERROR,
2360 ACE_TEXT ("ERROR: invalid ior <%s>\n"),nm2ref),
2361 RC_ERROR);
2362 }
2363
2364 /// Now validate seamless operations between the two instances of NS_group
2365 const ACE_TCHAR * policy = ACE_TEXT ("round");
2366 const ACE_TCHAR * test_group_1 = ACE_TEXT ("test_group_1");
2367 const ACE_TCHAR * test_group_2 = ACE_TEXT ("test_group_2");
2368
2369 if (RC_SUCCESS != svc1.group_create (test_group_1, policy))
2370 {
2371 ACE_ERROR_RETURN (( LM_ERROR,
2372 ACE_TEXT ("ERROR: Unable to create %s\n"),
2373 test_group_1),
2374 RC_ERROR);
2375 }
2376
2377 if (RC_SUCCESS != svc2.group_create (test_group_2, policy))
2378 {
2379 ACE_ERROR_RETURN (( LM_ERROR,
2380 ACE_TEXT ("ERROR: Unable to create %s\n"),
2381 test_group_2),
2382 RC_ERROR);
2383 }
2384
2385 if (false == svc1.group_exist(test_group_1))
2386 {
2387 ++error_count;
2388 ACE_DEBUG (( LM_DEBUG,
2389 ACE_TEXT ("ERROR: Primary Not Able To Find Object Group ")
2390 ACE_TEXT ("%s Created By Primary In Repository\n"),
2391 test_group_1));
2392 } else {
2393 ACE_DEBUG (( LM_DEBUG,
2394 ACE_TEXT ("INFO: Primary Found Object Group %s Created By ")
2395 ACE_TEXT ("Primary In Repository\n"),
2396 test_group_1));
2397 }
2398
2399 if (false == svc2.group_exist(test_group_2))
2400 {
2401 ++error_count;
2402 ACE_DEBUG (( LM_DEBUG,
2403 ACE_TEXT ("ERROR: Backup Not Able To Find Object Group %s ")
2404 ACE_TEXT ("Created By Backup In Repository\n"),
2405 test_group_2));
2406 } else {
2407 ACE_DEBUG (( LM_DEBUG,
2408 ACE_TEXT ("INFO: Backup Found Object Group %s Created By ")
2409 ACE_TEXT ("Backup In Repository\n"),
2410 test_group_2));
2411 }
2412
2413 if (false == svc1.group_exist(test_group_2))
2414 {
2415 ++error_count;
2416 ACE_DEBUG (( LM_DEBUG,
2417 ACE_TEXT ("ERROR: Primary Not Able To Find Object Group %s ")
2418 ACE_TEXT ("Created By Backup In Repository\n"),
2419 test_group_2));
2420 } else {
2421 ACE_DEBUG (( LM_DEBUG,
2422 ACE_TEXT ("INFO: Primary Found Object Group %s Created By ")
2423 ACE_TEXT ("Backup In Repository\n"),
2424 test_group_2));
2425 }
2426
2427 if (false == svc2.group_exist(test_group_1))
2428 {
2429 ++error_count;
2430 ACE_DEBUG (( LM_DEBUG,
2431 ACE_TEXT ("ERROR: Backup Not Able To Find Object Group %s ")
2432 ACE_TEXT ("Created By Primary In Repository\n"),
2433 test_group_1));
2434 } else {
2435 ACE_DEBUG (( LM_DEBUG,
2436 ACE_TEXT ("INFO: Backup Found Object Group %s Created By ")
2437 ACE_TEXT ("Primary In Repository\n"),
2438 test_group_1));
2439 }
2440
2441 }
2442 catch (const CORBA::Exception& ex)
2443 {
2444 ++error_count;
2445 ex._tao_print_exception (
2446 ACE_TEXT ("ERROR: Unable to resolve name manager servers"));
2447 }
2448
2449 return (error_count > 0) ? RC_ERROR : RC_SUCCESS;
2450 }