io.ingenieux.lambada.maven.ServeMojo Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of lambada-maven-plugin Show documentation
The newest version!
/*
 * Copyright (c) 2016 ingenieux Labs
 *
 * 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 io.ingenieux.lambada.maven;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ObjectNode;

import org.apache.commons.io.IOUtils;
import org.apache.commons.io.output.ByteArrayOutputStream;
import org.apache.maven.plugins.annotations.LifecyclePhase;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
import org.apache.maven.plugins.annotations.ResolutionScope;

import java.io.InputStream;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Set;
import java.util.TreeSet;

import io.ingenieux.lambada.invoker.Invoker;
import io.ingenieux.lambada.invoker.UserHandlerFactory;
import io.ingenieux.lambada.runtime.ApiGateway;
import io.ingenieux.lambada.runtime.LambadaFunction;
import io.ingenieux.lambada.testing.ImmutableLambadaContext;
import spark.Request;
import spark.Response;

import static org.apache.commons.lang3.StringUtils.defaultString;
import static spark.Spark.awaitInitialization;
import static spark.Spark.get;
import static spark.Spark.port;
import static spark.Spark.post;
import static spark.Spark.stop;
import static spark.Spark.threadPool;

@Mojo(name = "serve", requiresDirectInvocation = true, requiresProject = true,
    defaultPhase = LifecyclePhase.PROCESS_CLASSES,
    requiresDependencyResolution = ResolutionScope.COMPILE_PLUS_RUNTIME)
public class ServeMojo extends AbstractLambadaMetadataMojo {

  /**
   * Port to Use
   */
  @Parameter(property = "lambada.port", defaultValue = "8080")
  Integer serverPort;
  private final Set pathHandlers = new TreeSet();

  @Override
  protected void executeInternal() throws Exception {
    loadPathHandlers();

    port(serverPort);

    threadPool(8);

    setupServer();

    awaitInitialization();

    while (10 != System.in.read()) {
      Thread.sleep(500);
    }

    stop();
  }

  private void setupServer() {
    for (PathHandler p : pathHandlers) {
      if (p.getMethodType() == ApiGateway.MethodType.GET) {
        get(p.getPath(), p::handle);
      } else if (p.getMethodType() == ApiGateway.MethodType.POST) {
        post(p.getPath(), p::handle);
      }
    }
  }

  public void loadPathHandlers() throws Exception {
    final Set methodsAnnotatedWith = extractRuntimeAnnotations(LambadaFunction.class);

    getLog().info("There are " + methodsAnnotatedWith.size() + " found methods.");

    for (Method m : methodsAnnotatedWith) {
      final LambadaFunction annotation = m.getAnnotation(LambadaFunction.class);

      if (null == annotation.api() || 1 != annotation.api().length)
        return;

      ApiGateway a = annotation.api()[0];

      PathHandler pathHandler = new PathHandler();

      pathHandler.setPath(a.path());
      pathHandler.setMethod(m);

      boolean bStatic = Modifier.isStatic(m.getModifiers());

      // TODO: ApiGateway
      getLog().info("Class: " + m.getDeclaringClass().getName());

      if (!bStatic) {
        try {
          pathHandler.setInstance(m.getDeclaringClass().newInstance());
        } catch (Exception exc) {
          throw new RuntimeException("Unable to create class " + m.getDeclaringClass(), exc);
        }
      }

      pathHandler.setMethodType(a.method());

      getLog().info("Added path handler: " + pathHandler);

      pathHandlers.add(pathHandler.build());
    }


  }

  class PathHandler implements Comparable {

    String path;

    public String getPath() {
      return path;
    }

    public void setPath(String path) {
      this.path = path;
    }

    ApiGateway.MethodType methodType;

    public ApiGateway.MethodType getMethodType() {
      return methodType;
    }

    public void setMethodType(ApiGateway.MethodType methodType) {
      this.methodType = methodType;
    }

    Object instance;

    public Object getInstance() {
      return instance;
    }

    public void setInstance(Object instance) {
      this.instance = instance;
    }

    Method method;

    public Method getMethod() {
      return method;
    }

    public void setMethod(Method method) {
      this.method = method;
    }

    @Override
    public int compareTo(PathHandler o) {
      return path.compareTo(o.path);
    }

    @Override
    public String toString() {
      return "PathHandler{" +
             "path='" + path + '\'' +
             ", methodType=" + methodType +
             ", instance=" + instance +
             ", method=" + method +
             '}';
    }

    Invoker invoker = null;

    public PathHandler build() {
      invoker = new Invoker();

      invoker.setUserHandler(UserHandlerFactory.findUserFactory(this.instance, this.method));

      if (null == invoker.getUserHandler())
        throw new IllegalArgumentException("Oops: Unable to build an path handler for " + this.toString());

      return this;
    }

    public Object handle(Request request, Response response) throws Exception {
      InputStream is = IOUtils.toInputStream(defaultString(request.body(), "null"));
      ByteArrayOutputStream baos = new ByteArrayOutputStream();

      try {
        invoker.invoke(is, baos, ImmutableLambadaContext.builder().build());

        response.status(200);
        response.type("application/json");

        if (0 == baos.size()) {
          return "null";
        } else {
          try {
            JsonNode asJsonNode = OBJECT_MAPPER.readValue(baos.toByteArray(), JsonNode.class);

            return asJsonNode;
          } catch (Exception e) {
            response.type("text/plain");

            return new String(baos.toByteArray());
          }
        }
      } catch (Exception exc) {
        response.status(500);
        response.type("application/json");

        if (OBJECT_MAPPER.canSerialize(exc.getClass())) {
          return OBJECT_MAPPER.writeValueAsString(exc);
        } else {
          ObjectNode parentNode = OBJECT_MAPPER.createObjectNode();

          parentNode.put("message", exc.getMessage());
          parentNode.put("class", exc.getClass().getName());

          return parentNode;
        }
      }
    }
  }
}