Exemple #1
1
  private String detectAgentUrl(
      HttpServer pServer, JolokiaServerConfig pConfig, String pContextPath) {
    serverAddress = pServer.getAddress();
    InetAddress realAddress;
    int port;
    if (serverAddress != null) {
      realAddress = serverAddress.getAddress();
      if (realAddress.isAnyLocalAddress()) {
        try {
          realAddress = NetworkUtil.getLocalAddress();
        } catch (IOException e) {
          try {
            realAddress = InetAddress.getLocalHost();
          } catch (UnknownHostException e1) {
            // Ok, ok. We take the original one
            realAddress = serverAddress.getAddress();
          }
        }
      }
      port = serverAddress.getPort();
    } else {
      realAddress = pConfig.getAddress();
      port = pConfig.getPort();
    }

    return String.format(
        "%s://%s:%d%s", pConfig.getProtocol(), realAddress.getHostAddress(), port, pContextPath);
  }
Exemple #2
0
  protected HttpServer createHttpServer() throws IOException {
    HttpServer server = new HttpServer();

    SocketListener listener = new SocketListener();
    listener.setPort(SysConfig.getHttpPortAsInt());
    server.addListener(listener);

    return server;
  }
Exemple #3
0
  public void stopHttpServer(HttpServer httpServer) {
    try {
      httpServer.stop(true);
    } catch (InterruptedException ie) {
      SysLog.logThrowable(ie);
    }

    SysLog.logInfo("http server was stopped");
  }
 public String getUrl() {
   if (server != null) {
     return (server instanceof HttpsServer ? "https://" : "http://")
         + PMS.get().getServer().getHost()
         + ":"
         + server.getAddress().getPort();
   }
   return null;
 }
  public static void main(String[] args) {
    try {
      String serverAddress = args[0];
      int port = Integer.parseInt(args[1]);
      String localAddress = args[2];

      /** create a httpServer */
      System.out.println("Starting HTTP server");
      HttpServer httpServer = HttpServer.create(new InetSocketAddress(80), 0);
      httpServer.createContext("/", new HttpFileHandler());
      httpServer.setExecutor(null);
      httpServer.start();

      System.out.println("Creating RMI Registry");
      Registry registry = LocateRegistry.createRegistry(1099);
      Reference reference =
          new javax.naming.Reference(
              "client.ExportObject", "client.ExportObject", "http://" + localAddress + "/");
      ReferenceWrapper referenceWrapper = new com.sun.jndi.rmi.registry.ReferenceWrapper(reference);
      registry.bind("Object", referenceWrapper);

      System.out.println("Connecting to server " + serverAddress + ":" + port);
      Socket socket = new Socket(serverAddress, port);
      System.out.println("Connected to server");
      String jndiAddress = "rmi://" + localAddress + ":1099/Object";

      org.springframework.transaction.jta.JtaTransactionManager object =
          new org.springframework.transaction.jta.JtaTransactionManager();
      object.setUserTransactionName(jndiAddress);

      System.out.println("Sending object to server...");
      ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
      objectOutputStream.writeObject(object);
      objectOutputStream.flush();
      /*
      while(true) {
      	Thread.sleep(1000);
      }
      */
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
Exemple #6
0
 public static void main(String[] args) throws Exception {
   MyAuthenticator auth = new MyAuthenticator();
   Authenticator.setDefault(auth);
   try {
     server = new HttpServer(new AuthHeaderTest(), 1, 10, 0);
     System.out.println("Server: listening on port: " + server.getLocalPort());
     client("http://localhost:" + server.getLocalPort() + "/d1/foo.html");
   } catch (Exception e) {
     if (server != null) {
       server.terminate();
     }
     throw e;
   }
   int f = auth.getCount();
   if (f != 1) {
     except("Authenticator was called " + f + " times. Should be 1");
   }
   server.terminate();
 }
Exemple #7
0
 private static HttpServer createHttpServer(ExecutorService execs) throws Exception {
   InetSocketAddress inetAddress = new InetSocketAddress(0);
   HttpServer testServer = HttpServer.create(inetAddress, 5);
   testServer.setExecutor(execs);
   HttpContext context = testServer.createContext("/test");
   context.setHandler(
       new HttpHandler() {
         public void handle(HttpExchange msg) {
           try {
             synchronized (lock) {
               ++s_received;
               if ((s_received % 1000) == 0) {
                 System.out.println("Received=" + s_received);
               }
             }
             String method = msg.getRequestMethod();
             if (method.equals("POST")) {
               InputStream is = msg.getRequestBody();
               byte[] buf = readFully(is);
               is.close();
               writePostReply(msg, buf);
             } else {
               System.out.println("****** METHOD not handled ***** " + method);
               System.out.println("Received=" + s_received);
             }
             synchronized (lock) {
               ++sent;
               if ((sent % 1000) == 0) {
                 System.out.println("sent=" + sent);
               }
             }
           } catch (Exception e) {
             e.printStackTrace();
           } finally {
             msg.close();
           }
         }
       });
   return testServer;
 }
 private void addCtx(String path, HttpHandler h) {
   HttpContext ctx = server.createContext(path, h);
   if (configuration.isWebAuthenticate()) {
     ctx.setAuthenticator(
         new BasicAuthenticator("") {
           @Override
           public boolean checkCredentials(String user, String pwd) {
             LOGGER.debug("authenticate " + user);
             return pwd.equals(users.get(user));
             // return true;
           }
         });
   }
 }
Exemple #9
0
  /**
   * Create the HttpServer to use. Can be overridden if a custom or already existing HttpServer
   * should be used
   *
   * @return HttpServer to use
   * @throws IOException if something fails during the initialisation
   */
  private HttpServer createHttpServer(JolokiaServerConfig pConfig) throws IOException {
    int port = pConfig.getPort();
    InetAddress address = pConfig.getAddress();
    InetSocketAddress socketAddress = new InetSocketAddress(address, port);

    HttpServer server =
        pConfig.useHttps()
            ? createHttpsServer(socketAddress, pConfig)
            : HttpServer.create(socketAddress, pConfig.getBacklog());

    // Prepare executor pool
    Executor executor;
    String mode = pConfig.getExecutor();
    if ("fixed".equalsIgnoreCase(mode)) {
      executor = Executors.newFixedThreadPool(pConfig.getThreadNr(), daemonThreadFactory);
    } else if ("cached".equalsIgnoreCase(mode)) {
      executor = Executors.newCachedThreadPool(daemonThreadFactory);
    } else {
      executor = Executors.newSingleThreadExecutor(daemonThreadFactory);
    }
    server.setExecutor(executor);

    return server;
  }
Exemple #10
0
 public static void main(String[] args) throws Exception {
   try {
     lock = new Object();
     if (args.length > 0) {
       NUM = Integer.parseInt(args[0]);
     }
     execs = Executors.newFixedThreadPool(5);
     httpServer = createHttpServer(execs);
     port = httpServer.getAddress().getPort();
     pool = Executors.newFixedThreadPool(10);
     httpServer.start();
     for (int i = 0; i < NUM; i++) {
       pool.execute(new Client());
       if (error) {
         throw new Exception("error in test");
       }
     }
     System.out.println("Main thread waiting");
     pool.shutdown();
     long latest = System.currentTimeMillis() + 200 * 1000;
     while (System.currentTimeMillis() < latest) {
       if (pool.awaitTermination(2000L, TimeUnit.MILLISECONDS)) {
         System.out.println("Main thread done!");
         return;
       }
       if (error) {
         throw new Exception("error in test");
       }
     }
     throw new Exception("error in test: timed out");
   } finally {
     httpServer.stop(0);
     pool.shutdownNow();
     execs.shutdownNow();
   }
 }
Exemple #11
0
  /**
   * Initialize this JolokiaServer with the given HttpServer. The calle is responsible for managing
   * (starting/stopping) the HttpServer.
   *
   * @param pServer server to use
   * @param pConfig configuration
   * @param pLazy whether the initialization should be done lazy or not
   */
  protected final void init(HttpServer pServer, JolokiaServerConfig pConfig, boolean pLazy) {
    config = pConfig;
    lazy = pLazy;

    // Create proper context along with handler
    final String contextPath = pConfig.getContextPath();
    jolokiaHttpHandler = new JolokiaHttpHandler(pConfig.getJolokiaConfig());
    HttpContext context = pServer.createContext(contextPath, jolokiaHttpHandler);

    // Add authentication if configured
    final Authenticator authenticator = pConfig.getAuthenticator();
    if (authenticator != null) {
      context.setAuthenticator(authenticator);
    }

    url = detectAgentUrl(pServer, pConfig, contextPath);
  }
Exemple #12
0
  public static void main(String[] args) throws Exception {
    HttpServer s1 = null;
    HttpsServer s2 = null;
    ExecutorService executor = null;
    try {
      String root = System.getProperty("test.src") + "/docs";
      System.out.print("Test12: ");
      InetSocketAddress addr = new InetSocketAddress(0);
      s1 = HttpServer.create(addr, 0);
      s2 = HttpsServer.create(addr, 0);
      HttpHandler h = new FileServerHandler(root);
      HttpContext c1 = s1.createContext("/test1", h);
      HttpContext c2 = s2.createContext("/test1", h);
      executor = Executors.newCachedThreadPool();
      s1.setExecutor(executor);
      s2.setExecutor(executor);
      ctx = new SimpleSSLContext(System.getProperty("test.src")).get();
      s2.setHttpsConfigurator(new HttpsConfigurator(ctx));
      s1.start();
      s2.start();

      int port = s1.getAddress().getPort();
      int httpsport = s2.getAddress().getPort();
      Runner r[] = new Runner[8];
      r[0] = new Runner(true, "http", root + "/test1", port, "smallfile.txt", 23);
      r[1] = new Runner(true, "http", root + "/test1", port, "largefile.txt", 2730088);
      r[2] = new Runner(true, "https", root + "/test1", httpsport, "smallfile.txt", 23);
      r[3] = new Runner(true, "https", root + "/test1", httpsport, "largefile.txt", 2730088);
      r[4] = new Runner(false, "http", root + "/test1", port, "smallfile.txt", 23);
      r[5] = new Runner(false, "http", root + "/test1", port, "largefile.txt", 2730088);
      r[6] = new Runner(false, "https", root + "/test1", httpsport, "smallfile.txt", 23);
      r[7] = new Runner(false, "https", root + "/test1", httpsport, "largefile.txt", 2730088);
      start(r);
      join(r);
      System.out.println("OK");
    } finally {
      delay();
      if (s1 != null) s1.stop(2);
      if (s2 != null) s2.stop(2);
      if (executor != null) executor.shutdown();
    }
  }
 public String getAddress() {
   return PMS.get().getServer().getHost() + ":" + server.getAddress().getPort();
 }
Exemple #14
0
 public void startHttpServer(HttpServer httpServer) throws Exception {
   httpServer.start();
   SysLog.logInfo("http server was started");
 }
Exemple #15
0
 public static void except(String s) {
   server.terminate();
   throw new RuntimeException(s);
 }
  public RemoteWeb(int port) throws IOException {
    if (port <= 0) {
      port = defaultPort;
    }

    users = new HashMap<>();
    tags = new HashMap<>();
    roots = new HashMap<String, RootFolder>();
    // Add "classpaths" for resolving web resources
    resources =
        AccessController.doPrivileged(
            new PrivilegedAction<RemoteUtil.ResourceManager>() {

              public RemoteUtil.ResourceManager run() {
                return new RemoteUtil.ResourceManager(
                    "file:" + configuration.getProfileDirectory() + "/web/",
                    "jar:file:" + configuration.getProfileDirectory() + "/web.zip!/",
                    "file:" + configuration.getWebPath() + "/");
              }
            });

    readCred();

    // Setup the socket address
    InetSocketAddress address = new InetSocketAddress(InetAddress.getByName("0.0.0.0"), port);

    // Initialize the HTTP(S) server
    if (configuration.getWebHttps()) {
      try {
        server = httpsServer(address);
      } catch (IOException e) {
        LOGGER.error("Failed to start WEB interface on HTTPS: {}", e.getMessage());
        LOGGER.trace("", e);
        if (e.getMessage().contains("UMS.jks")) {
          LOGGER.info(
              "To enable HTTPS please generate a self-signed keystore file called \"UMS.jks\" using the java 'keytool' commandline utility.");
        }
      } catch (GeneralSecurityException e) {
        LOGGER.error(
            "Failed to start WEB interface on HTTPS due to a security error: {}", e.getMessage());
        LOGGER.trace("", e);
      }
    } else {
      server = HttpServer.create(address, 0);
    }

    if (server != null) {
      int threads = configuration.getWebThreads();

      // Add context handlers
      addCtx("/", new RemoteStartHandler(this));
      addCtx("/browse", new RemoteBrowseHandler(this));
      RemotePlayHandler playHandler = new RemotePlayHandler(this);
      addCtx("/play", playHandler);
      addCtx("/playstatus", playHandler);
      addCtx("/playlist", playHandler);
      addCtx("/media", new RemoteMediaHandler(this));
      addCtx("/fmedia", new RemoteMediaHandler(this, true));
      addCtx("/thumb", new RemoteThumbHandler(this));
      addCtx("/raw", new RemoteRawHandler(this));
      addCtx("/files", new RemoteFileHandler(this));
      addCtx("/doc", new RemoteDocHandler(this));
      addCtx("/poll", new RemotePollHandler(this));
      server.setExecutor(Executors.newFixedThreadPool(threads));
      server.start();
    }
  }
Exemple #17
0
  private void run(int port) {
    try {
      ServerFacade.initialize();
    } catch (ServerException e) {
      return;
    }

    try {
      server =
          HttpServer.create(new InetSocketAddress(SERVER_PORT_NUMBER), MAX_WAITING_CONNECTIONS);
    } catch (IOException e) {
      return;
    }

    server.setExecutor(null); // use the default executor

    server.createContext("/", downloadFileHandler);
    server.createContext("/ValidateUser", validateUserHandler);
    server.createContext("/GetProjects", getProjectsHandler);
    server.createContext("/GetSampleImage", getSampleImageHandler);
    server.createContext("/DownloadBatch", downloadBatchHandler);
    server.createContext("/SubmitBatch", submitBatchHandler);
    server.createContext("/GetFields", getFieldsHandler);
    server.createContext("/Search", searchHandler);

    server.start();
  }
Exemple #18
0
  protected void configureHttpServer(HttpServer server) {

    // Favicon hack

    HttpContext faviconContext = new HttpContext();
    faviconContext.setContextPath("/favicon.ico");
    server.addContext(faviconContext);

    ResourceHandler faviconHandler = new ResourceHandler();
    faviconContext.setResourceBase(SysConfig.getStaticDir().getRootPath());
    faviconContext.addHandler(faviconHandler);

    faviconContext.addHandler(new NotFoundHandler());

    // robots.txt hack

    HttpContext robotsContext = new HttpContext();
    robotsContext.setContextPath("/robots.txt");
    server.addContext(robotsContext);

    ResourceHandler robotsHandler = new ResourceHandler();
    robotsContext.setResourceBase(SysConfig.getStaticDir().getRootPath());
    robotsContext.addHandler(robotsHandler);

    robotsContext.addHandler(new NotFoundHandler());

    // Dynamic content

    HttpContext servletContext = new HttpContext();
    servletContext.setContextPath("/");
    server.addContext(servletContext);

    ServletHandler servlets = new ServletHandler();
    servletContext.addHandler(servlets);
    servlets.addServlet("/*", "org.wahlzeit.main.MainServlet");

    servletContext.addHandler(new NotFoundHandler());

    // Photos content

    HttpContext photosContext = new HttpContext();
    photosContext.setContextPath(SysConfig.getPhotosDirAsString());
    server.addContext(photosContext);

    ResourceHandler photosHandler = new ResourceHandler();
    photosContext.setResourceBase(SysConfig.getPhotosDirAsString());
    photosContext.addHandler(photosHandler);

    photosContext.addHandler(new NotFoundHandler());

    // Static content

    HttpContext staticContext = new HttpContext();
    staticContext.setContextPath(SysConfig.getStaticDir().getRootPath());
    server.addContext(staticContext);

    ResourceHandler staticHandler = new ResourceHandler();
    staticContext.setResourceBase(SysConfig.getStaticDir().getRootPath());
    staticContext.addHandler(staticHandler);

    staticContext.addHandler(new NotFoundHandler());
  }