ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/i-scream/projects/cms/source/server/uk/org/iscream/cms/server/componentmanager/ReferenceManager.java

Comparing projects/cms/source/server/uk/org/iscream/cms/server/componentmanager/ReferenceManager.java (file contents):
Revision 1.5 by ajm, Mon Dec 11 16:38:09 2000 UTC vs.
Revision 1.18 by tdb, Tue May 21 16:47:17 2002 UTC

#	Line 1 | Line 1
1	+	/*
2	+	* i-scream central monitoring system
3	+	* http://www.i-scream.org.uk
4	+	* Copyright (C) 2000-2002 i-scream
5	+	*
6	+	* This program is free software; you can redistribute it and/or
7	+	* modify it under the terms of the GNU General Public License
8	+	* as published by the Free Software Foundation; either version 2
9	+	* of the License, or (at your option) any later version.
10	+	*
11	+	* This program is distributed in the hope that it will be useful,
12	+	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	+	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14	+	* GNU General Public License for more details.
15	+	*
16	+	* You should have received a copy of the GNU General Public License
17	+	* along with this program; if not, write to the Free Software
18	+	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19	+	*/
20	+
21		//---PACKAGE DECLARATION---
22	<	package uk.ac.ukc.iscream.util;
22	>	package uk.org.iscream.cms.server.componentmanager;
23
24		//---IMPORTS---
25		import org.omg.CORBA.ORB;
26		import org.omg.CosNaming.*;
27		import org.omg.PortableServer.*;
28	<	import uk.ac.ukc.iscream.core.*;
28	>	import uk.org.iscream.cms.server.core.*;
29	>	import uk.org.iscream.cms.server.util.*;
30
31		/**
32		* This class returns references for global system objects.
#	Line 33 | Line 54 | public class ReferenceManager {
54		//---STATIC METHODS---
55
56		/**
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	–	/**
57		* This returns a reference to the single instance of the
58		* ReferenceManager.
59		*
60	<	* @return a reference to the ReferenceManager
60	>	* This creates the single instance of the ReferenceManager
61	>	* if it does not exist by calling the private constructor.
62		*
63	<	* @throws NotInitialisedException if the reference manager has not been initialised
63	>	* @return a reference to the ReferenceManager
64		*/
65	<	public static ReferenceManager getInstance() throws NotInitialisedException {
65	>	public synchronized static ReferenceManager getInstance() {
66		if (_instance == null) {
67	<	throw new NotInitialisedException("attempt to obtain reference when not initialised");
67	>	_instance = new ReferenceManager();
68		}
69		return _instance;
70		}
#	Line 72 | Line 74 | public class ReferenceManager {
74		/**
75		* This is a private constructor
76		* 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
77		*/
78	<	private ReferenceManager(String[] args, String name) {
79	<	_orb = ORB.init(args, null);
81	<	_name = name;
78	>	private ReferenceManager() {
79	>	_orb = ORB.init(new String[] {}, null);
80		}
81
82		//---PUBLIC METHODS---
#	Line 86 | Line 84 | public class ReferenceManager {
84		/**
85		* Obtains a CORBA reference through the naming service
86		* for the named object.
87	<	* This will throw a Error if there is an error
87	>	* Calls the dieWithError() if any exceptions happen!
88		*
89		* @param name the name of the CORBA object to resolve
90		*
#	Line 97 | Line 95 | public class ReferenceManager {
95		try {
96		objRef = getNS().resolve(getNS().to_name(name));
97		} catch (org.omg.CosNaming.NamingContextPackage.CannotProceed e) {
98	<	throw new Error("\nCRITICAL:Naming Service Cannot Proceed - when resolving reference to " + name + "!\n" +
98	>	dieWithError("\nCRITICAL:Naming Service Cannot Proceed - when resolving reference to " + name + "!\n" +
99		"         Please check with your CORBA naming service provider.");
100		} catch (org.omg.CosNaming.NamingContextPackage.InvalidName e) {
101	<	throw new Error("\nCRITICAL:Invalid Name - when resolving reference to " + name + "!\n" +
101	>	dieWithError("\nCRITICAL:Invalid Name - when resolving reference to " + name + "!\n" +
102		"         Please check with your CORBA naming service provider.");
103		} catch (org.omg.CosNaming.NamingContextPackage.NotFound e) {
104	<	throw new Error("\nCRITICAL:Not Found - when resolving reference to " + name + "!\n" +
104	>	recoverWithError("\nCRITICAL:Not Found - when resolving reference to " + name + "!\n" +
105		"         Please check that this component is running.");
106		}
107		return objRef;
#	Line 112 | Line 110 | public class ReferenceManager {
110		/**
111		* Binds a given servant with the given name
112		* to the naming service.
113	<	* This will throw a Error if there is an error
113	>	* Calls the dieWithError() if any exceptions happen!
114		*
115		* @param objRef a reverence to the servant object
116		* @param name the name to bind to the naming service with
#	Line 121 | Line 119 | public class ReferenceManager {
119		try {
120		getNS().bind(getNS().to_name(name), getRootPOA().servant_to_reference(objRef));
121		} catch (org.omg.PortableServer.POAPackage.WrongPolicy e) {
122	<	throw new Error("\nCRITICAL:Wrong POA Policy - when binding " + name + "!\n" +
122	>	dieWithError("\nCRITICAL:Wrong POA Policy - when binding " + name + "!\n" +
123		"         This indicates an error with your ORB.");
124		} catch (org.omg.PortableServer.POAPackage.ServantNotActive e) {
125	<	throw new Error("\nCRITICAL:ServantNotActive - when binding " + name + "!\n" +
125	>	dieWithError("\nCRITICAL:ServantNotActive - when binding " + name + "!\n" +
126		"         This indicates an error with your ORB.");
127		} catch (org.omg.CosNaming.NamingContextPackage.InvalidName e) {
128	<	throw new Error("\nCRITICAL:Invalid Name - when binding " + name + "!\n" +
128	>	dieWithError("\nCRITICAL:Invalid Name - when binding " + name + "!\n" +
129		"         Please check with your CORBA naming service provider.");
130		} catch (org.omg.CosNaming.NamingContextPackage.CannotProceed e) {
131	<	throw new Error("\nCRITICAL:Naming Service Cannot Proceed - when binding " + name + "!\n" +
131	>	dieWithError("\nCRITICAL:Naming Service Cannot Proceed - when binding " + name + "!\n" +
132		"         Please check with your CORBA naming service provider.");
133		} catch (org.omg.CosNaming.NamingContextPackage.NotFound e) {
134	<	throw new Error("\nCRITICAL:Naming Service Not Found - when binding " + name + "!\n" +
134	>	recoverWithError("\nCRITICAL:Naming Service Not Found - when binding " + name + "!\n" +
135		"         Please check with your CORBA naming service provider.");
136		} catch (org.omg.CosNaming.NamingContextPackage.AlreadyBound e) {
137	<	throw new Error("\nCRITICAL:Already Bound - when binding " + name + "!\n" +
137	>	dieWithError("\nCRITICAL:Already Bound - when binding " + name + "!\n" +
138		"         Another component with this name is already running.");
139		}
140		}
141
142		/**
143		* Activates the POA
144	<	* This will throw a Error if there is an error
144	>	* Calls the dieWithError() if any exceptions happen!
145		*/
146		public void activatePOA() {
147		try {
148		getRootPOA().the_POAManager().activate();
149		} catch (org.omg.PortableServer.POAManagerPackage.AdapterInactive e) {
150	<	throw new Error("\nCRITICAL:POA Set Inactive - when trying to activate POA!\n" +
150	>	dieWithError("\nCRITICAL:POA Set Inactive - when trying to activate POA!\n" +
151		"         This indicates an error with your ORB.");
152		}
153		}
#	Line 158 | Line 156 | public class ReferenceManager {
156		* Overrides the {@link java.lang.Object#toString() Object.toString()}
157		* method to provide clean logging (every class should have this).
158		*
159	+	* This uses the uk.org.iscream.cms.server.util.NameFormat class
160	+	* to format the toString()
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) + ")";
165	>	return FormatName.getName(
166	>	_name,
167	>	getClass().getName(),
168	>	REVISION);
169		}
170
171		//---PRIVATE METHODS---
172
173	+	/**
174	+	* If there are any CORBA errors this method is called with the
175	+	* error message.
176	+	*
177	+	* The exception this throws is generic to CORBA communication
178	+	* problems, this is a Runtime exception and is typically only
179	+	* explicitly caught in the ComponentManager for the current VM
180	+	* The ComponentManager can then decide what course of action to
181	+	* take.
182	+	*
183	+	* Also, if it can, it will log the message with the logger.
184	+	*
185	+	* @param message the error message to die with
186	+	*/
187	+	private void recoverWithError(String message) throws ComponentCORBAException {
188	+	if (_logger != null) {
189	+	_logger.write(toString(), Logger.WARNING, "component CORBA error - " + message);
190	+	}
191	+	throw new ComponentCORBAException(message);
192	+	}
193	+
194	+
195	+	/**
196	+	* If there are any CORBA errors this method is called with the
197	+	* error message.
198	+	*
199	+	* Currently this prints the error, on the local err stream.  Will
200	+	* print to the logger if one is available.
201	+	*
202	+	* ANY CALLS TO THIS METHOD CAUSE
203	+	* THE SYSTEM TO EXIT WITH A NON
204	+	* ZERO CODE!
205	+	*
206	+	* @param message the error message to die with
207	+	*/
208	+	private void dieWithError(String message) {
209	+	System.err.println(message);
210	+	if (_logger != null) {
211	+	_logger.write(toString(), Logger.FATAL, message);
212	+	}
213	+	System.exit(1);
214	+	}
215	+
216	+
217	+
218		//---ACCESSOR/MUTATOR METHODS---
219
220		/**
#	Line 179 | Line 228 | public class ReferenceManager {
228
229		/**
230		* Returns a reference to the Root POA
231	<	* This will throw a Error if there is an error
231	>	* Calls the dieWithError() if any exceptions happen!
232		*
233		* @return the reference this class holds
234		*/
#	Line 189 | Line 238 | public class ReferenceManager {
238		try {
239		objRef = getORB().resolve_initial_references("RootPOA");
240		} catch (org.omg.CORBA.ORBPackage.InvalidName e) {
241	<	throw new Error("\nCRITICAL:Unable to resolve reference to the RootPOA!\n" +
241	>	dieWithError("\nCRITICAL:Unable to resolve reference to the RootPOA!\n" +
242		"         This indicates an error with your ORB.");
243		}
244		_rootPOA = POAHelper.narrow(objRef);
#	Line 199 | Line 248 | public class ReferenceManager {
248
249		/**
250		* Returns a reference to the Naming Service
251	<	* This will throw a Error if there is an error
251	>	* Calls the dieWithError() if any exceptions happen!
252		*
253		* @return the reference this class holds
254		*/
#	Line 209 | Line 258 | public class ReferenceManager {
258		try {
259		objRef = getORB().resolve_initial_references("NameService");
260		} catch (org.omg.CORBA.ORBPackage.InvalidName e) {
261	<	throw new Error("\nCRITICAL:Unable to resolve reference to the Naming Service!\n" +
261	>	dieWithError("\nCRITICAL:Unable to resolve reference to the Naming Service!\n" +
262		"         Please check with your CORBA naming service provider.");
263		}
264		_ns = NamingContextExtHelper.narrow(objRef);
265		}
266		// check we managed to talk to the naming service
267		if (_ns == null) {
268	<	throw new Error("\nCRITICAL:Unable to resolve reference to the Naming Service!\n" +
268	>	dieWithError("\nCRITICAL:Unable to resolve reference to the Naming Service!\n" +
269		"         Please check with your CORBA naming service provider.");
270		}
271		return _ns;
#	Line 224 | Line 273 | public class ReferenceManager {
273
274		/**
275		* Returns a reference to the configuration manager
276	<	* This will throw a Error if there is an error
276	>	* Calls the dieWithError() if any exceptions happen!
277		*
278		* @return the reference this class holds
279		*/
#	Line 234 | Line 283 | public class ReferenceManager {
283		}
284		// check we managed to talk to the configuration manager
285		if (_cm == null) {
286	<	throw new Error("\nCRITICAL:Unable to resolve reference to the Configuration Manager!\n" +
286	>	dieWithError("\nCRITICAL:Unable to resolve reference to the Configuration Manager!\n" +
287		"         Please check with your CORBA naming service provider.");
288		}
289		return _cm;
#	Line 252 | Line 301 | public class ReferenceManager {
301		}
302		return _logger;
303		}
255	–
256	–	/**
257	–	* Sets the reference to the name
258	–	*
259	–	* @param the new name
260	–	*/
261	–	public void setName(String name) {
262	–	_name = name;
263	–	}
304
265	–	/**
266	–	* Returns a reference to the name
267	–	*
268	–	* @return the reference this class holds
269	–	*/
270	–	public String getName() {
271	–	return _name;
272	–	}
273	–
305		//---ATTRIBUTES---
306
307		/**
#	Line 299 | Line 330 | public class ReferenceManager {
330		private Logger _logger;
331
332		/**
333	<	* The name
333	>	* This is the friendly identifier of the
334	>	* component this class is running in.
335	>	* eg, a Filter may be called "filter1",
336	>	* If this class does not have an owning
337	>	* component,  a name from the configuration
338	>	* can be placed here.  This name could also
339	>	* be changed to null for utility classes.
340		*/
341	<	private String _name;
341	>	private String _name = null;
342
343		//---STATIC ATTRIBUTES---
344
345		/**
346		* A reference to the single instance of this class
347		*/
348	<	private static ReferenceManager _instance;
348	>	private static ReferenceManager _instance = null;
349		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines