Repackage to org.cristalise

3 files changed, 504 insertions, 0 deletions

diff --git a/src/main/java/org/cristalise/storage/MemoryOnlyClusterStorage.java b/src/main/java/org/cristalise/storage/MemoryOnlyClusterStorage.java
new file mode 100644
index 0000000..737a173
--- /dev/null
+++ b/src/main/java/org/cristalise/storage/MemoryOnlyClusterStorage.java
@@ -0,0 +1,166 @@
+/**

+ * This file is part of the CRISTAL-iSE kernel.

+ * Copyright (c) 2001-2014 The CRISTAL Consortium. All rights reserved.

+ *

+ * This library is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU Lesser General Public License as published

+ * by the Free Software Foundation; either version 3 of the License, or (at

+ * your option) any later version.

+ *

+ * This library is distributed in the hope that it will be useful, but WITHOUT

+ * ANY WARRANTY; with out even the implied warranty of MERCHANTABILITY or

+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public

+ * License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public License

+ * along with this library; if not, write to the Free Software Foundation,

+ * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.

+ *

+ * http://www.fsf.org/licensing/licenses/lgpl.html

+ */

+package org.cristalise.storage;

+

+import java.util.ArrayList;

+import java.util.ConcurrentModificationException;

+import java.util.HashMap;

+import java.util.Map;

+

+import org.cristalise.kernel.common.PersistencyException;

+import org.cristalise.kernel.entity.C2KLocalObject;

+import org.cristalise.kernel.lookup.ItemPath;

+import org.cristalise.kernel.persistency.ClusterStorage;

+import org.cristalise.kernel.process.auth.Authenticator;

+import org.cristalise.kernel.utils.Logger;

+

+

+public class MemoryOnlyClusterStorage extends ClusterStorage {

+

+    HashMap<ItemPath, Map<String, C2KLocalObject>> memoryCache = new HashMap<ItemPath, Map<String, C2KLocalObject>>();

+	/**

+	 * 

+	 */

+	public MemoryOnlyClusterStorage() {

+		memoryCache = new HashMap<ItemPath, Map<String,C2KLocalObject>>();

+	}

+

+	@Override

+	public void open(Authenticator auth) throws PersistencyException {

+

+	}

+

+	@Override

+	public void close() throws PersistencyException {

+	}

+

+	@Override

+	public short queryClusterSupport(String clusterType) {

+		return ClusterStorage.READWRITE;

+	}

+

+	@Override

+	public String getName() {

+		return "Memory Cache";

+	}

+

+	@Override

+	public String getId() {

+		return "Memory Cache";

+	}

+

+	@Override

+	public C2KLocalObject get(ItemPath thisItem, String path)

+			throws PersistencyException {

+        Map<String, C2KLocalObject> sysKeyMemCache = memoryCache.get(thisItem);

+        if (sysKeyMemCache != null)

+            return sysKeyMemCache.get(path);

+        return null;

+	}

+

+	@Override

+	public void put(ItemPath thisItem, C2KLocalObject obj)

+			throws PersistencyException {

+

+		// create item cache if not present

+        Map<String, C2KLocalObject> sysKeyMemCache;

+        synchronized (memoryCache) {

+        	if (memoryCache.containsKey(thisItem))

+        		sysKeyMemCache = memoryCache.get(thisItem);

+        	else {

+        		sysKeyMemCache = new HashMap<String, C2KLocalObject>();

+        		memoryCache.put(thisItem, sysKeyMemCache);

+            }

+        }

+        

+        // store object in the cache

+        String path = ClusterStorage.getPath(obj);

+        synchronized(sysKeyMemCache) {

+	        sysKeyMemCache.put(path, obj);

+        }

+

+	}

+

+	@Override

+	public void delete(ItemPath thisItem, String path)

+			throws PersistencyException {

+        Map<String, C2KLocalObject> sysKeyMemCache = memoryCache.get(thisItem);

+        if (sysKeyMemCache != null) {

+        	synchronized (sysKeyMemCache) {

+        		if (sysKeyMemCache.containsKey(path)) {

+        			sysKeyMemCache.remove(path);

+        			if (sysKeyMemCache.isEmpty()) {

+        				synchronized (memoryCache) {

+        					memoryCache.remove(thisItem);

+        				}

+        			}

+        		}

+        	}

+        }

+	}

+

+	@Override

+	public String[] getClusterContents(ItemPath thisItem, String path)

+			throws PersistencyException {

+		Map<String, C2KLocalObject> sysKeyMemCache = memoryCache.get(thisItem);

+		ArrayList<String> result = new ArrayList<String>();

+        if (sysKeyMemCache != null) {

+        	while (path.endsWith("/")) 

+        		path = path.substring(0,path.length()-1);

+        	path = path+"/";

+        	for (String thisPath : sysKeyMemCache.keySet()) {

+				if (thisPath.startsWith(path)) {

+					String end = thisPath.substring(path.length());

+					int slash = end.indexOf('/');

+					String suffix = slash>-1?end.substring(0, slash):end;

+					if (!result.contains(suffix)) result.add(suffix);

+				}

+			}

+        }

+        return result.toArray(new String[result.size()]);

+	}

+	

+    public void dumpContents(ItemPath thisItem) {

+        synchronized(memoryCache) {

+			Logger.msg(0, "Cached Objects of Entity "+thisItem);

+			Map<String, C2KLocalObject> sysKeyMemCache = memoryCache.get(thisItem);

+			if (sysKeyMemCache == null) {

+				Logger.msg(0, "No cache found");

+				return;

+			}

+            try {

+                synchronized(sysKeyMemCache) {

+             for (Object name : sysKeyMemCache.keySet()) {

+               String path = (String) name;

+               try {

+                 Logger.msg(0, "    Path "+path+": "+sysKeyMemCache.get(path).getClass().getName());

+               } catch (NullPointerException e) {

+                 Logger.msg(0, "    Path "+path+": reaped");

+               }

+             }

+                }

+            } catch (ConcurrentModificationException ex) {

+                Logger.msg(0, "Cache modified - aborting");

+            }

+		}

+        Logger.msg(0, "Total number of cached entities: "+memoryCache.size());

+    }

+}

diff --git a/src/main/java/org/cristalise/storage/ProxyLoader.java b/src/main/java/org/cristalise/storage/ProxyLoader.java
new file mode 100644
index 0000000..8922e35
--- /dev/null
+++ b/src/main/java/org/cristalise/storage/ProxyLoader.java
@@ -0,0 +1,160 @@
+/**

+ * This file is part of the CRISTAL-iSE kernel.

+ * Copyright (c) 2001-2014 The CRISTAL Consortium. All rights reserved.

+ *

+ * This library is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU Lesser General Public License as published

+ * by the Free Software Foundation; either version 3 of the License, or (at

+ * your option) any later version.

+ *

+ * This library is distributed in the hope that it will be useful, but WITHOUT

+ * ANY WARRANTY; with out even the implied warranty of MERCHANTABILITY or

+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public

+ * License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public License

+ * along with this library; if not, write to the Free Software Foundation,

+ * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.

+ *

+ * http://www.fsf.org/licensing/licenses/lgpl.html

+ */

+package org.cristalise.storage;

+import java.util.HashMap;

+import java.util.StringTokenizer;

+

+import org.cristalise.kernel.common.ObjectNotFoundException;

+import org.cristalise.kernel.common.PersistencyException;

+import org.cristalise.kernel.entity.AgentHelper;

+import org.cristalise.kernel.entity.C2KLocalObject;

+import org.cristalise.kernel.entity.Item;

+import org.cristalise.kernel.entity.ItemHelper;

+import org.cristalise.kernel.lookup.ItemPath;

+import org.cristalise.kernel.lookup.Lookup;

+import org.cristalise.kernel.persistency.ClusterStorage;

+import org.cristalise.kernel.persistency.outcome.Outcome;

+import org.cristalise.kernel.process.Gateway;

+import org.cristalise.kernel.process.auth.Authenticator;

+import org.cristalise.kernel.utils.Logger;

+

+

+/** Used by proxies to load clusters by queryData from the Entity.

+*   Last client storage - only used if not cached elsewhere

+*/

+

+public class ProxyLoader extends ClusterStorage {

+    HashMap<ItemPath, Item> entities = new HashMap<ItemPath, Item>();

+    Lookup lookup;

+

+    @Override

+	public void open(Authenticator auth) throws PersistencyException {

+        lookup = Gateway.getLookup();

+    }

+

+    @Override

+	public void close() throws PersistencyException {

+    }

+    // introspection

+    @Override

+	public short queryClusterSupport(String clusterType) {

+        return READ;

+    }

+

+    @Override

+	public String getName() {

+        return "Proxy Cluster Loader";

+    }

+

+    @Override

+	public String getId() {

+        return "CORBA";

+    }

+

+    // retrieve object by path

+    @Override

+	public C2KLocalObject get(ItemPath thisItem, String path) throws PersistencyException {

+        try {

+            Item thisEntity = getIOR(thisItem);

+            String type = getClusterType(path);

+

+            // fetch the xml from the item

+            String queryData = thisEntity.queryData(path);

+            if (Logger.doLog(6)) Logger.msg(6, "ProxyLoader - "+thisItem+":"+path+" = "+queryData);

+

+            if (queryData != null) {

+                if (type.equals(OUTCOME))

+                    return new Outcome(path, queryData);

+                else

+                    return (C2KLocalObject)Gateway.getMarshaller().unmarshall(queryData);

+            }

+        } catch (ObjectNotFoundException e) {

+        	return null;

+        } catch (Exception e) {

+            Logger.error(e);

+            throw new PersistencyException(e.getMessage());

+        }

+        return null;

+    }

+

+    // store object by path

+    @Override

+	public void put(ItemPath thisItem, C2KLocalObject obj) throws PersistencyException {

+        // not supported

+        throw new PersistencyException("Cannot write to items through the ProxyLoader");

+    }

+    // delete cluster

+    @Override

+	public void delete(ItemPath thisItem, String path) throws PersistencyException {

+        // not supported

+        throw new PersistencyException("Cannot write to items through the ProxyLoader");

+    }

+

+    /* navigation */

+

+    // directory listing

+    @Override

+	public String[] getClusterContents(ItemPath thisItem, String path) throws PersistencyException {

+        try {

+            Item thisEntity = getIOR(thisItem);

+            String contents = thisEntity.queryData(path+"/all");

+            StringTokenizer tok = new StringTokenizer(contents, ",");

+            String[] result = new String[tok.countTokens()];

+            for (int i=0; i<result.length; i++)

+                result[i] = tok.nextToken();

+

+            return result;

+        } catch (Exception e) {

+        	Logger.error(e);

+            throw new PersistencyException(e.getMessage());

+        }

+    }

+

+    private Item getIOR(ItemPath thisPath) throws PersistencyException {

+        if (entities.containsKey(thisPath)) {

+            // check the cache

+            Logger.msg(7, "ProxyLoader.getIOR() - "+thisPath+" cached.");

+            return entities.get(thisPath);

+        }

+

+        try {

+            Logger.msg(7, "ProxyLoader.getIOR() - Resolving "+thisPath+".");

+            org.omg.CORBA.Object ior = lookup.resolve(thisPath);

+

+            Item thisItem = null;

+            try {

+            	thisItem = ItemHelper.narrow(ior);

+            } catch (org.omg.CORBA.BAD_PARAM ex) {

+                try {

+                	thisItem =  AgentHelper.narrow(ior);

+                } catch (org.omg.CORBA.BAD_PARAM ex2) {

+                    throw new PersistencyException ("Could not narrow "+thisItem+" as a known Entity type");

+                }

+            }

+

+            Logger.msg(7, "ProxyLoader.getIOR() - Found "+thisItem+".");

+            entities.put(thisPath, thisItem);

+            return thisItem;

+        } catch (Exception e) {

+            throw new PersistencyException("Error narrowing "+thisPath+": "+e.getMessage());

+        }

+    }

+}

diff --git a/src/main/java/org/cristalise/storage/XMLClusterStorage.java b/src/main/java/org/cristalise/storage/XMLClusterStorage.java
new file mode 100644
index 0000000..3ac864e
--- /dev/null
+++ b/src/main/java/org/cristalise/storage/XMLClusterStorage.java
@@ -0,0 +1,178 @@
+/**

+ * This file is part of the CRISTAL-iSE kernel.

+ * Copyright (c) 2001-2014 The CRISTAL Consortium. All rights reserved.

+ *

+ * This library is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU Lesser General Public License as published

+ * by the Free Software Foundation; either version 3 of the License, or (at

+ * your option) any later version.

+ *

+ * This library is distributed in the hope that it will be useful, but WITHOUT

+ * ANY WARRANTY; with out even the implied warranty of MERCHANTABILITY or

+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public

+ * License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public License

+ * along with this library; if not, write to the Free Software Foundation,

+ * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.

+ *

+ * http://www.fsf.org/licensing/licenses/lgpl.html

+ */

+package org.cristalise.storage;

+import java.io.File;

+import java.util.ArrayList;

+

+import org.cristalise.kernel.common.PersistencyException;

+import org.cristalise.kernel.entity.C2KLocalObject;

+import org.cristalise.kernel.lookup.InvalidItemPathException;

+import org.cristalise.kernel.lookup.ItemPath;

+import org.cristalise.kernel.persistency.ClusterStorage;

+import org.cristalise.kernel.persistency.outcome.Outcome;

+import org.cristalise.kernel.process.Gateway;

+import org.cristalise.kernel.process.auth.Authenticator;

+import org.cristalise.kernel.utils.FileStringUtility;

+import org.cristalise.kernel.utils.Logger;

+

+

+public class XMLClusterStorage extends ClusterStorage {

+    String rootDir=null;

+

+    public XMLClusterStorage() {

+    }

+

+    @Override

+	public void open(Authenticator auth) throws PersistencyException {

+        String rootProp = Gateway.getProperties().getString("XMLStorage.root");

+        if (rootProp == null)

+            throw new PersistencyException("XMLClusterStorage.open() - Root path not given in config file.");

+

+        rootDir = new File(rootProp).getAbsolutePath();

+

+        if( !FileStringUtility.checkDir( rootDir ) ) {

+            Logger.error("XMLClusterStorage.open() - Path " + rootDir + "' does not exist. Attempting to create.");

+            boolean success = FileStringUtility.createNewDir(rootDir);

+            if (!success) throw new PersistencyException("XMLClusterStorage.open() - Could not create dir "+ rootDir +". Cannot continue.");

+        }

+    }

+

+    @Override

+	public void close() {

+        rootDir = null;

+    }

+

+    // introspection

+    @Override

+	public short queryClusterSupport(String clusterType) {

+        return ClusterStorage.READWRITE;

+    }

+

+    @Override

+	public String getName() {

+        return "XML File Cluster Storage";

+    }

+

+    @Override

+	public String getId() {

+        return "XML";

+    }

+

+    /* object manipulation */

+

+    // retrieve object by path

+    @Override

+	public C2KLocalObject get(ItemPath itemPath, String path) throws PersistencyException {

+        try {

+            String type = ClusterStorage.getClusterType(path);

+            String filePath = getFilePath(itemPath, path)+".xml";

+            String objString = FileStringUtility.file2String(filePath);

+            if (objString.length() == 0) return null;

+            Logger.debug(9, objString);

+            if (type.equals("Outcome"))

+                return new Outcome(path, objString);

+            else {

+                C2KLocalObject obj = (C2KLocalObject)Gateway.getMarshaller().unmarshall(objString);

+                return obj;

+            }

+

+        } catch (Exception e) {

+            Logger.msg(3,"XMLClusterStorage.get() - The path "+path+" from "+itemPath+" does not exist.: "+e.getMessage());

+        }

+        return null;

+    }

+

+    // store object by path

+    @Override

+	public void put(ItemPath itemPath, C2KLocalObject obj) throws PersistencyException {

+        try {

+            String filePath = getFilePath(itemPath, getPath(obj)+".xml");

+            Logger.msg(7, "Writing "+filePath);

+            String data = Gateway.getMarshaller().marshall(obj);

+

+            String dir = filePath.substring(0, filePath.lastIndexOf('/'));

+        if( !FileStringUtility.checkDir( dir ) ) {

+            boolean success = FileStringUtility.createNewDir(dir);

+            if (!success) throw new PersistencyException("XMLClusterStorage.put() - Could not create dir "+ dir +". Cannot continue.");

+        }

+            FileStringUtility.string2File(filePath, data);

+        } catch (Exception e) {

+            Logger.error(e);

+            throw new PersistencyException("XMLClusterStorage.put() - Could not write "+getPath(obj)+" to "+itemPath);

+        }

+    }

+

+    // delete cluster

+    @Override

+	public void delete(ItemPath itemPath, String path) throws PersistencyException {

+        try {

+            String filePath = getFilePath(itemPath, path+".xml");

+            boolean success = FileStringUtility.deleteDir(filePath, true, true);

+            if (success) return;

+            filePath = getFilePath(itemPath, path);

+            success = FileStringUtility.deleteDir(filePath, true, true);

+            if (success) return;

+        } catch(Exception e) { }

+        throw new PersistencyException("XMLClusterStorage.delete() - Failure deleting path "+path+" in "+itemPath);

+    }

+

+    /* navigation */

+

+    // directory listing

+    @Override

+	public String[] getClusterContents(ItemPath itemPath, String path) throws PersistencyException {

+		String[] result = new String[0];

+        try {

+            String filePath = getFilePath(itemPath, path);

+            ArrayList<String> paths = FileStringUtility.listDir( filePath, true, false );

+            if (paths == null) return result; // dir doesn't exist yet

+            ArrayList<String> contents = new ArrayList<String>();

+            String previous = null;

+            for (int i=0; i<paths.size(); i++) {

+                String next = paths.get(i);

+

+                // trim off the xml from the end if it's there

+                if (next.endsWith(".xml")) next = next.substring(0, next.length()-4);

+

+                // avoid duplicates (xml and dir)

+                if (next.equals(previous)) continue;

+                previous = next;

+

+                // only keep the last bit of the path

+                if (next.indexOf('/') > -1) next = next.substring(next.lastIndexOf('/')+1);

+                contents.add(next);

+            }

+

+            result = contents.toArray(result);

+            return result;

+        } catch (Exception e) {

+        	Logger.error(e);

+            throw new PersistencyException("XMLClusterStorage.getClusterContents() - Could not get contents of "+path+" from "+itemPath+": "+e.getMessage());

+        }

+    }

+

+    protected String getFilePath(ItemPath itemPath, String path) throws InvalidItemPathException {

+        if (path.length() == 0 || path.charAt(0) != '/') path = "/"+path;

+        String filePath = rootDir+itemPath.toString()+path;

+        Logger.msg(8, "XMLClusterStorage.getFilePath() - "+filePath);

+        return filePath;

+    }

+}