Ignore:
Timestamp:
08/28/10 21:55:08 (21 months ago)
Author:
kasper
Message:

Ticket #382: Added CLI for executing jobs

File:
1 edited

Legend:

Unmodified
Added
Removed

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/descriptors/ClasspathScanDescriptorProvider.java

    r978 r982  
    66import java.io.FilenameFilter; 
    77import java.io.IOException; 
     8import java.io.InputStream; 
     9import java.net.JarURLConnection; 
    810import java.net.URL; 
     11import java.net.URLConnection; 
    912import java.util.Collection; 
    1013import java.util.Collections; 
    … …  
    1215import java.util.HashMap; 
    1316import java.util.Map; 
     17import java.util.jar.JarEntry; 
     18import java.util.jar.JarFile; 
    1419 
    1520import org.eobjects.analyzer.beans.Analyzer; 
    … …  
    2025import org.slf4j.LoggerFactory; 
    2126 
    22 public final class ClasspathScanDescriptorProvider implements 
    23                 DescriptorProvider { 
     27public final class ClasspathScanDescriptorProvider extends 
     28                AbstractDescriptorProvider { 
    2429 
    2530        private static final Logger logger = LoggerFactory 
    2631                        .getLogger(ClasspathScanDescriptorProvider.class); 
     32 
    2733        private Map<Class<? extends Analyzer<?>>, AnalyzerBeanDescriptor<?>> _analyzerBeanDescriptors = new HashMap<Class<? extends Analyzer<?>>, AnalyzerBeanDescriptor<?>>(); 
    2834        private Map<Class<? extends Transformer<?>>, TransformerBeanDescriptor<?>> _transformerBeanDescriptors = new HashMap<Class<? extends Transformer<?>>, TransformerBeanDescriptor<?>>(); 
    2935        private Map<Class<? extends Renderer<?, ?>>, RendererBeanDescriptor> _rendererBeanDescriptors = new HashMap<Class<? extends Renderer<?, ?>>, RendererBeanDescriptor>(); 
    3036 
    31         @Override 
    32         public AnalyzerBeanDescriptor<?> getAnalyzerBeanDescriptorByDisplayName( 
    33                         String name) { 
    34                 Collection<AnalyzerBeanDescriptor<?>> analyzerBeanDescriptors = getAnalyzerBeanDescriptors(); 
    35                 for (AnalyzerBeanDescriptor<?> analyzerBeanDescriptor : analyzerBeanDescriptors) { 
    36                         if (name.equals(analyzerBeanDescriptor.getDisplayName())) { 
    37                                 return analyzerBeanDescriptor; 
    38                         } 
    39                 } 
    40                 return null; 
    41         } 
    42  
    43         @Override 
    44         public TransformerBeanDescriptor<?> getTransformerBeanDescriptorByDisplayName( 
    45                         String name) { 
    46                 Collection<TransformerBeanDescriptor<?>> transformerBeanDescriptors = getTransformerBeanDescriptors(); 
    47                 for (TransformerBeanDescriptor<?> transformerBeanDescriptor : transformerBeanDescriptors) { 
    48                         if (name.equals(transformerBeanDescriptor.getDisplayName())) { 
    49                                 return transformerBeanDescriptor; 
    50                         } 
    51                 } 
    52                 return null; 
    53         } 
    54  
    5537        public ClasspathScanDescriptorProvider scanPackage(String packageName, 
    5638                        boolean recursive) { 
    5739                String packagePath = packageName.replace('.', '/'); 
     40                logger.debug("Scanning package path: {}", packagePath); 
    5841                try { 
    5942                        Enumeration<URL> resources = ClassLoader 
    … …  
    6245                                URL resource = resources.nextElement(); 
    6346                                File dir = new File(resource.getFile()); 
    64                                 scanDirectory(dir, recursive); 
     47 
     48                                if (dir.isDirectory()) { 
     49                                        logger.debug("Resource is a file, scanning directory: {}", 
     50                                                        dir.getAbsolutePath()); 
     51                                        scanDirectory(dir, recursive); 
     52                                } else { 
     53                                        URLConnection connection = resource.openConnection(); 
     54                                        if (connection instanceof JarURLConnection) { 
     55                                                JarURLConnection jarUrlConnection = (JarURLConnection) connection; 
     56                                                logger.debug("Resource is a JAR file, scanning file: " 
     57                                                                + jarUrlConnection.getJarFile().getName()); 
     58                                                scanJar(jarUrlConnection, packagePath, recursive); 
     59                                        } else { 
     60                                                throw new IllegalStateException( 
     61                                                                "Unknown connection type: " + connection); 
     62                                        } 
     63                                } 
    6564                        } 
    6665                } catch (IOException e) { 
    … …  
    6968 
    7069                return this; 
     70        } 
     71 
     72        private void scanJar(JarURLConnection jarUrlConnection, String packagePath, 
     73                        boolean recursive) throws IOException { 
     74                JarFile jarFile = jarUrlConnection.getJarFile(); 
     75                Enumeration<JarEntry> entries = jarFile.entries(); 
     76 
     77                while (entries.hasMoreElements()) { 
     78                        JarEntry entry = entries.nextElement(); 
     79                        String entryName = entry.getName(); 
     80                        if (entryName.startsWith(packagePath) 
     81                                        && entryName.endsWith(".class")) { 
     82                                if (recursive) { 
     83                                        InputStream inputStream = jarFile.getInputStream(entry); 
     84                                        scanInputStream(inputStream); 
     85                                } else { 
     86                                        String trailingPart = entryName.substring(packagePath 
     87                                                        .length()); 
     88                                        if (trailingPart.startsWith("/")) { 
     89                                                trailingPart = trailingPart.substring(1); 
     90                                        } 
     91                                        if (trailingPart.indexOf('/') == -1) { 
     92                                                InputStream inputStream = jarFile.getInputStream(entry); 
     93                                                scanInputStream(inputStream); 
     94                                        } else { 
     95                                                logger.info("Omitting recursive JAR file entry: {}", 
     96                                                                entryName); 
     97                                        } 
     98                                } 
     99                        } else { 
     100                                logger.info("Omitting JAR file entry: {}", entryName); 
     101                        } 
     102                } 
    71103        } 
    72104 
    … …  
    91123                for (File file : classFiles) { 
    92124                        try { 
    93                                 BeanClassVisitor visitor = new BeanClassVisitor(); 
    94                                 ClassReader classReader = new ClassReader(new FileInputStream( 
    95                                                 file)); 
    96                                 classReader.accept(visitor, ClassReader.SKIP_CODE); 
    97  
    98                                 if (visitor.isAnalyzer()) { 
    99                                         @SuppressWarnings("unchecked") 
    100                                         Class<? extends Analyzer<?>> analyzerClass = (Class<? extends Analyzer<?>>) visitor 
    101                                                         .getBeanClass(); 
    102                                         AnalyzerBeanDescriptor<?> descriptor = _analyzerBeanDescriptors 
    103                                                         .get(analyzerClass); 
    104                                         if (descriptor == null) { 
    105                                                 descriptor = AnnotationBasedAnalyzerBeanDescriptor 
    106                                                                 .create(analyzerClass); 
    107                                                 _analyzerBeanDescriptors.put(analyzerClass, descriptor); 
    108                                         } 
    109                                 } 
    110                                 if (visitor.isTransformer()) { 
    111                                         @SuppressWarnings("unchecked") 
    112                                         Class<? extends Transformer<?>> transformerClass = (Class<? extends Transformer<?>>) visitor 
    113                                                         .getBeanClass(); 
    114                                         TransformerBeanDescriptor<?> descriptor = _transformerBeanDescriptors 
    115                                                         .get(transformerClass); 
    116                                         if (descriptor == null) { 
    117                                                 descriptor = AnnotationBasedTransformerBeanDescriptor 
    118                                                                 .create(transformerClass); 
    119                                                 _transformerBeanDescriptors.put(transformerClass, 
    120                                                                 descriptor); 
    121                                         } 
    122                                 } 
    123                                 if (visitor.isRenderer()) { 
    124                                         @SuppressWarnings("unchecked") 
    125                                         Class<? extends Renderer<?, ?>> rendererClass = (Class<? extends Renderer<?, ?>>) visitor 
    126                                                         .getBeanClass(); 
    127                                         RendererBeanDescriptor descriptor = _rendererBeanDescriptors 
    128                                                         .get(rendererClass); 
    129                                         if (descriptor == null) { 
    130                                                 descriptor = new AnnotationBasedRendererBeanDescriptor( 
    131                                                                 rendererClass); 
    132                                                 _rendererBeanDescriptors.put(rendererClass, descriptor); 
    133                                         } 
    134                                 } 
     125                                InputStream inputStream = new FileInputStream(file); 
     126                                scanInputStream(inputStream); 
    135127                        } catch (IOException e) { 
    136128                                logger.error("Could not read file", e); 
    … …  
    155147        } 
    156148 
     149        protected void scanInputStream(InputStream inputStream) throws IOException { 
     150                ClassReader classReader = new ClassReader(inputStream); 
     151                BeanClassVisitor visitor = new BeanClassVisitor(); 
     152                classReader.accept(visitor, ClassReader.SKIP_CODE); 
     153 
     154                if (visitor.isAnalyzer()) { 
     155                        @SuppressWarnings("unchecked") 
     156                        Class<? extends Analyzer<?>> analyzerClass = (Class<? extends Analyzer<?>>) visitor 
     157                                        .getBeanClass(); 
     158                        AnalyzerBeanDescriptor<?> descriptor = _analyzerBeanDescriptors 
     159                                        .get(analyzerClass); 
     160                        if (descriptor == null) { 
     161                                descriptor = AnnotationBasedAnalyzerBeanDescriptor 
     162                                                .create(analyzerClass); 
     163                                _analyzerBeanDescriptors.put(analyzerClass, descriptor); 
     164                        } 
     165                } 
     166                if (visitor.isTransformer()) { 
     167                        @SuppressWarnings("unchecked") 
     168                        Class<? extends Transformer<?>> transformerClass = (Class<? extends Transformer<?>>) visitor 
     169                                        .getBeanClass(); 
     170                        TransformerBeanDescriptor<?> descriptor = _transformerBeanDescriptors 
     171                                        .get(transformerClass); 
     172                        if (descriptor == null) { 
     173                                descriptor = AnnotationBasedTransformerBeanDescriptor 
     174                                                .create(transformerClass); 
     175                                _transformerBeanDescriptors.put(transformerClass, descriptor); 
     176                        } 
     177                } 
     178                if (visitor.isRenderer()) { 
     179                        @SuppressWarnings("unchecked") 
     180                        Class<? extends Renderer<?, ?>> rendererClass = (Class<? extends Renderer<?, ?>>) visitor 
     181                                        .getBeanClass(); 
     182                        RendererBeanDescriptor descriptor = _rendererBeanDescriptors 
     183                                        .get(rendererClass); 
     184                        if (descriptor == null) { 
     185                                descriptor = new AnnotationBasedRendererBeanDescriptor( 
     186                                                rendererClass); 
     187                                _rendererBeanDescriptors.put(rendererClass, descriptor); 
     188                        } 
     189                } 
     190        } 
     191 
    157192        @Override 
    158193        public Collection<AnalyzerBeanDescriptor<?>> getAnalyzerBeanDescriptors() { 
    … …  
    161196        } 
    162197 
    163         @SuppressWarnings("unchecked") 
    164         @Override 
    165         public <A extends Analyzer<?>> AnalyzerBeanDescriptor<A> getAnalyzerBeanDescriptorForClass( 
    166                         Class<A> analyzerBeanClass) { 
    167                 return (AnalyzerBeanDescriptor<A>) _analyzerBeanDescriptors 
    168                                 .get(analyzerBeanClass); 
    169         } 
    170  
    171198        @Override 
    172199        public Collection<TransformerBeanDescriptor<?>> getTransformerBeanDescriptors() { 
    … …  
    175202        } 
    176203 
    177         @SuppressWarnings("unchecked") 
    178         @Override 
    179         public <T extends Transformer<?>> TransformerBeanDescriptor<T> getTransformerBeanDescriptorForClass( 
    180                         Class<T> transformerBeanClass) { 
    181                 return (TransformerBeanDescriptor<T>) _transformerBeanDescriptors 
    182                                 .get(transformerBeanClass); 
    183         } 
    184  
    185204        @Override 
    186205        public Collection<RendererBeanDescriptor> getRendererBeanDescriptors() { 
    … …  
    188207                                .values()); 
    189208        } 
    190  
    191         @Override 
    192         public RendererBeanDescriptor getRendererBeanDescriptorForClass( 
    193                         Class<? extends Renderer<?, ?>> rendererBeanClass) { 
    194                 return _rendererBeanDescriptors.get(rendererBeanClass); 
    195         } 
    196209} 
Note: See TracChangeset for help on using the changeset viewer.