ActiveIO - 1.0

Clover coverage report - ActiveIO - 1.0

Coverage timestamp: Fri Apr 22 2005 14:27:22 PDT

FRAMES NO FRAMES

file stats:	LOC:	214		Methods:	12
	NCLOC:	140		Classes:	2

30 day Evaluation Version distributed via the Maven Jar Repository. Clover is not free. You have 30 days to evaluate it. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover

Source file

Conditionals

Statements

Methods

TOTAL

ChannelFactory.java

66.7%

84.1%

91.7%

82.8%

 /** 
  * 
  * Copyright 2004 Protique Ltd
  * 
  * Licensed under the Apache License, Version 2.0 (the "License"); 
  * you may not use this file except in compliance with the License. 
  * You may obtain a copy of the License at 
  * 
  * http://www.apache.org/licenses/LICENSE-2.0
  * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, 
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
  * See the License for the specific language governing permissions and 
  * limitations under the License. 
  * 
  **/
 package org.activeio;
 
 import java.io.BufferedInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URI;
 import java.util.HashMap;
 import java.util.Properties;
 
 import org.activeio.adapter.AsynchToSynchChannelFactoryAdaptor;
 import org.activeio.adapter.SynchToAsynchChannelFactoryAdaptor;
 
 import EDU.oswego.cs.dl.util.concurrent.Executor;
 import EDU.oswego.cs.dl.util.concurrent.PooledExecutor;
 import EDU.oswego.cs.dl.util.concurrent.ThreadFactory;
 
 /**
  * A {@see ChannelFactory}uses the requested URI's scheme to determine the
  * actual {@see org.activeio.SynchChannelFactory}or
  * {@see org.activeio.AsynchChannelFactory}implementation to use to create it's
  * {@see org.activeio.Channel}s and {@see org.activeio.ChannelServer}s.
  * 
  * Each URI scheme that {@see ChannelFactory}object handles will have a
  * properties file located at: "META-INF/org.activeio.ChannelFactory/{scheme}".
  * 
  */
 public class ChannelFactory implements SynchChannelFactory, AsynchChannelFactory {
 
     private final HashMap synchChannelFactoryMap = new HashMap();
     private final HashMap asynchChannelFactoryMap = new HashMap();
 
     
     static public final Executor DEFAULT_EXECUTOR = new PooledExecutor();
     static {
         ((PooledExecutor) DEFAULT_EXECUTOR).setThreadFactory(new ThreadFactory() {
             public Thread newThread(Runnable run) {
                 Thread thread = new Thread(run);
                 thread.setDaemon(true);
                 return thread;
             }
         });
     }
 
     static private class FactoryFinder {
         private String path;
 
         public FactoryFinder(String path) {
             this.path = path;
         }
 
         /**
          * Creates a new instance of the given key
          * 
          * @param key
          *            is the key to add to the path to find a text file
          *            containing the factory name
          * @return a newly created instance
          */
         public Object newInstance(String key) throws IllegalAccessException, InstantiationException, IOException,
                 ClassNotFoundException {
             return newInstance(key, null);
         }
 
         public Object newInstance(String key, String propertyPrefix) throws IllegalAccessException,
                 InstantiationException, IOException, ClassNotFoundException {
             return newInstance(doFindFactoryProperies(key), propertyPrefix);
         }
 
         private Object newInstance(Properties properties, String propertyPrefix) throws ClassNotFoundException,
                 InstantiationException, IllegalAccessException, IOException {
 
             if (propertyPrefix == null)
                 propertyPrefix = "";
 
             String className = properties.getProperty(propertyPrefix + "class");
             if (className == null) {
                 throw new IOException("Expected property is missing: " + propertyPrefix + "class");
             }
             Class clazz;
             try {
                 clazz = Thread.currentThread().getContextClassLoader().loadClass(className);
             } catch (ClassNotFoundException e) {
                 clazz = getClass().getClassLoader().loadClass(className);
             }
 
             // We could use the properties to pass constructor args or set
             // properties on the object.
             return clazz.newInstance();
         }
 
         private Properties doFindFactoryProperies(String key) throws IOException, ClassNotFoundException {
             String uri = path + key;
 
             // lets try the thread context class loader first
             InputStream in = Thread.currentThread().getContextClassLoader().getResourceAsStream(uri);
             if (in == null) {
                 in = getClass().getClassLoader().getResourceAsStream(uri);
                 if (in == null) {
                     throw new IOException("Could not find factory class for resource: " + uri);
                 }
             }
 
             // lets load the file
             BufferedInputStream reader = null;
             try {
                 reader = new BufferedInputStream(in);
                 Properties properties = new Properties();
                 properties.load(reader);
                 return properties;
             } finally {
                 try {
                     reader.close();
                 } catch (Exception e) {
                 }
             }
         }
     }
 
     private static FactoryFinder finder = new FactoryFinder("META-INF/org.activeio.ChannelFactory/");
 
     public SynchChannel openSynchChannel(URI location) throws IOException {
         SynchChannelFactory factory = getSynchChannelFactory(location.getScheme());
         return factory.openSynchChannel(location);
     }
 
     public SynchChannelServer bindSynchChannel(URI location) throws IOException {
         SynchChannelFactory factory = getSynchChannelFactory(location.getScheme());
         return factory.bindSynchChannel(location);
     }
 
     public AsynchChannel openAsynchChannel(URI location) throws IOException {
         AsynchChannelFactory factory = getAsynchChannelFactory(location.getScheme());
         return factory.openAsynchChannel(location);
     }
 
     public AsynchChannelServer bindAsynchChannel(URI location) throws IOException {
         AsynchChannelFactory factory = getAsynchChannelFactory(location.getScheme());
         return factory.bindAsynchChannel(location);
     }
 
     private SynchChannelFactory getSynchChannelFactory(String protocol) throws IOException {
         try {
             SynchChannelFactory rc = (SynchChannelFactory) synchChannelFactoryMap.get(protocol);
             if (rc == null) {
                 try {
                     rc = (SynchChannelFactory) finder.newInstance(protocol, "SynchChannelFactory.");
                 } catch (Throwable original) {
                     // try to recovery by using AsynchChannelFactory and adapt
                     // it to be synch.
                     try {
                         AsynchChannelFactory f = (AsynchChannelFactory) finder.newInstance(protocol,
                                 "AsynchChannelFactory.");
                         rc = AsynchToSynchChannelFactoryAdaptor.adapt(f);
                     } catch (Throwable e) {
                         // Recovery strategy failed.. throw original exception.
                         throw original;
                     }
                 }
                 synchChannelFactoryMap.put(protocol, rc);
             }
             return rc;
         } catch (Throwable e) {
             throw (IOException) new IOException("Could not load a SynchChannelFactory for protcol: " + protocol
                     + ", reason: " + e).initCause(e);
         }
     }
 
     private AsynchChannelFactory getAsynchChannelFactory(String protocol) throws IOException {
         try {
             AsynchChannelFactory rc = (AsynchChannelFactory) asynchChannelFactoryMap.get(protocol);
             if (rc == null) {
 
                 try {
                     rc = (AsynchChannelFactory) finder.newInstance(protocol, "AsynchChannelFactory.");
                 } catch (Throwable original) {
                     // try to recovery by using SynchChannelFactory and adapt it
                     // to be asynch.
                     try {
                         SynchChannelFactory f = (SynchChannelFactory) finder.newInstance(protocol,
                                 "SynchChannelFactory.");
                         rc = SynchToAsynchChannelFactoryAdaptor.adapt(f);
                     } catch (Throwable e) {
                         // Recovery strategy failed.. throw original exception.
                         throw original;
                     }
                 }
 
                 asynchChannelFactoryMap.put(protocol, rc);
             }
             return rc;
         } catch (Throwable e) {
             throw (IOException) new IOException("Could not load a AsynchChannelFactory for protcol: " + protocol
                     + ", reason: " + e).initCause(e);
         }
     }
 
 }

1		/**
2		*
3		* Copyright 2004 Protique Ltd
4		*
5		* Licensed under the Apache License, Version 2.0 (the "License");
6		* you may not use this file except in compliance with the License.
7		* You may obtain a copy of the License at
8		*
9		* http://www.apache.org/licenses/LICENSE-2.0
10		*
11		* Unless required by applicable law or agreed to in writing, software
12		* distributed under the License is distributed on an "AS IS" BASIS,
13		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14		* See the License for the specific language governing permissions and
15		* limitations under the License.
16		*
17		**/
18		package org.activeio;
19
20		import java.io.BufferedInputStream;
21		import java.io.IOException;
22		import java.io.InputStream;
23		import java.net.URI;
24		import java.util.HashMap;
25		import java.util.Properties;
26
27		import org.activeio.adapter.AsynchToSynchChannelFactoryAdaptor;
28		import org.activeio.adapter.SynchToAsynchChannelFactoryAdaptor;
29
30		import EDU.oswego.cs.dl.util.concurrent.Executor;
31		import EDU.oswego.cs.dl.util.concurrent.PooledExecutor;
32		import EDU.oswego.cs.dl.util.concurrent.ThreadFactory;
33
34		/**
35		* A {@see ChannelFactory}uses the requested URI's scheme to determine the
36		* actual {@see org.activeio.SynchChannelFactory}or
37		* {@see org.activeio.AsynchChannelFactory}implementation to use to create it's
38		* {@see org.activeio.Channel}s and {@see org.activeio.ChannelServer}s.
39		*
40		* Each URI scheme that {@see ChannelFactory}object handles will have a
41		* properties file located at: "META-INF/org.activeio.ChannelFactory/{scheme}".
42		*
43		*/
44		public class ChannelFactory implements SynchChannelFactory, AsynchChannelFactory {
45
46		private final HashMap synchChannelFactoryMap = new HashMap();
47		private final HashMap asynchChannelFactoryMap = new HashMap();
48
49
50		static public final Executor DEFAULT_EXECUTOR = new PooledExecutor();
51		static {
52	12	((PooledExecutor) DEFAULT_EXECUTOR).setThreadFactory(new ThreadFactory() {
53	22	public Thread newThread(Runnable run) {
54	22	Thread thread = new Thread(run);
55	22	thread.setDaemon(true);
56	22	return thread;
57		}
58		});
59		}
60
61		static private class FactoryFinder {
62		private String path;
63
64	12	public FactoryFinder(String path) {
65	12	this.path = path;
66		}
67
68		/**
69		* Creates a new instance of the given key
70		*
71		* @param key
72		* is the key to add to the path to find a text file
73		* containing the factory name
74		* @return a newly created instance
75		*/
76	0	public Object newInstance(String key) throws IllegalAccessException, InstantiationException, IOException,
77		ClassNotFoundException {
78	0	return newInstance(key, null);
79		}
80
81	16	public Object newInstance(String key, String propertyPrefix) throws IllegalAccessException,
82		InstantiationException, IOException, ClassNotFoundException {
83	16	return newInstance(doFindFactoryProperies(key), propertyPrefix);
84		}
85
86	16	private Object newInstance(Properties properties, String propertyPrefix) throws ClassNotFoundException,
87		InstantiationException, IllegalAccessException, IOException {
88
89	16	if (propertyPrefix == null)
90	0	propertyPrefix = "";
91
92	16	String className = properties.getProperty(propertyPrefix + "class");
93	16	if (className == null) {
94	4	throw new IOException("Expected property is missing: " + propertyPrefix + "class");
95		}
96	12	Class clazz;
97	12	try {
98	12	clazz = Thread.currentThread().getContextClassLoader().loadClass(className);
99		} catch (ClassNotFoundException e) {
100	0	clazz = getClass().getClassLoader().loadClass(className);
101		}
102
103		// We could use the properties to pass constructor args or set
104		// properties on the object.
105	12	return clazz.newInstance();
106		}
107
108	16	private Properties doFindFactoryProperies(String key) throws IOException, ClassNotFoundException {
109	16	String uri = path + key;
110
111		// lets try the thread context class loader first
112	16	InputStream in = Thread.currentThread().getContextClassLoader().getResourceAsStream(uri);
113	16	if (in == null) {
114	0	in = getClass().getClassLoader().getResourceAsStream(uri);
115	0	if (in == null) {
116	0	throw new IOException("Could not find factory class for resource: " + uri);
117		}
118		}
119
120		// lets load the file
121	16	BufferedInputStream reader = null;
122	16	try {
123	16	reader = new BufferedInputStream(in);
124	16	Properties properties = new Properties();
125	16	properties.load(reader);
126	16	return properties;
127		} finally {
128	16	try {
129	16	reader.close();
130		} catch (Exception e) {
131		}
132		}
133		}
134		}
135
136		private static FactoryFinder finder = new FactoryFinder("META-INF/org.activeio.ChannelFactory/");
137
138	6	public SynchChannel openSynchChannel(URI location) throws IOException {
139	6	SynchChannelFactory factory = getSynchChannelFactory(location.getScheme());
140	6	return factory.openSynchChannel(location);
141		}
142
143	6	public SynchChannelServer bindSynchChannel(URI location) throws IOException {
144	6	SynchChannelFactory factory = getSynchChannelFactory(location.getScheme());
145	6	return factory.bindSynchChannel(location);
146		}
147
148	6	public AsynchChannel openAsynchChannel(URI location) throws IOException {
149	6	AsynchChannelFactory factory = getAsynchChannelFactory(location.getScheme());
150	6	return factory.openAsynchChannel(location);
151		}
152
153	6	public AsynchChannelServer bindAsynchChannel(URI location) throws IOException {
154	6	AsynchChannelFactory factory = getAsynchChannelFactory(location.getScheme());
155	6	return factory.bindAsynchChannel(location);
156		}
157
158	12	private SynchChannelFactory getSynchChannelFactory(String protocol) throws IOException {
159	12	try {
160	12	SynchChannelFactory rc = (SynchChannelFactory) synchChannelFactoryMap.get(protocol);
161	12	if (rc == null) {
162	6	try {
163	6	rc = (SynchChannelFactory) finder.newInstance(protocol, "SynchChannelFactory.");
164		} catch (Throwable original) {
165		// try to recovery by using AsynchChannelFactory and adapt
166		// it to be synch.
167	2	try {
168	2	AsynchChannelFactory f = (AsynchChannelFactory) finder.newInstance(protocol,
169		"AsynchChannelFactory.");
170	2	rc = AsynchToSynchChannelFactoryAdaptor.adapt(f);
171		} catch (Throwable e) {
172		// Recovery strategy failed.. throw original exception.
173	0	throw original;
174		}
175		}
176	6	synchChannelFactoryMap.put(protocol, rc);
177		}
178	12	return rc;
179		} catch (Throwable e) {
180	0	throw (IOException) new IOException("Could not load a SynchChannelFactory for protcol: " + protocol
181		+ ", reason: " + e).initCause(e);
182		}
183		}
184
185	12	private AsynchChannelFactory getAsynchChannelFactory(String protocol) throws IOException {
186	12	try {
187	12	AsynchChannelFactory rc = (AsynchChannelFactory) asynchChannelFactoryMap.get(protocol);
188	12	if (rc == null) {
189
190	6	try {
191	6	rc = (AsynchChannelFactory) finder.newInstance(protocol, "AsynchChannelFactory.");
192		} catch (Throwable original) {
193		// try to recovery by using SynchChannelFactory and adapt it
194		// to be asynch.
195	2	try {
196	2	SynchChannelFactory f = (SynchChannelFactory) finder.newInstance(protocol,
197		"SynchChannelFactory.");
198	2	rc = SynchToAsynchChannelFactoryAdaptor.adapt(f);
199		} catch (Throwable e) {
200		// Recovery strategy failed.. throw original exception.
201	0	throw original;
202		}
203		}
204
205	6	asynchChannelFactoryMap.put(protocol, rc);
206		}
207	12	return rc;
208		} catch (Throwable e) {
209	0	throw (IOException) new IOException("Could not load a AsynchChannelFactory for protcol: " + protocol
210		+ ", reason: " + e).initCause(e);
211		}
212		}
213
214		}