| /* |
| * 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.apache.axis2.transport.http; |
| |
| import org.apache.axis2.AxisFault; |
| import org.apache.axis2.Constants; |
| import org.apache.axis2.addressing.EndpointReference; |
| import org.apache.axis2.context.ConfigurationContext; |
| import org.apache.axis2.context.ConfigurationContextFactory; |
| import org.apache.axis2.context.MessageContext; |
| import org.apache.axis2.context.SessionContext; |
| import org.apache.axis2.description.Parameter; |
| import org.apache.axis2.description.TransportInDescription; |
| import org.apache.axis2.engine.ListenerManager; |
| import org.apache.axis2.kernel.http.HTTPConstants; |
| import org.apache.axis2.kernel.TransportListener; |
| import org.apache.axis2.transport.http.server.HttpFactory; |
| import org.apache.axis2.transport.http.server.SessionManager; |
| import org.apache.axis2.transport.http.server.SimpleHttpServer; |
| import org.apache.axis2.util.OptionsParser; |
| import org.apache.commons.logging.Log; |
| import org.apache.commons.logging.LogFactory; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.util.Iterator; |
| |
| /** |
| * This is a simple implementation of an HTTP server for processing |
| * SOAP requests via Apache's xml-axis2. |
| * It can be used with no configuration other than the port to listen on, or it can |
| * be configured in detail with an HttpFactory. |
| */ |
| public class SimpleHTTPServer implements TransportListener { |
| |
| private static final Log log = LogFactory.getLog(SimpleHTTPServer.class); |
| |
| /** |
| * Embedded commons http core based server |
| */ |
| SimpleHttpServer embedded = null; |
| int port = -1; |
| |
| public static int DEFAULT_PORT = 8080; |
| |
| public static String PARAM_PORT = "port"; |
| |
| |
| protected ConfigurationContext configurationContext; |
| private TransportInDescription trpInDesc; |
| protected HttpFactory httpFactory; |
| private SessionManager sessionManager; |
| |
| public SimpleHTTPServer() { |
| } |
| |
| /** |
| * Create a SimpleHTTPServer using default HttpFactory settings |
| */ |
| public SimpleHTTPServer(ConfigurationContext configurationContext, int port) throws AxisFault { |
| this(new HttpFactory(configurationContext, port)); |
| } |
| |
| /** |
| * Create a configured SimpleHTTPServer |
| */ |
| public SimpleHTTPServer(HttpFactory httpFactory) throws AxisFault { |
| this.httpFactory = httpFactory; |
| this.configurationContext = httpFactory.getConfigurationContext(); |
| this.port = httpFactory.getPort(); |
| TransportInDescription httpDescription = |
| new TransportInDescription(Constants.TRANSPORT_HTTP); |
| httpDescription.setReceiver(this); |
| trpInDesc = httpDescription; |
| httpFactory.getListenerManager().addListener(httpDescription, true); |
| sessionManager = new SessionManager(); |
| } |
| |
| /** |
| * init method in TransportListener |
| * |
| * @param axisConf |
| * @param transprtIn |
| * @throws AxisFault |
| */ |
| public void init(ConfigurationContext axisConf, TransportInDescription transprtIn) |
| throws AxisFault { |
| try { |
| this.configurationContext = axisConf; |
| this.trpInDesc = transprtIn; |
| |
| Parameter param = transprtIn.getParameter(PARAM_PORT); |
| if (param != null) { |
| this.port = Integer.parseInt((String) param.getValue()); |
| } |
| |
| if (httpFactory == null) { |
| httpFactory = new HttpFactory(configurationContext, port); |
| } |
| } catch (Exception e1) { |
| throw AxisFault.makeFault(e1); |
| } |
| } |
| |
| /** |
| * Method main |
| * |
| * @param args |
| * @throws Exception |
| */ |
| public static void main(String[] args) throws Exception { |
| int port = DEFAULT_PORT; |
| OptionsParser optionsParser = new OptionsParser(args); |
| |
| args = optionsParser.getRemainingArgs(); |
| // first check if we should print usage |
| if ((optionsParser.isFlagSet('?') > 0) || (optionsParser.isFlagSet('h') > 0) || |
| args == null || args.length == 0 || args.length > 3) { |
| printUsage(); |
| } |
| String paramPort = optionsParser.isValueSet('p'); |
| if (paramPort != null) { |
| port = Integer.parseInt(paramPort); |
| } |
| |
| boolean startAllTransports = "all".equals(optionsParser.isValueSet('t')); |
| String repository = optionsParser.isValueSet('r'); |
| if (repository == null) { |
| args = optionsParser.getRemainingArgs(); |
| if (args != null && args[0] != null && !args[0].equals("")) { |
| repository = args[0]; |
| } else { |
| printUsage(); |
| } |
| } |
| |
| System.out.println("[SimpleHTTPServer] Starting"); |
| System.out.println("[SimpleHTTPServer] Using the Axis2 Repository " |
| + new File(repository).getAbsolutePath()); |
| System.out.println("[SimpleHTTPServer] Listening on port " + port); |
| try { |
| ConfigurationContext configctx = ConfigurationContextFactory |
| .createConfigurationContextFromFileSystem(repository, null); |
| SimpleHTTPServer receiver = new SimpleHTTPServer(configctx, port); |
| Runtime.getRuntime().addShutdownHook(new ShutdownThread(receiver)); |
| receiver.start(); |
| ListenerManager listenerManager = configctx .getListenerManager(); |
| TransportInDescription trsIn = new TransportInDescription(Constants.TRANSPORT_HTTP); |
| trsIn.setReceiver(receiver); |
| if (listenerManager == null) { |
| listenerManager = new ListenerManager(); |
| listenerManager.init(configctx); |
| } |
| listenerManager.addListener(trsIn, true); |
| |
| // should all transports be started? specified as "-t all" |
| if (startAllTransports) { |
| Iterator<String> iter = configctx.getAxisConfiguration(). |
| getTransportsIn().keySet().iterator(); |
| while (iter.hasNext()) { |
| String trp = iter.next(); |
| if (!Constants.TRANSPORT_HTTP.equals(trp)) { |
| trsIn = (TransportInDescription) |
| configctx.getAxisConfiguration().getTransportsIn().get(trp); |
| listenerManager.addListener(trsIn, false); |
| } |
| } |
| } |
| |
| System.out.println("[SimpleHTTPServer] Started"); |
| } catch (Throwable t) { |
| log.fatal("Error starting SimpleHTTPServer", t); |
| System.out.println("[SimpleHTTPServer] Shutting down"); |
| } |
| } |
| |
| public static void printUsage() { |
| System.out.println("Usage: SimpleHTTPServer [options] -r <repository>"); |
| System.out.println(" Opts: -? this message"); |
| System.out.println(); |
| System.out.println(" -p port :to listen on (default is 8080)"); |
| System.out.println( |
| " -t all :to start all transports defined in the axis2 configuration"); |
| System.exit(1); |
| } |
| |
| |
| /** |
| * Start this server as a NON-daemon. |
| */ |
| public void start() throws AxisFault { |
| try { |
| embedded = new SimpleHttpServer(httpFactory, port); |
| embedded.init(); |
| embedded.start(); |
| } catch (IOException e) { |
| log.error(e.getMessage(), e); |
| throw AxisFault.makeFault(e); |
| } |
| } |
| |
| /** |
| * Stop this server. Can be called safely if the system is already stopped, |
| * or if it was never started. |
| * This will interrupt any pending accept(). |
| */ |
| public void stop() { |
| System.out.println("[SimpleHTTPServer] Stop called"); |
| if (embedded != null) { |
| try { |
| embedded.destroy(); |
| } catch (Exception e) { |
| log.error(e.getMessage(), e); |
| } |
| } |
| } |
| |
| /** |
| * replyToEPR |
| * If the user has given host address paramter then it gets the high priority and |
| * ERP will be creatd using that |
| * N:B - hostAddress should be a complete url (http://www.myApp.com/ws) |
| * |
| * @param serviceName |
| * @param ip |
| * @return an EndpointReference |
| * @see org.apache.axis2.kernel.TransportListener#getEPRForService(String,String) |
| */ |
| public EndpointReference[] getEPRsForService(String serviceName, String ip) throws AxisFault { |
| if (embedded == null) { |
| throw new AxisFault("Unable to generate EPR for the transport : http"); |
| } |
| return HTTPTransportUtils.getEPRsForService(configurationContext, trpInDesc, serviceName, ip, embedded.getPort()); |
| } |
| |
| /** |
| * Getter for httpFactory |
| */ |
| public HttpFactory getHttpFactory() { |
| return httpFactory; |
| } |
| |
| /** |
| * Method getConfigurationContext |
| * |
| * @return the system context |
| */ |
| public ConfigurationContext getConfigurationContext() { |
| return configurationContext; |
| } |
| |
| /** |
| * replyToEPR |
| * If the user has given host address paramter then it gets the high priority and |
| * ERP will be creatd using that |
| * N:B - hostAddress should be a complte url (http://www.myApp.com/ws) |
| * |
| * @param serviceName |
| * @param ip |
| * @return an EndpointReference |
| * @see org.apache.axis2.kernel.TransportListener#getEPRForService(String,String) |
| */ |
| public EndpointReference getEPRForService(String serviceName, String ip) throws AxisFault { |
| return getEPRsForService(serviceName, ip)[0]; |
| } |
| |
| /** |
| * Checks if this HTTP server instance is running. |
| * |
| * @return true/false |
| */ |
| public boolean isRunning() { |
| if (embedded == null) { |
| return false; |
| } |
| |
| return embedded.isRunning(); |
| } |
| |
| static class ShutdownThread extends Thread { |
| private SimpleHTTPServer server = null; |
| |
| public ShutdownThread(SimpleHTTPServer server) { |
| super(); |
| this.server = server; |
| } |
| |
| public void run() { |
| System.out.println("[SimpleHTTPServer] Shutting down"); |
| server.stop(); |
| System.out.println("[SimpleHTTPServer] Shutdown complete"); |
| } |
| } |
| |
| |
| public SessionContext getSessionContext(MessageContext messageContext) { |
| String sessionKey = (String) messageContext.getProperty(HTTPConstants.COOKIE_STRING); |
| return this.sessionManager.getSessionContext(sessionKey); |
| } |
| |
| public void destroy() { |
| this.configurationContext = null; |
| } |
| } |