com.bluejeans.jin.client.BasicJinClient Maven / Gradle / Ivy

Go to download
/**
 *
 */
package com.bluejeans.jin.client;

import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

import javax.net.ssl.SSLContext;

import org.apache.commons.io.IOUtils;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.ssl.SSLContexts;

/**
 * @author Dinesh Ilindra
 *
 */
public class BasicJinClient {

    public static final int DEFAULT_PORT = 5678;

    public static final String API_PREFIX = "/do";

    public static final String GET_PREFIX = "/get";

    public static final String RUN_PREFIX = "/run";

    public abstract class JinRequestContext {
        private final StringBuilder api = new StringBuilder();

        public JinRequestContext append(final String part) {
            api.append(part);
            return this;
        }

        public String getApi() {
            return api.toString();
        }
    }

    public class JinRequestTarget extends JinRequestContext {
        public JinRequestTarget(final String target) {
            append("/");
            append(target);
        }

        public JinRequestProperty property(final String property) {
            return new JinRequestProperty(this, property);
        }
    }

    public class JinRequestProperty extends JinRequestContext {
        private String argStr(final Object obj) {
            if (obj == null) {
                return "{NULL}";
            } else if (obj instanceof Boolean) {
                return "{" + obj + "}";
            } else {
                return obj.toString();
            }
        }

        public JinRequestProperty(final JinRequestTarget target, final String property) {
            append(target.getApi());
            append("/");
            append(property);
        }

        public JinRequestProperty f(final String name) {
            return field(name);
        }

        public JinRequestProperty field(final String name) {
            append("..$");
            append(name);
            return this;
        }

        public JinRequestProperty fSet(final String name, final Object value) {
            field(name);
            append("~~");
            if (value == null) {
                append("$null");
            } else {
                append(String.valueOf(value));
            }
            return this;
        }

        public JinRequestProperty m(final String name) {
            return method(name);
        }

        public JinRequestProperty method(final String name) {
            append("..");
            append(name);
            return this;
        }

        public JinRequestProperty get(final String key) {
            return mapGet(key);
        }

        public JinRequestProperty get(final int index) {
            return listGet(index);
        }

        public JinRequestProperty mapGet(final String key) {
            append("..");
            append("~");
            append(key);
            return this;
        }

        public JinRequestProperty mapSet(final String key, final Object value) {
            append("..");
            append("~");
            append(key);
            append("~~");
            append(value.toString());
            return this;
        }

        public JinRequestProperty listGet(final int index) {
            append("..");
            append("~");
            append(String.valueOf(index));
            return this;
        }

        public JinRequestProperty listSet(final int index, final Object value) {
            append("..");
            append("~");
            append(String.valueOf(index));
            append("~~");
            append(value.toString());
            return this;
        }

        public JinRequestProperty args(final Object... args) {
            return withArgs(args);
        }

        public JinRequestProperty withArgs(final Object... args) {
            append("~~");
            append(Arrays.asList(args).stream().map(a -> argStr(a)).collect(Collectors.joining("::")));
            return this;
        }

        public List get() {
            return BasicJinClient.this.get(getApi());
        }

        public List call() {
            return BasicJinClient.this.call(getApi());
        }
    }

    public class JinRequestSpring extends JinRequestProperty {
        public JinRequestSpring() {
            super(new JinRequestTarget("spring"), "context");
        }

        public JinRequestProperty bean(final String name) {
            return method("getBean").withArgs(name);
        }
    }

    private Set urls = null;
    private JinUrlProvider provider = null;
    private CloseableHttpClient httpClient = null;

    public BasicJinClient() {
        this("localhost");
    }

    public BasicJinClient(final String jins) {
        final List jinList = Arrays.asList(jins.split(","));
        urls = jinList.stream().map(j -> j.contains("://") ? j : "http://" + j)
                .map(j -> j.split(":").length > 2 ? j : j + ":" + DEFAULT_PORT).collect(Collectors.toSet());
        initHttp();
    }

    public BasicJinClient(final JinUrlProvider provider) {
        this.provider = provider;
        initHttp();
    }

    private void initHttp() {
        if (httpClient == null) {
            final SSLContextBuilder builder = SSLContexts.custom();
            PoolingHttpClientConnectionManager cm = null;
            try {
                builder.loadTrustMaterial(null, (chain, authType) -> true);
                final SSLContext sslContext = builder.build();
                final SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext,
                        NoopHostnameVerifier.INSTANCE);
                final Registry socketFactoryRegistry = RegistryBuilder
                        . create().register("https", sslsf)
                        .register("http", new PlainConnectionSocketFactory()).build();
                cm = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
            } catch (NoSuchAlgorithmException | KeyStoreException | KeyManagementException ex) {
                cm = new PoolingHttpClientConnectionManager();
            }
            cm.setMaxTotal(200);
            cm.setDefaultMaxPerRoute(20);
            httpClient = HttpClients.custom().setConnectionManager(cm).build();
        }
    }

    public List invoke(final String uri, final String prefix) {
        return (urls == null ? provider.getJinUrls() : urls).parallelStream().map(u -> {
            try {
                return IOUtils.toString(httpClient.execute(new HttpGet(u + prefix + uri)).getEntity().getContent());
            } catch (final Exception e) {
                return null;
            }
        }).filter(v -> v != null).filter(v -> !v.trim().startsWith("{\"error\"")).collect(Collectors.toList());
    }

    public List run(final String scr) {
        return invoke(scr, RUN_PREFIX);
    }

    public List call(final String api) {
        return invoke(api, API_PREFIX);
    }

    public List get(final String api) {
        return invoke(api, GET_PREFIX);
    }

    public JinRequestTarget target(final String name) {
        return new JinRequestTarget(name);
    }

    public JinRequestSpring spring() {
        return new JinRequestSpring();
    }

}