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% |

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 |  |
     }