Reorganize compiler for more flexibility.

[jagi.git] / src / jagi / fs / JavaHandler.java

package jagi.fs;

import jagi.*;
import java.util.*;
import java.util.function.*;
import java.util.logging.*;
import java.lang.reflect.*;
import java.nio.file.*;

public class JavaHandler implements Function<Map<Object, Object>, Map<Object, Object>> {
    private static final Logger log = Logger.getLogger("jagi-fs");
    private final Map<Compiler.Module, Function<Map<Object, Object>, Map<Object, Object>>> handlers = new WeakHashMap<>();

    public static class HandlerException extends RuntimeException {
	public final Path file;

	public HandlerException(Path file, String msg, Throwable cause) {
	    super(msg, cause);
	    this.file = file;
	}
	public HandlerException(Path file, String msg) {
	    this(file, msg, null);
	}

	public String getMessage() {
	    return(file + ": " + super.getMessage());
	}
    }

    @SuppressWarnings("unchecked")
    private static Function<Map<Object, Object>, Map<Object, Object>> makehandler(Compiler.Module mod) {
	Class<?> main;
	try {
	    main = mod.code.loadClass("Main");
	} catch(ClassNotFoundException e) {
	    throw(new HandlerException(mod.file, "no Main class"));
	}
	try {
	    Method wmain = main.getDeclaredMethod("wmain", String[].class);
	    int attr = wmain.getModifiers();
	    if(((attr & Modifier.STATIC) == 0) || ((attr & Modifier.PUBLIC) == 0))
		throw(new NoSuchMethodException());
	    Object handler = wmain.invoke(null, new Object[] {new String[] {}});
	    if(!(handler instanceof Function))
		throw(new HandlerException(mod.file, "wmain in " + main.getName() + " returned " + ((handler == null) ? "null" : ("a " + handler.getClass()))));
	    return((Function<Map<Object, Object>, Map<Object, Object>>)handler);
	} catch(IllegalAccessException e) {
	    throw(new HandlerException(mod.file, "could not call wmain", e));
	} catch(InvocationTargetException e) {
	    throw(new HandlerException(mod.file, "wmain failed", e.getCause()));
	} catch(NoSuchMethodException e) {
	}
	if(Function.class.isAssignableFrom(main)) {
	    try {
		Constructor<? extends Function> cons = main.asSubclass(Function.class).getConstructor();
		Function handler = cons.newInstance();
		return((Function<Map<Object, Object>, Map<Object, Object>>)handler);
	    } catch(NoSuchMethodException e) {
	    } catch(InvocationTargetException e) {
		throw(new HandlerException(mod.file, "constructor failed", e.getCause()));
	    } catch(ReflectiveOperationException e) {
		throw(new HandlerException(mod.file, "could not construct Main", e));
	    }
	}
	throw(new HandlerException(mod.file, "no wmain and not directly applicable"));
    }

    private Function<Map<Object, Object>, Map<Object, Object>> gethandler(Compiler.File file) {
	Compiler.Module mod = file.mod();
	synchronized(handlers) {
	    Function<Map<Object, Object>, Map<Object, Object>> ret = handlers.get(mod);
	    if(ret == null)
		handlers.put(mod, ret = makehandler(mod));
	    return(ret);
	}
    }

    public Map<Object, Object> apply(Map<Object, Object> req) {
	Compiler.File file = Compiler.get().file(Paths.get((String)req.get("SCRIPT_FILENAME")));
	try {
	    file.update();
	} catch(Compiler.CompilationException e) {
	    log.warning(String.format("Could not compile %s:\n%s", file.name, e.messages()));
	    return(Utils.simpleerror(500, "Internal Error", "Could not load JAGI handler"));
	} catch(Exception e) {
	    log.log(Level.WARNING, String.format("Error occurred when loading %s", file.name), e);
	    return(Utils.simpleerror(500, "Internal Error", "Could not load JAGI handler"));
	}
	Function<Map<Object, Object>, Map<Object, Object>> handler;
	try {
	    handler = gethandler(file);
	} catch(HandlerException e) {
	    Throwable cause = e.getCause();
	    if(cause != null)
		log.log(Level.WARNING, cause, e::getMessage);
	    else
		log.log(Level.WARNING, e::getMessage);
	    return(Utils.simpleerror(500, "Internal Error", "Invalid JAGI handler"));
	}
	return(handler.apply(req));
    }
}