int
ACE_Module_Type::resume (void) const
{
  ACE_TRACE ("ACE_Module_Type::resume");
  void *obj = this->object ();
  MT_Module *mod = (MT_Module *) obj;
  MT_Task *reader = mod->reader ();
  MT_Task *writer = mod->writer ();

  if (reader->resume () == -1
      || writer->resume () == -1)
    return -1;
  else
    return 0;
}
int
ACE_Module_Type::init (int argc, ACE_TCHAR *argv[]) const
{
  ACE_TRACE ("ACE_Module_Type::init");
  void *obj = this->object ();
  MT_Module *mod = (MT_Module *) obj;
  MT_Task *reader = mod->reader ();
  MT_Task *writer = mod->writer ();

  if (reader->init (argc, argv) == -1
      || writer->init (argc, argv) == -1)
    return -1;
  else
    return 0;
}
Example #3
0
int
ACE_Module_Type::fini (void) const
{
  ACE_TRACE ("ACE_Module_Type::fini");
  void *obj = this->object ();
  MT_Module *mod = (MT_Module *) obj;
  MT_Task *reader = mod->reader ();
  MT_Task *writer = mod->writer ();

  if (reader != 0)
    reader->fini ();

  if (writer != 0)
    writer->fini ();

  // Close the module and delete the memory.
  mod->close (MT_Module::M_DELETE);
  return ACE_Service_Type_Impl::fini ();
}
Example #4
0
int
ACE_Module_Type::init (int argc, ACE_TCHAR *argv[]) const
{
  ACE_TRACE ("ACE_Module_Type::init");
  void *obj = this->object ();
  MT_Module *mod = (MT_Module *) obj;
  //
  // Change the Module's name to what's in the svc.conf file.
  // We must do this so the names match up so everything shuts
  // down properly during the call to ACE_Stream_Type::fini
  // which calls MT_Stream::remove([name]) for all the modules.
  // If the calls to remove fail, we end up with a double delete
  // during shutdown. Bugzilla #3847
  //
  mod->name (this->name_);
  MT_Task *reader = mod->reader ();
  MT_Task *writer = mod->writer ();

  if (reader->init (argc, argv) == -1
      || writer->init (argc, argv) == -1)
    return -1;
  else
    return 0;
}
Example #5
0
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
  try
    {
      CORBA::ORB_var orb =
        CORBA::ORB_init (argc, argv);

      CORBA::Object_var poa_object =
        orb->resolve_initial_references("RootPOA");

      PortableServer::POA_var root_poa =
        PortableServer::POA::_narrow (poa_object.in ());

      if (CORBA::is_nil (root_poa.in ()))
        ACE_ERROR_RETURN ((LM_ERROR,
                           " (%P|%t) Panic: nil RootPOA\n"),
                          1);

      PortableServer::POAManager_var poa_manager =
        root_poa->the_POAManager ();

      if (parse_args (argc, argv) != 0)
        return 1;

      One_Impl *one_impl = 0;
      ACE_NEW_RETURN (one_impl,
                      One_Impl (orb.in ()),
                      1);
      Two_Impl *two_impl = 0;
      ACE_NEW_RETURN (two_impl,
                      Two_Impl (orb.in ()),
                      1);

      Three_Impl *three_impl = 0;
      ACE_NEW_RETURN (three_impl,
                      Three_Impl (orb.in ()),
                      1);

      PortableServer::ServantBase_var owner_transfer1 (one_impl);
      PortableServer::ServantBase_var owner_transfer2 (two_impl);
      PortableServer::ServantBase_var owner_transfer3 (three_impl);

      CORBA::PolicyList policies;  // Empty policy list.

      PortableServer::POA_var first_poa =
        root_poa->create_POA ("first POA",
                              poa_manager.in (),
                              policies);

      PortableServer::ObjectId_var oid1 =
        first_poa->activate_object (one_impl);

      PortableServer::ObjectId_var oid2 =
        first_poa->activate_object (two_impl);

      PortableServer::ObjectId_var oid3 =
        first_poa->activate_object (three_impl);

      // Output the IOR to the <ior_output_file>
      FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
      if (output_file == 0)
        ACE_ERROR_RETURN ((LM_ERROR,
                           "Cannot open output file for writing IOR: %s\n",
                           ior_output_file),
                           1);
      ACE_OS::fprintf (output_file, "%s", "started");
      ACE_OS::fclose (output_file);

      MT_Task task (first_poa.in (),
                    one_impl,
                    two_impl,
                    three_impl);

      if (task.activate (THR_NEW_LWP | THR_JOINABLE,
                         32) != 0)
        ACE_ERROR_RETURN ((LM_ERROR,
                           "Cannot activate threads\n"),
                          1);

      task.thr_mgr ()->wait ();

      poa_manager->activate ();

      ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - test finished\n"));

      root_poa->destroy (1, 1);

      orb->destroy ();
    }
  catch (const CORBA::Exception& ex)
    {
      ex._tao_print_exception ("Exception caught:");
      return 1;
    }

  return 0;
}