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.3 by ajm, Thu Nov 30 02:38:17 2000 UTC vs.
Revision 1.21 by tdb, Sun Aug 1 10:40:50 2004 UTC

#	Line 1 | Line 1
1	+	/*
2	+	* i-scream central monitoring system
3	+	* http://www.i-scream.org
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.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;
82	<	getLogger().write(toString(), Logger.SYSINIT, "created");
78	>	private ReferenceManager() {
79	>	_orb = ORB.init(new String[] {}, null);
80		}
81
82		//---PUBLIC METHODS---
#	Line 87 | 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 RuntimeException 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 98 | 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 RuntimeException("\nCRITICAL:Naming Service Cannot Proceed - when resolving reference to " + name + "!\n" +
99	<	"         Please check with your CORBA naming service provider.");
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 RuntimeException("\nCRITICAL:Invalid Name - when resolving reference to " + name + "!\n" +
102	<	"         Please check with your CORBA naming service provider.");
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 RuntimeException("\nCRITICAL:Not Found - when resolving reference to " + name + "!\n" +
105	<	"         Please check that this component is running.");
104	>	recoverWithError("\nCRITICAL:Not Found - when resolving reference to " + name + "!\n" +
105	>	"         Please check that this component is running.");
106		}
107		return objRef;
108		}
#	Line 113 | 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 RuntimeException 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 122 | 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 RuntimeException("\nCRITICAL:Wrong POA Policy - when binding " + name + "!\n" +
123	<	"         This indicates an error with your ORB.");
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 RuntimeException("\nCRITICAL:ServantNotActive - when binding " + name + "!\n" +
126	<	"         This indicates an error with your ORB.");
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 RuntimeException("\nCRITICAL:Invalid Name - when binding " + name + "!\n" +
129	<	"         Please check with your CORBA naming service provider.");
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 RuntimeException("\nCRITICAL:Naming Service Cannot Proceed - when binding " + name + "!\n" +
132	<	"         Please check with your CORBA naming service provider.");
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 RuntimeException("\nCRITICAL:Naming Service Not Found - when binding " + name + "!\n" +
135	<	"         Please check with your CORBA naming service provider.");
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 RuntimeException("\nCRITICAL:Already Bound - when binding " + name + "!\n" +
138	<	"         Another component with this name is already running.");
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 RuntimeException 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 RuntimeException("\nCRITICAL:POA Set Inactive - when trying to activate POA!\n" +
151	<	"         This indicates an error with your ORB.");
150	>	dieWithError("\nCRITICAL:POA Set Inactive - when trying to activate POA!\n" +
151	>	"         This indicates an error with your ORB.");
152		}
153		}
154
#	Line 159 | 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.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 180 | Line 228 | public class ReferenceManager {
228
229		/**
230		* Returns a reference to the Root POA
231	<	* This will throw a RuntimeException if there is an error
231	>	* Calls the dieWithError() if any exceptions happen!
232		*
233		* @return the reference this class holds
234		*/
#	Line 190 | 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 RuntimeException("\nCRITICAL:Unable to resolve reference to the RootPOA!\n" +
242	<	"         This indicates an error with your ORB.");
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);
245		}
#	Line 200 | Line 248 | public class ReferenceManager {
248
249		/**
250		* Returns a reference to the Naming Service
251	<	* This will throw a RuntimeException if there is an error
251	>	* Calls the dieWithError() if any exceptions happen!
252		*
253		* @return the reference this class holds
254		*/
#	Line 210 | 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 RuntimeException("\nCRITICAL:Unable to resolve reference to the Naming Service!\n" +
262	<	"         Please check with your CORBA naming service provider.");
261	>	dieWithError("\nCRITICAL:Unable to resolve reference to the Naming Service!\n" +
262	>	"         Please check with your CORBA naming service provider.");
263	>	} catch (java.lang.NullPointerException e) {
264	>	dieWithError("\nCRITICAL:Unable to resolve reference to the Naming Service!\n" +
265	>	"         Please check with your CORBA naming service provider.");
266		}
267		_ns = NamingContextExtHelper.narrow(objRef);
268		}
269	+	// check we managed to talk to the naming service
270	+	if (_ns == null) {
271	+	dieWithError("\nCRITICAL:Unable to resolve reference to the Naming Service!\n" +
272	+	"         Please check with your CORBA naming service provider.");
273	+	}
274		return _ns;
275		}
276
277		/**
278		* Returns a reference to the configuration manager
279	<	* This will throw a RuntimeException if there is an error
279	>	* Calls the dieWithError() if any exceptions happen!
280		*
281		* @return the reference this class holds
282		*/
#	Line 228 | Line 284 | public class ReferenceManager {
284		if (_cm == null) {
285		_cm = ConfigurationManagerHelper.narrow(getCORBARef("iscream.ConfigurationManager"));
286		}
287	+	// check we managed to talk to the configuration manager
288	+	if (_cm == null) {
289	+	dieWithError("\nCRITICAL:Unable to resolve reference to the Configuration Manager!\n" +
290	+	"         Please check with your CORBA naming service provider.");
291	+	}
292		return _cm;
293		}
294
295		/**
296		* Returns a reference to the logger
297	<	* This will throw a RuntimeException if there is an error
297	>	* This will throw a Error if there is an error
298		*
299		* @return the reference this class holds
300		*/
#	Line 244 | Line 305 | public class ReferenceManager {
305		return _logger;
306		}
307
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	–
308		//---ATTRIBUTES---
309
310		/**
#	Line 281 | Line 333 | public class ReferenceManager {
333		private Logger _logger;
334
335		/**
336	<	* The name
336	>	* This is the friendly identifier of the
337	>	* component this class is running in.
338	>	* eg, a Filter may be called "filter1",
339	>	* If this class does not have an owning
340	>	* component,  a name from the configuration
341	>	* can be placed here.  This name could also
342	>	* be changed to null for utility classes.
343		*/
344	<	private String _name;
344	>	private String _name = null;
345
346		//---STATIC ATTRIBUTES---
347
348		/**
349		* A reference to the single instance of this class
350		*/
351	<	private static ReferenceManager _instance;
351	>	private static ReferenceManager _instance = null;
352		}

Diff Legend

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