moved to sub projects

vasc-backends/vasc-backend-ldap/.classpath

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" output="target/classes" path="src/main/java"/>
+	<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources"/>
+	<classpathentry kind="src" output="target/test-classes" path="src/test/java"/>
+	<classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
+	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER"/>
+	<classpathentry kind="con" path="org.maven.ide.eclipse.MAVEN2_CLASSPATH_CONTAINER"/>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>

vasc-backends/vasc-backend-ldap/.project

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>vasc-backend-ldap</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.maven.ide.eclipse.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.maven.ide.eclipse.maven2Nature</nature>
+	</natures>
+</projectDescription>

vasc-backends/vasc-backend-ldap/.settings/org.eclipse.core.resources.prefs

@@ -0,0 +1,7 @@
+#Sun Dec 25 17:29:07 CET 2011
+eclipse.preferences.version=1
+encoding//src/main/java=UTF-8
+encoding//src/main/resources=UTF-8
+encoding//src/test/java=UTF-8
+encoding//src/test/resources=UTF-8
+encoding/<project>=UTF-8

vasc-backends/vasc-backend-ldap/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,6 @@
+#Mon Aug 30 21:55:41 CEST 2010
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
+org.eclipse.jdt.core.compiler.compliance=1.5
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
+org.eclipse.jdt.core.compiler.source=1.5

vasc-backends/vasc-backend-ldap/.settings/org.eclipse.m2e.core.prefs

@@ -0,0 +1,5 @@
+#Sun Dec 25 17:29:02 CET 2011
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1

vasc-backends/vasc-backend-ldap/.settings/org.maven.ide.eclipse.prefs

@@ -0,0 +1,9 @@
+#Mon Aug 30 21:55:40 CEST 2010
+activeProfiles=
+eclipse.preferences.version=1
+fullBuildGoals=process-test-resources
+includeModules=false
+resolveWorkspaceProjects=true
+resourceFilterGoals=process-resources resources\:testResources
+skipCompilerPlugin=true
+version=1

vasc-backends/vasc-backend-ldap/pom.xml

@@ -0,0 +1,25 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <artifactId>vasc-backends</artifactId>
+    <groupId>net.forwardfire.vasc</groupId>
+    <version>0.3.5-SNAPSHOT</version>
+  </parent>
+  <groupId>net.forwardfire.vasc</groupId>
+  <artifactId>vasc-backend-ldap</artifactId>
+  <version>0.3.5-SNAPSHOT</version>
+  <name>vasc-backend-ldap</name>
+  <description>vasc-backend-ldap</description>
+  <dependencies>
+  	<dependency>
+		<groupId>net.forwardfire.vasc</groupId>
+		<artifactId>vasc-core</artifactId>
+		<version>${project.version}</version>
+    </dependency>
+    <dependency>
+		<groupId>com.novell.ldap</groupId>
+		<artifactId>jldap</artifactId>
+		<version>${jldap.version}</version>
+    </dependency>
+  </dependencies>
+</project>

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;
+	}
+}