Introduce filtered resources

git-svn-id: https://svn.argeo.org/slc/trunk@3410 4cfe0d0a-d680-48aa-b62c-e0a02a3f76cc

diff --git a/runtime/org.argeo.slc.core/src/main/java/org/argeo/slc/core/execution/SedFilteredResource.java b/runtime/org.argeo.slc.core/src/main/java/org/argeo/slc/core/execution/SedFilteredResource.java
new file mode 100644 (file)
index 0000000..676c025
--- /dev/null
+++ b/runtime/org.argeo.slc.core/src/main/java/org/argeo/slc/core/execution/SedFilteredResource.java
@@ -0,0 +1,120 @@
+package org.argeo.slc.core.execution;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.channels.Channels;
+import java.nio.channels.FileChannel;
+import java.nio.channels.ReadableByteChannel;
+import java.nio.channels.WritableByteChannel;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CharsetEncoder;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.StringTokenizer;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.argeo.slc.SlcException;
+import org.springframework.beans.factory.FactoryBean;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.core.io.ByteArrayResource;
+import org.springframework.core.io.Resource;
+
+public class SedFilteredResource implements FactoryBean, InitializingBean {
+       private Resource source;
+
+       private List<String> filters = new ArrayList<String>();
+       private Map<Pattern, String> patterns = new HashMap<Pattern, String>();
+
+       private String charset = "UTF-8";
+       private Charset cs;
+       private CharsetDecoder decoder;
+       private CharsetEncoder encoder;
+
+       public Object getObject() throws Exception {
+               if (filters.size() == 0)
+                       return source;
+
+               int capacity = 100 * 1024;// 100 KB
+               ByteBuffer bb;
+               if (source instanceof ByteArrayResource) {
+                       bb = ByteBuffer.wrap(((ByteArrayResource) source).getByteArray());
+               } else {
+                       try {
+                               File file = source.getFile();
+                               FileInputStream fis = new FileInputStream(file);
+                               FileChannel fc = fis.getChannel();
+
+                               // Get the file's size and then map it into memory
+                               int sz = (int) fc.size();
+                               bb = fc.map(FileChannel.MapMode.READ_ONLY, 0, sz);
+                       } catch (IOException e) {
+                               ReadableByteChannel channel = Channels.newChannel(source
+                                               .getInputStream());
+                               bb = ByteBuffer.allocateDirect(capacity);
+                               channel.read(bb);
+                       }
+               }
+               CharBuffer cb = decoder.decode(bb);
+               for (Pattern pattern : patterns.keySet()) {
+                       Matcher matcher = pattern.matcher(cb);
+                       matcher.replaceAll(patterns.get(pattern));
+               }
+               ByteBuffer bbout = encoder.encode(cb);
+               ByteArrayOutputStream out = new ByteArrayOutputStream(capacity);
+               WritableByteChannel wchannel = Channels.newChannel(out);
+               wchannel.write(bbout);
+               ByteArrayResource res = new ByteArrayResource(out.toByteArray());
+               return res;
+       }
+
+       public Class<?> getObjectType() {
+               return Resource.class;
+       }
+
+       public boolean isSingleton() {
+               return true;
+       }
+
+       public void afterPropertiesSet() throws Exception {
+               cs = Charset.forName(charset);
+               decoder = cs.newDecoder();
+               encoder = cs.newEncoder();
+
+               for (String sedStr : filters) {
+                       sedStr = sedStr.trim();
+                       if (sedStr.length() < 4)
+                               throw new SlcException(sedStr + " not properly formatted.");
+                       if (sedStr.charAt(0) != 's')
+                               throw new SlcException(sedStr + " not properly formatted.");
+                       Character sep = sedStr.charAt(1);
+                       List<String> tokens = new ArrayList<String>(4);
+                       StringTokenizer st = new StringTokenizer(sedStr, sep.toString());
+                       while (st.hasMoreTokens())
+                               tokens.add(st.nextToken());
+                       if (tokens.size() != 3 && tokens.size() != 4)
+                               throw new SlcException(sedStr + " not properly formatted.");
+                       patterns.put(Pattern.compile(tokens.get(1)), tokens.get(2));
+               }
+       }
+
+       public void setSource(Resource source) {
+               this.source = source;
+       }
+
+       public void setFilters(List<String> filters) {
+               this.filters = filters;
+       }
+
+       public void setCharset(String charset) {
+               this.charset = charset;
+       }
+
+}

diff --git a/runtime/org.argeo.slc.support.simple/src/main/java/org/argeo/slc/jsch/ScpTo.java b/runtime/org.argeo.slc.support.simple/src/main/java/org/argeo/slc/jsch/ScpTo.java
index 2a6da62de8048b60607c7aee17d0994999151036..8d7e49b01e4d24c1930e76dac7bc7ca499466c64 100644 (file)
--- a/runtime/org.argeo.slc.support.simple/src/main/java/org/argeo/slc/jsch/ScpTo.java
+++ b/runtime/org.argeo.slc.support.simple/src/main/java/org/argeo/slc/jsch/ScpTo.java
@@ -15,6 +15,7 @@ import org.apache.commons.io.IOUtils;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.argeo.slc.SlcException;
+import org.springframework.core.io.ByteArrayResource;
 import org.springframework.core.io.Resource;
 import org.springframework.util.AntPathMatcher;
 import org.springframework.util.PathMatcher;
@@ -125,18 +126,25 @@ public class ScpTo extends AbstractJschTask {
                        // load the resource in memory before transferring it
                        InputStream in = null;
                        try {
-                               in = resource.getInputStream();
-                               ByteArrayOutputStream out = new ByteArrayOutputStream();
-                               IOUtils.copy(in, out);
-                               byte[] arr = out.toByteArray();
+                               byte[] arr;
+                               String path;
+                               if (resource instanceof ByteArrayResource) {
+                                       arr = ((ByteArrayResource) resource).getByteArray();
+                                       path = "bytearray";
+                               } else {
+                                       in = resource.getInputStream();
+                                       ByteArrayOutputStream out = new ByteArrayOutputStream();
+                                       IOUtils.copy(in, out);
+                                       arr = out.toByteArray();
+                                       path = resource.getURL().getPath();
+                               }
                                ByteArrayInputStream content = new ByteArrayInputStream(arr);
-                               uploadFile(session, content, arr.length, resource.getURL()
-                                               .getPath(), resource.toString(), remotePath);
+                               uploadFile(session, content, arr.length, path, resource
+                                               .toString(), remotePath);
                                arr = null;
                        } catch (IOException e1) {
-                               throw new SlcException("Can neither interpret resource "
-                                               + localResource
-                                               + " as file, nor create a temporary file", e1);
+                               throw new SlcException("Can not interpret resource "
+                                               + localResource, e1);
                        } finally {
                                IOUtils.closeQuietly(in);
                                // no need to close byte arrays streams