cms/org.argeo.slc.spring/src/org/argeo/slc/core/deploy/DefaultResourceSet.java

   1 package org.argeo.slc.core.deploy;
   2
   3 import java.io.IOException;
   4 import java.util.ArrayList;
   5 import java.util.List;
   6 import java.util.Map;
   7 import java.util.StringTokenizer;
   8 import java.util.TreeMap;
   9
  10 import org.apache.commons.logging.Log;
  11 import org.apache.commons.logging.LogFactory;
  12 import org.argeo.slc.SlcException;
  13 import org.springframework.beans.factory.InitializingBean;
  14 import org.springframework.context.ResourceLoaderAware;
  15 import org.springframework.core.io.Resource;
  16 import org.springframework.core.io.ResourceLoader;
  17 import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
  18 import org.springframework.core.io.support.ResourcePatternResolver;
  19 import org.springframework.util.AntPathMatcher;
  20 import org.springframework.util.PathMatcher;
  21
  22 public class DefaultResourceSet implements ResourceLoaderAware,
  23                 InitializingBean, ResourceSet {
  24         private final static Log log = LogFactory.getLog(DefaultResourceSet.class);
  25         public final static String DEFAULT_EXCLUDES = "**/.svn/**";
  26
  27         private String base;
  28         private String include;
  29         private List<String> includes = new ArrayList<String>();
  30         private String exclude;
  31         private List<String> excludes = new ArrayList<String>();
  32         private Boolean useDefaultExcludes = true;
  33         private ResourcePatternResolver resourcePatternResolver;
  34         private PathMatcher excludePathMatcher = new AntPathMatcher();
  35
  36         private ResourceLoader resourceLoader;
  37
  38         /** List the resources, identified by their relative path. */
  39         public Map<String, Resource> listResources() {
  40                 try {
  41                         Map<String, Resource> res = new TreeMap<String, Resource>();
  42                         if (base == null)
  43                                 return res;
  44                         String baseResUrl = getResourceLoaderToUse().getResource(base)
  45                                         .getURL().toString();
  46                         for (String includePattern : includes)
  47                                 processInclude(res, includePattern, baseResUrl);
  48                         return res;
  49                 } catch (IOException e) {
  50                         throw new SlcException("Cannot list resource from " + base, e);
  51                 }
  52         }
  53
  54         protected void processInclude(Map<String, Resource> res, String include,
  55                         String baseResUrl) throws IOException {
  56                 String pattern = base + "/" + include;
  57                 if (log.isTraceEnabled())
  58                         log.trace("Look for resources with pattern '" + pattern
  59                                         + "' in base url " + baseResUrl);
  60                 Resource[] resources = resourcePatternResolver.getResources(pattern);
  61                 resources: for (Resource resource : resources) {
  62                         String url = resource.getURL().toString();
  63                         String relPath = url.substring(baseResUrl.length());
  64
  65                         // skip dir
  66                         if (relPath.charAt(relPath.length() - 1) == '/') {
  67                                 if (log.isTraceEnabled())
  68                                         log.trace("Skip directory " + relPath + "=" + resource);
  69                                 continue resources;
  70                         }
  71
  72                         // make sure there is not starting '/'
  73                         if (relPath.charAt(0) == '/')
  74                                 relPath = relPath.substring(1);
  75
  76                         // skip excludes
  77                         for (String exclude : excludes)
  78                                 if (excludePathMatcher.match(exclude, relPath)) {
  79                                         if (log.isTraceEnabled())
  80                                                 log.trace("Exclude " + relPath + "=" + resource);
  81                                         continue resources;
  82                                 }
  83
  84                         // check if already exists
  85                         if (res.containsKey(relPath))
  86                                 log.warn(relPath + " already matched by " + res.get(relPath)
  87                                                 + ", " + resource + " will override it.");
  88
  89                         // store the marched resource
  90                         res.put(relPath, resource);
  91                         if (log.isTraceEnabled())
  92                                 log.trace(relPath + "=" + resource);
  93                 }
  94
  95         }
  96
  97         public void afterPropertiesSet() throws Exception {
  98                 if (resourcePatternResolver == null)
  99                         resourcePatternResolver = new PathMatchingResourcePatternResolver(
 100                                         getResourceLoaderToUse());
 101                 if (include != null)
 102                         addCommaSeparatedToList(include, includes);
 103                 if (exclude != null)
 104                         addCommaSeparatedToList(exclude, excludes);
 105
 106                 if (includes.size() == 0)
 107                         includes.add("**");
 108
 109                 if (useDefaultExcludes)
 110                         addCommaSeparatedToList(DEFAULT_EXCLUDES, excludes);
 111         }
 112
 113         private void addCommaSeparatedToList(String str, List<String> lst) {
 114                 StringTokenizer st = new StringTokenizer(str, ",");
 115                 while (st.hasMoreTokens()) {
 116                         String token = st.nextToken();
 117                         if (!lst.contains(token))
 118                                 lst.add(token);
 119                 }
 120         }
 121
 122         public void setResourceLoader(ResourceLoader resourceLoader) {
 123                 this.resourceLoader = resourceLoader;
 124         }
 125
 126         /**
 127          * Can be overridden in order to provide the proper resource loader used to
 128          * resolve resources.
 129          */
 130         public ResourceLoader getResourceLoaderToUse() {
 131                 return resourceLoader;
 132         }
 133
 134         public void setBase(String base) {
 135                 this.base = base;
 136         }
 137
 138         public void setInclude(String include) {
 139                 this.include = include;
 140         }
 141
 142         public void setIncludes(List<String> includes) {
 143                 this.includes = includes;
 144         }
 145
 146         public void setExclude(String exclude) {
 147                 this.exclude = exclude;
 148         }
 149
 150         public void setExcludes(List<String> excludes) {
 151                 this.excludes = excludes;
 152         }
 153
 154         public void setUseDefaultExcludes(Boolean useDefaultExcludes) {
 155                 this.useDefaultExcludes = useDefaultExcludes;
 156         }
 157
 158         public void setExcludePathMatcher(PathMatcher excludePathMatcher) {
 159                 this.excludePathMatcher = excludePathMatcher;
 160         }
 161
 162         public void setResourcePatternResolver(
 163                         ResourcePatternResolver resourcePatternResolver) {
 164                 this.resourcePatternResolver = resourcePatternResolver;
 165         }
 166
 167         public ResourcePatternResolver getResourcePatternResolver() {
 168                 return resourcePatternResolver;
 169         }
 170
 171 }