TAO_Naming_Server Class Reference

Defines a wrapper class that holds the root Naming Context. More...

#include <Naming_Server.h>

Collaboration diagram for TAO_Naming_Server:

Classes
struct	IOR_Bundle

Public Member Functions
	TAO_Naming_Server (size_t bsize=1)
	Default constructor. More...
	TAO_Naming_Server (CORBA::ORB_ptr orb, PortableServer::POA_ptr poa, size_t context_size=ACE_DEFAULT_MAP_SIZE, ACE_Time_Value *timeout=0, bool resolve_for_existing_naming_service=true, const ACE_TCHAR *persistence_location=0, void *base_addr=TAO_NAMING_BASE_ADDR, int enable_multicast=1, int use_storable_context=0, int round_trip_timeout=0, int use_round_trip_timeout=0, size_t bsize=1)
int	init (CORBA::ORB_ptr orb, PortableServer::POA_ptr poa, size_t context_size=ACE_DEFAULT_MAP_SIZE, ACE_Time_Value *timeout=0, bool resolve_for_existing_naming_service=true, const ACE_TCHAR *persistence_location=0, void *base_addr=TAO_NAMING_BASE_ADDR, int enable_multicast=1, int use_storable_context=0, int round_trip_timeout=0, int use_round_trip_timeout=0)
virtual int	init_with_orb (int argc, ACE_TCHAR *argv [], CORBA::ORB_ptr orb)
virtual int	fini (void)
	Destroy the child POA created in init_with_orb. More...
virtual	~TAO_Naming_Server (void)
	Destructor. More...
char *	naming_service_ior (void)
	Returns the IOR of the naming service. More...
CosNaming::NamingContext_ptr	operator-> (void) const
	Returns a <NamingContext_ptr> for the root Naming Context. More...

Protected Types
enum	Base_IOR_Indexes { ROOT = 0 }

Protected Member Functions
void	assign (size_t ndx, bool take, CORBA::Object_ptr obj)
int	write (size_t ndx) const
virtual int	init_new_naming (CORBA::ORB_ptr orb, PortableServer::POA_ptr root_poa, const ACE_TCHAR *persistence_location, void *base_addr, size_t context_size, int enable_multicast, int use_storable_context, int round_trip_timeout=0, int use_round_trip_timeout=0)
virtual int	parse_args (int argc, ACE_TCHAR *argv[])
	parses the arguments. More...
int	write_ior_to_file (const char *ior_string, const char *file_name)
	Write the provided ior_string to the file. Return 0 if success. More...
virtual TAO_Storable_Naming_Context_Factory *	storable_naming_context_factory (size_t context_size)
virtual TAO_Persistent_Naming_Context_Factory *	persistent_naming_context_factory (void)
IOR_Bundle *	bundle_at (size_t ndx)
const IOR_Bundle *	bundle_at (size_t ndx) const

Protected Attributes
TAO_IOR_Multicast *	ior_multicast_
	The ior_multicast event handler. More...
CORBA::ORB_var	orb_
	The ORB. More...
PortableServer::POA_var	root_poa_
	The Root POA. More...
PortableServer::POA_var	ns_poa_
	The Naming Service POA. More...
const ACE_TCHAR *	pid_file_name_
	File to output the process id. More...
IOR_Bundle *	iors_
size_t	bundle_size_
size_t	context_size_
int	multicast_
	If not zero multicast is enabled. More...
TAO_Persistent_Context_Index *	context_index_
const ACE_TCHAR *	persistence_dir_
void *	base_address_
int	use_storable_context_
	If not zero use flat file persistence. More...
int	use_servant_activator_
TAO_Storable_Naming_Context_Activator *	servant_activator_
int	use_redundancy_
int	round_trip_timeout_
	If not zero use round trip timeout policy set to value specified. More...
int	use_round_trip_timeout_

Detailed Description

Defines a wrapper class that holds the root Naming Context.

This class either finds an existing Naming Service (if the <resolve_for_existing_naming_service> flag is set) or creates one (if resolve_for_existing_naming_service flag isn't set or Naming Service was not found). This class also defines the operator-> so that <NamingContext> functions like <bind>, <unbind> .. can be called directly on a <TAO_Naming_Server> object, and be forwareded to the root Naming Context. This class is intended to simplify programs that want to play the role of a Naming Service server. To simplify programs that want to play the role of Naming Service clients, use <TAO_Naming_Client>. If a Naming Service is created locally, a TAO_IOR_Multicast event handler is created and installed on the ORB's reactor. This event handler allows other clients on the network to discover and use this Naming Service. Event handler listens on a multicast port for messages from clients looking for a Naming Service, and sends back the ior of the root Naming Context. For more information on how this bootstraping through a multicast process works, check out orbsvcs/orbsvcs/TAO_IOR_Multicast.*, implementation of <resolve_initial_references>, and orbsvcs/Naming/README.

Definition at line 64 of file Naming_Server.h.

Member Enumeration Documentation

Base_IOR_Indexes

enum TAO_Naming_Server::Base_IOR_Indexes

protected

Enumerator
ROOT

Definition at line 149 of file Naming_Server.h.

                        {
    ROOT = 0
  };

Constructor & Destructor Documentation

TAO_Naming_Server() [1/2]

TAO_Naming_Server::TAO_Naming_Server

(

size_t

bsize = 1

)

Default constructor.

Definition at line 41 of file Naming_Server.cpp.

  : ior_multicast_ (0),
    pid_file_name_ (0),
    iors_ (0),
    bundle_size_ (bsize),
    context_size_ (ACE_DEFAULT_MAP_SIZE),
    multicast_ (0),
#if !defined (CORBA_E_MICRO)
    context_index_ (0),
    persistence_dir_ (0),
    base_address_ (TAO_NAMING_BASE_ADDR),
    use_storable_context_ (0),
    use_servant_activator_ (false),
    servant_activator_ (0),
#endif /* CORBA_E_MICRO */
    use_redundancy_(0),
    round_trip_timeout_ (0),
    use_round_trip_timeout_ (0)
{
  ACE_NEW (iors_, IOR_Bundle[bsize]);
}

TAO_Naming_Server() [2/2]

TAO_Naming_Server::TAO_Naming_Server	(	CORBA::ORB_ptr	orb,
		PortableServer::POA_ptr	poa,
		size_t	context_size = ACE_DEFAULT_MAP_SIZE,
		ACE_Time_Value *	timeout = 0,
		bool	resolve_for_existing_naming_service = true,
		const ACE_TCHAR *	persistence_location = 0,
		void *	base_addr = TAO_NAMING_BASE_ADDR,
		int	enable_multicast = 1,
		int	use_storable_context = 0,
		int	round_trip_timeout = 0,
		int	use_round_trip_timeout = 0,
		size_t	bsize = 1
	)

Constructor. Attempts to find an existing Naming Service if resolve_for_existing_naming_service is set to true. If it is false, or no Naming Service was found during a timeout period, create the Naming Service in this process. If creating the Naming Service locally, make the root context of size <context_size>, register it under the <poa>, and make the Naming Service persistent if <persistence_location> is not 0. (<persistence_location> specifies name of the file to use for persistent storage, <base_addr> specifies the address used for memory mapping <persistent_location> file). If <enable_multicast> is not zero then the service will respond to multicast location queries.

Definition at line 63 of file Naming_Server.cpp.

  : ior_multicast_ (0),
    pid_file_name_ (0),
    iors_ (0),
    bundle_size_ (bsize),
    context_size_ (ACE_DEFAULT_MAP_SIZE),
    multicast_ (0),
#if !defined (CORBA_E_MICRO)
    context_index_ (0),
    persistence_dir_ (0),
    base_address_ (TAO_NAMING_BASE_ADDR),
    use_storable_context_ (use_storable_context),
    use_servant_activator_ (false),
    servant_activator_ (0),
#endif /* CORBA_E_MICRO */
    use_redundancy_(0),
    round_trip_timeout_ (0),
    use_round_trip_timeout_ (0)
{
  ACE_NEW (iors_, IOR_Bundle[bsize]);
  if (this->init (orb,
                  poa,
                  context_size,
                  timeout,
                  resolve_for_existing_naming_service,
                  persistence_location,
                  base_addr,
                  enable_multicast,
                  use_storable_context,
                  round_trip_timeout,
                  use_round_trip_timeout) == -1)
    ORBSVCS_ERROR ((LM_ERROR,
                "(%P|%t) %p\n",
                "TAO_Naming_Server::init"));
}

~TAO_Naming_Server()

TAO_Naming_Server::~TAO_Naming_Server ( void  )

virtual

Destructor.

Definition at line 875 of file Naming_Server.cpp.

{
  delete [] this->iors_;

#if (TAO_HAS_MINIMUM_POA == 0) && \
    !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO)
  if (this->use_servant_activator_ &&
      this->servant_activator_)
    {
      // Activator is reference counted. Don't delete it directly.
      this->servant_activator_->_remove_ref ();
    }
#endif /* TAO_HAS_MINIMUM_POA */
}

Member Function Documentation

assign()

void TAO_Naming_Server::assign ( size_t  ndx, bool  take, CORBA::Object_ptr  obj  )

protected

Definition at line 968 of file Naming_Server.cpp.

{
  IOR_Bundle *b = this->bundle_at(ndx);
  if (b == 0)
    return;

  b->ref_ = take ? obj : CORBA::Object::_duplicate (obj);
  CORBA::String_var ior = this->orb_->object_to_string (b->ref_.in());
  b->ior_ = ior.in();
}

bundle_at() [1/2]

TAO_Naming_Server::IOR_Bundle * TAO_Naming_Server::bundle_at ( size_t  ndx )

protected

Definition at line 892 of file Naming_Server.cpp.

  {
  if (ndx >= this->bundle_size_)
    {
    if (TAO_debug_level)
      {
      ORBSVCS_ERROR((LM_ERROR,
        ACE_TEXT("(%P|%t) TAO_naming_Server::bundle_at, ")
        ACE_TEXT("index %d out of range\n"),
        ndx));
      }
    return 0;
    }
  return &iors_[ndx];
  }

bundle_at() [2/2]

const TAO_Naming_Server::IOR_Bundle * TAO_Naming_Server::bundle_at ( size_t  ndx ) const

protected

Definition at line 909 of file Naming_Server.cpp.

  {
  if (ndx >= this->bundle_size_)
    {
    if (TAO_debug_level)
      {
      ORBSVCS_ERROR((LM_ERROR,
        ACE_TEXT("(%P|%t) const TAO_naming_Server::bundle_at, ")
        ACE_TEXT("index %d out of range\n"),
        ndx));
      }
    return 0;
    }
  return &iors_[ndx];
  }

fini()

int TAO_Naming_Server::fini ( void  )

virtual

Destroy the child POA created in init_with_orb.

Definition at line 783 of file Naming_Server.cpp.

{
  // First get rid of the multi cast handler
  if (this->ior_multicast_)
    {
      orb_->orb_core()->reactor ()->remove_handler (this->ior_multicast_,
         ACE_Event_Handler::READ_MASK | ACE_Event_Handler::DONT_CALL);
      delete this->ior_multicast_;
      this->ior_multicast_ = 0;
    }

  for (size_t i = 0; i < bundle_size_; i++ )
    {
      this->iors_[i].ref_ = CORBA::Object::_nil();
    }

  // Destroy the child POA ns_poa that is created when initializing
  // the Naming Service
  try
    {
      if (!CORBA::is_nil (this->ns_poa_.in ()))
        this->ns_poa_->destroy (1, 1);

    }
  catch (const CORBA::Exception&)
    {
      // Ignore
    }
  try
    {
      CORBA::Object_var table_object =
        this->orb_->resolve_initial_references ("IORTable");

      IORTable::Table_var ior_table =
        IORTable::Table::_narrow (table_object.in ());

      if (!CORBA::is_nil (ior_table.in ()))
        {
          ior_table->unbind ("NameService");
        }

    }
  catch (const CORBA::Exception&)
    {
      // Ignore
    }

  try
    {
#if !defined (CORBA_E_MICRO)
      CORBA::Object_var svc =
        this->orb_->unregister_initial_reference ("NameService");
#endif /* CORBA_E_MICRO */

    }
  catch (const CORBA::Exception&)
    {
      // Ignore
    }

  ns_poa_ = PortableServer::POA::_nil ();
  root_poa_ = PortableServer::POA::_nil ();
  orb_ = CORBA::ORB::_nil ();

#if !defined (CORBA_E_MICRO)
  delete this->context_index_;
#endif /* CORBA_E_MICRO */

  return 0;
}

init()

int TAO_Naming_Server::init	(	CORBA::ORB_ptr	orb,
		PortableServer::POA_ptr	poa,
		size_t	context_size = ACE_DEFAULT_MAP_SIZE,
		ACE_Time_Value *	timeout = 0,
		bool	resolve_for_existing_naming_service = true,
		const ACE_TCHAR *	persistence_location = 0,
		void *	base_addr = TAO_NAMING_BASE_ADDR,
		int	enable_multicast = 1,
		int	use_storable_context = 0,
		int	round_trip_timeout = 0,
		int	use_round_trip_timeout = 0
	)

Initializer. Attempts to find an existing Naming Service if resolve_for_existing_naming_service is set to true. If it is false, or no Naming Service was found during a <timeout> period, create the Naming Service in this process. If creating the Naming Service locally, make the root context of size <context_size>, register it under the <poa>, and make the Naming Service persistent if <persistence_location> is not 0. (<persistence_location> specifies name of the file to use for persistent storage, <base_addr> specifies the address used for memory mapping <persistent_location> file). If <enable_multicast> is not zero then the service will respond to multicast location queries.

Definition at line 111 of file Naming_Server.cpp.

{
  if (CORBA::is_nil (this->orb_.in ()))
    {
      this->orb_ = CORBA::ORB::_duplicate (orb);
    }
  for (size_t i = 0; i < bundle_size_; i++ )
    {
      this->iors_[i].ref_ = CORBA::Object::_nil();
    }

  if (resolve_for_existing_naming_service)
    {
      try
        {
          // Try to find an existing Naming Service.
          CORBA::Object_var naming_obj =
            orb->resolve_initial_references ("NameService", timeout);

          if (!CORBA::is_nil (naming_obj.in ()))
            {
              //
              // Success in finding a Naming Service.
              //
              if (TAO_debug_level > 0)
                ORBSVCS_DEBUG ((LM_DEBUG,
                                "\nNameService found!\n"));

              this->assign (size_t(ROOT), false, naming_obj);
              return 0;
            }
        }
      catch (const CORBA::Exception& ex)
        {
          ex._tao_print_exception ("TAO_Naming_Server::init");
        }
    }

  if (TAO_debug_level > 0)
    ORBSVCS_DEBUG ((LM_DEBUG,
                "\nWe'll become a NameService\n"));

  // Become a Naming Service.
  return this->init_new_naming (orb,
                                poa,
                                persistence_location,
                                base_addr,
                                context_size,
                                enable_multicast,
                                use_storable_context,
                                round_trip_timeout,
                                use_round_trip_timeout);
}

init_new_naming()

int TAO_Naming_Server::init_new_naming ( CORBA::ORB_ptr  orb, PortableServer::POA_ptr  root_poa, const ACE_TCHAR *  persistence_location, void *  base_addr, size_t  context_size, int  enable_multicast, int  use_storable_context, int  round_trip_timeout = 0, int  use_round_trip_timeout = 0  )

protectedvirtual

Helper method: create Naming Service locally. Can be specialized to refine how Naming Service components are created and initialized Make the root context of size context_size, register it under the root_poa, and make the Naming Service persistent if <persistence_location> is not 0. (<persistence_location> specifies name of the file to use for persistent storage). If <enable_multicast> is not zero then the service will respond to multicast location queries.

Definition at line 456 of file Naming_Server.cpp.

{
  try
    {
      if (CORBA::is_nil (this->orb_.in ()))
        {
          this->orb_ = CORBA::ORB::_duplicate (orb);
        }

#if defined (CORBA_E_MICRO)
      ACE_UNUSED_ARG (persistence_location);
      ACE_UNUSED_ARG (base_addr);
      ACE_UNUSED_ARG (use_storable_context);
#else
      if (use_storable_context)
        {
          // In lieu of a fully implemented service configurator version
          // of this Reader and Writer, let's just take something off the
          // command line for now.
          TAO::Storable_Factory* pf = 0;
          ACE_CString directory (ACE_TEXT_ALWAYS_CHAR (persistence_location));
          ACE_NEW_RETURN (pf, TAO::Storable_FlatFileFactory (directory), -1);
#if defined (ACE_HAS_CPP11)
          std::unique_ptr<TAO::Storable_Factory> persFactory(pf);
#else
          auto_ptr<TAO::Storable_Factory> persFactory(pf);
#endif /* ACE_HAS_CPP11 */

          // Use an auto_ptr to ensure that we clean up the factory in the case
          // of a failure in creating and registering the Activator.
          TAO_Storable_Naming_Context_Factory* cf =
            this->storable_naming_context_factory (context_size);
          // Make sure we got a factory
          if (cf == 0) return -1;
#if defined (ACE_HAS_CPP11)
          std::unique_ptr<TAO_Storable_Naming_Context_Factory> contextFactory (cf);
#else
          auto_ptr<TAO_Storable_Naming_Context_Factory> contextFactory (cf);
#endif /* ACE_HAS_CPP11 */

          // This instance will either get deleted after recreate all or,
          // in the case of a servant activator's use, on destruction of the
          // activator.

          // Was a location specified?
          if (persistence_location == 0)
            {
              // No, assign the default location "NameService"
              persistence_location = ACE_TEXT ("NameService");
            }

          // Now make sure this directory exists
          if (ACE_OS::access (persistence_location, W_OK|X_OK))
            {
              ORBSVCS_ERROR_RETURN ((LM_ERROR,
                "Invalid persistence directory %C %p\n",
                persistence_location, "access"), -1);
            }

#if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT)
          if (this->use_servant_activator_)
            {
              ACE_NEW_THROW_EX (this->servant_activator_,
                                TAO_Storable_Naming_Context_Activator (orb,
                                                                       persFactory.get(),
                                                                       contextFactory.get (),
                                                                       persistence_location),
                                CORBA::NO_MEMORY ());
              this->ns_poa_->set_servant_manager(this->servant_activator_);
            }
#endif /* TAO_HAS_MINIMUM_POA */
          try {  // The following might throw an exception.
            this->assign (size_t(ROOT), false, TAO_Storable_Naming_Context::
                                    recreate_all (orb,
                                                  poa,
                                                  TAO_ROOT_NAMING_CONTEXT,
                                                  context_size,
                                                  0,
                                                  contextFactory.get (),
                                                  persFactory.get (),
                                                  use_redundancy_));
          }
          catch (const CORBA::Exception& ex)
          {
            // The activator already took over the factories so we need to release the auto_ptr
            if (this->use_servant_activator_)
            {
              // The context factory is now owned by the activator
              // so we should release it
              contextFactory.release ();
              // If using a servant activator, the activator now owns the
              // factory, so we should release it
              persFactory.release ();
            }
            // Print out the exception and return failure
            ex._tao_print_exception (
              "TAO_Naming_Server::init_new_naming");
            return -1;
          }

        // Kind of a duplicate of the above here, but we must also release the
        // factory autoptrs in the good case as well.
        if (this->use_servant_activator_)
            {
              // The context factory is now owned by the activator
              // so we should release it
              contextFactory.release ();
              // If using a servant activator, the activator now owns the
              // factory, so we should release it
              persFactory.release ();
            }

      }
      else if (persistence_location != 0)
        //
        // Initialize Persistent Naming Service.
        //
        {

          // Create Naming Context Implementation Factory to be used for the creation of
          // naming contexts by the TAO_Persistent_Context_Index
          TAO_Persistent_Naming_Context_Factory *naming_context_factory =
            this->persistent_naming_context_factory ();
          // Make sure we got a factory.
          if (naming_context_factory == 0) return -1;

          // Allocate and initialize Persistent Context Index.
          ACE_NEW_RETURN (this->context_index_,
                          TAO_Persistent_Context_Index (orb, poa, naming_context_factory),
                          -1);

          if (this->context_index_->open (persistence_location,
                                          base_addr) == -1
              || this->context_index_->init (context_size) == -1)
            {
              if (TAO_debug_level >0)
                ORBSVCS_DEBUG ((LM_DEBUG,
                            "TAO_Naming_Server: context_index initialization failed\n"));
              return -1;
            }

          // Set the root Naming Context reference.
          this->assign (size_t(ROOT), false, this->context_index_->root_context ());
        }
      else
#endif /* CORBA_E_MICRO */
        {
          //
          // Initialize Transient Naming Service.
          //
          CosNaming::NamingContext_var new_context = TAO_Transient_Naming_Context::make_new_context (poa,
                                                            TAO_ROOT_NAMING_CONTEXT,
                                                            context_size);
          this->assign (size_t(ROOT), false, new_context.in());

        }

#if !defined (CORBA_E_MICRO)
      // Register with the ORB's resolve_initial_references()
      // mechanism.  Primarily useful for dynamically loaded Name
      // Services.
      orb->register_initial_reference ("NameService",
                                       this->iors_[ROOT].ref_.in ());
#endif /* CORBA_E_MICRO */

      CORBA::Object_var table_object =
        orb->resolve_initial_references ("IORTable");

      IORTable::Table_var ior_table =
        IORTable::Table::_narrow (table_object.in ());
      if (CORBA::is_nil (ior_table.in ()))
        {
          ORBSVCS_ERROR ((LM_ERROR, "Nil IORTable\n"));
        }
      else
        {
          ior_table->bind ("NameService",
                         this->iors_[ROOT].ior_.c_str());
        }

#if defined (ACE_HAS_IP_MULTICAST)
      if (enable_multicast)
        {
          // @@ Marina: is there anyway to implement this stuff
          // without using ORB_Core_instance()? For example can you
          // pass the ORB as an argument?

          //
          // Install ior multicast handler.
          //
          // Get reactor instance from TAO.
          ACE_Reactor *reactor = orb->orb_core()->reactor ();

          // See if the -ORBMulticastDiscoveryEndpoint option was specified.
          ACE_CString mde (orb->orb_core ()->orb_params ()->mcast_discovery_endpoint ());

          // First, see if the user has given us a multicast port number
          // on the command-line;
          u_short port =
            orb->orb_core ()->orb_params ()->service_port (TAO::MCAST_NAMESERVICE);

          if (port == 0)
            {
              // Check environment var. for multicast port.
              const char *port_number =
                ACE_OS::getenv ("NameServicePort");

              if (port_number != 0)
                port = static_cast<u_short> (ACE_OS::atoi (port_number));
            }

          // Port wasn't specified on the command-line or in environment -
          // use the default.
          if (port == 0)
            port = TAO_DEFAULT_NAME_SERVER_REQUEST_PORT;

          // Instantiate a handler which will handle client requests for
          // the root Naming Context ior, received on the multicast port.
          ACE_NEW_RETURN (this->ior_multicast_,
                          TAO_IOR_Multicast (),
                          -1);

          if (mde.length () != 0)
            {
              if (this->ior_multicast_->init (this->iors_[ROOT].ior_.c_str (),
                                              mde.c_str (),
                                              TAO_SERVICEID_NAMESERVICE) == -1)
                return -1;
            }
          else
            {
              if (this->ior_multicast_->init (this->iors_[ROOT].ior_.c_str (),
                                              port,
#if defined (ACE_HAS_IPV6)
                                              ACE_DEFAULT_MULTICASTV6_ADDR,
#else
                                              ACE_DEFAULT_MULTICAST_ADDR,
#endif /* ACE_HAS_IPV6 */
                                              TAO_SERVICEID_NAMESERVICE) == -1)
                return -1;
            }

          // Register event handler for the ior multicast.
          if (reactor->register_handler (this->ior_multicast_,
                                         ACE_Event_Handler::READ_MASK) == -1)
            {
              if (TAO_debug_level > 0)
                ORBSVCS_DEBUG ((LM_DEBUG,
                            ACE_TEXT ("TAO_Naming_Server: cannot register Event handler\n")));
              return -1;
            }

          if (TAO_debug_level > 0)
            ORBSVCS_DEBUG ((LM_DEBUG,
                        ACE_TEXT ("TAO_Naming_Server: The multicast server setup is done.\n")));
        }
#else
  ACE_UNUSED_ARG (enable_multicast);
#endif /* ACE_HAS_IP_MULTICAST */

#if defined (TAO_HAS_CORBA_MESSAGING) && TAO_HAS_CORBA_MESSAGING != 0
      if (use_round_trip_timeout == 1)
      {
        TimeBase::TimeT roundTripTimeoutVal = round_trip_timeout;
        CORBA::Any anyObjectVal;
        anyObjectVal <<= roundTripTimeoutVal;
        CORBA::PolicyList polList (1);
        polList.length (1);
        polList[0] = orb->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
                                         anyObjectVal);

        // set a timeout on the orb
        //
        CORBA::Object_var orbPolicyManagerObj =
          orb->resolve_initial_references ("ORBPolicyManager");

        CORBA::PolicyManager_var orbPolicyManager =
          CORBA::PolicyManager::_narrow (orbPolicyManagerObj.in ());
        orbPolicyManager->set_policy_overrides (polList, CORBA::SET_OVERRIDE);

        polList[0]->destroy ();
        polList[0] = CORBA::Policy::_nil ();
      }
#else
  ACE_UNUSED_ARG (use_round_trip_timeout);
  ACE_UNUSED_ARG (round_trip_timeout);
#endif /* TAO_HAS_CORBA_MESSAGING */
    }
  catch (const CORBA::Exception& ex)
    {
      ex._tao_print_exception (
        "TAO_Naming_Server::init_new_naming");
      return -1;
    }

  return 0;
}

init_with_orb()

int TAO_Naming_Server::init_with_orb ( int  argc, ACE_TCHAR *  argv[], CORBA::ORB_ptr  orb  )

virtual

Initialize the Naming Service with the command line arguments and the ORB.

Definition at line 302 of file Naming_Server.cpp.

{
  int result;

  try
    {
      // Duplicate the ORB
      this->orb_ = CORBA::ORB::_duplicate (orb);

      // Get the POA from the ORB.
      CORBA::Object_var poa_object =
        orb->resolve_initial_references ("RootPOA");

      if (CORBA::is_nil (poa_object.in ()))
        {
          ORBSVCS_ERROR_RETURN ((LM_ERROR,
                             ACE_TEXT(" (%P|%t) Unable to initialize the POA.\n")),
                            -1);
        }

      // Check the non-ORB arguments.  this needs to come before we
      // initialize my_naming_server so that we can pass on some of
      // the command-line arguments.
      result = this->parse_args (argc, argv);

      if (result < 0)
        return result;

      // Get the POA object.
      this->root_poa_ = PortableServer::POA::_narrow (poa_object.in ());

      // Get the POA_Manager.
      PortableServer::POAManager_var poa_manager =
        this->root_poa_->the_POAManager ();

#if defined (CORBA_E_MICRO)
      this->ns_poa_ = PortableServer::POA::_duplicate (this->root_poa_);
#else
      int numPolicies = 2;
# if (TAO_HAS_MINIMUM_POA == 0)
      if (this->use_storable_context_)
        {
          this->use_servant_activator_ = true;
        }

      if (this->use_servant_activator_) {
        numPolicies += 2;
      }
# endif /* TAO_HAS_MINIMUM_POA */

      CORBA::PolicyList policies (numPolicies);
      policies.length (numPolicies);

      // Id Assignment policy
      policies[0] =
        this->root_poa_->create_id_assignment_policy (PortableServer::USER_ID);

      // Lifespan policy
      policies[1] =
        this->root_poa_->create_lifespan_policy (PortableServer::PERSISTENT);

# if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT)
      if (this->use_servant_activator_)
        {
          // Request Processing Policy
          policies[2] =
            this->root_poa_->create_request_processing_policy (PortableServer::USE_SERVANT_MANAGER);

          // Servant Retention Policy
          policies[3] =
            this->root_poa_->create_servant_retention_policy (PortableServer::RETAIN);
        }
# endif /* TAO_HAS_MINIMUM_POA */

      // We use a different POA, otherwise the user would have to change
      // the object key each time it invokes the server.
      this->ns_poa_ = this->root_poa_->create_POA ("NameService",
                                                   poa_manager.in (),
                                                   policies);
      // Warning!  If create_POA fails, then the policies won't be
      // destroyed and there will be hell to pay in memory leaks!

      // Creation of the new POAs over, so destroy the Policy_ptr's.
      for (CORBA::ULong i = 0;
           i < policies.length ();
           ++i)
        {
          CORBA::Policy_ptr policy = policies[i];
          policy->destroy ();
        }
#endif /* CORBA_E_MICRO */

      poa_manager->activate ();

#if defined (CORBA_E_MICRO)
      result = this->init (orb,
                           this->ns_poa_.in (),
                           this->context_size_,
                           0,
                           0,
                           0,
                           0,
                           this->multicast_,
                           false,
                           this->round_trip_timeout_,
                           this->use_round_trip_timeout_);
#else
      result = this->init (orb,
                           this->ns_poa_.in (),
                           this->context_size_,
                           0,
                           0,
                           this->persistence_dir_,
                           this->base_address_,
                           this->multicast_,
                           this->use_storable_context_,
                           this->round_trip_timeout_,
                           this->use_round_trip_timeout_);
#endif /* CORBA_E_MICRO */

      if (result == -1)
        return result;
    }
  catch (const CORBA::Exception& ex)
    {
      ex._tao_print_exception (
        "TAO_Naming_Server::init_with_orb");
      return -1;
    }

  // If an ior file name was provided on command line
  if (this->write (size_t(ROOT)) != 0)
    {
      return -1;
    }

  if (this->pid_file_name_ != 0)
    {
      FILE *pidf = ACE_OS::fopen (this->pid_file_name_, ACE_TEXT("w"));
      if (pidf != 0)
        {
          ACE_OS::fprintf (pidf,
                           "%ld\n",
                           static_cast<long> (ACE_OS::getpid ()));
          ACE_OS::fclose (pidf);
        }
    }

  return 0;
}

naming_service_ior()

char * TAO_Naming_Server::naming_service_ior

(

void

)

Returns the IOR of the naming service.

Definition at line 855 of file Naming_Server.cpp.

{
  return CORBA::string_dup (this->iors_[ROOT].ior_.c_str());
}

operator->()

CosNaming::NamingContext_ptr TAO_Naming_Server::operator->

(

void

)

const

Returns a <NamingContext_ptr> for the root Naming Context.

Definition at line 861 of file Naming_Server.cpp.

{
  if (CORBA::is_nil (this->iors_[ROOT].ref_))
    {
      return CosNaming::NamingContext::_nil ();
    }

  CosNaming::NamingContext_ptr ret =
    CosNaming::NamingContext::_narrow (this->iors_[ROOT].ref_);

  return ret;
}

parse_args()

int TAO_Naming_Server::parse_args ( int  argc, ACE_TCHAR *  argv[]  )

protectedvirtual

parses the arguments.

Definition at line 176 of file Naming_Server.cpp.

{
#if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT)
  ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("b:do:p:s:f:m:u:r:z:"));
#else
  ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("b:do:p:s:f:m:z:"));
#endif /* TAO_HAS_MINIMUM_POA */

  int c;
  int size;
#if !defined (CORBA_E_MICRO)
  int result;

  // This is declared this way to avoid warnings from
  // some compilers that complain about mismatching types
  // in the sscanf.
#if ACE_SIZEOF_VOID_P == ACE_SIZEOF_LONG_LONG
  ptrdiff_t address;
#else
  long int address;
#endif /* ACE_SIZEOF_VOID_P */
#endif /* CORBA_E_MICRO */

  // Make sure only one persistence option is specified
  int f_opt_used = 0;
  int u_opt_used = 0;
  int r_opt_used = 0;

  while ((c = get_opts ()) != -1)
    switch (c)
      {
      case 'd':  // debug flag.
        ++TAO_debug_level;
        break;
      case 'o': // outputs the naming service ior to a file.
        this->iors_[ROOT].filename_ = get_opts.opt_arg ();
        break;
      case 'p':
        this->pid_file_name_ = get_opts.opt_arg ();
        break;
      case 's':
        size = ACE_OS::atoi (get_opts.opt_arg ());
        if (size >= 0)
          this->context_size_ = size;
        break;
      case 'm':
        this->multicast_ = ACE_OS::atoi(get_opts.opt_arg ());
        break;
#if !defined (CORBA_E_MICRO)
      case 'b':
        result = ::sscanf (ACE_TEXT_ALWAYS_CHAR (get_opts.opt_arg ()),
#if ACE_SIZEOF_VOID_P == ACE_SIZEOF_LONG_LONG
                           ACE_INT64_FORMAT_SPECIFIER_ASCII,
#else
                           "%ld",
#endif /* ACE_SIZEOF_VOID_P */
                           &address);
        if (result == 0 || result == EOF)
          ORBSVCS_ERROR_RETURN ((LM_ERROR,
                             "Unable to process <-b> option"),
                            -1);
        this->base_address_ = (void *) address;
        break;
      case 'f':
        this->persistence_dir_ = get_opts.opt_arg ();
        f_opt_used = 1;
        break;
#if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT)
      case 'r':
        this->use_redundancy_ = 1;
        this->use_storable_context_ = 1;
        this->persistence_dir_ = get_opts.opt_arg ();
        r_opt_used = 1;
        break;
      case 'u':
        this->use_storable_context_ = 1;
        this->persistence_dir_ = get_opts.opt_arg ();
        u_opt_used = 1;
        break;
#endif /* TAO_HAS_MINIMUM_POA == 0 */
#endif /* !CORBA_E_MICRO */
      case 'z':
        this->use_round_trip_timeout_ = 1;
        this->round_trip_timeout_ = (int)1.0e7 * ACE_OS::atoi (get_opts.opt_arg ());
        break;
      case '?':
      default:
#if !defined (ACE_NLOGGING)
        const ACE_TCHAR *reqNonMinCorba=
#if !defined (CORBA_E_MICRO)
          ACE_TEXT ("-f <persistence_file_name> ")
#endif /* CORBA_E_MICRO */
#if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_MICRO)
          ACE_TEXT ("-u <storable_persistence_directory (not used with -f)> ")
          ACE_TEXT ("-r <redundant_persistence_directory> ");
#else
          ACE_TEXT ("");
#endif /* TAO_HAS_MINIMUM_POA && !CORBA_E_MICRO */
#endif /* !ACE_NLOGGING */
        ORBSVCS_ERROR_RETURN ((LM_ERROR,
                           ACE_TEXT ("usage:  %s ")
                           ACE_TEXT ("-d ")
                           ACE_TEXT ("-o <ior_output_file> ")
                           ACE_TEXT ("-p <pid_file_name> ")
                           ACE_TEXT ("-s <context_size> ")
                           ACE_TEXT ("-b <base_address> ")
                           ACE_TEXT ("-u <persistence dir name> ")
                           ACE_TEXT ("-m <1=enable multicast, 0=disable multicast(default) ")
                           ACE_TEXT ("%s")
                           ACE_TEXT ("-z <relative round trip timeout> ")
                           ACE_TEXT ("\n"),
                           argv [0], reqNonMinCorba),
                          -1);
      }

  if (f_opt_used + u_opt_used + r_opt_used > 1)
    ORBSVCS_ERROR_RETURN ((LM_ERROR,
                       ACE_TEXT ("Only one persistence option can be passed")
                       ACE_TEXT ("\n")),
                      -1);

  return 0;
}

persistent_naming_context_factory()

TAO_Persistent_Naming_Context_Factory * TAO_Naming_Server::persistent_naming_context_factory ( void  )

protectedvirtual

Definition at line 773 of file Naming_Server.cpp.

{
#if defined (ACE_HAS_NEW_NOTHROW)
  return new (ACE_nothrow) TAO_Persistent_Naming_Context_Factory;
#else
  return new TAO_Persistent_Naming_Context_Factory;
#endif /* ACE_HAS_NEW_NOTHROW */
}

storable_naming_context_factory()

TAO_Storable_Naming_Context_Factory * TAO_Naming_Server::storable_naming_context_factory ( size_t  context_size )

protectedvirtual

Definition at line 763 of file Naming_Server.cpp.

{
#if defined (ACE_HAS_NEW_NOTHROW)
  return new (ACE_nothrow) TAO_Storable_Naming_Context_Factory (context_size);
#else
  return new TAO_Storable_Naming_Context_Factory (context_size);
#endif /* ACE_HAS_NEW_NOTHROW */
}

write()

int TAO_Naming_Server::write ( size_t  ndx ) const

protected

Definition at line 928 of file Naming_Server.cpp.

{
  const IOR_Bundle *b = bundle_at(ndx);
  if (b == 0)
    return -1;

  if (b->filename_.length() == 0)
    return 0;

  if (b->ior_.length() == 0)
    {
      if (TAO_debug_level > 0)
        {
          ORBSVCS_ERROR ((LM_ERROR,
                         ACE_TEXT ("IOR_Bundle::write called with ")
                          ACE_TEXT ("empty IOR \n")));
        }
      return -1;
    }

  FILE *iorf = ACE_OS::fopen (b->filename_.c_str(), ACE_TEXT("w"));
  if (iorf == 0)
    {
      if (TAO_debug_level > 0)
        {
          ORBSVCS_ERROR ((LM_ERROR,
                          ACE_TEXT("Unable to open %C for writing:(%u) %p\n"),
                          b->filename_.c_str(),
                          ACE_ERRNO_GET,
                          ACE_TEXT("IOR_Bundle::write")));
        }
      return -1;
    }
  ACE_OS::fprintf (iorf, "%s\n", b->ior_.c_str());
  ACE_OS::fclose (iorf);

  return 0;
}

write_ior_to_file()

int TAO_Naming_Server::write_ior_to_file ( const char *  ior_string, const char *  file_name  )

protected

Write the provided ior_string to the file. Return 0 if success.

Member Data Documentation

base_address_

void* TAO_Naming_Server::base_address_

protected

Address to be used for memory mapping Naming Service state file, identified by the <persistence_file_name_>.

Definition at line 241 of file Naming_Server.h.

bundle_size_

size_t TAO_Naming_Server::bundle_size_

protected

Definition at line 212 of file Naming_Server.h.

context_index_

TAO_Persistent_Context_Index* TAO_Naming_Server::context_index_

protected

Pointer to the object used to create/initialize the Naming Service when local persistent Naming Service is desired.

Definition at line 233 of file Naming_Server.h.

context_size_

size_t TAO_Naming_Server::context_size_

protected

Size of the hash_table allocated upon the creation of the Naming Service context (if one is created). Note: all the contexts created under the given context will use the same size for their initial hash table allocations.

Definition at line 222 of file Naming_Server.h.

ior_multicast_

TAO_IOR_Multicast* TAO_Naming_Server::ior_multicast_

protected

The ior_multicast event handler.

Definition at line 194 of file Naming_Server.h.

iors_

IOR_Bundle* TAO_Naming_Server::iors_

protected

Although this class only manages the root context info the FT class adds primary/backup IORs for the root context as well as IORs for LB groups as well.

Definition at line 211 of file Naming_Server.h.

multicast_

int TAO_Naming_Server::multicast_

protected

If not zero multicast is enabled.

Definition at line 225 of file Naming_Server.h.

ns_poa_

PortableServer::POA_var TAO_Naming_Server::ns_poa_

protected

The Naming Service POA.

Definition at line 203 of file Naming_Server.h.

orb_

CORBA::ORB_var TAO_Naming_Server::orb_

protected

The ORB.

Definition at line 197 of file Naming_Server.h.

persistence_dir_

const ACE_TCHAR* TAO_Naming_Server::persistence_dir_

protected

Path to the file to be used to store/read in Naming Service persistent state.

Definition at line 237 of file Naming_Server.h.

pid_file_name_

const ACE_TCHAR* TAO_Naming_Server::pid_file_name_

protected

File to output the process id.

Definition at line 206 of file Naming_Server.h.

root_poa_

PortableServer::POA_var TAO_Naming_Server::root_poa_

protected

The Root POA.

Definition at line 200 of file Naming_Server.h.

round_trip_timeout_

int TAO_Naming_Server::round_trip_timeout_

protected

If not zero use round trip timeout policy set to value specified.

Definition at line 264 of file Naming_Server.h.

servant_activator_

TAO_Storable_Naming_Context_Activator* TAO_Naming_Server::servant_activator_

protected

Need to retain the servant activator between calls to init_with_orb() and init_new_naming().

Definition at line 255 of file Naming_Server.h.

use_redundancy_

int TAO_Naming_Server::use_redundancy_

protected

If not zero support redundant naming servers.

Definition at line 261 of file Naming_Server.h.

use_round_trip_timeout_

int TAO_Naming_Server::use_round_trip_timeout_

protected

Definition at line 265 of file Naming_Server.h.

use_servant_activator_

int TAO_Naming_Server::use_servant_activator_

protected

If not zero use servant activator that uses flat file persistence.

Definition at line 249 of file Naming_Server.h.

use_storable_context_

int TAO_Naming_Server::use_storable_context_

protected

If not zero use flat file persistence.

Definition at line 244 of file Naming_Server.h.

---

The documentation for this class was generated from the following files:

• Naming_Server.h
• Naming_Server.cpp