moved to sub projects

vasc-backends/vasc-backend-ldap/src/main/java/net/forwardfire/vasc/backends/ldap/LdapConnectionProvider.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2004-2007 IDCA. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+ * following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of conditions and
+ *        the following disclaimer.
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions
+ *        and the following disclaimer in the documentation and/or other materials provided with the
+ *        distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY IDCA AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL IDCA OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the authors and
+ * should not be interpreted as representing official policies, either expressed or implied, of IDCA.
+ */
+
+package net.forwardfire.vasc.backends.ldap;
+
+import com.novell.ldap.LDAPConnection;
+
+/**
+ * 
+ * @author Willem Cazander
+ * @version 1.0 Sep 4, 2008
+ */
+public interface LdapConnectionProvider {
+	
+	public LDAPConnection getLdapConnection();
+}

vasc-backends/vasc-backend-ldap/src/main/java/net/forwardfire/vasc/backends/ldap/LdapVascBackend.java

@@ -0,0 +1,334 @@
+/*
+ * Copyright 2004-2007 IDCA. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+ * following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of conditions and
+ *        the following disclaimer.
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions
+ *        and the following disclaimer in the documentation and/or other materials provided with the
+ *        distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY IDCA AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL IDCA OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the authors and
+ * should not be interpreted as representing official policies, either expressed or implied, of IDCA.
+ */
+
+package net.forwardfire.vasc.backends.ldap;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import net.forwardfire.vasc.backends.MapVascEntryFieldValue;
+import net.forwardfire.vasc.backends.MapVascEntryRecordCreator;
+import net.forwardfire.vasc.core.AbstractVascBackend;
+import net.forwardfire.vasc.core.VascBackendState;
+import net.forwardfire.vasc.core.VascEntry;
+import net.forwardfire.vasc.core.VascEntryField;
+import net.forwardfire.vasc.core.VascException;
+import net.forwardfire.vasc.core.entry.VascEntryFieldValue;
+import net.forwardfire.vasc.core.entry.VascEntryRecordCreator;
+
+
+import com.novell.ldap.LDAPAttribute;
+import com.novell.ldap.LDAPAttributeSet;
+import com.novell.ldap.LDAPConnection;
+import com.novell.ldap.LDAPEntry;
+import com.novell.ldap.LDAPModification;
+import com.novell.ldap.LDAPSearchConstraints;
+import com.novell.ldap.LDAPSearchResults;
+
+/**
+ * Provides backend for ldap.
+ * 
+ * @author Willem Cazander
+ * @version 1.0 Sep 4, 2008
+ */
+public class LdapVascBackend extends AbstractVascBackend  {
+
+
+	private LdapConnectionProvider ldapConnectionProvider = null;
+	private String baseDN = null;
+	private String keyAttribute = null;
+	private String ldapFilter = null;
+	
+	
+	/**
+	 * @return the ldapConnectionProvider
+	 */
+	public LdapConnectionProvider getLdapConnectionProvider() {
+		return ldapConnectionProvider;
+	}
+
+	/**
+	 * @param ldapConnectionProvider the ldapConnectionProvider to set
+	 */
+	public void setLdapConnectionProvider(LdapConnectionProvider ldapConnectionProvider) {
+		this.ldapConnectionProvider = ldapConnectionProvider;
+	}
+
+	
+	
+	
+	/**
+	 * @see net.forwardfire.vasc.core.VascBackend#execute()
+	 */
+	public List<Object> execute(VascBackendState state) throws VascException {
+		LdapConnectionProvider prov = getLdapConnectionProvider();
+		LDAPConnection connection = prov.getLdapConnection();
+		List<Object> result = new ArrayList<Object>(50); 
+		try {
+			
+
+			LDAPSearchConstraints cons = new LDAPSearchConstraints();
+			cons.setBatchSize( 0 );
+	        cons.setTimeLimit( 10000 ) ;
+	        cons.setReferralFollowing(true);
+	        connection.setConstraints(cons);
+
+	        int searchScope = LDAPConnection.SCOPE_ONE;
+	        String searchBase  = baseDN;
+			
+	        //System.out.println("Reading object :" + searchBase + " with filter: " + ldapFilter);
+            LDAPSearchResults searchResults = connection.search(
+            				searchBase,      // object to read
+                            searchScope,  // scope - read single object
+                            ldapFilter,   // search filter
+                            null,         // return all attributes
+                            false);       // return attrs and values
+            
+            while (searchResults.hasMore()) {
+            	 LDAPEntry entry = searchResults.next();
+            	 Map<String,Object> map = new HashMap<String,Object>(10);
+            	 
+            	 LDAPAttributeSet attributeSet = entry.getAttributeSet();
+            	 Iterator<LDAPAttribute> i = attributeSet.iterator();
+            	 while (i.hasNext()) {
+            		 LDAPAttribute attr = i.next();
+            		 //System.out.println("ATTR: "+attr.getName()+" value: "+attr.getStringValue());
+            		 String[] s = attr.getStringValueArray();
+            		 if (s.length==1) {
+            			 map.put(attr.getName(), attr.getStringValue());
+            		 } else {
+            			 List<String> multiValue = new ArrayList<String>(s.length);
+            			 for (String ss:s) {
+            				 multiValue.add(ss);
+            			 }
+            			 map.put(attr.getName(), multiValue );
+            		 }
+            	 }
+            	 result.add(map);	 
+            }
+		} catch (Exception e) {
+			throw new VascException(e);
+		} finally {
+			if (connection!=null) {
+				connection.clone();
+			}
+		}
+		return result;
+	}
+
+	/**
+	 * @see net.forwardfire.vasc.core.VascBackend#merge(java.lang.Object)
+	 */
+	public Object merge(Object object) throws VascException {
+		LdapConnectionProvider prov = getLdapConnectionProvider();
+		LDAPConnection connection = prov.getLdapConnection();
+		try {
+			Map<String,Object> map = (Map)object;
+			String keyValue = (String)map.get(keyAttribute);
+			LDAPSearchConstraints cons = new LDAPSearchConstraints();
+			cons.setBatchSize( 0 );
+	        cons.setTimeLimit( 10000 ) ;
+	        cons.setReferralFollowing(true);
+	        connection.setConstraints(cons);
+
+	        int searchScope = LDAPConnection.SCOPE_ONE;
+	        String searchBase  = baseDN;
+	        String filter = "(&("+keyAttribute+"="+keyValue+"))";
+	        System.out.println("ldap filter: "+filter);
+            LDAPSearchResults searchResults = connection.search(
+            				searchBase,      // object to read
+                            searchScope,  // scope - read single object
+                            filter,   // search filter
+                            null,         // return all attributes
+                            false);       // return attrs and values
+            
+            if (searchResults.hasMore()==false) {
+            	// no result to mod
+            	return object;
+            }
+            LDAPEntry entry = searchResults.next();
+			List<LDAPModification> mods = new ArrayList<LDAPModification>(20);
+            for (String key:map.keySet()) {
+            	Object value = map.get(key);
+            	LDAPAttribute attr = entry.getAttribute(key);
+            	
+            	String[] s = attr.getStringValueArray();
+       		 	if (s.length==1) {
+       		 		String v = (String)value;
+       		 		if (attr.getStringValue().equals(v)==false) {
+       		 			LDAPModification mod = new LDAPModification(LDAPModification.REPLACE,new LDAPAttribute(key,v));
+       		 			mods.add(mod);
+       		 		}
+       		 		map.put(attr.getName(), attr.getStringValue());
+       		 	} else {
+       		 		List<String> multiValue = new ArrayList<String>(s.length);
+       		 		for (String ss:s) {
+       		 			multiValue.add(ss);
+       		 		}
+       		 		List<String> v = null;
+       		 		if (value instanceof String) {
+       		 			v = new ArrayList<String>(1);
+       		 			v.add((String)value);
+       		 		} else {
+       		 			v = (List<String>)value;
+       		 		}
+       		 		if (v.equals(multiValue)==false) {
+       		 			LDAPAttribute a = new LDAPAttribute(key);
+       		 			for (String vv:v) {
+       		 				a.addValue(vv);	
+       		 			}
+       		 			LDAPModification mod = new LDAPModification(LDAPModification.REPLACE,a);
+       		 			mods.add(mod);
+       		 		}
+       		 	}
+            }
+
+            LDAPModification[] m = new LDAPModification[mods.size()];
+            mods.toArray(m);
+			connection.modify(entry.getDN(), m);
+			return object;
+		} catch (Exception e) {
+			throw new VascException(e);
+		} finally {
+			if (connection!=null) {
+				connection.clone();
+			}
+		}
+	}
+
+	/**
+	 * @see net.forwardfire.vasc.core.VascBackend#persist(java.lang.Object)
+	 */
+	public void persist(Object object) throws VascException {
+		LdapConnectionProvider prov = getLdapConnectionProvider();
+		LDAPConnection connection = prov.getLdapConnection();
+		try {
+			LDAPEntry entry = new LDAPEntry();
+		//	entry.getAttributeSet().
+			
+			connection.add(entry);
+		} catch (Exception e) {
+			throw new VascException(e);
+		} finally {
+			if (connection!=null) {
+				connection.clone();
+			}
+		}
+	}
+	
+	/**
+	 * @see net.forwardfire.vasc.core.VascBackend#delete(java.lang.Object)
+	 */
+	public void delete(Object object) throws VascException {
+		LdapConnectionProvider prov = getLdapConnectionProvider();
+		LDAPConnection connection = prov.getLdapConnection();
+		try {
+			Map<String,Object> map = (Map)object;
+			String keyValue = (String)map.get(keyAttribute);
+	        int searchScope = LDAPConnection.SCOPE_ONE;
+	        String searchBase  = baseDN;
+	        String filter = "(&("+ldapFilter+")("+keyAttribute+"="+keyValue+"))";
+            LDAPSearchResults searchResults = connection.search(
+            				searchBase,      // object to read
+                            searchScope,  // scope - read single object
+                            filter,   // search filter
+                            null,         // return all attributes
+                            false);       // return attrs and values
+            
+            if (searchResults.hasMore()==false) {
+            	// no result to mod
+            	return;
+            }
+            LDAPEntry entry = searchResults.next();
+            connection.delete(entry.getDN());
+		} catch (Exception e) {
+			throw new VascException(e);
+		} finally {
+			if (connection!=null) {
+				connection.clone();
+			}
+		}
+	}
+	
+	/**
+	 * @see net.forwardfire.vasc.core.VascBackend#provideVascEntryRecordCreator(net.forwardfire.vasc.core.VascEntry)
+	 */
+	public VascEntryRecordCreator provideVascEntryRecordCreator(VascEntry vascEntry) {
+		return new MapVascEntryRecordCreator();
+	}
+
+	/**
+	 * @see net.forwardfire.vasc.core.VascBackend#provideVascEntryFieldValue(net.forwardfire.vasc.core.VascEntryField)
+	 */
+	public VascEntryFieldValue provideVascEntryFieldValue(VascEntryField field) {
+		return new MapVascEntryFieldValue();
+	}
+
+	/**
+	 * @return the baseDN
+	 */
+	public String getBaseDN() {
+		return baseDN;
+	}
+
+	/**
+	 * @param baseDN the baseDN to set
+	 */
+	public void setBaseDN(String baseDN) {
+		this.baseDN = baseDN;
+	}
+
+	/**
+	 * @return the keyAttribute
+	 */
+	public String getKeyAttribute() {
+		return keyAttribute;
+	}
+
+	/**
+	 * @param keyAttribute the keyAttribute to set
+	 */
+	public void setKeyAttribute(String keyAttribute) {
+		this.keyAttribute = keyAttribute;
+	}
+
+	/**
+	 * @return the ldapFilter
+	 */
+	public String getLdapFilter() {
+		return ldapFilter;
+	}
+
+	/**
+	 * @param ldapFilter the ldapFilter to set
+	 */
+	public void setLdapFilter(String ldapFilter) {
+		this.ldapFilter = ldapFilter;
+	}
+}

vasc-backends/vasc-backend-ldap/src/main/java/net/forwardfire/vasc/backends/ldap/SimpleLdapConnectionProvider.java

@@ -0,0 +1,138 @@
+/*
+ * Copyright 2004-2007 IDCA. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+ * following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of conditions and
+ *        the following disclaimer.
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions
+ *        and the following disclaimer in the documentation and/or other materials provided with the
+ *        distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY IDCA AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL IDCA OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the authors and
+ * should not be interpreted as representing official policies, either expressed or implied, of IDCA.
+ */
+
+package net.forwardfire.vasc.backends.ldap;
+
+import com.novell.ldap.LDAPConnection;
+
+/**
+ * 
+ * @author Willem Cazander
+ * @version 1.0 Sep 4, 2008
+ */
+public class SimpleLdapConnectionProvider implements LdapConnectionProvider {
+
+	private String ldapHost = "localhost";
+	private int ldapPort = LDAPConnection.DEFAULT_PORT;
+	private int ldapVersion  = LDAPConnection.LDAP_V3;
+	private String bindUser = null;
+	private String bindPass = null;
+	
+	/**
+	 * @see net.forwardfire.vasc.backends.ldap.LdapConnectionProvider#getLdapConnection()
+	 */
+	public LDAPConnection getLdapConnection() {
+		try {
+			
+			// if ssl;
+			//Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider());
+			//System.setProperty("javax.net.ssl.trustStore", "/tmp/somewhere/ldap.root.crt");
+			//LDAPSocketFactory ssf = new LDAPJSSESecureSocketFactory();
+			// Set the socket factory as the default for all future connections
+			//LDAPConnection.setSocketFactory(ssf);
+
+			LDAPConnection lc = new LDAPConnection();
+			lc.connect( ldapHost, ldapPort );
+			if (bindUser!=null && bindPass!=null) { 
+				lc.bind( ldapVersion, bindUser, bindPass.getBytes("UTF8") );
+			}
+			return lc;
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	/**
+	 * @return the ldapHost
+	 */
+	public String getLdapHost() {
+		return ldapHost;
+	}
+
+	/**
+	 * @param ldapHost the ldapHost to set
+	 */
+	public void setLdapHost(String ldapHost) {
+		this.ldapHost = ldapHost;
+	}
+
+	/**
+	 * @return the ldapPort
+	 */
+	public int getLdapPort() {
+		return ldapPort;
+	}
+
+	/**
+	 * @param ldapPort the ldapPort to set
+	 */
+	public void setLdapPort(int ldapPort) {
+		this.ldapPort = ldapPort;
+	}
+
+	/**
+	 * @return the ldapVersion
+	 */
+	public int getLdapVersion() {
+		return ldapVersion;
+	}
+
+	/**
+	 * @param ldapVersion the ldapVersion to set
+	 */
+	public void setLdapVersion(int ldapVersion) {
+		this.ldapVersion = ldapVersion;
+	}
+
+	/**
+	 * @return the bindUser
+	 */
+	public String getBindUser() {
+		return bindUser;
+	}
+
+	/**
+	 * @param bindUser the bindUser to set
+	 */
+	public void setBindUser(String bindUser) {
+		this.bindUser = bindUser;
+	}
+
+
+	/**
+	 * @return the bindPass
+	 */
+	public String getBindPass() {
+		return bindPass;
+	}
+
+	/**
+	 * @param bindPass the bindPass to set
+	 */
+	public void setBindPass(String bindPass) {
+		this.bindPass = bindPass;
+	}
+}