org.openqa.selenium.grid.web.ResourceHandler Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of selenium-grid Show documentation
Selenium automates browsers. That's it! What you do with that power is entirely up to you.
The newest version!
// Licensed to the Software Freedom Conservancy (SFC) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The SFC 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.openqa.selenium.grid.web;

import static com.google.common.net.MediaType.CACHE_MANIFEST_UTF_8;
import static com.google.common.net.MediaType.CSS_UTF_8;
import static com.google.common.net.MediaType.GIF;
import static com.google.common.net.MediaType.HTML_UTF_8;
import static com.google.common.net.MediaType.JAVASCRIPT_UTF_8;
import static com.google.common.net.MediaType.JPEG;
import static com.google.common.net.MediaType.JSON_UTF_8;
import static com.google.common.net.MediaType.OCTET_STREAM;
import static com.google.common.net.MediaType.PLAIN_TEXT_UTF_8;
import static com.google.common.net.MediaType.PNG;
import static com.google.common.net.MediaType.SVG_UTF_8;
import static com.google.common.net.MediaType.WOFF;
import static com.google.common.net.MediaType.XHTML_UTF_8;
import static com.google.common.net.MediaType.XML_UTF_8;
import static java.net.HttpURLConnection.HTTP_MOVED_TEMP;
import static java.net.HttpURLConnection.HTTP_NOT_FOUND;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.openqa.selenium.remote.http.Contents.bytes;
import static org.openqa.selenium.remote.http.Contents.utf8String;
import static org.openqa.selenium.remote.http.HttpMethod.GET;

import com.google.common.net.MediaType;
import java.io.UncheckedIOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Optional;
import java.util.stream.Collectors;
import org.openqa.selenium.internal.Require;
import org.openqa.selenium.remote.http.HttpRequest;
import org.openqa.selenium.remote.http.HttpResponse;
import org.openqa.selenium.remote.http.Routable;
import org.openqa.selenium.remote.http.UrlPath;

public class ResourceHandler implements Routable {

  private final Resource resource;

  public ResourceHandler(Resource resource) {
    this.resource = Require.nonNull("Resource", resource);
  }

  @Override
  public boolean matches(HttpRequest req) {
    return GET == req.getMethod() && resource.get(req.getUri()).isPresent();
  }

  @Override
  public HttpResponse execute(HttpRequest req) throws UncheckedIOException {
    Optional result = resource.get(req.getUri());

    if (!result.isPresent()) {
      String errorMessage;
      try {
        new URL(req.getUri());
        errorMessage = "Unable to find " + req.getUri();
      } catch (MalformedURLException ignore) {
        errorMessage = "Unable to find resource, invalid path in url.";
      }
      return new HttpResponse().setStatus(HTTP_NOT_FOUND).setContent(utf8String(errorMessage));
    }

    Resource resource = result.get();

    if (resource.isDirectory()) {
      Optional index = resource.get("index.html");
      if (index.isPresent()) {
        return readFile(req, index.get());
      }

      return readDirectory(req, resource);
    }
    return readFile(req, resource);
  }

  private HttpResponse readDirectory(HttpRequest req, Resource resource) {
    if (!req.getUri().endsWith("/")) {
      String dest = UrlPath.relativeToContext(req, req.getUri() + "/");
      return new HttpResponse().setStatus(HTTP_MOVED_TEMP).addHeader("Location", dest);
    }

    String links =
        resource.list().stream()
            .map(res -> String.format("%s", res.name(), res.name()))
            .sorted()
            .collect(Collectors.joining("\n", "\n", "\n"));

    String html =
        String.format(
            "Listing of %s%s%s",
            resource.name(), resource.name(), links);

    return new HttpResponse()
        .addHeader("Content-Type", HTML_UTF_8.toString())
        .setContent(utf8String(html));
  }

  private HttpResponse readFile(HttpRequest req, Resource resource) {
    Optional bytes = resource.read();
    if (bytes.isPresent()) {
      return new HttpResponse()
          .addHeader("Content-Type", mediaType(req.getUri()))
          .setContent(bytes(bytes.get()));
    }
    return get404(req);
  }

  private HttpResponse get404(HttpRequest req) {
    return new HttpResponse()
        .setStatus(HTTP_NOT_FOUND)
        .setContent(utf8String("Unable to read " + req.getUri()));
  }

  private String mediaType(String uri) {
    int index = uri.lastIndexOf(".");
    String extension = (index == -1 || uri.length() == index) ? "" : uri.substring(index + 1);

    MediaType type;
    switch (extension.toLowerCase()) {
      case "appcache":
        type = CACHE_MANIFEST_UTF_8;
        break;

      case "dll":
      case "ttf":
        type = OCTET_STREAM;
        break;

      case "css":
        type = CSS_UTF_8;
        break;

      case "gif":
        type = GIF;
        break;

      case "jpeg":
      case "jpg":
        type = JPEG;
        break;

      case "js":
        type = JAVASCRIPT_UTF_8;
        break;

      case "json":
        type = JSON_UTF_8;
        break;

      case "md":
      case "txt":
        type = PLAIN_TEXT_UTF_8;
        break;

      case "png":
        type = PNG;
        break;

      case "svg":
        type = SVG_UTF_8;
        break;

      case "woff":
        type = WOFF;
        break;

      case "xhtml":
        type = XHTML_UTF_8;
        break;

      case "xml":
        type = XML_UTF_8;
        break;

      case "xsl":
        type = MediaType.create("application", "xslt+xml").withCharset(UTF_8);
        break;

      default:
        type = MediaType.create("text", "html");
        break;
    }

    return type.toString();
  }
}