Variety of Improvements to deployment process

pom.xml

@@ -10,8 +10,8 @@
 
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-        <java.source-target.version>1.8</java.source-target.version>
-        <aspectj.version>1.8.2</aspectj.version>
+        <java.source-target.version>11</java.source-target.version>
+        <aspectj.version>1.9.5</aspectj.version>
     </properties>
 
     <dependencies>
@@ -25,13 +25,6 @@
             <artifactId>maven-model</artifactId>
             <version>2.2.1</version>
         </dependency>
-        <dependency>
-            <groupId>com.sun.tools</groupId>
-            <artifactId>tools</artifactId>
-            <version>${java.version}</version>
-            <scope>system</scope>
-            <systemPath>${java.home}/../lib/tools.jar</systemPath>
-        </dependency>
         <dependency>
             <groupId>org.aspectj</groupId>
             <artifactId>aspectjrt</artifactId>
@@ -56,20 +49,21 @@
         <dependency>
             <groupId>com.amazonaws</groupId>
             <artifactId>aws-java-sdk-lambda</artifactId>
-            <version>1.11.60</version>
+            <version>1.11.774</version>
         </dependency>
 
+
     </dependencies>
 
     <build>
         <plugins>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.6.0</version>
+                <version>3.8.1</version>
                 <configuration>
-                    <source>1.8</source>
-                    <target>1.8</target>
+                    <source>11</source>
+                    <target>11</target>
                     <!-- Disable annotation processing for ourselves. -->
                     <compilerArgument>-proc:none</compilerArgument>
                 </configuration>

src/main/java/ch/zhaw/splab/podilizerproc/annotations/LambdaProcessor.java

@@ -2,6 +2,8 @@
 
 import ch.zhaw.splab.podilizerproc.awslambda.Functions;
 import ch.zhaw.splab.podilizerproc.awslambda.LambdaFunction;
+import ch.zhaw.splab.podilizerproc.depdencies.CompilationUnitInfo;
+import ch.zhaw.splab.podilizerproc.depdencies.DependencyResolver;
 import com.sun.source.tree.ClassTree;
 import com.sun.source.tree.CompilationUnitTree;
 import com.sun.source.tree.MethodTree;
@@ -10,51 +12,73 @@
 import com.sun.source.util.TreePathScanner;
 import com.sun.source.util.Trees;
 
-import javax.annotation.processing.*;
+import javax.annotation.processing.AbstractProcessor;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.annotation.processing.RoundEnvironment;
+import javax.annotation.processing.SupportedAnnotationTypes;
 import javax.lang.model.SourceVersion;
 import javax.lang.model.element.Element;
 import javax.lang.model.element.TypeElement;
-import javax.tools.Diagnostic;
+import javax.lang.model.type.ExecutableType;
+import javax.lang.model.util.Types;
 import javax.tools.JavaFileObject;
 import java.io.IOException;
 import java.io.Writer;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
 
 /**
  * Processor of {@link Lambda} annotation
  */
 @SupportedAnnotationTypes({"ch.zhaw.splab.podilizerproc.annotations.Lambda"})
 public class LambdaProcessor extends AbstractProcessor {
+
     private Trees trees;
+    private Types typeUtils;
 
     /**
-     * Initialization of {@link ProcessEnvironment} object and {@link Trees} object
+     * Initialization.
      *
      * @param processingEnv
      */
     @Override
     public synchronized void init(ProcessingEnvironment processingEnv) {
         super.init(processingEnv);
         trees = Trees.instance(processingEnv);
+        typeUtils = processingEnv.getTypeUtils();
 
     }
 
 
     public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
-        ;
+        // TODO: For a normal maven compile call this class / method is called twice.
+        //  This method should somehow detect if it was already run and should avoid executing twice.
+        if (roundEnv.errorRaised()) {
+            System.out.println("[TERMITE] Code not compilable, skipping processing for now...");
+            return false;
+        }
+        if (roundEnv.processingOver()) {
+            System.out.println("[TERMITE] Nothing left todo, skipping processing...");
+            return false;
+        }
+
+
         List<LambdaFunction> functions = new ArrayList<>();
 
         Set<? extends Element> annotatedMethods = roundEnv.getElementsAnnotatedWith(Lambda.class);
-        if (annotatedMethods.size() == 0) {
+        if (annotatedMethods.isEmpty()) {
             return true;
         }
+        DependencyResolver dependencyResolver = new DependencyResolver(trees, roundEnv);
 
         for (Element element :
                 annotatedMethods) {
             MethodScanner methodScanner = new MethodScanner();
             TypeScanner typeScanner = new TypeScanner();
             CUVisitor cuVisitor = new CUVisitor();
 
+            Set<CompilationUnitInfo> requiredCompilationUnits = dependencyResolver.resolveDependencies(element);
 
             TreePath tp = trees.getPath(element);
             methodScanner.scan(tp, trees);
@@ -63,15 +87,24 @@ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment
             TreePath tp1 = trees.getPath(getMostExternalType(element));
             cuVisitor.visit(tp1, trees);
 
+            ExecutableType emeth = (ExecutableType) element.asType();
 
             Lambda lambda = element.getAnnotation(Lambda.class);
             LambdaFunction lambdaFunction =
-                    new LambdaFunction(methodScanner.getMethod(), typeScanner.getClazz(), cuVisitor.getCu(), lambda);
+                    new LambdaFunction(methodScanner.getMethod(),
+                            typeScanner.getClazz(),
+                            cuVisitor.getCu(),
+                            lambda,
+                            requiredCompilationUnits,
+                            emeth.getParameterTypes(),
+                            emeth.getReturnType());
             functions.add(lambdaFunction);
+
             try {
                 String packageName = lambdaFunction.generateInputPackage();
+                System.out.println("[TERMITE] Generating local Data Classes. For Package: " + packageName);
                 String generatedClassPath = packageName.substring(8, packageName.length() - 1);
-                JavaFileObject inputType = processingEnv.getFiler().createSourceFile(generatedClassPath +".InputType", null);
+                JavaFileObject inputType = processingEnv.getFiler().createSourceFile(generatedClassPath + ".InputType", null);
                 JavaFileObject outputType = processingEnv.getFiler().createSourceFile(generatedClassPath + ".OutputType", null);
                 Writer writer = inputType.openWriter();
                 Writer writer1 = outputType.openWriter();
@@ -81,8 +114,11 @@ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment
                 writer1.append(lambdaFunction.createOutputType());
                 writer.flush();
                 writer1.flush();
+                writer.close();
+                writer1.close();
+                System.out.println("[TERMITE] Successfully generated local sources.");
             } catch (IOException e) {
-                e.printStackTrace();
+                System.out.println("[TERMITE] Failed to generate local sources. They probably already exist.");
             }
 
         }

src/main/java/ch/zhaw/splab/podilizerproc/aspect/Invoke.java

@@ -1,25 +1,206 @@
 package ch.zhaw.splab.podilizerproc.aspect;
 
 
-import ch.zhaw.splab.podilizerproc.awslambda.InvokeThread;
+import ch.zhaw.splab.podilizerproc.annotations.Lambda;
+import ch.zhaw.splab.podilizerproc.awslambda.AwsCredentialsReader;
+import com.amazonaws.auth.AWSCredentials;
+import com.amazonaws.auth.AWSStaticCredentialsProvider;
+import com.amazonaws.auth.BasicAWSCredentials;
+import com.amazonaws.client.builder.AwsClientBuilder;
+import com.amazonaws.regions.Regions;
+import com.amazonaws.services.lambda.AWSLambda;
+import com.amazonaws.services.lambda.AWSLambdaClientBuilder;
+import com.amazonaws.services.lambda.model.InvokeRequest;
+import com.amazonaws.services.lambda.model.InvokeResult;
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
 import org.aspectj.lang.ProceedingJoinPoint;
-import org.aspectj.lang.annotation.*;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
 import org.aspectj.lang.reflect.MethodSignature;
 
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 
 @Aspect
 public class Invoke {
 
     @Around("@annotation(lambda)")
     public Object anyExec(ProceedingJoinPoint joinPoint,
                           ch.zhaw.splab.podilizerproc.annotations.Lambda lambda) throws Throwable {
+        System.out.println("[TERMITE] Annotation invoked");
         MethodSignature signature = (MethodSignature) joinPoint.getSignature();
         Method method = signature.getMethod();
 
-        InvokeThread invokeThread = new InvokeThread(method, lambda, joinPoint);
-        invokeThread.start();
-        return null;
+        return invokeOnLambda(method, lambda, joinPoint);
     }
 
+    private Object invokeOnLambda(Method method, Lambda lambda, ProceedingJoinPoint joinPoint) throws Throwable {
+        Class inClazz = null;
+        Class outClazz = null;
+        try {
+            inClazz = Class.forName(getInputPackage(method));
+            outClazz = Class.forName(getOutputPackage(method));
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+        AwsCredentialsReader credentialsReader = new AwsCredentialsReader();
+        credentialsReader.read();
+        String awsAccessKeyId = credentialsReader.getAwsAccessKeyId();
+        String awsSecretKeyAccessKey = credentialsReader.getAwsSecretAccessKey();
+        String regionName = lambda.region();
+        String functionName = getFunctionName(method);
+
+        AWSCredentials credentials = new BasicAWSCredentials(awsAccessKeyId, awsSecretKeyAccessKey);
+        Regions region = Regions.fromName(regionName);
+
+
+        AWSLambdaClientBuilder clientBuilder = AWSLambdaClientBuilder
+                .standard()
+                .withCredentials(new AWSStaticCredentialsProvider(credentials))
+                .withRegion(region);
+
+        if (!lambda.endPoint().equals("")) {
+            clientBuilder = clientBuilder.withEndpointConfiguration(new AwsClientBuilder.EndpointConfiguration(lambda.endPoint(), regionName));
+        }
+        AWSLambda awsLambda = clientBuilder.build();
+
+        ObjectMapper objectMapper = new ObjectMapper();
+        objectMapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
+        objectMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
+        String json = "";
+        try {
+            List<Object> ctorArgs = new ArrayList<>();
+            if (!Modifier.isStatic(joinPoint.getSignature().getModifiers())) {
+                ctorArgs.add(joinPoint.getTarget());
+            }
+            ctorArgs.addAll(Arrays.asList(joinPoint.getArgs()));
+
+
+            Constructor<Object> correctCtor = null;
+            for (Constructor<Object> constructor : inClazz.getConstructors()) {
+                if (constructor.getParameterCount() == ctorArgs.size()) {
+                    correctCtor = constructor;
+                    break;
+                }
+            }
+
+            Object inputObj = correctCtor.newInstance(ctorArgs.toArray());
+            json = objectMapper.writeValueAsString(inputObj);
+            // TODO: Remove these verbose printouts (Or make log level configurable)
+            System.out.println("[TERMITE] Sending json input.");
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | JsonProcessingException e) {
+            e.printStackTrace();
+        }
+        Object outObj = null;
+        Object methodResult = null;
+
+        try {
+            InvokeRequest invokeRequest = new InvokeRequest();
+            invokeRequest.setFunctionName(functionName);
+            invokeRequest.setPayload(json);
+            System.out.println("[TERMITE] Starting ");
+            InvokeResult invokeResult = awsLambda.invoke(invokeRequest);
+            String resultJson = byteBufferToString(invokeResult.getPayload(), StandardCharsets.UTF_8);
+            System.out.println("[TERMITE] Received json output."
+                    + " Size: " + invokeResult.getSdkHttpMetadata().getAllHttpHeaders().get("Content-Length"));
+            System.out.flush();
+            try {
+                outObj = objectMapper.readValue(resultJson, outClazz);
+                objectMapper.readerForUpdating(outObj).readValue(resultJson);
+            } catch (Throwable t) {
+                System.out.println("[TERMITE] Failed to deserialize result.");
+                t.printStackTrace();
+            }
+            // TODO: Remove these verbose printouts (Or make log level configurable)
+
+            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
+            if (outObj != null && signature != null && !void.class.equals(signature.getReturnType())) {
+                // GetResult is only generated for non void methods
+                Method getResultMethod = outObj.getClass().getDeclaredMethod("getResult");
+                methodResult = getResultMethod.invoke(outObj);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            System.out.println("Function " + method.getName() + " is unreachable. Processing locally...");
+
+            // Note: While using the joinPoint to proceed normal execution, the code will sometimes be executed twice.
+            // This is a known AspectJ Bug documented here: https://github.com/spring-projects/spring-framework/issues/24046
+            methodResult = joinPoint.proceed();
+        }
+        awsLambda.shutdown();
+
+        try {
+            if (outObj != null) {
+                String functionReport = "Thread of Function " + method.getName() + " invocation was finished. " +
+                        "Function performed at - " + outObj.getClass().getDeclaredMethod("getDefaultReturn", null).invoke(outObj) +
+                        " - for " + outObj.getClass().getDeclaredMethod("getTime", null).invoke(outObj) + " ms";
+                System.out.println(functionReport);
+            } else {
+                System.out.println("Processed " + method.getName() + " locally with result " + methodResult);
+            }
+        } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
+            e.printStackTrace();
+        }
+
+        return methodResult;
+    }
+
+
+    /**
+     * Generates package name for input type based on method signature
+     *
+     * @param method is method signature object
+     * @return {@link String} package name of InputType
+     */
+    private String getInputPackage(Method method) {
+        String fullClassName = method.getDeclaringClass().getName();
+        return "aws." + fullClassName + "." + method.getName() + method.getParameterCount() + ".InputType";
+    }
+
+    /**
+     * Generates package name for output type based on method signature
+     *
+     * @param method is method signature object
+     * @return {@link String} package name of OutputType
+     */
+    private String getOutputPackage(Method method) {
+        String fullClassName = method.getDeclaringClass().getName();
+        return "aws." + fullClassName + "." + method.getName() + method.getParameterCount() + ".OutputType";
+    }
+
+    /**
+     * Generates function name for annotated method over the load process
+     *
+     * @param method is annotated method to generate lambda function name for
+     * @return {@link String} name of format 'package_class_method_#argsNumber'
+     */
+    private String getFunctionName(Method method) {
+        String result = method.getDeclaringClass().getName().replace('.', '_');
+        result += "_" + method.getName();
+        result += method.getParameterCount();
+        return result;
+    }
+
+    private static String byteBufferToString(ByteBuffer buffer, Charset charset) {
+        byte[] bytes;
+        if (buffer.hasArray()) {
+            bytes = buffer.array();
+        } else {
+            bytes = new byte[buffer.remaining()];
+            buffer.get(bytes);
+        }
+        return new String(bytes, charset);
+    }
 }