TAO_Storable_Naming_Context Class Reference

This class plays a role of a 'ConcreteImplementor' in the Bridge pattern architecture of the CosNaming::NamingContext implementation. More...

#include <Storable_Naming_Context.h>

Inheritance diagram for TAO_Storable_Naming_Context:

[legend]Collaboration diagram for TAO_Storable_Naming_Context:

[legend]List of all members.

Public Types
typedef TAO_Storable_Bindings_Map::HASH_MAP	HASH_MAP
	Underlying data structure - typedef for ease of use.
Public Member Functions
	TAO_Storable_Naming_Context (CORBA::ORB_ptr orb, PortableServer::POA_ptr poa, const char *poa_id, TAO_Naming_Service_Persistence_Factory *factory, const ACE_TCHAR *persistence_directory, size_t hash_table_size=ACE_DEFAULT_MAP_SIZE)
	Constructor.
virtual	~TAO_Storable_Naming_Context (void)
	Destructor.
virtual CosNaming::NamingContext_ptr	new_context (void)
virtual void	list (CORBA::ULong how_many, CosNaming::BindingList_out &bl, CosNaming::BindingIterator_out &bi)
virtual void	rebind (const CosNaming::Name &n, CORBA::Object_ptr obj)
virtual void	bind (const CosNaming::Name &n, CORBA::Object_ptr obj)
virtual void	bind_context (const CosNaming::Name &n, CosNaming::NamingContext_ptr nc)
virtual void	rebind_context (const CosNaming::Name &n, CosNaming::NamingContext_ptr nc)
virtual CORBA::Object_ptr	resolve (const CosNaming::Name &n)
virtual void	unbind (const CosNaming::Name &n)
virtual CosNaming::NamingContext_ptr	bind_new_context (const CosNaming::Name &n)
virtual void	destroy (void)
Static Public Member Functions
CosNaming::NamingContext_ptr	make_new_context (CORBA::ORB_ptr orb, PortableServer::POA_ptr poa, const char *poa_id, size_t context_size, TAO_Naming_Service_Persistence_Factory *factory, const ACE_TCHAR *persistence_directory, TAO_Storable_Naming_Context **new_context)
CosNaming::NamingContext_ptr	recreate_all (CORBA::ORB_ptr orb, PortableServer::POA_ptr poa, const char *poa_id, size_t context_size, int reentering, TAO_Naming_Service_Persistence_Factory *factory, const ACE_TCHAR *persistence_directory, int use_redundancy)
Protected Member Functions
int	load_map (File_Open_Lock_and_Check *flck)
void	Write (TAO_Storable_Base &wrtr)
Protected Attributes
ACE_UINT32	counter_
	Counter used for generation of transients.
TAO_Storable_Bindings_Map *	storable_context_
CORBA::ORB_var	orb_
ACE_CString	name_
PortableServer::POA_var	poa_
	POA we are registered with.
TAO_Naming_Service_Persistence_Factory *	factory_
ACE_CString	persistence_directory_
	The directory in which to store the files.
size_t	hash_table_size_
	Save the hash table initial size.
time_t	last_changed_
	Disk time that match current memory state.
Static Protected Attributes
ACE_UINT32	gcounter_
int	redundant_
	Flag to tell use whether we are redundant or not.
const char *	root_name_
ACE_Auto_Ptr< TAO_Storable_Base >	gfl_
	The pointer to the global file used to allocate new contexts.
Friends
class	File_Open_Lock_and_Check

---

Detailed Description

This class plays a role of a 'ConcreteImplementor' in the Bridge pattern architecture of the CosNaming::NamingContext implementation.

This class provides a implementation of the NamingContext functionality, i.e., the state can be preserved across process boundaries. Derives from TAO_Hash_Naming_Context and uses TAO_Storable_Bindings_Map to store name to object bindings.

Definition at line 218 of file Storable_Naming_Context.h.

---

Member Typedef Documentation

typedef TAO_Storable_Bindings_Map::HASH_MAP TAO_Storable_Naming_Context::HASH_MAP

Underlying data structure - typedef for ease of use. Definition at line 224 of file Storable_Naming_Context.h.

---

Constructor & Destructor Documentation

TAO_Storable_Naming_Context::TAO_Storable_Naming_Context (  CORBA::ORB_ptr  orb, PortableServer::POA_ptr  poa, const char *  poa_id, TAO_Naming_Service_Persistence_Factory *  factory, const ACE_TCHAR *  persistence_directory, size_t  hash_table_size = ACE_DEFAULT_MAP_SIZE )

Constructor. Definition at line 546 of file Storable_Naming_Context.cpp. References ACE_TEXT_ALWAYS_CHAR, ACE_TRACE, hash_table_size_, last_changed_, persistence_directory_, and storable_context_. : TAO_Hash_Naming_Context (poa, poa_id), counter_ (0), storable_context_ (0), orb_(CORBA::ORB::_duplicate (orb)), name_ (poa_id), poa_ (PortableServer::POA::_duplicate (poa)), factory_(factory), persistence_directory_ (ACE_TEXT_ALWAYS_CHAR(persistence_directory)), hash_table_size_(hash_table_size), last_changed_(0) { ACE_TRACE("TAO_Storable_Naming_Context"); }

TAO_Storable_Naming_Context::~TAO_Storable_Naming_Context (  void   )  [virtual]

Destructor. Definition at line 568 of file Storable_Naming_Context.cpp. References ACE_CString, ACE_DEBUG, ACE_TEXT, ACE_TRACE, ACE_Auto_Basic_Ptr< X >::get(), LM_DEBUG, and TAO_debug_level. { ACE_TRACE("~TAO_Storable_Naming_Context"); // If we're in the DTOR as a result of the destroy() operation, // then we go ahead and delete the file. Otherwise, we leave the // file around because they need to be there for persistence. if (this->destroyed_) { // Make sure we delete the associated stream ACE_CString file_name (this->persistence_directory_); file_name += "/"; file_name += this->name_; // Now delete the file ACE_Auto_Ptr<TAO_Storable_Base> fl ( this->factory_->create_stream(file_name.c_str(), ACE_TEXT("r")) ); if (fl.get()) { if (TAO_debug_level > 5) ACE_DEBUG ((LM_DEBUG, "(%P|%t) NameService: removing file %s\n", file_name.fast_rep())); fl->remove (); } } }

---

Member Function Documentation

void TAO_Storable_Naming_Context::bind (  const CosNaming::Name &  n, CORBA::Object_ptr  obj )  [virtual]

Create a binding for name and object in the naming context. Compound names are treated as follows: ctx->bind (<c1; c2; c3; cn>, obj) = (ctx->resolve (<c1; c2; cn-1>))->bind (, obj) if the there already exists a binding for the specified name, exception is thrown. Naming contexts should be bound using and in order to participate in name resolution later. Reimplemented from TAO_Hash_Naming_Context. Definition at line 1208 of file Storable_Naming_Context.cpp. References ACE_GUARD_THROW_EX, ACE_SYNCH_RECURSIVE_MUTEX, ACE_TRACE, TAO_Bindings_Map::bind(), TAO_Hash_Naming_Context::get_context(), CosNaming::Name, TAO_Storable_Naming_Context::File_Open_Lock_and_Check::peer(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::release(), and Write(). { ACE_TRACE("TAO_Storable_Naming_Context::bind"); // Get the length of the name. CORBA::ULong name_len = n.length (); // Check for invalid name. if (name_len == 0) throw CosNaming::NamingContext::InvalidName(); // we didn't need a lock to check the input arg, but now we do ACE_GUARD_THROW_EX (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); // Open the backing file File_Open_Lock_and_Check flck(this, name_len > 1 ? "r" : "rw"); // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) throw CORBA::OBJECT_NOT_EXIST (); // If we received compound name, resolve it to get the context in // which the binding should take place, then perform the binding // on target context. if (name_len > 1) { // This had been a read on the file so now we are done with it flck.release(); CosNaming::NamingContext_var context = get_context (n); CosNaming::Name simple_name; simple_name.length (1); simple_name[0] = n[name_len - 1]; context->bind (simple_name, obj); } // If we received a simple name, we need to bind it in this context. else { // Try binding the name. int result = this->context_->bind (n[0].id, n[0].kind, obj, CosNaming::nobject); if (result == 1) throw CosNaming::NamingContext::AlreadyBound(); // Something went wrong with the internal structure else if (result == -1) throw CORBA::INTERNAL (); this->Write(flck.peer()); } }

void TAO_Storable_Naming_Context::bind_context (  const CosNaming::Name &  n, CosNaming::NamingContext_ptr  nc )  [virtual]

This is the version of specifically for binding naming contexts, so that they will participate in name resolution when compound names are passed to be resolved. Reimplemented from TAO_Hash_Naming_Context. Definition at line 814 of file Storable_Naming_Context.cpp. References ACE_GUARD_THROW_EX, ACE_SYNCH_RECURSIVE_MUTEX, ACE_TRACE, TAO_Bindings_Map::bind(), TAO_Hash_Naming_Context::get_context(), CORBA::is_nil(), CosNaming::Name, TAO_Storable_Naming_Context::File_Open_Lock_and_Check::peer(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::release(), and Write(). Referenced by bind_new_context(). { ACE_TRACE("TAO_Storable_Naming_Context::bind_context"); // Get the length of the name. CORBA::ULong name_len = n.length (); // Check for invalid name. if (name_len == 0) throw CosNaming::NamingContext::InvalidName(); // Do not allow binding of nil context reference. if (CORBA::is_nil (nc)) throw CORBA::BAD_PARAM (); // we didn't need a lock to check the input arg, but now we do ACE_GUARD_THROW_EX (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); // Open the backing file File_Open_Lock_and_Check flck(this, name_len > 1 ? "r" : "rw"); // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) throw CORBA::OBJECT_NOT_EXIST (); // If we received compound name, resolve it to get the context in // which the binding should take place, then perform the binding // on target context. if (name_len > 1) { // This had been a read on the file so now we are done with it flck.release(); CosNaming::NamingContext_var context = get_context (n); CosNaming::Name simple_name; simple_name.length (1); simple_name[0] = n[name_len - 1]; context->bind_context (simple_name, nc); } // If we received a simple name, we need to bind it in this context. else { // Try binding the name. int result = this->context_->bind (n[0].id, n[0].kind, nc, CosNaming::ncontext); if (result == 1) throw CosNaming::NamingContext::AlreadyBound(); // Something went wrong with the internal structure else if (result == -1) throw CORBA::INTERNAL (); this->Write(flck.peer()); } }

CosNaming::NamingContext_ptr TAO_Storable_Naming_Context::bind_new_context (  const CosNaming::Name &  n  )  [virtual]

This operation creates a new context and binds it to the name supplied as an argument. The newly-created context is implemented by the same server as the context in which it was bound (the name argument excluding the last component). Reimplemented from TAO_Hash_Naming_Context. Definition at line 1081 of file Storable_Naming_Context.cpp. References ACE_GUARD_THROW_EX, ACE_SYNCH_RECURSIVE_MUTEX, ACE_TRACE, bind_context(), TAO_Hash_Naming_Context::get_context(), CosNaming::Name, new_context(), and TAO_Storable_Naming_Context::File_Open_Lock_and_Check::release(). { ACE_TRACE("bind_new_context"); // Get the length of the name. CORBA::ULong name_len = n.length (); // Check for invalid name. if (name_len == 0) throw CosNaming::NamingContext::InvalidName(); ACE_GUARD_THROW_EX (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) throw CORBA::OBJECT_NOT_EXIST (); // Open the backing file File_Open_Lock_and_Check flck(this, name_len > 1 ? "r" : "rw"); // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) throw CORBA::OBJECT_NOT_EXIST (); // If we received compound name, resolve it to get the context in // which the binding should take place, then perform the operation on // target context. if (name_len > 1) { // This had been a read on the file so now we are done with it flck.release(); CosNaming::NamingContext_var context = get_context (n); CosNaming::Name simple_name; simple_name.length (1); simple_name[0] = n[name_len - 1]; return context->bind_new_context (simple_name); } // If we received a simple name, we need to bind it in this context. // This had been a read on the file so now we are done with it flck.release(); // Stores our new Naming Context. CosNaming::NamingContext_var result = CosNaming::NamingContext::_nil (); // Create new context. result = new_context (); // Bind the new context to the name. try { bind_context (n, result.in ()); } catch (const CORBA::Exception&) { { try { result->destroy (); } catch (const CORBA::Exception&) { // Do nothing? } } // Re-raise the exception in bind_context() throw; } return result._retn (); }

void TAO_Storable_Naming_Context::destroy (  void   )  [virtual]

Delete the naming context. The user should take care to any bindings in which the given context is bound to some names, to avoid dangling references when invoking operation. NOTE: is a no-op on the root context. NOTE: after is invoked on a Naming Context, all BindingIterators associated with that Naming Context are also destroyed. Reimplemented from TAO_Hash_Naming_Context. Definition at line 1162 of file Storable_Naming_Context.cpp. References TAO_Hash_Naming_Context::_default_POA(), ACE_GUARD_THROW_EX, ACE_SYNCH_RECURSIVE_MUTEX, ACE_TRACE, TAO_Bindings_Map::current_size(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::peer(), TAO_Hash_Naming_Context::root(), and Write(). { ACE_TRACE("destroy"); ACE_GUARD_THROW_EX (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); // Open the backing file File_Open_Lock_and_Check flck(this, "rw"); // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) throw CORBA::OBJECT_NOT_EXIST (); if (this->context_->current_size () != 0) throw CosNaming::NamingContext::NotEmpty(); // Destroy is a no-op on a root context. if (root ()) return; else { this->destroyed_ = 2; // Remove self from POA. Because of reference counting, the POA // will automatically delete the servant when all pending requests // on this servant are complete. PortableServer::POA_var poa = this->_default_POA (); PortableServer::ObjectId_var id = PortableServer::string_to_ObjectId (poa_id_.fast_rep ()); poa->deactivate_object (id.in ()); this->Write(flck.peer()); } }

void TAO_Storable_Naming_Context::list (  CORBA::ULong  how_many, CosNaming::BindingList_out &  bl, CosNaming::BindingIterator_out &  bi )  [virtual]

Returns at most the requested number of bindings in . If the naming context contains additional bindings, they are returned with a BindingIterator. In the naming context does not contain any additional bindings returned as null. Implements TAO_Naming_Context_Impl. Definition at line 1269 of file Storable_Naming_Context.cpp. References ACE_GUARD_THROW_EX, ACE_NEW_THROW_EX, ACE_SYNCH_RECURSIVE_MUTEX, ACE_TRACE, CosNaming::BindingList, TAO_Bindings_Map::current_size(), TAO_Storable_Bindings_Map::map(), ACE_Auto_Basic_Ptr< X >::release(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::release(), ACE_OS::sprintf(), and storable_context_. { ACE_TRACE("list"); // Allocate nil out parameters in case we won't be able to complete // the operation. bi = CosNaming::BindingIterator::_nil (); ACE_NEW_THROW_EX (bl, CosNaming::BindingList (0), CORBA::NO_MEMORY ()); // Obtain a lock before we proceed with the operation. ACE_GUARD_THROW_EX (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); // Open the backing file File_Open_Lock_and_Check flck(this, "r"); // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) throw CORBA::OBJECT_NOT_EXIST (); // We have the map in memory, let the disk go flck.release(); // Dynamically allocate iterator for traversing the underlying hash map. HASH_MAP::ITERATOR *hash_iter = 0; ACE_NEW_THROW_EX (hash_iter, HASH_MAP::ITERATOR (storable_context_->map ()), CORBA::NO_MEMORY ()); // Store <hash_iter temporarily in auto pointer, in case we'll have // some failures and throw an exception. ACE_Auto_Basic_Ptr<HASH_MAP::ITERATOR> temp (hash_iter); // Silliness below is required because of broken old g++!!! E.g., // without it, we could have just said HASH_MAP::ITERATOR everywhere we use ITER_DEF. typedef ACE_Hash_Map_Manager<TAO_Storable_ExtId, TAO_Storable_IntId, ACE_Null_Mutex>::ITERATOR ITER_DEF; typedef ACE_Hash_Map_Manager<TAO_Storable_ExtId, TAO_Storable_IntId, ACE_Null_Mutex>::ENTRY ENTRY_DEF; // Typedef to the type of BindingIterator servant for ease of use. typedef TAO_Bindings_Iterator<ITER_DEF, ENTRY_DEF> ITER_SERVANT; // A pointer to BindingIterator servant. ITER_SERVANT *bind_iter = 0; // Number of bindings that will go into the BindingList <bl>. CORBA::ULong n; // Calculate number of bindings that will go into <bl>. if (this->context_->current_size () > how_many) n = how_many; else n = static_cast<CORBA::ULong> (this->context_->current_size ()); // Use the hash map iterator to populate <bl> with bindings. bl->length (n); ENTRY_DEF *hash_entry = 0; for (CORBA::ULong i = 0; i < n; i++) { hash_iter->next (hash_entry); hash_iter->advance (); if (ITER_SERVANT::populate_binding (hash_entry, bl[i]) == 0) throw CORBA::NO_MEMORY(); } // Now we are done with the BindingsList, and we can follow up on // the BindingIterator business. // If we do not need to pass back BindingIterator. if (this->context_->current_size () <= how_many) return; else { // *** This is a problem. Is there an exception we can throw? *** ACE_UNUSED_ARG (bind_iter); throw CORBA::NO_IMPLEMENT (); #if 0 // Create a BindingIterator for return. ACE_NEW_THROW_EX (bind_iter, ITER_SERVANT (this, hash_iter, this->poa_.in (), this->lock_), CORBA::NO_MEMORY ()); // Release <hash_iter> from auto pointer, and start using // reference counting to control our servant. temp.release (); PortableServer::ServantBase_var iter = bind_iter; // Increment reference count on this Naming Context, so it doesn't get // deleted before the BindingIterator servant gets deleted. interface_->_add_ref (); // Register with the POA. char poa_id[BUFSIZ]; ACE_OS::sprintf (poa_id, "%s_%d", this->poa_id_.c_str (), this->counter_++); PortableServer::ObjectId_var id = PortableServer::string_to_ObjectId (poa_id); this->poa_->activate_object_with_id (id.in (), bind_iter); bi = bind_iter->_this (); #endif /* 0 */ } }

int TAO_Storable_Naming_Context::load_map (  File_Open_Lock_and_Check *  flck  )  [protected]

Definition at line 350 of file Storable_Naming_Context.cpp. References ACE_NEW_THROW_EX, ACE_TRACE, TAO_Storable_Bindings_Map::bind(), TAO_Storable_Base::clear(), TAO_NS_Persistence_Header::destroyed(), TAO_Storable_Base::good(), hash_table_size_, TAO_NS_Persistence_Record::id(), TAO_NS_Persistence_Record::kind(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::peer(), TAO_NS_Persistence_Record::ref(), TAO_NS_Persistence_Header::size(), storable_context_, and TAO_NS_Persistence_Record::type(). Referenced by TAO_Storable_Naming_Context::File_Open_Lock_and_Check::File_Open_Lock_and_Check(). { ACE_TRACE("load_map"); // assume file already open for reading TAO_Storable_Bindings_Map *bindings_map; // create the new bindings map ACE_NEW_THROW_EX (bindings_map, TAO_Storable_Bindings_Map (hash_table_size_,orb_.in()), CORBA::NO_MEMORY ()); // get the data for this bindings map from the file TAO_NS_Persistence_Header header; TAO_NS_Persistence_Record record; // we are only using the size from this header flck->peer() >> header; if (!flck->peer ().good ()) { flck->peer ().clear (); throw CORBA::INTERNAL (); } // reset the destroyed flag this->destroyed_ = header.destroyed(); // read in the data for the map for (unsigned int i= 0u; i<header.size(); ++i) { flck->peer() >> record; if (!flck->peer ().good ()) { flck->peer ().clear (); throw CORBA::INTERNAL (); } if (TAO_NS_Persistence_Record::LOCAL_NCONTEXT == record.type ()) { PortableServer::ObjectId_var id = PortableServer::string_to_ObjectId (record.ref ().c_str ()); const char *intf = interface_->_interface_repository_id (); CORBA::Object_var objref = poa_->create_reference_with_id (id.in (), intf); bindings_map->bind ( record.id ().c_str (), record.kind ().c_str (), objref.in (), CosNaming::ncontext ); } else { CORBA::Object_var objref = orb_->string_to_object (record.ref ().c_str ()); bindings_map->bind ( record.id ().c_str (), record.kind ().c_str (), objref.in (), ((TAO_NS_Persistence_Record::REMOTE_NCONTEXT == record.type ()) ? CosNaming::ncontext // REMOTE_NCONTEXT : CosNaming::nobject )); // OBJREF } } storable_context_ = bindings_map; context_ = storable_context_; return 0; }

CosNaming::NamingContext_ptr TAO_Storable_Naming_Context::make_new_context (  CORBA::ORB_ptr  orb, PortableServer::POA_ptr  poa, const char *  poa_id, size_t  context_size, TAO_Naming_Service_Persistence_Factory *  factory, const ACE_TCHAR *  persistence_directory, TAO_Storable_Naming_Context **  new_context )  [static]

This utility method factors out the code needed to create a new Storable Naming Context servant and activate it under the specified POA with the specified id. This function is static so that the code can be used, both from inside the class (e.g., ), and from outside (e.g., Naming_Utils.cpp). Definition at line 599 of file Storable_Naming_Context.cpp. References ACE_NEW_THROW_EX, ACE_TRACE, and ACE_Auto_Basic_Ptr< X >::release(). Referenced by new_context(), and recreate_all(). { ACE_TRACE("make_new_context"); // Store the stub we will return here. CosNaming::NamingContext_var result; // Put together a servant for the new Naming Context. TAO_Storable_Naming_Context *context_impl = 0; ACE_NEW_THROW_EX (context_impl, TAO_Storable_Naming_Context (orb, poa, poa_id, factory, persistence_directory, context_size), CORBA::NO_MEMORY ()); // Put <context_impl> into the auto pointer temporarily, in case next // allocation fails. ACE_Auto_Basic_Ptr<TAO_Storable_Naming_Context> temp (context_impl); TAO_Naming_Context *context = 0; ACE_NEW_THROW_EX (context, TAO_Naming_Context (context_impl), CORBA::NO_MEMORY ()); // Let <implementation> know about it's <interface>. context_impl->interface (context); // Release auto pointer, and start using reference counting to // control our servant. temp.release (); PortableServer::ServantBase_var s = context; // Register the new context with the POA. PortableServer::ObjectId_var id = PortableServer::string_to_ObjectId (poa_id); // If we try to register a naming context that is already registered, // the following activation causes a POA::ObjectAlreadyActive exception be // thrown which is transmitted as a CORBA::UNKNOWN on the wire. To rectify // this problem, we explicitly throw the correct INS exception in // this situation. try { poa->activate_object_with_id (id.in (), context); } catch (const PortableServer::POA::ObjectAlreadyActive&) { throw CosNaming::NamingContext::AlreadyBound(); } result = context->_this (); // return the address of the new context object so that caller can finish *new_context = context_impl; return result._retn (); }

CosNaming::NamingContext_ptr TAO_Storable_Naming_Context::new_context (  void   )  [virtual]

This operation returns a new naming context implemented by the same naming server in which the operation was invoked. The context is not bound. Implements TAO_Naming_Context_Impl. Definition at line 669 of file Storable_Naming_Context.cpp. References ACE_GUARD_THROW_EX, ACE_NEW_THROW_EX, ACE_SYNCH_RECURSIVE_MUTEX, ACE_TEXT_CHAR_TO_TCHAR, ACE_TRACE, TAO_Hash_Naming_Context::context_, TAO_NS_Persistence_Global::counter(), gcounter_, ACE_Auto_Basic_Ptr< X >::get(), gfl_, hash_table_size_, make_new_context(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::peer(), redundant_, ACE_Auto_Basic_Ptr< X >::release(), root_name_, ACE_OS::sprintf(), storable_context_, TAO_Storable_Bindings_Map::total_size(), and Write(). Referenced by bind_new_context(). { ACE_TRACE("new_context"); ACE_GUARD_THROW_EX (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); { // Open the backing file File_Open_Lock_and_Check flck(this, "r"); // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) throw CORBA::OBJECT_NOT_EXIST (); } TAO_NS_Persistence_Global global; // Generate a POA id for the new context. if(redundant_) { // acquire a lock on the file that holds our counter if (gfl_->open() != 0) { delete gfl_.release(); throw CORBA::PERSIST_STORE(); } if (gfl_ -> flock(0, 0, 0) != 0) throw CORBA::INTERNAL(); // get the counter from disk *gfl_.get() >> global; if (!gfl_.get ()->good () && gfl_.get ()->rdstate () != TAO_Storable_Base::eofbit) { gfl_.get ()->clear (); throw CORBA::INTERNAL (); } gcounter_ = global.counter(); // use it to generate a new name } char poa_id[BUFSIZ]; ACE_OS::sprintf (poa_id, "%s_%d", root_name_, gcounter_++); // then save it back on disk global.counter(gcounter_); *gfl_.get() << global; if(redundant_) { // and release our lock if (gfl_ -> flock(0, 0, 0) != 0) throw CORBA::INTERNAL(); gfl_->close(); } // Create a new context. TAO_Storable_Naming_Context *new_context = 0; CosNaming::NamingContext_var result = make_new_context (this->orb_.in (), this->poa_.in (), poa_id, this->storable_context_->total_size (), this->factory_, ACE_TEXT_CHAR_TO_TCHAR (this->persistence_directory_.c_str ()), &new_context); // Since this is a new context, make an empty map in it ACE_NEW_THROW_EX (new_context->storable_context_, TAO_Storable_Bindings_Map (hash_table_size_,orb_.in ()), CORBA::NO_MEMORY ()); new_context->context_ = new_context->storable_context_; File_Open_Lock_and_Check flck(new_context, "wc"); new_context->Write(flck.peer()); return result._retn (); }

void TAO_Storable_Naming_Context::rebind (  const CosNaming::Name &  n, CORBA::Object_ptr  obj )  [virtual]

This is similar to operation above, except for when the binding for the specified name already exists in the specified context. In that case, the existing binding is replaced with the new one. Reimplemented from TAO_Hash_Naming_Context. Definition at line 751 of file Storable_Naming_Context.cpp. References ACE_GUARD_THROW_EX, ACE_SYNCH_RECURSIVE_MUTEX, ACE_TRACE, TAO_Hash_Naming_Context::get_context(), CosNaming::Name, TAO_Storable_Naming_Context::File_Open_Lock_and_Check::peer(), TAO_Bindings_Map::rebind(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::release(), and Write(). { ACE_TRACE("rebind"); // Get the length of the name. CORBA::ULong name_len = n.length (); // Check for invalid name. if (name_len == 0) throw CosNaming::NamingContext::InvalidName(); // we didn't need a lock to check the input arg, but now we do ACE_GUARD_THROW_EX (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); // Open the backing file File_Open_Lock_and_Check flck(this, name_len > 1 ? "r" : "rw"); // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) throw CORBA::OBJECT_NOT_EXIST (); // If we received compound name, resolve it to get the context in // which the rebinding should take place, then perform the rebinding // on target context. if (name_len > 1) { // This had been a read on the file so now we are done with it flck.release(); CosNaming::NamingContext_var context = get_context (n); CosNaming::Name simple_name; simple_name.length (1); simple_name[0] = n[name_len - 1]; context->rebind (simple_name, obj); } // If we received a simple name, we need to rebind it in this // context. else { int result = this->context_->rebind (n[0].id, n[0].kind, obj, CosNaming::nobject); // Check for error conditions. if (result == -1) throw CORBA::INTERNAL (); else if (result == -2) throw CosNaming::NamingContext::NotFound( CosNaming::NamingContext::not_object, n); this->Write(flck.peer()); } }

void TAO_Storable_Naming_Context::rebind_context (  const CosNaming::Name &  n, CosNaming::NamingContext_ptr  nc )  [virtual]

This is a version of specifically for naming contexts, so that they can participate in name resolution when compound names are passed. Reimplemented from TAO_Hash_Naming_Context. Definition at line 878 of file Storable_Naming_Context.cpp. References ACE_GUARD_THROW_EX, ACE_SYNCH_RECURSIVE_MUTEX, ACE_TRACE, TAO_Hash_Naming_Context::get_context(), CosNaming::Name, TAO_Storable_Naming_Context::File_Open_Lock_and_Check::peer(), TAO_Bindings_Map::rebind(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::release(), and Write(). { ACE_TRACE("rebind_context"); // Get the length of the name. CORBA::ULong name_len = n.length (); // Check for invalid name. if (name_len == 0) throw CosNaming::NamingContext::InvalidName(); // we didn't need a lock to check the input arg, but now we do ACE_GUARD_THROW_EX (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); // Open the backing file File_Open_Lock_and_Check flck(this, name_len > 1 ? "r" : "rw"); // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) throw CORBA::OBJECT_NOT_EXIST (); // If we received compound name, resolve it to get the context in // which the rebinding should take place, then perform the rebinding // on target context. if (name_len > 1) { // This had been a read on the file so now we are done with it flck.release(); CosNaming::NamingContext_var context = get_context (n); CosNaming::Name simple_name; simple_name.length (1); simple_name[0] = n[name_len - 1]; context->rebind_context (simple_name, nc); } // If we received a simple name, we need to rebind it in this // context. else { int result = this->context_->rebind (n[0].id, n[0].kind, nc, CosNaming::ncontext); // Check for error conditions. if (result == -1) throw CORBA::INTERNAL (); else if (result == -2) throw CosNaming::NamingContext::NotFound( CosNaming::NamingContext::not_context, n); this->Write(flck.peer()); } }

TAO_END_VERSIONED_NAMESPACE_DECL TAO_BEGIN_VERSIONED_NAMESPACE_DECL CosNaming::NamingContext_ptr TAO_Storable_Naming_Context::recreate_all (  CORBA::ORB_ptr  orb, PortableServer::POA_ptr  poa, const char *  poa_id, size_t  context_size, int  reentering, TAO_Naming_Service_Persistence_Factory *  factory, const ACE_TCHAR *  persistence_directory, int  use_redundancy )  [static]

Definition at line 1397 of file Storable_Naming_Context.cpp. References ACE_NEW_THROW_EX, ACE_TEXT, ACE_TEXT_ALWAYS_CHAR, ACE_TEXT_CHAR_TO_TCHAR, ACE_TRACE, ACE_TString, TAO_Hash_Naming_Context::context_, TAO_NS_Persistence_Global::counter(), TAO_Naming_Service_Persistence_Factory::create_stream(), gcounter_, ACE_Auto_Basic_Ptr< X >::get(), gfl_, make_new_context(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::peer(), redundant_, ACE_Auto_Basic_Ptr< X >::release(), ACE_Auto_Basic_Ptr< X >::reset(), root_name_, storable_context_, and Write(). Referenced by TAO_Naming_Server::init_new_naming(). { ACE_TRACE("recreate_all"); ACE_UNUSED_ARG (reentering); // Whether we are redundant is global redundant_ = use_redundancy; // Save the root name for later use root_name_ = poa_id; // Create a new context. TAO_Storable_Naming_Context *new_context = 0; CosNaming::NamingContext_var result = make_new_context (orb, poa, poa_id, context_size, factory, persistence_directory, &new_context); // Now does this already exist on disk? ACE_TString file_name(persistence_directory); file_name += ACE_TEXT("/"); file_name += ACE_TEXT_CHAR_TO_TCHAR(poa_id); ACE_Auto_Ptr<TAO_Storable_Base> fl (factory->create_stream(ACE_TEXT_ALWAYS_CHAR(file_name.c_str()), ACE_TEXT("r"))); if (fl->exists()) { // Load the map from disk File_Open_Lock_and_Check flck(new_context, "r"); } else { // Since this is a new context, make and empty map in it ACE_NEW_THROW_EX (new_context->storable_context_, TAO_Storable_Bindings_Map (context_size,orb), CORBA::NO_MEMORY ()); new_context->context_ = new_context->storable_context_; File_Open_Lock_and_Check flck(new_context, "wc"); new_context->Write(flck.peer()); } // build the global file name file_name += ACE_TEXT("_global"); // Create the stream for the counter used to uniquely creat context names gfl_.reset(factory->create_stream(ACE_TEXT_ALWAYS_CHAR(file_name.c_str()), ACE_TEXT("crw"))); if (gfl_->open() != 0) { delete gfl_.release(); throw CORBA::PERSIST_STORE(); } // get the counter from disk TAO_NS_Persistence_Global global; *gfl_.get() >> global; if (!gfl_.get ()->good () && gfl_.get ()->rdstate () != TAO_Storable_Base::eofbit) { gfl_.get ()->clear (); throw CORBA::INTERNAL (); } gcounter_ = global.counter(); if(redundant_) gfl_->close(); return result._retn (); }

CORBA::Object_ptr TAO_Storable_Naming_Context::resolve (  const CosNaming::Name &  n  )  [virtual]

Return object reference that is bound to the name. Compound name resolve is defined as follows: ctx->resolve (<c1; c2; cn>) = ctx->resolve (<c1; c2 cn-1>)->resolve () The naming service does not return the type of the object. Clients are responsible for "narrowing" the object to the appropriate type. Reimplemented from TAO_Hash_Naming_Context. Definition at line 939 of file Storable_Naming_Context.cpp. References CORBA::Object::_nil(), ACE_GUARD_THROW_EX, ACE_SYNCH_RECURSIVE_MUTEX, ACE_TRACE, TAO_Bindings_Map::find(), CORBA::is_nil(), CosNaming::Name, and TAO_Storable_Naming_Context::File_Open_Lock_and_Check::release(). { ACE_TRACE("resolve"); // Get the length of the name. CORBA::ULong name_len = n.length (); // Check for invalid name. if (name_len == 0) throw CosNaming::NamingContext::InvalidName(); // we didn't need a lock to check the input arg, but now we do ACE_GUARD_THROW_EX (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); // Open the backing file File_Open_Lock_and_Check flck(this, "r"); // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) throw CORBA::OBJECT_NOT_EXIST (); // Resolve the first component of the name. flck.release(); // Stores the binding type for the first name component. CosNaming::BindingType type; // Stores the object reference bound to the first name component. CORBA::Object_ptr obj = CORBA::Object::_nil (); if (this->context_->find (n[0].id, n[0].kind, obj, type) == -1) throw CosNaming::NamingContext::NotFound( CosNaming::NamingContext::missing_node, n); // Store the value in var to avoid memory leaks. CORBA::Object_var result = obj; // If the name we have to resolve is a compound name, we need to // resolve it recursively. if (name_len > 1) { CosNaming::NamingContext_var context = CosNaming::NamingContext::_nil (); if (type == CosNaming::ncontext) { // Narrow to NamingContext. context = CosNaming::NamingContext::_narrow (result.in ()); } else // The first name component wasn't bound to a NamingContext. throw CosNaming::NamingContext::NotFound( CosNaming::NamingContext::not_context, n); // If narrow failed... if (CORBA::is_nil (context.in ())) throw CosNaming::NamingContext::NotFound( CosNaming::NamingContext::not_context, n); else { // Successfully resolved the first name component, need to // recursively call resolve on <n> without the first component. // We need a name just like <n> but without the first // component. Instead of copying data we can reuse <n>'s // buffer since we will only be using it for 'in' parameters // (no modifications). CosNaming::Name rest_of_name (n.maximum () - 1, n.length () - 1, const_cast<CosNaming::NameComponent*> (n.get_buffer ()) + 1); // If there are any exceptions, they will propagate up. return context->resolve (rest_of_name); } } // If the name we had to resolve was simple, we just need to return // the result. return result._retn (); }

void TAO_Storable_Naming_Context::unbind (  const CosNaming::Name &  n  )  [virtual]

Remove the name binding from the context. When compound names are used, unbind is defined as follows: ctx->unbind (<c1; c2; cn>) = (ctx->resolve (<c1; c2; cn-1>))->unbind () Reimplemented from TAO_Hash_Naming_Context. Definition at line 1027 of file Storable_Naming_Context.cpp. References ACE_GUARD_THROW_EX, ACE_SYNCH_RECURSIVE_MUTEX, ACE_TRACE, TAO_Hash_Naming_Context::get_context(), CosNaming::Name, TAO_Storable_Naming_Context::File_Open_Lock_and_Check::peer(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::release(), TAO_Bindings_Map::unbind(), and Write(). { ACE_TRACE("unbind"); // Get the length of the name. CORBA::ULong name_len = n.length (); // Check for invalid name. if (name_len == 0) throw CosNaming::NamingContext::InvalidName(); // we didn't need a lock to check the input arg, but now we do ACE_GUARD_THROW_EX (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); // Open the backing file File_Open_Lock_and_Check flck(this, name_len > 1 ? "r" : "rw"); // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) throw CORBA::OBJECT_NOT_EXIST (); // If we received compound name, resolve it to get the context in // which the unbinding should take place, then perform the unbinding // on target context. if (name_len > 1) { // This had been a read on the file so now we are done with it flck.release(); CosNaming::NamingContext_var context = get_context (n); CosNaming::Name simple_name; simple_name.length (1); simple_name[0] = n[name_len - 1]; context->unbind (simple_name); } // If we received a simple name, we need to unbind it in this // context. else { if (this->context_->unbind (n[0].id, n[0].kind) == -1) throw CosNaming::NamingContext::NotFound( CosNaming::NamingContext::missing_node, n); this->Write(flck.peer()); } }

void TAO_Storable_Naming_Context::Write (  TAO_Storable_Base &  wrtr  )  [protected]

Definition at line 254 of file Storable_Naming_Context.cpp. References ACE_CString, ACE_TRACE, TAO_Storable_Bindings_Map::current_size(), TAO_NS_Persistence_Header::destroyed(), TAO_NS_Persistence_Record::id(), TAO_NS_Persistence_Record::kind(), TAO_Storable_Bindings_Map::map(), TAO_NS_Persistence_Record::ref(), TAO_NS_Persistence_Header::size(), storable_context_, and TAO_NS_Persistence_Record::type(). Referenced by bind(), bind_context(), destroy(), new_context(), rebind(), rebind_context(), recreate_all(), and unbind(). { ACE_TRACE("Write"); TAO_NS_Persistence_Header header; header.size (static_cast<unsigned int> (storable_context_->current_size())); header.destroyed (destroyed_); wrtr << header; if (0u == header.size ()) return; ACE_Hash_Map_Iterator<TAO_Storable_ExtId,TAO_Storable_IntId, ACE_Null_Mutex> it = storable_context_->map().begin(); ACE_Hash_Map_Iterator<TAO_Storable_ExtId,TAO_Storable_IntId, ACE_Null_Mutex> itend = storable_context_->map().end(); ACE_Hash_Map_Entry<TAO_Storable_ExtId,TAO_Storable_IntId> ent = *it; while (!(it == itend)) { TAO_NS_Persistence_Record record; ACE_CString name; CosNaming::BindingType bt = (*it).int_id_.type_; if (bt == CosNaming::ncontext) { CORBA::Object_var obj = orb_->string_to_object ((*it).int_id_.ref_.in ()); if (obj->_is_collocated ()) { // This is a local (i.e. non federated context) we therefore // store only the ObjectID (persistence filename) for the object. // The driving force behind storing ObjectIDs rather than IORs for // local contexts is to provide for a redundant naming service. // That is, a naming service that runs simultaneously on multiple // machines sharing a file system. It allows multiple redundant // copies to be started and stopped independently. // The original target platform was Tru64 Clusters where there was // a cluster address. In that scenario, clients may get different // servers on each request, hence the requirement to keep // synchronized to the disk. It also works on non-cluster system // where the client picks one of the redundant servers and uses it, // while other systems can pick different servers. (However in this // scenario, if a server fails and a client must pick a new server, // that client may not use any saved context IORs, instead starting // from the root to resolve names. So this latter mode is not quite // transparent to clients.) [Rich Seibel (seibel_r) of ociweb.com] PortableServer::ObjectId_var oid = poa_->reference_to_id (obj.in ()); CORBA::String_var nm = PortableServer::ObjectId_to_string (oid.in ()); const char *newname = nm.in (); name.set (newname); // The local ObjectID (persistance filename) record.type (TAO_NS_Persistence_Record::LOCAL_NCONTEXT); } else { // Since this is a foreign (federated) context, we can not store // the objectID (because it isn't in our storage), if we did, when // we restore, we would end up either not finding a permanent // record (and thus ending up incorrectly assuming the context was // destroyed) or loading another context altogether (just because // the contexts shares its objectID filename which is very likely). // [Simon Massey (sma) of prismtech.com] name.set ((*it).int_id_.ref_.in ()); // The federated context IOR record.type (TAO_NS_Persistence_Record::REMOTE_NCONTEXT); } } else // if (bt == CosNaming::nobject) // shouldn't be any other, can there? { name.set ((*it).int_id_.ref_.in ()); // The non-context object IOR record.type (TAO_NS_Persistence_Record::OBJREF); } record.ref(name); const char *myid = (*it).ext_id_.id(); ACE_CString id(myid); record.id(id); const char *mykind = (*it).ext_id_.kind(); ACE_CString kind(mykind); record.kind(kind); wrtr << record; it.advance(); } }

---

Friends And Related Function Documentation

friend class File_Open_Lock_and_Check [friend]

Definition at line 450 of file Storable_Naming_Context.h.

---

Member Data Documentation

ACE_UINT32 TAO_Storable_Naming_Context::counter_ [protected]

Counter used for generation of transients. Definition at line 361 of file Storable_Naming_Context.h.

TAO_Naming_Service_Persistence_Factory* TAO_Storable_Naming_Context::factory_ [protected]

Definition at line 378 of file Storable_Naming_Context.h. Referenced by TAO_Storable_Naming_Context::File_Open_Lock_and_Check::File_Open_Lock_and_Check().

ACE_UINT32 TAO_Storable_Naming_Context::gcounter_ [static, protected]

Global counter used for generation of POA ids for children Naming Contexts. Definition at line 27 of file Storable_Naming_Context.cpp. Referenced by new_context(), and recreate_all().

ACE_Auto_Ptr< TAO_Storable_Base > TAO_Storable_Naming_Context::gfl_ [static, protected]

The pointer to the global file used to allocate new contexts. Definition at line 28 of file Storable_Naming_Context.cpp. Referenced by new_context(), and recreate_all().

size_t TAO_Storable_Naming_Context::hash_table_size_ [protected]

Save the hash table initial size. Definition at line 384 of file Storable_Naming_Context.h. Referenced by load_map(), new_context(), and TAO_Storable_Naming_Context().

time_t TAO_Storable_Naming_Context::last_changed_ [protected]

Disk time that match current memory state. Definition at line 387 of file Storable_Naming_Context.h. Referenced by TAO_Storable_Naming_Context::File_Open_Lock_and_Check::File_Open_Lock_and_Check(), and TAO_Storable_Naming_Context().

ACE_CString TAO_Storable_Naming_Context::name_ [protected]

Definition at line 374 of file Storable_Naming_Context.h. Referenced by TAO_Storable_Naming_Context::File_Open_Lock_and_Check::File_Open_Lock_and_Check().

CORBA::ORB_var TAO_Storable_Naming_Context::orb_ [protected]

Definition at line 372 of file Storable_Naming_Context.h.

ACE_CString TAO_Storable_Naming_Context::persistence_directory_ [protected]

The directory in which to store the files. Definition at line 381 of file Storable_Naming_Context.h. Referenced by TAO_Storable_Naming_Context::File_Open_Lock_and_Check::File_Open_Lock_and_Check(), and TAO_Storable_Naming_Context().

PortableServer::POA_var TAO_Storable_Naming_Context::poa_ [protected]

POA we are registered with. Reimplemented from TAO_Hash_Naming_Context. Definition at line 376 of file Storable_Naming_Context.h.

int TAO_Storable_Naming_Context::redundant_ [static, protected]

Flag to tell use whether we are redundant or not. Definition at line 29 of file Storable_Naming_Context.cpp. Referenced by TAO_Storable_Naming_Context::File_Open_Lock_and_Check::File_Open_Lock_and_Check(), new_context(), recreate_all(), and TAO_Storable_Naming_Context::File_Open_Lock_and_Check::release().

TAO_BEGIN_VERSIONED_NAMESPACE_DECL const char * TAO_Storable_Naming_Context::root_name_ [static, protected]

Definition at line 26 of file Storable_Naming_Context.cpp. Referenced by new_context(), and recreate_all().

TAO_Storable_Bindings_Map* TAO_Storable_Naming_Context::storable_context_ [protected]

A pointer to the underlying data structure used to store name bindings. While our superclass (TAO_Hash_Naming_Context) also maintains a pointer to the data structure, keeping this pointer around saves us from the need to downcast when invoking non-virtual methods. Definition at line 370 of file Storable_Naming_Context.h. Referenced by TAO_Storable_Naming_Context::File_Open_Lock_and_Check::File_Open_Lock_and_Check(), list(), load_map(), new_context(), recreate_all(), TAO_Storable_Naming_Context(), and Write().

---

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

• Storable_Naming_Context.h
• Storable_Naming_Context.cpp

---