Clover coverage report - ActiveIO - 1.0
Coverage timestamp: Fri Apr 22 2005 14:27:22 PDT
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%
coverage coverage
 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   
 }