nicolaken 2002/11/28 07:12:34
Modified: . changes.xml module.xml properties.xml
Added: src/blocks/naming/java/org/apache/cocoon/transformation
LDAPTransformer.java
src/blocks/naming/conf naming.xmap
src/blocks/naming/samples notyet.txt
Removed: src/java/org/apache/cocoon/transformation
LDAPTransformer.java naming.xmap
Log:
<action dev="NKB" type="update">
Moved LDAPTransformer to a block called "naming".
</action>
Revision Changes Path
1.291 +5 -2 xml-cocoon2/changes.xml
Index: changes.xml
===================================================================
RCS file: /home/cvs/xml-cocoon2/changes.xml,v
retrieving revision 1.290
retrieving revision 1.291
diff -u -r1.290 -r1.291
--- changes.xml 28 Nov 2002 08:41:53 -0000 1.290
+++ changes.xml 28 Nov 2002 15:12:32 -0000 1.291
@@ -40,11 +40,14 @@
</devs>
<release version="@version@" date="@date@">
+ <action dev="NKB" type="update">
+ Moved LDAPTransformer to a block called "naming".
+ </action>
<action dev="DC" type="update" fixes-bug="14581" due-to="Colin Paul Adams"
due-to-email="[EMAIL PROTECTED]">
New build target "validate-schematron" to conduct build-time validation
(currently only the sitemaps) using RELAX NG grammars with embedded
Schematron rules.
- This uses <link="http://www.ascc.net/xml/schematron/";>Schematron</link>
+ This uses <link href="http://www.ascc.net/xml/schematron/";>Schematron</link>
stylesheets from Rick Jelliffe and Academia Sinica Computing Center, Taiwan.
</action>
<action dev="DC" type="add" due-to="Colin Paul Adams"
due-to-email="[EMAIL PROTECTED]">
1.18 +19 -0 xml-cocoon2/module.xml
Index: module.xml
===================================================================
RCS file: /home/cvs/xml-cocoon2/module.xml,v
retrieving revision 1.17
retrieving revision 1.18
diff -u -r1.17 -r1.18
--- module.xml 25 Nov 2002 15:18:30 -0000 1.17
+++ module.xml 28 Nov 2002 15:12:33 -0000 1.18
@@ -333,6 +333,25 @@
</project>
+ <project name="naming-block">
+ <package>org.apache.cocoon</package>
+
+ <ant target="block">
+ <property name="block-name" value="naming"/>
+ </ant>
+
+ <depend project="xml-cocoon2"/>
+
+ <work nested="tools/anttasks"/>
+ <home nested="build/cocoon"/>
+
+ <jar name="naming-block.jar"/>
+
+ <nag from="Nicola Ken Barozzi <[EMAIL PROTECTED]>"
+ to="[EMAIL PROTECTED]"/>
+
+ </project>
+
<!--
********************************************
******** COCOON SUPPLIED PROJECTS ********
1.14 +2 -1 xml-cocoon2/properties.xml
Index: properties.xml
===================================================================
RCS file: /home/cvs/xml-cocoon2/properties.xml,v
retrieving revision 1.13
retrieving revision 1.14
diff -u -r1.13 -r1.14
--- properties.xml 25 Nov 2002 15:18:30 -0000 1.13
+++ properties.xml 28 Nov 2002 15:12:33 -0000 1.14
@@ -119,7 +119,8 @@
<databases include="true"/>
<hsqldb include="true"/>
<precept/>
- <poi include="true"/>
+ <poi include="true"/>
+ <naming include="true"/>
</blocks>
<!-- Specify what should be included in the web application (war) file -->
1.1
xml-cocoon2/src/blocks/naming/java/org/apache/cocoon/transformation/LDAPTransformer.java
Index: LDAPTransformer.java
===================================================================
/*
============================================================================
The Apache Software License, Version 1.1
============================================================================
Copyright (C) 1999-2002 The Apache Software Foundation. All rights reserved.
Redistribution and use in source and binary forms, with or without modifica-
tion, 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.
3. The end-user documentation included with the redistribution, if any, must
include the following acknowledgment: "This product includes software
developed by the Apache Software Foundation (http://www.apache.org/)."
Alternately, this acknowledgment may appear in the software itself, if
and wherever such third-party acknowledgments normally appear.
4. The names "Apache Cocoon" and "Apache Software Foundation" must not be
used to endorse or promote products derived from this software without
prior written permission. For written permission, please contact
[EMAIL PROTECTED]
5. Products derived from this software may not be called "Apache", nor may
"Apache" appear in their name, without prior written permission of the
Apache Software Foundation.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 THE
APACHE SOFTWARE FOUNDATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLU-
DING, 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.
This software consists of voluntary contributions made by many individuals
on behalf of the Apache Software Foundation and was originally created by
Stefano Mazzocchi <[EMAIL PROTECTED]>. For more information on the Apache
Software Foundation, please see <http://www.apache.org/>.
*/
package org.apache.cocoon.transformation;
import org.apache.avalon.framework.parameters.Parameters;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.environment.SourceResolver;
import org.apache.cocoon.xml.XMLConsumer;
import org.apache.avalon.framework.logger.Logger;
import org.xml.sax.Attributes;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.ext.LexicalHandler;
import org.xml.sax.helpers.AttributesImpl;
import javax.naming.Context;
import javax.naming.NamingEnumeration;
import javax.naming.NamingException;
import javax.naming.directory.*;
import java.io.IOException;
import java.util.*;
/*****************************************************************************
* The <code>LDAPTransformer</code> is a class that can be plugged into a pipeline
* to transform the SAX events which passes thru this transformer into queries
* an responses to/from a ldap interface.
* <br>
* The file will be specified in a parameter tag in the sitemap pipeline to the
* transformer as follows:
* <p>
* <code>
* <map:transform type="ldap"/><br>
* </code>
* </p>
* <br>
*
* The following DTD is valid:<br>
* <!ELEMENT execute-query (attribute+ | show-attribute? | scope? | initializer?
| authentication? | error-element? | sax-error? doc-element? | row-element? |
version? | serverurl? | rootdn? | password? | deref-link? | count-limit? | searchbase,
filter)><br>
* <!ELEMENT execute-increment (attribute | show-attribute? | scope? |
initializer? | authentication? | error-element? | sax-error? | doc-element? |
row-element? | version? | serverurl? | rootdn? | password? | deref-link? |
count-limit? | searchbase, filter)><br>
* increments (+1) an integer attribute on a directory-server (ldap)<br>
* <br>
* <!ELEMENT initializer (#PCDATA)>+ (default:
"com.sun.jndi.ldap.LdapCtxFactory")<br>
* <!ELEMENT authentication (#PCDATA)>+ (default: "simple")<br>
* <!ELEMENT version (#PCDATA)>+ (default: "2")<br>
* <!ELEMENT serverurl (#PCDATA)>+<br>
* <!ELEMENT port (#PCDATA)>+ (default: 389)<br>
* <!ELEMENT rootdn (#PCDATA)>+<br>
* <!ELEMENT password (#PCDATA)>+<br>
* <!ELEMENT scope (ONELEVEL_SCOPE | SUBTREE_SCOPE | OBJECT_SCOPE)>+ (default:
ONELEVEL_SCOPE)<br>
* <!ELEMENT searchbase (#PCDATA)>+<br>
* <!ELEMENT doc-element (#PCDATA)>+ (default: "doc-element")<br>
* <!ELEMENT row-element (#PCDATA)>+ (default: "row-element")<br>
* <!ELEMENT error-element (#PCDATA)>+ (default: "ldap-error") (in case of
error returned error tag)<br>
* <!ELEMENT sax_error (TRUE | FALSE)>+; (default: FALSE) (throws
SAX-Exception instead of error tag)<br>
* <!ELEMENT attribute (#PCDATA)><br>
* <!ELEMENT show-attribute (TRUE | FALSE)> (default: TRUE)<br>
* <!ELEMENT filter (#PCDATA | execute-query)><br>
* <!ELEMENT deref-link (TRUE | FALSE)> (default: FALSE)<br>
* <!ELEMENT count-limit (#PCDATA)> (integer default: 0 -> no limit)<br>
* <!ELEMENT time-limit (#PCDATA)> (integer default: 0 -> infinite)<br>
* <!ELEMENT debug (TRUE | FALSE)>+; (default: FALSE)<br>
* <br>
* + can also be defined as parameter in the sitemap.
* <br>
* <br>
*
* @author Felix Knecht
* @version CVS $Id: LDAPTransformer.java,v 1.1 2002/11/28 15:12:33 nicolaken Exp $
*/
public class LDAPTransformer extends AbstractTransformer {
/** The LDAP namespace ("http://apache.org/cocoon/LDAP/1.0";)**/
public static final String my_uri = "http://apache.org/cocoon/LDAP/1.0";;
public static final String my_name = "LDAPTransformer";
/** The LDAP namespace element names **/
public static final String MAGIC_EXECUTE_QUERY = "execute-query";
public static final String MAGIC_EXECUTE_INCREMENT = "execute-increment";
public static final String MAGIC_INITIALIZER_ELEMENT = "initializer";
public static final String MAGIC_DOC_ELEMENT = "doc-element";
public static final String MAGIC_ROW_ELEMENT = "row-element";
public static final String MAGIC_ERROR_ELEMENT = "error-element";
public static final String MAGIC_SAX_ERROR = "sax-error";
public static final String MAGIC_ATTRIBUTE_ELEMENT = "attribute";
public static final String MAGIC_SERVERURL_ELEMENT = "serverurl";
public static final String MAGIC_PORT_ELEMENT = "port";
public static final String MAGIC_SEARCHBASE_ELEMENT = "searchbase";
public static final String MAGIC_FILTER_ELEMENT = "filter";
public static final String MAGIC_ROOT_DN_ELEMENT = "rootdn";
public static final String MAGIC_PASSWORD_ELEMENT = "password";
public static final String MAGIC_SHOW_ATTRIBUTE_ELEMENT = "show-attribute";
public static final String MAGIC_SCOPE_ELEMENT = "scope";
public static final String MAGIC_VERSION_ELEMENT = "version";
public static final String MAGIC_AUTHENTICATION_ELEMENT = "authentication";
public static final String MAGIC_DEREF_LINK_ELEMENT = "deref-link";
public static final String MAGIC_COUNT_LIMIT_ELEMENT = "count-limit";
public static final String MAGIC_TIME_LIMIT_ELEMENT = "time-limit";
public static final String MAGIC_DEBUG_ELEMENT = "debug";
/** The states we are allowed to be in **/
public static final int STATE_OUTSIDE = 0;
public static final int STATE_INSIDE_EXECUTE_QUERY = 1;
public static final int STATE_INSIDE_EXECUTE_INCREMENT = 2;
public static final int STATE_INSIDE_EXECUTE_ELEMENT = 3;
public static final int STATE_INSIDE_INITIALIZER_ELEMENT = 4;
public static final int STATE_INSIDE_SERVERURL_ELEMENT = 5;
public static final int STATE_INSIDE_PORT_ELEMENT = 6;
public static final int STATE_INSIDE_SCOPE_ELEMENT = 7;
public static final int STATE_INSIDE_VERSION_ELEMENT = 8;
public static final int STATE_INSIDE_AUTHENTICATION_ELEMENT = 9;
public static final int STATE_INSIDE_ROOT_DN_ELEMENT = 10;
public static final int STATE_INSIDE_PASSWORD_ELEMENT = 11;
public static final int STATE_INSIDE_SEARCHBASE_ELEMENT = 12;
public static final int STATE_INSIDE_DOC_ELEMENT = 13;
public static final int STATE_INSIDE_ROW_ELEMENT = 14;
public static final int STATE_INSIDE_ATTRIBUTE_ELEMENT = 15;
public static final int STATE_INSIDE_SHOW_ATTRIBUTE_ELEMENT = 16;
public static final int STATE_INSIDE_ERROR_ELEMENT = 17;
public static final int STATE_INSIDE_FILTER_ELEMENT = 18;
public static final int STATE_INSIDE_DEREF_LINK_ELEMENT = 19;
public static final int STATE_INSIDE_COUNT_LIMIT_ELEMENT = 20;
public static final int STATE_INSIDE_TIME_LIMIT_ELEMENT = 21;
public static final int STATE_INSIDE_DEBUG_ELEMENT = 22;
public static final int STATE_INSIDE_SAX_ERROR_ELEMENT = 23;
/** Default parameters that might apply to all queries **/
protected Properties default_properties = new Properties();
/** The name of the value element we're currently receiving **/
protected String current_name;
/** The current state of the event receiving FSM **/
protected int current_state = STATE_OUTSIDE;
/** The value of the value element we're currently receiving **/
protected StringBuffer current_value = new StringBuffer();
/** The list of queries that we're currently working on **/
protected Vector queries = new Vector();
/** The offset of the current query in the queries list **/
protected int current_query_index = -1;
/** SAX producing state information */
protected XMLConsumer xml_consumer;
protected LexicalHandler lexical_handler;
/** BEGIN SitemapComponent methods **/
public void setup(SourceResolver resolver, Map objectModel,
String source, Parameters parameters)
throws ProcessingException, SAXException, IOException {
current_state = STATE_OUTSIDE;
// Check the initializer
String parameter = parameters.getParameter(MAGIC_INITIALIZER_ELEMENT, null);
if (parameter != null) {
default_properties.setProperty(MAGIC_INITIALIZER_ELEMENT, parameter);
}
// Check the version
parameter = parameters.getParameter(MAGIC_VERSION_ELEMENT, null);
if (parameter != null) {
default_properties.setProperty(MAGIC_VERSION_ELEMENT, parameter);
}
// Check the authentication
parameter = parameters.getParameter(MAGIC_AUTHENTICATION_ELEMENT, null);
if (parameter != null) {
default_properties.setProperty(MAGIC_AUTHENTICATION_ELEMENT, parameter);
}
// Check the scope
parameter = parameters.getParameter(MAGIC_SCOPE_ELEMENT, null);
if (parameter != null) {
default_properties.setProperty(MAGIC_SCOPE_ELEMENT, parameter);
}
// Check the serverurl
parameter = parameters.getParameter(MAGIC_SERVERURL_ELEMENT, null);
if (parameter != null) {
default_properties.setProperty(MAGIC_SERVERURL_ELEMENT, parameter);
}
// Check the ldap-root_dn
parameter = parameters.getParameter(MAGIC_ROOT_DN_ELEMENT, null);
if (parameter != null) {
default_properties.setProperty(MAGIC_ROOT_DN_ELEMENT, parameter);
}
// Check the ldap-pwd
parameter = parameters.getParameter(MAGIC_PASSWORD_ELEMENT,null);
if (parameter != null) {
default_properties.setProperty(MAGIC_PASSWORD_ELEMENT, parameter);
}
// Check the port
parameter = parameters.getParameter(MAGIC_PORT_ELEMENT, null);
if (parameter != null) {
default_properties.setProperty(MAGIC_PORT_ELEMENT, parameter);
}
// Check the searchbase
parameter = parameters.getParameter(MAGIC_SEARCHBASE_ELEMENT, null);
if (parameter != null) {
default_properties.setProperty(MAGIC_SEARCHBASE_ELEMENT, parameter);
}
// Check the doc-element
parameter = parameters.getParameter(MAGIC_DOC_ELEMENT, null);
if (parameter != null) {
default_properties.setProperty(MAGIC_DOC_ELEMENT, parameter);
}
// Check the row-element
parameter = parameters.getParameter(MAGIC_ROW_ELEMENT,null);
if (parameter != null) {
default_properties.setProperty(MAGIC_ROW_ELEMENT, parameter);
}
// Check the error-element
parameter = parameters.getParameter(MAGIC_ERROR_ELEMENT, null);
if (parameter != null) {
default_properties.setProperty(MAGIC_ERROR_ELEMENT, parameter);
}
// Check the sax-error
parameter = parameters.getParameter(MAGIC_SAX_ERROR, null);
if (parameter != null) {
default_properties.setProperty(MAGIC_SAX_ERROR, parameter);
}
// Check the deref-link-element
parameter = parameters.getParameter(MAGIC_DEREF_LINK_ELEMENT, null);
if (parameter != null) {
default_properties.setProperty(MAGIC_DEREF_LINK_ELEMENT,
parameter.toUpperCase());
}
// Check the count-limit-element
parameter = parameters.getParameter(MAGIC_COUNT_LIMIT_ELEMENT, null);
if (parameter != null) {
default_properties.setProperty(MAGIC_COUNT_LIMIT_ELEMENT, parameter);
}
// Check the time-limit-element
parameter = parameters.getParameter(MAGIC_TIME_LIMIT_ELEMENT, null);
if (parameter != null) {
default_properties.setProperty(MAGIC_TIME_LIMIT_ELEMENT, parameter);
}
// Check the debug-element
parameter = parameters.getParameter(MAGIC_DEBUG_ELEMENT, null);
if (parameter != null) {
default_properties.setProperty(MAGIC_DEBUG_ELEMENT, parameter);
}
}
/** END SitemapComponent methods **/
/** BEGIN my very own methods **/
/**
* This will be the meat of LDAPTransformer, where the query is run.
*/
protected void executeQuery(int index) throws SAXException {
this.contentHandler.startPrefixMapping("", LDAPTransformer.my_uri);
LDAPQuery query = (LDAPQuery) queries.elementAt(index);
try {
query.execute();
} catch (NamingException e) {
throw new SAXException (e);
} catch (Exception e) {
throw new SAXException (e);
}
this.contentHandler.endPrefixMapping("");
}
protected static void throwIllegalStateException(String message) {
throw new IllegalStateException(my_name + ": " + message);
}
protected void startExecuteQuery(Attributes attributes) {
LDAPQuery query;
switch (current_state) {
case LDAPTransformer.STATE_OUTSIDE:
current_state = LDAPTransformer.STATE_INSIDE_EXECUTE_QUERY;
current_query_index = queries.size();
query = new LDAPQuery(this);
queries.addElement(query);
getCurrentQuery().toDo = LDAPTransformer.STATE_INSIDE_EXECUTE_QUERY;
getCurrentQuery().query_index = current_query_index;
break;
case LDAPTransformer.STATE_INSIDE_FILTER_ELEMENT:
current_state = LDAPTransformer.STATE_INSIDE_EXECUTE_QUERY;
current_query_index = queries.size();
query = new LDAPQuery(this);
queries.addElement(query);
getCurrentQuery().toDo = LDAPTransformer.STATE_INSIDE_EXECUTE_QUERY;
getCurrentQuery().query_index = current_query_index;
break;
default:
throwIllegalStateException("Not expecting a start execute-query
element");
}
}
protected void endExecuteQuery() throws SAXException {
switch (current_state) {
case STATE_INSIDE_EXECUTE_QUERY:
executeQuery(current_query_index);
queries.remove(current_query_index);
--current_query_index;
if (current_query_index > -1) {
current_state = getCurrentQuery().toDo;
} else {
queries.removeAllElements();
current_state = LDAPTransformer.STATE_OUTSIDE;
}
break;
default:
throwIllegalStateException("Not expecting a end execute-query
element");
}
}
protected void startExecuteIncrement(Attributes attributes) {
LDAPQuery query;
switch (current_state) {
case LDAPTransformer.STATE_OUTSIDE:
current_state = LDAPTransformer.STATE_INSIDE_EXECUTE_INCREMENT;
current_query_index = queries.size();
query = new LDAPQuery(this);
queries.addElement(query);
getCurrentQuery().toDo =
LDAPTransformer.STATE_INSIDE_EXECUTE_INCREMENT;
getCurrentQuery().query_index = current_query_index;
break;
case LDAPTransformer.STATE_INSIDE_EXECUTE_QUERY:
current_state = LDAPTransformer.STATE_INSIDE_EXECUTE_INCREMENT;
current_query_index = queries.size();
query = new LDAPQuery(this);
queries.addElement(query);
getCurrentQuery().toDo =
LDAPTransformer.STATE_INSIDE_EXECUTE_INCREMENT;
getCurrentQuery().query_index = current_query_index;
break;
default:
throwIllegalStateException("Not expecting a start execute-increment
element");
}
}
protected void endExecuteIncrement() throws SAXException {
switch (current_state) {
case LDAPTransformer.STATE_INSIDE_EXECUTE_INCREMENT:
executeQuery(current_query_index);
queries.remove(current_query_index);
--current_query_index;
if (current_query_index > 1) {
current_state = getCurrentQuery().toDo;
} else {
queries.removeAllElements();
current_state = LDAPTransformer.STATE_OUTSIDE;
}
break;
default:
throwIllegalStateException("Not expecting a end execute-increment
element");
}
}
protected void startInitializerElement(Attributes attributes) {
switch (current_state) {
case STATE_INSIDE_EXECUTE_QUERY:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_INITIALIZER_ELEMENT;
getCurrentQuery().current_state =
LDAPTransformer.STATE_INSIDE_INITIALIZER_ELEMENT;
break;
case STATE_INSIDE_EXECUTE_INCREMENT:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_INITIALIZER_ELEMENT;
getCurrentQuery().current_state =
LDAPTransformer.STATE_INSIDE_INITIALIZER_ELEMENT;
break;
default:
throwIllegalStateException("Not expecting a start initializer
element");
}
}
protected void endInitializerElement() {
switch (current_state) {
case LDAPTransformer.STATE_INSIDE_INITIALIZER_ELEMENT:
getCurrentQuery().initializer = current_value.toString();
current_state = getCurrentQuery().toDo;
break;
default:
throwIllegalStateException("Not expecting a end initializer
element");
}
}
protected void startScopeElement(Attributes attributes) {
switch (current_state) {
case STATE_INSIDE_EXECUTE_QUERY:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_SCOPE_ELEMENT;
getCurrentQuery().current_state =
LDAPTransformer.STATE_INSIDE_SCOPE_ELEMENT;
break;
case STATE_INSIDE_EXECUTE_INCREMENT:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_SCOPE_ELEMENT;
getCurrentQuery().current_state =
LDAPTransformer.STATE_INSIDE_SCOPE_ELEMENT;
break;
default:
throwIllegalStateException("Not expecting a start scope element");
}
}
protected void endScopeElement() {
switch (current_state) {
case LDAPTransformer.STATE_INSIDE_SCOPE_ELEMENT:
getCurrentQuery().scope = current_value.toString();
current_state = getCurrentQuery().toDo;
break;
default:
throwIllegalStateException("Not expecting a end scope element");
}
}
protected void startAuthenticationElement(Attributes attributes) {
switch (current_state) {
case STATE_INSIDE_EXECUTE_QUERY:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_AUTHENTICATION_ELEMENT;
getCurrentQuery().current_state =
LDAPTransformer.STATE_INSIDE_AUTHENTICATION_ELEMENT;
break;
case STATE_INSIDE_EXECUTE_INCREMENT:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_AUTHENTICATION_ELEMENT;
getCurrentQuery().current_state =
LDAPTransformer.STATE_INSIDE_AUTHENTICATION_ELEMENT;
break;
default:
throwIllegalStateException("Not expecting a start authentication
element");
}
}
protected void endAuthenticationElement() {
switch (current_state) {
case LDAPTransformer.STATE_INSIDE_AUTHENTICATION_ELEMENT:
getCurrentQuery().authentication = current_value.toString();
current_state = getCurrentQuery().toDo;
break;
default:
throwIllegalStateException("Not expecting a end authentication
element");
}
}
protected void startServerurlElement(Attributes attributes) {
switch (current_state) {
case STATE_INSIDE_EXECUTE_QUERY:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_SERVERURL_ELEMENT;
break;
case STATE_INSIDE_EXECUTE_INCREMENT:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_SERVERURL_ELEMENT;
break;
default:
throwIllegalStateException("Not expecting a start serverurl
element");
}
}
protected void endServerurlElement() {
switch (current_state) {
case LDAPTransformer.STATE_INSIDE_SERVERURL_ELEMENT:
getCurrentQuery().serverurl = current_value.toString();
current_state = getCurrentQuery().toDo;
break;
default:
throwIllegalStateException("Not expecting a end serverurl element");
}
}
protected void startPortElement(Attributes attributes) {
switch (current_state) {
case STATE_INSIDE_EXECUTE_QUERY:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_PORT_ELEMENT;
break;
case STATE_INSIDE_EXECUTE_INCREMENT:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_PORT_ELEMENT;
break;
default:
throwIllegalStateException("Not expecting a start port element");
}
}
protected void endPortElement() {
switch (current_state) {
case LDAPTransformer.STATE_INSIDE_PORT_ELEMENT:
getCurrentQuery().port = Integer.parseInt(current_value.toString());
current_state = getCurrentQuery().toDo;
break;
default:
throwIllegalStateException("Not expecting a end server element");
}
}
protected void startShowAttributeElement(Attributes attributes) {
switch (current_state) {
case STATE_INSIDE_EXECUTE_QUERY:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_SHOW_ATTRIBUTE_ELEMENT;
break;
case STATE_INSIDE_EXECUTE_INCREMENT:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_SHOW_ATTRIBUTE_ELEMENT;
break;
default:
throwIllegalStateException("Not expecting a start show-attribute
element");
}
}
protected void endShowAttributeElement() {
switch (current_state) {
case LDAPTransformer.STATE_INSIDE_SHOW_ATTRIBUTE_ELEMENT:
if (current_value.toString().toUpperCase().equals("FALSE")) {
getCurrentQuery().showAttribute = false;
}
current_state = getCurrentQuery().toDo;
break;
default:
throwIllegalStateException("Not expecting a end show-attribute
element");
}
}
protected void startSearchbaseElement(Attributes attributes) {
switch (current_state) {
case STATE_INSIDE_EXECUTE_QUERY:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_SEARCHBASE_ELEMENT;
break;
case STATE_INSIDE_EXECUTE_INCREMENT:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_SEARCHBASE_ELEMENT;
break;
default:
throwIllegalStateException("Not expecting a start searchbase
element");
}
}
protected void endSearchbaseElement() {
switch (current_state) {
case LDAPTransformer.STATE_INSIDE_SEARCHBASE_ELEMENT:
getCurrentQuery().searchbase = current_value.toString();
current_state = getCurrentQuery().toDo;
break;
default:
throwIllegalStateException("Not expecting a end searchbase element");
}
}
protected void startDocElement(Attributes attributes) {
switch (current_state) {
case STATE_INSIDE_EXECUTE_QUERY:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_DOC_ELEMENT;
break;
case STATE_INSIDE_EXECUTE_INCREMENT:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_DOC_ELEMENT;
break;
default:
throwIllegalStateException("Not expecting a start doc-element
element");
}
}
protected void endDocElement() {
switch (current_state) {
case LDAPTransformer.STATE_INSIDE_DOC_ELEMENT:
getCurrentQuery().doc_element = current_value.toString();
current_state = getCurrentQuery().toDo;
break;
default:
throwIllegalStateException("Not expecting a end doc-element
element");
}
}
protected void startRowElement(Attributes attributes) {
switch (current_state) {
case STATE_INSIDE_EXECUTE_QUERY:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_ROW_ELEMENT;
break;
case STATE_INSIDE_EXECUTE_INCREMENT:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_ROW_ELEMENT;
break;
default:
throwIllegalStateException("Not expecting a start row-element
element");
}
}
protected void endRowElement() {
switch (current_state) {
case LDAPTransformer.STATE_INSIDE_ROW_ELEMENT:
getCurrentQuery().row_element = current_value.toString();
current_state = getCurrentQuery().toDo;
break;
default:
throwIllegalStateException("Not expecting a end row-element
element");
}
}
protected void startErrorElement(Attributes attributes) {
switch (current_state) {
case STATE_INSIDE_EXECUTE_QUERY:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_ERROR_ELEMENT;
break;
case STATE_INSIDE_EXECUTE_INCREMENT:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_ERROR_ELEMENT;
break;
default:
throwIllegalStateException("Not expecting a start error-element
element");
}
}
protected void endErrorElement() {
switch (current_state) {
case LDAPTransformer.STATE_INSIDE_ERROR_ELEMENT:
getCurrentQuery().error_element = current_value.toString();
current_state = getCurrentQuery().toDo;
break;
default:
throwIllegalStateException("Not expecting a end error-element
element");
}
}
protected void startSaxError(Attributes attributes) {
switch (current_state) {
case STATE_INSIDE_EXECUTE_QUERY:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_SAX_ERROR_ELEMENT;
break;
case STATE_INSIDE_EXECUTE_INCREMENT:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_SAX_ERROR_ELEMENT;
break;
default:
throwIllegalStateException("Not expecting a start sax-error
element");
}
}
protected void endSaxError() {
switch (current_state) {
case LDAPTransformer.STATE_INSIDE_SAX_ERROR_ELEMENT:
if (current_value.toString().toUpperCase().equals("TRUE")) {
getCurrentQuery().sax_error = true;
}
current_state = getCurrentQuery().toDo;
break;
default:
throwIllegalStateException("Not expecting a end sax-error element");
}
}
protected void startRootDnElement(Attributes attributes) {
switch (current_state) {
case STATE_INSIDE_EXECUTE_QUERY:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_ROOT_DN_ELEMENT;
break;
case STATE_INSIDE_EXECUTE_INCREMENT:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_ROOT_DN_ELEMENT;
break;
default:
throwIllegalStateException("Not expecting a start root-dn element");
}
}
protected void endRootDnElement() {
switch (current_state) {
case LDAPTransformer.STATE_INSIDE_ROOT_DN_ELEMENT:
getCurrentQuery().root_dn = current_value.toString( );
current_state = getCurrentQuery().toDo;
break;
default:
throwIllegalStateException("Not expecting a end root-dn element");
}
}
protected void startPasswordElement(Attributes attributes) {
switch (current_state) {
case STATE_INSIDE_EXECUTE_QUERY:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_PASSWORD_ELEMENT;
break;
case STATE_INSIDE_EXECUTE_INCREMENT:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_PASSWORD_ELEMENT;
break;
default:
throwIllegalStateException("Not expecting a start password element");
}
}
protected void endPasswordElement() {
switch (current_state) {
case LDAPTransformer.STATE_INSIDE_PASSWORD_ELEMENT:
getCurrentQuery().password = current_value.toString();
current_state = getCurrentQuery().toDo;
break;
default:
throwIllegalStateException("Not expecting a end password element");
}
}
protected void startAttributeElement(Attributes attributes) {
switch (current_state) {
case STATE_INSIDE_EXECUTE_QUERY:
current_state = LDAPTransformer.STATE_INSIDE_ATTRIBUTE_ELEMENT;
current_value.setLength(0);
break;
case STATE_INSIDE_EXECUTE_INCREMENT:
current_state = LDAPTransformer.STATE_INSIDE_ATTRIBUTE_ELEMENT;
current_value.setLength(0);
break;
default:
throwIllegalStateException("Not expecting a start attribute
element");
}
}
protected void endAttributeElement() {
switch (current_state) {
case LDAPTransformer.STATE_INSIDE_ATTRIBUTE_ELEMENT:
getCurrentQuery().addAttrList(current_value.toString());
current_state = getCurrentQuery().toDo;
break;
default:
throwIllegalStateException("Not expecting a end attribute element");
}
}
protected void startVersionElement(Attributes attributes) {
switch (current_state) {
case STATE_INSIDE_EXECUTE_QUERY:
current_state = LDAPTransformer.STATE_INSIDE_VERSION_ELEMENT;
current_value.setLength(0);
break;
case STATE_INSIDE_EXECUTE_INCREMENT:
current_state = LDAPTransformer.STATE_INSIDE_VERSION_ELEMENT;
current_value.setLength(0);
break;
default:
throwIllegalStateException("Not expecting a start version element");
}
}
protected void endVersionElement() {
switch (current_state) {
case LDAPTransformer.STATE_INSIDE_VERSION_ELEMENT:
getCurrentQuery().version = current_value.toString();
current_state = getCurrentQuery().toDo;
break;
default:
throwIllegalStateException("Not expecting a end version element");
}
}
protected void startFilterElement(Attributes attributes) {
switch (current_state) {
case STATE_INSIDE_EXECUTE_QUERY:
current_state = LDAPTransformer.STATE_INSIDE_FILTER_ELEMENT;
getCurrentQuery().current_state =
LDAPTransformer.STATE_INSIDE_FILTER_ELEMENT;
current_value.setLength(0);
break;
case STATE_INSIDE_EXECUTE_INCREMENT:
current_state = LDAPTransformer.STATE_INSIDE_FILTER_ELEMENT;
getCurrentQuery().current_state =
LDAPTransformer.STATE_INSIDE_FILTER_ELEMENT;
current_value.setLength(0);
break;
default:
throwIllegalStateException("Not expecting a start filter element");
}
}
protected void endFilterElement() {
switch (current_state) {
case LDAPTransformer.STATE_INSIDE_FILTER_ELEMENT:
getCurrentQuery().filter = current_value.toString();
current_state = getCurrentQuery().toDo;
break;
default:
throwIllegalStateException("Not expecting a end filter element");
}
}
protected void startDerefLinkElement(Attributes attributes) {
switch (current_state) {
case STATE_INSIDE_EXECUTE_QUERY:
current_state = LDAPTransformer.STATE_INSIDE_DEREF_LINK_ELEMENT;
current_value.setLength(0);
break;
case STATE_INSIDE_EXECUTE_INCREMENT:
current_state = LDAPTransformer.STATE_INSIDE_DEREF_LINK_ELEMENT;
current_value.setLength(0);
break;
default:
throwIllegalStateException("Not expecting a start deref-link
element");
}
}
protected void endDerefLinkElement() {
switch (current_state) {
case LDAPTransformer.STATE_INSIDE_DEREF_LINK_ELEMENT:
if (current_value.toString().toUpperCase().equals("TRUE")) {
getCurrentQuery().deref_link = true;
}
current_state = getCurrentQuery().toDo;
break;
default:
throwIllegalStateException("Not expecting a end deref-link element");
}
}
protected void startCountLimitElement(Attributes attributes) {
switch (current_state) {
case STATE_INSIDE_EXECUTE_QUERY:
current_state = LDAPTransformer.STATE_INSIDE_COUNT_LIMIT_ELEMENT;
current_value.setLength(0);
break;
case STATE_INSIDE_EXECUTE_INCREMENT:
current_state = LDAPTransformer.STATE_INSIDE_COUNT_LIMIT_ELEMENT;
current_value.setLength(0);
break;
default:
throwIllegalStateException("Not expecting a start count-limit
element");
}
}
protected void endCountLimitElement() {
switch (current_state) {
case LDAPTransformer.STATE_INSIDE_COUNT_LIMIT_ELEMENT:
getCurrentQuery().count_limit =
Integer.parseInt(current_value.toString());
current_state = getCurrentQuery().toDo;
break;
default:
throwIllegalStateException("Not expecting a end count-limit
element");
}
}
protected void startTimeLimitElement(Attributes attributes) {
switch (current_state) {
case STATE_INSIDE_EXECUTE_QUERY:
current_state = LDAPTransformer.STATE_INSIDE_TIME_LIMIT_ELEMENT;
current_value.setLength(0);
break;
case STATE_INSIDE_EXECUTE_INCREMENT:
current_state = LDAPTransformer.STATE_INSIDE_TIME_LIMIT_ELEMENT;
current_value.setLength(0);
break;
default:
throwIllegalStateException("Not expecting a start time-limit
element");
}
}
protected void endTimeLimitElement() {
switch (current_state) {
case LDAPTransformer.STATE_INSIDE_TIME_LIMIT_ELEMENT:
getCurrentQuery().time_limit =
Integer.parseInt(current_value.toString());
current_state = getCurrentQuery().toDo;
break;
default:
throwIllegalStateException("Not expecting a end time-limit element");
}
}
protected void startDebugElement(Attributes attributes) {
switch (current_state) {
case STATE_INSIDE_EXECUTE_QUERY:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_DEBUG_ELEMENT;
break;
case STATE_INSIDE_EXECUTE_INCREMENT:
current_value.setLength(0);
current_state = LDAPTransformer.STATE_INSIDE_DEBUG_ELEMENT;
break;
default:
throwIllegalStateException("Not expecting a start debug element");
}
}
protected void endDebugElement() {
switch (current_state) {
case LDAPTransformer.STATE_INSIDE_DEBUG_ELEMENT:
if (current_value.toString().toUpperCase().equals("TRUE")) {
getCurrentQuery().debug = true;
}
current_state = getCurrentQuery().toDo;
break;
default:
throwIllegalStateException("Not expecting a end debug element");
}
}
protected LDAPQuery getCurrentQuery() {
return (LDAPQuery) queries.elementAt(current_query_index);
}
protected LDAPQuery getQuery(int i) {
return (LDAPQuery) queries.elementAt(i);
}
/** END my very own methods **/
/** BEGIN SAX ContentHandler handlers **/
public void setDocumentLocator(Locator locator) {
if (getLogger().isDebugEnabled()) {
getLogger().debug( "PUBLIC ID: " + locator.getPublicId() );
getLogger().debug( "SYSTEM ID: " + locator.getSystemId() );
}
if (super.contentHandler != null)
super.contentHandler.setDocumentLocator(locator);
}
public void startElement(String uri, String name, String raw,
Attributes attributes) throws SAXException {
if (!uri.equals(my_uri)) {
super.startElement(uri, name, raw, attributes);
return;
}
if (this.getLogger().isDebugEnabled()) {
getLogger().debug("RECEIVED START ELEMENT " + name + "(" + uri + ")");
}
if (name.equals(LDAPTransformer.MAGIC_EXECUTE_QUERY)) {
startExecuteQuery(attributes);
} else if (name.equals(LDAPTransformer.MAGIC_EXECUTE_INCREMENT)) {
startExecuteIncrement(attributes);
} else if (name.equals(LDAPTransformer.MAGIC_INITIALIZER_ELEMENT)) {
startInitializerElement(attributes);
} else if (name.equals(LDAPTransformer.MAGIC_AUTHENTICATION_ELEMENT)) {
startAuthenticationElement(attributes);
} else if (name.equals(LDAPTransformer.MAGIC_SCOPE_ELEMENT)) {
startScopeElement(attributes);
} else if (name.equals(LDAPTransformer.MAGIC_VERSION_ELEMENT)) {
startVersionElement(attributes);
} else if (name.equals(LDAPTransformer.MAGIC_SERVERURL_ELEMENT)) {
startServerurlElement(attributes);
} else if (name.equals(LDAPTransformer.MAGIC_PORT_ELEMENT)) {
startPortElement(attributes);
} else if (name.equals(LDAPTransformer.MAGIC_DOC_ELEMENT)) {
startDocElement(attributes);
} else if (name.equals(LDAPTransformer.MAGIC_ROW_ELEMENT)) {
startRowElement(attributes);
} else if (name.equals(LDAPTransformer.MAGIC_ERROR_ELEMENT)) {
startErrorElement(attributes);
} else if (name.equals(LDAPTransformer.MAGIC_SAX_ERROR)) {
startSaxError(attributes);
} else if (name.equals(LDAPTransformer.MAGIC_ROOT_DN_ELEMENT)) {
startRootDnElement(attributes);
} else if (name.equals(LDAPTransformer.MAGIC_PASSWORD_ELEMENT)) {
startPasswordElement(attributes);
} else if (name.equals(LDAPTransformer.MAGIC_ATTRIBUTE_ELEMENT)) {
startAttributeElement(attributes);
} else if (name.equals(LDAPTransformer.MAGIC_SHOW_ATTRIBUTE_ELEMENT)) {
startShowAttributeElement(attributes);
} else if (name.equals(LDAPTransformer.MAGIC_SEARCHBASE_ELEMENT)) {
startSearchbaseElement(attributes);
} else if (name.equals(LDAPTransformer.MAGIC_FILTER_ELEMENT)) {
startFilterElement(attributes);
} else if (name.equals(LDAPTransformer.MAGIC_DEREF_LINK_ELEMENT)) {
startDerefLinkElement(attributes);
} else if (name.equals(LDAPTransformer.MAGIC_COUNT_LIMIT_ELEMENT)) {
startCountLimitElement(attributes);
} else if (name.equals(LDAPTransformer.MAGIC_TIME_LIMIT_ELEMENT)) {
startTimeLimitElement(attributes);
} else if (name.equals(LDAPTransformer.MAGIC_DEBUG_ELEMENT)) {
startDebugElement(attributes);
}
}
public void endElement(String uri, String name,
String raw) throws SAXException {
if (!uri.equals(my_uri)) {
super.endElement(uri, name, raw);
return;
}
if (this.getLogger().isDebugEnabled()) {
getLogger().debug("RECEIVED END ELEMENT "+ name + "(" + uri + ")");
}
if (name.equals(LDAPTransformer.MAGIC_EXECUTE_QUERY)) {
endExecuteQuery();
} else if (name.equals(LDAPTransformer.MAGIC_EXECUTE_INCREMENT)) {
endExecuteIncrement();
} else if (name.equals(LDAPTransformer.MAGIC_INITIALIZER_ELEMENT)) {
endInitializerElement();
} else if (name.equals(LDAPTransformer.MAGIC_AUTHENTICATION_ELEMENT)) {
endAuthenticationElement();
} else if (name.equals(LDAPTransformer.MAGIC_SCOPE_ELEMENT)) {
endScopeElement();
} else if (name.equals(LDAPTransformer.MAGIC_VERSION_ELEMENT)) {
endVersionElement();
} else if (name.equals(LDAPTransformer.MAGIC_SERVERURL_ELEMENT)) {
endServerurlElement();
} else if (name.equals(LDAPTransformer.MAGIC_PORT_ELEMENT)) {
endPortElement();
} else if (name.equals(LDAPTransformer.MAGIC_DOC_ELEMENT)) {
endDocElement();
} else if (name.equals(LDAPTransformer.MAGIC_ROW_ELEMENT)) {
endRowElement();
} else if (name.equals(LDAPTransformer.MAGIC_ERROR_ELEMENT)) {
endErrorElement();
} else if (name.equals(LDAPTransformer.MAGIC_SAX_ERROR)) {
endSaxError();
} else if (name.equals(LDAPTransformer.MAGIC_ROOT_DN_ELEMENT)) {
endRootDnElement();
} else if (name.equals(LDAPTransformer.MAGIC_PASSWORD_ELEMENT)) {
endPasswordElement();
} else if (name.equals(LDAPTransformer.MAGIC_ATTRIBUTE_ELEMENT)) {
endAttributeElement();
} else if (name.equals(LDAPTransformer.MAGIC_SHOW_ATTRIBUTE_ELEMENT)) {
endShowAttributeElement();
} else if (name.equals(LDAPTransformer.MAGIC_SEARCHBASE_ELEMENT)) {
endSearchbaseElement();
} else if (name.equals(LDAPTransformer.MAGIC_FILTER_ELEMENT)) {
endFilterElement();
} else if (name.equals(LDAPTransformer.MAGIC_DEREF_LINK_ELEMENT)) {
endDerefLinkElement();
} else if (name.equals(LDAPTransformer.MAGIC_COUNT_LIMIT_ELEMENT)) {
endCountLimitElement();
} else if (name.equals(LDAPTransformer.MAGIC_TIME_LIMIT_ELEMENT)) {
endTimeLimitElement();
} else if (name.equals(LDAPTransformer.MAGIC_DEBUG_ELEMENT)) {
endDebugElement();
}
}
public void characters(char ary[], int start, int length) throws SAXException {
if (current_state != LDAPTransformer.STATE_INSIDE_INITIALIZER_ELEMENT &&
current_state != LDAPTransformer.STATE_INSIDE_AUTHENTICATION_ELEMENT
&&
current_state != LDAPTransformer.STATE_INSIDE_SCOPE_ELEMENT &&
current_state != LDAPTransformer.STATE_INSIDE_VERSION_ELEMENT &&
current_state != LDAPTransformer.STATE_INSIDE_SERVERURL_ELEMENT &&
current_state != LDAPTransformer.STATE_INSIDE_PORT_ELEMENT &&
current_state != LDAPTransformer.STATE_INSIDE_DOC_ELEMENT &&
current_state != LDAPTransformer.STATE_INSIDE_ROW_ELEMENT &&
current_state != LDAPTransformer.STATE_INSIDE_ERROR_ELEMENT &&
current_state != LDAPTransformer.STATE_INSIDE_SAX_ERROR_ELEMENT &&
current_state != LDAPTransformer.STATE_INSIDE_ROOT_DN_ELEMENT &&
current_state != LDAPTransformer.STATE_INSIDE_PASSWORD_ELEMENT &&
current_state != LDAPTransformer.STATE_INSIDE_ATTRIBUTE_ELEMENT &&
current_state != LDAPTransformer.STATE_INSIDE_SHOW_ATTRIBUTE_ELEMENT
&&
current_state != LDAPTransformer.STATE_INSIDE_FILTER_ELEMENT &&
current_state != LDAPTransformer.STATE_INSIDE_DEREF_LINK_ELEMENT &&
current_state != LDAPTransformer.STATE_INSIDE_COUNT_LIMIT_ELEMENT &&
current_state != LDAPTransformer.STATE_INSIDE_TIME_LIMIT_ELEMENT &&
current_state != LDAPTransformer.STATE_INSIDE_DEBUG_ELEMENT &&
current_state != LDAPTransformer.STATE_INSIDE_SEARCHBASE_ELEMENT) {
super.characters(ary, start, length);
}
if (this.getLogger().isDebugEnabled()) {
getLogger().debug("RECEIVED CHARACTERS: " + new String(ary, start,
length));
}
current_value.append(ary, start, length);
}
private void attribute(AttributesImpl attr, String name, String value) {
attr.addAttribute("", name, name, "CDATA", value);
}
private void start(String name, AttributesImpl attr) throws SAXException {
super.contentHandler.startElement("", name, name, attr);
attr.clear();
}
private void end(String name) throws SAXException {
super.contentHandler.endElement("", name, name);
}
private void data(String data) throws SAXException {
if (data != null)
super.contentHandler.characters(data.toCharArray(), 0, data.length());
}
protected static String getStringValue(Object object) {
if (object instanceof byte[]) {
return new String((byte[]) object);
} else if (object instanceof char[]) {
return new String((char[]) object);
} else if (object != null) {
return object.toString();
} else {
return "";
}
}
public final Logger getTheLogger()
{
return getLogger();
}
class LDAPQuery {
/** What index are you in daddy's queries list **/
protected int query_index;
/** The current state of the event receiving FSM **/
protected int current_state;
/** Who's your daddy? **/
protected LDAPTransformer transformer;
/** LDAP configuration information **/
protected String initializer = "com.sun.jndi.ldap.LdapCtxFactory";
protected String serverurl = "localhost";
protected int port = 389;
protected String root_dn = "";
protected String password = "";
protected String version = "2";
protected String scope = "ONELEVEL_SCOPE";
protected String authentication = "simple";
/** LDAP environment information **/
protected Properties env = new Properties();
protected DirContext ctx;
/** LDAP Query **/
protected int toDo;
protected String searchbase = "";
protected List attrListe = new LinkedList();
protected boolean showAttribute = true;
protected String filter = "";
protected String doc_element = "doc-element";
protected String row_element = "row-element";
protected String error_element = "ldap-error";
protected boolean sax_error = false;
protected boolean deref_link = false; // Dereference: true -> dereference
the link during search
protected long count_limit = 0; // Maximum number of entries
to return: 0 -> no limit
protected int time_limit = 0; // Number of milliseconds to wait
before return: 0 -> infinite
protected boolean debug = false;
protected LDAPQuery (LDAPTransformer transformer) {
this.transformer = transformer;
if (null !=
transformer.default_properties.getProperty(transformer.MAGIC_INITIALIZER_ELEMENT)) {
initializer =
transformer.default_properties.getProperty(transformer.MAGIC_INITIALIZER_ELEMENT);
}
if (null !=
transformer.default_properties.getProperty(transformer.MAGIC_SERVERURL_ELEMENT)) {
serverurl =
transformer.default_properties.getProperty(transformer.MAGIC_SERVERURL_ELEMENT);
}
if (null !=
transformer.default_properties.getProperty(transformer.MAGIC_PORT_ELEMENT)) {
port =
Integer.parseInt(transformer.default_properties.getProperty(transformer.MAGIC_PORT_ELEMENT));
}
if (null !=
transformer.default_properties.getProperty(transformer.MAGIC_ROOT_DN_ELEMENT)) {
root_dn =
transformer.default_properties.getProperty(transformer.MAGIC_ROOT_DN_ELEMENT);
}
if (null !=
transformer.default_properties.getProperty(transformer.MAGIC_PASSWORD_ELEMENT)) {
password =
transformer.default_properties.getProperty(transformer.MAGIC_PASSWORD_ELEMENT);
}
if (null !=
transformer.default_properties.getProperty(transformer.MAGIC_VERSION_ELEMENT)) {
version =
transformer.default_properties.getProperty(transformer.MAGIC_VERSION_ELEMENT);
}
if (null !=
transformer.default_properties.getProperty(transformer.MAGIC_SCOPE_ELEMENT)) {
scope =
transformer.default_properties.getProperty(transformer.MAGIC_SCOPE_ELEMENT);
}
if (null !=
transformer.default_properties.getProperty(transformer.MAGIC_AUTHENTICATION_ELEMENT)) {
authentication =
transformer.default_properties.getProperty(transformer.MAGIC_AUTHENTICATION_ELEMENT);
}
if (null !=
transformer.default_properties.getProperty(transformer.MAGIC_SEARCHBASE_ELEMENT)) {
searchbase =
transformer.default_properties.getProperty(transformer.MAGIC_SEARCHBASE_ELEMENT);
}
if (null !=
transformer.default_properties.getProperty(transformer.MAGIC_SHOW_ATTRIBUTE_ELEMENT)) {
showAttribute =
transformer.default_properties.getProperty(transformer.MAGIC_SHOW_ATTRIBUTE_ELEMENT).equals("FALSE")
? false : true;
}
if (null !=
transformer.default_properties.getProperty(transformer.MAGIC_DOC_ELEMENT)) {
doc_element =
transformer.default_properties.getProperty(transformer.MAGIC_DOC_ELEMENT);
}
if (null !=
transformer.default_properties.getProperty(transformer.MAGIC_ROW_ELEMENT)) {
row_element =
transformer.default_properties.getProperty(transformer.MAGIC_ROW_ELEMENT);
}
if (null !=
transformer.default_properties.getProperty(transformer.MAGIC_ERROR_ELEMENT)) {
error_element =
transformer.default_properties.getProperty(transformer.MAGIC_ERROR_ELEMENT);
}
if (null !=
transformer.default_properties.getProperty(transformer.MAGIC_SAX_ERROR)) {
sax_error =
transformer.default_properties.getProperty(transformer.MAGIC_SAX_ERROR).equals("TRUE")
? true : false;
}
if (null !=
transformer.default_properties.getProperty(transformer.MAGIC_DEREF_LINK_ELEMENT)) {
deref_link =
transformer.default_properties.getProperty(transformer.MAGIC_DEREF_LINK_ELEMENT).equals("TRUE")
? true : false;
}
if (null !=
transformer.default_properties.getProperty(transformer.MAGIC_COUNT_LIMIT_ELEMENT)) {
count_limit =
Long.parseLong(transformer.default_properties.getProperty(transformer.MAGIC_COUNT_LIMIT_ELEMENT));
}
if (null !=
transformer.default_properties.getProperty(transformer.MAGIC_TIME_LIMIT_ELEMENT)) {
time_limit =
Integer.parseInt(transformer.default_properties.getProperty(transformer.MAGIC_TIME_LIMIT_ELEMENT));
}
if (null !=
transformer.default_properties.getProperty(transformer.MAGIC_DEBUG_ELEMENT)) {
debug =
transformer.default_properties.getProperty(transformer.MAGIC_DEBUG_ELEMENT).equals("TRUE")
? true : false;
}
}
protected void execute() throws Exception, NamingException {
String[] attrList = new String[attrListe.size()];
AttributesImpl attr = new AttributesImpl();
if (debug) {
debugPrint();
}
SearchControls constraints = new SearchControls();
attrListe.toArray(attrList);
attrListe.clear();
try {
connect();
switch (toDo) {
case LDAPTransformer.STATE_INSIDE_EXECUTE_QUERY:
try {
if (scope.equals("OBJECT_SCOPE")) {
constraints.setSearchScope(SearchControls.OBJECT_SCOPE);
} else if (scope.equals("SUBTREE_SCOPE")) {
constraints.setSearchScope(SearchControls.SUBTREE_SCOPE);
} else {
constraints.setSearchScope(SearchControls.ONELEVEL_SCOPE);
}
constraints.setTimeLimit(time_limit);
constraints.setDerefLinkFlag(deref_link);
constraints.setCountLimit(count_limit);
if (attrList.length > 0) {
constraints.setReturningAttributes(attrList);
}
NamingEnumeration ldapresults = ctx.search(searchbase,
filter, constraints);
if (!doc_element.equals("")) {
transformer.start(doc_element, attr);
}
while (ldapresults != null && ldapresults.hasMore()) {
if (!row_element.equals("")) {
transformer.start(row_element, attr);
}
SearchResult si = (SearchResult)ldapresults.next();
javax.naming.directory.Attributes attrs =
si.getAttributes();
if (attrs != null) {
NamingEnumeration ae = attrs.getAll();
while (ae.hasMoreElements()) {
Attribute at = (Attribute)ae.next();
Enumeration vals = at.getAll();
String attrID = at.getID();
if (showAttribute) {
transformer.start(attrID, attr);
}
String attrVal = (String)vals.nextElement();
if (query_index > 0) {
switch
(transformer.getQuery(query_index-1).current_state) {
case
LDAPTransformer.STATE_INSIDE_FILTER_ELEMENT:
if
(!transformer.getQuery(query_index-1).filter.equals("")) {
transformer.getQuery(query_index-1).filter.concat(", ");
}
transformer.getQuery(query_index-1).filter.concat(attrID).concat("=").concat(attrVal);
break;
default:
transformer.start(attrID, attr);
}
} else {
transformer.data(String.valueOf(attrVal));
}
if (showAttribute) {
transformer.end(attrID);
}
}
}
if (!row_element.equals("")) {
transformer.end(row_element);
}
}
if (!doc_element.equals("")) {
transformer.end(doc_element);
}
} catch(Exception e) {
if (sax_error) {
throw new Exception ("[LDAPTransformer] Error in
LDAP-Query: " + e.toString());
} else {
transformer.start(error_element, attr);
transformer.data("[LDAPTransformer] Error in
LDAP-Query: " + e);
transformer.end(error_element);
transformer.getTheLogger().error("[LDAPTransformer]
Exception: " + e.toString());
}
}
break;
case LDAPTransformer.STATE_INSIDE_EXECUTE_INCREMENT:
try {
if (scope.equals("OBJECT_SCOPE")) {
constraints.setSearchScope(SearchControls.OBJECT_SCOPE);
} else if (scope.equals("SUBTREE_SCOPE")) {
constraints.setSearchScope(SearchControls.SUBTREE_SCOPE);
} else {
constraints.setSearchScope(SearchControls.ONELEVEL_SCOPE);
}
constraints.setTimeLimit(time_limit);
constraints.setDerefLinkFlag(deref_link);
constraints.setCountLimit(count_limit);
if (attrList.length != 1) {
transformer.start(error_element, attr);
transformer.data("Increment must reference exactly 1
attribute.");
transformer.end(error_element);
} else {
constraints.setReturningAttributes(attrList);
NamingEnumeration ldapresults =
ctx.search(searchbase, filter, constraints);
int attrVal = 0;
String attrID = "";
SearchResult si = null;
while (ldapresults != null && ldapresults.hasMore())
{
si = (SearchResult)ldapresults.next();
javax.naming.directory.Attributes attrs =
si.getAttributes();
if (attrs != null) {
NamingEnumeration ae = attrs.getAll();
while (ae.hasMoreElements()) {
Attribute at = (Attribute)ae.next();
Enumeration vals = at.getAll();
attrID = at.getID();
attrVal =
Integer.parseInt((String)vals.nextElement());
}
}
}
++attrVal;
// Specify the changes to make
ModificationItem[] mods = new ModificationItem[1];
// Replace the "mail" attribute with a new value
mods[0] = new
ModificationItem(DirContext.REPLACE_ATTRIBUTE,
new BasicAttribute(attrID,
Integer.toString(attrVal)));
// Perform the requested modifications on the named
object
ctx.modifyAttributes(new
StringBuffer(si.toString().substring(0,si.toString().indexOf(":")))
.append(",").append(searchbase).toString(),
mods);
}
} catch(Exception e) {
if (sax_error) {
throw new Exception ("[LDAPTransformer] Error
incrementing an attribute: " + e.toString());
} else {
transformer.start(error_element, attr);
transformer.data("[LDAPTransformer] Error
incrementing an attribute: " + e.toString());
transformer.end(error_element);
transformer.getTheLogger().error("[LDAPTransformer]
Error incrementing an attribute: " + e.toString());
}
}
break;
default:
} //end switch
} catch (NamingException e) {
if (sax_error) {
throw new NamingException ("[LDAPTransformer] Failed
ldap-connection to directory service: " + e.toString());
} else {
transformer.start(error_element, attr);
transformer.data("[LDAPTransformer] Failed ldap-connection to
directory service.");
transformer.end(error_element);
transformer.getTheLogger().error("[LDAPTransformer] Failed to
connect to " + serverurl + e.toString());
}
}
try {
disconnect();
} catch (NamingException e) {
if (sax_error) {
throw new NamingException ("[LDAPTransformer] Failed
ldap-disconnection from directory service: " + e.toString());
} else {
transformer.start(error_element, attr);
transformer.data("[LDAPTransformer] Failed ldap-disconnection to
directory service.");
transformer.end(error_element);
transformer.getTheLogger().error("[LDAPTransformer] Failed to
disconnect from " + serverurl + e.toString());
}
}
}
protected void addAttrList(String attr) {
attrListe.add(attr);
}
protected void connect() throws NamingException {
if (root_dn != null && password != null) {
env.put(Context.SECURITY_AUTHENTICATION, authentication);
env.put(Context.SECURITY_PRINCIPAL, root_dn);
env.put(Context.SECURITY_CREDENTIALS, password);
}
env.put("java.naming.ldap.version", version );
env.put(Context.INITIAL_CONTEXT_FACTORY, initializer);
env.put(Context.PROVIDER_URL, serverurl + ":" + port);
try {
ctx = new InitialDirContext(env);
} catch (NamingException e) {
env.clear();
throw new NamingException (e.toString());
}
}
protected void disconnect() throws NamingException {
try {
if (ctx != null) ctx.close();
} catch (NamingException e) {
ctx = null;
env.clear();
throw new NamingException (e.toString());
}
ctx = null;
env.clear();
}
protected void debugPrint() {
transformer.getTheLogger().debug("[LDAPTransformer] query_index: " +
query_index);
transformer.getTheLogger().debug("[LDAPTransformer] current_state: " +
current_state);
transformer.getTheLogger().debug("[LDAPTransformer] serverurl: " +
serverurl);
transformer.getTheLogger().debug("[LDAPTransformer] port: " + port);
transformer.getTheLogger().debug("[LDAPTransformer] root_dn: " +
root_dn);
transformer.getTheLogger().debug("[LDAPTransformer] password: " +
password);
transformer.getTheLogger().debug("[LDAPTransformer] version: " +
version);
transformer.getTheLogger().debug("[LDAPTransformer] scope: " + scope);
transformer.getTheLogger().debug("[LDAPTransformer] authentication: " +
authentication);
transformer.getTheLogger().debug("[LDAPTransformer] toDo: " + toDo);
transformer.getTheLogger().debug("[LDAPTransformer] searchbase: " +
searchbase);
transformer.getTheLogger().debug("[LDAPTransformer] showAttribute: " +
showAttribute);
transformer.getTheLogger().debug("[LDAPTransformer] attribute: " +
attrListe.toString());
transformer.getTheLogger().debug("[LDAPTransformer] filter: " + filter);
transformer.getTheLogger().debug("[LDAPTransformer] doc_element: " +
doc_element);
transformer.getTheLogger().debug("[LDAPTransformer] row_element: " +
row_element);
transformer.getTheLogger().debug("[LDAPTransformer] error_element: " +
error_element);
transformer.getTheLogger().debug("[LDAPTransformer] sax-error: " +
sax_error);
transformer.getTheLogger().debug("[LDAPTransformer] deref_link: " +
deref_link);
transformer.getTheLogger().debug("[LDAPTransformer] count_limit: " +
count_limit);
transformer.getTheLogger().debug("[LDAPTransformer] time_limit: " +
time_limit);
}
}
}
1.1 xml-cocoon2/src/blocks/naming/conf/naming.xmap
Index: naming.xmap
===================================================================
<?xml version="1.0"?>
<xmap xpath="/sitemap/components/transformers"
unless="transformer[@name='ldap']">
<map:transformer name="ldap"
src="org.apache.cocoon.transformation.LDAPTransformer"/>
</xmap>
1.1 xml-cocoon2/src/blocks/naming/samples/notyet.txt
<<Binary file>>
----------------------------------------------------------------------
In case of troubles, e-mail: [EMAIL PROTECTED]
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
