transientnamingcontext.java

java1.6众多例子参考

/*
 * @(#)TransientNamingContext.java	1.54 05/11/17
 *
 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

package com.sun.corba.se.impl.naming.cosnaming;

// Import general CORBA classes
import org.omg.CORBA.SystemException;
import org.omg.CORBA.Object;
import org.omg.CORBA.INTERNAL;
import org.omg.CORBA.CompletionStatus;
import org.omg.CORBA.ORB;
import org.omg.PortableServer.POA;

// Import org.omg.CosNaming types
import org.omg.CosNaming.Binding;
import org.omg.CosNaming.BindingType;
import org.omg.CosNaming.BindingTypeHolder;
import org.omg.CosNaming.BindingListHolder;
import org.omg.CosNaming.BindingIteratorHolder;
import org.omg.CosNaming.NameComponent;
import org.omg.CosNaming.NamingContext;

import java.util.logging.Logger;
import java.util.logging.Level;

import java.util.Hashtable;
import com.sun.corba.se.impl.orbutil.LogKeywords;
import com.sun.corba.se.impl.logging.NamingSystemException;
import com.sun.corba.se.spi.logging.CORBALogDomains;

/**
 * Class TransientNamingContext implements the methods defined
 * by NamingContextDataStore, and extends the NamingContextImpl class to
 * provide a servant implementation of CosNaming::NamingContext.
 * The TransientNamingContext uses a hash table
 * to store the mappings between bindings and object references and the
 * hash table is not persistent; thereby the name "transient".
 * This class should not be used directly; instead, the class
 * TransientNameService should be instantiated.
 * <p>
 * The keys in the hash table are InternalBindingKey objects, containing
 * a single NameComponent and implementing the proper functions, i.e.,
 * equals() and hashCode() in an efficient manner. The values in the hash
 * table are InternalBindingValues and store a org.omg.CosNaming::Binding and
 * the object reference associated with the binding. For iteration,
 * TransientBindingIterator objects are created, which are passed a cloned
 * copy of the hashtable. Since elements are inserted and deleted and
 * never modified, this provides stable iterators at the cost of cloning
 * the hash table.
 * <p>
 * To create and destroy object references, the TransientNamingContext
 * uses the orb.connect() and orb.disconnect() methods.
 *
 * @see NamingContextImpl
 * @see NamingContextDataStore
 * @see TransientBindingIterator
 * @see TransientNameService
 */
public class TransientNamingContext extends NamingContextImpl implements NamingContextDataStore
{
    private Logger readLogger, updateLogger, lifecycleLogger;

    // XXX: the wrapper calls are all preceded by logger updates.
    // These can be combined, and then we simply use 3 NamingSystemException wrappers,
    // for read, update, and lifecycl.
    private NamingSystemException wrapper ;

    /**
     * Constructs a new TransientNamingContext object.
     * @param orb an orb object.
     * @param initial the initial naming context.
     * @exception Exception a Java exception thrown of the base class cannot
     * initialize.   
     */
    public TransientNamingContext(com.sun.corba.se.spi.orb.ORB orb, 
	org.omg.CORBA.Object initial,
        POA nsPOA )
	throws java.lang.Exception
    {
	super(orb, nsPOA );
	wrapper = NamingSystemException.get( orb, CORBALogDomains.NAMING ) ;

	this.localRoot = initial;
        readLogger = orb.getLogger( CORBALogDomains.NAMING_READ);
        updateLogger = orb.getLogger( CORBALogDomains.NAMING_UPDATE);
        lifecycleLogger = orb.getLogger( 
            CORBALogDomains.NAMING_LIFECYCLE);
        lifecycleLogger.fine( "Root TransientNamingContext LIFECYCLE.CREATED" );
    }

    /**
     * Binds the object to the name component as the specified binding type.
     * It creates a InternalBindingKey object and a InternalBindingValue
     * object and inserts them in the hash table.
     * @param n A single org.omg.CosNaming::NameComponent under which the 
     * object will be bound.
     * @param obj An object reference to be bound under the supplied name.
     * @param bt The type of the binding (i.e., as object or as context).
     * @exception org.omg.CORBA.SystemException One of a fixed set of CORBA 
     * system exceptions.
     */
    public final void Bind(NameComponent n, org.omg.CORBA.Object obj,
			   BindingType bt)
	throws org.omg.CORBA.SystemException
    {
	// Create a key and a value
	InternalBindingKey key = new InternalBindingKey(n);
	NameComponent[] name = new NameComponent[1];
	name[0] = n;
	Binding b = new Binding(name,bt);
	InternalBindingValue value = new InternalBindingValue(b,null);
	value.theObjectRef = obj;
	// insert it
	InternalBindingValue oldValue =
	    (InternalBindingValue)this.theHashtable.put(key,value);

	if (oldValue != null) {
            updateLogger.warning( LogKeywords.NAMING_BIND + "Name " + 
                getName( n ) + " Was Already Bound" );
	    throw wrapper.transNcBindAlreadyBound() ;
	}
        if( updateLogger.isLoggable( Level.FINE ) ) {
            updateLogger.fine( LogKeywords.NAMING_BIND_SUCCESS + 
                "Name Component: " + n.id + "." + n.kind );
        }
    }

    /**
     * Resolves the supplied name to an object reference and returns
     * the type of the resolved binding. It creates a InternalBindingKey
     * and uses the key for looking up in the hash table. If nothing
     * is found an exception is thrown, otherwise the object reference
     * is returned and the binding type set.
     * @param n a NameComponent which is the name to be resolved.
     * @param bth the BindingType as an out parameter.
     * @return the object reference bound under the supplied name, null if not 
     * found.
     * @exception org.omg.CORBA.SystemException One of a fixed set of CORBA 
     * system exceptions.
     */
    public final org.omg.CORBA.Object Resolve(NameComponent n,
					      BindingTypeHolder bth)
	throws org.omg.CORBA.SystemException
    {
	// Is the initial naming context requested?
	if ( (n.id.length() == 0)
           &&(n.kind.length() == 0 ) )
        {
	    bth.value = BindingType.ncontext;
	    return localRoot;
	}
    
	// Create a key and lookup the value
	InternalBindingKey key = new InternalBindingKey(n);

	InternalBindingValue value = 
            (InternalBindingValue) this.theHashtable.get(key);
	if (value == null) return null;
        if( readLogger.isLoggable( Level.FINE ) ) {
            readLogger.fine( LogKeywords.NAMING_RESOLVE_SUCCESS 
                + "Namecomponent :" + getName( n ) );
        }
    
        // Copy out binding type and object reference
	bth.value = value.theBinding.binding_type;
	return value.theObjectRef;
    }

    /**
     * Deletes the binding with the supplied name. It creates a
     * InternalBindingKey and uses it to remove the value associated
     * with the key. If nothing is found an exception is thrown, otherwise
     * the element is removed from the hash table.
     * @param n a NameComponent which is the name to unbind
     * @return the object reference bound to the name, or null if not found.
     * @exception org.omg.CORBA.SystemException One of a fixed set of CORBA 
     * system exceptions.
     */
    public final org.omg.CORBA.Object Unbind(NameComponent n)
	throws org.omg.CORBA.SystemException
    {
	// Create a key and remove it from the hashtable
	InternalBindingKey key = new InternalBindingKey(n);
	InternalBindingValue value = 
            (InternalBindingValue)this.theHashtable.remove(key);

	// Return what was found
	if (value == null) {
            if( updateLogger.isLoggable( Level.FINE ) ) {
                updateLogger.fine( LogKeywords.NAMING_UNBIND_FAILURE +
                    " There was no binding with the name " + getName( n ) + 
                    " to Unbind " ); 
            }
	    return null;
        } else {
            if( updateLogger.isLoggable( Level.FINE ) ) {
                updateLogger.fine( LogKeywords.NAMING_UNBIND_SUCCESS +
                    " NameComponent:  " + getName( n ) ); 
            }
	    return value.theObjectRef;
       }
    }  

    /**
     * List the contents of this NamingContext. It creates a new
     * TransientBindingIterator object and passes it a clone of the
     * hash table and an orb object. It then uses the
     * newly created object to return the required number of bindings.
     * @param how_many The number of requested bindings in the BindingList.
     * @param bl The BindingList as an out parameter.
     * @param bi The BindingIterator as an out parameter.
     * @exception org.omg.CORBA.SystemException One of a fixed set of CORBA 
     * system exceptions.
     */
    public final void List(int how_many, BindingListHolder bl,
			   BindingIteratorHolder bi)
	throws org.omg.CORBA.SystemException
    {
	try {
	    // Create a new binding iterator servant with a copy of this 
            // hashtable. nsPOA is passed to the object so that it can 
            // de-activate itself from the Active Object Map when 
            // Binding Iterator.destroy is called.
	    TransientBindingIterator bindingIterator =
		new TransientBindingIterator(this.orb,
	        (Hashtable)this.theHashtable.clone(), nsPOA);
	    // Have it set the binding list
            bindingIterator.list(how_many,bl);
            
            byte[] objectId = nsPOA.activate_object( bindingIterator );
            org.omg.CORBA.Object obj = nsPOA.id_to_reference( objectId );
      
	    // Get the object reference for the binding iterator servant
	    org.omg.CosNaming.BindingIterator bindingRef = 
                org.omg.CosNaming.BindingIteratorHelper.narrow( obj );
      
	    bi.value = bindingRef;
	} catch (org.omg.CORBA.SystemException e) {
            readLogger.warning( LogKeywords.NAMING_LIST_FAILURE + e );
	    throw e;
	} catch (Exception e) {
	    // Convert to a CORBA system exception
            readLogger.severe( LogKeywords.NAMING_LIST_FAILURE + e );
	    throw wrapper.transNcListGotExc( e ) ;
	}
    }
  
    /**
     * Create a new NamingContext. It creates a new TransientNamingContext
     * object, passing it the orb object. 
     * @return an object reference for a new NamingContext object implemented
     * by this Name Server.
     * @exception org.omg.CORBA.SystemException One of a fixed set of CORBA 
     * system exceptions.
     */
    public final org.omg.CosNaming.NamingContext NewContext()
	throws org.omg.CORBA.SystemException
    {
	try {
	    // Create a new servant
	    TransientNamingContext transContext =
		new TransientNamingContext(
                (com.sun.corba.se.spi.orb.ORB) orb,localRoot, nsPOA);

            byte[] objectId = nsPOA.activate_object( transContext );
            org.omg.CORBA.Object obj = nsPOA.id_to_reference( objectId );
            lifecycleLogger.fine( "TransientNamingContext " +
                "LIFECYCLE.CREATE SUCCESSFUL" ); 
            return org.omg.CosNaming.NamingContextHelper.narrow( obj );

	} catch (org.omg.CORBA.SystemException e) {
            lifecycleLogger.log( 
                Level.WARNING, LogKeywords.LIFECYCLE_CREATE_FAILURE, e );
	    throw e;
	} catch (Exception e) {
            lifecycleLogger.log( 
                Level.WARNING, LogKeywords.LIFECYCLE_CREATE_FAILURE, e );
	    throw wrapper.transNcNewctxGotExc( e ) ;
	}
    }

    /**
     * Destroys this NamingContext by disconnecting from the ORB.
     * @exception org.omg.CORBA.SystemException One of a fixed set of CORBA 
     * system exceptions.
     */
    public final void Destroy()
	throws org.omg.CORBA.SystemException
    {
	// Destroy the object reference by disconnecting from the ORB
	try {
            byte[] objectId = nsPOA.servant_to_id( this );
            if( objectId != null ) {
                nsPOA.deactivate_object( objectId );
            }
            if( lifecycleLogger.isLoggable( Level.FINE ) ) {
                lifecycleLogger.fine( 
                    LogKeywords.LIFECYCLE_DESTROY_SUCCESS );
            }
	} catch (org.omg.CORBA.SystemException e) {
            lifecycleLogger.log( Level.WARNING, 
                LogKeywords.LIFECYCLE_DESTROY_FAILURE, e ); 
	    throw e;
	} catch (Exception e) { 
            lifecycleLogger.log( Level.WARNING, 
                LogKeywords.LIFECYCLE_DESTROY_FAILURE, e ); 
	    throw wrapper.transNcDestroyGotExc( e ) ;
	}
    }

    /**
     * A Utility Method For Logging..
     */
    private String getName( NameComponent n ) {
        return n.id + "." + n.kind;
    }

    /**
     * Return whether this NamingContext contains any bindings. It forwards
     * this request to the hash table.
     * @return true if this NamingContext contains no bindings.
     */
    public final boolean IsEmpty()
    {
	return this.theHashtable.isEmpty();
    }

    // A hashtable to store the bindings
    private final Hashtable  theHashtable = new Hashtable();

    /**
     * The local root naming context.
     */
    public org.omg.CORBA.Object localRoot;
}