Wit.AI Java Client

	package edu.sjsu.amigo.mp.kafka;
	import com.fasterxml.jackson.annotation.JsonProperty;
	import lombok.Data;
	/**
	* The intent object returned from the wit.ai service.
	*
	* {
	"msg_id" : "5e89f3d9-93d1-4dfa-b128-73fda21974b3",
	"_text" : "list my ec2 instances on aws and azure",
	"entities" : {
	"intent" : [ {
	"confidence" : 0.9771069792658154,
	"type" : "value",
	"value" : "list"
	}, {
	"confidence" : 0.9721842327959846,
	"type" : "value",
	"value" : "ec2"
	}, {
	"confidence" : 0.873736763412216,
	"type" : "value",
	"value" : "aws"
	}, {
	"confidence" : 0.7501236802989762,
	"type" : "value",
	"value" : "azure",
	"suggested" : true
	} ]
	}
	}
	This class represents each element of intent JSON array.
	*
	* @author rwatsh on 3/8/17.
	*/
	@Data
	public class IntentElem {
	@JsonProperty
	private String confidence;
	@JsonProperty
	private String type;
	@JsonProperty
	private String value;
	@JsonProperty
	private boolean suggested;
	}

view raw IntentElem.java hosted with ❤ by GitHub

	package edu.sjsu.amigo.slackbot;
	/**
	* @author rwatsh on 3/7/17.
	*/
	public class InvalidMessageException extends RuntimeException {
	public InvalidMessageException(Throwable t) {
	super(t);
	}
	public InvalidMessageException(String msg) {
	super(msg);
	}
	}

view raw InvalidMessageException.java hosted with ❤ by GitHub

	package edu.sjsu.amigo.slackbot;
	import com.fasterxml.jackson.databind.JsonNode;
	import edu.sjsu.amigo.http.client.HttpClient;
	import edu.sjsu.amigo.http.client.Response;
	import edu.sjsu.amigo.mp.kafka.IntentElem;
	import edu.sjsu.amigo.mp.util.JsonUtils;
	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	/**
	* This class provides methods to access wit.api REST endpoints.
	*
	* @author rwatsh on 3/7/17.
	*/
	public class WitDotAIClient {
	public static final String WIT_AI_SERVER_ACCESS_TOKEN = System.getenv("WIT_AI_SERVER_ACCESS_TOKEN");
	public static final String WIT_AI_URL_PREFIX = "https://api.wit.ai";
	public static final String WIT_AI_MESSAGE_URI = "/message";
	public static final String WIT_AI_INTENTS_URI = "/intents";
	public static final Map<String, String> queryStringMap = new HashMap<String, String>() {
	{
	put("v", "20160526");
	}
	};
	public static final Map<String, String> headersMap = new HashMap<String, String>() {
	{
	put("authorization", "Bearer " + WIT_AI_SERVER_ACCESS_TOKEN); //OAuth 2.0 Bearer Token
	}
	};
	/**
	* Given a message find the intents.
	*
	* A sample message from wit.ai:
	* {
	"msg_id" : "5e89f3d9-93d1-4dfa-b128-73fda21974b3",
	"_text" : "list my ec2 instances on aws and azure",
	"entities" : {
	"intent" : [ {
	"confidence" : 0.9771069792658154,
	"type" : "value",
	"value" : "list"
	}, {
	"confidence" : 0.9721842327959846,
	"type" : "value",
	"value" : "ec2"
	}, {
	"confidence" : 0.873736763412216,
	"type" : "value",
	"value" : "aws"
	}, {
	"confidence" : 0.7501236802989762,
	"type" : "value",
	"value" : "azure",
	"suggested" : true
	} ]
	}
	}
	*
	* @param message the message to parse and to find intents from.
	* @return an array of intents.
	*/
	public static List<IntentElem> getIntent(String message) {
	try(HttpClient httpClient = new HttpClient()) {
	String url = WIT_AI_URL_PREFIX + WIT_AI_MESSAGE_URI;
	queryStringMap.put("q", message);
	Response<String> resp = httpClient.get(url, null, queryStringMap, headersMap, String.class);
	JsonNode jsonNode = JsonUtils.parseJson(resp.getRawBody());
	JsonNode intentNode = jsonNode.path("entities").path("intent");
	List<IntentElem> intents = new ArrayList<>();
	if(intentNode.isArray()) {
	for (JsonNode node: intentNode) {
	IntentElem intentElem = new IntentElem();
	intentElem.setConfidence(node.path("confidence").asText());
	intentElem.setType(node.path("type").asText());
	intentElem.setValue(node.path("value").asText());
	intentElem.setSuggested(node.path("suggested").asBoolean());
	intents.add(intentElem);
	}
	}
	//return JsonUtils.prettyPrint(resp.getRawBody());
	return intents;
	} catch (Exception e) {
	throw new InvalidMessageException(e);
	}
	}
	/**
	* Get all intents.
	*
	* @return
	*/
	public static String getAllIntents() {
	try(HttpClient httpClient = new HttpClient()) {
	String url = WIT_AI_URL_PREFIX + WIT_AI_INTENTS_URI;
	Response<String> resp = httpClient.get(url, null, null, headersMap, String.class);
	return JsonUtils.prettyPrint(resp.getRawBody());
	} catch (Exception e) {
	throw new InvalidMessageException(e);
	}
	}
	public static void main(String[] args) throws IOException {
	String message = "list ec2 instances aws";
	List<IntentElem> resp = getIntent(message);
	System.out.println("Input: " + message);
	System.out.println(JsonUtils.convertObjectToJson(resp));
	//String intents = getAllIntents();
	//System.out.println(intents);
	}
	}

view raw WitDotAIClient.java hosted with ❤ by GitHub

Docker Swarm: An Introduction

Docker swarm is orchestrator for docker containers.

1. It can be used to deploy docker containers in a cluster.
2. The cluster has one or more managers and multiple workers.
3. The docker engine on the cluster nodes have the docker swarm mode (as of docker 1.12 release) which can be used to register nodes to the swarm cluster (no separate service registry is required). It internally uses Consul for service registration. No separate swarm agent container is required to run on each cluster node anymore like it was required before 1.12 release.
4. The same docker compose file can be used to deploy application locally on one host and in swarm cluster. So no separate deployment files for development and production modes. This is an advantage compared to kubernetes where we have docker-compose file for development on a single host only and kubernetes specific deployment file for deployment in kubernetes cluster in production.
5. Once a cluster is provisioned, docker swarm will manage on which node the service container gets deployed.
6. Docker swarm will also ensure that at any time the number of container replicas remains same. So if a node goes down or a container crashes, it will start new container for the application service such that the total number of replicas remain same as configured initially. This is same as what Amazon Auto scaling group (ASG) does.

Apache Kafka Message Producer/Consumer

Message Producer for Kafka

	package edu.sjsu.amigo.mp.kafka;
	import org.apache.kafka.clients.producer.KafkaProducer;
	import org.apache.kafka.clients.producer.Producer;
	import org.apache.kafka.clients.producer.ProducerConfig;
	import org.apache.kafka.clients.producer.ProducerRecord;
	import java.io.Closeable;
	import java.util.Properties;
	import static edu.sjsu.amigo.mp.kafka.MessageQueueConstants.USER_MSG_TOPIC;
	/**
	* A kafka message producer.
	*
	* @author rwatsh on 2/26/17.
	*/
	public class MessageProducer implements AutoCloseable {
	private final Producer producer;
	public MessageProducer() {
	//Configure the Producer
	Properties configProperties = new Properties();
	// Assuming that localhost port 9092 is mapped to kafka container's port 9092
	// TODO externalize the port
	configProperties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"localhost:9092");
	configProperties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.ByteArraySerializer");
	configProperties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");
	producer = new KafkaProducer<String, String>(configProperties);
	}
	public void sendUserMessage(String message) {
	sendMessage(USER_MSG_TOPIC, message);
	}
	private void sendMessage(String topicName, String message) {
	ProducerRecord<String, String> rec = new ProducerRecord<String, String>(topicName, message);
	producer.send(rec);
	}
	/**
	* Closes this resource, relinquishing any underlying resources.
	* This method is invoked automatically on objects managed by the
	* {@code try}-with-resources statement.
	* <p>
	* <p>While this interface method is declared to throw {@code
	* Exception}, implementers are <em>strongly</em> encouraged to
	* declare concrete implementations of the {@code close} method to
	* throw more specific exceptions, or to throw no exception at all
	* if the close operation cannot fail.
	* <p>
	* <p> Cases where the close operation may fail require careful
	* attention by implementers. It is strongly advised to relinquish
	* the underlying resources and to internally <em>mark</em> the
	* resource as closed, prior to throwing the exception. The {@code
	* close} method is unlikely to be invoked more than once and so
	* this ensures that the resources are released in a timely manner.
	* Furthermore it reduces problems that could arise when the resource
	* wraps, or is wrapped, by another resource.
	* <p>
	* <p><em>Implementers of this interface are also strongly advised
	* to not have the {@code close} method throw {@link
	* InterruptedException}.</em>
	* <p>
	* This exception interacts with a thread's interrupted status,
	* and runtime misbehavior is likely to occur if an {@code
	* InterruptedException} is {@linkplain Throwable#addSuppressed
	* suppressed}.
	* <p>
	* More generally, if it would cause problems for an
	* exception to be suppressed, the {@code AutoCloseable.close}
	* method should not throw it.
	* <p>
	* <p>Note that unlike the {@link Closeable#close close}
	* method of {@link Closeable}, this {@code close} method
	* is <em>not</em> required to be idempotent. In other words,
	* calling this {@code close} method more than once may have some
	* visible side effect, unlike {@code Closeable.close} which is
	* required to have no effect if called more than once.
	* <p>
	* However, implementers of this interface are strongly encouraged
	* to make their {@code close} methods idempotent.
	*
	* @throws Exception if this resource cannot be closed
	*/
	@Override
	public void close() throws Exception {
	if (producer != null) {
	producer.close();
	}
	}
	}

view raw MessageProducer.java hosted with ❤ by GitHub

Message Consumer for Kafka

	/*
	* Copyright (c) 2017 San Jose State University.
	*
	* Permission is hereby granted, free of charge, to any person obtaining a copy
	* of this software and associated documentation files (the "Software"), to deal
	* in the Software without restriction, including without limitation the rights
	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	* copies of the Software, and to permit persons to whom the Software is
	* furnished to do so, subject to the following conditions:
	*
	* The above copyright notice and this permission notice shall be included in
	* all copies or substantial portions of the Software.
	*/
	package edu.sjsu.amigo.cp.kafka;
	import edu.sjsu.amigo.cp.jobs.JobManager;
	import edu.sjsu.amigo.cp.jobs.MessageProcessorJob;
	import org.apache.kafka.clients.consumer.ConsumerRecord;
	import org.apache.kafka.clients.consumer.ConsumerRecords;
	import org.apache.kafka.clients.consumer.KafkaConsumer;
	import org.apache.kafka.common.errors.WakeupException;
	import org.apache.kafka.common.serialization.StringDeserializer;
	import org.quartz.JobDataMap;
	import org.quartz.SchedulerException;
	import java.util.*;
	import java.util.concurrent.ExecutorService;
	import java.util.concurrent.Executors;
	import java.util.concurrent.TimeUnit;
	import static edu.sjsu.amigo.mp.kafka.MessageQueueConstants.AMIGO_CHATBOT_GROUP;
	import static edu.sjsu.amigo.mp.kafka.MessageQueueConstants.USER_MSG_TOPIC;
	/**
	* A Kafka message consumer. As soon as it receives a message it will spawn a job to process it.
	*
	* Based on https://www.confluent.io/blog/tutorial-getting-started-with-the-new-apache-kafka-0-9-consumer-client/
	*
	* @author rwatsh on 2/25/17.
	*/
	public class ConsumerLoop implements Runnable {
	private final KafkaConsumer<String, String> consumer;
	private final List<String> topics;
	private final int id;
	public ConsumerLoop(int id,
	String groupId,
	List<String> topics) {
	this.id = id;
	this.topics = topics;
	Properties props = new Properties();
	props.put("bootstrap.servers", "localhost:9092");
	props.put("group.id", groupId);
	props.put("key.deserializer", StringDeserializer.class.getName());
	props.put("value.deserializer", StringDeserializer.class.getName());
	this.consumer = new KafkaConsumer<>(props);
	}
	@Override
	public void run() {
	try {
	consumer.subscribe(topics);
	while (true) {
	ConsumerRecords<String, String> records = consumer.poll(Long.MAX_VALUE);
	for (ConsumerRecord<String, String> record : records) {
	Map<String, Object> data = new HashMap<>();
	data.put("partition", record.partition());
	data.put("offset", record.offset());
	String value = record.value();
	data.put("value", value);
	processMessageAsync(value);
	System.out.println(this.id + ": " + data);
	}
	}
	} catch (WakeupException e) {
	// ignore for shutdown
	} finally {
	consumer.close();
	}
	}
	private void processMessageAsync(String value) {
	if (value != null && !value.trim().isEmpty()) {
	try {
	// Using Quartz job scheduler to process the message asynchronously
	// Job code is not shown in this gist.
	// Some unique job name
	String jobName = "MESG-JOB-" + UUID.randomUUID().toString();
	String groupName = "CHATBOT-GRP";
	JobDataMap params = new JobDataMap();
	params.put("message", value);
	JobManager.getInstance().scheduleJob(MessageProcessorJob.class, jobName, groupName, params);
	} catch (Exception e) {
	e.printStackTrace();
	}
	}
	}
	public void shutdown() {
	consumer.wakeup();
	}
	/**
	* Run the client program.
	*
	* @param args
	*/
	public static void main(String[] args) throws SchedulerException {
	//Start the job scheduler
	JobManager.getInstance().startScheduler();
	int numConsumers = 3;
	String groupId = AMIGO_CHATBOT_GROUP;
	List<String> topics = Arrays.asList(USER_MSG_TOPIC);
	ExecutorService executor = Executors.newFixedThreadPool(numConsumers);
	final List<ConsumerLoop> consumers = new ArrayList<>();
	for (int i = 0; i < numConsumers; i++) {
	ConsumerLoop consumer = new ConsumerLoop(i, groupId, topics);
	consumers.add(consumer);
	executor.submit(consumer);
	}
	Runtime.getRuntime().addShutdownHook(new Thread() {
	@Override
	public void run() {
	for (ConsumerLoop consumer : consumers) {
	consumer.shutdown();
	}
	executor.shutdown();
	try {
	executor.awaitTermination(5000, TimeUnit.MILLISECONDS);
	} catch (InterruptedException e) {
	e.printStackTrace();
	}
	}
	});
	}
	}

view raw ConsumerLoop.java hosted with ❤ by GitHub

Java HttpClient using Unirest Java Library

	package edu.sjsu.amigo.http.client;
	import com.fasterxml.jackson.core.JsonProcessingException;
	import com.mashape.unirest.http.HttpResponse;
	import com.mashape.unirest.http.JsonNode;
	import com.mashape.unirest.http.ObjectMapper;
	import com.mashape.unirest.http.Unirest;
	import com.mashape.unirest.http.exceptions.UnirestException;
	import com.mashape.unirest.request.GetRequest;
	import com.mashape.unirest.request.HttpRequestWithBody;
	import java.io.*;
	import java.util.Map;
	import java.util.logging.Logger;
	/**
	* Wrapper over http methods with basic auth.
	*
	* Below methods are synchronous.
	*
	* For asynch methods use the unirest-java library directly.
	*
	* @author rwatsh on 2/27/17.
	* @see "http://unirest.io/java.html"
	*/
	public class HttpClient implements AutoCloseable {
	private static final Logger LOGGER = Logger.getLogger(HttpClient.class.getName());
	private String user;
	private String password;
	/**
	* Create a http client with no auth (user anonymous).
	*/
	public HttpClient() {
	init();
	}
	/**
	* Create a http client with basic auth.
	*
	* @param user
	* @param passwd
	*/
	public HttpClient(String user, String passwd) {
	init();
	this.user = user;
	this.password = passwd;
	}
	/**
	* Initialize the instance.
	*/
	private void init() {
	// setup to serialize Json from\to Object using jackson object mapper
	Unirest.setObjectMapper(new ObjectMapper() {
	private com.fasterxml.jackson.databind.ObjectMapper jacksonObjectMapper
	= new com.fasterxml.jackson.databind.ObjectMapper();
	public <T> T readValue(String value, Class<T> valueType) {
	try {
	return jacksonObjectMapper.readValue(value, valueType);
	} catch (IOException e) {
	throw new RuntimeException(e);
	}
	}
	public String writeValue(Object value) {
	try {
	return jacksonObjectMapper.writeValueAsString(value);
	} catch (JsonProcessingException e) {
	throw new RuntimeException(e);
	}
	}
	});
	}
	public <T> Response<T> get(String url, Class<T> clazz) throws HttpClientException {
	return get(url, null, null, null, clazz);
	}
	public <T> Response<T> get(String url,
	Map<String, String> routeParamsMap,
	Map<String, String> queryStringMap,
	Map<String, String> headersMap,
	Class<T> clazz) throws HttpClientException {
	GetRequest request = Unirest.get(url);
	return executeGetRequest(routeParamsMap, queryStringMap, headersMap, clazz, request);
	}
	public <T> Response<T> head(String url, Class<T> clazz) throws HttpClientException {
	return head(url, null, null, null, clazz);
	}
	public <T> Response<T> head(String url,
	Map<String, String> routeParamsMap,
	Map<String, String> queryStringMap,
	Map<String, String> headersMap,
	Class<T> clazz) throws HttpClientException {
	GetRequest request = Unirest.head(url);
	return executeGetRequest(routeParamsMap, queryStringMap, headersMap, clazz, request);
	}
	public Response<Object> post(String url, Object bodyObject) throws HttpClientException {
	return post(url, null, null, null, bodyObject);
	}
	public Response<Object> post(String url,
	Map<String, String> routeParamsMap,
	Map<String, String> queryStringMap,
	Map<String, String> headersMap,
	Object bodyObject) throws HttpClientException {
	HttpRequestWithBody request = Unirest.post(url);
	return executeHttpRequestWithBody(routeParamsMap, queryStringMap, headersMap, bodyObject, request);
	}
	public Response<Object> put(String url, Object bodyObject) throws HttpClientException {
	return put(url, null, null, null, bodyObject);
	}
	public Response<Object> put(String url,
	Map<String, String> routeParamsMap,
	Map<String, String> queryStringMap,
	Map<String, String> headersMap,
	Object bodyObject) throws HttpClientException {
	HttpRequestWithBody request = Unirest.post(url);
	return executeHttpRequestWithBody(routeParamsMap, queryStringMap, headersMap, bodyObject, request);
	}
	public Response<Object> delete(String url, Object bodyObject) throws HttpClientException {
	return delete(url, null, null, null, bodyObject);
	}
	public Response<Object> delete(String url,
	Map<String, String> routeParamsMap,
	Map<String, String> queryStringMap,
	Map<String, String> headersMap,
	Object bodyObject) throws HttpClientException {
	HttpRequestWithBody request = Unirest.delete(url);
	return executeHttpRequestWithBody(routeParamsMap, queryStringMap, headersMap, bodyObject, request);
	}
	private <T> Response executeGetRequest(Map<String, String> routeParamsMap, Map<String, String> queryStringMap, Map<String, String> headersMap, Class<T> clazz, GetRequest request) throws HttpClientException {
	request.basicAuth(user, password);
	if(routeParamsMap != null) {
	for (Map.Entry<String, String> entry : routeParamsMap.entrySet()) {
	request.routeParam(entry.getKey(), entry.getValue());
	}
	}
	if (queryStringMap != null) {
	for (Map.Entry<String, String> entry : queryStringMap.entrySet()) {
	request.queryString(entry.getKey(), entry.getValue());
	}
	}
	if (headersMap != null) {
	for (Map.Entry<String, String> entry : headersMap.entrySet()) {
	request.header(entry.getKey(), entry.getValue());
	}
	}
	try {
	HttpResponse<T> response = request.asObject(clazz);
	Response<T> r = new Response();
	r.setStatusCode(response.getStatus());
	r.setStatusText(response.getStatusText());
	r.setRawBody(getStringFromInputStream(response.getRawBody()));
	r.setParsedObject(response.getBody());
	return r;
	} catch (UnirestException e) {
	throw new HttpClientException(e);
	}
	}
	private Response executeHttpRequestWithBody(Map<String, String> routeParamsMap, Map<String, String> queryStringMap, Map<String, String> headersMap, Object bodyObject, HttpRequestWithBody request) throws HttpClientException {
	request.basicAuth(user, password);
	if(routeParamsMap != null) {
	for (Map.Entry<String, String> entry : routeParamsMap.entrySet()) {
	request.routeParam(entry.getKey(), entry.getValue());
	}
	}
	if (queryStringMap != null) {
	for (Map.Entry<String, String> entry : queryStringMap.entrySet()) {
	request.queryString(entry.getKey(), entry.getValue());
	}
	}
	if (headersMap != null) {
	for (Map.Entry<String, String> entry : headersMap.entrySet()) {
	request.header(entry.getKey(), entry.getValue());
	}
	}
	if(bodyObject != null) {
	request.body(bodyObject);
	}
	try {
	HttpResponse<JsonNode> response = request.asJson();
	Response<Object> r = new Response();
	r.setStatusCode(response.getStatus());
	r.setStatusText(response.getStatusText());
	r.setRawBody(getStringFromInputStream(response.getRawBody()));
	r.setParsedObject(response.getBody().isArray() ?
	response.getBody().getArray() :
	response.getBody().getObject());
	return r;
	} catch (UnirestException e) {
	throw new HttpClientException(e);
	}
	}
	// convert InputStream to String
	private static String getStringFromInputStream(InputStream is) {
	if (is == null) return "";
	BufferedReader br = null;
	StringBuilder sb = new StringBuilder();
	String line;
	try {
	br = new BufferedReader(new InputStreamReader(is));
	while ((line = br.readLine()) != null) {
	sb.append(line);
	}
	} catch (IOException e) {
	e.printStackTrace();
	} finally {
	if (br != null) {
	try {
	br.close();
	} catch (IOException e) {
	e.printStackTrace();
	}
	}
	}
	return sb.toString();
	}
	/**
	* Closes this resource, relinquishing any underlying resources.
	* This method is invoked automatically on objects managed by the
	* {@code try}-with-resources statement.
	* <p>
	* <p>While this interface method is declared to throw {@code
	* Exception}, implementers are <em>strongly</em> encouraged to
	* declare concrete implementations of the {@code close} method to
	* throw more specific exceptions, or to throw no exception at all
	* if the close operation cannot fail.
	* <p>
	* <p> Cases where the close operation may fail require careful
	* attention by implementers. It is strongly advised to relinquish
	* the underlying resources and to internally <em>mark</em> the
	* resource as closed, prior to throwing the exception. The {@code
	* close} method is unlikely to be invoked more than once and so
	* this ensures that the resources are released in a timely manner.
	* Furthermore it reduces problems that could arise when the resource
	* wraps, or is wrapped, by another resource.
	* <p>
	* <p><em>Implementers of this interface are also strongly advised
	* to not have the {@code close} method throw {@link
	* InterruptedException}.</em>
	* <p>
	* This exception interacts with a thread's interrupted status,
	* and runtime misbehavior is likely to occur if an {@code
	* InterruptedException} is {@linkplain Throwable#addSuppressed
	* suppressed}.
	* <p>
	* More generally, if it would cause problems for an
	* exception to be suppressed, the {@code AutoCloseable.close}
	* method should not throw it.
	* <p>
	* <p>Note that unlike the {@link Closeable#close close}
	* method of {@link Closeable}, this {@code close} method
	* is <em>not</em> required to be idempotent. In other words,
	* calling this {@code close} method more than once may have some
	* visible side effect, unlike {@code Closeable.close} which is
	* required to have no effect if called more than once.
	* <p>
	* However, implementers of this interface are strongly encouraged
	* to make their {@code close} methods idempotent.
	*
	* @throws Exception if this resource cannot be closed
	*/
	@Override
	public void close() throws Exception {
	Unirest.shutdown();
	}
	}

view raw HttpClient.java hosted with ❤ by GitHub

	package edu.sjsu.amigo.http.client;
	/**
	* A friendly http client exception.
	*
	* @author rwatsh on 2/27/17.
	*/
	public class HttpClientException extends Exception {
	public HttpClientException(String msg) {
	super(msg);
	}
	public HttpClientException(Throwable throwable) {
	super(throwable);
	}
	}

view raw HttpClientException.java hosted with ❤ by GitHub

	package edu.sjsu.amigo.http.client.test;
	import edu.sjsu.amigo.http.client.HttpClient;
	import edu.sjsu.amigo.http.client.Response;
	import org.junit.Test;
	import java.util.HashMap;
	import java.util.Map;
	/**
	* Test against the http://httpbin.org service endpoints.
	*
	* @author rwatsh on 3/1/17.
	*/
	public class HttpClientTest {
	@Test
	public void testGetRequest() throws Exception {
	try(HttpClient c = new HttpClient()) {
	Response<String> resp = c.get("http://httpbin.org/get", String.class);
	System.out.println(resp);
	} catch (Exception e) {
	throw e;
	}
	}
	@Test
	public void testHeadRequest() throws Exception {
	try (HttpClient c = new HttpClient()) {
	Response<String> resp = c.head("http://httpbin.org/get", String.class);
	System.out.println(resp);
	} catch (Exception e) {
	throw e;
	}
	}
	@Test
	public void testPostRequest() throws Exception {
	try (HttpClient c = new HttpClient()) {
	String data = "test";
	Response<Object> resp = c.post("http://httpbin.org/post", data);
	System.out.println(resp);
	} catch (Exception e) {
	throw e;
	}
	}
	@Test
	public void testPutRequest() throws Exception {
	try (HttpClient c = new HttpClient()) {
	Map<String, String> data = new HashMap<>();
	data.put("isTest", "yes");
	Response<Object> resp = c.put("http://httpbin.org/put", null);
	System.out.println(resp);
	} catch (Exception e) {
	throw e;
	}
	}
	@Test
	public void testDeleteRequest() throws Exception {
	try (HttpClient c = new HttpClient()) {
	String data = "test";
	Response<Object> resp = c.delete("http://httpbin.org/delete", data);
	System.out.println(resp);
	} catch (Exception e) {
	throw e;
	}
	}
	}

view raw HttpClientTest.java hosted with ❤ by GitHub

	<?xml version="1.0" encoding="UTF-8"?>
	<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<artifactId>httpclient-common</artifactId>
	<dependencies>
	<dependency>
	<groupId>org.apache.httpcomponents</groupId>
	<artifactId>httpclient</artifactId>
	<version>${httpclient.version}</version>
	</dependency>
	<dependency>
	<groupId>org.apache.httpcomponents</groupId>
	<artifactId>httpasyncclient</artifactId>
	<version>${httpasyncclient.version}</version>
	</dependency>
	<dependency>
	<groupId>org.apache.httpcomponents</groupId>
	<artifactId>httpmime</artifactId>
	<version>${httpmime.version}</version>
	</dependency>
	<dependency>
	<groupId>org.json</groupId>
	<artifactId>json</artifactId>
	<version>${json.version}</version>
	</dependency>
	<dependency>
	<groupId>com.mashape.unirest</groupId>
	<artifactId>unirest-java</artifactId>
	<version>${unirest-java.version}</version>
	</dependency>
	<dependency>
	<groupId>com.fasterxml.jackson.core</groupId>
	<artifactId>jackson-core</artifactId>
	<version>${jackson-core.version}</version>
	</dependency>
	<dependency>
	<groupId>com.fasterxml.jackson.core</groupId>
	<artifactId>jackson-annotations</artifactId>
	<version>${jackson-core.version}</version>
	</dependency>
	<dependency>
	<groupId>com.fasterxml.jackson.core</groupId>
	<artifactId>jackson-databind</artifactId>
	<version>${jackson-core.version}</version>
	</dependency>
	<dependency>
	<groupId>org.projectlombok</groupId>
	<artifactId>lombok</artifactId>
	<version>${lombok.version}</version>
	<scope>provided</scope>
	</dependency>
	<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>${junit.version}</version>
	<scope>test</scope>
	</dependency>
	<dependency>
	<groupId>commons-io</groupId>
	<artifactId>commons-io</artifactId>
	<version>${commons-io.version}</version>
	<scope>test</scope>
	</dependency>
	</dependencies>
	<properties>
	<httpclient.version>4.3.6</httpclient.version>
	<httpasyncclient.version>4.0.2</httpasyncclient.version>
	<httpmime.version>4.3.6</httpmime.version>
	<json.version>20140107</json.version>
	<unirest-java.version>1.4.9</unirest-java.version>
	<junit.version>4.11</junit.version>
	<commons-io.version>2.4</commons-io.version>
	<jackson-core.version>2.8.6</jackson-core.version>
	<lombok.version>1.16.6</lombok.version>
	</properties>
	</project>

view raw pom.xml hosted with ❤ by GitHub

	package edu.sjsu.amigo.http.client;
	import lombok.Data;
	import java.util.Map;
	/**
	* Http response wrapper.
	*
	* @author rwatsh on 3/1/17.
	*/
	@Data
	public class Response<T> {
	private int statusCode;
	private String statusText;
	private Map<String, String> headers;
	private String rawBody;
	private T parsedObject;
	}

view raw Response.java hosted with ❤ by GitHub

Dockerize Java Application

	# Use this base image for JDK 8
	# You can even use this image to set up maven and build from source the fat jar
	# that you will execute below.
	# See this for setting up maven - https://runnable.com/docker/java/dockerize-your-java-application
	FROM sjsucohort6/oracle-java:8
	MAINTAINER Watsh Rajneesh <watsh.rajneesh@sjsu.edu>
	WORKDIR /slackbot
	# Use maven-shade-plugin to create a fat jar of your application which runs as a service
	# see my gist on slackbot for example pom.xml or google it up.
	ADD ./target/slackbot-1.0-SNAPSHOT.jar /slackbot
	CMD ["java", "-jar", "slackbot-1.0-SNAPSHOT.jar"]

view raw Dockerfile hosted with ❤ by GitHub