function factory

Author: patriot1burke

src/main/java/com/microsoft/azure/functions/worker/broker/JavaMethodExecutor.java

@@ -1,10 +1,18 @@
 package com.microsoft.azure.functions.worker.broker;
 
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
 import java.lang.reflect.*;
-import java.net.*;
+import java.net.URL;
 import java.util.*;
+import java.util.logging.FileHandler;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.logging.SimpleFormatter;
 
-import com.microsoft.azure.functions.annotation.*;
+import com.microsoft.azure.functions.worker.WorkerLogManager;
 import com.microsoft.azure.functions.worker.binding.*;
 import com.microsoft.azure.functions.worker.description.*;
 import com.microsoft.azure.functions.worker.reflect.*;
@@ -16,7 +24,7 @@
  */
 public class JavaMethodExecutor {
     public JavaMethodExecutor(FunctionMethodDescriptor descriptor, Map<String, BindingInfo> bindingInfos, ClassLoaderProvider classLoaderProvider)
-            throws MalformedURLException, ClassNotFoundException, NoSuchMethodException
+            throws IOException, ClassNotFoundException, NoSuchMethodException
     {
         descriptor.validateMethodInfo();
 
@@ -42,24 +50,69 @@ public JavaMethodExecutor(FunctionMethodDescriptor descriptor, Map<String, Bindi
         for (Map.Entry<String, BindingInfo> entry : bindingInfos.entrySet()) {
             this.bindingDefinitions.put(entry.getKey(), new BindingDefinition(entry.getKey(), entry.getValue()));
         }
+        resolveFunctionFactory();
     }
-    
+
+    // TODO remove once I figure out how to see logging in local docker
+    private static Logger fileLogger;
+    static {
+        fileLogger = Logger.getAnonymousLogger();
+        fileLogger.setUseParentHandlers(false);
+        FileHandler fh = null;
+        try {
+            fh = new FileHandler("java_worker.log");
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        fh.setFormatter(new SimpleFormatter());
+        fh.setLevel(Level.ALL);
+        fileLogger.addHandler(fh);
+        fileLogger.info("INITIALIZED LOGGER");
+
+    }
+    private Logger getLogger() {
+        return fileLogger;
+    }
+
     Map<String, BindingDefinition> getBindingDefinitions() { return this.bindingDefinitions; }
 
     public ParameterResolver getOverloadResolver() { return this.overloadResolver; }
 
     void execute(BindingDataStore dataStore) throws Exception {
         Object retValue = this.overloadResolver.resolve(dataStore)
             .orElseThrow(() -> new NoSuchMethodException("Cannot locate the method signature with the given input"))
-            .invoke(() -> this.containingClass.newInstance());
+            .invoke(() -> createFunctionInstance());
         dataStore.setDataTargetValue(BindingDataStore.RETURN_NAME, retValue);
     }
-    
+
+    private Object createFunctionInstance() throws Exception {
+        if (functionFactory == null) {
+            return this.containingClass.newInstance();
+        }
+        return functionFactory.invoke(null, containingClass);
+    }
+
     Class<?> getContainingClass(String className, ClassLoaderProvider classLoaderProvider) throws ClassNotFoundException {
         ClassLoader classLoader = classLoaderProvider.getClassLoader();
         return Class.forName(className, true, classLoader);
     }
 
+    private void resolveFunctionFactory() throws IOException, ClassNotFoundException, NoSuchMethodException {
+        ClassLoader cl = containingClass.getClassLoader();
+        InputStream is = cl.getResourceAsStream("META-INF/service/com.microsoft.azure.functions.FunctionFactory");
+        if (is == null) {
+            getLogger().info("resolveFunctionFactory could not find descriptor");
+            return;
+        }
+        BufferedReader reader = new BufferedReader(new InputStreamReader(is));
+        String factoryName = reader.readLine().trim();
+        Class factoryClass = cl.loadClass(factoryName);
+        functionFactory = factoryClass.getMethod("newInstance", Class.class);
+        is.close();
+    }
+
+
+    private Method functionFactory;
     private Class<?> containingClass;
     private final ParameterResolver overloadResolver;
     private final Map<String, BindingDefinition> bindingDefinitions;