mosgi.jmx.httpconnector/src/main/java/org/apache/felix/mosgi/jmx/httpconnector/mx4j/tools/adaptor/http/HttpAdaptor.java

/*
 *  Copyright (C) MX4J.
 *  All rights reserved.
 *
 *  This software is distributed under the terms of the MX4J License version 1.0.
 *  See the terms of the MX4J License in the documentation provided with this software.
 */
/*
 *   Copyright 2005 The Apache Software Foundation
 *
 *   Licensed 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.apache.felix.mosgi.jmx.httpconnector.mx4j.tools.adaptor.http;

import java.io.IOException;
import java.io.InputStream;
import java.io.InterruptedIOException;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.StringTokenizer;
import javax.management.JMException;
import javax.management.MBeanRegistration;
import javax.management.MBeanServer;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;

import org.osgi.framework.ServiceReference;
import org.osgi.service.log.LogService;

import org.apache.felix.mosgi.jmx.httpconnector.mx4j.tools.adaptor.AdaptorServerSocketFactory;
import org.apache.felix.mosgi.jmx.httpconnector.mx4j.tools.adaptor.PlainAdaptorServerSocketFactory;

import org.apache.felix.mosgi.jmx.agent.mx4j.util.Base64Codec;

import org.apache.felix.mosgi.jmx.httpconnector.HttpConnectorActivator;

import org.apache.felix.mosgi.jmx.httpconnector.mx4j.tools.adaptor.http.ServerCommandProcessor;
import org.apache.felix.mosgi.jmx.httpconnector.mx4j.tools.adaptor.http.ServerByDomainCommandProcessor;
import org.apache.felix.mosgi.jmx.httpconnector.mx4j.tools.adaptor.http.MBeanCommandProcessor;
import org.apache.felix.mosgi.jmx.httpconnector.mx4j.tools.adaptor.http.SetAttributesCommandProcessor;
import org.apache.felix.mosgi.jmx.httpconnector.mx4j.tools.adaptor.http.DeleteMBeanCommandProcessor;
import org.apache.felix.mosgi.jmx.httpconnector.mx4j.tools.adaptor.http.InvokeOperationCommandProcessor;
import org.apache.felix.mosgi.jmx.httpconnector.mx4j.tools.adaptor.http.CreateMBeanCommandProcessor;
import org.apache.felix.mosgi.jmx.httpconnector.mx4j.tools.adaptor.http.ConstructorsCommandProcessor;
import org.apache.felix.mosgi.jmx.httpconnector.mx4j.tools.adaptor.http.EmptyCommandProcessor;

/**
 * HttpAdaptor sets the basic adaptor listening for HTTP requests
 *
 * @author    <a href="mailto:tibu@users.sourceforge.net">Carlos Quiroz</a>
 * @version   $Revision: 1.1.1.1 $
 */
public class HttpAdaptor implements HttpAdaptorMBean, MBeanRegistration
{
	private static final String VERSION = "2.0 Beta 1";

	/** Port to listen for connections */
	private int port = 8080;

	/** Host where to set the server socket */
	private String host = "localhost";

	/** Target server */
	private MBeanServer server;

	/** Server socket */
	private ServerSocket serverSocket;

	/** Indicates whether the server is running */
	private boolean alive;

	/** Map of commands indexed by the request path */
	private Map commands = new HashMap();

	/** Target processor */
	private ProcessorMBean processor = null;

	/** Target processor name */
	private ObjectName processorName = null;

	/** Default processor */
	private ProcessorMBean defaultProcessor = new DefaultProcessor();

	private String authenticationMethod = "none";

	// Should be dependant on the server?
	private String realm="MX4J";

	private Map authorizations = new HashMap();

	private AdaptorServerSocketFactory socketFactory = null;

	private ObjectName factoryName;

	private String processorClass;

	private Date startDate;

	private long requestsCount;

	private String[][] defaultCommandProcessors = {
		{"server", ServerCommandProcessor.class.getName()},
		{"serverbydomain", ServerByDomainCommandProcessor.class.getName()},
		{"mbean", MBeanCommandProcessor.class.getName()},
		{"setattributes", SetAttributesCommandProcessor.class.getName()},
		{"setattribute", SetAttributeCommandProcessor.class.getName()},
		{"getattribute", GetAttributeCommandProcessor.class.getName()},
		{"delete", DeleteMBeanCommandProcessor.class.getName()},
		{"invoke", InvokeOperationCommandProcessor.class.getName()},
		{"create", CreateMBeanCommandProcessor.class.getName()},
		{"constructors", ConstructorsCommandProcessor.class.getName()},
		{"empty", EmptyCommandProcessor.class.getName()}};

//		{"relation", "mx4j.tools.adaptor.http.RelationCommandProcessor"},

	private DocumentBuilder builder;

	/**
	 * Default Constructor added so that we can have some additional
	 * constructors as well.
	 */
	public HttpAdaptor()
	{
	}

	/**
	 * Overloaded constructor to allow the port to be set.
	 * The reason this was added was to allow the loading of this adaptor by
	 * the dynamic loading service of the MBean server and have the port set
	 * from a param in the mlet file. Example: (replaced lt & gt symbol with [])
	 * <br>[mlet code="mx4j.tools.adaptor.http.HttpAdaptor"
	 * <br>      archive="mx4j.jar"
	 * <br>      name="Server:name=HttpAdaptor"]
	 * <br>   [arg type="int" value="12345"]
	 * <br>[/mlet]
	 *
	 * <p>This constructor uses the default host or the host must be set later.
	 * @param port The port on which the HttpAdaptor should listen
	 */
	public HttpAdaptor(int port)
	{
		this.port = port;
	}


	/**
	 * Overloaded constructor to allow the host to be set.
	 * The reason this was added was to allow the loading of this adaptor by
	 * the dynamic loading service of the MBean server and have the host set
	 * from a param in the mlet file. Example: (replaced lt & gt symbol with [])
	 * <br>[mlet code="mx4j.tools.adaptor.http.HttpAdaptor"
	 * <br>      archive="mx4j.jar"
	 * <br>      name="Server:name=HttpAdaptor"]
	 * <br>   [arg type="java.lang.String" value="someserver.somehost.com"]
	 * <br>[/mlet]
	 *
	 * <p>This constructor uses the default port or the port must be set later.
	 * @param host The host on which the HttpAdaptor should listen
	 */
	public HttpAdaptor(String host)
	{
		this.host = host;
	}


	/**
	 * Overloaded constructor to allow the port to be set.
	 * The reason this was added was to allow the loading of this adaptor by
	 * the dynamic loading service of the MBean server and have the port set
	 * from a param in the mlet file. Example: (replaced lt & gt symbol with [])
	 * NOTE that the port must come before the host in the arg list of the mlet
	 * <br>[mlet code="mx4j.tools.adaptor.http.HttpAdaptor"
	 * <br>      archive="mx4j.jar"
	 * <br>      name="Server:name=HttpAdaptor"]
	 * <br>   [arg type="int" value="12345"]
	 * <br>   [arg type="java.lang.String" value="someserver.somehost.com"]
	 * <br>[/mlet]
	 *
	 * @param port The port on which the HttpAdaptor should listen
	 * @param host The host on which the HttpAdaptor should listen
	 */
	public HttpAdaptor(int port, String host)
	{
		this.port = port;
		this.host = host;
	}


	/**
	 * Sets the value of the server's port
	 *
	 * @param port  the new port's value
	 */
	public void setPort(int port)
	{
		if (alive)
		{
			throw new IllegalArgumentException("Not possible to change port with the server running");
		}
		this.port = port;
	}


	/**
	 * Returns the port where the server is running on. Default is 8080
	 *
	 * @return   HTTPServer's port
	 */
	public int getPort()
	{
		return port;
	}


	/**
	 * Sets the host name where the server will be listening
	 *
	 * @param host  Server's host
	 */
	public void setHost(String host)
	{
		if (alive)
		{
			throw new IllegalArgumentException("Not possible to change port with the server running");
		}
		this.host = host;
	}


	/**
	 * Return the host name the server will be listening to. If null the server
	 * listen at the localhost
	 *
	 * @return   the current hostname
	 */
	public String getHost()
	{
		return host;
	}


	/**
	 * Sets the Authentication Method.
	 *
	 * @param method none/basic/digest
	 */
	public void setAuthenticationMethod(String method) {
		if (alive)
		{
			throw new IllegalArgumentException("Not possible to change authentication method with the server running");
		}
		if (method == null || !(method.equals("none") || method.equals("basic") || method.equals("digest")))
		{
			throw new IllegalArgumentException("Only accept methods none/basic/digest");
		}
		this.authenticationMethod = method;
	}


	/**
	 * Authentication Method
	 *
	 * @return authentication method
	 */
	public String getAuthenticationMethod()
	{
		return authenticationMethod;
	}


	/**
	 * Sets the object which will post process the XML results. The last value set
	 * between the setPostProcessor and setPostProcessorName will be the valid one
	 *
	 * @param processor  a Post processor object
	 */
	public void setProcessor(ProcessorMBean processor)
	{
		this.processor = processor;
		this.processorName = null;
	}


	/**
	 * Sets the classname of the object which will post process the XML results. The adaptor
	 * will try to build the object and use the processor name ObjectName to register it
	 * The class name has to implements mx4j.tools.adaptor.http.ProcessorMBean and be MBean
	 * compliant
	 * @param processorClass  a Post processor object
	 */
	public void setProcessorClass(String processorClass)
	{
		this.processorClass = processorClass;
	}


	/**
	 * Sets the object name of the PostProcessor MBean. If ProcessorClass is set the processor
	 * will be created
	 * @param processorName  a Post processor object
	 */
	public void setProcessorNameString(String processorName) throws MalformedObjectNameException
	{
		this.processorName = new ObjectName(processorName);
	}


	/**
	 * Sets the object name which will post process the XML result. The last value
	 * set between the setPostProcessor and setPostProcessorName will be the valid
	 * one. The MBean will be verified to be of instance HttpPostProcessor
	 * @param processorName  The new processorName value
	 */
	public void setProcessorName(ObjectName processorName)
	{
		this.processor = null;
		this.processorName = processorName;
	}

	public ProcessorMBean getProcessor()
	{
		return this.processor;
	}

	public ObjectName getProcessorName()
	{
		return this.processorName;
	}

	/**
	 * Sets the object which create the server sockets
	 *
	 * @param factory the socket factory
	 */
	public void setSocketFactory(AdaptorServerSocketFactory factory)
	{
		this.factoryName = null;
		this.socketFactory = factory;
	}


	/**
	 * Sets the factory's object name which will create the server sockets
	 *
	 * @param factoryName the socket factory
	 */
	public void setSocketFactoryName(ObjectName factoryName)
	{
		this.socketFactory = null;
		this.factoryName = factoryName;
	}


		/**
	 * Sets the factory's object name which will create the server sockets
	 *
	 * @param factoryName the socket factory
	 */
	public void setSocketFactoryNameString(String factoryName) throws MalformedObjectNameException
	{
		this.socketFactory = null;
		this.factoryName = new ObjectName(factoryName);
	}


	/**
	 * Indicates whether the server's running
	 *
	 * @return        The active value
	 */
	public boolean isActive()
	{
		return alive;
	}


	/**
	 * Starting date
	 *
	 * @return        The date when the server was started
	 */
	public Date getStartDate()
	{
		return startDate;
	}


	/**
	 * Requests count
	 *
	 * @return        The total of requests served so far
	 */
	public long getRequestsCount()
	{
		return requestsCount;
	}


	/**
	 * Gets the HttpAdaptor version
	 *
	 * @return        HttpAdaptor's version
	 */
	public String getVersion()
	{
		return VERSION;
	}


	/**
	 * Adds a command processor object
	 */
	public void addCommandProcessor(String path, HttpCommandProcessor processor)
	{
		commands.put(path, processor);
		if (alive)
		{
			processor.setMBeanServer(server);
			processor.setDocumentBuilder(builder);
		}
	}


	/**
	 * Adds a command processor object by class
	 */
	public void addCommandProcessor(String path, String processorClass)
	{
		try
		{
			HttpCommandProcessor processor = (HttpCommandProcessor)Class.forName(processorClass).newInstance();
			addCommandProcessor(path, processor);
		}
		catch (Exception e)
		{
       HttpAdaptor.log(LogService.LOG_ERROR,
                "Exception creating Command Processor of class " + processorClass,
                e);
		}
	}


	/**
	 * Removes a command processor object by class
	 */
	public void removeCommandProcessor(String path)
	{
		if (commands.containsKey(path))
		{
			commands.remove(path);
		}
	}


	/**
	 * Starts the server
	 */
	public void start()
		throws IOException
	{

		if (server != null)
		{
			serverSocket = createServerSocket();

			if (serverSocket == null)
			{
        HttpAdaptor.log(LogService.LOG_ERROR, "Server socket is null", null);
				return;
			}

			if (processorClass != null && processorName != null)
			{
        HttpAdaptor.log(LogService.LOG_INFO,"Building processor class of type " + processorClass + " and name " + processorName, null);
				try {
					server.createMBean(processorClass, processorName, null);
				} catch (JMException e) {
          HttpAdaptor.log(LogService.LOG_INFO, "Exception creating processor class", e);
				}
			}

			Iterator i = commands.values().iterator();
			while (i.hasNext())
			{
				HttpCommandProcessor processor = (HttpCommandProcessor)i.next();
				processor.setMBeanServer(server);
				processor.setDocumentBuilder(builder);
			}

      HttpAdaptor.log(LogService.LOG_INFO, "HttpAdaptor server listening on port " + port, null);
			alive = true;
			Thread serverThread = new Thread(
				new Runnable() {
					public void run() {
            HttpAdaptor.log(LogService.LOG_INFO, "HttpAdaptor version " + VERSION + " started",null);

						startDate = new Date();
						requestsCount = 0;

						while (alive)
						{
							try
							{
								Socket client = null;
								client = serverSocket.accept();
								if (!alive)
								{
									break;
								}
								requestsCount++;
								new HttpClient(client).start();
							}
							catch (InterruptedIOException e)
							{
								continue;
							}
							catch (IOException e)
							{
								continue;
							}
							catch (Exception e)
							{
                HttpAdaptor.log(LogService.LOG_WARNING, "Exception during request processing", e);
								continue;
							}
							catch (Error e)
							{
                HttpAdaptor.log(LogService.LOG_ERROR, "Error during request processing", e);
								continue;
							}
						}
						try {
							serverSocket.close();
						} catch (IOException e) {
              HttpAdaptor.log(LogService.LOG_WARNING, "Exception closing the server", e);
						}
						serverSocket = null;
						alive = false;
						HttpAdaptor.log(LogService.LOG_INFO, "Server stopped", null);
					}
				});
			serverThread.start();
		}
		else
		{
			HttpAdaptor.log(LogService.LOG_INFO,"Start failed, no server target server has been set",null);
		}
	}


	/**
	 * Restarts the server. Useful when changing the Server parameters
	 *
	 * @deprecated as of RC 1
	 */
	public void restart()
		throws IOException
	{
		stop();
		start();
	}


	/**
	 * Stops the HTTP daemon
	 */
	public void stop()
	{
		try
		{
			if (alive)
			{
				alive = false;
				// force the close with a socket call
				new Socket(host, port);
			}
		}
		catch (IOException e)
		{
			HttpAdaptor.log(LogService.LOG_WARNING,e.getMessage(),e);
		}
		try {
			if (serverSocket != null)
			{
				serverSocket.close();
			}
		}
		catch (IOException e)
		{
			HttpAdaptor.log(LogService.LOG_WARNING,e.getMessage(),e);
		}
	}


	/**
	 * Adds an authorization pair as username/password
	 */
	public void addAuthorization(String username, String password)
	{
		if (username == null || password == null)
		{
			throw new IllegalArgumentException("username and passwords cannot be null");
		}
		authorizations.put(username, password);
	}


	/**
	 * Gathers some basic data
	 */
	public ObjectName preRegister(MBeanServer server, ObjectName name)
		throws java.lang.Exception
	{
		this.server = server;
		buildCommands();
		return name;
	}


	public void postRegister(Boolean registrationDone) { }


	public void preDeregister()
		throws java.lang.Exception
	{
		// stop the server
		stop();
	}

	public void postDeregister() { }

	private ServerSocket createServerSocket() throws IOException
	{
		if (socketFactory == null)
		{
			if (factoryName == null)
			{
				socketFactory = new PlainAdaptorServerSocketFactory();
				return socketFactory.createServerSocket(port, 50, host);
			}
			else
			{
				try
				{
					return (ServerSocket)server.invoke(factoryName, "createServerSocket", new Object[] {new Integer(port), new Integer(50), host}, new String[] {"int", "int", "java.lang.String"});
				}
				catch (Exception x)
				{
					HttpAdaptor.log(LogService.LOG_ERROR,"Exception invoking AdaptorServerSocketFactory via MBeanServer", x);
				}
			}
		}
		else
		{
			return socketFactory.createServerSocket(port, 50, host);
		}

		return null;
	}


	private boolean isUsernameValid(String username, String password)
	{
		if (authorizations.containsKey(username))
		{
			return password.equals(authorizations.get(username));
		}
		return false;
	}


	protected HttpCommandProcessor getProcessor(String path)
	{
		return (HttpCommandProcessor)commands.get(path);
	}


	/**
	 * Build the commands
	 */
	protected void buildCommands()
	{
		try
		{
			DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
			builder = factory.newDocumentBuilder();
			for (int i=0;i<defaultCommandProcessors.length;i++)
			{
				try
				{
					HttpCommandProcessor processor = (HttpCommandProcessor)Class.forName(defaultCommandProcessors[i][1]).newInstance();
					commands.put(defaultCommandProcessors[i][0], processor);
				} catch (Exception e) {
					HttpAdaptor.log(LogService.LOG_WARNING,"Exception building command procesor", e);
				}
			}
		}
		catch (ParserConfigurationException e)
		{
			HttpAdaptor.log(LogService.LOG_ERROR,"Exception building the Document Factories", e);
		}
	}


	protected void postProcess(HttpOutputStream out, HttpInputStream in, Document document)
		throws IOException, JMException
	{
		boolean processed = false;
		// inefficient but handles modifications at runtime
		if (processorName != null)
		{
			if (server.isRegistered(processorName) &&
					server.isInstanceOf(processorName, ProcessorMBean.class.getName()))
			{
				server.invoke(processorName,
						"writeResponse",
						new Object[]{out, in, document},
						new String[]{HttpOutputStream.class.getName(), HttpInputStream.class.getName(), Document.class.getName()});
				processed = true;
			}
			else
			{
				HttpAdaptor.log(LogService.LOG_DEBUG,processorName + " not found",null);
			}
		}
		if (!processed && processor != null)
		{
			processor.writeResponse(out, in, document);
			processed = true;
		}
		if (!processed)
		{
			defaultProcessor.writeResponse(out, in, document);
		}
	}


	protected void findUnknownElement(String path, HttpOutputStream out, HttpInputStream in)
		throws IOException, JMException
	{
		boolean processed = false;
		// inefficient but handles modifications at runtime
		if (processorName != null)
		{
			if (server.isRegistered(processorName) &&
					server.isInstanceOf(processorName, ProcessorMBean.class.getName()))
			{
				server.invoke(processorName,
						"notFoundElement",
						new Object[]{path, out, in},
						new String[]{String.class.getName(), HttpOutputStream.class.getName(), HttpInputStream.class.getName()});
				processed = true;
			}
			else
			{
				HttpAdaptor.log(LogService.LOG_DEBUG,processorName + " not found",null);
			}
		}
		if (!processed && processor != null)
		{
			processor.notFoundElement(path, out, in);
			processed = true;
		}
		if (!processed)
		{
			defaultProcessor.notFoundElement(path, out, in);
		}
	}


	protected String preProcess(String path)
		throws IOException, JMException
	{
		boolean processed = false;
		// inefficient but handles modifications at runtime
		if (processorName != null)
		{
			HttpAdaptor. log(LogService.LOG_DEBUG,"Preprocess using " + processorName,null);
			if (server.isRegistered(processorName) &&
					server.isInstanceOf(processorName, ProcessorMBean.class.getName()))
			{
				HttpAdaptor.log(LogService.LOG_DEBUG,"Preprocessing",null);
				path = (String)server.invoke(processorName,
						"preProcess",
						new Object[]{path},
						new String[]{String.class.getName()});
				processed = true;
			}
			else
			{
				HttpAdaptor.log(LogService.LOG_DEBUG,processorName + " not found",null);
			}
		}
		if (!processed && processor != null)
		{
			path = processor.preProcess(path);
			processed = true;
		}
		if (!processed)
		{
			path = defaultProcessor.preProcess(path);
		}
		return path;
	}


	protected void postProcess(HttpOutputStream out, HttpInputStream in, Exception e)
		throws IOException, JMException
	{
		boolean processed = false;
		// inefficient but handles modifications at runtime
		if (processorName != null)
		{
			if (server.isRegistered(processorName) &&
					server.isInstanceOf(processorName, ProcessorMBean.class.getName()))
			{
				server.invoke(processorName,
						"writeError",
						new Object[]{out, in, e},
						new String[]{HttpOutputStream.class.getName(),HttpInputStream.class.getName(), Exception.class.getName()});
				processed = true;
			}
			else
			{
				HttpAdaptor.log(LogService.LOG_DEBUG,processorName + " not found",null);
			}
		}
		if (!processed && processor != null)
		{
			processor.writeError(out, in, e);
			processed = true;
		}
		if (!processed)
		{
			defaultProcessor.writeError(out, in, e);
		}
	}


	private class HttpClient extends Thread
	{
		private Socket client;


		HttpClient(Socket client)
		{
			this.client = client;
		}

		public boolean isValid(String authorizationString) {
			if (authenticationMethod.startsWith("basic"))
			{
				authorizationString = authorizationString.substring(5,authorizationString.length());
				String decodeString = new String(Base64Codec.decodeBase64(authorizationString.getBytes()));
				if (decodeString.indexOf(":")>0)
				{
					try
					{
						StringTokenizer tokens = new StringTokenizer(decodeString, ":");
						String username = tokens.nextToken();
						String password = tokens.nextToken();
						return isUsernameValid(username, password);
					}
					catch (Exception e)
					{
						return false;
					}
				}
			}
			return false;
		}


		private boolean handleAuthentication(HttpInputStream in, HttpOutputStream out) throws IOException {
			if (authenticationMethod.equals("basic"))
			{
				String result = in.getHeader("authorization");
				if (result != null)
				{
					if (isValid(result))
					{
						return true;
					}
					throw new HttpException(HttpConstants.STATUS_FORBIDDEN, "Authentication failed");
				}

				out.setCode(HttpConstants.STATUS_AUTHENTICATE);
				out.setHeader("WWW-Authenticate", "Basic realm=\"" + realm + "\"");
				out.sendHeaders();
				out.flush();
				return false;
			}
			if (authenticationMethod.equals("digest"))
			{
				// not implemented
			}
			return true;
		}


		public void run()
		{
			HttpInputStream httpIn = null;
			HttpOutputStream httpOut = null;
			try
			{
				// get input streams
				InputStream in = client.getInputStream();
				httpIn = new HttpInputStream(in);
				httpIn.readRequest();

				// Find a suitable command processor
				String path = httpIn.getPath();
				String queryString = httpIn.getQueryString();
				HttpAdaptor.log(LogService.LOG_INFO,"Request " + path + ((queryString == null) ? "" : ("?" + queryString)), null);
				String postPath = preProcess(path);
				if (!postPath.equals(path))
				{
					HttpAdaptor.log(LogService.LOG_INFO,"Processor replaced path " + path + " with the path " + postPath,null);
					path = postPath;
				}
				OutputStream out = client.getOutputStream();
				httpOut = new HttpOutputStream(out, httpIn);
				if (!handleAuthentication(httpIn, httpOut)) {
					return;
				}
				HttpCommandProcessor processor = getProcessor(path.substring(1, path.length()));
				if (processor == null)
				{
					HttpAdaptor.log(LogService.LOG_INFO,"No suitable command processor found, requesting from processor path " + path, null);
					findUnknownElement(path, httpOut, httpIn);
				}
				else
				{
					Document document = processor.executeRequest(httpIn);
					postProcess(httpOut, httpIn, document);
				}
			}
			catch (Exception ex)
			{
        ex.printStackTrace();
				HttpAdaptor.log(LogService.LOG_WARNING,"Exception during http request", ex);
				if (httpOut != null)
				{
					try
					{
						postProcess(httpOut, httpIn, ex);
					}
					catch (IOException e)
					{
						HttpAdaptor.log(LogService.LOG_WARNING,"IOException during http request", e);
					}
					catch (JMException e)
					{
						 HttpAdaptor.log(LogService.LOG_WARNING,"JMException during http request", e);
					}
					catch (RuntimeException rte)
					{
						HttpAdaptor.log(LogService.LOG_ERROR,"RuntimeException during http request", rte);
					}
					catch (Error er)
					{
						HttpAdaptor.log(LogService.LOG_ERROR,"Error during http request ", er);
					}
					catch (Throwable t)
					{
	          HttpAdaptor.log(LogService.LOG_ERROR,"Throwable during http request ", t);
					}
				}
			}
			catch (Error ex)
			{
				HttpAdaptor.log(LogService.LOG_ERROR,"Error during http request ", ex);
			}
			finally
			{
				try
				{
					if (httpOut != null)
					{
						httpOut.flush();
					}
					// always close the socket
					client.close();
				}
				catch (IOException e)
				{
					HttpAdaptor.log(LogService.LOG_WARNING,"Exception during request processing", e);
				}
			}
		}
	}


  private static void log(int prio, String message, Throwable t){
    if (HttpConnectorActivator.bc!=null){
    ServiceReference logSR=HttpConnectorActivator.bc.getServiceReference(LogService.class.getName());
    if (logSR!=null){
      ((LogService)HttpConnectorActivator.bc.getService(logSR)).log(prio, message, t);
    }else{
      System.out.println("No Log Service");
    }
    }else{
      System.out.println(HttpAdaptor.class.getName()+".log: No bundleContext");
    }
  }
}