Adds a proof-of-concept recording/playback cache for the XMLA driver.…

… To use, uncomment the right lines in test.properties and unzip the xmla/cache/mondrian-xmla-[VERSION].zip file you want to test against. Make sure that the test.properties entry points to the proper file.

Known issues: The requests are loaded into memory in a simple hashmap. This is slow. There is also an issue with TestStatementTimeout. Will try to resolve that later.

git-svn-id: https://olap4j.svn.sourceforge.net/svnroot/olap4j/trunk@421 c6a108a4-781c-0410-a6c6-c2d559e19af0

test.properties

@@ -49,8 +49,24 @@ org.olap4j.test.connectUrl=jdbc:mondrian:Datasource=jdbc/SampleData;Catalog=./fo
 # Both the data and the schema can be found in /foodmart
 
 #org.olap4j.test.helperClassName=org.olap4j.RemoteXmlaTester
-#org.olap4j.RemoteXmlaTester.JdbcUrl=jdbc:xmla:Server=http://localhost:8080/mondrian/xmla
+#org.olap4j.RemoteXmlaTester.JdbcUrl=jdbc:xmla:Server=http://localhost:81/mondrian/xmla
 #org.olap4j.RemoteXmlaTester.Username=joe
 #org.olap4j.RemoteXmlaTester.Password=password
 
+###############################################################################
+# Examples of the remote XMLA tester using a special proxy to record/play
+# known responses. So far, it is only a proof of concept. We do not recommend
+# to rely on this for testing.
+
+# This example uses a cached Mondrian 3.3-SNAPSHOT server requests/responses data file
+# to run the TCK.
+# To make this example work, one must first unzip the data file manually.
+#org.olap4j.test.helperClassName=org.olap4j.RemoteXmlaTester
+#org.olap4j.RemoteXmlaTester.JdbcUrl=jdbc:xmla:Server=http://example.com;Cache=org.olap4j.driver.xmla.cache.XmlaTextFileCache;Cache.Play=true;Cache.Input=./xmla-cache/mondrian-xmla-3.3-SNAPSHOT.dat
+
+# This other example conencts to an olap server and records the requests to a file.
+#org.olap4j.test.helperClassName=org.olap4j.RemoteXmlaTester
+#org.olap4j.RemoteXmlaTester.JdbcUrl=jdbc:xmla:Server=http://localhost:81/mondrian/xmla;Cache=org.olap4j.driver.xmla.cache.XmlaTextFileCache;Cache.Record=true;Cache.Output=./output-xmla.dat
+
+
 # End test.properties

testsrc/org/olap4j/driver/xmla/cache/XmlaTextFileCache.java

@@ -0,0 +1,156 @@
+package org.olap4j.driver.xmla.cache;
+
+import java.io.BufferedReader;
+import java.io.DataInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.URL;
+import java.util.Map;
+import java.util.StringTokenizer;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.olap4j.impl.Base64;
+
+/**
+ * This mock server cache is only used to save and load
+ * runs of the XMLA driver as an external file.
+ * @author LBoudreau
+ */
+public class XmlaTextFileCache implements XmlaOlap4jCache {
+
+    private static boolean initDone = false;
+    private final static String CACHE_IDENT= "Chunky Bacon!";
+    private final static ConcurrentHashMap<String, byte[]> cache =
+        new ConcurrentHashMap<String, byte[]>();
+
+    public static enum Properties {
+        /**
+         * File to save the requests to, if RECORD is true.
+         * java.util.File(path) will be used.
+         */
+        OUTPUT,
+        /**
+         * File to read the requests from, if PLAY is true.
+         * java.util.File(path) will be used.
+         */
+        INPUT,
+        /**
+         * Whether to record the requests/responses to a file.
+         */
+        RECORD,
+        /**
+         * Whether to playback responses from a file.
+         */
+        PLAY,
+    }
+
+    private static File output = null;
+    private static File input = null;
+    private static boolean record = false;
+    private static boolean play = false;;
+
+    public void flushCache() {
+        // no op
+    }
+
+    public byte[] get(String id, URL url, byte[] request)
+            throws XmlaOlap4jInvalidStateException
+    {
+        synchronized (cache) {
+            if (play && input != null) {
+                return cache.get(new String(request));
+            } else {
+                return null;
+            }
+        }
+    }
+
+    public void put(String id, URL url, byte[] request, byte[] response)
+            throws XmlaOlap4jInvalidStateException
+    {
+        synchronized (cache) {
+            if (record && output != null) {
+                String base64Request = Base64.encodeBytes(request);
+                String base64Response = Base64.encodeBytes(response);
+                try {
+                    FileWriter writer = new FileWriter(output, true);
+                    try 
+                    {
+                        writer.write(base64Request);
+                        writer.write("\r\n||\r\n");
+                        writer.write(base64Response);
+                        writer.write("\r\n||\r\n");
+                        writer.flush();
+                    } finally {
+                        writer.close();
+                    }
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+    }
+
+    public String setParameters(Map<String, String> config,
+            Map<String, String> props)
+    {
+        if (!initDone) {
+            synchronized (cache) {
+                cache.clear();
+                try {
+                    if (props.containsKey(Properties.RECORD.name())
+                            && props.containsKey(Properties.OUTPUT.name()))
+                    {
+                        record = true;
+                        output = new File(props.get(Properties.OUTPUT.name()));
+                        if (!output.exists()
+                                && !output.createNewFile()) {
+                            throw new RuntimeException(
+                                    "Failed to create output file.");
+                        }
+                    }
+                    if (props.containsKey(Properties.PLAY.name())
+                            && props.containsKey(Properties.INPUT.name()))
+                    {
+                        play = true;
+                        input = new File(props.get(Properties.INPUT.name()));
+                        if (input.exists()) {
+                            FileInputStream fstream =
+                                new FileInputStream(input);
+                            DataInputStream in =
+                                new DataInputStream(fstream);
+                            BufferedReader br =
+                                new BufferedReader(new InputStreamReader(in));
+                            String strLine;
+                            StringBuilder sb = new StringBuilder();
+                            while ((strLine = br.readLine()) != null) {
+                                sb.append(strLine);
+                            }
+                            StringTokenizer st =
+                                new StringTokenizer(
+                                    sb.toString(),
+                                    "\r\n|||\r\n");
+                            while (st.hasMoreTokens()) {
+                                byte[] request =
+                                    Base64.decode(st.nextToken());
+                                byte[] response =
+                                    Base64.decode(st.nextToken());
+                                cache.put(new String(request), response);
+                            }
+                            in.close();
+                        }
+                    }
+                } catch (Exception e) {
+                    throw new RuntimeException(
+                        "Failed to configure the mock server cache.",
+                        e);
+                }
+            }
+        }
+        return CACHE_IDENT;
+    }
+
+}