move Pair class

gradle.properties

@@ -1,21 +1,26 @@
 group = org.xbib
 name = netty-http
-version = 4.1.36.5
+version = 4.1.36.6
 
 # main packages
 netty.version = 4.1.36.Final
 tcnative.version = 2.0.25.Final
 
 # common
-xbib-net-url.version = 1.3.2
+xbib-net-url.version = 1.3.3
 
 # server
 bouncycastle.version = 1.61
+
+# reactive
 reactivestreams.version = 1.0.2
 
-# server-rest
+# rest
 xbib-guice.version = 4.0.4
 
+# xmlrpc-client
+commons-httpclient.version = 3.1
+
 # test packages
 junit.version = 5.4.2
 conscrypt.version = 2.0.0

netty-http-common/build.gradle

@@ -1,5 +1,4 @@
-
 dependencies {
-    implementation "org.xbib:net-url:${project.property('xbib-net-url.version')}"
+    compile "org.xbib:net-url:${project.property('xbib-net-url.version')}"
-    implementation "io.netty:netty-codec-http2:${project.property('netty.version')}"
+    compile "io.netty:netty-codec-http2:${project.property('netty.version')}"
 }

netty-http-common/src/main/java/org/xbib/netty/http/common/HttpParameters.java

@@ -4,7 +4,7 @@ import org.xbib.net.PercentDecoder;
 import org.xbib.net.PercentEncoder;
 import org.xbib.net.PercentEncoders;
 import org.xbib.netty.http.common.util.LimitedSet;
-import org.xbib.netty.http.common.util.LimitedMap;
+import org.xbib.netty.http.common.util.LimitedTreeMap;
 
 import java.nio.charset.MalformedInputException;
 import java.nio.charset.StandardCharsets;
@@ -42,7 +42,7 @@ public class HttpParameters implements Map<String, SortedSet<String>> {
 
     private final int elementSizeLimit;
 
-    private final LimitedMap<String, String> map;
+    private final LimitedTreeMap<String, String> map;
 
     private final PercentEncoder percentEncoder;
 
@@ -62,7 +62,7 @@ public class HttpParameters implements Map<String, SortedSet<String>> {
         this.maxParam = maxParam;
         this.sizeLimit = sizeLimit;
         this.elementSizeLimit = elementSizeLimit;
-        this.map = new LimitedMap<>(maxParam);
+        this.map = new LimitedTreeMap<>(maxParam);
         this.percentEncoder = PercentEncoders.getQueryEncoder(StandardCharsets.UTF_8);
         this.percentDecoder = new PercentDecoder();
         this.contentType = contentType;

netty-http-common/src/main/java/org/xbib/netty/http/common/util/LRUCache.java

@@ -13,6 +13,7 @@ public class LRUCache<K, V> extends LinkedHashMap<K, V> {
         this.cacheSize = cacheSize;
     }
 
+    @Override
     protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
         return size() >= cacheSize;
     }

netty-http-common/src/main/java/org/xbib/netty/http/common/util/LimitedMap.java

@@ -1,22 +1,22 @@
 package org.xbib.netty.http.common.util;
 
-import java.util.SortedSet;
+import java.util.LinkedHashMap;
-import java.util.TreeMap;
 
 @SuppressWarnings("serial")
-public class LimitedMap<K, V> extends TreeMap<K, SortedSet<V>> {
+public class LimitedMap<K, V> extends LinkedHashMap<K, V> {
 
     private final int limit;
 
     public LimitedMap(int limit) {
+        super(16, 0.75f, true);
         this.limit = limit;
     }
 
     @Override
-    public SortedSet<V> put(K key, SortedSet<V> value) {
+    public V put(K key, V value) {
         if (size() < limit) {
             return super.put(key, value);
         }
-        return null;
+        throw new IllegalArgumentException("size limit exceeded: " + limit);
     }
 }

netty-http-common/src/main/java/org/xbib/netty/http/common/util/LimitedSet.java

@@ -21,6 +21,7 @@ public class LimitedSet<T extends CharSequence> extends TreeSet<T> {
         if (size() < sizeLimit && t.length() <= elementMaximumLength) {
             return super.add(t);
         }
-        return false;
+        throw new IllegalArgumentException("limit exceeded");
+
     }
 }

netty-http-common/src/main/java/org/xbib/netty/http/common/util/LimitedTreeMap.java

@@ -0,0 +1,22 @@
+package org.xbib.netty.http.common.util;
+
+import java.util.SortedSet;
+import java.util.TreeMap;
+
+@SuppressWarnings("serial")
+public class LimitedTreeMap<K, V> extends TreeMap<K, SortedSet<V>> {
+
+    private final int limit;
+
+    public LimitedTreeMap(int limit) {
+        this.limit = limit;
+    }
+
+    @Override
+    public SortedSet<V> put(K key, SortedSet<V> value) {
+        if (size() < limit) {
+            return super.put(key, value);
+        }
+        return null;
+    }
+}

netty-http-server-reactive/build.gradle

@@ -0,0 +1,7 @@
+dependencies {
+    compile project(':netty-http-server')
+    implementation "org.reactivestreams:reactive-streams:${project.property('reactivestreams.version')}"
+    testImplementation("org.reactivestreams:reactive-streams-tck:${project.property('reactivestreams.version')}") {
+        exclude module: 'testng'
+    }
+}

netty-http-server-reactive/src/main/java/org/xbib/netty/http/server/reactive/HandlerPublisher.java

@@ -154,8 +154,11 @@ public class HandlerPublisher<T> extends ChannelDuplexHandler implements Publish
     private State state = NO_SUBSCRIBER_OR_CONTEXT;
 
     private volatile Subscriber<? super T> subscriber;
+
     private ChannelHandlerContext ctx;
+
     private long outstandingDemand = 0;
+
     private Throwable noSubscriberError;
 
     @Override

netty-http-server-reactive/src/test/java/org/xbib/netty/http/server/reactive/test/BatchedProducer.java

@@ -1,4 +1,4 @@
-package org.xbib.netty.http.server.test.reactive;
+package org.xbib.netty.http.server.reactive.test;
 
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelOutboundHandlerAdapter;

netty-http-server-reactive/src/test/java/org/xbib/netty/http/server/reactive/test/ChannelPublisherTest.java

@@ -1,4 +1,4 @@
-package org.xbib.netty.http.server.test.reactive;
+package org.xbib.netty.http.server.reactive.test;
 
 import io.netty.bootstrap.Bootstrap;
 import io.netty.channel.Channel;
@@ -44,8 +44,7 @@ class ChannelPublisherTest {
         EventLoop eventLoop = group.next();
         HandlerPublisher<Channel> handlerPublisher = new HandlerPublisher<>(eventLoop, Channel.class);
         Bootstrap bootstrap = new Bootstrap();
-        bootstrap
+        bootstrap.channel(NioServerSocketChannel.class)
-                .channel(NioServerSocketChannel.class)
                 .group(eventLoop)
                 .option(ChannelOption.AUTO_READ, false)
                 .handler(handlerPublisher)

netty-http-server-reactive/src/test/java/org/xbib/netty/http/server/reactive/test/ClosedLoopChannel.java

@@ -1,4 +1,4 @@
-package org.xbib.netty.http.server.test.reactive;
+package org.xbib.netty.http.server.reactive.test;
 
 import io.netty.channel.AbstractChannel;
 import io.netty.channel.ChannelConfig;

netty-http-server/build.gradle

@@ -1,14 +1,9 @@
 dependencies {
-    implementation project(":netty-http-common")
+    compile project(":netty-http-common")
-    implementation "io.netty:netty-handler:${project.property('netty.version')}"
+    compile "io.netty:netty-handler:${project.property('netty.version')}"
-    implementation "io.netty:netty-transport-native-epoll:${project.property('netty.version')}"
+    compile "io.netty:netty-transport-native-epoll:${project.property('netty.version')}"
-    implementation "io.netty:netty-tcnative-boringssl-static:${project.property('tcnative.version')}"
+    compile "io.netty:netty-tcnative-boringssl-static:${project.property('tcnative.version')}"
-    implementation "io.netty:netty-codec-http2:${project.property('netty.version')}"
+    compile "io.netty:netty-codec-http2:${project.property('netty.version')}"
-    implementation "org.xbib:net-url:${project.property('xbib-net-url.version')}"
+    compile "org.bouncycastle:bcpkix-jdk15on:${project.property('bouncycastle.version')}"
-    implementation "org.bouncycastle:bcpkix-jdk15on:${project.property('bouncycastle.version')}"
-    implementation "org.reactivestreams:reactive-streams:${project.property('reactivestreams.version')}"
     testImplementation project(":netty-http-client")
-    testImplementation("org.reactivestreams:reactive-streams-tck:${project.property('reactivestreams.version')}") {
-        exclude module: 'testng'
-    }
 }

netty-http-server/src/main/java/org/xbib/netty/http/server/Domain.java

@@ -10,7 +10,7 @@ import io.netty.handler.ssl.SslProvider;
 import org.xbib.netty.http.common.HttpAddress;
 import org.xbib.netty.http.common.SecurityUtil;
 import org.xbib.netty.http.server.endpoint.HttpEndpoint;
-import org.xbib.netty.http.server.endpoint.EndpointResolver;
+import org.xbib.netty.http.server.endpoint.HttpEndpointResolver;
 import org.xbib.netty.http.server.endpoint.service.Service;
 import org.xbib.netty.http.server.security.tls.SelfSignedCertificate;
 
@@ -39,7 +39,7 @@ public class Domain {
 
     private final SslContext sslContext;
 
-    private final List<EndpointResolver> endpointResolvers;
+    private final List<HttpEndpointResolver> httpEndpointResolvers;
 
     /**
      * Constructs a {@code NamedServer} with the given name.
@@ -47,18 +47,18 @@ public class Domain {
      * @param name the name, or null if it is the default server
      * @param aliases alias names for the named server
      * @param httpAddress HTTP address, used for determining if named server is secure or not
-     * @param endpointResolvers the endpoint resolvers
+     * @param httpEndpointResolvers the endpoint resolvers
      * @param sslContext SSL context or null
      */
     protected Domain(String name, Set<String> aliases,
                      HttpAddress httpAddress,
-                     List<EndpointResolver> endpointResolvers,
+                     List<HttpEndpointResolver> httpEndpointResolvers,
                      SslContext sslContext) {
         this.httpAddress = httpAddress;
         this.name = name;
         this.sslContext = sslContext;
         this.aliases = Collections.unmodifiableSet(aliases);
-        this.endpointResolvers = endpointResolvers;
+        this.httpEndpointResolvers = httpEndpointResolvers;
     }
 
     public static Builder builder() {
@@ -99,10 +99,10 @@ public class Domain {
         return aliases;
     }
 
-    public void execute(ServerRequest serverRequest, ServerResponse serverResponse) throws IOException {
+    public void handle(ServerRequest serverRequest, ServerResponse serverResponse) throws IOException {
-        if (endpointResolvers != null && !endpointResolvers.isEmpty()) {
+        if (httpEndpointResolvers != null && !httpEndpointResolvers.isEmpty()) {
-            for (EndpointResolver endpointResolver : endpointResolvers) {
+            for (HttpEndpointResolver httpEndpointResolver : httpEndpointResolvers) {
-                endpointResolver.resolve(serverRequest, serverResponse);
+                httpEndpointResolver.handle(serverRequest, serverResponse);
             }
         } else {
             ServerResponse.write(serverResponse, HttpResponseStatus.NOT_IMPLEMENTED);
@@ -122,7 +122,7 @@ public class Domain {
 
         private Set<String> aliases;
 
-        private List<EndpointResolver> endpointResolvers;
+        private List<HttpEndpointResolver> httpEndpointResolvers;
 
         private TrustManagerFactory trustManagerFactory;
 
@@ -146,7 +146,7 @@ public class Domain {
             this.httpAddress = httpAddress;
             this.serverName = serverName;
             this.aliases = new LinkedHashSet<>();
-            this.endpointResolvers = new ArrayList<>();
+            this.httpEndpointResolvers = new ArrayList<>();
             this.trustManagerFactory = SecurityUtil.Defaults.DEFAULT_TRUST_MANAGER_FACTORY; // InsecureTrustManagerFactory.INSTANCE;
             this.sslProvider = SecurityUtil.Defaults.DEFAULT_SSL_PROVIDER;
             this.ciphers = SecurityUtil.Defaults.DEFAULT_CIPHERS;
@@ -243,25 +243,25 @@ public class Domain {
             return this;
         }
 
-        public Builder addEndpointResolver(EndpointResolver endpointResolver) {
+        public Builder addEndpointResolver(HttpEndpointResolver httpEndpointResolver) {
-            this.endpointResolvers.add(endpointResolver);
+            this.httpEndpointResolvers.add(httpEndpointResolver);
             return this;
         }
 
         public Builder singleEndpoint(String path, Service service) {
-            addEndpointResolver(EndpointResolver.builder()
+            addEndpointResolver(HttpEndpointResolver.builder()
                     .addEndpoint(HttpEndpoint.builder().setPath(path).addFilter(service).build()).build());
             return this;
         }
 
         public Builder singleEndpoint(String prefix, String path, Service service) {
-            addEndpointResolver(EndpointResolver.builder()
+            addEndpointResolver(HttpEndpointResolver.builder()
                     .addEndpoint(HttpEndpoint.builder().setPrefix(prefix).setPath(path).addFilter(service).build()).build());
             return this;
         }
 
         public Builder singleEndpoint(String prefix, String path, Service service, String... methods) {
-            addEndpointResolver(EndpointResolver.builder()
+            addEndpointResolver(HttpEndpointResolver.builder()
                     .addEndpoint(HttpEndpoint.builder().setPrefix(prefix).setPath(path).addFilter(service)
                             .setMethods(Arrays.asList(methods)).build()).build());
             return this;
@@ -282,12 +282,12 @@ public class Domain {
                     if (httpAddress.getVersion().majorVersion() == 2) {
                         sslContextBuilder.applicationProtocolConfig(newApplicationProtocolConfig());
                     }
-                    return new Domain(serverName, aliases, httpAddress, endpointResolvers, sslContextBuilder.build());
+                    return new Domain(serverName, aliases, httpAddress, httpEndpointResolvers, sslContextBuilder.build());
                 } catch (Throwable t) {
                     throw new RuntimeException(t);
                 }
             } else {
-                return new Domain(serverName, aliases, httpAddress, endpointResolvers, null);
+                return new Domain(serverName, aliases, httpAddress, httpEndpointResolvers, null);
             }
         }
 

netty-http-server/src/main/java/org/xbib/netty/http/server/ServerRequest.java

@@ -1,11 +1,13 @@
 package org.xbib.netty.http.server;
 
 import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufInputStream;
+import io.netty.channel.Channel;
 import io.netty.handler.codec.http.HttpHeaders;
 import io.netty.handler.codec.http.HttpMethod;
 import org.xbib.net.URL;
 import org.xbib.netty.http.common.HttpParameters;
-import org.xbib.netty.http.server.endpoint.EndpointInfo;
+import org.xbib.netty.http.server.endpoint.HttpEndpointDescriptor;
 
 import javax.net.ssl.SSLSession;
 import java.io.IOException;
@@ -16,7 +18,9 @@ public interface ServerRequest {
 
     URL getURL();
 
-    EndpointInfo getEndpointInfo();
+    Channel getChannel();
+
+    HttpEndpointDescriptor getEndpointDescriptor();
 
     void setContext(List<String> context);
 
@@ -24,8 +28,6 @@ public interface ServerRequest {
 
     void addPathParameter(String key, String value) throws IOException;
 
-    void createParameters() throws IOException;
-
     Map<String, String> getPathParameters();
 
     HttpMethod getMethod();
@@ -40,12 +42,14 @@ public interface ServerRequest {
 
     Integer getSequenceId();
 
-    Integer streamId();
+    Integer getStreamId();
 
-    Integer requestId();
+    Integer getRequestId();
 
     SSLSession getSession();
 
     ByteBuf getContent();
 
+    ByteBufInputStream getInputStream();
+
 }

netty-http-server/src/main/java/org/xbib/netty/http/server/ServerResponse.java

@@ -1,6 +1,7 @@
 package org.xbib.netty.http.server;
 
 import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufOutputStream;
 import io.netty.buffer.ByteBufUtil;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.http.HttpResponseStatus;
@@ -30,10 +31,22 @@ public interface ServerResponse {
 
     ServerResponse withCookie(Cookie cookie);
 
+    ByteBufOutputStream getOutputStream();
+
+    void flush();
+
+    void write(byte[] bytes);
+
+    void write(ByteBufOutputStream byteBufOutputStream);
+
     void write(ByteBuf byteBuf);
 
     void write(ChunkedInput<ByteBuf> chunkedInput);
 
+    /**
+     * Convenience methods.
+     */
+
     static void write(ServerResponse serverResponse, int status) {
         write(serverResponse, HttpResponseStatus.valueOf(status));
     }

netty-http-server/src/main/java/org/xbib/netty/http/server/endpoint/Endpoint.java

@@ -1,16 +1,19 @@
 package org.xbib.netty.http.server.endpoint;
 
 import org.xbib.netty.http.server.ServerRequest;
+import org.xbib.netty.http.server.ServerResponse;
 
 import java.io.IOException;
 
-public interface Endpoint {
+public interface Endpoint<D extends EndpointDescriptor> {
 
     String getPrefix();
 
     String getPath();
 
-    boolean matches(EndpointInfo info);
+    boolean matches(D descriptor);
 
     void resolveUriTemplate(ServerRequest serverRequest) throws IOException;
+
+    void handle(ServerRequest serverRequest, ServerResponse serverResponse) throws IOException;
 }

netty-http-server/src/main/java/org/xbib/netty/http/server/endpoint/EndpointDescriptor.java

@@ -0,0 +1,4 @@
+package org.xbib.netty.http.server.endpoint;
+
+public interface EndpointDescriptor {
+}

netty-http-server/src/main/java/org/xbib/netty/http/server/endpoint/HttpEndpoint.java

@@ -1,5 +1,6 @@
 package org.xbib.netty.http.server.endpoint;
 
+import org.xbib.net.Pair;
 import org.xbib.net.QueryParameters;
 import org.xbib.net.path.PathMatcher;
 import org.xbib.net.path.PathNormalizer;
@@ -13,7 +14,7 @@ import java.util.Arrays;
 import java.util.Comparator;
 import java.util.List;
 
-public class HttpEndpoint {
+public class HttpEndpoint implements Endpoint<HttpEndpointDescriptor> {
 
     private static final PathMatcher pathMatcher = new PathMatcher();
 
@@ -50,32 +51,36 @@ public class HttpEndpoint {
                 .setFilters(endpoint.filters);
     }
 
+    @Override
     public String getPrefix() {
         return prefix;
     }
 
+    @Override
     public String getPath() {
         return path;
     }
 
-    public boolean matches(EndpointInfo info) {
+    @Override
+    public boolean matches(HttpEndpointDescriptor info) {
         return pathMatcher.match(prefix + path, info.getPath()) &&
                 (methods == null || methods.isEmpty() || (methods.contains(info.getMethod()))) &&
                 (contentTypes == null || contentTypes.isEmpty() || info.getContentType() == null ||
                 contentTypes.stream().anyMatch(info.getContentType()::startsWith));
     }
 
+    @Override
     public void resolveUriTemplate(ServerRequest serverRequest) throws IOException {
-        if (pathMatcher.match(prefix + path,  serverRequest.getEffectiveRequestPath() /*serverRequest.getRequest().uri()*/ )) {
+        if (pathMatcher.match(prefix + path,  serverRequest.getEffectiveRequestPath())) {
             QueryParameters queryParameters = pathMatcher.extractUriTemplateVariables(prefix + path,
-                    serverRequest.getEffectiveRequestPath() /*serverRequest.getRequest().uri()*/ );
+                    serverRequest.getEffectiveRequestPath());
-            for (QueryParameters.Pair<String, String> pair : queryParameters) {
+            for (Pair<String, String> pair : queryParameters) {
                 serverRequest.addPathParameter(pair.getFirst(), pair.getSecond());
             }
         }
     }
 
-    public void executeFilters(ServerRequest serverRequest, ServerResponse serverResponse) throws IOException {
+    public void handle(ServerRequest serverRequest, ServerResponse serverResponse) throws IOException {
         serverRequest.setContext(pathMatcher.tokenizePath(getPrefix()));
         for (Service service : filters) {
             service.handle(serverRequest, serverResponse);

netty-http-server/src/main/java/org/xbib/netty/http/server/endpoint/HttpEndpointDescriptor.java

@@ -4,7 +4,7 @@ import org.xbib.netty.http.server.transport.HttpServerRequest;
 
 import static io.netty.handler.codec.http.HttpHeaderNames.CONTENT_TYPE;
 
-public class EndpointInfo implements Comparable<EndpointInfo> {
+public class HttpEndpointDescriptor implements EndpointDescriptor, Comparable<HttpEndpointDescriptor> {
 
     private final String path;
 
@@ -12,7 +12,7 @@ public class EndpointInfo implements Comparable<EndpointInfo> {
 
     private final String contentType;
 
-    public EndpointInfo(HttpServerRequest serverRequest) {
+    public HttpEndpointDescriptor(HttpServerRequest serverRequest) {
         this.path = extractPath(serverRequest.getRequest().uri());
         this.method = serverRequest.getRequest().method().name();
         this.contentType = serverRequest.getRequest().headers().get(CONTENT_TYPE);
@@ -42,11 +42,11 @@ public class EndpointInfo implements Comparable<EndpointInfo> {
 
     @Override
     public boolean equals(Object o) {
-        return o instanceof EndpointInfo && toString().equals(o.toString());
+        return o instanceof HttpEndpointDescriptor && toString().equals(o.toString());
     }
 
     @Override
-    public int compareTo(EndpointInfo o) {
+    public int compareTo(HttpEndpointDescriptor o) {
         return toString().compareTo(o.toString());
     }
 

netty-http-server/src/main/java/org/xbib/netty/http/server/endpoint/HttpEndpointResolver.java

@@ -1,6 +1,7 @@
 package org.xbib.netty.http.server.endpoint;
 
 import io.netty.handler.codec.http.HttpResponseStatus;
+import org.xbib.netty.http.common.util.LimitedMap;
 import org.xbib.netty.http.server.ServerRequest;
 import org.xbib.netty.http.server.ServerResponse;
 import org.xbib.netty.http.server.annotation.Endpoint;
@@ -17,9 +18,9 @@ import java.util.logging.Level;
 import java.util.logging.Logger;
 import java.util.stream.Collectors;
 
-public class EndpointResolver {
+public class HttpEndpointResolver {
 
-    private static final Logger logger = Logger.getLogger(EndpointResolver.class.getName());
+    private static final Logger logger = Logger.getLogger(HttpEndpointResolver.class.getName());
 
     private final HttpEndpoint defaultEndpoint;
 
@@ -27,31 +28,32 @@ public class EndpointResolver {
 
     private final EndpointDispatcher endpointDispatcher;
 
-    private final LRUCache<EndpointInfo, List<HttpEndpoint>> endpointInfos;
+    private final LimitedMap<HttpEndpointDescriptor, List<HttpEndpoint>> endpointDescriptors;
 
-    private EndpointResolver(HttpEndpoint defaultEndpoint,
+    private HttpEndpointResolver(HttpEndpoint defaultEndpoint,
-                             List<HttpEndpoint> endpoints,
+                                 List<HttpEndpoint> endpoints,
-                             EndpointDispatcher endpointDispatcher,
+                                 EndpointDispatcher endpointDispatcher,
-                             int cacheSize) {
+                                 int limit) {
         this.defaultEndpoint = defaultEndpoint == null ? createDefaultEndpoint() : defaultEndpoint;
         this.endpoints = endpoints;
         this.endpointDispatcher = endpointDispatcher;
-        this.endpointInfos = new LRUCache<>(cacheSize);
+        this.endpointDescriptors = new LimitedMap<>(limit);
     }
 
-    public void resolve(ServerRequest serverRequest, ServerResponse serverResponse) throws IOException {
+    public void handle(ServerRequest serverRequest, ServerResponse serverResponse) throws IOException {
-        EndpointInfo endpointInfo = serverRequest.getEndpointInfo();
+        HttpEndpointDescriptor httpEndpointDescriptor = serverRequest.getEndpointDescriptor();
-        endpointInfos.putIfAbsent(endpointInfo, endpoints.stream()
+        endpointDescriptors.putIfAbsent(httpEndpointDescriptor, endpoints.stream()
-                .filter(endpoint -> endpoint.matches(endpointInfo))
+                .filter(endpoint -> endpoint.matches(httpEndpointDescriptor))
-                .sorted(new HttpEndpoint.EndpointPathComparator(endpointInfo.getPath())).collect(Collectors.toList()));
+                .sorted(new HttpEndpoint.EndpointPathComparator(httpEndpointDescriptor.getPath())).collect(Collectors.toList()));
-        List<HttpEndpoint> matchingEndpoints = endpointInfos.get(endpointInfo);
+        List<HttpEndpoint> matchingEndpoints = endpointDescriptors.get(httpEndpointDescriptor);
         if (logger.isLoggable(Level.FINE)) {
-            logger.log(Level.FINE, "endpoint info = " + endpointInfo + " matching endpoints = " + matchingEndpoints + " cache size=" + endpointInfos.size());
+            logger.log(Level.FINE, () -> "endpoint = " + httpEndpointDescriptor +
+                    " matching endpoints = " + matchingEndpoints);
         }
         if (matchingEndpoints.isEmpty()) {
             if (defaultEndpoint != null) {
                 defaultEndpoint.resolveUriTemplate(serverRequest);
-                defaultEndpoint.executeFilters(serverRequest, serverResponse);
+                defaultEndpoint.handle(serverRequest, serverResponse);
                 if (endpointDispatcher != null) {
                     endpointDispatcher.dispatch(defaultEndpoint, serverRequest, serverResponse);
                 }
@@ -61,7 +63,7 @@ public class EndpointResolver {
         } else {
             for (HttpEndpoint endpoint : matchingEndpoints) {
                 endpoint.resolveUriTemplate(serverRequest);
-                endpoint.executeFilters(serverRequest, serverResponse);
+                endpoint.handle(serverRequest, serverResponse);
                 if (serverResponse.getStatus() != null) {
                     break;
                 }
@@ -77,8 +79,8 @@ public class EndpointResolver {
         }
     }
 
-    public Map<EndpointInfo, List<HttpEndpoint>> getEndpointInfos() {
+    public Map<HttpEndpointDescriptor, List<HttpEndpoint>> getEndpointDescriptors() {
-        return endpointInfos;
+        return endpointDescriptors;
     }
 
     protected HttpEndpoint createDefaultEndpoint() {
@@ -119,7 +121,7 @@ public class EndpointResolver {
 
     public static class Builder {
 
-        private int cacheSize;
+        private int limit;
 
         private String prefix;
 
@@ -130,12 +132,12 @@ public class EndpointResolver {
         private EndpointDispatcher endpointDispatcher;
 
         Builder() {
-            this.cacheSize = 1024;
+            this.limit = 1024;
             this.endpoints = new ArrayList<>();
         }
 
-        public Builder setCacheSize(int cacheSize) {
+        public Builder setLimit(int limit) {
-            this.cacheSize = cacheSize;
+            this.limit = limit;
             return this;
         }
 
@@ -197,8 +199,8 @@ public class EndpointResolver {
             return this;
         }
 
-        public EndpointResolver build() {
+        public HttpEndpointResolver build() {
-            return new EndpointResolver(defaultEndpoint, endpoints, endpointDispatcher, cacheSize);
+            return new HttpEndpointResolver(defaultEndpoint, endpoints, endpointDispatcher, limit);
         }
     }
 }

netty-http-server/src/main/java/org/xbib/netty/http/server/transport/BaseTransport.java

@@ -81,7 +81,7 @@ abstract class BaseTransport implements Transport {
      */
     static void handle(Domain domain, HttpServerRequest serverRequest, ServerResponse serverResponse) throws IOException {
         // create server URL and parse parameters from query string, path, and parse body, if exists
-        serverRequest.createParameters();
+        serverRequest.handleParameters();
-        domain.execute(serverRequest, serverResponse);
+        domain.handle(serverRequest, serverResponse);
     }
 }

netty-http-server/src/main/java/org/xbib/netty/http/server/transport/Http2ServerResponse.java

@@ -1,6 +1,7 @@
 package org.xbib.netty.http.server.transport;
 
 import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufOutputStream;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelFutureListener;
 import io.netty.channel.ChannelHandlerContext;
@@ -42,6 +43,8 @@ public class Http2ServerResponse implements ServerResponse {
 
     private HttpResponseStatus httpResponseStatus;
 
+    private ByteBufOutputStream byteBufOutputStream;
+
     public Http2ServerResponse(HttpServerRequest serverRequest) {
         Objects.requireNonNull(serverRequest);
         Objects.requireNonNull(serverRequest.getChannelHandlerContext());
@@ -96,9 +99,31 @@ public class Http2ServerResponse implements ServerResponse {
         return this;
     }
 
+    @Override
+    public ByteBufOutputStream getOutputStream() {
+        this.byteBufOutputStream = new ByteBufOutputStream(ctx.alloc().buffer());
+        return byteBufOutputStream;
+    }
+
+    @Override
+    public void flush() {
+        write((ByteBuf) null);
+    }
+
+    @Override
+    public void write(byte[] bytes) {
+        ByteBuf byteBuf = ctx.alloc().buffer(bytes.length);
+        byteBuf.writeBytes(bytes);
+        write(byteBuf);
+    }
+
+    @Override
+    public void write(ByteBufOutputStream byteBufOutputStream) {
+        write(byteBufOutputStream.buffer());
+    }
+
     @Override
     public void write(ByteBuf byteBuf) {
-        Objects.requireNonNull(byteBuf);
         if (httpResponseStatus == null) {
             httpResponseStatus = HttpResponseStatus.OK;
         }
@@ -107,7 +132,9 @@ public class Http2ServerResponse implements ServerResponse {
             headers.add(HttpHeaderNames.CONTENT_TYPE, HttpHeaderValues.APPLICATION_OCTET_STREAM);
         }
         if (!headers.contains(HttpHeaderNames.CONTENT_LENGTH) && !headers.contains(HttpHeaderNames.TRANSFER_ENCODING)) {
-            headers.add(HttpHeaderNames.CONTENT_LENGTH, Long.toString(byteBuf.readableBytes()));
+            if (byteBuf != null) {
+                headers.add(HttpHeaderNames.CONTENT_LENGTH, Long.toString(byteBuf.readableBytes()));
+            }
         }
         if (serverRequest != null && "close".equalsIgnoreCase(serverRequest.getHeaders().get(HttpHeaderNames.CONNECTION)) &&
                 !headers.contains(HttpHeaderNames.CONNECTION)) {
@@ -117,21 +144,20 @@ public class Http2ServerResponse implements ServerResponse {
             headers.add(HttpHeaderNames.DATE, DateTimeFormatter.RFC_1123_DATE_TIME.format(ZonedDateTime.now(ZoneOffset.UTC)));
         }
         headers.add(HttpHeaderNames.SERVER, ServerName.getServerName());
-
         if (serverRequest != null) {
-            Integer streamId = serverRequest.streamId();
+            Integer streamId = serverRequest.getStreamId();
             if (streamId != null) {
                 headers.setInt(HttpConversionUtil.ExtensionHeaderNames.STREAM_ID.text(), streamId);
             }
         }
         if (ctx.channel().isWritable()) {
             Http2Headers http2Headers = new DefaultHttp2Headers().status(httpResponseStatus.codeAsText()).add(headers);
-            Http2HeadersFrame http2HeadersFrame = new DefaultHttp2HeadersFrame(http2Headers, false);
+            Http2HeadersFrame http2HeadersFrame = new DefaultHttp2HeadersFrame(http2Headers, byteBuf == null);
-            logger.log(Level.FINEST, http2HeadersFrame::toString);
             ctx.channel().write(http2HeadersFrame);
-            Http2DataFrame http2DataFrame = new DefaultHttp2DataFrame(byteBuf, true);
+            if (byteBuf != null) {
-            logger.log(Level.FINEST, http2DataFrame::toString);
+                Http2DataFrame http2DataFrame = new DefaultHttp2DataFrame(byteBuf, true);
-            ctx.channel().write(http2DataFrame);
+                ctx.channel().write(http2DataFrame);
+            }
             ctx.channel().flush();
         }
     }

netty-http-server/src/main/java/org/xbib/netty/http/server/transport/HttpServerRequest.java

@@ -1,19 +1,23 @@
 package org.xbib.netty.http.server.transport;
 
 import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufInputStream;
+import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.http.FullHttpRequest;
 import io.netty.handler.codec.http.HttpHeaders;
 import io.netty.handler.codec.http.HttpMethod;
 import io.netty.handler.codec.http.HttpUtil;
+import org.xbib.net.Pair;
 import org.xbib.net.QueryParameters;
 import org.xbib.net.URL;
 import org.xbib.netty.http.common.HttpParameters;
 import org.xbib.netty.http.server.ServerRequest;
-import org.xbib.netty.http.server.endpoint.EndpointInfo;
+import org.xbib.netty.http.server.endpoint.HttpEndpointDescriptor;
 
 import javax.net.ssl.SSLSession;
 import java.io.IOException;
+import java.io.InputStream;
 import java.nio.charset.MalformedInputException;
 import java.nio.charset.StandardCharsets;
 import java.nio.charset.UnmappableCharacterException;
@@ -40,7 +44,7 @@ public class HttpServerRequest implements ServerRequest {
 
     private FullHttpRequest httpRequest;
 
-    private EndpointInfo info;
+    private HttpEndpointDescriptor info;
 
     private HttpParameters parameters;
 
@@ -54,6 +58,26 @@ public class HttpServerRequest implements ServerRequest {
 
     private SSLSession sslSession;
 
+    public void handleParameters() throws IOException {
+        try {
+            HttpParameters httpParameters = new HttpParameters();
+            URL.Builder builder = URL.builder().path(getRequest().uri());
+            this.url = builder.build();
+            QueryParameters queryParameters = url.getQueryParams();
+            ByteBuf byteBuf = httpRequest.content();
+            if (APPLICATION_FORM_URL_ENCODED.equals(HttpUtil.getMimeType(httpRequest)) && byteBuf != null) {
+                String content = byteBuf.toString(HttpUtil.getCharset(httpRequest, StandardCharsets.ISO_8859_1));
+                queryParameters.addPercentEncodedBody(content);
+            }
+            for (Pair<String, String> pair : queryParameters) {
+                httpParameters.add(pair.getFirst(), pair.getSecond());
+            }
+            this.parameters = httpParameters;
+        } catch (MalformedInputException | UnmappableCharacterException e) {
+            throw new IOException(e);
+        }
+    }
+
     public void setChannelHandlerContext(ChannelHandlerContext ctx) {
         this.ctx = ctx;
     }
@@ -64,7 +88,7 @@ public class HttpServerRequest implements ServerRequest {
 
     public void setRequest(FullHttpRequest fullHttpRequest) {
         this.httpRequest = fullHttpRequest;
-        this.info = new EndpointInfo(this);
+        this.info = new HttpEndpointDescriptor(this);
     }
 
     public FullHttpRequest getRequest() {
@@ -77,7 +101,12 @@ public class HttpServerRequest implements ServerRequest {
     }
 
     @Override
-    public EndpointInfo getEndpointInfo() {
+    public Channel getChannel() {
+        return ctx.channel();
+    }
+
+    @Override
+    public HttpEndpointDescriptor getEndpointDescriptor() {
         return info;
     }
 
@@ -99,7 +128,7 @@ public class HttpServerRequest implements ServerRequest {
 
     @Override
     public String getEffectiveRequestPath() {
-        String path = getEndpointInfo().getPath();
+        String path = getEndpointDescriptor().getPath();
         String effective = contextPath != null && !PATH_SEPARATOR.equals(contextPath) && path.startsWith(contextPath) ?
                 path.substring(contextPath.length()) : path;
         return effective.isEmpty() ? PATH_SEPARATOR : effective;
@@ -126,27 +155,6 @@ public class HttpServerRequest implements ServerRequest {
         return httpRequest.headers();
     }
 
-    @Override
-    public void createParameters() throws IOException {
-        try {
-            HttpParameters httpParameters = new HttpParameters();
-            URL.Builder builder = URL.builder().path(getRequest().uri());
-            this.url = builder.build();
-            QueryParameters queryParameters = url.getQueryParams();
-            ByteBuf byteBuf = httpRequest.content();
-            if (APPLICATION_FORM_URL_ENCODED.equals(HttpUtil.getMimeType(httpRequest)) && byteBuf != null) {
-                String content = byteBuf.toString(HttpUtil.getCharset(httpRequest, StandardCharsets.ISO_8859_1));
-                queryParameters.addPercentEncodedBody(content);
-            }
-            for (QueryParameters.Pair<String, String> pair : queryParameters) {
-                httpParameters.add(pair.getFirst(), pair.getSecond());
-            }
-            this.parameters = httpParameters;
-        } catch (MalformedInputException | UnmappableCharacterException e) {
-            throw new IOException(e);
-        }
-    }
-
     @Override
     public HttpParameters getParameters() {
         return parameters;
@@ -166,7 +174,7 @@ public class HttpServerRequest implements ServerRequest {
     }
 
     @Override
-    public Integer streamId() {
+    public Integer getStreamId() {
         return streamId;
     }
 
@@ -175,7 +183,7 @@ public class HttpServerRequest implements ServerRequest {
     }
 
     @Override
-    public Integer requestId() {
+    public Integer getRequestId() {
         return requestId;
     }
 
@@ -193,6 +201,11 @@ public class HttpServerRequest implements ServerRequest {
         return httpRequest.content();
     }
 
+    @Override
+    public ByteBufInputStream getInputStream() {
+        return new ByteBufInputStream(getContent(), true);
+    }
+
     public String toString() {
         return "ServerRequest[request=" + httpRequest + "]";
     }

netty-http-server/src/main/java/org/xbib/netty/http/server/transport/HttpServerResponse.java

@@ -1,6 +1,8 @@
 package org.xbib.netty.http.server.transport;
 
 import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufOutputStream;
+import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelFutureListener;
 import io.netty.channel.ChannelHandlerContext;
@@ -23,6 +25,7 @@ import org.xbib.netty.http.server.ServerResponse;
 import org.xbib.netty.http.server.cookie.ServerCookieEncoder;
 import org.xbib.netty.http.server.handler.http.HttpPipelinedResponse;
 
+import java.io.OutputStream;
 import java.nio.charset.Charset;
 import java.time.ZoneOffset;
 import java.time.ZonedDateTime;
@@ -45,6 +48,8 @@ public class HttpServerResponse implements ServerResponse {
 
     private HttpResponseStatus httpResponseStatus;
 
+    private ByteBufOutputStream byteBufOutputStream;
+
     public HttpServerResponse(HttpServerRequest serverRequest) {
         Objects.requireNonNull(serverRequest, "serverRequest");
         Objects.requireNonNull(serverRequest.getChannelHandlerContext(), "serverRequest channelHandlerContext");
@@ -100,9 +105,31 @@ public class HttpServerResponse implements ServerResponse {
         return this;
     }
 
+    @Override
+    public ByteBufOutputStream getOutputStream() {
+        this.byteBufOutputStream = new ByteBufOutputStream(ctx.alloc().buffer());
+        return byteBufOutputStream;
+    }
+
+    @Override
+    public void flush() {
+        write((ByteBuf) null);
+    }
+
+    @Override
+    public void write(byte[] bytes) {
+        ByteBuf byteBuf = ctx.alloc().buffer(bytes.length);
+        byteBuf.writeBytes(bytes);
+        write(byteBuf);
+    }
+
+    @Override
+    public void write(ByteBufOutputStream byteBufOutputStream) {
+        write(byteBufOutputStream.buffer());
+    }
+
     @Override
     public void write(ByteBuf byteBuf) {
-        Objects.requireNonNull(byteBuf);
         if (httpResponseStatus == null) {
             httpResponseStatus = HttpResponseStatus.OK;
         }
@@ -110,9 +137,12 @@ public class HttpServerResponse implements ServerResponse {
         if (contentType == null) {
             headers.add(HttpHeaderNames.CONTENT_TYPE, HttpHeaderValues.APPLICATION_OCTET_STREAM);
         }
-        if (!headers.contains(HttpHeaderNames.CONTENT_LENGTH) && !headers.contains(HttpHeaderNames.TRANSFER_ENCODING)) {
+        if (httpResponseStatus.code() >= 200 && httpResponseStatus.code() != 204) {
-            int length = byteBuf.readableBytes();
+            if (!headers.contains(HttpHeaderNames.CONTENT_LENGTH) && !headers.contains(HttpHeaderNames.TRANSFER_ENCODING)) {
-            headers.add(HttpHeaderNames.CONTENT_LENGTH, Long.toString(length));
+                if (byteBuf != null) {
+                    headers.add(HttpHeaderNames.CONTENT_LENGTH, Long.toString(byteBuf.readableBytes()));
+                }
+            }
         }
         if (serverRequest != null && "close".equalsIgnoreCase(serverRequest.getHeaders().get(HttpHeaderNames.CONNECTION)) &&
                 !headers.contains(HttpHeaderNames.CONNECTION)) {
@@ -123,9 +153,9 @@ public class HttpServerResponse implements ServerResponse {
         }
         headers.add(HttpHeaderNames.SERVER, ServerName.getServerName());
         if (ctx.channel().isWritable()) {
-            FullHttpResponse fullHttpResponse =
+            FullHttpResponse fullHttpResponse = byteBuf != null ?
-                    new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, httpResponseStatus, byteBuf, headers, trailingHeaders);
+                    new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, httpResponseStatus, byteBuf, headers, trailingHeaders) :
-            logger.log(Level.FINEST, fullHttpResponse.headers()::toString);
+                    new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, httpResponseStatus, Unpooled.buffer(0), headers, trailingHeaders);
             if (serverRequest != null && serverRequest.getSequenceId() != null) {
                 HttpPipelinedResponse httpPipelinedResponse = new HttpPipelinedResponse(fullHttpResponse,
                         ctx.channel().newPromise(), serverRequest.getSequenceId());

netty-http-server/src/test/java/org/xbib/netty/http/server/test/EndpointTest.java

@@ -10,7 +10,7 @@ import org.xbib.netty.http.common.HttpAddress;
 import org.xbib.netty.http.server.Server;
 import org.xbib.netty.http.server.ServerResponse;
 import org.xbib.netty.http.server.endpoint.HttpEndpoint;
-import org.xbib.netty.http.server.endpoint.EndpointResolver;
+import org.xbib.netty.http.server.endpoint.HttpEndpointResolver;
 import org.xbib.netty.http.server.Domain;
 import org.xbib.netty.http.server.endpoint.service.FileService;
 import org.xbib.netty.http.server.endpoint.service.Service;
@@ -38,15 +38,15 @@ class EndpointTest {
         Path vartmp = Paths.get("/var/tmp/");
         Service service = new FileService(vartmp);
         HttpAddress httpAddress = HttpAddress.http1("localhost", 8008);
-        EndpointResolver endpointResolver = EndpointResolver.builder()
+        HttpEndpointResolver httpEndpointResolver = HttpEndpointResolver.builder()
                 .addEndpoint(HttpEndpoint.builder().setPath("/**").build())
                 .setDispatcher((endpoint, req, resp) -> {
-                    logger.log(Level.FINE, "dispatching endpoint=" + endpoint + " req=" + req);
+                    logger.log(Level.FINE, "dispatching endpoint = " + endpoint + " req = " + req);
                     service.handle(req, resp);
                 })
                 .build();
         Domain domain = Domain.builder(httpAddress)
-                .addEndpointResolver(endpointResolver)
+                .addEndpointResolver(httpEndpointResolver)
                 .build();
         Server server = Server.builder(domain)
                 .build();
@@ -78,15 +78,15 @@ class EndpointTest {
         Path vartmp = Paths.get("/var/tmp/");
         Service service = new FileService(vartmp);
         HttpAddress httpAddress = HttpAddress.http1("localhost", 8008);
-        EndpointResolver endpointResolver = EndpointResolver.builder()
+        HttpEndpointResolver httpEndpointResolver = HttpEndpointResolver.builder()
                 .addEndpoint(HttpEndpoint.builder().setPrefix("/").setPath("/**").build())
                 .setDispatcher((endpoint, req, resp) -> {
-                    logger.log(Level.FINE, "dispatching endpoint=" + endpoint + " req=" + req);
+                    logger.log(Level.FINE, "dispatching endpoint = " + endpoint + " req = " + req);
                     service.handle(req, resp);
                 })
                 .build();
         Domain domain = Domain.builder(httpAddress)
-                .addEndpointResolver(endpointResolver)
+                .addEndpointResolver(httpEndpointResolver)
                 .build();
         Server server = Server.builder(domain)
                 .build();
@@ -119,17 +119,17 @@ class EndpointTest {
         Path vartmp = Paths.get("/var/tmp/");
         Service service = new FileService(vartmp);
         HttpAddress httpAddress = HttpAddress.http1("localhost", 8008);
-        EndpointResolver endpointResolver = EndpointResolver.builder()
+        HttpEndpointResolver httpEndpointResolver = HttpEndpointResolver.builder()
                 .addEndpoint(HttpEndpoint.builder().setPrefix("/static").setPath("/**").build())
                 .addEndpoint(HttpEndpoint.builder().setPrefix("/static1").setPath("/**").build())
                 .addEndpoint(HttpEndpoint.builder().setPrefix("/static2").setPath("/**").build())
                 .setDispatcher((endpoint, req, resp) -> {
-                    logger.log(Level.FINE, "dispatching endpoint=" + endpoint + " req=" + req);
+                    logger.log(Level.FINE, "dispatching endpoint = " + endpoint + " req = " + req);
                     service.handle(req, resp);
                 })
                 .build();
         Domain domain = Domain.builder(httpAddress)
-                .addEndpointResolver(endpointResolver)
+                .addEndpointResolver(httpEndpointResolver)
                 .build();
         Server server = Server.builder(domain)
                 .build();
@@ -185,18 +185,18 @@ class EndpointTest {
         Path vartmp = Paths.get("/var/tmp/");
         Service service = new FileService(vartmp);
         HttpAddress httpAddress = HttpAddress.http1("localhost", 8008);
-        EndpointResolver endpointResolver = EndpointResolver.builder()
+        HttpEndpointResolver httpEndpointResolver = HttpEndpointResolver.builder()
                 .addEndpoint(HttpEndpoint.builder().setPrefix("/static").setPath("/**").build())
                 .addEndpoint(HttpEndpoint.builder().setPrefix("/static1").setPath("/**").build())
                 .addEndpoint(HttpEndpoint.builder().setPrefix("/static2").setPath("/**").build())
                 .setDispatcher((endpoint, req, resp) -> {
-                    logger.log(Level.FINE, "dispatching endpoint=" + endpoint + " req=" + req +
+                    logger.log(Level.FINE, "dispatching endpoint = " + endpoint + " req = " + req +
                             " fragment=" + req.getURL().getFragment());
                     service.handle(req, resp);
                 })
                 .build();
         Domain domain = Domain.builder(httpAddress)
-                .addEndpointResolver(endpointResolver)
+                .addEndpointResolver(httpEndpointResolver)
                 .build();
         Server server = Server.builder(domain)
                 .build();
@@ -264,9 +264,9 @@ class EndpointTest {
 
     @Test
     void testMassiveEndpoints() throws IOException {
-        int max = 2; // more than 1024
+        int max = 1024;
         HttpAddress httpAddress = HttpAddress.http1("localhost", 8008);
-        EndpointResolver.Builder endpointResolverBuilder = EndpointResolver.builder()
+        HttpEndpointResolver.Builder endpointResolverBuilder = HttpEndpointResolver.builder()
                 .setPrefix("/static");
         for (int i = 0; i < max; i++) {
             endpointResolverBuilder.addEndpoint(HttpEndpoint.builder()

netty-http-server/src/test/java/org/xbib/netty/http/server/test/StreamTest.java

@@ -0,0 +1,65 @@
+package org.xbib.netty.http.server.test;
+
+import io.netty.buffer.ByteBufInputStream;
+import io.netty.buffer.ByteBufOutputStream;
+import io.netty.handler.codec.http.HttpResponseStatus;
+import io.netty.handler.codec.http.HttpVersion;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.xbib.netty.http.client.Client;
+import org.xbib.netty.http.client.Request;
+import org.xbib.netty.http.common.HttpAddress;
+import org.xbib.netty.http.server.Domain;
+import org.xbib.netty.http.server.Server;
+
+import java.nio.charset.StandardCharsets;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@ExtendWith(NettyHttpExtension.class)
+class StreamTest {
+
+    @Test
+    void testServerStreams() throws Exception {
+        HttpAddress httpAddress = HttpAddress.http1("localhost", 8008);
+        Domain domain = Domain.builder(httpAddress)
+                .singleEndpoint("/", (request, response) -> {
+                    ByteBufInputStream inputStream = request.getInputStream();
+                    String content = inputStream.readLine();
+                    assertEquals("my body parameter", content);
+                    ByteBufOutputStream outputStream = response.getOutputStream();
+                    outputStream.writeBytes("Hello World");
+                    response.withStatus(HttpResponseStatus.OK)
+                            .withContentType("text/plain")
+                            .write(outputStream);
+                })
+                .build();
+        Server server = Server.builder(domain)
+                .build();
+        Client client = Client.builder()
+                .build();
+        int max = 1;
+        final AtomicInteger count = new AtomicInteger(0);
+        try {
+            server.accept();
+            Request request = Request.get().setVersion(HttpVersion.HTTP_1_1)
+                    .url(server.getServerConfig().getAddress().base().resolve("/"))
+                    .content("my body parameter", "text/plain")
+                    .build()
+                    .setResponseListener(response -> {
+                        if (response.status().equals(HttpResponseStatus.OK)) {
+                            assertEquals("Hello World", response.content().toString(StandardCharsets.UTF_8));
+                            count.incrementAndGet();
+                        }
+                    });
+            for (int i = 0; i < max; i++) {
+                client.execute(request).get();
+            }
+        } finally {
+            server.shutdownGracefully();
+            client.shutdownGracefully();
+        }
+        assertEquals(max, count.get());
+    }
+}

netty-http-xmlrpc-client/build.gradle

@@ -0,0 +1,7 @@
+dependencies {
+    compile project(":netty-http-xmlrpc-common")
+    compile "commons-httpclient:commons-httpclient:${project.property(('commons-httpclient.version'))}"
+    testCompile project(":netty-http-xmlrpc-servlet")
+    testCompileOnly group: 'javax.servlet', name: 'javax.servlet-api', version: '3.1.0'
+
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/AsyncCallback.java

@@ -0,0 +1,20 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import org.xbib.netty.http.xmlrpc.common.XmlRpcRequest;
+
+/**
+ * A callback interface for an asynchronous XML-RPC call.
+ */
+public interface AsyncCallback {
+    /** Call went ok, handle result.
+     * @param pRequest The request being performed.
+     * @param pResult The result object, which was returned by the server.
+     */
+    public void handleResult(XmlRpcRequest pRequest, Object pResult);
+
+    /** Something went wrong, handle error.
+     * @param pRequest The request being performed.
+     * @param pError The error being thrown.
+     */
+    public void handleError(XmlRpcRequest pRequest, Throwable pError);
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/ClientFactory.java

@@ -0,0 +1,139 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import org.xbib.netty.http.xmlrpc.common.TypeConverter;
+import org.xbib.netty.http.xmlrpc.common.TypeConverterFactory;
+import org.xbib.netty.http.xmlrpc.common.TypeConverterFactoryImpl;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcInvocationException;
+
+import java.lang.reflect.Proxy;
+import java.lang.reflect.UndeclaredThrowableException;
+
+/**
+ * <p>The {@link ClientFactory} is a useful tool for simplifying the
+ * use of Apache XML-RPC. The rough idea is as follows: All XML-RPC
+ * handlers are implemented as interfaces. The server uses the actual
+ * implementation. The client uses the {@link ClientFactory} to
+ * obtain an implementation, which is based on running XML-RPC calls.</p>
+ */
+public class ClientFactory {
+
+    private final XmlRpcClient client;
+
+    private final TypeConverterFactory typeConverterFactory;
+
+    private boolean objectMethodLocal;
+
+    /** Creates a new instance.
+     * @param pClient A fully configured XML-RPC client, which is
+     *   used internally to perform XML-RPC calls.
+     * @param pTypeConverterFactory Creates instances of {@link TypeConverterFactory},
+     *   which are used to transform the result object in its target representation.
+     */
+    public ClientFactory(XmlRpcClient pClient, TypeConverterFactory pTypeConverterFactory) {
+        typeConverterFactory = pTypeConverterFactory;
+        client = pClient;
+    }
+
+    /** Creates a new instance. Shortcut for
+     * <pre>
+     *   new ClientFactory(pClient, new TypeConverterFactoryImpl());
+     * </pre>
+     * @param pClient A fully configured XML-RPC client, which is
+     *   used internally to perform XML-RPC calls.
+     * @see TypeConverterFactoryImpl
+     */
+    public ClientFactory(XmlRpcClient pClient) {
+        this(pClient, new TypeConverterFactoryImpl());
+    }
+
+    /** Returns the factories client.
+     */
+    public XmlRpcClient getClient() {
+        return client;
+    }
+
+    /** Returns, whether a method declared by the {@link Object
+     * Object class} is performed by the local object, rather than
+     * by the server. Defaults to true.
+     */
+    public boolean isObjectMethodLocal() {
+        return objectMethodLocal;
+    }
+
+    /** Sets, whether a method declared by the {@link Object
+     * Object class} is performed by the local object, rather than
+     * by the server. Defaults to true.
+     */
+    public void setObjectMethodLocal(boolean pObjectMethodLocal) {
+        objectMethodLocal = pObjectMethodLocal;
+    }
+
+    /**
+     * Creates an object, which is implementing the given interface.
+     * The objects methods are internally calling an XML-RPC server
+     * by using the factories client; shortcut for
+     * <pre>
+     *   newInstance(Thread.currentThread().getContextClassLoader(),
+     *     pClass)
+     * </pre>
+     */
+    public Object newInstance(Class<?> pClass) {
+        return newInstance(Thread.currentThread().getContextClassLoader(), pClass);
+    }
+
+    /** Creates an object, which is implementing the given interface.
+     * The objects methods are internally calling an XML-RPC server
+     * by using the factories client; shortcut for
+     * <pre>
+     *   newInstance(pClassLoader, pClass, pClass.getName())
+     * </pre>
+     */
+    public Object newInstance(ClassLoader pClassLoader, Class<?> pClass) {
+        return newInstance(pClassLoader, pClass, pClass.getName());
+    }
+
+    /** Creates an object, which is implementing the given interface.
+     * The objects methods are internally calling an XML-RPC server
+     * by using the factories client.
+     * @param pClassLoader The class loader, which is being used for
+     *   loading classes, if required.
+     * @param pClass Interface, which is being implemented.
+     * @param pRemoteName Handler name, which is being used when
+     *   calling the server. This is used for composing the
+     *   method name. For example, if <code>pRemoteName</code>
+     *   is "Foo" and you want to invoke the method "bar" in
+     *   the handler, then the full method name would be "Foo.bar".
+     */
+    public Object newInstance(ClassLoader pClassLoader, final Class<?> pClass, final String pRemoteName) {
+
+       return Proxy.newProxyInstance(pClassLoader, new Class<?>[] { pClass }, (pProxy, pMethod, pArgs) -> {
+           if (isObjectMethodLocal()  &&  pMethod.getDeclaringClass().equals(Object.class)) {
+               return pMethod.invoke(pProxy, pArgs);
+           }
+           final String methodName;
+           if (pRemoteName == null  ||  pRemoteName.length() == 0) {
+               methodName = pMethod.getName();
+           } else {
+               methodName = pRemoteName + "." + pMethod.getName();
+           }
+           Object result;
+           try {
+               result = client.execute(methodName, pArgs);
+           } catch (XmlRpcInvocationException e) {
+               Throwable t = e.linkedException;
+               if (t instanceof RuntimeException) {
+                   throw t;
+               }
+               Class<?>[] exceptionTypes = pMethod.getExceptionTypes();
+               for (Class<?> c : exceptionTypes) {
+                   if (c.isAssignableFrom(t.getClass())) {
+                       throw t;
+                   }
+               }
+               throw new UndeclaredThrowableException(t);
+           }
+           TypeConverter typeConverter = typeConverterFactory.getTypeConverter(pMethod.getReturnType());
+           return typeConverter.convert(result);
+       });
+    }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/TimingOutCallback.java

@@ -0,0 +1,78 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import org.xbib.netty.http.xmlrpc.common.XmlRpcException;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcRequest;
+
+/**
+ * <p>A callback object that can wait up to a specified amount
+ * of time for the XML-RPC response. Suggested use is as follows:
+ * </p>
+ * <pre>
+ *   // Wait for 10 seconds.
+ *   TimingOutCallback callback = new TimingOutCallback(10 * 1000);
+ *   XmlRpcClient client = new XmlRpcClient(url);
+ *   client.executeAsync(methodName, aVector, callback);
+ *   try {
+ *       return callback.waitForResponse();
+ *   } catch (TimeoutException e) {
+ *       System.out.println("No response from server.");
+ *   } catch (Exception e) {
+ *       System.out.println("Server returned an error message.");
+ *   }
+ * </pre>
+ */
+public class TimingOutCallback implements AsyncCallback {
+    /** This exception is thrown, if the request times out.
+     */
+    public static class TimeoutException extends XmlRpcException {
+        private static final long serialVersionUID = 4875266372372105081L;
+
+        /** Creates a new instance with the given error code and
+         * error message.
+         */
+        public TimeoutException(int pCode, String message) {
+            super(pCode, message);
+        }
+    }
+
+    private final long timeout;
+    private Object result;
+    private Throwable error;
+    private boolean responseSeen;
+
+    /** Waits the specified number of milliseconds for a response.
+     */
+    public TimingOutCallback(long pTimeout) {
+        timeout = pTimeout;
+    }
+
+    /** Called to wait for the response.
+     * @throws InterruptedException The thread was interrupted.
+     * @throws TimeoutException No response was received after waiting the specified time.
+     * @throws Throwable An error was returned by the server.
+     */
+    public synchronized Object waitForResponse() throws Throwable {
+        if (!responseSeen) {
+            wait(timeout);
+            if (!responseSeen) {
+                throw new TimeoutException(0, "No response after waiting for " + timeout + " milliseconds.");
+            }
+        }
+        if (error != null) {
+            throw error;
+        }
+        return result;
+    }
+
+    public synchronized void handleError(XmlRpcRequest pRequest, Throwable pError) {
+        responseSeen = true;
+        error = pError;
+        notify();
+    }
+
+    public synchronized void handleResult(XmlRpcRequest pRequest, Object pResult) {
+        responseSeen = true;
+        result = pResult;
+        notify();
+    }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcClient.java

@@ -0,0 +1,246 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import org.xbib.netty.http.xmlrpc.common.XmlRpcConfig;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcController;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcException;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcRequest;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcWorkerFactory;
+import org.xbib.netty.http.xmlrpc.common.serializer.XmlWriterFactory;
+
+import java.util.List;
+
+/**
+ * <p>The main access point of an XML-RPC client. This object serves mainly
+ * as an object factory. It is designed with singletons in mind: Basically,
+ * an application should be able to hold a single instance of
+ * <code>XmlRpcClient</code> in a static variable, unless you would be
+ * working with different factories.</p>
+ * <p>Until Apache XML-RPC 2.0, this object was used both as an object
+ * factory and as a place, where configuration details (server URL,
+ * suggested encoding, user credentials and the like) have been stored.
+ * In Apache XML-RPC 3.0, the configuration details has been moved to
+ * the {@link XmlRpcClientConfig} object.
+ * The configuration object is designed for being passed through the
+ * actual worker methods.</p>
+ * <p>A configured XmlRpcClient object is thread safe: In other words,
+ * the suggested use is, that you configure the client using
+ * {@link #setTransportFactory(XmlRpcTransportFactory)} and similar
+ * methods, store it in a field and never modify it again. Without
+ * modifications, the client may be used for an arbitrary number
+ * of concurrent requests.</p>
+ */
+public class XmlRpcClient extends XmlRpcController {
+
+    private XmlRpcTransportFactory transportFactory = XmlRpcClientDefaults.newTransportFactory(this);
+
+    private XmlRpcClientConfig config = XmlRpcClientDefaults.newXmlRpcClientConfig();
+
+    private XmlWriterFactory xmlWriterFactory = XmlRpcClientDefaults.newXmlWriterFactory();
+
+    protected XmlRpcWorkerFactory getDefaultXmlRpcWorkerFactory() {
+        return new XmlRpcClientWorkerFactory(this);
+    }
+
+    /**
+     * Sets the clients default configuration. This configuration
+     * is used by the methods
+     * {@link #execute(String, List)},
+     * {@link #execute(String, Object[])}, and
+     * {@link #execute(XmlRpcRequest)}.
+     * You may overwrite this per request by using
+     * {@link #execute(XmlRpcClientConfig, String, List)},
+     * or {@link #execute(XmlRpcClientConfig, String, Object[])}.
+     * @param pConfig The default request configuration.
+     */
+    public void setConfig(XmlRpcClientConfig pConfig) {
+        config = pConfig;
+    }
+
+    /**
+     * Returns the clients default configuration. This configuration
+     * is used by the methods
+     * {@link #execute(String, List)},
+     * {@link #execute(String, Object[])}.
+     * You may overwrite this per request by using
+     * {@link #execute(XmlRpcClientConfig, String, List)},
+     * or {@link #execute(XmlRpcClientConfig, String, Object[])}.
+     * @return The default request configuration.
+     */
+    public XmlRpcConfig getConfig() {
+        return config;
+    }
+
+    /**
+     * Returns the clients default configuration. Shortcut for
+     * <code>(XmlRpcClientConfig) getConfig()</code>.
+     * This configuration is used by the methods
+     * {@link #execute(String, List)},
+     * {@link #execute(String, Object[])}.
+     * You may overwrite this per request by using
+     * {@link #execute(XmlRpcClientConfig, String, List)}, or
+     * {@link #execute(XmlRpcClientConfig, String, Object[])}
+     * @return The default request configuration.
+     */
+    public XmlRpcClientConfig getClientConfig() {
+        return config;
+    }
+
+    /**
+     * Sets the clients transport factory. The client will invoke the
+     * factory method {@link XmlRpcTransportFactory#getTransport()}
+     * for any request.
+     * @param pFactory The clients transport factory.
+     */
+    public void setTransportFactory(XmlRpcTransportFactory pFactory) {
+        transportFactory = pFactory;
+    }
+
+    /**
+     * Returns the clients transport factory. The client will use this factory
+     * for invocation of {@link XmlRpcTransportFactory#getTransport()}
+     * for any request.
+     * @return The clients transport factory.
+     */
+    public XmlRpcTransportFactory getTransportFactory() {
+        return transportFactory;
+    }
+
+    /**
+     * Performs a request with the clients default configuration.
+     * @param pMethodName The method being performed.
+     * @param pParams The parameters.
+     * @return The result object.
+     * @throws XmlRpcException Performing the request failed.
+     */
+    public Object execute(String pMethodName, Object[] pParams) throws XmlRpcException {
+        return execute(getClientConfig(), pMethodName, pParams);
+    }
+
+    /**
+     * Performs a request with the given configuration.
+     * @param pConfig The request configuration.
+     * @param pMethodName The method being performed.
+     * @param pParams The parameters.
+     * @return The result object.
+     * @throws XmlRpcException Performing the request failed.
+     */
+    public Object execute(XmlRpcClientConfig pConfig, String pMethodName, Object[] pParams) throws XmlRpcException {
+        return execute(new XmlRpcClientRequestImpl(pConfig, pMethodName, pParams));
+    }
+
+    /**
+     * Performs a request with the clients default configuration.
+     * @param pMethodName The method being performed.
+     * @param pParams The parameters.
+     * @return The result object.
+     * @throws XmlRpcException Performing the request failed.
+     */
+    public Object execute(String pMethodName, List<Object> pParams) throws XmlRpcException {
+        return execute(getClientConfig(), pMethodName, pParams);
+    }
+
+    /**
+     * Performs a request with the given configuration.
+     * @param pConfig The request configuration.
+     * @param pMethodName The method being performed.
+     * @param pParams The parameters.
+     * @return The result object.
+     * @throws XmlRpcException Performing the request failed.
+     */
+    public Object execute(XmlRpcClientConfig pConfig, String pMethodName, List<Object> pParams) throws XmlRpcException {
+        return execute(new XmlRpcClientRequestImpl(pConfig, pMethodName, pParams));
+    }
+
+    /**
+     * Performs a request with the clients default configuration.
+     * @param pRequest The request being performed.
+     * @return The result object.
+     * @throws XmlRpcException Performing the request failed.
+     */
+    public Object execute(XmlRpcRequest pRequest) throws XmlRpcException {
+        return getWorkerFactory().getWorker().execute(pRequest);
+    }
+
+    /**
+     * Performs an asynchronous request with the clients default configuration.
+     * @param pMethodName The method being performed.
+     * @param pParams The parameters.
+     * @param pCallback The callback being notified when the request is finished.
+     * @throws XmlRpcException Performing the request failed.
+     */
+    public void executeAsync(String pMethodName, Object[] pParams,
+                             AsyncCallback pCallback) throws XmlRpcException {
+        executeAsync(getClientConfig(), pMethodName, pParams, pCallback);
+    }
+
+    /**
+     * Performs an asynchronous request with the given configuration.
+     * @param pConfig The request configuration.
+     * @param pMethodName The method being performed.
+     * @param pParams The parameters.
+     * @param pCallback The callback being notified when the request is finished.
+     * @throws XmlRpcException Performing the request failed.
+     */
+    public void executeAsync(XmlRpcClientConfig pConfig,
+                             String pMethodName, Object[] pParams,
+                             AsyncCallback pCallback) throws XmlRpcException {
+        executeAsync(new XmlRpcClientRequestImpl(pConfig, pMethodName, pParams),
+                pCallback);
+    }
+
+    /**
+     * Performs an asynchronous request with the clients default configuration.
+     * @param pMethodName The method being performed.
+     * @param pParams The parameters.
+     * @param pCallback The callback being notified when the request is finished.
+     * @throws XmlRpcException Performing the request failed.
+     */
+    public void executeAsync(String pMethodName, List<Object> pParams,
+                             AsyncCallback pCallback) throws XmlRpcException {
+        executeAsync(getClientConfig(), pMethodName, pParams, pCallback);
+    }
+
+    /**
+     * Performs an asynchronous request with the given configuration.
+     * @param pConfig The request configuration.
+     * @param pMethodName The method being performed.
+     * @param pParams The parameters.
+     * @param pCallback The callback being notified when the request is finished.
+     * @throws XmlRpcException Performing the request failed.
+     */
+    public void executeAsync(XmlRpcClientConfig pConfig,
+                             String pMethodName, List<Object> pParams,
+                             AsyncCallback pCallback) throws XmlRpcException {
+        executeAsync(new XmlRpcClientRequestImpl(pConfig, pMethodName, pParams), pCallback);
+    }
+
+    /**
+     * Performs a request with the clients default configuration.
+     * @param pRequest The request being performed.
+     * @param pCallback The callback being notified when the request is finished.
+     * @throws XmlRpcException Performing the request failed.
+     */
+    public void executeAsync(XmlRpcRequest pRequest,
+                             AsyncCallback pCallback) throws XmlRpcException {
+        XmlRpcClientWorker w = (XmlRpcClientWorker) getWorkerFactory().getWorker();
+        w.execute(pRequest, pCallback);
+    }
+
+    /**
+     * Returns the clients instance of
+     * {@link XmlWriterFactory}.
+     * @return A factory for creating instances.
+     */
+    public XmlWriterFactory getXmlWriterFactory() {
+        return xmlWriterFactory;
+    }
+
+    /**
+     * Sets the clients instance of
+     * {@link XmlWriterFactory}.
+     * @param pFactory A factory for creating instances}.
+     */
+    public void setXmlWriterFactory(XmlWriterFactory pFactory) {
+        xmlWriterFactory = pFactory;
+    }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcClientConfig.java

@@ -0,0 +1,15 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import org.xbib.netty.http.xmlrpc.common.XmlRpcRequestConfig;
+
+/**
+ * This interface is being implemented by an Apache XML-RPC clients
+ * configuration object. Depending on the transport factory, a
+ * configuration object must implement additional methods. For
+ * example, an HTTP transport requires an instance of
+ * {@link XmlRpcHttpClientConfig}. A
+ * local transport requires an instance of
+ * {@link XmlRpcLocalClientConfig}.
+ */
+public interface XmlRpcClientConfig extends XmlRpcRequestConfig {
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcClientConfigImpl.java

@@ -0,0 +1,68 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import org.xbib.netty.http.xmlrpc.common.XmlRpcHttpRequestConfigImpl;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcRequestProcessor;
+
+import java.io.Serializable;
+import java.net.URL;
+
+/**
+ * Default implementation of a clients request configuration.
+ */
+public class XmlRpcClientConfigImpl extends XmlRpcHttpRequestConfigImpl
+        implements XmlRpcHttpClientConfig, XmlRpcLocalClientConfig, Cloneable, Serializable {
+    private static final long serialVersionUID = 4121131450507800889L;
+    private URL serverURL;
+    private XmlRpcRequestProcessor xmlRpcServer;
+    private String userAgent;
+
+    /** Creates a new client configuration with default settings.
+     */
+    public XmlRpcClientConfigImpl() {
+    }
+
+    /** Creates a clone of this client configuration.
+     * @return A clone of this configuration.
+     */
+    public XmlRpcClientConfigImpl cloneMe() {
+        try {
+            return (XmlRpcClientConfigImpl) clone();
+        } catch (CloneNotSupportedException e) {
+            throw new IllegalStateException("Unable to create my clone");
+        }
+    }
+
+    /** Sets the servers URL.
+     * @param pURL Servers URL
+     */
+    public void setServerURL(URL pURL) {
+        serverURL = pURL;
+    }
+
+    public URL getServerURL() { return serverURL; }
+    /** Returns the {@link XmlRpcRequestProcessor} being invoked.
+     * @param pServer Server object being invoked. This will typically
+     * be a singleton instance, but could as well create a new
+     * instance with any call.
+     */
+    public void setXmlRpcServer(XmlRpcRequestProcessor pServer) {
+        xmlRpcServer = pServer;
+    }
+
+    public XmlRpcRequestProcessor getXmlRpcServer() { return xmlRpcServer; }
+
+    /**
+     * Returns the user agent header to use 
+     * @return the http user agent header to set when doing xmlrpc requests
+     */
+    public String getUserAgent() {
+        return userAgent;
+    }
+
+    /**
+     * @param pUserAgent the http user agent header to set when doing xmlrpc requests
+     */
+    public void setUserAgent(String pUserAgent) {
+        userAgent = pUserAgent;
+    }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcClientDefaults.java

@@ -0,0 +1,41 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import org.xbib.netty.http.xmlrpc.common.serializer.DefaultXMLWriterFactory;
+import org.xbib.netty.http.xmlrpc.common.serializer.XmlWriterFactory;
+
+/**
+ * This class is responsible to provide default settings.
+ */
+public class XmlRpcClientDefaults {
+
+    private static final XmlWriterFactory xmlWriterFactory = new DefaultXMLWriterFactory();
+
+    /**
+     * Creates a new transport factory for the given client.
+     */
+    public static XmlRpcTransportFactory newTransportFactory(XmlRpcClient pClient) {
+        try {
+            return new XmlRpcSun15HttpTransportFactory(pClient);
+        } catch (Throwable t1) {
+            try {
+                return new XmlRpcSun14HttpTransportFactory(pClient);
+            } catch (Throwable t2) {
+                return new XmlRpcSunHttpTransportFactory(pClient);
+            }
+        }
+    }
+
+    /**
+     * Creates a new instance of {@link XmlRpcClientConfig}.
+     */
+    public static XmlRpcClientConfig newXmlRpcClientConfig() {
+        return new XmlRpcClientConfigImpl();
+    }
+    
+    /**
+     * Creates a new {@link XmlWriterFactory}.
+     */
+    public static XmlWriterFactory newXmlWriterFactory() {
+        return xmlWriterFactory;
+    }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcClientException.java

@@ -0,0 +1,22 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+
+import org.xbib.netty.http.xmlrpc.common.XmlRpcException;
+
+/** <p>This is thrown by many of the client classes if an error occured processing
+ * and XML-RPC request or response due to client side processing..</p>
+ */
+public class XmlRpcClientException extends XmlRpcException {
+	private static final long serialVersionUID = 3545798797134608691L;
+
+	/**
+     * Create an XmlRpcClientException with the given message and
+     * underlying cause exception.
+     *
+     * @param pMessage the message for this exception.
+     * @param pCause the cause of the exception.
+     */
+    public XmlRpcClientException(String pMessage, Throwable pCause) {
+        super(0, pMessage, pCause);
+    }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcClientRequestImpl.java

@@ -0,0 +1,61 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import org.xbib.netty.http.xmlrpc.common.XmlRpcRequest;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcRequestConfig;
+
+import java.util.List;
+
+/**
+ * Default implementation of
+ * {@link XmlRpcRequest}.
+ */
+public class XmlRpcClientRequestImpl implements XmlRpcRequest {
+
+    private static final Object[] ZERO_PARAMS = new Object[0];
+
+    private final XmlRpcRequestConfig config;
+
+    private final String methodName;
+
+    private final Object[] params;
+
+    /**
+     * Creates a new instance.
+     * @param pConfig The request configuration.
+     * @param pMethodName The method name being performed.
+     * @param pParams The parameters.
+     * @throws NullPointerException One of the parameters is null.
+     */
+    public XmlRpcClientRequestImpl(XmlRpcRequestConfig pConfig,
+                                   String pMethodName, Object[] pParams) {
+        config = pConfig;
+        if (config == null) {
+            throw new NullPointerException("The request configuration must not be null.");
+        }
+        methodName = pMethodName;
+        if (methodName == null) {
+            throw new NullPointerException("The method name must not be null.");
+        }
+        params = pParams == null ? ZERO_PARAMS : pParams;
+    }
+
+    /**
+     * Creates a new instance.
+     * @param pConfig The request configuration.
+     * @param pMethodName The method name being performed.
+     * @param pParams The parameters.
+     * @throws NullPointerException The method name or the parameters are null.
+     */
+    public XmlRpcClientRequestImpl(XmlRpcRequestConfig pConfig,
+                                   String pMethodName, List<Object> pParams) {
+        this(pConfig, pMethodName, pParams == null ? null : pParams.toArray());
+    }
+
+    public String getMethodName() { return methodName; }
+
+    public int getParameterCount() { return params.length; }
+
+    public Object getParameter(int pIndex) { return params[pIndex]; }
+
+    public XmlRpcRequestConfig getConfig() { return config; }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcClientWorker.java

@@ -0,0 +1,74 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import org.xbib.netty.http.xmlrpc.common.XmlRpcController;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcException;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcRequest;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcWorker;
+
+/** Object, which performs a request on the clients behalf.
+ * The client maintains a pool of workers. The main purpose of the
+ * pool is limitation of the maximum number of concurrent requests.
+ */
+public class XmlRpcClientWorker implements XmlRpcWorker {
+	private final XmlRpcClientWorkerFactory factory;
+
+	/** Creates a new instance.
+	 * @param pFactory The factory, which is being notified, if
+	 * the worker's ready.
+	 */
+	public XmlRpcClientWorker(XmlRpcClientWorkerFactory pFactory) {
+		factory = pFactory;
+	}
+
+	public XmlRpcController getController() {
+		return factory.getController();
+	}
+
+	/** Performs a synchronous request.
+	 * @param pRequest The request being performed.
+	 * @return The requests result.
+	 * @throws XmlRpcException Performing the request failed.
+	 */
+	public Object execute(XmlRpcRequest pRequest)
+			throws XmlRpcException {
+		try {
+			XmlRpcClient client = (XmlRpcClient) getController();
+			return client.getTransportFactory().getTransport().sendRequest(pRequest);
+		} finally {
+			factory.releaseWorker(this);
+		}
+	}
+
+	protected Thread newThread(Runnable pRunnable) {
+		Thread result = new Thread(pRunnable);
+		result.setDaemon(true);
+		return result;
+	}
+
+	/** Performs an synchronous request.
+	 * @param pRequest The request being performed.
+	 * @param pCallback The callback being invoked, when the request is finished.
+	 */
+	public void execute(final XmlRpcRequest pRequest,
+						final AsyncCallback pCallback) {
+		Runnable runnable = new Runnable(){
+			public void run(){
+				Object result = null;
+				Throwable th = null;
+				try {
+					XmlRpcClient client = (XmlRpcClient) getController();
+					result = client.getTransportFactory().getTransport().sendRequest(pRequest);
+				} catch (Throwable t) {
+					th = t;
+				}
+				factory.releaseWorker(XmlRpcClientWorker.this);
+				if (th == null) {
+					pCallback.handleResult(pRequest, result);
+				} else {
+					pCallback.handleError(pRequest, th);
+				}
+			}
+		};
+		newThread(runnable).start();
+	}
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcClientWorkerFactory.java

@@ -0,0 +1,24 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import org.xbib.netty.http.xmlrpc.common.XmlRpcWorker;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcWorkerFactory;
+
+/**
+ * A worker factory for the client, creating instances of
+ * {@link XmlRpcClientWorker}.
+ */
+public class XmlRpcClientWorkerFactory extends XmlRpcWorkerFactory {
+	/** Creates a new instance.
+	 * @param pClient The factory controller.
+	 */
+	public XmlRpcClientWorkerFactory(XmlRpcClient pClient) {
+		super(pClient);
+	}
+
+	/** Creates a new worker instance.
+	 * @return New instance of {@link XmlRpcClientWorker}.
+	 */
+	protected XmlRpcWorker newWorker() {
+		return new XmlRpcClientWorker(this);
+	}
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcCommonsTransport.java

@@ -0,0 +1,242 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import java.io.BufferedOutputStream;
+import java.io.FilterOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import org.apache.commons.httpclient.Credentials;
+import org.apache.commons.httpclient.Header;
+import org.apache.commons.httpclient.HttpClient;
+import org.apache.commons.httpclient.HttpException;
+import org.apache.commons.httpclient.HttpMethod;
+import org.apache.commons.httpclient.HttpStatus;
+import org.apache.commons.httpclient.HttpVersion;
+import org.apache.commons.httpclient.URI;
+import org.apache.commons.httpclient.URIException;
+import org.apache.commons.httpclient.UsernamePasswordCredentials;
+import org.apache.commons.httpclient.auth.AuthScope;
+import org.apache.commons.httpclient.methods.PostMethod;
+import org.apache.commons.httpclient.methods.RequestEntity;
+import org.apache.commons.httpclient.params.HttpMethodParams;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcException;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcRequest;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcStreamConfig;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcStreamRequestConfig;
+import org.xbib.netty.http.xmlrpc.common.util.HttpUtil;
+import org.xml.sax.SAXException;
+
+/**
+ * An HTTP transport factory, which is based on the Jakarta Commons HTTP Client.
+ */
+public class XmlRpcCommonsTransport extends XmlRpcHttpTransport {
+    /**
+     * Maximum number of allowed redirects.
+     */
+    private static final int MAX_REDIRECT_ATTEMPTS = 100;
+
+    protected final HttpClient client;
+	private static final String userAgent = USER_AGENT + " (Jakarta Commons httpclient Transport)";
+	protected PostMethod method;
+	private int contentLength = -1;
+	private XmlRpcHttpClientConfig config;      
+
+	/** Creates a new instance.
+	 * @param pFactory The factory, which created this transport.
+	 */
+	public XmlRpcCommonsTransport(XmlRpcCommonsTransportFactory pFactory) {
+		super(pFactory.getClient(), userAgent);
+        HttpClient httpClient = pFactory.getHttpClient();
+        if (httpClient == null) {
+            httpClient = newHttpClient();
+        }
+        client = httpClient;
+     }
+
+	protected void setContentLength(int pLength) {
+		contentLength = pLength;
+	}
+
+    protected HttpClient newHttpClient() {
+        return new HttpClient();
+    }
+
+    protected void initHttpHeaders(XmlRpcRequest pRequest) throws XmlRpcClientException {
+        config = (XmlRpcHttpClientConfig) pRequest.getConfig();
+        method = newPostMethod(config);
+        super.initHttpHeaders(pRequest);
+        
+        if (config.getConnectionTimeout() != 0)
+            client.getHttpConnectionManager().getParams().setConnectionTimeout(config.getConnectionTimeout());
+        
+        if (config.getReplyTimeout() != 0)
+            client.getHttpConnectionManager().getParams().setSoTimeout(config.getReplyTimeout());
+        
+        method.getParams().setVersion(HttpVersion.HTTP_1_1);
+    }
+
+    protected PostMethod newPostMethod(XmlRpcHttpClientConfig pConfig) {
+        return new PostMethod(pConfig.getServerURL().toString());
+    }
+
+	protected void setRequestHeader(String pHeader, String pValue) {
+		method.setRequestHeader(new Header(pHeader, pValue));
+	}
+
+	protected boolean isResponseGzipCompressed() {
+		Header h = method.getResponseHeader( "Content-Encoding" );
+		if (h == null) {
+			return false;
+		} else {
+			return HttpUtil.isUsingGzipEncoding(h.getValue());
+		}
+	}
+
+	protected InputStream getInputStream() throws XmlRpcException {
+        try {
+            checkStatus(method);
+            return method.getResponseBodyAsStream();
+		} catch (HttpException e) {
+			throw new XmlRpcClientException("Error in HTTP transport: " + e.getMessage(), e);
+		} catch (IOException e) {
+			throw new XmlRpcClientException("I/O error in server communication: " + e.getMessage(), e);
+		}
+	}
+
+	protected void setCredentials(XmlRpcHttpClientConfig pConfig) throws XmlRpcClientException {
+		String userName = pConfig.getBasicUserName();
+		if (userName != null) {
+            String enc = pConfig.getBasicEncoding();
+            if (enc == null) {
+                enc = XmlRpcStreamConfig.UTF8_ENCODING;
+            }
+            client.getParams().setParameter(HttpMethodParams.CREDENTIAL_CHARSET, enc);
+			Credentials creds = new UsernamePasswordCredentials(userName, pConfig.getBasicPassword());
+			AuthScope scope = new AuthScope(null, AuthScope.ANY_PORT, null, AuthScope.ANY_SCHEME);
+			client.getState().setCredentials(scope, creds);
+            client.getParams().setAuthenticationPreemptive(true);
+        }
+	}
+
+	protected void close() throws XmlRpcClientException {
+		method.releaseConnection();
+	}
+
+	protected boolean isResponseGzipCompressed(XmlRpcStreamRequestConfig pConfig) {
+		Header h = method.getResponseHeader( "Content-Encoding" );
+		if (h == null) {
+			return false;
+		} else {
+			return HttpUtil.isUsingGzipEncoding(h.getValue());
+		}
+	}
+
+	protected boolean isRedirectRequired() {
+	    switch (method.getStatusCode()) {
+	        case HttpStatus.SC_MOVED_TEMPORARILY:
+	        case HttpStatus.SC_MOVED_PERMANENTLY:
+	        case HttpStatus.SC_SEE_OTHER:
+	        case HttpStatus.SC_TEMPORARY_REDIRECT:
+	            return true;
+	        default:
+	            return false;
+	    }
+	}
+
+	protected void resetClientForRedirect()
+            throws XmlRpcException {
+	    //get the location header to find out where to redirect to
+	    Header locationHeader = method.getResponseHeader("location");
+	    if (locationHeader == null) {
+            throw new XmlRpcException("Invalid redirect: Missing location header");
+	    }
+	    String location = locationHeader.getValue();
+
+	    URI redirectUri = null;
+	    URI currentUri = null;
+	    try {
+	        currentUri = method.getURI();
+	        String charset = currentUri.getProtocolCharset();
+	        redirectUri = new URI(location, true, charset);
+	        method.setURI(redirectUri);
+	    } catch (URIException ex) {
+            throw new XmlRpcException(ex.getMessage(), ex);
+	    }
+
+	    //And finally invalidate the actual authentication scheme
+	    method.getHostAuthState().invalidate();
+    }
+
+    protected void writeRequest(final ReqWriter pWriter) throws XmlRpcException {
+		method.setRequestEntity(new RequestEntity(){
+			public boolean isRepeatable() { return true; }
+			public void writeRequest(OutputStream pOut) throws IOException {
+				try {
+                    /* Make sure, that the socket is not closed by replacing it with our
+                     * own BufferedOutputStream.
+                     */
+                    OutputStream ostream;
+                    if (isUsingByteArrayOutput(config)) {
+                        // No need to buffer the output.
+                        ostream = new FilterOutputStream(pOut){
+                            public void close() throws IOException {
+                                flush();
+                            }
+                        };
+                    } else {
+                        ostream = new BufferedOutputStream(pOut){
+                            public void close() throws IOException {
+                                flush();
+                            }
+                        };
+                    }
+					pWriter.write(ostream);
+				} catch (XmlRpcException e) {
+					throw new XmlRpcIOException(e);
+				} catch (SAXException e) {
+                    throw new XmlRpcIOException(e);
+                }
+			}
+			public long getContentLength() { return contentLength; }
+			public String getContentType() { return "text/xml"; }
+		});
+		try {
+            int redirectAttempts = 0;
+            for (;;) {
+    			client.executeMethod(method);
+                if (!isRedirectRequired()) {
+                    break;
+                }
+                if (redirectAttempts++ > MAX_REDIRECT_ATTEMPTS) {
+                    throw new XmlRpcException("Too many redirects.");
+                }
+                resetClientForRedirect();
+            }
+		} catch (XmlRpcIOException e) {
+			Throwable t = e.getLinkedException();
+			if (t instanceof XmlRpcException) {
+				throw (XmlRpcException) t;
+			} else {
+				throw new XmlRpcException("Unexpected exception: " + t.getMessage(), t);
+			}
+		} catch (IOException e) {
+			throw new XmlRpcException("I/O error while communicating with HTTP server: " + e.getMessage(), e);
+		}
+	}
+    
+    /**
+     * Check the status of the HTTP request and throw an XmlRpcHttpTransportException if it
+     * indicates that there is an error.
+     * @param pMethod the method that has been executed
+     * @throws XmlRpcHttpTransportException if the status of the method indicates that there is an error.
+     */
+    private void checkStatus(HttpMethod pMethod) throws XmlRpcHttpTransportException {
+        final int status = pMethod.getStatusCode();
+        
+        // All status codes except SC_OK are handled as errors. Perhaps some should require special handling (e.g., SC_UNAUTHORIZED)
+        if (status < 200  ||  status > 299) {
+            throw new XmlRpcHttpTransportException(status, pMethod.getStatusText());
+        }
+    }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcCommonsTransportFactory.java

@@ -0,0 +1,66 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.xbib.netty.http.xmlrpc.client;
+
+import org.apache.commons.httpclient.HttpClient;
+
+
+/** An HTTP transport factory, which is based on the Jakarta Commons
+ * HTTP Client.
+ */
+public class XmlRpcCommonsTransportFactory extends XmlRpcTransportFactoryImpl {
+    private HttpClient httpClient;
+
+    /** Creates a new instance.
+	 * @param pClient The client, which is controlling the factory.
+	 */
+	public XmlRpcCommonsTransportFactory(XmlRpcClient pClient) {
+		super(pClient);
+	}
+
+	public XmlRpcTransport getTransport() {
+		return new XmlRpcCommonsTransport(this);
+	}
+
+	/**
+     * <p>Sets the factories {@link HttpClient}. By default, a new instance
+     * of {@link HttpClient} is created for any request.</p>
+     * <p>Reusing the {@link HttpClient} is required, if you want to preserve
+     * some state between requests. This applies, in particular, if you want
+     * to use cookies: In that case, create an instance of {@link HttpClient},
+     * give it to the factory, and use {@link HttpClient#getState()} to
+     * read or set cookies.
+	 */
+    public void setHttpClient(HttpClient pHttpClient) {
+        httpClient = pHttpClient;
+    }
+
+    /**
+     * <p>Returns the factories {@link HttpClient}. By default, a new instance
+     * of {@link HttpClient} is created for any request.</p>
+     * <p>Reusing the {@link HttpClient} is required, if you want to preserve
+     * some state between requests. This applies, in particular, if you want
+     * to use cookies: In that case, create an instance of {@link HttpClient},
+     * give it to the factory, and use {@link HttpClient#getState()} to
+     * read or set cookies.
+     */
+    public HttpClient getHttpClient() {
+        return httpClient;
+    }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcHttpClientConfig.java

@@ -0,0 +1,23 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import org.xbib.netty.http.xmlrpc.common.XmlRpcHttpRequestConfig;
+
+import java.net.URL;
+
+/** Extension of {@link XmlRpcClientConfig}
+ * for HTTP based transport. Provides details like server URL,
+ * user credentials, and so on.
+ */
+public interface XmlRpcHttpClientConfig extends XmlRpcHttpRequestConfig {
+	/** Returns the HTTP servers URL.
+	 * @return XML-RPC servers URL; for example, this may be the URL of a
+	 * servlet
+	 */
+	URL getServerURL();
+    
+    /**
+     * Returns the user agent header to use 
+     * @return the http user agent header to set when doing xmlrpc requests
+     */
+    String getUserAgent();
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcHttpTransport.java

@@ -0,0 +1,147 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.UnsupportedEncodingException;
+import java.lang.reflect.UndeclaredThrowableException;
+import java.net.URL;
+import java.util.Properties;
+
+import org.xbib.netty.http.xmlrpc.common.XmlRpcException;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcRequest;
+import org.xbib.netty.http.xmlrpc.common.util.HttpUtil;
+import org.xml.sax.SAXException;
+
+
+/** Abstract base implementation of an HTTP transport. Base class for the
+ * concrete implementations, like {@link XmlRpcSunHttpTransport},
+ * or {@link XmlRpcCommonsTransport}.
+ */
+public abstract class XmlRpcHttpTransport extends XmlRpcStreamTransport {
+    protected class ByteArrayReqWriter implements ReqWriter {
+        private final ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        ByteArrayReqWriter(XmlRpcRequest pRequest)
+                throws XmlRpcException, IOException, SAXException {
+            new ReqWriterImpl(pRequest).write(baos);
+        }
+
+        protected int getContentLength() {
+            return baos.size();
+        }
+
+        public void write(OutputStream pStream) throws IOException {
+            try {
+                baos.writeTo(pStream);
+                pStream.close();
+                pStream = null;
+            } finally {
+                if (pStream != null) { try { pStream.close(); } catch (Throwable ignore) {} }
+            }
+        }
+    }
+
+    /** The user agent string.
+     */
+    public static final String USER_AGENT;
+    static {
+        final String p = "XmlRpcClient.properties";
+        final URL url = XmlRpcHttpTransport.class.getResource(p);
+        if (url == null) {
+            throw new IllegalStateException("Failed to locate resource: " + p);
+        }
+        InputStream stream = null;
+        try {
+            stream = url.openStream();
+            final Properties props = new Properties();
+            props.load(stream);
+            USER_AGENT = props.getProperty("user.agent");
+            if (USER_AGENT == null  ||  USER_AGENT.trim().length() == 0) {
+                throw new IllegalStateException("The property user.agent is not set.");
+            }
+            stream.close();
+            stream = null;
+        } catch (IOException e) {
+            throw new UndeclaredThrowableException(e, "Failed to load resource " + url + ": " + e.getMessage());
+        } finally {
+            if (stream != null) { try { stream.close(); } catch (Throwable t) { /* Ignore me */ } }
+        }
+    }
+
+    private String userAgent;
+
+
+	protected XmlRpcHttpTransport(XmlRpcClient pClient, String pUserAgent) {
+		super(pClient);
+		userAgent = pUserAgent;
+	}
+
+	protected String getUserAgent() { return userAgent; }
+
+	protected abstract void setRequestHeader(String pHeader, String pValue);
+
+	protected void setCredentials(XmlRpcHttpClientConfig pConfig)
+			throws XmlRpcClientException {
+		String auth;
+		try {
+			auth = HttpUtil.encodeBasicAuthentication(pConfig.getBasicUserName(),
+													  pConfig.getBasicPassword(),
+													  pConfig.getBasicEncoding());
+		} catch (UnsupportedEncodingException e) {
+			throw new XmlRpcClientException("Unsupported encoding: " + pConfig.getBasicEncoding(), e);
+		}
+		if (auth != null) {
+			setRequestHeader("Authorization", "Basic " + auth);
+		}
+	}
+
+	protected void setContentLength(int pLength) {
+		setRequestHeader("Content-Length", Integer.toString(pLength));
+	}
+
+	protected void setCompressionHeaders(XmlRpcHttpClientConfig pConfig) {
+		if (pConfig.isGzipCompressing()) {
+			setRequestHeader("Content-Encoding", "gzip");
+		}
+		if (pConfig.isGzipRequesting()) {
+			setRequestHeader("Accept-Encoding", "gzip");
+		}
+	}
+
+	protected void initHttpHeaders(XmlRpcRequest pRequest) throws XmlRpcClientException {
+		XmlRpcHttpClientConfig config = (XmlRpcHttpClientConfig) pRequest.getConfig();
+		setRequestHeader("Content-Type", "text/xml");
+        if(config.getUserAgent() != null)
+            setRequestHeader("User-Agent", config.getUserAgent());
+        else
+            setRequestHeader("User-Agent", getUserAgent());
+		setCredentials(config);
+		setCompressionHeaders(config);
+	}
+
+	public Object sendRequest(XmlRpcRequest pRequest) throws XmlRpcException {
+		initHttpHeaders(pRequest);
+		return super.sendRequest(pRequest);
+	}
+
+	protected boolean isUsingByteArrayOutput(XmlRpcHttpClientConfig pConfig) {
+		return !pConfig.isEnabledForExtensions()
+			|| !pConfig.isContentLengthOptional();
+	}
+
+	protected ReqWriter newReqWriter(XmlRpcRequest pRequest)
+			throws XmlRpcException, IOException, SAXException {
+		final XmlRpcHttpClientConfig config = (XmlRpcHttpClientConfig) pRequest.getConfig();
+        if (isUsingByteArrayOutput(config)) {
+            ByteArrayReqWriter reqWriter = new ByteArrayReqWriter(pRequest);
+            setContentLength(reqWriter.getContentLength());
+            if (isCompressingRequest(config)) {
+                return new GzipReqWriter(reqWriter);
+            }
+            return reqWriter;
+		} else {
+			return super.newReqWriter(pRequest);
+		}
+	}
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcHttpTransportException.java

@@ -0,0 +1,57 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import org.xbib.netty.http.xmlrpc.common.XmlRpcException;
+
+/**
+ * Exception thrown if the HTTP status code sent by the server
+ * indicates that the request could not be processed. In
+ * general, the 400 and 500 level HTTP status codes will
+ * result in an XmlRpcHttpTransportException being thrown.
+ */
+public class XmlRpcHttpTransportException extends XmlRpcException {
+    private static final long serialVersionUID = -6933992871198450027L;
+
+    private final int status;
+    private final String statusMessage;
+    
+    /**
+     * Creates a new instance with the specified HTTP status code
+     * and HTTP status message.
+     * @param pCode The HTTP status code
+     * @param pMessage The HTTP status message returned by the HTTP server
+     */
+    public XmlRpcHttpTransportException(int pCode, String pMessage) {
+        this(pCode, pMessage, "HTTP server returned unexpected status: " + pMessage);
+    }
+    
+    /**
+     * Construct a new XmlRpcHttpTransportException with the specified HTTP status code, 
+     * HTTP status message, and exception message.
+     * @param httpStatusCode the HTTP status code
+     * @param httpStatusMessage the HTTP status message returned by the HTTP server
+     * @param message the exception message.
+     */
+    public XmlRpcHttpTransportException(int httpStatusCode, String httpStatusMessage, String message) {
+        super( message );
+        this.status = httpStatusCode;
+        this.statusMessage = httpStatusMessage;
+    }
+    
+    /**
+     * Get the HTTP status code that resulted in this exception.
+     * @return the HTTP status code that resulted in this exception.
+     */
+    public int getStatusCode()
+    {
+        return status;
+    }
+    
+    /**
+     * Get the status message returned by the HTTP server.
+     * @return the status message returned by the HTTP server.
+     */
+    public String getStatusMessage()
+    {
+        return statusMessage;
+    }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcIOException.java

@@ -0,0 +1,28 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import java.io.IOException;
+
+/** This is a subclass of {@link IOException}, which
+ * allows to attach a linked exception. Throwing this
+ * particular instance of {@link IOException} allows
+ * to catch it and throw the linked exception instead.
+ */
+public class XmlRpcIOException extends IOException {
+	private static final long serialVersionUID = -7704704099502077919L;
+	private final Throwable linkedException;
+
+	/** Creates a new instance of {@link XmlRpcIOException}
+	 * with the given cause.
+	 */
+	public XmlRpcIOException(Throwable t) {
+		super(t.getMessage());
+		linkedException = t;
+	}
+
+	/** Returns the linked exception, which is the actual
+	 * cause for this exception.
+	 */
+	public Throwable getLinkedException() {
+		return linkedException;
+	}
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcLite14HttpTransport.java

@@ -0,0 +1,48 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import java.io.IOException;
+import java.net.Socket;
+import java.net.UnknownHostException;
+
+import javax.net.ssl.SSLSocketFactory;
+
+/**
+ * A "light" HTTP transport implementation for Java 1.4.
+ */
+public class XmlRpcLite14HttpTransport extends XmlRpcLiteHttpTransport {
+    private SSLSocketFactory sslSocketFactory;
+
+    /**
+     * Creates a new instance.
+     * @param pClient The client controlling this instance.
+     */
+    public XmlRpcLite14HttpTransport(XmlRpcClient pClient) {
+        super(pClient);
+    }
+
+    /**
+     * Sets the SSL Socket Factory to use for https connections.
+     */
+    public SSLSocketFactory getSSLSocketFactory() {
+        return sslSocketFactory;
+    }
+
+    /**
+     * Returns the SSL Socket Factory to use for https connections.
+     */
+    public void setSSLSocketFactory(SSLSocketFactory pSSLSocketFactory) {
+        sslSocketFactory = pSSLSocketFactory;
+    }
+
+    protected Socket newSocket(boolean pSSL, String pHostName, int pPort) throws UnknownHostException, IOException {
+        if (pSSL) {
+            SSLSocketFactory sslSockFactory = getSSLSocketFactory();
+            if (sslSockFactory == null) {
+                sslSockFactory = (SSLSocketFactory) SSLSocketFactory.getDefault();
+            }
+            return sslSockFactory.createSocket(pHostName, pPort);
+        } else {
+            return super.newSocket(pSSL, pHostName, pPort);
+        }
+    }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcLite14HttpTransportFactory.java

@@ -0,0 +1,39 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import javax.net.ssl.SSLSocketFactory;
+
+/**
+ * Java 1.4 specific factory for the lite HTTP transport,
+ * {@link XmlRpcLiteHttpTransport}.
+ */
+public class XmlRpcLite14HttpTransportFactory extends XmlRpcLiteHttpTransportFactory {
+    private SSLSocketFactory sslSocketFactory;
+
+    /**
+     * Creates a new instance.
+     * @param pClient The client, which will invoke the factory.
+     */
+    public XmlRpcLite14HttpTransportFactory(XmlRpcClient pClient) {
+        super(pClient);
+    }
+
+    /**
+     * Sets the SSL Socket Factory to use for https connections.
+     */
+    public SSLSocketFactory getSSLSocketFactory() {
+        return sslSocketFactory;
+    }
+
+    /**
+     * Returns the SSL Socket Factory to use for https connections.
+     */
+    public void setSSLSocketFactory(SSLSocketFactory pSSLSocketFactory) {
+        sslSocketFactory = pSSLSocketFactory;
+    }
+
+    public XmlRpcTransport getTransport() {
+        XmlRpcLite14HttpTransport transport = new XmlRpcLite14HttpTransport(getClient());
+        transport.setSSLSocketFactory(sslSocketFactory);
+        return transport;
+    }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcLiteHttpTransport.java

@@ -0,0 +1,260 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.UnsupportedEncodingException;
+import java.net.ConnectException;
+import java.net.Socket;
+import java.net.URL;
+import java.net.UnknownHostException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.StringTokenizer;
+
+import org.xbib.netty.http.xmlrpc.common.XmlRpcException;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcRequest;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcStreamRequestConfig;
+import org.xbib.netty.http.xmlrpc.common.util.HttpUtil;
+import org.xbib.netty.http.xmlrpc.common.util.LimitedInputStream;
+import org.xml.sax.SAXException;
+
+/**
+ * A "light" HTTP transport implementation.
+ */
+public class XmlRpcLiteHttpTransport extends XmlRpcHttpTransport {
+    private static final String userAgent = USER_AGENT + " (Lite HTTP Transport)";
+    private boolean ssl;
+    private String hostname;
+    private String host;
+    private int port;
+    private String uri;
+    private Socket socket;
+    private OutputStream output;
+    private InputStream input;
+    private final Map<String, Object> headers = new HashMap<>();
+    private boolean responseGzipCompressed = false;
+    private XmlRpcHttpClientConfig config;
+
+    /**
+     * Creates a new instance.
+     * @param pClient The client controlling this instance.
+     */
+    public XmlRpcLiteHttpTransport(XmlRpcClient pClient) {
+        super(pClient, userAgent);
+    }
+
+    public Object sendRequest(XmlRpcRequest pRequest) throws XmlRpcException {
+        config = (XmlRpcHttpClientConfig) pRequest.getConfig();
+        URL url = config.getServerURL();
+        ssl = "https".equals(url.getProtocol());
+        hostname = url.getHost();
+        int p = url.getPort();
+        port = p < 1 ? 80 : p;
+        String u = url.getFile();
+        uri = (u == null  ||  "".equals(u)) ? "/" : u;
+        host = port == 80 ? hostname : hostname + ":" + port;
+        headers.put("Host", host);
+        return super.sendRequest(pRequest);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    protected void setRequestHeader(String pHeader, String pValue) {
+        Object value = headers.get(pHeader);
+        if (value == null) {
+            headers.put(pHeader, pValue);
+        } else {
+            List<Object> list;
+            if (value instanceof String) {
+                list = new ArrayList<>();
+                list.add(value);
+                headers.put(pHeader, list);
+            } else {
+                list = (List) value;
+            }
+            list.add(pValue);
+        }
+    }
+
+    @Override
+    protected void close() throws XmlRpcClientException {
+        IOException e = null;
+        if (input != null) {
+            try {
+                input.close();
+            } catch (IOException ex) {
+                e = ex;
+            }
+        }
+        if (output != null) {
+            try {
+                output.close();
+            } catch (IOException ex) {
+                if (e != null) {
+                    e = ex;
+                }
+            }
+        }
+        if (socket != null) {
+            try {
+                socket.close();
+            } catch (IOException ex) {
+                if (e != null) {
+                    e = ex;
+                }
+            }
+        }
+        if (e != null) {
+            throw new XmlRpcClientException("Failed to close connection: " + e.getMessage(), e);
+        }
+    }
+
+    private OutputStream getOutputStream() throws XmlRpcException {
+        try {
+            final int retries = 3;
+            final int delayMillis = 100;
+
+            for (int tries = 0;  ;  tries++) {
+                try {
+                    socket = newSocket(ssl, hostname, port);
+                    output = new BufferedOutputStream(socket.getOutputStream()){
+                        /** Closing the output stream would close the whole socket, which we don't want,
+                         * because the don't want until the request is processed completely.
+                         * A close will later occur within
+                         * {@link XmlRpcLiteHttpTransport#close()}.
+                         */
+                        @Override
+                        public void close() throws IOException {
+                            flush();
+                            socket.shutdownOutput();
+                        }
+                    };
+                    break;
+                } catch (ConnectException e) {
+                    if (tries >= retries) {
+                        throw new XmlRpcException("Failed to connect to "
+                                + hostname + ":" + port + ": " + e.getMessage(), e);
+                    } else {
+                        try {
+                            Thread.sleep(delayMillis);
+                        } catch (InterruptedException ignore) {
+                        }
+                    }
+                }
+            }
+            sendRequestHeaders(output);
+            return output;
+        } catch (IOException e) {
+            throw new XmlRpcException("Failed to open connection to "
+                    + hostname + ":" + port + ": " + e.getMessage(), e);
+        }
+    }
+
+    protected Socket newSocket(boolean pSSL, String pHostName, int pPort) throws UnknownHostException, IOException {
+        if (pSSL) {
+            throw new IOException("Unable to create SSL connections, use the XmlRpcLite14HttpTransportFactory.");
+        }
+        return new Socket(pHostName, pPort);
+    }
+
+    private byte[] toHTTPBytes(String pValue) throws UnsupportedEncodingException {
+        return pValue.getBytes(StandardCharsets.US_ASCII);
+    }
+
+    private void sendHeader(OutputStream pOut, String pKey, String pValue) throws IOException {
+        pOut.write(toHTTPBytes(pKey + ": " + pValue + "\r\n"));
+    }
+
+    @SuppressWarnings("unchecked")
+    private void sendRequestHeaders(OutputStream pOut) throws IOException {
+        pOut.write(("POST " + uri + " HTTP/1.0\r\n").getBytes(StandardCharsets.US_ASCII));
+        for (Object o : headers.entrySet()) {
+            Map.Entry<String, Object> entry = (Map.Entry) o;
+            String key = entry.getKey();
+            Object value = entry.getValue();
+            if (value instanceof String) {
+                sendHeader(pOut, key, (String) value);
+            } else {
+                List<Object> list = (List) value;
+                for (Object item : list) {
+                    sendHeader(pOut, key, (String) item);
+                }
+            }
+        }
+        pOut.write(toHTTPBytes("\r\n"));
+    }
+
+    @Override
+    protected boolean isResponseGzipCompressed(XmlRpcStreamRequestConfig pConfig) {
+        return responseGzipCompressed;
+    }
+
+    @Override
+    protected InputStream getInputStream() throws XmlRpcException {
+        final byte[] buffer = new byte[2048];
+        try {
+            // If reply timeout specified, set the socket timeout accordingly
+            if (config.getReplyTimeout() != 0)
+                socket.setSoTimeout(config.getReplyTimeout());
+            input = new BufferedInputStream(socket.getInputStream());
+            // start reading  server response headers
+            String line = HttpUtil.readLine(input, buffer);
+            StringTokenizer tokens = new StringTokenizer(line);
+            tokens.nextToken(); // Skip HTTP version
+            String statusCode = tokens.nextToken();
+            String statusMsg = tokens.nextToken("\n\r");
+            final int code;
+            try {
+                code = Integer.parseInt(statusCode);
+            } catch (NumberFormatException e) {
+                throw new XmlRpcClientException("Server returned invalid status code: "
+                        + statusCode + " " + statusMsg, null);
+            }
+            if (code < 200  ||  code > 299) {
+                throw new XmlRpcHttpTransportException(code, statusMsg);
+            }
+            int contentLength = -1;
+            for (;;) {
+                line = HttpUtil.readLine(input, buffer);
+                if ("".equals(line)) {
+                    break;
+                }
+                line = line.toLowerCase();
+                if (line.startsWith("content-length:")) {
+                    contentLength = Integer.parseInt(line.substring("content-length:".length()).trim());
+                } else if (line.startsWith("content-encoding:")) {
+                    responseGzipCompressed = HttpUtil.isUsingGzipEncoding(line.substring("content-encoding:".length()));
+                }
+            }
+            InputStream result;
+            if (contentLength == -1) {
+                result = input;
+            } else {
+                result = new LimitedInputStream(input, contentLength);
+            }
+            return result;
+        } catch (IOException e) {
+            throw new XmlRpcClientException("Failed to read server response: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    protected boolean isUsingByteArrayOutput(XmlRpcHttpClientConfig pConfig) {
+        boolean result = super.isUsingByteArrayOutput(pConfig);
+        if (!result) {
+            throw new IllegalStateException("The Content-Length header is required with HTTP/1.0, and HTTP/1.1 is unsupported by the Lite HTTP Transport.");
+        }
+        return result;
+    }
+
+    @Override
+    protected void writeRequest(ReqWriter pWriter) throws XmlRpcException, IOException, SAXException {
+        pWriter.write(getOutputStream());
+    }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcLiteHttpTransportFactory.java

@@ -0,0 +1,16 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+/** Factory for the lite HTTP transport,
+ * {@link XmlRpcLiteHttpTransport}.
+ */
+public class XmlRpcLiteHttpTransportFactory extends XmlRpcTransportFactoryImpl {
+	/**
+	 * Creates a new instance.
+	 * @param pClient The client, which will invoke the factory.
+	 */
+	public XmlRpcLiteHttpTransportFactory(XmlRpcClient pClient) {
+		super(pClient);
+	}
+
+	public XmlRpcTransport getTransport() { return new XmlRpcLiteHttpTransport(getClient()); }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcLocalClientConfig.java

@@ -0,0 +1,12 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import org.xbib.netty.http.xmlrpc.common.XmlRpcRequestProcessorFactory;
+
+/**
+ * Interface of a client configuration for local rpc calls. Local
+ * rpc calls are mainly useful for testing, because you don't need
+ * a running server.
+ */
+public interface XmlRpcLocalClientConfig extends XmlRpcClientConfig,
+		XmlRpcRequestProcessorFactory {
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcLocalStreamTransport.java

@@ -0,0 +1,61 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.xbib.netty.http.xmlrpc.common.LocalStreamConnection;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcException;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcRequest;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcStreamRequestConfig;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcStreamRequestProcessor;
+import org.xml.sax.SAXException;
+
+/** Another local transport for debugging and testing. This one is
+ * similar to the {@link XmlRpcLocalTransport},
+ * except that it adds request serialization. In other words, it is
+ * particularly well suited for development and testing of XML serialization
+ * and parsing.
+ */
+public class XmlRpcLocalStreamTransport extends XmlRpcStreamTransport {
+    private final XmlRpcStreamRequestProcessor localServer;
+    private LocalStreamConnection conn;
+    private XmlRpcRequest request;
+
+    /** Creates a new instance.
+     * @param pClient The client, which is controlling the transport.
+     * @param pServer An instance of {@link XmlRpcStreamRequestProcessor}.
+     */
+    public XmlRpcLocalStreamTransport(XmlRpcClient pClient,
+                                      XmlRpcStreamRequestProcessor pServer) {
+        super(pClient);
+        localServer = pServer;
+    }
+
+    protected boolean isResponseGzipCompressed(XmlRpcStreamRequestConfig pConfig) {
+        return pConfig.isGzipRequesting();
+    }
+
+    protected void close() throws XmlRpcClientException {
+    }
+
+    protected InputStream getInputStream() throws XmlRpcException {
+        localServer.execute(conn.getConfig(), conn.getServerStreamConnection());
+        return new ByteArrayInputStream(conn.getResponse().toByteArray());
+    }
+
+    protected ReqWriter newReqWriter(XmlRpcRequest pRequest)
+            throws XmlRpcException, IOException, SAXException {
+        request = pRequest;
+        return super.newReqWriter(pRequest);
+    }
+
+    protected void writeRequest(ReqWriter pWriter)
+            throws XmlRpcException, IOException, SAXException {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        pWriter.write(baos);
+        XmlRpcStreamRequestConfig config = (XmlRpcStreamRequestConfig) request.getConfig();
+        conn = new LocalStreamConnection(config, new ByteArrayInputStream(baos.toByteArray()));
+    }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcLocalStreamTransportFactory.java

@@ -0,0 +1,29 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import org.xbib.netty.http.xmlrpc.common.XmlRpcStreamRequestProcessor;
+
+/**
+ * Another local transport factory for debugging and testing. This one is
+ * similar to the {@link XmlRpcLocalTransportFactory},
+ * except that it adds request serialization. In other words, it is
+ * particularly well suited for development and testing of XML serialization
+ * and parsing.
+ */
+public class XmlRpcLocalStreamTransportFactory extends XmlRpcStreamTransportFactory {
+
+    private final XmlRpcStreamRequestProcessor server;
+
+    /** Creates a new instance.
+     * @param pClient The client controlling the factory.
+     * @param pServer An instance of {@link XmlRpcStreamRequestProcessor}.
+     */
+    public XmlRpcLocalStreamTransportFactory(XmlRpcClient pClient,
+                                             XmlRpcStreamRequestProcessor pServer) {
+        super(pClient);
+        server = pServer;
+    }
+
+    public XmlRpcTransport getTransport() {
+        return new XmlRpcLocalStreamTransport(getClient(), server);
+    }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcLocalTransport.java

@@ -0,0 +1,97 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import org.xbib.netty.http.xmlrpc.common.TypeConverter;
+import org.xbib.netty.http.xmlrpc.common.TypeConverterFactory;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcConfig;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcException;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcExtensionException;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcRequest;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcRequestProcessor;
+
+import java.util.Collection;
+import java.util.Date;
+import java.util.Map;
+
+/**
+ * The default implementation of a local transport.
+ */
+public class XmlRpcLocalTransport extends XmlRpcTransportImpl {
+
+    /**
+     * Creates a new instance.
+     * @param pClient The client, which creates the transport.
+     */
+    public XmlRpcLocalTransport(XmlRpcClient pClient) {
+        super(pClient);
+    }
+
+    @SuppressWarnings("unchecked")
+    private boolean isExtensionType(Object pObject) {
+        if (pObject == null) {
+            return true;
+        } else if (pObject instanceof Object[]) {
+            Object[] objects = (Object[]) pObject;
+            for (Object object : objects) {
+                if (isExtensionType(object)) {
+                    return true;
+                }
+            }
+            return false;
+        } else if (pObject instanceof Collection) {
+            for (Object o : ((Collection) pObject)) {
+                if (isExtensionType(o)) {
+                    return true;
+                }
+            }
+            return false;
+        } else if (pObject instanceof Map) {
+            Map<String, Object> map = (Map) pObject;
+            for (Object o : map.entrySet()) {
+                Map.Entry<String, Object> entry = (Map.Entry) o;
+                if (isExtensionType(entry.getKey()) || isExtensionType(entry.getValue())) {
+                    return true;
+                }
+            }
+            return false;
+        } else {
+            return !(pObject instanceof Integer
+                    ||  pObject instanceof Date
+                    ||  pObject instanceof String
+                    ||  pObject instanceof byte[]
+                    ||  pObject instanceof Double);
+        }
+    }
+
+    public Object sendRequest(XmlRpcRequest pRequest) throws XmlRpcException {
+        XmlRpcConfig config = pRequest.getConfig();
+        if (!config.isEnabledForExtensions()) {
+            for (int i = 0;  i < pRequest.getParameterCount();  i++) {
+                if (isExtensionType(pRequest.getParameter(i))) {
+                    throw new XmlRpcExtensionException("Parameter " + i + " has invalid type, if isEnabledForExtensions() == false");
+                }
+            }
+        }
+        final XmlRpcRequestProcessor server = ((XmlRpcLocalClientConfig) config).getXmlRpcServer();
+        Object result;
+        try {
+            result = server.execute(pRequest);
+        } catch (XmlRpcException t) {
+            throw t;
+        } catch (Throwable t) {
+            throw new XmlRpcClientException("Failed to invoke method " + pRequest.getMethodName()
+                    + ": " + t.getMessage(), t);
+        }
+        if (!config.isEnabledForExtensions()) {
+            if (isExtensionType(result)) {
+                throw new XmlRpcExtensionException("Result has invalid type, if isEnabledForExtensions() == false");
+            }
+        }
+
+        if (result == null) {
+            return null;
+        }
+        final TypeConverterFactory typeConverterFactory = server.getTypeConverterFactory();
+        final TypeConverter typeConverter = typeConverterFactory.getTypeConverter(result.getClass());
+        return typeConverter.backConvert(result);
+    }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcLocalTransportFactory.java

@@ -0,0 +1,25 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+/**
+ * <p>A transport factory being used for local XML-RPC calls. Local XML-RPC
+ * calls are mainly useful for development and unit testing: Both client
+ * and server are runing within the same JVM and communication is implemented
+ * in simple method invokcations.</p>
+ * <p>This class is thread safe and the returned instance of
+ * {@link XmlRpcTransport} will always return the
+ * same object, an instance of {@link XmlRpcLocalTransport}</p>
+ */
+public class XmlRpcLocalTransportFactory extends XmlRpcTransportFactoryImpl {
+
+    /**
+     * Creates a new instance, operated by the given client.
+     * @param pClient The client, which will invoke the factory.
+     */
+    public XmlRpcLocalTransportFactory(XmlRpcClient pClient) {
+        super(pClient);
+    }
+
+    private final XmlRpcTransport LOCAL_TRANSPORT = new XmlRpcLocalTransport(getClient());
+
+    public XmlRpcTransport getTransport() { return LOCAL_TRANSPORT; }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcStreamTransport.java

@@ -0,0 +1,195 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.zip.GZIPInputStream;
+import java.util.zip.GZIPOutputStream;
+
+import org.xbib.netty.http.xmlrpc.common.XmlRpcException;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcRequest;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcStreamConfig;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcStreamRequestConfig;
+import org.xbib.netty.http.xmlrpc.common.parser.XmlRpcResponseParser;
+import org.xbib.netty.http.xmlrpc.common.serializer.XmlRpcWriter;
+import org.xbib.netty.http.xmlrpc.common.util.SAXParsers;
+import org.xml.sax.ContentHandler;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xml.sax.XMLReader;
+
+/**
+ * Implementation of a transport class, which is based on an output
+ * stream for sending the request and an input stream for receiving
+ * the response,
+ */
+public abstract class XmlRpcStreamTransport extends XmlRpcTransportImpl {
+
+    protected interface ReqWriter {
+        /**
+         * Writes the requests data to the given output stream.
+         * The method ensures, that the target is being closed.
+         */
+        void write(OutputStream pStream) throws XmlRpcException, IOException, SAXException;
+    }
+
+    protected class ReqWriterImpl implements ReqWriter {
+        private final XmlRpcRequest request;
+
+        protected ReqWriterImpl(XmlRpcRequest pRequest) {
+            request = pRequest;
+        }
+
+        /**
+         * Writes the requests uncompressed XML data to the given
+         * output stream. Ensures, that the output stream is being
+         * closed.
+         */
+        public void write(OutputStream pStream)
+                throws XmlRpcException, IOException, SAXException {
+            final XmlRpcStreamConfig config = (XmlRpcStreamConfig) request.getConfig();
+            try {
+                ContentHandler h = getClient().getXmlWriterFactory().getXmlWriter(config, pStream);
+                XmlRpcWriter xw = new XmlRpcWriter(config, h, getClient().getTypeFactory());
+                xw.write(request);
+                pStream.close();
+                pStream = null;
+            } finally {
+                if (pStream != null) { try { pStream.close(); } catch (Throwable ignore) {} }
+            }
+        }
+    }
+
+    protected class GzipReqWriter implements ReqWriter {
+        private final ReqWriter reqWriter;
+        protected GzipReqWriter(ReqWriter pReqWriter) {
+            reqWriter = pReqWriter;
+        }
+
+        public void write(OutputStream pStream) throws XmlRpcException, IOException, SAXException {
+            try {
+                GZIPOutputStream gStream = new GZIPOutputStream(pStream);
+                reqWriter.write(gStream);
+                pStream.close();
+                pStream = null;
+            } catch (IOException e) {
+                throw new XmlRpcException("Failed to write request: " + e.getMessage(), e);
+            } finally {
+                if (pStream != null) { try { pStream.close(); } catch (Throwable ignore) {} }
+            }
+        }
+    }
+
+    /**
+     * Creates a new instance on behalf of the given client.
+     */
+    protected XmlRpcStreamTransport(XmlRpcClient pClient) {
+        super(pClient);
+    }
+
+    /**
+     * Closes the connection and ensures, that all resources are being
+     * released.
+     */
+    protected abstract void close() throws XmlRpcClientException;
+
+    /**
+     * Returns, whether the response is gzip compressed.
+     * @param pConfig The clients configuration.
+     * @return Whether the response stream is gzip compressed.
+     */
+    protected abstract boolean isResponseGzipCompressed(XmlRpcStreamRequestConfig pConfig);
+
+    /**
+     * Returns the input stream, from which the response is
+     * being read.
+     */
+    protected abstract InputStream getInputStream() throws XmlRpcException;
+
+    protected boolean isCompressingRequest(XmlRpcStreamRequestConfig pConfig) {
+        return pConfig.isEnabledForExtensions()
+                && pConfig.isGzipCompressing();
+    }
+
+    /**
+     * Creates a new instance of {@link ReqWriter}.
+     * @throws XmlRpcException Creating the instance failed.
+     * @throws IOException Creating the instance failed, because
+     *   an {@link IOException} occurs.
+     * @throws SAXException Creating the instance failed, because
+     *   the request could not be parsed.
+     */
+    protected ReqWriter newReqWriter(XmlRpcRequest pRequest)
+            throws XmlRpcException, IOException, SAXException {
+        ReqWriter reqWriter = new ReqWriterImpl(pRequest);
+        if (isCompressingRequest((XmlRpcStreamRequestConfig) pRequest.getConfig())) {
+            reqWriter = new GzipReqWriter(reqWriter);
+        }
+        return reqWriter;
+    }
+
+    protected abstract void writeRequest(ReqWriter pWriter)
+            throws XmlRpcException, IOException, SAXException;
+
+    public Object sendRequest(XmlRpcRequest pRequest) throws XmlRpcException {
+        XmlRpcStreamRequestConfig config = (XmlRpcStreamRequestConfig) pRequest.getConfig();
+        boolean closed = false;
+        try {
+            ReqWriter reqWriter = newReqWriter(pRequest);
+            writeRequest(reqWriter);
+            InputStream istream = getInputStream();
+            if (isResponseGzipCompressed(config)) {
+                istream = new GZIPInputStream(istream);
+            }
+            Object result = readResponse(config, istream);
+            closed = true;
+            close();
+            return result;
+        } catch (IOException e) {
+            throw new XmlRpcException("Failed to read server's response: "
+                    + e.getMessage(), e);
+        } catch (SAXException e) {
+            Exception ex = e.getException();
+            if (ex instanceof XmlRpcException) {
+                throw (XmlRpcException) ex;
+            }
+            throw new XmlRpcException("Failed to generate request: "
+                    + e.getMessage(), e);
+        } finally {
+            if (!closed) { try { close(); } catch (Throwable ignore) {} }
+        }
+    }
+
+    protected XMLReader newXMLReader() throws XmlRpcException {
+        return SAXParsers.newXMLReader();
+    }
+
+    protected Object readResponse(XmlRpcStreamRequestConfig pConfig, InputStream pStream) throws XmlRpcException {
+        InputSource isource = new InputSource(pStream);
+        XMLReader xr = newXMLReader();
+        XmlRpcResponseParser xp;
+        try {
+            xp = new XmlRpcResponseParser(pConfig, getClient().getTypeFactory());
+            xr.setContentHandler(xp);
+            xr.parse(isource);
+        } catch (SAXException e) {
+            throw new XmlRpcClientException("Failed to parse server's response: " + e.getMessage(), e);
+        } catch (IOException e) {
+            throw new XmlRpcClientException("Failed to read server's response: " + e.getMessage(), e);
+        }
+        if (xp.isSuccess()) {
+            return xp.getResult();
+        }
+        Throwable t = xp.getErrorCause();
+        if (t == null) {
+            throw new XmlRpcException(xp.getErrorCode(), xp.getErrorMessage());
+        }
+        if (t instanceof XmlRpcException) {
+            throw (XmlRpcException) t;
+        }
+        if (t instanceof RuntimeException) {
+            throw (RuntimeException) t;
+        }
+        throw new XmlRpcException(xp.getErrorCode(), xp.getErrorMessage(), t);
+    }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcStreamTransportFactory.java

@@ -0,0 +1,10 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+/**
+ * Abstract base implementation of a factory for stream transports.
+ */
+public abstract class XmlRpcStreamTransportFactory extends XmlRpcTransportFactoryImpl {
+	protected XmlRpcStreamTransportFactory(XmlRpcClient pClient) {
+		super(pClient);
+	}
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcSun14HttpTransport.java

@@ -0,0 +1,47 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import java.io.IOException;
+import java.net.URL;
+import java.net.URLConnection;
+import javax.net.ssl.HttpsURLConnection;
+import javax.net.ssl.SSLSocketFactory;
+
+/**
+ * Default implementation of an HTTP transport in Java 1.4, based on the
+ * {@link java.net.HttpURLConnection} class. Adds support for the
+ * {@link SSLSocketFactory}.
+ */
+public class XmlRpcSun14HttpTransport extends XmlRpcSunHttpTransport {
+    private SSLSocketFactory sslSocketFactory;
+
+    /**
+     * Creates a new instance.
+     * @param pClient The client controlling this instance.
+     */
+    public XmlRpcSun14HttpTransport(XmlRpcClient pClient) {
+        super(pClient);
+    }
+
+    /**
+     * Sets the SSLSocketFactory used to create secure sockets.
+     * @param pSocketFactory The SSLSocketFactory to use.
+     */
+    public void setSSLSocketFactory(SSLSocketFactory pSocketFactory) {
+        sslSocketFactory = pSocketFactory;
+    }
+
+    /**
+     * Returns the SSLSocketFactory used to create secure sockets.
+     */
+    public SSLSocketFactory getSSLSocketFactory() {
+        return sslSocketFactory;
+    }
+
+    protected URLConnection newURLConnection(URL pURL) throws IOException {
+        final URLConnection conn = super.newURLConnection(pURL);
+        final SSLSocketFactory sslSockFactory = getSSLSocketFactory();
+        if ((sslSockFactory != null) && (conn instanceof HttpsURLConnection))
+            ((HttpsURLConnection)conn).setSSLSocketFactory(sslSockFactory);
+        return conn;
+    }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcSun14HttpTransportFactory.java

@@ -0,0 +1,40 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import javax.net.ssl.SSLSocketFactory;
+
+/**
+ * Default implementation of an HTTP transport factory in Java 1.4, based
+ * on the {@link java.net.HttpURLConnection} class.
+ */
+public class XmlRpcSun14HttpTransportFactory extends XmlRpcTransportFactoryImpl {
+    private SSLSocketFactory sslSocketFactory;
+
+    /**
+     * Creates a new factory, which creates transports for the given client.
+     * @param pClient The client, which is operating the factory.
+     */
+    public XmlRpcSun14HttpTransportFactory(XmlRpcClient pClient) {
+        super(pClient);
+    }
+
+    /**
+     * Sets the SSLSocketFactory to be used by transports.
+     * @param pSocketFactory The SSLSocketFactory to use.
+     */
+    public void setSSLSocketFactory(SSLSocketFactory pSocketFactory) {
+        sslSocketFactory = pSocketFactory;
+    }
+
+    /**
+     * Returns the SSLSocketFactory to be used by transports.
+     */
+    public SSLSocketFactory getSSLSocketFactory() {
+        return sslSocketFactory;
+    }
+
+    public XmlRpcTransport getTransport() {
+        XmlRpcSun14HttpTransport transport = new XmlRpcSun14HttpTransport(getClient());
+        transport.setSSLSocketFactory(sslSocketFactory);
+        return transport;
+    }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcSun15HttpTransport.java

@@ -0,0 +1,66 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import org.xbib.netty.http.xmlrpc.common.XmlRpcRequest;
+
+import java.io.IOException;
+import java.net.Proxy;
+import java.net.URL;
+import java.net.URLConnection;
+
+import javax.net.ssl.HttpsURLConnection;
+import javax.net.ssl.SSLSocketFactory;
+
+/**
+ * Default implementation of an HTTP transport in Java 1.4, based on the
+ * {@link java.net.HttpURLConnection} class. Adds support for the
+ * {@link Proxy} class.
+ */
+public class XmlRpcSun15HttpTransport extends XmlRpcSun14HttpTransport {
+    /**
+     * Creates a new instance.
+     * @param pClient The client controlling this instance.
+     */
+    public XmlRpcSun15HttpTransport(XmlRpcClient pClient) {
+        super(pClient);
+    }
+
+    private Proxy proxy;
+
+    /**
+     * Sets the proxy to use.
+     */
+    public void setProxy(Proxy pProxy) {
+        proxy = pProxy;
+    }
+
+    /**
+     * Returns the proxy to use.
+     */
+    public Proxy getProxy() {
+        return proxy;
+    }
+
+    protected void initHttpHeaders(XmlRpcRequest pRequest)
+            throws XmlRpcClientException {
+        final XmlRpcHttpClientConfig config = (XmlRpcHttpClientConfig) pRequest.getConfig();
+        int connectionTimeout = config.getConnectionTimeout();
+        if (connectionTimeout > 0) {
+            getURLConnection().setConnectTimeout(connectionTimeout);
+        }
+        int replyTimeout = config.getReplyTimeout();
+        if (replyTimeout > 0) {
+            getURLConnection().setReadTimeout(replyTimeout);
+        }
+        super.initHttpHeaders(pRequest);
+    }
+
+    protected URLConnection newURLConnection(URL pURL) throws IOException {
+        final Proxy prox = getProxy();
+        final URLConnection conn = prox == null ? pURL.openConnection() : pURL.openConnection(prox);
+        final SSLSocketFactory sslSockFactory = getSSLSocketFactory();
+        if (sslSockFactory != null  &&  conn instanceof HttpsURLConnection) {
+            ((HttpsURLConnection)conn).setSSLSocketFactory(sslSockFactory);
+        }
+        return conn;
+    }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcSun15HttpTransportFactory.java

@@ -0,0 +1,64 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.xbib.netty.http.xmlrpc.client;
+
+import java.net.InetSocketAddress;
+import java.net.Proxy;
+
+/**
+ * Default implementation of an HTTP transport in Java 1.5, based on the
+ * {@link java.net.HttpURLConnection} class.
+ */
+public class XmlRpcSun15HttpTransportFactory extends XmlRpcSun14HttpTransportFactory {
+    private Proxy proxy;
+
+    /**
+     * Creates a new factory, which creates transports for the given client.
+     * @param pClient The client, which is operating the factory.
+     */
+    public XmlRpcSun15HttpTransportFactory(XmlRpcClient pClient) {
+        super(pClient);
+    }
+
+    /**
+     * Sets the proxy to use.
+     * @param proxyHost The proxy hostname.
+     * @param proxyPort The proxy port number.
+     * @throws IllegalArgumentException if the proxyHost parameter is null or if
+     *     the proxyPort parameter is outside the range of valid port values.
+     */
+    public void setProxy(String proxyHost, int proxyPort) {
+        setProxy(new Proxy(Proxy.Type.HTTP,new InetSocketAddress(proxyHost,proxyPort)));
+    }
+
+    /**
+     * Sets the proxy to use.
+     * @param pProxy The proxy settings.
+     */
+    public void setProxy(Proxy pProxy) {
+        proxy = pProxy;
+    }
+
+    public XmlRpcTransport getTransport() {
+        XmlRpcSun15HttpTransport transport = new XmlRpcSun15HttpTransport(getClient());
+        transport.setSSLSocketFactory(getSSLSocketFactory());
+        transport.setProxy(proxy);
+        return transport;
+    }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcSunHttpTransport.java

@@ -0,0 +1,88 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.net.URLConnection;
+
+import org.xbib.netty.http.xmlrpc.common.XmlRpcException;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcRequest;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcStreamRequestConfig;
+import org.xbib.netty.http.xmlrpc.common.util.HttpUtil;
+import org.xml.sax.SAXException;
+
+/**
+ * Default implementation of an HTTP transport, based on the
+ * {@link HttpURLConnection} class.
+ */
+public class XmlRpcSunHttpTransport extends XmlRpcHttpTransport {
+	private static final String userAgent = USER_AGENT + " (Sun HTTP Transport)";
+	private URLConnection conn;
+
+	/** Creates a new instance.
+	 * @param pClient The client controlling this instance.
+	 */
+	public XmlRpcSunHttpTransport(XmlRpcClient pClient) {
+		super(pClient, userAgent);
+	}
+
+    protected URLConnection newURLConnection(URL pURL) throws IOException {
+        return pURL.openConnection();
+    }
+
+    /**
+     * For use by subclasses.
+     */
+    protected URLConnection getURLConnection() {
+        return conn;
+    }
+
+    public Object sendRequest(XmlRpcRequest pRequest) throws XmlRpcException {
+		XmlRpcHttpClientConfig config = (XmlRpcHttpClientConfig) pRequest.getConfig();
+		try {
+		    final URLConnection c = conn = newURLConnection(config.getServerURL());
+			c.setUseCaches(false);
+			c.setDoInput(true);
+			c.setDoOutput(true);
+		} catch (IOException e) {
+			throw new XmlRpcException("Failed to create URLConnection: " + e.getMessage(), e);
+		}
+		return super.sendRequest(pRequest);
+	}
+
+	protected void setRequestHeader(String pHeader, String pValue) {
+	    getURLConnection().setRequestProperty(pHeader, pValue);
+	}
+
+	protected void close() throws XmlRpcClientException {
+	    final URLConnection c = getURLConnection();
+		if (c instanceof HttpURLConnection) {
+			((HttpURLConnection) c).disconnect();
+		}
+	}
+
+	protected boolean isResponseGzipCompressed(XmlRpcStreamRequestConfig pConfig) {
+		return HttpUtil.isUsingGzipEncoding(getURLConnection().getHeaderField("Content-Encoding"));
+	}
+
+	protected InputStream getInputStream() throws XmlRpcException {
+		try {
+		    URLConnection connection = getURLConnection();
+		    if ( connection instanceof HttpURLConnection ) {
+		        HttpURLConnection httpConnection = (HttpURLConnection) connection;
+		        int responseCode = httpConnection.getResponseCode();
+		        if (responseCode < 200  ||  responseCode > 299) {
+		            throw new XmlRpcHttpTransportException(responseCode, httpConnection.getResponseMessage());
+		        }
+		    }
+			return connection.getInputStream();
+		} catch (IOException e) {
+			throw new XmlRpcException("Failed to create input stream: " + e.getMessage(), e);
+		}
+	}
+
+	protected void writeRequest(ReqWriter pWriter) throws IOException, XmlRpcException, SAXException {
+        pWriter.write(getURLConnection().getOutputStream());
+	}
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcSunHttpTransportFactory.java

@@ -0,0 +1,17 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+/** Default implementation of a HTTP transport factory, based on the
+ * {@link java.net.HttpURLConnection} class.
+ */
+public class XmlRpcSunHttpTransportFactory extends XmlRpcTransportFactoryImpl {
+    /** Creates a new factory, which creates transports for the given client.
+	 * @param pClient The client, which is operating the factory.
+	 */
+	public XmlRpcSunHttpTransportFactory(XmlRpcClient pClient) {
+		super(pClient);
+	 }
+
+	public XmlRpcTransport getTransport() {
+	    return new XmlRpcSunHttpTransport(getClient());
+	}
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcTransport.java

@@ -0,0 +1,18 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+import org.xbib.netty.http.xmlrpc.common.XmlRpcException;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcRequest;
+
+/**
+ * <p>Interface from XML-RPC to an underlying transport, most likely based on HTTP.</p>
+ */
+public interface XmlRpcTransport {
+
+    /**  Send an XML-RPC message. This method is called to send a message to the
+     * other party.
+     * @param pRequest The request being performed.
+     * @return Result object, if invoking the remote method was successfull.
+     * @throws XmlRpcException Performing the request failed.
+     */
+    Object sendRequest(XmlRpcRequest pRequest) throws XmlRpcException;
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcTransportFactory.java

@@ -0,0 +1,14 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+/** Interface of an object creating instances of
+ * {@link XmlRpcTransport}. The implementation
+ * is typically based on singletons.
+ */
+public interface XmlRpcTransportFactory {
+    /** Returns an instance of {@link XmlRpcTransport}. This may
+     * be a singleton, but the caller should not depend on that:
+     * A new instance may as well be created for any request.
+     * @return The configured transport.
+     */
+    public XmlRpcTransport getTransport();
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcTransportFactoryImpl.java

@@ -0,0 +1,20 @@
+package org.xbib.netty.http.xmlrpc.client;
+
+/**
+ * Abstract base implementation of an {@link XmlRpcTransportFactory}.
+ */
+public abstract class XmlRpcTransportFactoryImpl implements XmlRpcTransportFactory {
+    private final XmlRpcClient client;
+
+    /** Creates a new instance.
+     * @param pClient The client, which will invoke the factory.
+     */
+    protected XmlRpcTransportFactoryImpl(XmlRpcClient pClient) {
+        client = pClient;
+    }
+
+    /** Returns the client operating this factory.
+     * @return The client.
+     */
+    public XmlRpcClient getClient() { return client; }
+}

netty-http-xmlrpc-client/src/main/java/org/xbib/netty/http/xmlrpc/client/XmlRpcTransportImpl.java

@@ -0,0 +1,38 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.xbib.netty.http.xmlrpc.client;
+
+
+/** Abstract base implementation of an {@link org.apache.xmlrpc.client.XmlRpcTransport}.
+ */
+public abstract class XmlRpcTransportImpl implements XmlRpcTransport {
+	private final XmlRpcClient client;
+
+	/** Creates a new instance.
+	 * @param pClient The client, which creates the transport.
+	 */
+	protected XmlRpcTransportImpl(XmlRpcClient pClient) {
+		client = pClient;
+	}
+
+	/** Returns the client, which created this transport.
+	 * @return The client.
+	 */
+	public XmlRpcClient getClient() { return client; }
+}

netty-http-xmlrpc-client/src/test/java/org/xbib/netty/http/xmlrpc/client/test/AuthenticationTest.java

@@ -0,0 +1,89 @@
+package org.xbib.netty.http.xmlrpc.client.test;
+
+import org.xbib.netty.http.xmlrpc.client.ClientFactory;
+import org.xbib.netty.http.xmlrpc.client.XmlRpcClient;
+import org.xbib.netty.http.xmlrpc.client.XmlRpcClientConfigImpl;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcException;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcHttpRequestConfig;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcRequest;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcRequestConfig;
+import org.xbib.netty.http.xmlrpc.server.AbstractReflectiveHandlerMapping;
+import org.xbib.netty.http.xmlrpc.server.XmlRpcHandlerMapping;
+
+import java.io.IOException;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Test case for supported authentication variants.
+ */
+public class AuthenticationTest extends XmlRpcTestCase {
+    private static final String PASSWORD = "98765432109876543210987654321098765432109876543210";
+    private static final String USER_NAME = "01234567890123456789012345678901234567890123456789"
+        + "\u00C4\u00D6\u00DC\u00F6\u00FC\u00E4\u00DF";
+
+    /** An interface, which is being implemented by the
+     * server.
+     */
+    public interface Adder {
+        /** Returns the sum of the given integers.
+         */
+        public int add(int pNum1, int pNum2);
+    }
+
+    /** Implementation of {@link DynamicProxyTest.Adder}, which is used by
+     * the server.
+     */
+    public static class AdderImpl implements Adder {
+        public int add(int pNum1, int pNum2) {
+            return pNum1 + pNum2;
+        }
+    }
+
+    protected XmlRpcHandlerMapping getHandlerMapping() throws IOException, XmlRpcException {
+        XmlRpcHandlerMapping mapping = getHandlerMapping("AuthenticationTest.properties");
+        ((AbstractReflectiveHandlerMapping) mapping).setAuthenticationHandler(new AbstractReflectiveHandlerMapping.AuthenticationHandler(){
+            public boolean isAuthorized(XmlRpcRequest pRequest)
+                    throws XmlRpcException {
+                XmlRpcRequestConfig config = pRequest.getConfig();
+                if (config instanceof XmlRpcHttpRequestConfig) {
+                    XmlRpcHttpRequestConfig httpRequestConfig = (XmlRpcHttpRequestConfig) config;
+                    return USER_NAME.equals(httpRequestConfig.getBasicUserName())
+                        &&  PASSWORD.equals(httpRequestConfig.getBasicPassword());
+                }
+                return true;
+            }
+        });
+        return mapping;
+    }
+
+    protected XmlRpcClientConfigImpl getConfig(ClientProvider pProvider)
+            throws Exception {
+        XmlRpcClientConfigImpl config = super.getConfig(pProvider);
+        config.setBasicUserName(USER_NAME);
+        config.setBasicPassword(PASSWORD);
+        return config;
+    }
+
+    private ClientFactory getClientFactory(ClientProvider pProvider) throws Exception {
+        XmlRpcClient client = pProvider.getClient();
+        client.setConfig(getConfig(pProvider));
+        return new ClientFactory(client);
+    }
+
+    /** Tests calling the {@link Adder#add(int,int)} method
+     * by using an object, which has been created by the
+     * {@link ClientFactory}.
+     */
+    public void testAdderCall() throws Exception {
+        for (int i = 0;  i < providers.length;  i++) {
+            testAdderCall(providers[i]);
+        }
+    }
+
+    private void testAdderCall(ClientProvider pProvider) throws Exception {
+        ClientFactory factory = getClientFactory(pProvider);
+        Adder adder = (Adder) factory.newInstance(Adder.class);
+        assertEquals(6, adder.add(2, 4));
+    }
+}

netty-http-xmlrpc-client/src/test/java/org/xbib/netty/http/xmlrpc/client/test/BaseTest.java

@@ -0,0 +1,906 @@
+package org.xbib.netty.http.xmlrpc.client.test;
+
+import java.io.IOException;
+import java.io.Serializable;
+import java.io.StringReader;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.TimeZone;
+
+import javax.xml.namespace.QName;
+import javax.xml.parsers.DocumentBuilderFactory;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.xbib.netty.http.xmlrpc.client.XmlRpcClient;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcException;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcExtensionException;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcInvocationException;
+import org.xbib.netty.http.xmlrpc.server.XmlRpcHandlerMapping;
+import org.xml.sax.InputSource;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+
+/**
+ * An abstract test case, to be implemented for the various
+ * transport classes.
+ */
+public class BaseTest extends XmlRpcTestCase {
+
+	/** The remote class being invoked by the test case.
+	 */
+	public static class Remote {
+		/** Returns the argument, multiplied by two.
+		 * @param pArg The argument being doubled.
+		 * @return The argument, multiplied by two.
+		 */
+		public int byteParam(byte pArg) { return pArg*2; }
+		/** Returns the argument, multiplied by two.
+		 * @param pArg The argument being doubled.
+		 * @return The argument, multiplied by two.
+		 */
+		public byte byteResult(byte pArg) { return (byte) (pArg*2); }
+		/** Returns the argument, multiplied by two.
+		 * @param pArg The argument being doubled.
+		 * @return The argument, multiplied by two.
+		 */
+		public int shortParam(short pArg) { return pArg*2; }
+		/** Returns the argument, multiplied by two.
+		 * @param pArg The argument being doubled.
+		 * @return The argument, multiplied by two.
+		 */
+		public short shortResult(short pArg) { return (short) (pArg*2); }
+		/** Returns the argument, multiplied by two.
+		 * @param pArg The argument being doubled.
+		 * @return The argument, multiplied by two.
+		 */
+		public int intParam(int pArg) { return pArg*2; }
+		/** Returns the argument, multiplied by two.
+		 * @param pArg The argument being doubled.
+		 * @return The argument, multiplied by two.
+		 */
+		public int longParam(long pArg) { return (int) (pArg*2); }
+		/** Returns the argument, multiplied by two.
+		 * @param pArg The argument being doubled.
+		 * @return The argument, multiplied by two.
+		 */
+		public long longResult(long pArg) { return pArg*2; }
+		/** Returns the argument, multiplied by two.
+		 * @param pArg The argument being doubled.
+		 * @return The argument, multiplied by two.
+		 */
+		public double floatParam(float pArg) { return pArg*2; }
+		/** Returns the argument, multiplied by two.
+		 * @param pArg The argument being doubled.
+		 * @return The argument, multiplied by two.
+		 */
+		public float floatResult(float pArg) { return pArg*2; }
+		/** Returns the argument, multiplied by two.
+		 * @param pArg The argument being doubled.
+		 * @return The argument, multiplied by two.
+		 */
+		public double doubleParam(double pArg) { return pArg*2; }
+		/** Returns the argument, multiplied by two.
+		 * @param pArg The argument being doubled.
+		 * @return The argument, multiplied by two.
+		 */
+		public double doubleResult(double pArg) { return pArg*2; }
+		/** Returns the argument, concatenated with itself.
+		 * @param pArg The argument being concatenated.
+		 * @return The argument, concatenated with itself.
+		 */
+		public String stringParam(String pArg) { return pArg+pArg; }
+        /**
+         * Throws a NullPointerException.
+         */
+        public Object throwNPE() {
+            throw new NullPointerException();
+        }
+		/** Returns the argument, concatenated with itself.
+		 * @param pArg The argument being concatenated.
+		 * @return The argument, concatenated with itself.
+		 */
+		public String nullableStringParam(String pArg) {
+			if (pArg == null) {
+				pArg = "";
+			}
+			return pArg+pArg;
+		}
+		/** Returns the argument, concatenated with itself.
+		 * @param pArg The argument being concatenated.
+		 * @return The argument, concatenated with itself.
+		 */
+		public String nullableStringResult(String pArg) {
+			if (pArg == null) {
+				return null;
+			}
+			return pArg+pArg;
+		}
+		/** Returns the sum of the bytes in the given byte array.
+		 * @param pArg The array of bytes being added.
+		 * @return Sum over the bytes in the array.
+		 */
+		public int byteArrayParam(byte[] pArg) {
+			int sum = 0;
+			for (int i = 0;  i < pArg.length;  i++) {
+				sum += pArg[i];
+			}
+			return sum;
+		}
+		/** Returns an array with the bytes 0..pArg.
+		 * @param pArg Requestes byte array length.
+		 * @return Byte array with 0..pArg.
+		 */
+		public byte[] byteArrayResult(int pArg) {
+			byte[] result = new byte[pArg];
+			for (int i = 0;  i < result.length;  i++) {
+				result[i] = (byte) i;
+			}
+			return result;
+		}
+		/** Returns the sum over the objects in the array.
+		 * @param pArg Object array being added
+		 * @return Sum over the objects in the array
+		 */
+		public int objectArrayParam(Object[] pArg) {
+			int sum = 0;
+			for (int i = 0;  i < pArg.length;  i++) {
+				if (pArg[i] instanceof Number) {
+					sum += ((Number) pArg[i]).intValue();
+				} else {
+					sum += Integer.parseInt((String) pArg[i]);
+				}
+			}
+			return sum;
+		}
+		/** Returns an array of integers with the values
+		 * 0..pArg.
+		 * @param pArg Requested array length.
+		 * @return Array of integers with the values 0..pArg
+		 */
+		public Object[] objectArrayResult(int pArg) {
+			Object[] result = new Object[pArg];
+			for (int i = 0;  i < result.length;  i++) {
+				result[i] = new Integer(i);
+			}
+			return result;
+		}
+		/** Returns a sum over the entries in the map. Each
+		 * key is multiplied with its value.
+		 * @param pArg The map being iterated.
+		 * @return Sum of keys, multiplied by their values.
+		 */
+		public int mapParam(Map pArg) {
+			int sum = 0;
+			for (Iterator iter = pArg.entrySet().iterator();  iter.hasNext();  ) {
+				Map.Entry entry = (Map.Entry) iter.next();
+				String key = (String) entry.getKey();
+				Integer value = (Integer) entry.getValue();
+				sum += Integer.parseInt(key) * value.intValue();
+			}
+			return sum;
+		}
+		/** Returns a map with the stringified values 0..pArg as
+		 * keys and the corresponding integers as values.
+		 * @param pArg Requested map size.
+		 * @return Map with the keys "0".."pArg" and
+		 * 0..pArg as values.
+		 */
+		public Map mapResult(int pArg) {
+			Map result = new HashMap();
+			for (int i = 0;  i < pArg;  i++) {
+				result.put(Integer.toString(i), new Integer(i));
+			}
+			return result;
+		}
+		/** Returns the sum of all "int" nodes in <code>pNode</code>.
+		 * @param pNode The node being counted.
+		 * @return The sum of the values of all "int" nodes.
+		 */
+		public int nodeParam(Node pNode) {
+			if (pNode.getNodeType() != Node.DOCUMENT_NODE) {
+				throw new IllegalStateException("Expected document node, got " + pNode);
+			}
+			Element e = ((Document) pNode).getDocumentElement();
+			if (!ROOT_TAG.equals(e.getLocalName()) || !INT_URI.equals(e.getNamespaceURI())) {
+				throw new IllegalStateException("Expected root element 'root', got "
+												+ new QName(e.getNamespaceURI(), e.getLocalName()));
+			}
+			return count(pNode);
+		}
+		private int count(Node pNode) {
+			if (INT_TAG.equals(pNode.getLocalName())  &&  INT_URI.equals(pNode.getNamespaceURI())) {
+				StringBuffer sb = new StringBuffer();
+				for (Node child = pNode.getFirstChild();  child != null;  child = child.getNextSibling()) {
+					if (child.getNodeType() == Node.TEXT_NODE  ||  child.getNodeType() == Node.CDATA_SECTION_NODE) {
+						sb.append(child.getNodeValue());
+					}
+				}
+				return Integer.parseInt(sb.toString());
+			} else {
+				int result = 0;
+				for (Node child = pNode.getFirstChild();  child != null;  child = child.getNextSibling()) {
+					if (child.getNodeType() == Node.ELEMENT_NODE) {
+						result += count(child);
+					}
+				}
+				return result;
+			}
+		}
+
+		/** Example of a Serializable instance.
+		 */
+        public static class CalendarWrapper implements Serializable {
+            private static final long serialVersionUID = 8153663910532549627L;
+            final Calendar cal;
+            CalendarWrapper(Calendar pCalendar) {
+                cal = pCalendar;
+            }
+        }
+
+        /** Returns the calendar value in milliseconds.
+		 * @param pCal Calendar object
+		 * @return <code>pCal.getTime().getTime()</code>.
+		 */
+		public long serializableParam(CalendarWrapper pCal) {
+			return pCal.cal.getTime().getTime();
+		}
+
+		/** Returns midnight of the following day.
+		 */
+        public Calendar calendarParam(Calendar pCal) {
+            Calendar cal = (Calendar) pCal.clone();
+            cal.add(Calendar.DAY_OF_MONTH, 1);
+            cal.set(Calendar.HOUR_OF_DAY, 0);
+            cal.set(Calendar.MINUTE, 0);
+            cal.set(Calendar.SECOND, 0);
+            cal.set(Calendar.MILLISECOND, 0);
+            return cal;
+        }
+
+        /** Returns midnight of the following day.
+         */
+        public Date dateParam(Date pDate) {
+            Calendar cal = Calendar.getInstance();
+            cal.setTime(pDate);
+            return calendarParam(cal).getTime();
+        }
+    }
+
+    protected XmlRpcHandlerMapping getHandlerMapping() throws IOException, XmlRpcException {
+        return getHandlerMapping("BaseTest.properties");
+	}
+
+	/** Test, whether we can invoke a method, passing a byte value.
+	 * @throws Exception The test failed.
+	 */
+	public void testByteParam() throws Exception {
+		for (int i = 0;  i < providers.length;  i++) {
+			testByteParam(providers[i]);
+		}
+	}
+
+	private void testByteParam(ClientProvider pProvider) throws Exception {
+		final String methodName = "Remote.byteParam";
+		final Object[] params = new Object[]{new Byte((byte) 3)};
+		XmlRpcClient client = pProvider.getClient();
+		Object result = client.execute(getExConfig(pProvider), methodName, params);
+		assertEquals(new Integer(6), result);
+		boolean ok = false;
+		try {
+			client.execute(getConfig(pProvider), methodName, params);
+		} catch (XmlRpcExtensionException e) {
+			ok = true;
+		}
+		assertTrue(ok);
+	}
+
+	/** Test, whether we can invoke a method, returning a byte.
+	 * @throws Exception The test failed.
+	 */
+	public void testByteResult() throws Exception {
+		for (int i = 0;  i < providers.length;  i++) {
+			testByteResult(providers[i]);
+		}
+	}
+
+	private void testByteResult(ClientProvider pProvider) throws Exception {
+		final String methodName = "Remote.byteResult";
+		final Object[] params = new Object[]{new Byte((byte) 3)};
+		final XmlRpcClient client = pProvider.getClient();
+		Object result = client.execute(getExConfig(pProvider), methodName, params);
+		assertEquals(new Byte((byte) 6), result);
+		boolean ok = false;
+		try {
+			client.execute(getConfig(pProvider), methodName, params);
+		} catch (XmlRpcExtensionException e) {
+			ok = true;
+		}
+		assertTrue(ok);
+	}
+
+	/** Test, whether we can invoke a method, passing a short value.
+	 * @throws Exception The test failed.
+	 */
+	public void testShortParam() throws Exception {
+		for (int i = 0;  i < providers.length;  i++) {
+			testShortParam(providers[i]);
+		}
+	}
+
+	private void testShortParam(ClientProvider pProvider) throws Exception {
+		final String methodName = "Remote.shortParam";
+		final Object[] params = new Object[]{new Short((short) 4)};
+		final XmlRpcClient client = pProvider.getClient();
+		Object result = client.execute(getExConfig(pProvider), methodName, params);
+		assertEquals(new Integer(8), result);
+		boolean ok = false;
+		try {
+			client.execute(getConfig(pProvider), methodName, params);
+		} catch (XmlRpcExtensionException e) {
+			ok = true;
+		}
+		assertTrue(ok);
+	}
+
+	/** Test, whether we can invoke a method, returning a short value.
+	 * @throws Exception The test failed.
+	 */
+	public void testShortResult() throws Exception {
+		for (int i = 0;  i < providers.length;  i++) {
+			testShortResult(providers[i]);
+		}
+	}
+
+	private void testShortResult(ClientProvider pProvider) throws Exception {
+		final String methodName = "Remote.shortResult";
+		final Object[] params = new Object[]{new Short((short) 4)};
+		final XmlRpcClient client = pProvider.getClient();
+		Object result = client.execute(getExConfig(pProvider), methodName, params);
+		assertEquals(new Short((short) 8), result);
+		boolean ok = false;
+		try {
+			client.execute(getConfig(pProvider), methodName, params);
+		} catch (XmlRpcExtensionException e) {
+			ok = true;
+		}
+		assertTrue(ok);
+	}
+
+	/** Test, whether we can invoke a method, passing an
+	 * integer value.
+	 * @throws Exception The test failed.
+	 */
+	public void testIntParam() throws Exception {
+		for (int i = 0;  i < providers.length;  i++) {
+			testIntParam(providers[i]);
+		}
+	}
+
+	private void testIntParam(ClientProvider pProvider) throws Exception {
+		final String methodName = "Remote.intParam";
+		final Object[] params = new Object[]{new Integer(5)};
+		final XmlRpcClient client = pProvider.getClient();
+		Object result = client.execute(getConfig(pProvider), methodName, params);
+		assertEquals(new Integer(10), result);
+		result = client.execute(getExConfig(pProvider), methodName, params);
+		assertEquals(new Integer(10), result);
+	}
+
+	/** Test, whether we can invoke a method, passing a long value.
+	 * @throws Exception The test failed.
+	 */
+	public void testLongParam() throws Exception {
+		for (int i = 0;  i < providers.length;  i++) {
+			testLongParam(providers[i]);
+		}
+	}
+
+	private void testLongParam(ClientProvider pProvider) throws Exception {
+		final String methodName = "Remote.longParam";
+		final Object[] params = new Object[]{new Long(6L)};
+		final XmlRpcClient client = pProvider.getClient();
+		Object result = client.execute(getExConfig(pProvider), methodName, params);
+		assertEquals(new Integer(12), result);
+		boolean ok = false;
+		try {
+			client.execute(getConfig(pProvider), methodName, params);
+		} catch (XmlRpcExtensionException e) {
+			ok = true;
+		}
+		assertTrue(ok);
+	}
+
+	/** Test, whether we can invoke a method, returning a long value.
+	 * @throws Exception The test failed.
+	 */
+	public void testLongResult() throws Exception {
+		for (int i = 0;  i < providers.length;  i++) {
+			testLongResult(providers[i]);
+		}
+	}
+
+	private void testLongResult(ClientProvider pProvider) throws Exception {
+		final String methodName = "Remote.longResult";
+		final Object[] params = new Object[]{new Long(6L)};
+		final XmlRpcClient client = pProvider.getClient();
+		Object result = client.execute(getExConfig(pProvider), methodName, params);
+		assertEquals(new Long(12L), result);
+		boolean ok = false;
+		try {
+			client.execute(getConfig(pProvider), methodName, params);
+		} catch (XmlRpcExtensionException e) {
+			ok = true;
+		}
+		assertTrue(ok);
+	}
+
+	/** Test, whether we can invoke a method, passing a
+	 * string value.
+	 * @throws Exception The test failed.
+	 */
+	public void testStringParam() throws Exception {
+		for (int i = 0;  i < providers.length;  i++) {
+			testStringParam(providers[i]);
+		}
+	}
+
+	private void testStringParam(ClientProvider pProvider) throws Exception {
+		final String methodName = "Remote.stringParam";
+		final Object[] params = new Object[]{"abc"};
+		final XmlRpcClient client = pProvider.getClient();
+		Object result = client.execute(getConfig(pProvider), methodName, params);
+		assertEquals("abcabc", result);
+		result = client.execute(getExConfig(pProvider), methodName, params);
+		assertEquals("abcabc", result);
+	}
+
+	/** Test, whether we can invoke a method, passing a
+	 * string value or null.
+	 * @throws Exception The test failed.
+	 */
+	public void testNullableStringParam() throws Exception {
+		for (int i = 0;  i < providers.length;  i++) {
+			testNullableStringParam(providers[i]);
+		}
+	}
+
+	private void testNullableStringParam(ClientProvider pProvider) throws Exception {
+		final String methodName = "Remote.nullableStringParam";
+		final Object[] params = new Object[]{"abc"};
+		final XmlRpcClient client = pProvider.getClient();
+		Object result = client.execute(getConfig(pProvider), methodName, params);
+		assertEquals("abcabc", result);
+		result = client.execute(getExConfig(pProvider), methodName, params);
+		assertEquals("abcabc", result);
+		final Object[] nullParams = new Object[]{null};
+		result = client.execute(getExConfig(pProvider), methodName, nullParams);
+		assertEquals("", result);
+		boolean ok = false;
+		try {
+			client.execute(getConfig(pProvider), methodName, nullParams);
+		} catch (XmlRpcExtensionException e) {
+			ok = true;
+		}
+		assertTrue(ok);
+	}
+
+	/** Test, whether we can invoke a method, returning a
+	 * string value or null.
+	 * @throws Exception The test failed.
+	 */
+	public void testNullableStringResult() throws Exception {
+		for (int i = 0;  i < providers.length;  i++) {
+			testNullableStringResult(providers[i]);
+		}
+	}
+
+	private void testNullableStringResult(ClientProvider pProvider) throws Exception {
+		final String methodName = "Remote.nullableStringResult";
+		final Object[] params = new Object[]{"abc"};
+		final XmlRpcClient client = pProvider.getClient();
+		Object result = client.execute(getConfig(pProvider), methodName, params);
+		assertEquals("abcabc", result);
+		result = client.execute(getExConfig(pProvider), methodName, params);
+		assertEquals("abcabc", result);
+		final Object[] nullParams = new Object[]{null};
+		result = client.execute(getExConfig(pProvider), methodName, nullParams);
+		assertEquals(null, result);
+		boolean ok = false;
+		try {
+			client.execute(getConfig(pProvider), methodName, nullParams);
+		} catch (XmlRpcExtensionException e) {
+			ok = true;
+		}
+		assertTrue(ok);
+	}
+
+	/** Test, whether we can invoke a method, passing a float value.
+	 * @throws Exception The test failed.
+	 */
+	public void testFloatParam() throws Exception {
+		for (int i = 0;  i < providers.length;  i++) {
+			testFloatParam(providers[i]);
+		}
+	}
+
+	private void testFloatParam(ClientProvider pProvider) throws Exception {
+		final String methodName = "Remote.floatParam";
+		final Object[] params = new Object[]{new Float(0.4)};
+		final XmlRpcClient client = pProvider.getClient();
+		Object result = client.execute(getExConfig(pProvider), methodName, params);
+		assertEquals(8, Math.round(((Double) result).doubleValue()*10));
+		boolean ok = false;
+		try {
+			client.execute(getConfig(pProvider), methodName, params);
+		} catch (XmlRpcExtensionException e) {
+			ok = true;
+		}
+		assertTrue(ok);
+	}
+
+	/** Test, whether we can invoke a method, returning a float value.
+	 * @throws Exception The test failed.
+	 */
+	public void testFloatResult() throws Exception {
+		for (int i = 0;  i < providers.length;  i++) {
+			testFloatResult(providers[i]);
+		}
+	}
+
+	private void testFloatResult(ClientProvider pProvider) throws Exception {
+		final String methodName = "Remote.floatResult";
+		final Object[] params = new Object[]{new Float(0.4)};
+		final XmlRpcClient client = pProvider.getClient();
+		Object result = client.execute(getExConfig(pProvider), methodName, params);
+		assertEquals(new Float(0.8), result);
+		boolean ok = false;
+		try {
+			client.execute(getConfig(pProvider), methodName, params);
+		} catch (XmlRpcExtensionException e) {
+			ok = true;
+		}
+		assertTrue(ok);
+	}
+
+	/** Test, whether we can invoke a method, passing a
+	 * double value.
+	 * @throws Exception The test failed.
+	 */
+	public void testDoubleParam() throws Exception {
+		for (int i = 0;  i < providers.length;  i++) {
+			testDoubleParam(providers[i]);
+		}
+	}
+
+	private void testDoubleParam(ClientProvider pProvider) throws Exception {
+		final String methodName = "Remote.doubleParam";
+		final Object[] params = new Object[]{new Double(0.6)};
+		final XmlRpcClient client = pProvider.getClient();
+		Object result = client.execute(getConfig(pProvider), methodName, params);
+		assertEquals(new Double(1.2), result);
+		result = client.execute(getExConfig(pProvider), methodName, params);
+		assertEquals(new Double(1.2), result);
+	}
+
+	/** Test, whether we can invoke a method, returning a
+	 * double value.
+	 * @throws Exception The test failed.
+	 */
+	public void testDoubleResult() throws Exception {
+		for (int i = 0;  i < providers.length;  i++) {
+			testDoubleResult(providers[i]);
+		}
+	}
+
+	private void testDoubleResult(ClientProvider pProvider) throws Exception {
+		final String methodName = "Remote.doubleResult";
+		final Object[] params = new Object[]{new Double(0.6)};
+		final XmlRpcClient client = pProvider.getClient();
+		Object result = client.execute(getConfig(pProvider), methodName, params);
+		assertEquals(new Double(1.2), result);
+		result = client.execute(getExConfig(pProvider), methodName, params);
+		assertEquals(new Double(1.2), result);
+	}
+
+	/** Test, whether we can invoke a method, passing a
+	 * byte array.
+	 * @throws Exception The test failed.
+	 */
+	public void testByteArrayParam() throws Exception {
+		for (int i = 0;  i < providers.length;  i++) {
+			testByteArrayParam(providers[i]);
+		}
+	}
+
+	private void testByteArrayParam(ClientProvider pProvider) throws Exception {
+		final byte[] bytes = new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+		final String methodName = "Remote.byteArrayParam";
+		final Object[] params = new Object[]{bytes};
+		final XmlRpcClient client = pProvider.getClient();
+		Object result = client.execute(getConfig(pProvider), methodName, params);
+		assertEquals(new Integer(0+1+2+3+4+5+6+7+8+9), result);
+		result = client.execute(getExConfig(pProvider), methodName, params);
+		assertEquals(new Integer(0+1+2+3+4+5+6+7+8+9), result);
+	}
+
+	/** Test, whether we can invoke a method, returning a
+	 * byte array.
+	 * @throws Exception The test failed.
+	 */
+	public void testByteArrayResult() throws Exception {
+		for (int i = 0;  i < providers.length;  i++) {
+			testByteArrayResult(providers[i]);
+		}
+	}
+
+	private void testByteArrayResult(ClientProvider pProvider) throws Exception {
+		final byte[] bytes = new byte[]{0, 1, 2, 3, 4, 5, 6, 7};
+		final String methodName = "Remote.byteArrayResult";
+		final Object[] params = new Object[]{new Integer(8)};
+		final XmlRpcClient client = pProvider.getClient();
+		Object result = client.execute(getConfig(pProvider), methodName, params);
+		assertTrue(Arrays.equals(bytes, (byte[]) result));
+		result = client.execute(getExConfig(pProvider), methodName, params);
+		assertTrue(Arrays.equals(bytes, (byte[]) result));
+	}
+
+	/** Test, whether we can invoke a method, passing an
+	 * object array.
+	 * @throws Exception The test failed.
+	 */
+	public void testObjectArrayParam() throws Exception {
+		for (int i = 0;  i < providers.length;  i++) {
+			testObjectArrayParam(providers[i]);
+		}
+	}
+
+	private void testObjectArrayParam(ClientProvider pProvider) throws Exception {
+		final Object[] objects = new Object[]{new Byte((byte) 1), new Short((short) 2),
+											  new Integer(3), new Long(4), "5"};
+		final String methodName = "Remote.objectArrayParam";
+		final Object[] params = new Object[]{objects};
+		final XmlRpcClient client = pProvider.getClient();
+		boolean ok = false;
+		try {
+			client.execute(getConfig(pProvider), methodName, params);
+		} catch (XmlRpcExtensionException e) {
+			ok = true;
+		}
+		assertTrue(ok);
+		Object result = client.execute(getExConfig(pProvider), methodName, params);
+		assertEquals(new Integer(15), result);
+	}
+
+	/** Test, whether we can invoke a method, returning an
+	 * object array.
+	 * @throws Exception The test failed.
+	 */
+	public void testObjectArrayResult() throws Exception {
+		for (int i = 0;  i < providers.length;  i++) {
+			testObjectArrayResult(providers[i]);
+		}
+	}
+
+	private void testObjectArrayResult(ClientProvider pProvider) throws Exception {
+		final Object[] objects = new Object[]{new Integer(0), new Integer(1),
+											  new Integer(2), new Integer(3)};
+		final String methodName = "Remote.objectArrayResult";
+		final Object[] params = new Object[]{new Integer(4)};
+		final XmlRpcClient client = pProvider.getClient();
+		Object result = client.execute(getConfig(pProvider), methodName, params);
+		assertTrue(Arrays.equals(objects, (Object[]) result));
+		result = client.execute(getExConfig(pProvider), methodName, params);
+		assertTrue(Arrays.equals(objects, (Object[]) result));
+	}
+
+	/** Test, whether we can invoke a method, passing a map.
+	 * @throws Exception The test failed.
+	 */
+	public void testMapParam() throws Exception {
+		for (int i = 0;  i < providers.length;  i++) {
+			testMapParam(providers[i]);
+		}
+	}
+
+	private void testMapParam(ClientProvider pProvider) throws Exception {
+		final Map map = new HashMap();
+		map.put("2", new Integer(3));
+		map.put("3", new Integer(5));
+		final String methodName = "Remote.mapParam";
+		final Object[] params = new Object[]{map};
+		final XmlRpcClient client = pProvider.getClient();
+		Object result = client.execute(getConfig(pProvider), methodName, params);
+		assertEquals(new Integer(21), result);
+		result = client.execute(getExConfig(pProvider), methodName, params);
+		assertEquals(new Integer(21), result);
+	}
+
+	private void checkMap(Map pResult) {
+		assertEquals(4, pResult.size());
+		assertEquals(new Integer(0), pResult.get("0"));
+		assertEquals(new Integer(1), pResult.get("1"));
+		assertEquals(new Integer(2), pResult.get("2"));
+		assertEquals(new Integer(3), pResult.get("3"));
+	}
+
+	/** Test, whether we can invoke a method, returning a map.
+	 * @throws Exception The test failed.
+	 */
+	public void testMapResult() throws Exception {
+		for (int i = 0;  i < providers.length;  i++) {
+			testMapResult(providers[i]);
+		}
+	}
+
+	private void testMapResult(ClientProvider pProvider) throws Exception {
+		final String methodName = "Remote.mapResult";
+		final Object[] params = new Object[]{new Integer(4)};
+		final XmlRpcClient client = pProvider.getClient();
+		Object result = client.execute(getConfig(pProvider), methodName, params);
+		checkMap((Map) result);
+		result = client.execute(getExConfig(pProvider), methodName, params);
+		checkMap((Map) result);
+	}
+
+	/** Test, whether we can invoke a method, passing a DOM
+	 * node as parameter.
+	 * @throws Exception The test failed.
+	 */
+	public void testNodeParam() throws Exception {
+		for (int i = 0;  i < providers.length;  i++) {
+			testNodeParam(providers[i]);
+		}
+	}
+
+	private static final String ROOT_TAG = "root";
+	private static final String INT_TAG = "int";
+	private static final String INT_URI = "http://ws.apache.org/xmlrpc/namespaces/testNodeParam";
+
+	private void testNodeParam(ClientProvider pProvider) throws Exception {
+		final String xml =
+			"<" + ROOT_TAG + " xmlns='" + INT_URI +"'>" +
+			"  <" + INT_TAG + ">1</" + INT_TAG + ">" +
+			"  <" + INT_TAG + ">2</" + INT_TAG + ">" +
+			"  <" + INT_TAG + ">3</" + INT_TAG + ">" +
+			"  <" + INT_TAG + ">4</" + INT_TAG + ">" +
+			"  <" + INT_TAG + ">5</" + INT_TAG + ">" +
+			"</" + ROOT_TAG + ">";
+		final String methodName = "Remote.nodeParam";
+		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+		dbf.setValidating(false);
+		dbf.setNamespaceAware(true);
+		Document doc = dbf.newDocumentBuilder().parse(new InputSource(new StringReader(xml)));
+		final Object[] params = new Object[]{doc};
+		final XmlRpcClient client = pProvider.getClient();
+		Object result = client.execute(getExConfig(pProvider), methodName, params);
+		assertEquals(1 + 2 + 3 + 4 + 5, result);
+		boolean ok = false;
+		try {
+			client.execute(getConfig(pProvider), methodName, params);
+		} catch (XmlRpcExtensionException e) {
+			ok = true;
+		}
+		assertTrue(ok);
+	}
+
+	/** Test, whether we can invoke a method, passing an instance of
+	 * {@link Serializable} as a parameter.
+	 * @throws Exception The test failed.
+	 */
+	public void testSerializableParam() throws Exception {
+		for (int i = 0;  i < providers.length;  i++) {
+			testSerializableParam(providers[i]);
+		}
+	}
+
+	private void testSerializableParam(ClientProvider pProvider) throws Exception {
+		final String methodName = "Remote.serializableParam";
+		Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
+		cal.set(2005, 5, 23, 8, 4, 0);
+		cal.set(Calendar.MILLISECOND, 5);
+		final Object[] params = new Object[]{new Remote.CalendarWrapper(cal)};
+		final XmlRpcClient client = pProvider.getClient();
+		Object result = client.execute(getExConfig(pProvider), methodName, params);
+		assertEquals(new Long(cal.getTime().getTime()), result);
+		boolean ok = false;
+		try {
+			client.execute(getConfig(pProvider), methodName, params);
+		} catch (XmlRpcExtensionException e) {
+			ok = true;
+		}
+		assertTrue(ok);
+	}
+
+	/** Tests, whether we can invoke a method, passing an instance of
+     * {@link Calendar} as a parameter.
+     * @throws Exception The test failed.
+	 */
+	public void testCalendarParam() throws Exception {
+	    for (int i = 0;  i < providers.length;  i++) {
+	        testCalendarParam(providers[i]);
+        }
+    }
+
+	private void testCalendarParam(ClientProvider pProvider) throws Exception {
+	    final String methodName = "Remote.calendarParam";
+        Calendar cal1 = newCalendarParam();
+        Calendar cal2 = newCalendarResult();
+        final Object[] params = new Object[]{cal1};
+        final XmlRpcClient client = pProvider.getClient();
+        Object result = client.execute(getExConfig(pProvider), methodName, params);
+        assertEquals(cal2.getTime(), ((Calendar) result).getTime());
+        boolean ok = false;
+        try {
+            client.execute(getConfig(pProvider), methodName, params);
+        } catch (XmlRpcExtensionException e) {
+            ok = true;
+        }
+        assertTrue(ok);
+    }
+
+    private Calendar newCalendarResult() {
+        Calendar cal2 = Calendar.getInstance(TimeZone.getDefault());
+        cal2.set(2005, 5, 24, 0, 0, 0);
+        cal2.set(Calendar.MILLISECOND, 0);
+        return cal2;
+    }
+
+    private Calendar newCalendarParam() {
+        Calendar cal1 = Calendar.getInstance(TimeZone.getDefault());
+        cal1.set(2005, 5, 23, 8, 4, 0);
+        cal1.set(Calendar.MILLISECOND, 5);
+        return cal1;
+    }
+
+    /** Tests, whether we can invoke a method, passing an instance of
+     * {@link Date} as a parameter.
+     * @throws Exception The test failed.
+     */
+    public void testDateParam() throws Exception {
+        for (int i = 0;  i < providers.length;  i++) {
+            testDateParam(providers[i]);
+        }
+    }
+
+    private void testDateParam(ClientProvider pProvider) throws Exception {
+        final String methodName = "Remote.dateParam";
+        Date date1 = newCalendarParam().getTime();
+        Calendar cal2 = newCalendarResult();
+        final Object[] params = new Object[]{date1};
+        final XmlRpcClient client = pProvider.getClient();
+        Object result = client.execute(getExConfig(pProvider), methodName, params);
+        assertEquals(cal2.getTime(), result);
+        result = client.execute(getConfig(pProvider), methodName, params);
+        assertEquals(cal2.getTime(), result);
+    }
+
+    /**
+     * Tests, whether a NullPointerException, thrown by the server, can be
+     * trapped by the client.
+     */
+    public void testCatchNPE() throws Exception {
+        for (int i = 0;  i < providers.length;  i++) {
+            testCatchNPE(providers[i]);
+        }
+    }
+
+    private void testCatchNPE(ClientProvider pProvider) throws Exception {
+        final XmlRpcClient client = pProvider.getClient();
+        final String methodName = "Remote.throwNPE";
+        try {
+            client.execute(getExConfig(pProvider), methodName, (Object[]) null); 
+        } catch (XmlRpcInvocationException e) {
+            if (!(e.getCause() instanceof NullPointerException)) {
+                throw e;
+            }
+        }
+    }
+}

netty-http-xmlrpc-client/src/test/java/org/xbib/netty/http/xmlrpc/client/test/ClientIpTest.java

@@ -0,0 +1,143 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.xbib.netty.http.xmlrpc.client.test;
+
+import java.io.IOException;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.xmlrpc.XmlRpcException;
+import org.apache.xmlrpc.XmlRpcHandler;
+import org.apache.xmlrpc.XmlRpcRequest;
+import org.apache.xmlrpc.client.XmlRpcClient;
+import org.apache.xmlrpc.server.XmlRpcHandlerMapping;
+import org.apache.xmlrpc.server.XmlRpcNoSuchHandlerException;
+import org.apache.xmlrpc.webserver.XmlRpcServlet;
+
+
+/**
+ * Test case for reading the clients IP address.
+ */
+public class ClientIpTest extends XmlRpcTestCase {
+    /**
+     * An object, which provides additional information
+     * about the client to the user.
+     */
+    public static class ClientInfo {
+        private final String ipAddress;
+
+        /**
+         * Creates a new instance.
+         */
+        public ClientInfo(String pIpAddress) {
+            ipAddress = pIpAddress;
+        }
+
+        /**
+         * Returns the clients IP address.
+         */
+        public String getIpAddress() {
+            return ipAddress;
+        }
+    }
+
+    /**
+     * An extension of the {@link XmlRpcServlet}, which
+     * ensures the availability of a {@link ClientInfo}
+     * object.
+     */
+    public static class ClientInfoServlet extends XmlRpcServlet {
+        private static final long serialVersionUID = 8210342625908021538L;
+        private static ThreadLocal clientInfo = new ThreadLocal();
+
+        /**
+         * Returns the current threads. client info object.
+         */
+        public static ClientInfo getClientInfo() {
+            return (ClientInfo) clientInfo.get();
+        }
+
+        public void doPost(HttpServletRequest pRequest,
+                HttpServletResponse pResponse) throws IOException,
+                ServletException {
+            clientInfo.set(new ClientInfo(pRequest.getRemoteAddr()));
+            super.doPost(pRequest, pResponse);
+        }
+    }
+
+    private static class ClientIpTestProvider extends ServletWebServerProvider {
+        ClientIpTestProvider(XmlRpcHandlerMapping pMapping, boolean pContentLength)
+                throws ServletException, IOException {
+            super(pMapping, pContentLength);
+        }
+
+        protected XmlRpcServlet newXmlRpcServlet() {
+            return new ClientInfoServlet();
+        }
+    }
+    
+    protected ClientProvider[] initProviders(XmlRpcHandlerMapping pMapping)
+            throws ServletException, IOException {
+        return new ClientProvider[]{
+            new ClientIpTestProvider(pMapping, false),
+            new ClientIpTestProvider(pMapping, true)
+        };
+    }
+
+    protected XmlRpcHandlerMapping getHandlerMapping() throws IOException,
+            XmlRpcException {
+        final XmlRpcHandler handler = new XmlRpcHandler(){
+            public Object execute(XmlRpcRequest pRequest) throws XmlRpcException {
+                final ClientInfo clientInfo = ClientInfoServlet.getClientInfo();
+                if (clientInfo == null) {
+                    return "";
+                }
+                final String ip = clientInfo.getIpAddress();
+                if (ip == null) {
+                    return "";
+                }
+                return ip;
+            }
+        };
+        return new XmlRpcHandlerMapping(){
+            public XmlRpcHandler getHandler(String pHandlerName)
+                    throws XmlRpcNoSuchHandlerException, XmlRpcException {
+                return handler;
+            }
+        };
+    }
+
+    private void testClientIpAddress(ClientProvider pProvider) throws Exception {
+        final XmlRpcClient client = pProvider.getClient();
+        client.setConfig(getConfig(pProvider));
+        final String ip = (String) client.execute("getIpAddress", new Object[]{});
+        assertEquals("127.0.0.1", ip);
+    }
+    
+    /** Test, whether we can invoke a method, returning a byte.
+     * @throws Exception The test failed.
+     */
+    public void testClientIpAddress() throws Exception {
+        for (int i = 0;  i < providers.length;  i++) {
+            testClientIpAddress(providers[i]);
+        }
+    }
+}

netty-http-xmlrpc-client/src/test/java/org/xbib/netty/http/xmlrpc/client/test/ClientProvider.java

@@ -0,0 +1,31 @@
+package org.xbib.netty.http.xmlrpc.client.test;
+
+import org.xbib.netty.http.xmlrpc.client.XmlRpcClient;
+import org.xbib.netty.http.xmlrpc.client.XmlRpcClientConfigImpl;
+import org.xbib.netty.http.xmlrpc.server.XmlRpcServer;
+
+/** This interface allows to perform a unit test with various
+ * transports. Basically, the implementation creates the client,
+ * including the transport, and the server, if required.
+ */
+public interface ClientProvider {
+	/** Returns the clients default configuration.
+	 * @return The clients configuration.
+	 * @throws Exception Creating the configuration failed.
+	 */
+	XmlRpcClientConfigImpl getConfig() throws Exception;
+
+	/** Returns a new client instance.
+	 * @return A client being used for performing the test.
+	 */
+	XmlRpcClient getClient();
+
+	/** Returns the providers server instance.
+     * @return A server instance, which is being used for performing the test.
+	 */
+    XmlRpcServer getServer();
+
+    /** Performs a shutdown of the server.
+     */
+    void shutdown();
+}

netty-http-xmlrpc-client/src/test/java/org/xbib/netty/http/xmlrpc/client/test/ClientProviderImpl.java

@@ -0,0 +1,41 @@
+package org.xbib.netty.http.xmlrpc.client.test;
+
+
+import org.xbib.netty.http.xmlrpc.client.XmlRpcClient;
+import org.xbib.netty.http.xmlrpc.client.XmlRpcClientConfigImpl;
+import org.xbib.netty.http.xmlrpc.client.XmlRpcTransportFactory;
+import org.xbib.netty.http.xmlrpc.server.XmlRpcHandlerMapping;
+import org.xbib.netty.http.xmlrpc.server.XmlRpcServer;
+
+/** Abstract base implementation of {@link ClientProvider}.
+ */
+public abstract class ClientProviderImpl implements ClientProvider {
+	protected final XmlRpcHandlerMapping mapping;
+
+	protected abstract XmlRpcTransportFactory getTransportFactory(XmlRpcClient pClient);
+
+	/** Creates a new instance.
+	 * @param pMapping The test servers handler mapping.
+	 */
+	protected ClientProviderImpl(XmlRpcHandlerMapping pMapping) {
+		mapping = pMapping;
+	}
+
+	protected XmlRpcServer getXmlRpcServer() throws Exception {
+		XmlRpcServer server = new XmlRpcServer();
+		server.setHandlerMapping(mapping);
+		return server;
+	}
+
+	public XmlRpcClientConfigImpl getConfig() throws Exception {
+		XmlRpcClientConfigImpl config = new XmlRpcClientConfigImpl();
+		return config;
+	}
+
+	public XmlRpcClient getClient() {
+		XmlRpcClient client = new XmlRpcClient();
+		client.setTransportFactory(getTransportFactory(client));
+		return client;
+	}
+
+}

netty-http-xmlrpc-client/src/test/java/org/xbib/netty/http/xmlrpc/client/test/CommonsProvider.java

@@ -0,0 +1,23 @@
+package org.xbib.netty.http.xmlrpc.client.test;
+
+import org.xbib.netty.http.xmlrpc.client.XmlRpcClient;
+import org.xbib.netty.http.xmlrpc.client.XmlRpcCommonsTransportFactory;
+import org.xbib.netty.http.xmlrpc.client.XmlRpcTransportFactory;
+import org.xbib.netty.http.xmlrpc.server.XmlRpcHandlerMapping;
+
+/**
+ * Provider for testing the
+ * {@link XmlRpcCommonsTransport}.
+ */
+public class CommonsProvider extends WebServerProvider {
+	/** Creates a new instance.
+	 * @param pMapping The test servers handler mapping.
+	 */
+	public CommonsProvider(XmlRpcHandlerMapping pMapping) {
+		super(pMapping, true);
+	}
+
+	protected XmlRpcTransportFactory getTransportFactory(XmlRpcClient pClient) {
+		return new XmlRpcCommonsTransportFactory(pClient);
+	}
+}

netty-http-xmlrpc-client/src/test/java/org/xbib/netty/http/xmlrpc/client/test/CustomTypesTest.java

@@ -0,0 +1,128 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.xbib.netty.http.xmlrpc.client.test;
+
+import java.io.IOException;
+import java.text.DateFormat;
+import java.text.Format;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+
+import org.apache.ws.commons.util.NamespaceContextImpl;
+import org.apache.xmlrpc.XmlRpcException;
+import org.apache.xmlrpc.XmlRpcRequest;
+import org.apache.xmlrpc.client.XmlRpcClient;
+import org.apache.xmlrpc.client.XmlRpcClientConfigImpl;
+import org.apache.xmlrpc.client.XmlRpcClientRequestImpl;
+import org.apache.xmlrpc.common.TypeFactory;
+import org.apache.xmlrpc.common.TypeFactoryImpl;
+import org.apache.xmlrpc.common.XmlRpcController;
+import org.apache.xmlrpc.common.XmlRpcStreamConfig;
+import org.apache.xmlrpc.parser.DateParser;
+import org.apache.xmlrpc.parser.TypeParser;
+import org.apache.xmlrpc.serializer.DateSerializer;
+import org.apache.xmlrpc.serializer.TypeSerializer;
+import org.apache.xmlrpc.server.PropertyHandlerMapping;
+import org.apache.xmlrpc.server.XmlRpcHandlerMapping;
+import org.apache.xmlrpc.server.XmlRpcServer;
+import org.xml.sax.SAXException;
+
+
+/**
+ * Test suite for working with custom types.
+ */
+public class CustomTypesTest extends XmlRpcTestCase {
+    /**
+     * Sample date converter
+     */
+    public static class DateConverter {
+        /**
+         * Adds one day to the given date.
+         */
+        public Date tomorrow(Date pDate) {
+            Calendar cal = Calendar.getInstance();
+            cal.setTime(pDate);
+            cal.add(Calendar.DAY_OF_MONTH, 1);
+            return cal.getTime();
+        }
+    }
+    
+    protected XmlRpcHandlerMapping getHandlerMapping() throws IOException, XmlRpcException {
+        PropertyHandlerMapping mapping = new PropertyHandlerMapping();
+        mapping.addHandler("DateConverter", DateConverter.class);
+        return mapping;
+    }
+
+    /** Tests using a custom date format.
+     */
+    public void testCustomDateFormat() throws Exception {
+        for (int i = 0;  i < providers.length;  i++) {
+            testCustomDateFormat(providers[i]);
+        }
+    }
+
+    private TypeFactory getCustomDateTypeFactory(XmlRpcController pController, final Format pFormat) {
+        return new TypeFactoryImpl(pController){
+            private TypeSerializer dateSerializer = new DateSerializer(pFormat);
+
+            public TypeParser getParser(XmlRpcStreamConfig pConfig, NamespaceContextImpl pContext, String pURI, String pLocalName) {
+                if (DateSerializer.DATE_TAG.equals(pLocalName)) {
+                    return new DateParser(pFormat);
+                } else {
+                    return super.getParser(pConfig, pContext, pURI, pLocalName);
+                }
+            }
+
+            public TypeSerializer getSerializer(XmlRpcStreamConfig pConfig, Object pObject) throws SAXException {
+                if (pObject instanceof Date) {
+                    return dateSerializer;
+                } else {
+                    return super.getSerializer(pConfig, pObject);
+                }
+            }
+            
+        };
+    }
+
+    private void testCustomDateFormat(ClientProvider pProvider) throws Exception {
+        final DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
+        XmlRpcClient client = pProvider.getClient();
+        XmlRpcClientConfigImpl config = getConfig(pProvider);
+        client.setConfig(config);
+        TypeFactory typeFactory = getCustomDateTypeFactory(client, format);
+        client.setTypeFactory(typeFactory);
+        Calendar cal1 = Calendar.getInstance();
+        XmlRpcRequest request = new XmlRpcClientRequestImpl(config, "DateConverter.tomorrow", new Object[]{cal1.getTime()});
+        final String got = XmlRpcTestCase.writeRequest(client, request);
+        final String expect = "<?xml version=\"1.0\" encoding=\"US-ASCII\"?>"
+            + "<methodCall><methodName>DateConverter.tomorrow</methodName>"
+            + "<params><param><value><dateTime.iso8601>" + format.format(cal1.getTime())
+            + "</dateTime.iso8601></value></param></params></methodCall>";
+        assertEquals(expect, got);
+        
+        XmlRpcServer server = pProvider.getServer();
+        server.setTypeFactory(getCustomDateTypeFactory(server, format));
+        Date date = (Date) client.execute(request);
+        Calendar cal2 = Calendar.getInstance();
+        cal2.setTime(date);
+        cal1.add(Calendar.DAY_OF_MONTH, 1);
+        assertEquals(cal1, cal2);
+    }
+}

netty-http-xmlrpc-client/src/test/java/org/xbib/netty/http/xmlrpc/client/test/DynamicProxyTest.java

@@ -0,0 +1,132 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.xbib.netty.http.xmlrpc.client.test;
+
+import java.io.IOException;
+
+import org.apache.xmlrpc.XmlRpcException;
+import org.apache.xmlrpc.client.XmlRpcClient;
+import org.apache.xmlrpc.client.util.ClientFactory;
+import org.apache.xmlrpc.server.XmlRpcHandlerMapping;
+import org.xml.sax.SAXException;
+
+
+/** Test case for the {@link ClientFactory}.
+ */
+public class DynamicProxyTest extends XmlRpcTestCase {
+    /** An interface, which is being implemented by the
+     * server.
+     */
+    public interface Adder {
+        /** Returns the sum of the given integers.
+         */
+        public int add(int pNum1, int pNum2);
+
+        /**
+         * Throws a SAXException.
+         */
+        public Object parse(String pMessage) throws SAXException;
+
+        /**
+         * A void method; these are disabled without support for
+         * extensions, but enabled when extensions are on.
+         */
+        public void ping();
+    }
+
+    /** Implementation of {@link Adder}, which is used by
+     * the server.
+     */
+    public static class AdderImpl implements Adder {
+        public int add(int pNum1, int pNum2) {
+            return pNum1 + pNum2;
+        }
+        public Object parse(String pMessage) throws SAXException {
+            throw new SAXException("Failed to parse message: " + pMessage);
+        }
+        public void ping() {
+        }
+    }
+
+    protected XmlRpcHandlerMapping getHandlerMapping() throws IOException, XmlRpcException {
+        return getHandlerMapping("DynamicProxyTest.properties");
+    }
+
+    private ClientFactory getClientFactory(ClientProvider pProvider) throws Exception {
+        XmlRpcClient client = pProvider.getClient();
+        client.setConfig(getConfig(pProvider));
+        return new ClientFactory(client);
+    }
+
+    private ClientFactory getExClientFactory(ClientProvider pProvider) throws Exception {
+        XmlRpcClient client = pProvider.getClient();
+        client.setConfig(getExConfig(pProvider));
+        return new ClientFactory(client);
+    }
+
+    /** Tests calling the {@link Adder#add(int,int)} method
+     * by using an object, which has been created by the
+     * {@link ClientFactory}.
+     */
+    public void testAdderCall() throws Exception {
+        for (int i = 0;  i < providers.length;  i++) {
+            testAdderCall(providers[i]);
+        }
+    }
+
+    private void testAdderCall(ClientProvider pProvider) throws Exception {
+        ClientFactory factory = getClientFactory(pProvider);
+        Adder adder = (Adder) factory.newInstance(Adder.class);
+        assertEquals(6, adder.add(2, 4));
+    }
+
+    /** Tests trapping a SAXException.
+     */
+    public void testParseCall() throws Exception {
+        for (int i = 0;   i < providers.length;  i++) {
+            testParseCall(providers[i]);
+        }
+    }
+
+    private void testParseCall(ClientProvider pProvider) throws Exception {
+        ClientFactory factory = getExClientFactory(pProvider);
+        Adder adder = (Adder) factory.newInstance(Adder.class);
+        try {
+            adder.parse("foo");
+            fail("Expected SAXException");
+        } catch (SAXException e) {
+            // Ok
+        }
+    }
+
+    /**
+     * Tests invoking a "void" method.
+     */
+    public void testVoidMethod() throws Exception {
+        for (int i = 0;   i < providers.length;  i++) {
+            testVoidMethod(providers[i]);
+        }
+    }
+
+    private void testVoidMethod(ClientProvider pProvider) throws Exception {
+        ClientFactory factory = getExClientFactory(pProvider);
+        Adder adder = (Adder) factory.newInstance(Adder.class);
+        adder.ping();
+    }
+}

netty-http-xmlrpc-client/src/test/java/org/xbib/netty/http/xmlrpc/client/test/JiraTest.java

@@ -0,0 +1,402 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.xbib.netty.http.xmlrpc.client.test;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.lang.reflect.UndeclaredThrowableException;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.Collections;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Vector;
+
+import org.apache.xmlrpc.XmlRpcException;
+import org.apache.xmlrpc.client.TimingOutCallback;
+import org.apache.xmlrpc.client.XmlRpcClient;
+import org.apache.xmlrpc.client.XmlRpcHttpClientConfig;
+import org.apache.xmlrpc.client.util.ClientFactory;
+import org.apache.xmlrpc.common.XmlRpcStreamRequestConfig;
+import org.apache.xmlrpc.parser.XmlRpcResponseParser;
+import org.apache.xmlrpc.server.XmlRpcHandlerMapping;
+import org.apache.xmlrpc.util.SAXParsers;
+import org.xml.sax.InputSource;
+import org.xml.sax.XMLReader;
+
+
+/**
+ * Test case for various jira issues.
+ */ 
+public class JiraTest extends XmlRpcTestCase {
+    /** Interface of the handler for {@link JiraTest#testXMLRPC89()}
+     */
+    public interface XMLRPC89Handler {
+        /**
+         * Returns the reversed vector.
+         */
+        Vector reverse(Vector pVector);
+        /**
+         * Returns the same hashtable, but doubles the
+         * values.
+         */
+        Hashtable doubledValues(Hashtable pMap);
+        /**
+         * Returns the same properties, but doubles the
+         * values.
+         */
+        Properties doubledPropertyValues(Properties pMap);
+    }
+
+    /**
+     * Handler for {@link JiraTest#testXMLRPC89()}
+     */ 
+    public static class XMLRPC89HandlerImpl implements XMLRPC89Handler {
+        public Vector reverse(Vector pVector) {
+            Vector result = new Vector(pVector.size());
+            result.addAll(pVector);
+            Collections.reverse(result);
+            return result;
+        }
+        public Hashtable doubledValues(Hashtable pMap) {
+            final Hashtable result;
+            if (pMap instanceof Properties) {
+                result = new Properties();
+            } else {
+                result = new Hashtable();
+            }
+            result.putAll(pMap);
+            for (Iterator iter = result.entrySet().iterator();  iter.hasNext();  ) {
+                Map.Entry entry = (Map.Entry) iter.next();
+                Object value = entry.getValue();
+                final Integer i;
+                if (pMap instanceof Properties) {
+                    i = Integer.valueOf((String) value);
+                } else {
+                    i = (Integer) value;
+                }
+                Integer iDoubled = new Integer(i.intValue()*2);
+                if (pMap instanceof Properties) {
+                    entry.setValue(iDoubled.toString());
+                } else {
+                    entry.setValue(iDoubled);
+                }
+            }
+            return result;
+        }
+        public Properties doubledPropertyValues(Properties pProperties) {
+            return (Properties) doubledValues(pProperties);
+        }
+    }
+
+    protected XmlRpcHandlerMapping getHandlerMapping() throws IOException,
+            XmlRpcException {
+        return getHandlerMapping("JiraTest.properties");
+    }
+
+    /**
+     * Test case for <a href="http://issues.apache.org/jira/browse/XMLRPC-89">
+     * XMLRPC-89</a>
+     */
+    public void testXMLRPC89() throws Exception {
+        for (int i = 0;  i < providers.length;  i++) {
+            testXMLRPC89Vector(providers[i]);
+            testXMLRPC89Hashtable(providers[i]);
+            testXMLRPC89Properties(providers[i]);
+        }
+    }
+
+    private void testXMLRPC89Vector(ClientProvider pProvider) throws Exception {
+        Vector values = new Vector();
+        for (int i = 0;  i < 3;  i++) {
+            values.add(new Integer(i));
+        }
+        Vector params = new Vector();
+        params.add(values);
+        XmlRpcClient client = pProvider.getClient();
+        client.setConfig(getConfig(pProvider));
+        Object res = client.execute(XMLRPC89Handler.class.getName() + ".reverse", params);
+        Object[] result = (Object[]) res;
+        assertNotNull(result);
+        assertEquals(3, result.length);
+        for (int i = 0;  i < 3;  i++) {
+            assertEquals(new Integer(2-i), result[i]);
+        }
+
+        ClientFactory factory = new ClientFactory(client);
+        XMLRPC89Handler handler = (XMLRPC89Handler) factory.newInstance(XMLRPC89Handler.class);
+        Vector resultVector = handler.reverse(values);
+        assertNotNull(resultVector);
+        assertEquals(3, resultVector.size());
+        for (int i = 0;  i < 3;  i++) {
+            assertEquals(new Integer(2-i), resultVector.get(i));
+        }
+    }
+
+    private void verifyXMLRPC89Hashtable(Map pMap) {
+        assertNotNull(pMap);
+        assertEquals(3, pMap.size());
+        for (int i = 0;  i < 3;  i++) {
+            Integer j = (Integer) pMap.get(String.valueOf(i));
+            assertEquals(i*2, j.intValue());
+        }
+    }
+
+    private void testXMLRPC89Hashtable(ClientProvider pProvider) throws Exception {
+        Hashtable values = new Hashtable();
+        for (int i = 0;  i < 3;  i++) {
+            values.put(String.valueOf(i), new Integer(i));
+        }
+        XmlRpcClient client = pProvider.getClient();
+        client.setConfig(getConfig(pProvider));
+        Object res = client.execute(XMLRPC89Handler.class.getName() + ".doubledValues", new Object[]{values});
+        verifyXMLRPC89Hashtable((Map) res);
+
+        ClientFactory factory = new ClientFactory(client);
+        XMLRPC89Handler handler = (XMLRPC89Handler) factory.newInstance(XMLRPC89Handler.class);
+        Hashtable result = handler.doubledValues(values);
+        verifyXMLRPC89Hashtable(result);
+    }
+
+    private void verifyXMLRPC89Properties(Map pMap) {
+        assertNotNull(pMap);
+        assertEquals(3, pMap.size());
+        for (int i = 0;  i < 3;  i++) {
+            String j = (String) pMap.get(String.valueOf(i));
+            assertEquals(i*2, Integer.parseInt(j));
+        }
+    }
+
+    private void testXMLRPC89Properties(ClientProvider pProvider) throws Exception {
+        Properties values = new Properties();
+        for (int i = 0;  i < 3;  i++) {
+            values.put(String.valueOf(i), String.valueOf(i));
+        }
+        XmlRpcClient client = pProvider.getClient();
+        client.setConfig(getConfig(pProvider));
+        Object res = client.execute(XMLRPC89Handler.class.getName() + ".doubledPropertyValues", new Object[]{values});
+        verifyXMLRPC89Properties((Map) res);
+
+        ClientFactory factory = new ClientFactory(client);
+        XMLRPC89Handler handler = (XMLRPC89Handler) factory.newInstance(XMLRPC89Handler.class);
+        Properties result = handler.doubledPropertyValues(values);
+        verifyXMLRPC89Properties(result);
+    }
+
+    /** Handler for XMLRPC-96
+     */
+    public static class XMLRPC96Handler {
+        /** Returns the "Hello, world!" string.
+         */
+        public String getHelloWorld() {
+            return "Hello, world!";
+        }
+    }
+
+    /**
+     * Test case for <a href="http://issues.apache.org/jira/browse/XMLRPC-96">
+     * XMLRPC-96</a>
+     */
+    public void testXMLRPC96() throws Exception {
+        for (int i = 0;  i < providers.length;  i++) {
+            testXMLRPC96(providers[i]);
+        }
+    }
+
+    private void testXMLRPC96(ClientProvider pProvider) throws Exception {
+        XmlRpcClient client = pProvider.getClient();
+        client.setConfig(getConfig(pProvider));
+        String s = (String) client.execute(XMLRPC96Handler.class.getName() + ".getHelloWorld", new Object[0]);
+        assertEquals("Hello, world!", s);
+        s = (String) client.execute(XMLRPC96Handler.class.getName() + ".getHelloWorld", (Object[]) null);
+        assertEquals("Hello, world!", s);
+    }
+
+    /**
+     * Test case for <a href="http://issues.apache.org/jira/browse/XMLRPC-112">
+     * XMLRPC-112</a>
+     */
+    public void testXMLRPC112() throws Exception {
+        for (int i = 0;  i < providers.length;  i++) {
+            testXMLRPC112(providers[i]);
+        }
+    }
+
+    /**
+     * Test case for <a href="http://issues.apache.org/jira/browse/XMLRPC-113">
+     * XMLRPC-113</a>
+     */
+    public void testXMLRPC113() throws Exception {
+        for (int i = 0;  i < providers.length;  i++) {
+            testXMLRPC113(providers[i]);
+        }
+    }
+
+
+    private void testXMLRPC112(ClientProvider pProvider) throws Exception {
+        XmlRpcClient client = pProvider.getClient();
+        client.setConfig(getConfig(pProvider));
+        TimingOutCallback toc = new TimingOutCallback(5000);
+        final String methodName = XMLRPC89Handler.class.getName() + ".reverse";
+        client.executeAsync(methodName, new Object[]{new Object[]{"1", "2", "3"}}, toc);
+        Object o;
+        try {
+            o = toc.waitForResponse();
+        } catch (Exception e) {
+            throw e;
+        } catch (Throwable t) {
+            throw new UndeclaredThrowableException(t);
+        }
+        checkXMLRPC112Result(o);
+        checkXMLRPC112Result(client.execute(methodName, new Object[]{new Object[]{"1", "2", "3"}}));
+        checkXMLRPC112Result(client.execute(methodName, new Object[]{new Object[]{"1", "2", "3"}}));
+    }
+
+    private void checkXMLRPC112Result(Object pObject) {
+        Object[] args = (Object[]) pObject;
+        assertEquals(3, args.length);
+        assertEquals("3", args[0]);
+        assertEquals("2", args[1]);
+        assertEquals("1", args[2]);
+    }
+
+    /**
+     * Handler interface for {@link JiraTest#testXMLRPC113()}
+     */ 
+    public interface XMLRPC113Handler {
+        /**
+         * Throws an {@link XmlRpcException} with the given error code.
+         */
+        Object throwCode(int pCode) throws XmlRpcException;
+    }
+
+    /**
+     * Handler for {@link JiraTest#testXMLRPC113()}
+     */ 
+    public static class XMLRPC113HandlerImpl implements XMLRPC113Handler {
+        public Object throwCode(int pCode) throws XmlRpcException {
+            throw new XmlRpcException(pCode, "Message: " + pCode);
+        }
+    }
+
+    private void testXMLRPC113(ClientProvider pProvider) throws Exception {
+        XmlRpcClient client = pProvider.getClient();
+        client.setConfig(getConfig(pProvider));
+        XMLRPC113Handler handler = (XMLRPC113Handler) new ClientFactory(client).newInstance(XMLRPC113Handler.class);
+        for (int i = 0;  i < 5;  i++) {
+            try {
+                client.execute(XMLRPC113Handler.class.getName() + ".throwCode", new Object[]{new Integer(i)});
+                fail("Excpected exception");
+            } catch (XmlRpcException e) {
+                assertEquals(i, e.code);
+            }
+            try {
+                handler.throwCode(i);
+            } catch (XmlRpcException e) {
+                assertEquals(i, e.code);
+            }
+        }
+    }
+
+    /**
+     * Handler for {@link JiraTest#testXMLRPC115()}
+     */
+    public static class XMLRPC115Handler {
+        /**
+         * Does nothing, just for checking, whether the server is alive.
+         */
+        public Object[] ping() {
+            return new Object[0];
+        }
+    }
+
+    /**
+     * Test case for <a href="http://issues.apache.org/jira/browse/XMLRPC-115">
+     * XMLRPC-115</a>
+     */
+    public void testXMLRPC115() throws Exception {
+        for (int i = 0;  i < providers.length;  i++) {
+            testXMLRPC115(providers[i]);
+        }
+    }
+
+    private void testXMLRPC115(ClientProvider pProvider) throws Exception {
+        if (pProvider instanceof SunHttpTransportProvider) {
+            XmlRpcClient client = pProvider.getClient();
+            client.setConfig(getConfig(pProvider));
+            URL url = ((XmlRpcHttpClientConfig) client.getConfig()).getServerURL();
+            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
+            conn.setDoInput(true);
+            conn.setDoOutput(true);
+            conn.setRequestMethod("POST");
+            conn.setRequestProperty("content-type", "text/xml");
+            OutputStream ostream = conn.getOutputStream();
+            Writer w = new OutputStreamWriter(ostream, "UTF-8");
+            w.write("<methodCall><methodName>" + XMLRPC115Handler.class.getName() + ".ping"
+                    + "</methodName></methodCall>");
+            w.close();
+            InputStream istream = conn.getInputStream();
+            XmlRpcResponseParser parser = new XmlRpcResponseParser((XmlRpcStreamRequestConfig) client.getClientConfig(), client.getTypeFactory());
+            XMLReader xr = SAXParsers.newXMLReader();
+            xr.setContentHandler(parser);
+            xr.parse(new InputSource(istream));
+            istream.close();
+            assertTrue(parser.getResult() instanceof Object[]);
+            assertEquals(0, ((Object[]) parser.getResult()).length);
+        }
+    }
+
+    /**
+     * Test case for <a href="http://issues.apache.org/jira/browse/XMLRPC-119">
+     * XMLRPC-119</a>
+     */
+    public void testXMLRPC119() throws Exception {
+        for (int i = 0;  i < providers.length;  i++) {
+            testXMLRPC119(providers[i]);
+        }
+    }
+
+    /** Handler for XMLRPC-119
+     */
+    public static class XMLRPC119Handler {
+        /** Returns a string with a length of "num" Kilobytes.
+         */
+        public String getString(int pSize) {
+            StringBuffer sb = new StringBuffer(pSize*1024);
+            for (int i = 0;  i < pSize*1024;  i++) {
+                sb.append('&');
+            }
+            return sb.toString();
+        }
+    }
+
+    private void testXMLRPC119(ClientProvider pProvider) throws Exception {
+        XmlRpcClient client = pProvider.getClient();
+        client.setConfig(getConfig(pProvider));
+        for (int i = 0;  i < 100;  i+= 10) {
+            String s = (String) client.execute(XMLRPC119Handler.class.getName() + ".getString", new Object[]{new Integer(i)});
+            assertEquals(i*1024, s.length());
+        }
+    }
+}

netty-http-xmlrpc-client/src/test/java/org/xbib/netty/http/xmlrpc/client/test/LiteTransportProvider.java

@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.xbib.netty.http.xmlrpc.client.test;
+
+import org.apache.xmlrpc.client.XmlRpcClient;
+import org.apache.xmlrpc.client.XmlRpcLiteHttpTransportFactory;
+import org.apache.xmlrpc.client.XmlRpcTransportFactory;
+import org.apache.xmlrpc.server.XmlRpcHandlerMapping;
+
+
+/** Provider for testing the
+ * {@link org.apache.xmlrpc.client.XmlRpcLiteHttpTransport}.
+ */
+public class LiteTransportProvider extends WebServerProvider {
+	/** Creates a new instance.
+	 * @param pMapping The test servers handler mapping.
+	 * @param pContentLength Whether a Content-Length header is required.
+	 */
+	public LiteTransportProvider(XmlRpcHandlerMapping pMapping,
+								 boolean pContentLength) {
+		super(pMapping, pContentLength);
+	}
+
+	protected XmlRpcTransportFactory getTransportFactory(XmlRpcClient pClient) {
+		return new XmlRpcLiteHttpTransportFactory(pClient);
+	}
+}

netty-http-xmlrpc-client/src/test/java/org/xbib/netty/http/xmlrpc/client/test/LocalStreamTransportProvider.java

@@ -0,0 +1,52 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.xbib.netty.http.xmlrpc.client.test;
+
+import org.apache.xmlrpc.client.XmlRpcClient;
+import org.apache.xmlrpc.client.XmlRpcLocalStreamTransportFactory;
+import org.apache.xmlrpc.client.XmlRpcTransportFactory;
+import org.apache.xmlrpc.server.XmlRpcHandlerMapping;
+import org.apache.xmlrpc.server.XmlRpcLocalStreamServer;
+import org.apache.xmlrpc.server.XmlRpcServer;
+
+
+/** Implementation of {@link org.apache.xmlrpc.test.BaseTest}
+ * for testing the {@link org.apache.xmlrpc.client.XmlRpcLocalStreamTransport}.
+ */
+public class LocalStreamTransportProvider extends LocalTransportProvider {
+    private XmlRpcLocalStreamServer server;
+
+    /** Creates a new instance.
+	 * @param pMapping The test servers handler mapping.
+	 */
+	public LocalStreamTransportProvider(XmlRpcHandlerMapping pMapping) {
+		super(pMapping);
+	}
+
+	protected XmlRpcTransportFactory getTransportFactory(XmlRpcClient pClient) {
+	    server = new XmlRpcLocalStreamServer();
+        XmlRpcLocalStreamTransportFactory factory
+			= new XmlRpcLocalStreamTransportFactory(pClient, server);
+		return factory;
+	}
+
+    public XmlRpcServer getServer() {
+        return server;
+    }
+}

netty-http-xmlrpc-client/src/test/java/org/xbib/netty/http/xmlrpc/client/test/LocalTransportProvider.java

@@ -0,0 +1,61 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.xbib.netty.http.xmlrpc.client.test;
+
+import org.apache.xmlrpc.client.XmlRpcClient;
+import org.apache.xmlrpc.client.XmlRpcClientConfigImpl;
+import org.apache.xmlrpc.client.XmlRpcLocalTransportFactory;
+import org.apache.xmlrpc.client.XmlRpcTransportFactory;
+import org.apache.xmlrpc.server.XmlRpcHandlerMapping;
+import org.apache.xmlrpc.server.XmlRpcServer;
+
+
+/** Implementation of {@link org.apache.xmlrpc.test.BaseTest}
+ * for testing the {@link org.apache.xmlrpc.client.XmlRpcLocalTransport}.
+ */
+public class LocalTransportProvider extends ClientProviderImpl {
+    private XmlRpcServer server;
+
+    /** Creates a new instance.
+	 * @param pMapping The test servers handler mapping.
+	 */
+	public LocalTransportProvider(XmlRpcHandlerMapping pMapping) {
+		super(pMapping);
+	}
+
+	protected XmlRpcTransportFactory getTransportFactory(XmlRpcClient pClient) {
+		XmlRpcLocalTransportFactory factory = new XmlRpcLocalTransportFactory(pClient);
+		return factory;
+	}
+
+	public XmlRpcClientConfigImpl getConfig() throws Exception {
+		XmlRpcClientConfigImpl config = super.getConfig();
+		server = getXmlRpcServer();
+        config.setXmlRpcServer(server);
+		return config;
+	}
+
+    public XmlRpcServer getServer() {
+        return server;
+    }
+
+    public void shutdown() {
+        // Does nothing
+    }
+}

netty-http-xmlrpc-client/src/test/java/org/xbib/netty/http/xmlrpc/client/test/MetadataTest.java

@@ -0,0 +1,124 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.xbib.netty.http.xmlrpc.client.test;
+
+import java.io.IOException;
+import java.text.Collator;
+import java.util.Arrays;
+import java.util.Locale;
+
+import org.apache.xmlrpc.XmlRpcException;
+import org.apache.xmlrpc.client.XmlRpcClient;
+import org.apache.xmlrpc.client.XmlRpcClientConfig;
+import org.apache.xmlrpc.metadata.XmlRpcSystemImpl;
+import org.apache.xmlrpc.server.PropertyHandlerMapping;
+import org.apache.xmlrpc.server.XmlRpcHandlerMapping;
+
+
+/**
+ * Test class for the introspection stuff.
+ */
+public class MetadataTest extends XmlRpcTestCase {
+    protected XmlRpcHandlerMapping getHandlerMapping() throws IOException,
+            XmlRpcException {
+        PropertyHandlerMapping mapping = new PropertyHandlerMapping();
+        mapping.addHandler("Adder", AuthenticationTest.AdderImpl.class);
+        XmlRpcSystemImpl.addSystemHandler(mapping);
+        return mapping;
+    }
+
+    /**
+     * Test, whether the actual handlers are working.
+     */
+    public void testAdder() throws Exception {
+        for (int i = 0;  i < providers.length;  i++) {
+            testAdder(providers[i]);
+        }
+    }
+
+    private void testAdder(ClientProvider pProvider) throws Exception {
+        XmlRpcClient client = pProvider.getClient();
+        XmlRpcClientConfig config = getConfig(pProvider);
+        client.setConfig(config);
+        Object o = client.execute("Adder.add", new Object[]{new Integer(3), new Integer(5)});
+        assertEquals(new Integer(8), o);
+    }
+
+    /**
+     * Test for system.listMethods.
+     */
+    public void testListMethods() throws Exception {
+        for (int i = 0;  i < providers.length;  i++) {
+            testListMethods(providers[i]);
+        }
+    }
+
+    private void testListMethods(ClientProvider pProvider) throws Exception {
+        XmlRpcClient client = pProvider.getClient();
+        XmlRpcClientConfig config = getConfig(pProvider);
+        client.setConfig(config);
+        Object o = client.execute("system.listMethods", new Object[0]);
+        Object[] methodList = (Object[]) o;
+        Arrays.sort(methodList, Collator.getInstance(Locale.US));
+        assertEquals(4, methodList.length);
+        assertEquals("Adder.add", methodList[0]);
+        assertEquals("system.listMethods", methodList[1]);
+        assertEquals("system.methodHelp", methodList[2]);
+        assertEquals("system.methodSignature", methodList[3]);
+    }
+
+    /**
+     * Test for system.methodHelp.
+     */
+    public void testMethodHelp() throws Exception {
+        for (int i = 0;  i < providers.length;  i++) {
+            testMethodHelp(providers[i]);
+        }
+    }
+
+    private void testMethodHelp(ClientProvider pProvider) throws Exception {
+        XmlRpcClient client = pProvider.getClient();
+        XmlRpcClientConfig config = getConfig(pProvider);
+        client.setConfig(config);
+        String help = (String) client.execute("system.methodHelp", new Object[]{"Adder.add"});
+        assertEquals("Invokes the method org.apache.xmlrpc.test.AuthenticationTest$AdderImpl.add(int, int).", help);
+    }
+
+    /**
+     * Test for system.methodSignature.
+     */
+    public void testMethodSignature() throws Exception {
+        for (int i = 0;  i < providers.length;  i++) {
+            testMethodSignature(providers[i]);
+        }
+    }
+
+    private void testMethodSignature(ClientProvider pProvider) throws Exception {
+        XmlRpcClient client = pProvider.getClient();
+        XmlRpcClientConfig config = getConfig(pProvider);
+        client.setConfig(config);
+        Object[] signatures = (Object[]) client.execute("system.methodSignature", new Object[]{"Adder.add"});
+        assertEquals(signatures.length, 1);
+        Object[] signature = (Object[]) signatures[0];
+        assertEquals(3, signature.length);
+        assertEquals("int", signature[0]);
+        assertEquals("int", signature[1]);
+        assertEquals("int", signature[2]);
+    }
+}

netty-http-xmlrpc-client/src/test/java/org/xbib/netty/http/xmlrpc/client/test/ParserTest.java

@@ -0,0 +1,168 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.xbib.netty.http.xmlrpc.client.test;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.lang.reflect.UndeclaredThrowableException;
+import java.text.ParseException;
+import java.util.TimeZone;
+
+import junit.framework.TestCase;
+
+import org.apache.xmlrpc.XmlRpcException;
+import org.apache.xmlrpc.client.XmlRpcClient;
+import org.apache.xmlrpc.client.XmlRpcClientConfigImpl;
+import org.apache.xmlrpc.common.XmlRpcHttpRequestConfigImpl;
+import org.apache.xmlrpc.common.XmlRpcStreamConfig;
+import org.apache.xmlrpc.common.XmlRpcStreamRequestConfig;
+import org.apache.xmlrpc.parser.DateParser;
+import org.apache.xmlrpc.parser.XmlRpcRequestParser;
+import org.apache.xmlrpc.parser.XmlRpcResponseParser;
+import org.apache.xmlrpc.util.SAXParsers;
+import org.apache.xmlrpc.util.XmlRpcDateTimeFormat;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+import org.xml.sax.XMLReader;
+
+
+/** Test for the various parsers.
+ */
+public class ParserTest extends TestCase {
+	private Object parseResponse(final String s) throws XmlRpcException, IOException, SAXException {
+		return parseResponse(new InputSource(new StringReader(s)));
+	}
+
+    private Object parseResponse(InputSource isource) throws XmlRpcException,
+            IOException, SAXException {
+        XmlRpcStreamRequestConfig config = new XmlRpcClientConfigImpl();
+		XmlRpcClient client = new XmlRpcClient();
+		XmlRpcResponseParser parser = new XmlRpcResponseParser(config, client.getTypeFactory());
+		XMLReader xr = SAXParsers.newXMLReader();
+		xr.setContentHandler(parser);
+        xr.parse(isource);
+		Object o = parser.getResult();
+		return o;
+    }
+
+    private XmlRpcRequestParser parseRequest(final String s) throws XmlRpcException, IOException, SAXException {
+        XmlRpcStreamConfig config = new XmlRpcHttpRequestConfigImpl();
+        XmlRpcClient client = new XmlRpcClient();
+        XmlRpcRequestParser parser = new XmlRpcRequestParser(config, client.getTypeFactory());
+        XMLReader xr = SAXParsers.newXMLReader();
+        xr.setContentHandler(parser);
+        xr.parse(new InputSource(new StringReader(s)));
+        return parser;
+    }
+
+	/** Tests, whether strings can be parsed with,
+	 * or without, the "string" tag.
+	 */
+	public void testStringType() throws Exception {
+		final String[] strings = new String[]{
+			"3", "<string>3</string>",
+			"  <string>3</string>  "
+		};
+		for (int i = 0;  i < strings.length;  i++) {
+			final String s =
+				"<?xml version='1.0' encoding='UTF-8'?>\n"
+				+ "<methodResponse><params><param>\n"
+				+ "<value>" + strings[i] + "</value></param>\n"
+				+ "</params></methodResponse>\n";
+			Object o = parseResponse(s);
+			assertEquals("3", o);
+		}
+	}
+
+	/** Tests, whether nested arrays can be parsed.
+	 */
+	public void testNestedObjectArrays() throws Exception {
+		final String s =
+			"<?xml version='1.0' encoding='UTF-8'?>\n"
+			+ "<methodResponse><params><param>\n"
+			+ "<value><array><data><value><array>\n"
+			+ "<data><value>array</value>\n"
+			+ "<value>string</value></data></array>\n"
+			+ "</value></data></array></value></param>\n"
+			+ "</params></methodResponse>\n";
+		Object o = parseResponse(s);
+		assertTrue(o instanceof Object[]);
+		Object[] outer = (Object[]) o;
+		assertEquals(1, outer.length);
+		o = outer[0];
+		assertTrue(o instanceof Object[]);
+		Object[] inner = (Object[]) o;
+		assertEquals(2, inner.length);
+		assertEquals("array", inner[0]);
+		assertEquals("string", inner[1]);
+	}
+
+	/**
+     * Tests, whether a request may omit the <params> tag.
+	 */
+    public void testOptionalParams() throws Exception {
+        final String s1 = "<methodResponse/>";
+        Object o1 = parseResponse(s1);
+        assertNull(o1);
+
+        final String s2 = "<methodResponse><params/></methodResponse>";
+        Object o2 = parseResponse(s2);
+        assertNull(o2);
+
+        final String s3 = "<methodCall><methodName>foo</methodName></methodCall>";
+        XmlRpcRequestParser p3 = parseRequest(s3);
+        assertEquals("foo", p3.getMethodName());
+        assertNull(p3.getParams());
+
+        final String s4 = "<methodCall><methodName>bar</methodName><params/></methodCall>";
+        XmlRpcRequestParser p4 = parseRequest(s4);
+        assertEquals("bar", p4.getMethodName());
+        assertNotNull(p4.getParams());
+        assertTrue(p4.getParams().size() == 0);
+    }
+
+    /**
+     * Test for XMLRPC-140.
+     */
+    public void testXMLRPC140() throws Exception {
+        DateParser parser = new DateParser(new XmlRpcDateTimeFormat(){
+            private static final long serialVersionUID = 0L;
+            protected TimeZone getTimeZone() {
+                return TimeZone.getDefault();
+            }
+        }){
+            public void setResult(Object pObject){
+                try {
+                    super.setResult((String) pObject);
+                } catch (SAXException e) {
+                    throw new UndeclaredThrowableException(e);
+                }
+            }
+        };
+        try {
+            parser.setResult("20070316T162808Z");
+            fail("Expected exception");
+        } catch (UndeclaredThrowableException e) {
+            SAXParseException spe = (SAXParseException) e.getUndeclaredThrowable();
+            ParseException pe = (ParseException) spe.getException();
+            assertEquals(11, pe.getErrorOffset());
+        }
+    }
+}

netty-http-xmlrpc-client/src/test/java/org/xbib/netty/http/xmlrpc/client/test/ScalabilityTest.java

@@ -0,0 +1,212 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.xbib.netty.http.xmlrpc.client.test;
+
+import java.net.URL;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServlet;
+
+import org.apache.xmlrpc.XmlRpcException;
+import org.apache.xmlrpc.client.XmlRpcClient;
+import org.apache.xmlrpc.client.XmlRpcClientConfigImpl;
+import org.apache.xmlrpc.server.PropertyHandlerMapping;
+import org.apache.xmlrpc.server.XmlRpcHandlerMapping;
+import org.apache.xmlrpc.util.ThreadPool;
+import org.apache.xmlrpc.webserver.ServletWebServer;
+import org.apache.xmlrpc.webserver.WebServer;
+import org.apache.xmlrpc.webserver.XmlRpcServlet;
+
+import junit.framework.TestCase;
+
+
+/**
+ * Tests the frameworks scalability.
+ */
+public class ScalabilityTest extends TestCase {
+    /**
+     * Primitive handler class
+     */
+    public static class Adder {
+        /**
+         * Returns the sum of the numbers p1 and p2.
+         */
+        public int add(int p1, int p2) {
+            return p1 + p2;
+        }
+    }
+
+    private class MyServletWebServer extends ServletWebServer {
+        protected ThreadPool pool;
+        MyServletWebServer(HttpServlet pServlet, int pPort)
+                throws ServletException {
+            super(pServlet, pPort);
+        }
+        public ThreadPool newThreadPool(){
+            pool = new ThreadPool(getXmlRpcServer().getMaxThreads(), "XML-RPC"){
+            };
+            return pool;
+        }
+        int getNumThreads() {
+            return pool.getNumThreads();
+        }
+    }
+
+    private class MyWebServer extends WebServer {
+        protected ThreadPool pool;
+        MyWebServer(int pPort) {
+            super(pPort);
+        }
+        public ThreadPool newThreadPool(){
+            pool = new ThreadPool(getXmlRpcServer().getMaxThreads(), "XML-RPC"){
+            };
+            return pool;
+        }
+        int getNumThreads() {
+            return pool.getNumThreads();
+        }
+    }
+    
+    private static final int BASE = 1;
+    private static final Integer THREE = new Integer(3);
+    private static final Integer FIVE = new Integer(5);
+    private static final Integer EIGHT = new Integer(8);
+    private XmlRpcServlet servlet;
+    private MyServletWebServer server;
+    private MyWebServer webServer;
+
+    private XmlRpcHandlerMapping newXmlRpcHandlerMapping() throws XmlRpcException {
+        PropertyHandlerMapping mapping = new PropertyHandlerMapping();
+        mapping.addHandler("Adder", Adder.class);
+        return mapping;
+    }
+
+    private void initServletWebServer() throws Exception {
+        servlet = new XmlRpcServlet(){
+            private static final long serialVersionUID = -2040521497373327817L;
+            protected XmlRpcHandlerMapping newXmlRpcHandlerMapping()
+                    throws XmlRpcException {
+                return ScalabilityTest.this.newXmlRpcHandlerMapping();
+
+            }
+            
+        };
+        server = new MyServletWebServer(servlet, 0);
+        server.getXmlRpcServer().setMaxThreads(25);
+        server.start();
+    }
+
+    private void shutdownServletWebServer() {
+        server.shutdown();
+    }
+
+    private void initWebServer() throws Exception {
+        webServer = new MyWebServer(0);
+        webServer.getXmlRpcServer().setHandlerMapping(newXmlRpcHandlerMapping());
+        webServer.getXmlRpcServer().setMaxThreads(25);
+        webServer.start();
+    }
+
+    private void shutdownWebServer() {
+        webServer.shutdown();
+    }
+
+    /**
+     * Runs the test with a single client.
+     */
+    public void testSingleClient() throws Exception {
+        initServletWebServer();
+        boolean ok = false;
+        try {
+            long now = System.currentTimeMillis();
+            servlet.getXmlRpcServletServer().setMaxThreads(1);
+            new Client(100*BASE, server.getPort()).run();
+            System.out.println("Single client: " + (System.currentTimeMillis()-now) + ", " + server.getNumThreads());
+            shutdownServletWebServer();
+            ok = true;
+        } finally {
+            if (!ok) { try { shutdownServletWebServer(); } catch (Throwable t) {} }
+        }
+    }
+
+    /**
+     * Runs the web server test with a single client.
+     */
+    public void testSingleWebServerClient() throws Exception {
+        initWebServer();
+        boolean ok = false;
+        try {
+            long now = System.currentTimeMillis();
+            webServer.getXmlRpcServer().setMaxThreads(1);
+            new Client(100*BASE, webServer.getPort()).run();
+            System.out.println("Single client: " + (System.currentTimeMillis()-now) + ", " + webServer.getNumThreads());
+            shutdownWebServer();
+            ok = true;
+        } finally {
+            if (!ok) { try { shutdownWebServer(); } catch (Throwable t) {} }
+        }
+    }
+
+    private static class Client implements Runnable {
+        private final int iterations;
+        private final int port;
+        Client(int pIterations, int pPort) {
+            iterations = pIterations;
+            port = pPort;
+        }
+        public void run() {
+            try {
+                XmlRpcClient client = new XmlRpcClient();
+                XmlRpcClientConfigImpl config = new XmlRpcClientConfigImpl();
+                config.setServerURL(new URL("http://127.0.0.1:" + port + "/"));
+                client.setConfig(config);
+                for (int i = 0;  i < iterations;  i++) {
+                    assertEquals(EIGHT, client.execute("Adder.add", new Object[]{THREE, FIVE}));
+                }
+            } catch (Throwable t) {
+                t.printStackTrace();
+            }
+        }
+    }
+
+    /**
+     * Runs the test with ten clients.
+     */
+    public void testTenClient() throws Exception {
+        initServletWebServer();
+        boolean ok = false;
+        try {
+            final Thread[] threads = new Thread[10];
+            servlet.getXmlRpcServletServer().setMaxThreads(10);
+            long now = System.currentTimeMillis();
+            for (int i = 0;  i < threads.length;  i++) {
+                threads[i] = new Thread(new Client(10*BASE, server.getPort()));
+                threads[i].start();
+            }
+            for (int i = 0;  i < threads.length;  i++) {
+                threads[i].join();
+            }
+            System.out.println("Ten clients: " + (System.currentTimeMillis() - now) + ", " + server.getNumThreads());
+            shutdownServletWebServer();
+            ok = false;
+        } finally {
+            if (!ok) { try { shutdownServletWebServer(); } catch (Throwable t) {} }
+        }
+    }
+}

netty-http-xmlrpc-client/src/test/java/org/xbib/netty/http/xmlrpc/client/test/SerializerTest.java

@@ -0,0 +1,187 @@
+package org.xbib.netty.http.xmlrpc.client.test;
+
+import java.io.StringReader;
+import java.util.Calendar;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TimeZone;
+
+import javax.xml.parsers.SAXParserFactory;
+
+import junit.framework.TestCase;
+
+import org.xbib.netty.http.xmlrpc.client.XmlRpcClient;
+import org.xbib.netty.http.xmlrpc.client.XmlRpcClientConfig;
+import org.xbib.netty.http.xmlrpc.client.XmlRpcClientConfigImpl;
+import org.xbib.netty.http.xmlrpc.client.XmlRpcClientRequestImpl;
+import org.xbib.netty.http.xmlrpc.client.XmlRpcSunHttpTransportFactory;
+import org.xbib.netty.http.xmlrpc.common.TypeFactoryImpl;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcRequest;
+import org.xbib.netty.http.xmlrpc.common.XmlRpcStreamRequestConfig;
+import org.xbib.netty.http.xmlrpc.common.parser.XmlRpcRequestParser;
+import org.xbib.netty.http.xmlrpc.server.XmlRpcServer;
+import org.xbib.netty.http.xmlrpc.server.XmlRpcServerConfigImpl;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xml.sax.XMLReader;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+
+/** A test case for the various serializers.
+ */
+public class SerializerTest extends TestCase {
+	private final XmlRpcClient client;
+
+	/** Creates a new instance.
+	 */
+	public SerializerTest() {
+		client = new XmlRpcClient();
+		client.setTransportFactory(new XmlRpcSunHttpTransportFactory(client));
+	}
+
+	protected XmlRpcClientConfigImpl getConfig() {
+		XmlRpcClientConfigImpl config = new XmlRpcClientConfigImpl();
+		return config;
+	}
+
+	protected XmlRpcStreamRequestConfig getExConfig() {
+		XmlRpcClientConfigImpl config = getConfig();
+		config.setEnabledForExtensions(true);
+		return config;
+	}
+
+	protected String writeRequest(XmlRpcStreamRequestConfig pConfig, XmlRpcRequest pRequest)
+			throws SAXException {
+        client.setConfig((XmlRpcClientConfig) pConfig);
+        return XmlRpcTestCase.writeRequest(client, pRequest);
+	}
+
+	/** Test serialization of a byte parameter.
+	 * @throws Exception The test failed.
+	 */
+	public void testByteParam() throws Exception {
+		XmlRpcStreamRequestConfig config = getExConfig();
+		XmlRpcRequest request = new XmlRpcClientRequestImpl(config, "byteParam", new Object[]{new Byte((byte)3)});
+		String got = writeRequest(config, request);
+		String expect =
+			"<?xml version=\"1.0\" encoding=\"US-ASCII\"?>"
+			+ "<methodCall xmlns:ex=\"http://ws.apache.org/xmlrpc/namespaces/extensions\">"
+			+ "<methodName>byteParam</methodName><params><param><value><ex:i1>3</ex:i1></value></param></params></methodCall>";
+		assertEquals(expect, got);
+	}
+
+	/** Test serialization of an integer parameter.
+	 * @throws Exception The test failed.
+	 */
+	public void testIntParam() throws Exception {
+		XmlRpcStreamRequestConfig config = getConfig();
+		XmlRpcRequest request = new XmlRpcClientRequestImpl(config, "intParam", new Object[]{new Integer(3)});
+		String got = writeRequest(config, request);
+		String expect =
+			"<?xml version=\"1.0\" encoding=\"US-ASCII\"?>"
+			+ "<methodCall>"
+			+ "<methodName>intParam</methodName><params><param><value><i4>3</i4></value></param></params></methodCall>";
+		assertEquals(expect, got);
+	}
+
+	/** Test serialization of a byte array.
+	 * @throws Exception The test failed.
+	 */
+	public void testByteArrayParam() throws Exception {
+		byte[] bytes = new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+		XmlRpcStreamRequestConfig config = getConfig();
+		XmlRpcRequest request = new XmlRpcClientRequestImpl(config, "byteArrayParam", new Object[]{bytes});
+		String got = writeRequest(config, request);
+		String expect =
+			"<?xml version=\"1.0\" encoding=\"US-ASCII\"?>"
+			+ "<methodCall>"
+			+ "<methodName>byteArrayParam</methodName><params><param><value><base64>AAECAwQFBgcICQ==</base64></value></param></params></methodCall>";
+		assertEquals(expect, got);
+	}
+
+	/** Test serialization of a map.
+	 * @throws Exception The test failed.
+	 */
+	public void testMapParam() throws Exception {
+		final Map map = new HashMap();
+		map.put("2", new Integer(3));
+		map.put("3", new Integer(5));
+		final Object[] params = new Object[]{map};
+		XmlRpcStreamRequestConfig config = getConfig();
+		XmlRpcRequest request = new XmlRpcClientRequestImpl(config, "mapParam", params);
+		String got = writeRequest(config, request);
+		String expect =
+			"<?xml version=\"1.0\" encoding=\"US-ASCII\"?>"
+			+ "<methodCall><methodName>mapParam</methodName>"
+			+ "<params><param><value><struct>"
+			+ "<member><name>3</name><value><i4>5</i4></value></member>"
+			+ "<member><name>2</name><value><i4>3</i4></value></member>"
+			+ "</struct></value></param></params></methodCall>";
+		assertEquals(expect, got);
+	}
+
+	/** Tests serialization of a calendar instance.
+	 */
+    public void testCalendarParam() throws Exception {
+        TimeZone tz = TimeZone.getTimeZone("GMT");
+        Calendar cal1 = Calendar.getInstance(tz);
+        cal1.set(1933, 5, 12, 11, 7, 21);
+        cal1.set(Calendar.MILLISECOND, 311);
+        Calendar cal2 = Calendar.getInstance(TimeZone.getDefault());
+        cal2.set(1933, 5, 12, 11, 7, 21);
+        cal2.set(Calendar.MILLISECOND, 311);
+        XmlRpcStreamRequestConfig config = getExConfig();
+        XmlRpcRequest request = new XmlRpcClientRequestImpl(config, "dateParam", new Object[]{cal1, cal2.getTime()});
+        String got = writeRequest(config, request);
+        String expect =
+            "<?xml version=\"1.0\" encoding=\"US-ASCII\"?>"
+            + "<methodCall xmlns:ex=\"http://ws.apache.org/xmlrpc/namespaces/extensions\">"
+            + "<methodName>dateParam</methodName><params>"
+            + "<param><value><ex:dateTime>1933-06-12T11:07:21.311Z</ex:dateTime></value></param>"
+            + "<param><value><dateTime.iso8601>19330612T11:07:21</dateTime.iso8601></value></param>"
+            + "</params></methodCall>";
+        assertEquals(expect, got);
+    }
+
+    /**
+     * Test for XMLRPC-127: Is it possible to transmit a
+     * map with integers as the keys?
+     */
+    public void testIntegerKeyMap() throws Exception {
+        Map map = new HashMap();
+        map.put(new Integer(1), "one");
+        XmlRpcStreamRequestConfig config = getExConfig();
+        XmlRpcRequest request = new XmlRpcClientRequestImpl(config, "integerKeyMap", new Object[]{map});
+        String got = writeRequest(config, request);
+        String expect =
+            "<?xml version=\"1.0\" encoding=\"US-ASCII\"?>"
+            + "<methodCall xmlns:ex=\"http://ws.apache.org/xmlrpc/namespaces/extensions\">"
+            + "<methodName>integerKeyMap</methodName><params>"
+            + "<param><value><struct><member>"
+            +   "<name><value><i4>1</i4></value></name>"
+            +   "<value>one</value></member>"
+            + "</struct></value></param>"
+            + "</params></methodCall>";
+        assertEquals(expect, got);
+
+        XmlRpcServer server = new XmlRpcServer();
+        XmlRpcServerConfigImpl serverConfig = new XmlRpcServerConfigImpl();
+        serverConfig.setEnabledForExtensions(true);
+        server.setConfig(serverConfig);
+        XmlRpcRequestParser parser = new XmlRpcRequestParser(serverConfig, new TypeFactoryImpl(server));
+        SAXParserFactory spf = SAXParserFactory.newInstance();
+        spf.setValidating(false);
+        spf.setNamespaceAware(true);
+        XMLReader xr = spf.newSAXParser().getXMLReader();
+        xr.setContentHandler(parser);
+        xr.parse(new InputSource(new StringReader(expect)));
+        assertEquals("integerKeyMap", parser.getMethodName());
+        List params = parser.getParams();
+        assertEquals(1, params.size());
+        Map paramMap = (Map) params.get(0);
+        assertEquals(1, paramMap.size());
+        assertEquals("one", paramMap.get(new Integer(1)));
+    }
+}

netty-http-xmlrpc-client/src/test/java/org/xbib/netty/http/xmlrpc/client/test/ServletWebServerProvider.java

@@ -0,0 +1,75 @@
+package org.xbib.netty.http.xmlrpc.client.test;
+
+import org.xbib.netty.http.xmlrpc.client.XmlRpcClient;
+import org.xbib.netty.http.xmlrpc.client.XmlRpcClientConfigImpl;
+import org.xbib.netty.http.xmlrpc.client.XmlRpcSunHttpTransportFactory;
+import org.xbib.netty.http.xmlrpc.client.XmlRpcTransportFactory;
+import org.xbib.netty.http.xmlrpc.server.XmlRpcHandlerMapping;
+import org.xbib.netty.http.xmlrpc.server.XmlRpcServer;
+import org.xbib.netty.http.xmlrpc.server.XmlRpcServerConfigImpl;
+import org.xbib.netty.http.xmlrpc.servlet.ServletWebServer;
+import org.xbib.netty.http.xmlrpc.servlet.XmlRpcServlet;
+
+import javax.servlet.ServletException;
+import java.io.IOException;
+import java.net.URL;
+
+/**
+ * A provider class for testing the {@link ServletWebServer}.
+ */
+public class ServletWebServerProvider extends ClientProviderImpl {
+	protected final ServletWebServer webServer;
+    protected final XmlRpcServlet servlet;
+	private final boolean contentLength;
+	private final int port;
+
+	/**
+	 * Creates a new instance of {@link XmlRpcServlet}.
+	 */
+	protected XmlRpcServlet newXmlRpcServlet() {
+	    return new XmlRpcServlet();
+    }
+	
+	/** Creates a new instance.
+	 * @param pMapping The test servers handler mapping.
+	 * @throws ServletException 
+	 * @throws IOException 
+	 */
+	protected ServletWebServerProvider(XmlRpcHandlerMapping pMapping, boolean pContentLength) throws ServletException, IOException {
+		super(pMapping);
+		contentLength = pContentLength;
+		servlet = newXmlRpcServlet();
+		webServer = new ServletWebServer(servlet, 0);
+		XmlRpcServer server = servlet.getXmlRpcServletServer();
+		server.setHandlerMapping(mapping);
+		XmlRpcServerConfigImpl serverConfig = (XmlRpcServerConfigImpl) server.getConfig();
+		serverConfig.setEnabledForExtensions(true);
+		serverConfig.setContentLengthOptional(!contentLength);
+        serverConfig.setEnabledForExceptions(true);
+		webServer.start();
+		port = webServer.getPort();
+	 }
+
+	public final XmlRpcClientConfigImpl getConfig() throws Exception {
+		return getConfig(new URL("http://127.0.0.1:" + port + "/"));
+	}
+
+	protected XmlRpcClientConfigImpl getConfig(URL pServerURL) throws Exception {
+		XmlRpcClientConfigImpl config = super.getConfig();
+		config.setServerURL(pServerURL);
+		config.setContentLengthOptional(!contentLength);
+		return config;
+	}
+
+	protected XmlRpcTransportFactory getTransportFactory(XmlRpcClient pClient) {
+		return new XmlRpcSunHttpTransportFactory(pClient);
+	}
+
+    public XmlRpcServer getServer() {
+        return servlet.getXmlRpcServletServer();
+    }
+
+    public void shutdown() {
+        webServer.shutdown();
+    }
+}

netty-http-xmlrpc-client/src/test/java/org/xbib/netty/http/xmlrpc/client/test/SunHttpTransportProvider.java

@@ -0,0 +1,23 @@
+package org.xbib.netty.http.xmlrpc.client.test;
+
+import org.xbib.netty.http.xmlrpc.client.XmlRpcClient;
+import org.xbib.netty.http.xmlrpc.client.XmlRpcSunHttpTransportFactory;
+import org.xbib.netty.http.xmlrpc.client.XmlRpcTransportFactory;
+import org.xbib.netty.http.xmlrpc.server.XmlRpcHandlerMapping;
+
+/** Implementation of {@link BaseTest} for testing the
+ * {@link XmlRpcSunHttpTransport}.
+ */
+public class SunHttpTransportProvider extends WebServerProvider {
+	/** Creates a new instance.
+	 * @param pMapping The test servers handler mapping.
+	 * @param pContentLength Number of bytes being transmitted.
+	 */
+	public SunHttpTransportProvider(XmlRpcHandlerMapping pMapping, boolean pContentLength) {
+		super(pMapping, pContentLength);
+	}
+
+	protected XmlRpcTransportFactory getTransportFactory(XmlRpcClient pClient) {
+		return new XmlRpcSunHttpTransportFactory(pClient);
+	}
+}