com.networknt.aws.lambda.LambdaInvokerConfig Maven / Gradle / Ivy

Go to download
package com.networknt.aws.lambda;

import com.fasterxml.jackson.core.type.TypeReference;
import com.networknt.config.Config;
import com.networknt.config.ConfigException;
import com.networknt.config.JsonMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.HashMap;
import java.util.Map;

public class LambdaInvokerConfig {
    private static final Logger logger = LoggerFactory.getLogger(LambdaInvokerConfig.class);

    public static final String CONFIG_NAME = "lambda-invoker";
    private static final String REGION = "region";
    private static final String ENDPOINT_OVERRIDE = "endpointOverride";
    private static final String LOG_TYPE = "logType";
    private static final String FUNCTIONS = "functions";
    private static final String METRICS_INJECTION = "metricsInjection";
    private static final String METRICS_NAME = "metricsName";

    private String region;
    private String endpointOverride;
    private String logType;
    private Map functions;
    private boolean metricsInjection;
    private String metricsName;

    public String getRegion() {
        return region;
    }

    public void setRegion(String region) {
        this.region = region;
    }

    public String getEndpointOverride() {
        return endpointOverride;
    }

    public void setEndpointOverride(String endpointOverride) {
        this.endpointOverride = endpointOverride;
    }

    public String getLogType() {
        return logType;
    }

    public void setLogType(String logType) {
        this.logType = logType;
    }

    public Map getFunctions() {
        return functions;
    }

    public void setFunctions(Map functions) {
        this.functions = functions;
    }

    public boolean isMetricsInjection() {
        return metricsInjection;
    }

    public void setMetricsInjection(boolean metricsInjection) {
        this.metricsInjection = metricsInjection;
    }

    public String getMetricsName() {
        return metricsName;
    }

    public void setMetricsName(String metricsName) {
        this.metricsName = metricsName;
    }

    private Config config;
    private Map mappedConfig;

    public LambdaInvokerConfig() {
        this(CONFIG_NAME);
    }

    /**
     * Please note that this constructor is only for testing to load different config files
     * to test different configurations.
     * @param configName String
     */
    private LambdaInvokerConfig(String configName) {
        config = Config.getInstance();
        mappedConfig = config.getJsonMapConfigNoCache(configName);
        setConfigData();
        setConfigMap();
    }
    public static LambdaInvokerConfig load() {
        return new LambdaInvokerConfig();
    }

    public static LambdaInvokerConfig load(String configName) {
        return new LambdaInvokerConfig(configName);
    }

    void reload() {
        mappedConfig = config.getJsonMapConfigNoCache(CONFIG_NAME);
        setConfigData();
        setConfigMap();
    }
    public Map getMappedConfig() {
        return mappedConfig;
    }

    private void setConfigData() {
        Object object = mappedConfig.get(REGION);
        if (object != null) {
            region = ((String)object);
        }
        object = mappedConfig.get(ENDPOINT_OVERRIDE);
        if (object != null) {
            endpointOverride = ((String) object);
        }
        object = mappedConfig.get(LOG_TYPE);
        if (object != null) {
            logType = ((String) object);
        }
        object = getMappedConfig().get(METRICS_INJECTION);
        if(object != null && (Boolean) object) {
            metricsInjection = true;
        }
        object = getMappedConfig().get(METRICS_NAME);
        if(object != null ) {
            metricsName = (String)object;
        }
    }

    private void setConfigMap() {
        if (mappedConfig.get(FUNCTIONS) != null) {
            Object object = mappedConfig.get(FUNCTIONS);
            functions = new HashMap<>();
            if(object instanceof String) {
                String s = (String)object;
                s = s.trim();
                if(logger.isTraceEnabled()) logger.trace("functions s = " + s);
                if(s.startsWith("{")) {
                    // json format
                    try {
                        functions = Config.getInstance().getMapper().readValue(s, new TypeReference>() {});
                    } catch (Exception e) {
                        throw new ConfigException("could not parse the functions json with a map of string and string.");
                    }
                } else {
                    // comma separated
                    String[] pairs = s.split(",");
                    for (int i = 0; i < pairs.length; i++) {
                        String pair = pairs[i];
                        String[] keyValue = pair.split(":");
                        functions.put(keyValue[0], keyValue[1]);
                    }
                }
            } else if (object instanceof Map) {
                functions = (Map)object;
            } else {
                throw new ConfigException("functions must be a string string map.");
            }
        }

    }
}