TAO/examples/CSD_Strategy/ThreadPool5/FooServantList.cpp

   1 #include "FooServantList.h"
   2 #include "Foo_i.h"
   3 #include "Callback_i.h"
   4 #include "ClientTask.h"
   5 #include "OrbShutdownTask.h"
   6 #include "ace/OS_NS_unistd.h"
   7
   8 FooServantList::FooServantList(const ACE_TCHAR* prefix,
   9                                unsigned    num_servants,
  10                                unsigned    num_clients,
  11                                int         collocated_test,
  12                                int         servant_to_deactivate,
  13                                CORBA::ORB_ptr orb)
  14   : prefix_(prefix),
  15     num_servants_(num_servants),
  16     num_clients_(num_clients),
  17     init_num_clients_ (num_clients_),
  18     collocated_test_(collocated_test),
  19     servant_to_deactivate_ (servant_to_deactivate),
  20     collocated_client_ (0),
  21     orb_ (CORBA::ORB::_duplicate(orb))
  22 {
  23   this->servants_ = new Foo_i* [num_servants];
  24   this->safe_servants_ = new PortableServer::ServantBase_var[num_servants];
  25 }
  26
  27
  28 FooServantList::~FooServantList()
  29 {
  30   delete [] this->safe_servants_;
  31   delete [] this->servants_;
  32   delete collocated_client_;
  33 }
  34
  35
  36 void
  37 FooServantList::create_and_activate(CORBA::ORB_ptr orb,
  38                                     PortableServer::POA_ptr poa)
  39 {
  40   poa_ = PortableServer::POA::_duplicate (poa);
  41
  42   for (unsigned i = 0; i < this->num_servants_; i++)
  43     {
  44       ACE_TCHAR buf[32];
  45       ACE_OS::sprintf(buf, ACE_TEXT("%02d"), i + 1);
  46       ACE_TString servant_name = this->prefix_ + ACE_TEXT("_") + buf;
  47
  48       this->servants_[i] = new Foo_i(ACE_TEXT_ALWAYS_CHAR(servant_name.c_str()),this);
  49       this->safe_servants_[i] = this->servants_[i];
  50
  51       PortableServer::ObjectId_var id =
  52                     PortableServer::string_to_ObjectId(ACE_TEXT_ALWAYS_CHAR(servant_name.c_str()));
  53
  54       poa->activate_object_with_id(id.in(),
  55                                    this->safe_servants_[i].in());
  56
  57       CORBA::Object_var obj = poa->id_to_reference(id.in());
  58
  59       if (CORBA::is_nil(obj.in()))
  60         {
  61           ACE_ERROR((LM_ERROR,
  62                      "(%P|%t) Failed to activate servant (%s).\n",
  63                      servant_name.c_str()));
  64           throw TestException();
  65         }
  66
  67       // create the collocated object reference.
  68       if (this->collocated_test_ && i == 0)
  69         {
  70           Foo_var collocated = Foo::_narrow (obj.in ());
  71
  72           // Create the servant object.
  73           Callback_i* servant = new Callback_i ();
  74
  75           // local smart pointer variable to deal with releasing the reference
  76           // to the servant object when the smart pointer object falls out of scope.
  77           PortableServer::ServantBase_var safe_servant(servant);
  78
  79           PortableServer::ObjectId_var id =
  80             PortableServer::string_to_ObjectId("callback");
  81
  82           poa->activate_object_with_id(id.in(), safe_servant.in());
  83
  84           CORBA::Object_var obj = poa->id_to_reference(id.in());
  85
  86           if (CORBA::is_nil(obj.in()))
  87             {
  88               ACE_ERROR((LM_ERROR,
  89                         "(%P|%t) Failed to activate servant (%s).\n",
  90                         servant_name.c_str()));
  91               throw TestException();
  92             }
  93
  94           Callback_var callback
  95             = Callback::_narrow (obj.in ());
  96
  97           collocated_client_
  98             = new ClientTask(orb, collocated.in (), callback.in (), true);
  99           if (collocated_client_->open() != 0)
 100             {
 101               ACE_ERROR((LM_ERROR,
 102                 "(%P|%t) Failed to open the collocated client.\n"));
 103               throw TestException();
 104             }
 105         }
 106
 107       CORBA::String_var ior
 108         = this->orb_->object_to_string(obj.in());
 109
 110       ACE_TString filename = servant_name + ACE_TEXT(".ior");
 111       FILE* ior_file = ACE_OS::fopen(filename.c_str(), "w");
 112
 113       if (ior_file == 0)
 114         {
 115           ACE_ERROR((LM_ERROR,
 116                      "(%P|%t) Cannot open output file (%s) for writing IOR.",
 117                      filename.c_str()));
 118           throw TestException();
 119         }
 120       else
 121         {
 122           ACE_DEBUG((LM_DEBUG,
 123                      "(%P|%t) writing IOR to file %s\n",
 124                      filename.c_str()));
 125         }
 126       ACE_OS::fprintf(ior_file, "%s", ior.in());
 127       ACE_OS::fclose(ior_file);
 128     }
 129 }
 130
 131
 132 void
 133 FooServantList::client_done(void)
 134 {
 135   unsigned num_left;
 136
 137   {
 138     ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->num_clients_lock_);
 139     num_left = --this->num_clients_;
 140   }
 141
 142   if (num_left == 0)
 143     {
 144       if (TheOrbShutdownTask::instance()->open(0) != 0)
 145         {
 146           ACE_ERROR((LM_ERROR, "(%P|%t)FooServantList::client_done: "
 147             "failed to create orb shutdown thread.\n"));
 148         }
 149     }
 150 }
 151
 152
 153 ClientTask*
 154 FooServantList::collocated_client () const
 155 {
 156   return collocated_client_;
 157 }
 158
 159
 160 void
 161 FooServantList::deactivate_servant (void)
 162 {
 163   for (unsigned i = 0; i < this->num_servants_; i++)
 164     {
 165       // To eliminate compiler warning about comparison of signed vs unsigned.
 166       int signed_i = i;
 167
 168       if ((servant_to_deactivate_ == 0 ) ||
 169            ((servant_to_deactivate_ > 0) &&
 170             (signed_i == servant_to_deactivate_ - 1)))
 171         {
 172           if (servants_[i]->active())
 173             {
 174               servants_[i]->active(false);
 175               ACE_DEBUG((LM_DEBUG, "(%P|%t)FooServantList::deactivate_servant "
 176                 "deactivate %dth servant\n", i+1));
 177
 178               PortableServer::ObjectId_var id =
 179                 poa_->servant_to_id (safe_servants_[i].in ());
 180
 181               poa_->deactivate_object (id.in ());
 182
 183               if (this->num_servants_ == 1)
 184                 {
 185                   // If there is only one servant and we deactivate it then
 186                   // all clients will catch exception and we need a way to
 187                   // shutdown the orb.
 188                   // Wait for 5 seconds so we can see the requests queued
 189                   // will be cancelled by deactivate servant.
 190                   ACE_OS::sleep (5);
 191                   ACE_DEBUG((LM_DEBUG, "(%P|%t)shutdown ORB\n"));
 192                   if (TheOrbShutdownTask::instance()->open(0) != 0)
 193                     {
 194                       ACE_ERROR((LM_ERROR, "(%P|%t)FooServantList::deactivate_servant: "
 195                         "failed to create orb shutdown thread.\n"));
 196                     }
 197                 }
 198               else
 199                 {
 200                   ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->num_clients_lock_);
 201                   // The clients that requests this deactivated servant
 202                   // will catch exception due to the deactivated servant.
 203                   // We need descrease the num_clients so the alived
 204                   // servant can be called to shutdown the orb.
 205                   this->num_clients_ -= this->init_num_clients_/num_servants_;
 206                 }
 207             }
 208         }
 209     }
 210 }
 211