cms/util/ReferenceManager.java

//---PACKAGE DECLARATION---
package uk.ac.ukc.iscream.refman;

//---IMPORTS---
import org.omg.CORBA.ORB;
import org.omg.CosNaming.*;
import org.omg.PortableServer.*;
import uk.ac.ukc.iscream.core.*;

/**
 * This class returns references for global system objects.
 * This class is used to create and return references to objects
 * that are required throughout the system.  Most of which
 * are CORBA based.  It also manages the ORB for the component.
 *
 * It is a singleton object with a static method to obtain a
 * reference to it.  This removes the need for passing
 * references to all the objects it contains throughout 
 * a component.
 *
 * @author  $Author: ajm4 $
 * @version $Id: ReferenceManager.java,v 1.1 2000/11/30 00:54:27 ajm4 Exp $
 */
public class ReferenceManager {

//---FINAL ATTRIBUTES---
   
    /**
     * The current CVS revision of this class
     */
    public final String REVISION = "$Revision: 1.1 $";
    
//---STATIC METHODS---

    /**
     * This creates the single instance of the ReferenceManager by
     * calling the private constructor.  If it is called twice, 
     * it detects an instance already exits and throws an exception.
     *
     * @param args the args to be passed to the ORB
     * @param name the name of the component that will use this singleton
     *
     * @return a reference to the ReferenceManager
     *
     * @throws AlreadyInitialisedException if this method has already been called
     */
    public static ReferenceManager init(String[] args, String name) throws AlreadyInitialisedException {
        if (_instance != null) {
            throw new AlreadyInitialisedException("init has already been called");
        }
        _instance = new ReferenceManager(args, name);
        return _instance;
    }
    
    /**
     * This returns a reference to the single instance of the
     * ReferenceManager.
     *
     * @return a reference to the ReferenceManager
     *
     * @throws NotInitialisedException if the reference manager has not been initialised
     */
    public static ReferenceManager getInstance() throws NotInitialisedException {
        if (_instance == null) {
            throw new NotInitialisedException("attempt to obtain reference when not initialised");
        }
        return _instance;
    }

//---CONSTRUCTORS---

    /**
     * This is a private constructor
     * This ensures that the system performs according to a Singleton design pattern
     *
     * @param args the args to be passed to the ORB
     * @param name the name of the component that will use this singleton
     */
    private ReferenceManager(String[] args, String name) {
        _orb = ORB.init(args, null);
        _name = name;
        getLogger().write(toString(), Logger.SYSINIT, "created");
    }

//---PUBLIC METHODS---

    /**
     * Obtains a CORBA reference through the naming service
     * for the named object.
     * This will throw a RuntimeException if there is an error
     *
     * @param name the name of the CORBA object to resolve
     *
     * @return a reference to the object
     */
    public org.omg.CORBA.Object getCORBARef(String name) {
        org.omg.CORBA.Object objRef = null;
        try {
            objRef = getNS().resolve(getNS().to_name(name));
        } catch (org.omg.CosNaming.NamingContextPackage.CannotProceed e) {
            throw new RuntimeException("\nCRITICAL:Naming Service Cannot Proceed - when resolving reference to " + name + "!\n" + 
                                         "         Please check with your CORBA naming service provider.");
        } catch (org.omg.CosNaming.NamingContextPackage.InvalidName e) {
            throw new RuntimeException("\nCRITICAL:Invalid Name - when resolving reference to " + name + "!\n" + 
                                         "         Please check with your CORBA naming service provider.");
        } catch (org.omg.CosNaming.NamingContextPackage.NotFound e) {
            throw new RuntimeException("\nCRITICAL:Not Found - when resolving reference to " + name + "!\n" + 
                                         "         Please check that this component is running.");
        }
        return objRef;
    }

    /** 
     * Binds a given servant with the given name
     * to the naming service.
     * This will throw a RuntimeException if there is an error
     *
     * @param objRef a reverence to the servant object
     * @param name the name to bind to the naming service with
     */
    public void bindToOrb(org.omg.PortableServer.Servant objRef, String name) {
        try {
            getNS().bind(getNS().to_name(name), getRootPOA().servant_to_reference(objRef));
        } catch (org.omg.PortableServer.POAPackage.WrongPolicy e) {
            throw new RuntimeException("\nCRITICAL:Wrong POA Policy - when binding " + name + "!\n" + 
                                         "         This indicates an error with your ORB.");
        } catch (org.omg.PortableServer.POAPackage.ServantNotActive e) {
            throw new RuntimeException("\nCRITICAL:ServantNotActive - when binding " + name + "!\n" + 
                                         "         This indicates an error with your ORB.");
        } catch (org.omg.CosNaming.NamingContextPackage.InvalidName e) {
            throw new RuntimeException("\nCRITICAL:Invalid Name - when binding " + name + "!\n" + 
                                         "         Please check with your CORBA naming service provider.");
        } catch (org.omg.CosNaming.NamingContextPackage.CannotProceed e) {
            throw new RuntimeException("\nCRITICAL:Naming Service Cannot Proceed - when binding " + name + "!\n" + 
                                         "         Please check with your CORBA naming service provider.");
        } catch (org.omg.CosNaming.NamingContextPackage.NotFound e) {
            throw new RuntimeException("\nCRITICAL:Naming Service Not Found - when binding " + name + "!\n" + 
                                         "         Please check with your CORBA naming service provider.");
        } catch (org.omg.CosNaming.NamingContextPackage.AlreadyBound e) {
            throw new RuntimeException("\nCRITICAL:Already Bound - when binding " + name + "!\n" + 
                                         "         Another component with this name is already running.");
        }
    }
    
    /**
     * Activates the POA
     * This will throw a RuntimeException if there is an error
     */
    public void activatePOA() {
        try {
            getRootPOA().the_POAManager().activate();
        } catch (org.omg.PortableServer.POAManagerPackage.AdapterInactive e) {
            throw new RuntimeException("\nCRITICAL:POA Set Inactive - when trying to activate POA!\n" + 
                                         "         This indicates an error with your ORB.");
        }
    }
    
    /**
     * Overrides the {@link java.lang.Object#toString() Object.toString()}
     * method to provide clean logging (every class should have this).
     *
     * @return the name of this class and its CVS revision
     */
    public String toString() {
        return getName() + "{" + getClass().getName() + "}(" + REVISION.substring(11, REVISION.length() - 2) + ")";
    }

//---PRIVATE METHODS---

//---ACCESSOR/MUTATOR METHODS---

    /**
     * Returns a reference to the ORB
     *
     * @return the reference this class holds
     */
    public ORB getORB() {
        return _orb;
    }

    /**
     * Returns a reference to the Root POA
     * This will throw a RuntimeException if there is an error
     *
     * @return the reference this class holds
     */
    public POA getRootPOA() {
        if (_rootPOA == null) {
            org.omg.CORBA.Object objRef = null;
            try {
                objRef = getORB().resolve_initial_references("RootPOA");
            } catch (org.omg.CORBA.ORBPackage.InvalidName e) {
                throw new RuntimeException("\nCRITICAL:Unable to resolve reference to the RootPOA!\n" + 
                                             "         This indicates an error with your ORB.");
            }
            _rootPOA = POAHelper.narrow(objRef);
        }
        return _rootPOA;
    }
    
    /**
     * Returns a reference to the Naming Service
     * This will throw a RuntimeException if there is an error
     *
     * @return the reference this class holds
     */
    public NamingContextExt getNS() {
        if (_ns == null) {
            org.omg.CORBA.Object objRef = null;
            try {
                objRef = getORB().resolve_initial_references("NameService");
            } catch (org.omg.CORBA.ORBPackage.InvalidName e) {
                throw new RuntimeException("\nCRITICAL:Unable to resolve reference to the Naming Service!\n" +
                                             "         Please check with your CORBA naming service provider.");
            }
            _ns = NamingContextExtHelper.narrow(objRef);
        }
        return _ns;
    }
    
    /**
     * Returns a reference to the configuration manager
     * This will throw a RuntimeException if there is an error
     *
     * @return the reference this class holds
     */
    public ConfigurationManager getCM() {
        if (_cm == null) {
            _cm = ConfigurationManagerHelper.narrow(getCORBARef("iscream.ConfigurationManager"));
        }
        return _cm;
    }

    /**
     * Returns a reference to the logger
     * This will throw a RuntimeException if there is an error
     *
     * @return the reference this class holds
     */
    public Logger getLogger() {
        if (_logger == null) {
            _logger = LoggerHelper.narrow(getCORBARef("iscream.Logger"));
        }
        return _logger;
    }
    
    /**
     * Returns a reference to the name
     *
     * @return the reference this class holds
     */
    public String getName() {
        return _name;
    }

//---ATTRIBUTES---
    
    /**
     * The ORB
     */
    private ORB _orb;
    
    /**
     * The Naming Service
     */
    private NamingContextExt _ns;
    
    /**
     * The Root POA
     */
    private POA _rootPOA;

    /**
     * The configuration manager
     */
    private ConfigurationManager _cm;

    /**
     * The logger
     */
    private Logger _logger;
    
    /**
     * The name
     */
    private String _name;

//---STATIC ATTRIBUTES---
    
    /**
     * A reference to the single instance of this class
     */
    private static ReferenceManager _instance; 
}
Revision:	1.2
Committed:	Thu Nov 30 02:19:31 2000 UTC (23 years, 5 months ago) by ajm
Branch:	MAIN
Changes since 1.1:	+81 -53 lines
Log Message:	Added more ORB support services
#	User	Rev	Content
1	ajm	1.1	//---PACKAGE DECLARATION---
2			package uk.ac.ukc.iscream.refman;
3
4			//---IMPORTS---
5			import org.omg.CORBA.ORB;
6			import org.omg.CosNaming.*;
7			import org.omg.PortableServer.*;
8			import uk.ac.ukc.iscream.core.*;
9
10			/**
11			* This class returns references for global system objects.
12			* This class is used to create and return references to objects
13			* that are required throughout the system. Most of which
14	ajm	1.2	* are CORBA based. It also manages the ORB for the component.
15	ajm	1.1	*
16			* It is a singleton object with a static method to obtain a
17			* reference to it. This removes the need for passing
18			* references to all the objects it contains throughout
19			* a component.
20			*
21	ajm	1.2	* @author $Author: ajm4 $
22			* @version $Id: ReferenceManager.java,v 1.1 2000/11/30 00:54:27 ajm4 Exp $
23	ajm	1.1	*/
24			public class ReferenceManager {
25
26			//---FINAL ATTRIBUTES---
27
28			/**
29			* The current CVS revision of this class
30			*/
31	ajm	1.2	public final String REVISION = "$Revision: 1.1 $";
32	ajm	1.1
33			//---STATIC METHODS---
34
35			/**
36			* This creates the single instance of the ReferenceManager by
37			* calling the private constructor. If it is called twice,
38			* it detects an instance already exits and throws an exception.
39			*
40			* @param args the args to be passed to the ORB
41			* @param name the name of the component that will use this singleton
42			*
43			* @return a reference to the ReferenceManager
44			*
45			* @throws AlreadyInitialisedException if this method has already been called
46			*/
47			public static ReferenceManager init(String[] args, String name) throws AlreadyInitialisedException {
48			if (_instance != null) {
49			throw new AlreadyInitialisedException("init has already been called");
50			}
51			_instance = new ReferenceManager(args, name);
52			return _instance;
53			}
54
55			/**
56			* This returns a reference to the single instance of the
57			* ReferenceManager.
58			*
59			* @return a reference to the ReferenceManager
60			*
61			* @throws NotInitialisedException if the reference manager has not been initialised
62			*/
63			public static ReferenceManager getInstance() throws NotInitialisedException {
64			if (_instance == null) {
65			throw new NotInitialisedException("attempt to obtain reference when not initialised");
66			}
67			return _instance;
68			}
69
70			//---CONSTRUCTORS---
71
72			/**
73			* This is a private constructor
74			* This ensures that the system performs according to a Singleton design pattern
75			*
76			* @param args the args to be passed to the ORB
77			* @param name the name of the component that will use this singleton
78			*/
79			private ReferenceManager(String[] args, String name) {
80			_orb = ORB.init(args, null);
81			_name = name;
82			getLogger().write(toString(), Logger.SYSINIT, "created");
83			}
84
85			//---PUBLIC METHODS---
86
87			/**
88	ajm	1.2	* Obtains a CORBA reference through the naming service
89			* for the named object.
90			* This will throw a RuntimeException if there is an error
91			*
92			* @param name the name of the CORBA object to resolve
93			*
94			* @return a reference to the object
95			*/
96			public org.omg.CORBA.Object getCORBARef(String name) {
97			org.omg.CORBA.Object objRef = null;
98			try {
99			objRef = getNS().resolve(getNS().to_name(name));
100			} catch (org.omg.CosNaming.NamingContextPackage.CannotProceed e) {
101			throw new RuntimeException("\nCRITICAL:Naming Service Cannot Proceed - when resolving reference to " + name + "!\n" +
102			" Please check with your CORBA naming service provider.");
103			} catch (org.omg.CosNaming.NamingContextPackage.InvalidName e) {
104			throw new RuntimeException("\nCRITICAL:Invalid Name - when resolving reference to " + name + "!\n" +
105			" Please check with your CORBA naming service provider.");
106			} catch (org.omg.CosNaming.NamingContextPackage.NotFound e) {
107			throw new RuntimeException("\nCRITICAL:Not Found - when resolving reference to " + name + "!\n" +
108			" Please check that this component is running.");
109			}
110			return objRef;
111			}
112
113			/**
114			* Binds a given servant with the given name
115			* to the naming service.
116			* This will throw a RuntimeException if there is an error
117			*
118			* @param objRef a reverence to the servant object
119			* @param name the name to bind to the naming service with
120			*/
121			public void bindToOrb(org.omg.PortableServer.Servant objRef, String name) {
122			try {
123			getNS().bind(getNS().to_name(name), getRootPOA().servant_to_reference(objRef));
124			} catch (org.omg.PortableServer.POAPackage.WrongPolicy e) {
125			throw new RuntimeException("\nCRITICAL:Wrong POA Policy - when binding " + name + "!\n" +
126			" This indicates an error with your ORB.");
127			} catch (org.omg.PortableServer.POAPackage.ServantNotActive e) {
128			throw new RuntimeException("\nCRITICAL:ServantNotActive - when binding " + name + "!\n" +
129			" This indicates an error with your ORB.");
130			} catch (org.omg.CosNaming.NamingContextPackage.InvalidName e) {
131			throw new RuntimeException("\nCRITICAL:Invalid Name - when binding " + name + "!\n" +
132			" Please check with your CORBA naming service provider.");
133			} catch (org.omg.CosNaming.NamingContextPackage.CannotProceed e) {
134			throw new RuntimeException("\nCRITICAL:Naming Service Cannot Proceed - when binding " + name + "!\n" +
135			" Please check with your CORBA naming service provider.");
136			} catch (org.omg.CosNaming.NamingContextPackage.NotFound e) {
137			throw new RuntimeException("\nCRITICAL:Naming Service Not Found - when binding " + name + "!\n" +
138			" Please check with your CORBA naming service provider.");
139			} catch (org.omg.CosNaming.NamingContextPackage.AlreadyBound e) {
140			throw new RuntimeException("\nCRITICAL:Already Bound - when binding " + name + "!\n" +
141			" Another component with this name is already running.");
142			}
143			}
144
145			/**
146			* Activates the POA
147			* This will throw a RuntimeException if there is an error
148			*/
149			public void activatePOA() {
150			try {
151			getRootPOA().the_POAManager().activate();
152			} catch (org.omg.PortableServer.POAManagerPackage.AdapterInactive e) {
153			throw new RuntimeException("\nCRITICAL:POA Set Inactive - when trying to activate POA!\n" +
154			" This indicates an error with your ORB.");
155			}
156			}
157
158			/**
159	ajm	1.1	* Overrides the {@link java.lang.Object#toString() Object.toString()}
160			* method to provide clean logging (every class should have this).
161			*
162			* @return the name of this class and its CVS revision
163			*/
164			public String toString() {
165			return getName() + "{" + getClass().getName() + "}(" + REVISION.substring(11, REVISION.length() - 2) + ")";
166			}
167
168			//---PRIVATE METHODS---
169
170			//---ACCESSOR/MUTATOR METHODS---
171
172			/**
173			* Returns a reference to the ORB
174			*
175			* @return the reference this class holds
176			*/
177			public ORB getORB() {
178			return _orb;
179			}
180
181			/**
182			* Returns a reference to the Root POA
183			* This will throw a RuntimeException if there is an error
184			*
185			* @return the reference this class holds
186			*/
187			public POA getRootPOA() {
188			if (_rootPOA == null) {
189			org.omg.CORBA.Object objRef = null;
190			try {
191			objRef = getORB().resolve_initial_references("RootPOA");
192			} catch (org.omg.CORBA.ORBPackage.InvalidName e) {
193	ajm	1.2	throw new RuntimeException("\nCRITICAL:Unable to resolve reference to the RootPOA!\n" +
194			" This indicates an error with your ORB.");
195	ajm	1.1	}
196			_rootPOA = POAHelper.narrow(objRef);
197			}
198			return _rootPOA;
199			}
200
201			/**
202			* Returns a reference to the Naming Service
203			* This will throw a RuntimeException if there is an error
204			*
205			* @return the reference this class holds
206			*/
207			public NamingContextExt getNS() {
208			if (_ns == null) {
209			org.omg.CORBA.Object objRef = null;
210			try {
211			objRef = getORB().resolve_initial_references("NameService");
212			} catch (org.omg.CORBA.ORBPackage.InvalidName e) {
213	ajm	1.2	throw new RuntimeException("\nCRITICAL:Unable to resolve reference to the Naming Service!\n" +
214			" Please check with your CORBA naming service provider.");
215	ajm	1.1	}
216			_ns = NamingContextExtHelper.narrow(objRef);
217			}
218			return _ns;
219			}
220
221			/**
222			* Returns a reference to the configuration manager
223			* This will throw a RuntimeException if there is an error
224			*
225			* @return the reference this class holds
226			*/
227			public ConfigurationManager getCM() {
228			if (_cm == null) {
229	ajm	1.2	_cm = ConfigurationManagerHelper.narrow(getCORBARef("iscream.ConfigurationManager"));
230	ajm	1.1	}
231			return _cm;
232			}
233
234			/**
235			* Returns a reference to the logger
236			* This will throw a RuntimeException if there is an error
237			*
238			* @return the reference this class holds
239			*/
240			public Logger getLogger() {
241			if (_logger == null) {
242	ajm	1.2	_logger = LoggerHelper.narrow(getCORBARef("iscream.Logger"));
243	ajm	1.1	}
244			return _logger;
245			}
246
247			/**
248			* Returns a reference to the name
249			*
250			* @return the reference this class holds
251			*/
252			public String getName() {
253			return _name;
254			}
255
256			//---ATTRIBUTES---
257
258			/**
259			* The ORB
260			*/
261			private ORB _orb;
262
263			/**
264			* The Naming Service
265			*/
266			private NamingContextExt _ns;
267
268			/**
269			* The Root POA
270			*/
271			private POA _rootPOA;
272
273			/**
274			* The configuration manager
275			*/
276			private ConfigurationManager _cm;
277
278			/**
279			* The logger
280			*/
281			private Logger _logger;
282
283			/**
284			* The name
285			*/
286			private String _name;
287
288			//---STATIC ATTRIBUTES---
289
290			/**
291			* A reference to the single instance of this class
292			*/
293			private static ReferenceManager _instance;
294			}