Release version 2.0.2

Bumps [golang.org/x/net](https://github.com/golang/net) from 0.7.0 to 0.17.0.
- [Commits](https://github.com/golang/net/compare/v0.7.0...v0.17.0)

---
updated-dependencies:
- dependency-name: golang.org/x/net
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <[email protected]>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.gitignore

@@ -7,4 +7,5 @@ target/
 logs/
 server/pki/
 client/src/main/python/setup.py
+grafana/timely-app/yarn-error.log
 

analytics/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>timely</groupId>
     <artifactId>timely</artifactId>
-    <version>1.2.1</version>
+    <version>2.0.2</version>
   </parent>
   <artifactId>timely-analytics</artifactId>
   <!--
@@ -68,6 +68,7 @@
     <pluginManagement>
       <plugins>
         <plugin>
+          <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-compiler-plugin</artifactId>
           <configuration>
             <compilerId>jdt</compilerId>
@@ -76,7 +77,7 @@
             <dependency>
               <groupId>org.eclipse.tycho</groupId>
               <artifactId>tycho-compiler-jdt</artifactId>
-              <version>0.21.0</version>
+              <version>1.4.0</version>
             </dependency>
           </dependencies>
         </plugin>
@@ -168,6 +169,12 @@
                 </excludes>
               </artifactSet>
               <filters>
+                <filter>
+                  <artifact>*:*</artifact>
+                  <excludes>
+                    <exclude>**/module-info.class</exclude>
+                  </excludes>
+                </filter>
                 <filter>
                   <artifact>org.apache.flink:*</artifact>
                   <excludes>
@@ -245,6 +252,14 @@
                   <artifactSet>
                     <excludes combine.self="override" />
                   </artifactSet>
+                  <filters>
+                    <filter>
+                      <artifact>*:*</artifact>
+                      <excludes>
+                        <exclude>**/module-info.class</exclude>
+                      </excludes>
+                    </filter>
+                  </filters>
                 </configuration>
               </execution>
             </executions>

analytics/src/main/java/timely/analytics/flink/MetricHistogram.java

@@ -7,6 +7,7 @@ import java.util.List;
 import java.util.stream.Collectors;
 
 import org.apache.flink.streaming.util.serialization.SerializationSchema;
+
 import timely.model.Tag;
 
 public class MetricHistogram implements Serializable, SerializationSchema<MetricHistogram> {

analytics/src/main/java/timely/analytics/flink/MetricKeySelector.java

@@ -1,13 +1,13 @@
 package timely.analytics.flink;
 
 import org.apache.flink.api.java.functions.KeySelector;
+
 import timely.api.response.MetricResponse;
 
 /**
- * Uniquely defines a time series in a Flink stream. A unique time series is the
- * metric name and all of its tags, to include visibility if it exists.
+ * Uniquely defines a time series in a Flink stream. A unique time series is the metric name and all of its tags, to include visibility if it exists.
  */
-public class MetricKeySelector implements KeySelector<MetricResponse, String> {
+public class MetricKeySelector implements KeySelector<MetricResponse,String> {
 
     private static final long serialVersionUID = 1L;
 

analytics/src/main/java/timely/analytics/flink/SortedStringAccumulator.java

@@ -9,11 +9,11 @@ import org.apache.flink.api.common.accumulators.Accumulator;
  * Custom accumulator that retains a sorted map of strings and their counts
  *
  */
-public class SortedStringAccumulator implements Accumulator<String, ConcurrentSkipListMap<String, MutableLong>> {
+public class SortedStringAccumulator implements Accumulator<String,ConcurrentSkipListMap<String,MutableLong>> {
 
     private static final long serialVersionUID = 1L;
 
-    private ConcurrentSkipListMap<String, MutableLong> values = new ConcurrentSkipListMap<>();
+    private ConcurrentSkipListMap<String,MutableLong> values = new ConcurrentSkipListMap<>();
 
     @Override
     public void add(String value) {
@@ -25,7 +25,7 @@ public class SortedStringAccumulator implements Accumulator<String, ConcurrentSk
     }
 
     @Override
-    public ConcurrentSkipListMap<String, MutableLong> getLocalValue() {
+    public ConcurrentSkipListMap<String,MutableLong> getLocalValue() {
         return values;
     }
 
@@ -35,7 +35,7 @@ public class SortedStringAccumulator implements Accumulator<String, ConcurrentSk
     }
 
     @Override
-    public void merge(Accumulator<String, ConcurrentSkipListMap<String, MutableLong>> other) {
+    public void merge(Accumulator<String,ConcurrentSkipListMap<String,MutableLong>> other) {
         other.getLocalValue().forEach((k, v) -> {
             if (values.containsKey(k)) {
                 values.get(k).add(v.longValue());
@@ -46,7 +46,7 @@ public class SortedStringAccumulator implements Accumulator<String, ConcurrentSk
     }
 
     @Override
-    public Accumulator<String, ConcurrentSkipListMap<String, MutableLong>> clone() {
+    public Accumulator<String,ConcurrentSkipListMap<String,MutableLong>> clone() {
         SortedStringAccumulator a = new SortedStringAccumulator();
         a.getLocalValue().putAll(this.values);
         return a;

analytics/src/main/java/timely/analytics/flink/SubscriptionSource.java

@@ -22,6 +22,7 @@ import org.apache.flink.streaming.api.functions.source.RichSourceFunction;
 import org.apache.flink.streaming.api.watermark.Watermark;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+
 import timely.api.response.MetricResponse;
 import timely.api.response.MetricResponses;
 import timely.client.websocket.ClientHandler;
@@ -65,10 +66,9 @@ public class SubscriptionSource extends RichSourceFunction<MetricResponse> imple
     public void open(Configuration parameters) throws Exception {
         LOG.info("Opening summarization job.");
         super.open(parameters);
-        client = new WebSocketSubscriptionClient(jp.getTimelyHostname(), jp.getTimelyHttpsPort(), jp.getTimelyWssPort(),
-                jp.isClientAuth(), jp.isDoLogin(), jp.getTimelyUsername(), jp.getTimelyPassword(), jp.getKeyStoreFile(),
-                jp.getKeyStoreType(), jp.getKeyStorePass(), jp.getTrustStoreFile(), jp.getTrustStoreType(),
-                jp.getTrustStorePass(), jp.isHostVerificationEnabled(), jp.getBufferSize());
+        client = new WebSocketSubscriptionClient(jp.getTimelyHostname(), jp.getTimelyHttpsPort(), jp.getTimelyWssPort(), jp.isClientAuth(), jp.isDoLogin(),
+                        jp.getTimelyUsername(), jp.getTimelyPassword(), jp.getKeyStoreFile(), jp.getKeyStoreType(), jp.getKeyStorePass(),
+                        jp.getTrustStoreFile(), jp.getTrustStoreType(), jp.getTrustStorePass(), jp.isHostVerificationEnabled(), jp.getBufferSize());
     }
 
     @Override
@@ -103,12 +103,10 @@ public class SubscriptionSource extends RichSourceFunction<MetricResponse> imple
 
                     @Override
                     public void onMessage(final String message) {
-                        LOG.info("Message received on Websocket session {}, length: {}", session.getId(),
-                                message.length());
+                        LOG.info("Message received on Websocket session {}, length: {}", session.getId(), message.length());
                         try {
                             // Deserialize in this thread
-                            final MetricResponses responses = JsonSerializer.getObjectMapper().readValue(message,
-                                    MetricResponses.class);
+                            final MetricResponses responses = JsonSerializer.getObjectMapper().readValue(message, MetricResponses.class);
                             // Process in the other
                             final Runnable r = () -> {
                                 responses.getResponses().forEach(response -> {

analytics/src/main/java/timely/analytics/flink/SummarizationJob.java

@@ -13,6 +13,7 @@ import org.apache.flink.streaming.api.functions.sink.SocketClientSink;
 import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+
 import timely.api.response.MetricResponse;
 
 public class SummarizationJob {
@@ -67,7 +68,7 @@ public class SummarizationJob {
         })
         .name("Metric Windows")
         .addSink(
-    		new SocketClientSink<MetricHistogram>(jp.getTimelyHostname(), jp.getTimelyTcpPort(),
+            new SocketClientSink<MetricHistogram>(jp.getTimelyHostname(), jp.getTimelyTcpPort(),
                     new MetricHistogram(), 2, true) {
 
                 private final Logger LOG = LoggerFactory

analytics/src/main/java/timely/analytics/flink/SummarizationJobParameters.java

@@ -184,8 +184,8 @@ public class SummarizationJobParameters extends GlobalJobParameters implements S
     }
 
     @Override
-    public Map<String, String> toMap() {
-        Map<String, String> m = new HashMap<>();
+    public Map<String,String> toMap() {
+        Map<String,String> m = new HashMap<>();
         m.put("timelyHostname", this.timelyHostname);
         m.put("timelyHttpsPort", Integer.toString(this.timelyHttpsPort));
         m.put("timelyWssPort", Integer.toString(this.timelyWssPort));

analytics/src/main/spotbugs/excludes.xml

@@ -15,4 +15,12 @@
     <Method name="getMetrics" />
     <Bug pattern="EI_EXPOSE_REP" />
   </Match>
+  <Match>
+    <!-- these are probably avoidable, but needs further triage to fix -->
+    <Bug pattern="EI_EXPOSE_REP" />
+  </Match>
+  <Match>
+    <!-- these are probably avoidable, but needs further triage to fix -->
+    <Bug pattern="EI_EXPOSE_REP2" />
+  </Match>
 </FindBugsFilter>

analytics/src/test/java/timely/analytics/flink/MetricHistogramTest.java

@@ -6,6 +6,7 @@ import java.util.List;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
+
 import timely.model.Metric;
 import timely.model.Tag;
 import timely.model.parse.MetricParser;
@@ -96,9 +97,8 @@ public class MetricHistogramTest {
             Metric metric = metricParser.parse(put);
             Assert.assertEquals("sys.cpu.user_summarized", metric.getName());
             metric.getTags().forEach(t -> {
-                Assert.assertTrue(
-                        t.equals(t1) || t.equals(t2) || t.equals(avg) || t.equals(min) || t.equals(max) || t.equals(sum)
-                                || t.equals(count) || t.equals(p50) || t.equals(p75) || t.equals(p90) || t.equals(p99));
+                Assert.assertTrue(t.equals(t1) || t.equals(t2) || t.equals(avg) || t.equals(min) || t.equals(max) || t.equals(sum) || t.equals(count)
+                                || t.equals(p50) || t.equals(p75) || t.equals(p90) || t.equals(p99));
             });
         }
     }

balancer/bin/create-timely-balancer-profiles.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+
+if [[ `uname` == "Darwin" ]]; then
+    THIS_SCRIPT=`python -c 'import os,sys; print os.path.realpath(sys.argv[1])' $0`
+else
+    THIS_SCRIPT=`readlink -f $0`
+fi
+
+THIS_DIR="${THIS_SCRIPT%/*}"
+BASE_DIR=$(cd $THIS_DIR/.. && pwd)
+BIN_DIR=${BASE_DIR}/bin
+CONF_DIR=${BASE_DIR}/conf
+
+. ${BIN_DIR}/timely-balancer-env.sh
+
+for i in $(seq 1 $NUM_PROFILES); do
+    if [ "$NUM_PROFILES" -eq "1" ]; then
+        FILENAME=timely-balancer.yml
+    else
+        FILENAME=timely-balancer-${i}.yml
+    fi
+
+    echo "creating configuration file ${CONF_DIR}/${FILENAME}"
+    cp ${CONF_DIR}/timely-balancer-template.yml ${CONF_DIR}/${FILENAME}
+    sed -i "s/\${ZOOKEEPERS}/${ZOOKEEPERS}/g" ${CONF_DIR}/${FILENAME}
+    MULTIPLE=$(($i - 1))
+    TCP_PORT=$(($TCP_PORT_START + $MULTIPLE * $PORT_INCREMENT))
+    sed -i "s/\${TCP_PORT}/${TCP_PORT}/g" ${CONF_DIR}/${FILENAME}
+    HTTP_PORT=$(($HTTP_PORT_START + $MULTIPLE * $PORT_INCREMENT))
+    sed -i "s/\${HTTP_PORT}/${HTTP_PORT}/g" ${CONF_DIR}/${FILENAME}
+    WEBSOCKET_PORT=$(($WEBSOCKET_PORT_START + $MULTIPLE * $PORT_INCREMENT))
+    sed -i "s/\${WEBSOCKET_PORT}/${WEBSOCKET_PORT}/g" ${CONF_DIR}/${FILENAME}
+    UDP_PORT=$(($UDP_PORT_START + $MULTIPLE * $PORT_INCREMENT))
+    sed -i "s/\${UDP_PORT}/${UDP_PORT}/g" ${CONF_DIR}/${FILENAME}
+    sed -i "s/\${INSTANCE}/${i}/g" ${CONF_DIR}/${FILENAME}
+    sed -i "s#\${SERVER_CERTIFICATE_FILE}#${SERVER_CERTIFICATE_FILE}#g" ${CONF_DIR}/${FILENAME}
+    sed -i "s#\${SERVER_KEY_FILE}#${SERVER_KEY_FILE}#g" ${CONF_DIR}/${FILENAME}
+    sed -i "s/\${SERVER_KEY_PASSWORD}/${SERVER_KEY_PASSWORD}/g" ${CONF_DIR}/${FILENAME}
+    sed -i "s/\${SERVER_USE_GENERATED_KEYPAIR}/${SERVER_USE_GENERATED_KEYPAIR}/g" ${CONF_DIR}/${FILENAME}
+    sed -i "s#\${CLIENT_KEY_FILE}#${CLIENT_KEY_FILE}#g" ${CONF_DIR}/${FILENAME}
+    sed -i "s/\${CLIENT_KEY_TYPE}/${CLIENT_KEY_TYPE}/g" ${CONF_DIR}/${FILENAME}
+    sed -i "s/\${CLIENT_KEY_PASSWORD}/${CLIENT_KEY_PASSWORD}/g" ${CONF_DIR}/${FILENAME}
+    sed -i "s#\${TRUST_STORE_PEM}#${TRUST_STORE_PEM}#g" ${CONF_DIR}/${FILENAME}
+    sed -i "s#\${TRUST_STORE_JKS}#${TRUST_STORE_JKS}#g" ${CONF_DIR}/${FILENAME}
+    sed -i "s/\${TRUST_STORE_PASSWORD}/${TRUST_STORE_PASSWORD}/g" ${CONF_DIR}/${FILENAME}
+done
+

balancer/bin/start-all.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+if [[ `uname` == "Darwin" ]]; then
+    THIS_SCRIPT=`python -c 'import os,sys; print os.path.realpath(sys.argv[1])' $0`
+else
+    THIS_SCRIPT=`readlink -f $0`
+fi
+
+THIS_DIR="${THIS_SCRIPT%/*}"
+BASE_DIR=$(cd $THIS_DIR/.. && pwd)
+BIN_DIR=${BASE_DIR}/bin
+
+. ${BIN_DIR}/timely-balancer-env.sh
+
+if [ "$NUM_PROFILES" -eq "1" ]; then
+    echo ${BIN_DIR}/timely-balancer.sh
+    ${BIN_DIR}/timely-balancer.sh
+else
+    for i in $(seq 1 $NUM_PROFILES); do
+        echo ${BIN_DIR}/timely-balancer.sh $i
+        ${BIN_DIR}/timely-balancer.sh $i
+    done
+fi

balancer/bin/stop-all.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+pkill -9 -f timely.balancer.Balancer

balancer/bin/timely-balancer-env.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+NUM_PROFILES=1
+ZOOKEEPERS=localhost:2181
+TCP_PORT_START=4242
+HTTP_PORT_START=4243
+WEBSOCKET_PORT_START=4244
+UDP_PORT_START=4245
+PORT_INCREMENT=100
+
+HOST_IP=0.0.0.0
+HOST=$(hostname -s)
+HOST_FQDN=$(hostname -f)
+
+GENERATE_KEYS=true
+TRUST_STORE_TYPE=
+TRUST_STORE_FILE=
+TRUST_STORE_PASSWORD=
+KEY_STORE_TYPE=
+KEY_STORE_FILE=
+KEY_STORE_PASSWORD=
+AUTHORIZATION_URL=
+AUTHORIZATION_CERTIFICATE_TYPE=
+AUTHORIZATION_CERTIFICATE_FILE=

balancer/bin/timely-balancer.sh

@@ -9,35 +9,65 @@ else
 fi
 
 THIS_DIR="${THIS_SCRIPT%/*}"
-NATIVE_DIR="${THIS_DIR}/META-INF/native"
-BASE_DIR=${THIS_DIR}/..
-TMP_DIR="${BASE_DIR}/tmp"
-CONF_DIR="${BASE_DIR}/conf"
-LIB_DIR="${BASE_DIR}/lib"
-NUM_SERVER_THREADS=4
 
-if [[ -e ${TMP_DIR} ]]; then
-  rm -rf ${TMP_DIR}
+set -a
+. ${THIS_DIR}/timely-balancer-env.sh
+set +a
+
+if [ -n "$1" ]; then
+  export PROFILE_NUM=$1
+  PROFILE_ARG="--spring.profiles.active=${PROFILE_NUM}"
+  PID=`jps -m | grep timely.balancer.Balancer | grep "spring.profiles.active=${PROFILE_NUM}" | awk '{print $1}'`
+else
+  export PROFILE_NUM=""
+  PID=`jps -m | grep timely.balancer.Balancer | awk '{print $1}'`
 fi
-mkdir ${TMP_DIR}
 
-if [[ -e ${NATIVE_DIR} ]]; then
-  rm -rf ${NATIVE_DIR}
+if [ "$PID" == "" ]; then
+
+    NATIVE_DIR="${THIS_DIR}/META-INF/native"
+    BASE_DIR=$(cd $THIS_DIR/.. && pwd)
+    TMP_DIR="${BASE_DIR}/tmp"
+    CONF_DIR="${BASE_DIR}/conf"
+    LIB_DIR="${BASE_DIR}/lib"
+    export LOG_DIR="${BASE_DIR}/logs"
+    NUM_SERVER_THREADS=4
+
+    if [[ -e ${TMP_DIR} ]]; then
+      rm -rf ${TMP_DIR}
+    fi
+    mkdir ${TMP_DIR}
+
+    if [[ -e ${NATIVE_DIR} ]]; then
+      rm -rf ${NATIVE_DIR}
+    fi
+    mkdir -p ${NATIVE_DIR}
+
+    if [[ ! -e ${LOG_DIR} ]]; then
+      mkdir ${LOG_DIR}
+    fi
+
+    pushd ${BASE_DIR}/bin
+    $JAVA_HOME/bin/jar xf ${LIB_DIR}/netty-tcnative-boringssl-static*.jar META-INF/native/libnetty_tcnative_linux_x86_64.${TCNATIVE_SUFFIX}
+    $JAVA_HOME/bin/jar xf ${LIB_DIR}/netty-all*.jar META-INF/native/libnetty_transport_native_epoll_x86_64.${TCNATIVE_SUFFIX}
+    popd
+
+    export CLASSPATH="${CONF_DIR}:${LIB_DIR}/*:${HADOOP_CONF_DIR}"
+    JVM_ARGS="-Xmx1G -Xms1G -Dio.netty.eventLoopThreads=${NUM_SERVER_THREADS} -Dlog4j.configurationFile=${CONF_DIR}/log4j2-spring.xml"
+    JVM_ARGS="${JVM_ARGS} -DLog4jContextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector"
+    JVM_ARGS="${JVM_ARGS} -Djava.library.path=${NATIVE_DIR}"
+
+    JVM_ARGS="${JVM_ARGS} -Xmx2G -Xms2G -XX:NewSize=1G -XX:MaxNewSize=1G"
+    JVM_ARGS="${JVM_ARGS} -XX:+UseCompressedOops -XX:+UseNUMA -Djava.net.preferIPv4Stack=true"
+    JVM_ARGS="${JVM_ARGS} -XX:+UseG1GC -XX:MaxGCPauseMillis=4000 -XX:ParallelGCThreads=20 -XX:+UseStringDeduplication"
+
+    echo "$JAVA_HOME/bin/java ${JVM_ARGS} timely.balancer.Balancer --spring.config.name=timely-balancer ${PROFILE_ARG}"
+    nohup $JAVA_HOME/bin/java ${JVM_ARGS} timely.balancer.Balancer --spring.config.name=timely-balancer ${PROFILE_ARG} >> ${LOG_DIR}/timely-balancer${PROFILE_NUM}-startup.log 2>&1 &
+
+else
+    if [ "$PROFILE_NUM" == ""]; then
+        echo "timely-balancer already running with pid ${PID}"
+    else
+        echo "timely-balancer ${PROFILE_NUM} already running with pid ${PID}"
+    fi
 fi
-mkdir -p ${NATIVE_DIR}
-
-pushd ${BASE_DIR}/bin
-$JAVA_HOME/bin/jar xf ${LIB_DIR}/netty-tcnative*.jar META-INF/native/libnetty_tcnative.${TCNATIVE_SUFFIX}
-$JAVA_HOME/bin/jar xf ${LIB_DIR}/netty-transport-native-epoll*.jar META-INF/native/libnetty_transport_native_epoll_x86_64.${TCNATIVE_SUFFIX}
-popd
-
-export CLASSPATH="${CONF_DIR}:${LIB_DIR}/*:${HADOOP_CONF_DIR}"
-JVM_ARGS="-Xmx1G -Xms1G -Dio.netty.eventLoopThreads=${NUM_SERVER_THREADS}"
-JVM_ARGS="${JVM_ARGS} -DLog4jContextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector"
-JVM_ARGS="${JVM_ARGS} -Djava.library.path=${NATIVE_DIR}"
-JVM_ARGS="${JVM_ARGS} -Djava.library.path=${NATIVE_DIR}/libnetty-${TCNATIVE_SUFFIX}"
-
-#JVM_ARGS="${JVM_ARGS} -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005"
-
-echo "$JAVA_HOME/bin/java ${JVM_ARGS} timely.balancer.Balancer --spring.config.name=timely --spring.profiles.active=balancer"
-$JAVA_HOME/bin/java ${JVM_ARGS} timely.balancer.Balancer --spring.config.name=timely --spring.profiles.active=balancer

balancer/conf/log4j2-spring.xml

@@ -5,25 +5,19 @@
     <Property name="LOG_PATTERN">%clr{%d{yyyy-MM-dd HH:mm:ss.SSS}}{faint} %clr{%5p} %clr{${sys:PID}}{magenta} %clr{---}{faint} %clr{[%15.15t]}{faint} %clr{%-40.40c{1.}}{cyan} %clr{:}{faint} %m%n%wEx</Property>
   </Properties>
   <Appenders>
-    <RollingRandomAccessFile name="Rolling" fileName="/srv/logs/timely/timely-balancer.log"
-    						 filePattern="/srv/logs/timely/$${date:yyyy-MM}/timely-balancer-%d{MM-dd-yyyy}-%i.log.gz">
+    <RollingRandomAccessFile name="Rolling" fileName="${env:LOG_DIR}/timely-balancer${env:PROFILE_NUM}.log"
+    						 filePattern="${env:LOG_DIR}/$${date:yyyy-MM}/timely-balancer${env:PROFILE_NUM}-%d{MM-dd-yyyy}-%i.log.gz">
       <PatternLayout pattern="${LOG_PATTERN}"/>
       <Policies>
       	<SizeBasedTriggeringPolicy size="1024 MB" />
       </Policies>
       <DefaultRolloverStrategy max="10" />
     </RollingRandomAccessFile>
-    <Console name="Console" target="SYSTEM_OUT">
-      <PatternLayout pattern="${LOG_PATTERN}"/>
-    </Console>
   </Appenders>
   <Loggers>
-    <Root level="trace" includeLocation="false">
-      <AppenderRef ref="Console" level="warn" />
-      <AppenderRef ref="Rolling" level="trace" />
+    <Root level="warn" includeLocation="false">
+      <AppenderRef ref="Rolling"/>
     </Root>
-    <Logger name="timely" additivity="false">
-      <AppenderRef ref="Console" level="debug" />
-    </Logger>
+    <Logger name="timely" level="debug"/>
   </Loggers>
 </Configuration>

balancer/conf/security.properties

@@ -0,0 +1,9 @@
+trust.store.type=${TRUST_STORE_TYPE}
+trust.store.file=${TRUST_STORE_FILE}
+trust.store.password=${TRUST_STORE_PASSWORD}
+key.store.type=${KEY_STORE_TYPE}
+key.store.file=${KEY_STORE_FILE}
+key.store.password=${KEY_STORE_PASSWORD}
+authorization.url=${AUTHORIZATION_URL}
+authorization.certificate.type=${AUTHORIZATION_CERTIFICATE_TYPE}
+authorization.certificate.file=${AUTHORIZATION_CERTIFICATE_FILE}

balancer/conf/security.xml

@@ -1,51 +1,44 @@
 <beans:beans xmlns="http://www.springframework.org/schema/security"
-             xmlns:beans="http://www.springframework.org/schema/beans"
-             xmlns:util="http://www.springframework.org/schema/util"
-             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-             xsi:schemaLocation="http://www.springframework.org/schema/beans
+			 xmlns:beans="http://www.springframework.org/schema/beans"
+			 xmlns:util="http://www.springframework.org/schema/util"
+			 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+			 xmlns:context="http://www.springframework.org/schema/context"
+			 xsi:schemaLocation="http://www.springframework.org/schema/beans
 								 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 								 http://www.springframework.org/schema/security
 								 http://www.springframework.org/schema/security/spring-security.xsd
 								 http://www.springframework.org/schema/util
-								 http://www.springframework.org/schema/util/spring-util.xsd">
-		          
-	<beans:bean id="x509PrincipalExtractor" class="org.springframework.security.web.authentication.preauth.x509.SubjectDnX509PrincipalExtractor">
-		<beans:property name="subjectDnRegex" value="CN=(.*?)(?:,|$)"/>
+								 http://www.springframework.org/schema/util/spring-util.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
+
+	<context:property-placeholder location="classpath:security.properties"/>
+
+	<beans:bean id="clientSsl" class="timely.configuration.ClientSsl">
+		<beans:property name="trustStoreType" value="${trust.store.type}"/>
+		<beans:property name="trustStoreFile" value="${trust.store.file}"/>
+		<beans:property name="trustStorePassword" value="${trust.store.password}"/>
+		<beans:property name="keyStoreType" value="${key.store.type}"/>
+		<beans:property name="keyStoreFile" value="${key.store.file}"/>
+		<beans:property name="keyStorePassword" value="${key.store.password}"/>
 	</beans:bean>
 
-	<beans:bean id="timelyUserDetailsService" class="timely.auth.UserDetailsService">
-		<beans:property name="users">
-			<util:list>
-				<beans:bean class="timely.auth.TimelyUser">
-					<beans:constructor-arg name="subjectDn">
-						<beans:value>CN=example.com</beans:value>
-					</beans:constructor-arg>
-					<beans:constructor-arg name="auths">
-						<util:list>
-							<beans:value>D</beans:value>
-							<beans:value>E</beans:value>
-							<beans:value>F</beans:value>
-						</util:list>
-					</beans:constructor-arg>
-					<beans:constructor-arg name="roles">
-						<util:list>
-							<beans:value>G</beans:value>
-							<beans:value>H</beans:value>
-							<beans:value>I</beans:value>
-						</util:list>
-					</beans:constructor-arg>
-				</beans:bean>
-			</util:list>
-		</beans:property>
+	<beans:bean id="authorizationProperties" class="timely.configuration.AuthorizationProperties">
+		<beans:property name="authorizationUrl" value="${authorization.url}"/>
+		<beans:property name="publicCertificateType" value="${authorization.certificate.type}"/>
+		<beans:property name="publicCertificateFile" value="${authorization.certificate.file}"/>
 	</beans:bean>
-    
-    <beans:bean id="x509AuthorizationProvider" class="org.springframework.security.web.authentication.preauth.PreAuthenticatedAuthenticationProvider">
-    	<beans:property name="preAuthenticatedUserDetailsService" ref="timelyUserDetailsService" />
-    </beans:bean>
-    
-    <user-service id="usernamePasswordService">
-    	<user name="test" password="test1" authorities="A,B,C" />
-    </user-service>
+
+	<beans:bean id="remoteUserDetailsService" class="timely.auth.RemoteUserDetailsService">
+		<beans:constructor-arg ref="clientSsl"/>
+		<beans:constructor-arg ref="authorizationProperties"/>
+	</beans:bean>
+
+	<beans:bean id="x509AuthorizationProvider" class="org.springframework.security.web.authentication.preauth.PreAuthenticatedAuthenticationProvider">
+		<beans:property name="preAuthenticatedUserDetailsService" ref="remoteUserDetailsService" />
+	</beans:bean>
+
+	<user-service id="usernamePasswordService">
+		<user name="test" password="test1" authorities="A,B,C" />
+	</user-service>
 
 	<beans:bean id="noOpPasswordEncoder" class="org.springframework.security.crypto.password.NoOpPasswordEncoder"/>
 
@@ -53,7 +46,7 @@
 		<beans:property name="userDetailsService" ref="usernamePasswordService"/>
 		<beans:property name="passwordEncoder" ref="noOpPasswordEncoder"/>
 	</beans:bean>
-	    
+
 	<authentication-manager alias="authenticationManager">
 		<!-- X509 PreAuthenticated authorization provider -->
 		<authentication-provider ref="x509AuthorizationProvider"/>

balancer/conf/timely-balancer-template.yml

@@ -0,0 +1,136 @@
+timely-balancer:
+  zooKeeper:
+    servers: ${ZOOKEEPERS}
+    timeout: 30s
+  checkServerHealthInterval: 10000
+  serverFailuresBeforeDown: 6
+  serverSuccessesBeforeUp: 1
+  assignmentFile: /timely/balancer/assignments.csv
+  security:
+    session-max-age: 86400
+    cache-expiration-minutes: 60
+    cache-refresh-minutes: 5
+    allow-anonymous-http-access: true
+    allow-anonymous-ws-access: true
+    serverSsl:
+      key-store-type: ${KEY_STORE_TYPE}
+      key-store-file: ${KEY_STORE_FILE}
+      key-store-password: ${KEY_STORE_PASSWORD}
+      use-generated-keypair: ${GENERATE_KEYS}
+      ignore-ssl-handshake-errors: true
+      trust-store-type: ${TRUST_STORE_TYPE}
+      trust-store-file: ${TRUST_STORE_FILE}
+      trust-store-password: ${TRUST_STORE_PASSWORD}
+    clientSsl:
+      key-store-type: ${KEY_STORE_TYPE}
+      key-store-file: ${KEY_STORE_FILE}
+      key-store-password: ${KEY_STORE_PASSWORD}
+      trust-store-type: ${TRUST_STORE_TYPE}
+      trust-store-file: ${TRUST_STORE_FILE}
+      trust-store-password: ${TRUST_STORE_PASSWORD}
+    jwtSsl:
+      key-store-type: ${AUTHORIZATION_CERTIFICATE_TYPE}
+      key-store-file: ${AUTHORIZATION_CERTIFICATE_FILE}
+      key-store-password: ${AUTHORIZATION_CERTIFICATE_PASSWORD}
+  cache:
+    enabled: false
+    metric-age-off-hours:
+      default: 26
+    nonCachedMetrics:
+  server:
+    ip: ${HOST_IP}
+    tcpPort: ${TCP_PORT}
+    numTcpPools: 1
+    tcpBufferSize: 100
+    tcpClientPool:
+      minIdlePerKey: 0
+      maxIdlePerKey: 40
+      maxTotalPerKey: 40
+      maxTotal: -1
+      lifo: true
+      fairness: false
+      maxWaitMillis: -1
+      minEvictableIdleTimeMillis: 1800000
+      evictorShutdownTimeoutMillis: 10000
+      softMinEvictableIdleTimeMillis: -1
+      numTestsPerEvictionRun: 3
+      timeBetweenEvictionRunsMillis: -1
+      blockWhenExhausted: true
+      jmxEnabled: true
+      testOnBorrow: false
+      testOnReturn: false
+    udpPort: ${UDP_PORT}
+    udpClientPool:
+      minIdlePerKey: 0
+      maxIdlePerKey: 40
+      maxTotalPerKey: 40
+      maxTotal: -1
+      lifo: true
+      fairness: false
+      maxWaitMillis: -1
+      minEvictableIdleTimeMillis: 1800000
+      evictorShutdownTimeoutMillis: 10000
+      softMinEvictableIdleTimeMillis: -1
+      numTestsPerEvictionRun: 3
+      timeBetweenEvictionRunsMillis: -1
+      blockWhenExhausted: true
+      jmxEnabled: true
+      testOnBorrow: false
+      testOnReturn: false
+  http:
+    host: ${HOST}
+    ip: ${HOST_IP}
+    port: ${HTTP_PORT}
+    redirect-path: /secure-me
+    strict-transport-max-age: 608400
+    cors:
+      allow-any-origin: false
+      allow-null-origin: false
+      allow-credentials: true
+      allowed-origins:
+      allowed-methods: DELETE,GET,HEAD,OPTIONS,PUT,POST
+      allowed-headers: content-type
+    httpClientPool:
+      minIdlePerKey: 0
+      maxIdlePerKey: 40
+      maxTotalPerKey: 40
+      maxTotal: -1
+      lifo: true
+      fairness: false
+      maxWaitMillis: -1
+      minEvictableIdleTimeMillis: 1800000
+      evictorShutdownTimeoutMillis: 10000
+      softMinEvictableIdleTimeMillis: -1
+      numTestsPerEvictionRun: 3
+      timeBetweenEvictionRunsMillis: -1
+      blockWhenExhausted: true
+      jmxEnabled: true
+      testOnBorrow: false
+      testOnReturn: false
+  websocket:
+    ip: ${HOST_IP}
+    port: ${WEBSOCKET_PORT}
+    timeout: 60
+    subscription-lag: 120
+    scanner-batch-size: 10000
+    flush-interval-seconds: 30
+    scanner-read-ahead: 1
+    subscription-batch-size: 5000
+    incomingBufferSize: 50000000
+    wsClientPool:
+      minIdlePerKey: 0
+      maxIdlePerKey: 40
+      maxTotalPerKey: 40
+      maxTotal: -1
+      lifo: true
+      fairness: false
+      maxWaitMillis: -1
+      minEvictableIdleTimeMillis: 1800000
+      evictorShutdownTimeoutMillis: 10000
+      softMinEvictableIdleTimeMillis: -1
+      numTestsPerEvictionRun: 3
+      timeBetweenEvictionRunsMillis: -1
+      blockWhenExhausted: true
+      jmxEnabled: true
+      testOnBorrow: false
+      testOnReturn: false

balancer/conf/timely-balancer.yml

@@ -8,30 +8,37 @@ timely-balancer:
   assignmentFile: /timely/balancer/assignments.csv
   security:
     session-max-age: 86400
+    cache-expiration-minutes: 60
+    cache-refresh-minutes: 5
     allow-anonymous-http-access: true
     allow-anonymous-ws-access: true
     serverSsl:
-      certificate-file:
-      key-file:
-      #key-password:
+      key-store-type:
+      key-store-file:
+      key-store-password:
       use-generated-keypair: true
+      ignore-ssl-handshake-errors: true
+      trust-store-type:
       trust-store-file:
-      use-openssl: true
-      #use-ciphers:
+      trust-store-password:
     clientSsl:
-      keyFile:
-      keyType: pkcs12
-      #keyPassword:
-      trustStoreFile:
-      trustStoreType: jks
-      #trustStorePassword:
+      key-store-type:
+      key-store-file:
+      key-store-password:
+      trust-store-type:
+      trust-store-file:
+      trust-store-password:
+    jwtSsl:
+      key-store-type:
+      key-store-file:
+      key-store-password:
   cache:
     enabled: false
     metric-age-off-hours:
       default: 26
     nonCachedMetrics:
   server:
-    ip: 127.0.0.1
+    ip: 0.0.0.0
     tcpPort: 4242
     numTcpPools: 1
     tcpBufferSize: 100
@@ -72,7 +79,7 @@ timely-balancer:
       testOnReturn: false
   http:
     host: localhost
-    ip: 127.0.0.1
+    ip: 0.0.0.0
     port: 4243
     redirect-path: /secure-me
     strict-transport-max-age: 608400
@@ -101,7 +108,7 @@ timely-balancer:
       testOnBorrow: false
       testOnReturn: false
   websocket:
-    ip: 127.0.0.1
+    ip: 0.0.0.0
     port: 5244
     timeout: 60
     subscription-lag: 120
@@ -109,6 +116,7 @@ timely-balancer:
     flush-interval-seconds: 30
     scanner-read-ahead: 1
     subscription-batch-size: 5000
+    incomingBufferSize: 50000000
     wsClientPool:
       minIdlePerKey: 0
       maxIdlePerKey: 40

balancer/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>timely</groupId>
     <artifactId>timely</artifactId>
-    <version>1.2.1</version>
+    <version>2.0.2</version>
   </parent>
   <artifactId>timely-balancer</artifactId>
   <dependencies>
@@ -51,12 +51,6 @@
     <dependency>
       <groupId>org.apache.accumulo</groupId>
       <artifactId>accumulo-core</artifactId>
-      <exclusions>
-        <exclusion>
-          <groupId>org.slf4j</groupId>
-          <artifactId>slf4j-log4j12</artifactId>
-        </exclusion>
-      </exclusions>
     </dependency>
     <dependency>
       <groupId>org.apache.accumulo</groupId>
@@ -97,12 +91,6 @@
     <dependency>
       <groupId>org.apache.hadoop</groupId>
       <artifactId>hadoop-common</artifactId>
-      <exclusions>
-        <exclusion>
-          <groupId>jdk.tools</groupId>
-          <artifactId>jdk.tools</artifactId>
-        </exclusion>
-      </exclusions>
     </dependency>
     <dependency>
       <groupId>org.apache.hadoop</groupId>
@@ -119,12 +107,6 @@
     <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter</artifactId>
-      <exclusions>
-        <exclusion>
-          <groupId>org.springframework.boot</groupId>
-          <artifactId>spring-boot-starter-logging</artifactId>
-        </exclusion>
-      </exclusions>
     </dependency>
     <dependency>
       <groupId>org.springframework.boot</groupId>
@@ -161,9 +143,7 @@
     </dependency>
     <dependency>
       <groupId>io.netty</groupId>
-      <artifactId>netty-tcnative</artifactId>
-      <version>${version.netty-tcnative}</version>
-      <classifier>${os.detected.classifier}</classifier>
+      <artifactId>netty-tcnative-boringssl-static</artifactId>
       <scope>runtime</scope>
     </dependency>
     <dependency>
@@ -247,9 +227,8 @@
               <artifactItems>
                 <artifactItem>
                   <groupId>io.netty</groupId>
-                  <artifactId>netty-tcnative</artifactId>
+                  <artifactId>netty-tcnative-boringssl-static</artifactId>
                   <version>${version.netty-tcnative}</version>
-                  <classifier>${os.detected.classifier}</classifier>
                   <type>jar</type>
                   <overWrite>false</overWrite>
                   <outputDirectory>${project.build.directory}/native</outputDirectory>
@@ -291,37 +270,4 @@
       </extension>
     </extensions>
   </build>
-  <profiles>
-    <profile>
-      <id>native-epoll-linux</id>
-      <activation>
-        <os>
-          <family>!mac</family>
-        </os>
-      </activation>
-      <dependencies>
-        <dependency>
-          <groupId>io.netty</groupId>
-          <artifactId>netty-transport-native-epoll</artifactId>
-          <version>${version.netty}</version>
-          <classifier>linux-x86_64</classifier>
-        </dependency>
-      </dependencies>
-    </profile>
-    <profile>
-      <id>native-epoll</id>
-      <activation>
-        <os>
-          <family>mac</family>
-        </os>
-      </activation>
-      <dependencies>
-        <dependency>
-          <groupId>io.netty</groupId>
-          <artifactId>netty-transport-native-epoll</artifactId>
-          <version>${version.netty}</version>
-        </dependency>
-      </dependencies>
-    </profile>
-  </profiles>
 </project>

balancer/src/main/java/timely/balancer/ArrivalRate.java

@@ -1,7 +1,7 @@
 package timely.balancer;
 
-import java.util.Timer;
-import java.util.TimerTask;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicLong;
 
 import com.google.common.util.concurrent.AtomicDouble;
@@ -20,38 +20,26 @@ public class ArrivalRate {
     private AtomicDouble longTermRate = new AtomicDouble(0);
     private AtomicLong longTermLastReset = new AtomicLong(0);
 
-    public ArrivalRate(Timer timer) {
+    public ArrivalRate(ScheduledExecutorService arrivalRateExecutor) {
         long now = System.currentTimeMillis();
         shortTermLastReset.set(now);
         mediumTermLastReset.set(now);
         longTermLastReset.set(now);
 
         // 2 minute
-        timer.schedule(new TimerTask() {
-
-            @Override
-            public void run() {
-                resetShort();
-            }
-        }, 120000, 120000);
+        arrivalRateExecutor.scheduleAtFixedRate(() -> {
+            resetShort();
+        }, 2, 2, TimeUnit.MINUTES);
 
         // 5 minute
-        timer.schedule(new TimerTask() {
-
-            @Override
-            public void run() {
-                resetMedium();
-            }
-        }, 300000, 300000);
+        arrivalRateExecutor.scheduleAtFixedRate(() -> {
+            resetMedium();
+        }, 5, 5, TimeUnit.MINUTES);
 
         // 15 minute
-        timer.schedule(new TimerTask() {
-
-            @Override
-            public void run() {
-                resetLong();
-            }
-        }, 900000, 900000);
+        arrivalRateExecutor.scheduleAtFixedRate(() -> {
+            resetLong();
+        }, 15, 15, TimeUnit.MINUTES);
     }
 
     private void resetShort() {

balancer/src/main/java/timely/balancer/Balancer.java

@@ -1,10 +1,10 @@
 package timely.balancer;
 
+import static org.apache.accumulo.core.conf.ConfigurationTypeHelper.getTimeInMillis;
 import static timely.Server.SERVICE_DISCOVERY_PATH;
 import static timely.store.cache.DataStoreCache.NON_CACHED_METRICS;
 import static timely.store.cache.DataStoreCache.NON_CACHED_METRICS_LOCK_PATH;
 
-import java.io.File;
 import java.net.InetSocketAddress;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
@@ -16,6 +16,18 @@ import java.util.concurrent.TimeUnit;
 
 import javax.net.ssl.SSLContext;
 
+import org.apache.curator.RetryPolicy;
+import org.apache.curator.framework.CuratorFramework;
+import org.apache.curator.framework.CuratorFrameworkFactory;
+import org.apache.curator.retry.RetryForever;
+import org.apache.zookeeper.CreateMode;
+import org.apache.zookeeper.data.Stat;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.WebApplicationType;
+import org.springframework.boot.builder.SpringApplicationBuilder;
+import org.springframework.context.ConfigurableApplicationContext;
+
 import io.netty.bootstrap.Bootstrap;
 import io.netty.bootstrap.ServerBootstrap;
 import io.netty.buffer.PooledByteBufAllocator;
@@ -25,6 +37,7 @@ import io.netty.channel.ChannelHandler;
 import io.netty.channel.ChannelInitializer;
 import io.netty.channel.ChannelOption;
 import io.netty.channel.EventLoopGroup;
+import io.netty.channel.WriteBufferWaterMark;
 import io.netty.channel.epoll.EpollChannelOption;
 import io.netty.channel.epoll.EpollDatagramChannel;
 import io.netty.channel.epoll.EpollEventLoopGroup;
@@ -50,26 +63,15 @@ import io.netty.handler.ssl.OpenSslServerContext;
 import io.netty.handler.ssl.OpenSslServerSessionContext;
 import io.netty.handler.ssl.SslContext;
 import io.netty.handler.ssl.SslContextBuilder;
-import io.netty.handler.ssl.SslProvider;
 import io.netty.handler.ssl.util.SelfSignedCertificate;
 import io.netty.handler.stream.ChunkedWriteHandler;
 import io.netty.handler.timeout.IdleStateHandler;
 import io.netty.util.NettyRuntime;
 import io.netty.util.internal.SystemPropertyUtil;
-import org.apache.curator.RetryPolicy;
-import org.apache.curator.framework.CuratorFramework;
-import org.apache.curator.framework.CuratorFrameworkFactory;
-import org.apache.curator.retry.RetryForever;
-import org.apache.zookeeper.CreateMode;
-import org.apache.zookeeper.data.Stat;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.boot.WebApplicationType;
-import org.springframework.boot.builder.SpringApplicationBuilder;
-import org.springframework.context.ConfigurableApplicationContext;
 import timely.auth.AuthCache;
+import timely.auth.JWTTokenHandler;
+import timely.auth.util.SslHelper;
 import timely.balancer.configuration.BalancerConfiguration;
-import timely.balancer.configuration.ClientSsl;
 import timely.balancer.configuration.SpringBootstrap;
 import timely.balancer.connection.http.HttpClientPool;
 import timely.balancer.connection.tcp.TcpClientPool;
@@ -83,6 +85,7 @@ import timely.balancer.netty.ws.WsRelayHandler;
 import timely.balancer.resolver.BalancedMetricResolver;
 import timely.balancer.resolver.MetricResolver;
 import timely.client.http.HttpClient;
+import timely.configuration.ClientSsl;
 import timely.configuration.ServerSsl;
 import timely.netty.http.HttpStaticFileServerHandler;
 import timely.netty.http.NonSslRedirectHandler;
@@ -131,20 +134,22 @@ public class Balancer {
     protected volatile boolean shutdown = false;
     private static final int DEFAULT_EVENT_LOOP_THREADS;
 
-    private String[] zkPaths = new String[] { LEADER_LATCH_PATH, ASSIGNMENTS_LAST_UPDATED_PATH, ASSIGNMENTS_LOCK_PATH,
-            SERVICE_DISCOVERY_PATH, NON_CACHED_METRICS, NON_CACHED_METRICS_LOCK_PATH };
+    private String[] zkPaths = new String[] {LEADER_LATCH_PATH, ASSIGNMENTS_LAST_UPDATED_PATH, ASSIGNMENTS_LOCK_PATH, SERVICE_DISCOVERY_PATH,
+            NON_CACHED_METRICS, NON_CACHED_METRICS_LOCK_PATH};
 
     static {
-        DEFAULT_EVENT_LOOP_THREADS = Math.max(1,
-                SystemPropertyUtil.getInt("io.netty.eventLoopThreads", NettyRuntime.availableProcessors() * 2));
+        DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt("io.netty.eventLoopThreads", NettyRuntime.availableProcessors() * 2));
     }
 
     public Balancer(BalancerConfiguration balancerConf) throws Exception {
         this.balancerConfig = balancerConf;
     }
 
-    protected static ConfigurableApplicationContext initializeConfiguration(String[] args) {
-        return new SpringApplicationBuilder(SpringBootstrap.class).web(WebApplicationType.NONE).run(args);
+    protected static ConfigurableApplicationContext initializeContext(String[] args) {
+        SpringApplicationBuilder builder = new SpringApplicationBuilder(SpringBootstrap.class);
+        builder.web(WebApplicationType.NONE);
+        builder.registerShutdownHook(false);
+        return builder.run(args);
     }
 
     private void shutdownHook() {
@@ -176,8 +181,9 @@ public class Balancer {
             channelFutures.add(wsChannelHandle.close());
         }
 
+        int udpChannel = 1;
         for (Channel c : udpChannelHandleList) {
-            LOG.info("Closing udpChannelHandle");
+            LOG.info("Closing udpChannelHandle #" + udpChannel++);
             channelFutures.add(c.close());
         }
 
@@ -186,14 +192,13 @@ public class Balancer {
             try {
                 f.get();
             } catch (final Exception e) {
-                LOG.error("Error while shutting down channel: {}", f.channel().config());
-                LOG.error("{}", e.getMessage());
-                e.printStackTrace();
+                LOG.error("Channel:" + f.channel().config() + " -> " + e.getMessage(), e);
             }
         });
 
-        Integer quietPeriod = balancerConfig.getServer().getShutdownQuietPeriod();
+        int quietPeriod = balancerConfig.getServer().getShutdownQuietPeriod();
         List<Future<?>> groupFutures = new ArrayList<>();
+
         if (tcpBossGroup != null) {
             LOG.info("Shutting down tcpBossGroup");
             groupFutures.add(tcpBossGroup.shutdownGracefully(quietPeriod, 10, TimeUnit.SECONDS));
@@ -238,9 +243,7 @@ public class Balancer {
             try {
                 f.get();
             } catch (final Exception e) {
-                LOG.error("Error while shutting down group: {}", f.toString());
-                LOG.error("{}", e.getMessage());
-                e.printStackTrace();
+                LOG.error("Group:" + f.toString() + " -> " + e.getMessage(), e);
             }
         });
 
@@ -251,14 +254,29 @@ public class Balancer {
             LOG.error("Error closing WebSocketRequestDecoder during shutdown", e);
         }
 
+        if (this.metricResolver != null) {
+            try {
+                LOG.info("Closing metricResolver");
+                this.metricResolver.close();
+            } catch (Exception e) {
+                LOG.error(e.getMessage(), e);
+            }
+        }
+
+        if (curatorFramework != null) {
+            try {
+                LOG.info("Closing curatorFramework");
+                curatorFramework.close();
+            } catch (Exception e) {
+                LOG.error(e.getMessage(), e);
+            }
+        }
+
         if (applicationContext != null) {
             LOG.info("Closing applicationContext");
             applicationContext.close();
         }
 
-        if (curatorFramework != null) {
-            curatorFramework.close();
-        }
         this.shutdown = true;
         LOG.info("Server shut down.");
     }
@@ -304,40 +322,21 @@ public class Balancer {
             SelfSignedCertificate ssc = new SelfSignedCertificate("localhost", begin, end);
             ssl = SslContextBuilder.forServer(ssc.certificate(), ssc.privateKey());
         } else {
-            String cert = sslCfg.getCertificateFile();
-            String key = sslCfg.getKeyFile();
-            String keyPass = sslCfg.getKeyPassword();
-            if (null == cert || null == key) {
+            if (null == sslCfg.getKeyStoreFile()) {
                 throw new IllegalArgumentException("Check your SSL properties, something is wrong.");
             }
-            ssl = SslContextBuilder.forServer(new File(cert), new File(key), keyPass);
+            ssl = SslHelper.getSslContextBuilder(sslCfg);
         }
-
-        ssl.ciphers(sslCfg.getUseCiphers());
-
         // Can't set to REQUIRE because the CORS pre-flight requests will fail.
         ssl.clientAuth(ClientAuth.OPTIONAL);
-
-        Boolean useOpenSSL = sslCfg.isUseOpenssl();
-        if (useOpenSSL) {
-            ssl.sslProvider(SslProvider.OPENSSL);
-        } else {
-            ssl.sslProvider(SslProvider.JDK);
-        }
-        String trustStore = sslCfg.getTrustStoreFile();
-        if (null != trustStore) {
-            if (!trustStore.isEmpty()) {
-                ssl.trustManager(new File(trustStore));
-            }
-        }
         return ssl.build();
     }
 
     protected SSLContext createSSLClientContext(BalancerConfiguration config) throws Exception {
 
         ClientSsl ssl = config.getSecurity().getClientSsl();
-        return HttpClient.getSSLContext(ssl.getTrustStoreFile(), ssl.getTrustStoreType(), ssl.getTrustStorePassword(),
-                ssl.getKeyFile(), ssl.getKeyType(), ssl.getKeyPassword());
+        return HttpClient.getSSLContext(ssl.getTrustStoreFile(), ssl.getTrustStoreType(), ssl.getTrustStorePassword(), ssl.getKeyStoreFile(),
+                        ssl.getKeyStoreType(), ssl.getKeyStorePassword());
     }
 
     private void ensureZkPaths(CuratorFramework curatorFramework, String[] paths) {
@@ -345,8 +344,7 @@ public class Balancer {
             try {
                 Stat stat = curatorFramework.checkExists().forPath(s);
                 if (stat == null) {
-                    curatorFramework.create().creatingParentContainersIfNeeded().withMode(CreateMode.PERSISTENT)
-                            .forPath(s);
+                    curatorFramework.create().creatingParentContainersIfNeeded().withMode(CreateMode.PERSISTENT).forPath(s);
                 }
             } catch (Exception e) {
                 LOG.info(e.getMessage());
@@ -359,12 +357,13 @@ public class Balancer {
 
         // start curator framework
         RetryPolicy retryPolicy = new RetryForever(1000);
-        curatorFramework = CuratorFrameworkFactory.newClient(balancerConfig.getZooKeeper().getServers(), 30000, 1000,
-                retryPolicy);
+        int timeout = Long.valueOf(getTimeInMillis(balancerConfig.getZooKeeper().getTimeout())).intValue();
+        curatorFramework = CuratorFrameworkFactory.newClient(balancerConfig.getZooKeeper().getServers(), timeout, 10000, retryPolicy);
         curatorFramework.start();
         ensureZkPaths(curatorFramework, zkPaths);
 
-        AuthCache.setSessionMaxAge(balancerConfig.getSecurity());
+        AuthCache.configure(balancerConfig.getSecurity());
+        JWTTokenHandler.init(balancerConfig.getSecurity().getJwtSsl(), null);
         final boolean useEpoll = useEpoll();
         Class<? extends ServerSocketChannel> channelClass;
         Class<? extends Channel> datagramChannelClass;
@@ -430,8 +429,7 @@ public class Balancer {
         httpServer.group(httpBossGroup, httpWorkerGroup);
         httpServer.channel(channelClass);
         httpServer.handler(new LoggingHandler());
-        HttpClientPool httpClientPool = new HttpClientPool(balancerConfig.getSecurity(), balancerConfig.getHttp(),
-                clientSSLContext);
+        HttpClientPool httpClientPool = new HttpClientPool(balancerConfig.getSecurity(), balancerConfig.getHttp(), clientSSLContext);
         httpServer.childHandler(setupHttpChannel(balancerConfig, sslCtx, metricResolver, httpClientPool));
         httpServer.option(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT);
         httpServer.option(ChannelOption.SO_BACKLOG, 128);
@@ -450,10 +448,9 @@ public class Balancer {
         wsServer.option(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT);
         wsServer.option(ChannelOption.SO_BACKLOG, 128);
         wsServer.option(ChannelOption.SO_KEEPALIVE, true);
-        /* Not sure if next three lines are necessary */
+        /* Not sure if next two lines are necessary */
         wsServer.option(ChannelOption.SO_SNDBUF, 1048576);
-        wsServer.option(ChannelOption.WRITE_BUFFER_HIGH_WATER_MARK, 838860);
-        wsServer.option(ChannelOption.WRITE_BUFFER_LOW_WATER_MARK, 620145);
+        wsServer.option(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(620145, 838860));
         wsChannelHandle = wsServer.bind(wsIp, wsPort).sync().channel();
         final String wsAddress = ((InetSocketAddress) wsChannelHandle.localAddress()).getAddress().getHostAddress();
 
@@ -471,19 +468,18 @@ public class Balancer {
             udpChannelHandleList.add(udpServer.bind(udpIp, udpPort).sync().channel());
         }
         shutdownHook();
-        LOG.info(
-                "Server started. Listening on {}:{} for TCP traffic, {}:{} for HTTP traffic, {}:{} for WebSocket traffic, and {}:{} for UDP traffic",
-                tcpAddress, tcpPort, httpAddress, httpPort, wsAddress, wsPort, wsAddress, udpPort);
+        LOG.info("Server started. Listening on {}:{} for TCP traffic, {}:{} for HTTP traffic, {}:{} for WebSocket traffic, and {}:{} for UDP traffic",
+                        tcpAddress, tcpPort, httpAddress, httpPort, wsAddress, wsPort, wsAddress, udpPort);
     }
 
     public static void main(String[] args) throws Exception {
 
-        Balancer.applicationContext = Balancer.initializeConfiguration(args);
-        BalancerConfiguration balancerConf = applicationContext.getBean(BalancerConfiguration.class);
+        Balancer.applicationContext = Balancer.initializeContext(args);
+        BalancerConfiguration balancerConf = Balancer.applicationContext.getBean(BalancerConfiguration.class);
 
-        Balancer b = new Balancer(balancerConf);
+        Balancer balancer = new Balancer(balancerConf);
         try {
-            b.run();
+            balancer.run();
             LATCH.await();
         } catch (final InterruptedException e) {
             LOG.info("Server shutting down.");
@@ -491,15 +487,15 @@ public class Balancer {
             LOG.error("Error running server.", e);
         } finally {
             try {
-                b.shutdown();
+                balancer.shutdown();
             } catch (Exception e) {
                 System.exit(1);
             }
         }
     }
 
-    protected ChannelHandler setupHttpChannel(BalancerConfiguration balancerConfig, SslContext sslCtx,
-            MetricResolver metricResolver, HttpClientPool httpClientPool) {
+    protected ChannelHandler setupHttpChannel(BalancerConfiguration balancerConfig, SslContext sslCtx, MetricResolver metricResolver,
+                    HttpClientPool httpClientPool) {
 
         return new ChannelInitializer<SocketChannel>() {
 
@@ -508,18 +504,18 @@ public class Balancer {
 
                 ch.pipeline().addLast("ssl", new NonSslRedirectHandler(balancerConfig.getHttp(), sslCtx));
                 ch.pipeline().addLast("encoder", new HttpResponseEncoder());
-                ch.pipeline().addLast("decoder", new HttpRequestDecoder());
+                ch.pipeline().addLast("decoder", new HttpRequestDecoder(4096, 32768, 8192, true, 128));
                 ch.pipeline().addLast("compressor", new HttpContentCompressor());
                 ch.pipeline().addLast("decompressor", new HttpContentDecompressor());
                 ch.pipeline().addLast("aggregator", new HttpObjectAggregator(65536));
                 ch.pipeline().addLast("chunker", new ChunkedWriteHandler());
-                ch.pipeline().addLast("queryDecoder", new timely.netty.http.HttpRequestDecoder(
-                        balancerConfig.getSecurity(), balancerConfig.getHttp()));
-                ch.pipeline().addLast("fileServer", new HttpStaticFileServerHandler());
-                ch.pipeline().addLast("login",
-                        new X509LoginRequestHandler(balancerConfig.getSecurity(), balancerConfig.getHttp()));
+                ch.pipeline().addLast("queryDecoder", new timely.netty.http.HttpRequestDecoder(balancerConfig.getSecurity(), balancerConfig.getHttp()));
+                ch.pipeline().addLast("fileServer", new HttpStaticFileServerHandler()
+                                .setIgnoreSslHandshakeErrors(balancerConfig.getSecurity().getServerSsl().isIgnoreSslHandshakeErrors()));
+                ch.pipeline().addLast("login", new X509LoginRequestHandler(balancerConfig.getSecurity(), balancerConfig.getHttp()));
                 ch.pipeline().addLast("httpRelay", new HttpRelayHandler(metricResolver, httpClientPool));
-                ch.pipeline().addLast("error", new TimelyExceptionHandler());
+                ch.pipeline().addLast("error", new TimelyExceptionHandler()
+                                .setIgnoreSslHandshakeErrors(balancerConfig.getSecurity().getServerSsl().isIgnoreSslHandshakeErrors()));
             }
         };
     }
@@ -553,8 +549,7 @@ public class Balancer {
         };
     }
 
-    protected ChannelHandler setupWSChannel(BalancerConfiguration balancerConfig, SslContext sslCtx,
-            MetricResolver metricResolver, WsClientPool wsClientPool) {
+    protected ChannelHandler setupWSChannel(BalancerConfiguration balancerConfig, SslContext sslCtx, MetricResolver metricResolver, WsClientPool wsClientPool) {
         return new ChannelInitializer<SocketChannel>() {
 
             @Override
@@ -564,10 +559,8 @@ public class Balancer {
                 ch.pipeline().addLast("aggregator", new HttpObjectAggregator(65536));
                 ch.pipeline().addLast("sessionExtractor", new WebSocketFullRequestHandler());
 
-                ch.pipeline().addLast("idle-handler",
-                        new IdleStateHandler(balancerConfig.getWebsocket().getTimeout(), 0, 0));
-                ch.pipeline().addLast("ws-protocol",
-                        new WebSocketServerProtocolHandler(WS_PATH, null, true, 65536, true));
+                ch.pipeline().addLast("idle-handler", new IdleStateHandler(balancerConfig.getWebsocket().getTimeout(), 0, 0));
+                ch.pipeline().addLast("ws-protocol", new WebSocketServerProtocolHandler(WS_PATH, null, true, 65536, false, true));
                 ch.pipeline().addLast("wsDecoder", new WebSocketRequestDecoder(balancerConfig.getSecurity()));
                 ch.pipeline().addLast("httpRelay", new WsRelayHandler(balancerConfig, metricResolver, wsClientPool));
                 ch.pipeline().addLast("error", new WSTimelyExceptionHandler());

balancer/src/main/java/timely/balancer/configuration/BalancerConfiguration.java

@@ -6,6 +6,7 @@ import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.boot.context.properties.NestedConfigurationProperty;
 import org.springframework.stereotype.Component;
 import org.springframework.validation.annotation.Validated;
+
 import timely.configuration.Cache;
 
 @Validated

balancer/src/main/java/timely/balancer/configuration/BalancerHttp.java

@@ -3,16 +3,18 @@ package timely.balancer.configuration;
 import javax.validation.Valid;
 
 import org.apache.commons.pool2.impl.GenericKeyedObjectPoolConfig;
+import org.apache.http.impl.client.CloseableHttpClient;
 import org.springframework.boot.context.properties.NestedConfigurationProperty;
+
 import timely.configuration.Http;
 
 public class BalancerHttp extends Http {
 
     @Valid
     @NestedConfigurationProperty
-    private GenericKeyedObjectPoolConfig httpClientPool = new GenericKeyedObjectPoolConfig();
+    private GenericKeyedObjectPoolConfig<CloseableHttpClient> httpClientPool = new GenericKeyedObjectPoolConfig<>();
 
-    public GenericKeyedObjectPoolConfig getHttpClientPool() {
+    public GenericKeyedObjectPoolConfig<CloseableHttpClient> getHttpClientPool() {
         return httpClientPool;
     }
 }

balancer/src/main/java/timely/balancer/configuration/BalancerSecurity.java

@@ -3,6 +3,8 @@ package timely.balancer.configuration;
 import javax.validation.Valid;
 
 import org.springframework.boot.context.properties.NestedConfigurationProperty;
+
+import timely.configuration.ClientSsl;
 import timely.configuration.Security;
 
 public class BalancerSecurity extends Security {

balancer/src/main/java/timely/balancer/configuration/BalancerServer.java

@@ -4,27 +4,30 @@ import javax.validation.Valid;
 
 import org.apache.commons.pool2.impl.GenericKeyedObjectPoolConfig;
 import org.springframework.boot.context.properties.NestedConfigurationProperty;
+
+import timely.client.tcp.TcpClient;
+import timely.client.udp.UdpClient;
 import timely.configuration.Server;
 
 public class BalancerServer extends Server {
 
     @Valid
     @NestedConfigurationProperty
-    private GenericKeyedObjectPoolConfig udpClientPool = new GenericKeyedObjectPoolConfig();
+    private GenericKeyedObjectPoolConfig<UdpClient> udpClientPool = new GenericKeyedObjectPoolConfig<>();
 
     @Valid
     @NestedConfigurationProperty
-    private GenericKeyedObjectPoolConfig tcpClientPool = new GenericKeyedObjectPoolConfig();
+    private GenericKeyedObjectPoolConfig<TcpClient> tcpClientPool = new GenericKeyedObjectPoolConfig<>();
 
     private int numTcpPools = 1;
 
     private int tcpBufferSize = -1;
 
-    public GenericKeyedObjectPoolConfig getUdpClientPool() {
+    public GenericKeyedObjectPoolConfig<UdpClient> getUdpClientPool() {
         return udpClientPool;
     }
 
-    public GenericKeyedObjectPoolConfig getTcpClientPool() {
+    public GenericKeyedObjectPoolConfig<TcpClient> getTcpClientPool() {
         return tcpClientPool;
     }
 

balancer/src/main/java/timely/balancer/configuration/BalancerWebsocket.java

@@ -4,15 +4,27 @@ import javax.validation.Valid;
 
 import org.apache.commons.pool2.impl.GenericKeyedObjectPoolConfig;
 import org.springframework.boot.context.properties.NestedConfigurationProperty;
+
+import timely.client.websocket.subscription.WebSocketSubscriptionClient;
 import timely.configuration.Websocket;
 
 public class BalancerWebsocket extends Websocket {
 
     @Valid
     @NestedConfigurationProperty
-    private GenericKeyedObjectPoolConfig wsClientPool = new GenericKeyedObjectPoolConfig();
+    private GenericKeyedObjectPoolConfig<WebSocketSubscriptionClient> wsClientPool = new GenericKeyedObjectPoolConfig<>();
 
-    public GenericKeyedObjectPoolConfig getWsClientPool() {
+    public GenericKeyedObjectPoolConfig<WebSocketSubscriptionClient> getWsClientPool() {
         return wsClientPool;
     }
+
+    public int incomingBufferSize = 50000000;
+
+    public int getIncomingBufferSize() {
+        return incomingBufferSize;
+    }
+
+    public void setIncomingBufferSize(int incomingBufferSize) {
+        this.incomingBufferSize = incomingBufferSize;
+    }
 }

balancer/src/main/java/timely/balancer/configuration/ClientSsl.java

@@ -1,77 +0,0 @@
-package timely.balancer.configuration;
-
-public class ClientSsl {
-
-    private String keyFile;
-    private String keyType;
-    private String keyPassword;
-    private String trustStoreFile;
-    private String trustStoreType;
-    private String trustStorePassword;
-    private boolean useClientCert = true;
-    private boolean hostVerificationEnabled = true;
-
-    public String getKeyFile() {
-        return keyFile;
-    }
-
-    public void setKeyFile(String keyFile) {
-        this.keyFile = keyFile;
-    }
-
-    public String getKeyType() {
-        return keyType;
-    }
-
-    public void setKeyType(String keyType) {
-        this.keyType = keyType;
-    }
-
-    public String getKeyPassword() {
-        return keyPassword;
-    }
-
-    public void setKeyPassword(String keyPassword) {
-        this.keyPassword = keyPassword;
-    }
-
-    public String getTrustStoreFile() {
-        return trustStoreFile;
-    }
-
-    public void setTrustStoreFile(String trustStoreFile) {
-        this.trustStoreFile = trustStoreFile;
-    }
-
-    public String getTrustStoreType() {
-        return trustStoreType;
-    }
-
-    public void setTrustStoreType(String trustStoreType) {
-        this.trustStoreType = trustStoreType;
-    }
-
-    public String getTrustStorePassword() {
-        return trustStorePassword;
-    }
-
-    public void setTrustStorePassword(String trustStorePassword) {
-        this.trustStorePassword = trustStorePassword;
-    }
-
-    public void setUseClientCert(boolean useClientCert) {
-        this.useClientCert = useClientCert;
-    }
-
-    public boolean isUseClientCert() {
-        return useClientCert;
-    }
-
-    public void setHostVerificationEnabled(boolean hostVerificationEnabled) {
-        this.hostVerificationEnabled = hostVerificationEnabled;
-    }
-
-    public boolean isHostVerificationEnabled() {
-        return hostVerificationEnabled;
-    }
-}

balancer/src/main/java/timely/balancer/configuration/SpringBootstrap.java

@@ -2,6 +2,5 @@ package timely.balancer.configuration;
 
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 
-@SpringBootApplication(scanBasePackageClasses = { SpringBootstrap.class })
-public class SpringBootstrap {
-}
+@SpringBootApplication(scanBasePackageClasses = {SpringBootstrap.class})
+public class SpringBootstrap {}

balancer/src/main/java/timely/balancer/configuration/ZooKeeper.java

@@ -1,9 +1,14 @@
 package timely.balancer.configuration;
 
+import javax.validation.constraints.NotBlank;
+
 public class ZooKeeper {
 
     private String servers;
 
+    @NotBlank
+    private String timeout = "120s";
+
     public String getServers() {
         return servers;
     }
@@ -11,4 +16,12 @@ public class ZooKeeper {
     public void setServers(String servers) {
         this.servers = servers;
     }
+
+    public String getTimeout() {
+        return timeout;
+    }
+
+    public void setTimeout(String timeout) {
+        this.timeout = timeout;
+    }
 }

balancer/src/main/java/timely/balancer/connection/TimelyBalancedHost.java

@@ -1,19 +1,17 @@
 package timely.balancer.connection;
 
-import java.util.Timer;
-
 import org.apache.commons.lang3.builder.EqualsBuilder;
 import org.apache.commons.lang3.builder.HashCodeBuilder;
 import org.apache.commons.lang3.builder.ToStringBuilder;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+
 import timely.balancer.ArrivalRate;
 import timely.balancer.configuration.BalancerConfiguration;
 
 public class TimelyBalancedHost {
 
     private static final Logger LOG = LoggerFactory.getLogger(TimelyBalancedHost.class);
-    static private Timer arrivalRateTimer = new Timer("ArrivalRateTimerTBH", true);
 
     private String host;
     private int tcpPort;
@@ -24,34 +22,23 @@ public class TimelyBalancedHost {
     private BalancerConfiguration balancerConfig;
     private int failures = 0;
     private int successes = 0;
-    private ArrivalRate arrivalRate = new ArrivalRate(arrivalRateTimer);
+    private ArrivalRate arrivalRate = null;
 
-    public TimelyBalancedHost() {
+    private TimelyBalancedHost() {
 
     }
 
-    public TimelyBalancedHost(String host, int tcpPort, int httpPort, int wsPort, int udpPort) {
+    private TimelyBalancedHost(String host, int tcpPort, int httpPort, int wsPort, int udpPort, ArrivalRate arrivalRate) {
         this.host = host;
         this.tcpPort = tcpPort;
         this.httpPort = httpPort;
         this.wsPort = wsPort;
         this.udpPort = udpPort;
+        this.arrivalRate = arrivalRate;
     }
 
-    public TimelyBalancedHost(String host, int basePort) {
-        this.host = host;
-        this.tcpPort = basePort;
-        this.httpPort = basePort + 1;
-        this.wsPort = basePort + 2;
-        this.udpPort = basePort + 3;
-    }
-
-    static public TimelyBalancedHost of(String host, int tcpPort, int httpPort, int wsPort, int udpPort) {
-        return new TimelyBalancedHost(host, tcpPort, httpPort, wsPort, udpPort);
-    }
-
-    static public TimelyBalancedHost of(String host, int basePort) {
-        return new TimelyBalancedHost(host, basePort);
+    static public TimelyBalancedHost of(String host, int tcpPort, int httpPort, int wsPort, int udpPort, ArrivalRate arrivalRate) {
+        return new TimelyBalancedHost(host, tcpPort, httpPort, wsPort, udpPort, arrivalRate);
     }
 
     public void setBalancerConfig(BalancerConfiguration balancerConfig) {
@@ -68,8 +55,8 @@ public class TimelyBalancedHost {
         int p = tcpPort;
         synchronized (this) {
             if (LOG.isTraceEnabled()) {
-                LOG.trace("success reported host:{} port:{} isUp:{} successes:{} serverSuccessesBeforeUp:{}", h, p,
-                        isUp, (successes + 1), serverSuccessesBeforeUp);
+                LOG.trace("success reported host:{} port:{} isUp:{} successes:{} serverSuccessesBeforeUp:{}", h, p, isUp, (successes + 1),
+                                serverSuccessesBeforeUp);
             }
             if (!isUp) {
                 if (++successes >= serverSuccessesBeforeUp) {
@@ -87,8 +74,8 @@ public class TimelyBalancedHost {
         int p = tcpPort;
         synchronized (this) {
             if (LOG.isTraceEnabled()) {
-                LOG.trace("failure reported host:{} port:{} isUp:{} failures:{} serverFailuresBeforeUp:{}", h, p, isUp,
-                        (failures + 1), serverFailuresBeforeDown);
+                LOG.trace("failure reported host:{} port:{} isUp:{} failures:{} serverFailuresBeforeUp:{}", h, p, isUp, (failures + 1),
+                                serverFailuresBeforeDown);
             }
             if (isUp) {
                 if (++failures >= serverFailuresBeforeDown) {
@@ -141,11 +128,17 @@ public class TimelyBalancedHost {
     }
 
     public void arrived() {
-        arrivalRate.arrived();
+        if (this.arrivalRate != null) {
+            this.arrivalRate.arrived();
+        }
     }
 
     public double getArrivalRate() {
-        return arrivalRate.getRate();
+        if (this.arrivalRate == null) {
+            return 0;
+        } else {
+            return this.arrivalRate.getRate();
+        }
     }
 
     @Override

balancer/src/main/java/timely/balancer/connection/http/HttpClientFactory.java

@@ -6,10 +6,11 @@ import org.apache.commons.pool2.KeyedPooledObjectFactory;
 import org.apache.commons.pool2.PooledObject;
 import org.apache.commons.pool2.impl.DefaultPooledObject;
 import org.apache.http.impl.client.CloseableHttpClient;
+
 import timely.balancer.configuration.BalancerSecurity;
 import timely.balancer.connection.TimelyBalancedHost;
 
-public class HttpClientFactory implements KeyedPooledObjectFactory<TimelyBalancedHost, CloseableHttpClient> {
+public class HttpClientFactory implements KeyedPooledObjectFactory<TimelyBalancedHost,CloseableHttpClient> {
 
     private final SSLContext sslContext;
     private final BalancerSecurity security;
@@ -22,8 +23,8 @@ public class HttpClientFactory implements KeyedPooledObjectFactory<TimelyBalance
     @Override
     public PooledObject<CloseableHttpClient> makeObject(TimelyBalancedHost k) throws Exception {
         // disable cookie management because we are sharing connections
-        return new DefaultPooledObject<>(timely.client.http.HttpClient.get(this.sslContext, null,
-                security.getClientSsl().isHostVerificationEnabled(), security.getClientSsl().isUseClientCert()));
+        return new DefaultPooledObject<>(timely.client.http.HttpClient.get(this.sslContext, null, security.getClientSsl().isHostVerificationEnabled(),
+                        security.getClientSsl().isUseClientCert()));
     }
 
     @Override

balancer/src/main/java/timely/balancer/connection/http/HttpClientPool.java

@@ -4,15 +4,12 @@ import javax.net.ssl.SSLContext;
 
 import org.apache.commons.pool2.impl.GenericKeyedObjectPool;
 import org.apache.http.impl.client.CloseableHttpClient;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+
 import timely.balancer.configuration.BalancerHttp;
 import timely.balancer.configuration.BalancerSecurity;
 import timely.balancer.connection.TimelyBalancedHost;
 
-public class HttpClientPool extends GenericKeyedObjectPool<TimelyBalancedHost, CloseableHttpClient> {
-
-    private static final Logger LOG = LoggerFactory.getLogger(HttpClientPool.class);
+public class HttpClientPool extends GenericKeyedObjectPool<TimelyBalancedHost,CloseableHttpClient> {
 
     public HttpClientPool(BalancerSecurity balancerSecurity, BalancerHttp http, SSLContext sslContext) {
         super(new HttpClientFactory(balancerSecurity, sslContext), http.getHttpClientPool());

balancer/src/main/java/timely/balancer/connection/tcp/TcpClientFactory.java

@@ -5,10 +5,11 @@ import java.io.IOException;
 import org.apache.commons.pool2.KeyedPooledObjectFactory;
 import org.apache.commons.pool2.PooledObject;
 import org.apache.commons.pool2.impl.DefaultPooledObject;
+
 import timely.balancer.connection.TimelyBalancedHost;
 import timely.client.tcp.TcpClient;
 
-public class TcpClientFactory implements KeyedPooledObjectFactory<TimelyBalancedHost, TcpClient> {
+public class TcpClientFactory implements KeyedPooledObjectFactory<TimelyBalancedHost,TcpClient> {
 
     private int bufferSize;
 

balancer/src/main/java/timely/balancer/connection/tcp/TcpClientPool.java

@@ -1,13 +1,14 @@
 package timely.balancer.connection.tcp;
 
 import org.apache.commons.pool2.impl.GenericKeyedObjectPool;
+
 import timely.balancer.configuration.BalancerConfiguration;
 import timely.balancer.connection.TimelyBalancedHost;
 import timely.client.tcp.TcpClient;
 
-public class TcpClientPool extends GenericKeyedObjectPool<TimelyBalancedHost, TcpClient> {
+public class TcpClientPool extends GenericKeyedObjectPool<TimelyBalancedHost,TcpClient> {
 
     public TcpClientPool(BalancerConfiguration config) {
         super(new TcpClientFactory(config.getServer().getTcpBufferSize()), config.getServer().getTcpClientPool());
     }
-}
+}

balancer/src/main/java/timely/balancer/connection/udp/UdpClientFactory.java

@@ -5,13 +5,13 @@ import java.io.IOException;
 import org.apache.commons.pool2.KeyedPooledObjectFactory;
 import org.apache.commons.pool2.PooledObject;
 import org.apache.commons.pool2.impl.DefaultPooledObject;
+
 import timely.balancer.connection.TimelyBalancedHost;
 import timely.client.udp.UdpClient;
 
-public class UdpClientFactory implements KeyedPooledObjectFactory<TimelyBalancedHost, UdpClient> {
+public class UdpClientFactory implements KeyedPooledObjectFactory<TimelyBalancedHost,UdpClient> {
 
-    public UdpClientFactory() {
-    }
+    public UdpClientFactory() {}
 
     @Override
     public PooledObject<UdpClient> makeObject(TimelyBalancedHost k) throws Exception {

balancer/src/main/java/timely/balancer/connection/udp/UdpClientPool.java

@@ -1,11 +1,12 @@
 package timely.balancer.connection.udp;
 
 import org.apache.commons.pool2.impl.GenericKeyedObjectPool;
+
 import timely.balancer.configuration.BalancerConfiguration;
 import timely.balancer.connection.TimelyBalancedHost;
 import timely.client.udp.UdpClient;
 
-public class UdpClientPool extends GenericKeyedObjectPool<TimelyBalancedHost, UdpClient> {
+public class UdpClientPool extends GenericKeyedObjectPool<TimelyBalancedHost,UdpClient> {
 
     public UdpClientPool(BalancerConfiguration config) {
         super(new UdpClientFactory(), config.getServer().getUdpClientPool());

balancer/src/main/java/timely/balancer/connection/ws/WsClientFactory.java

@@ -5,11 +5,12 @@ import javax.net.ssl.SSLContext;
 import org.apache.commons.pool2.KeyedPooledObjectFactory;
 import org.apache.commons.pool2.PooledObject;
 import org.apache.commons.pool2.impl.DefaultPooledObject;
+
 import timely.balancer.configuration.BalancerConfiguration;
 import timely.balancer.connection.TimelyBalancedHost;
 import timely.client.websocket.subscription.WebSocketSubscriptionClient;
 
-public class WsClientFactory implements KeyedPooledObjectFactory<TimelyBalancedHost, WebSocketSubscriptionClient> {
+public class WsClientFactory implements KeyedPooledObjectFactory<TimelyBalancedHost,WebSocketSubscriptionClient> {
 
     private final SSLContext sslContext;
     private BalancerConfiguration balancerConfig;
@@ -22,11 +23,10 @@ public class WsClientFactory implements KeyedPooledObjectFactory<TimelyBalancedH
     @Override
     public PooledObject<WebSocketSubscriptionClient> makeObject(TimelyBalancedHost k) throws Exception {
 
-        int bufferSize = balancerConfig.getWebsocket().getSubscriptionBatchSize() * 500;
-        WebSocketSubscriptionClient client = new WebSocketSubscriptionClient(sslContext, k.getHost(), k.getHttpPort(),
-                k.getWsPort(), balancerConfig.getSecurity().getClientSsl().isUseClientCert(),
-                balancerConfig.isLoginRequired(), "", "",
-                balancerConfig.getSecurity().getClientSsl().isHostVerificationEnabled(), bufferSize);
+        int bufferSize = balancerConfig.getWebsocket().getIncomingBufferSize();
+        WebSocketSubscriptionClient client = new WebSocketSubscriptionClient(sslContext, k.getHost(), k.getHttpPort(), k.getWsPort(),
+                        balancerConfig.getSecurity().getClientSsl().isUseClientCert(), balancerConfig.isLoginRequired(), "", "",
+                        balancerConfig.getSecurity().getClientSsl().isHostVerificationEnabled(), bufferSize);
         return new DefaultPooledObject<>(client);
     }
 

balancer/src/main/java/timely/balancer/connection/ws/WsClientPool.java

@@ -3,11 +3,12 @@ package timely.balancer.connection.ws;
 import javax.net.ssl.SSLContext;
 
 import org.apache.commons.pool2.impl.GenericKeyedObjectPool;
+
 import timely.balancer.configuration.BalancerConfiguration;
 import timely.balancer.connection.TimelyBalancedHost;
 import timely.client.websocket.subscription.WebSocketSubscriptionClient;
 
-public class WsClientPool extends GenericKeyedObjectPool<TimelyBalancedHost, WebSocketSubscriptionClient> {
+public class WsClientPool extends GenericKeyedObjectPool<TimelyBalancedHost,WebSocketSubscriptionClient> {
 
     public WsClientPool(BalancerConfiguration balancerConfig, SSLContext sslContext) {
         super(new WsClientFactory(balancerConfig, sslContext), balancerConfig.getWebsocket().getWsClientPool());

balancer/src/main/java/timely/balancer/healthcheck/HealthChecker.java

@@ -2,11 +2,13 @@ package timely.balancer.healthcheck;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Timer;
-import java.util.TimerTask;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+
 import timely.balancer.configuration.BalancerConfiguration;
 import timely.balancer.connection.TimelyBalancedHost;
 import timely.balancer.connection.tcp.TcpClientPool;
@@ -15,12 +17,12 @@ public class HealthChecker {
 
     private static final Logger LOG = LoggerFactory.getLogger(HealthChecker.class);
     private List<TimelyBalancedHost> timelyHosts = new ArrayList<>();
-    private Timer timer;
+    private ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);
     final private TCPServerHealthCheck tcpServerHealthCheck;
-    private TimerTask check = new TimerTask() {
 
-        @Override
-        public void run() {
+    public HealthChecker(BalancerConfiguration config, TcpClientPool tcpClientPool) {
+        this.tcpServerHealthCheck = new TCPServerHealthCheck(tcpClientPool);
+        this.executorService.scheduleAtFixedRate(() -> {
             synchronized (timelyHosts) {
                 for (TimelyBalancedHost h : timelyHosts) {
                     try {
@@ -35,13 +37,7 @@ public class HealthChecker {
                     }
                 }
             }
-        }
-    };
-
-    public HealthChecker(BalancerConfiguration config, TcpClientPool tcpClientPool) {
-        this.tcpServerHealthCheck = new TCPServerHealthCheck(tcpClientPool);
-        this.timer = new Timer("HealthCheckerThread", true);
-        this.timer.scheduleAtFixedRate(check, 0, config.getCheckServerHealthInterval());
+        }, 0, config.getCheckServerHealthInterval(), TimeUnit.MILLISECONDS);
     }
 
     public void setTimelyHosts(List<TimelyBalancedHost> timelyHosts) {
@@ -50,4 +46,17 @@ public class HealthChecker {
             this.timelyHosts.addAll(timelyHosts);
         }
     }
+
+    public void close() throws Exception {
+        this.executorService.shutdown();
+        try {
+            this.executorService.awaitTermination(5, TimeUnit.SECONDS);
+        } catch (InterruptedException e) {
+
+        } finally {
+            if (!this.executorService.isTerminated()) {
+                this.executorService.shutdownNow();
+            }
+        }
+    }
 }

balancer/src/main/java/timely/balancer/netty/http/HttpRelayHandler.java

@@ -1,6 +1,6 @@
 package timely.balancer.netty.http;
 
-import static io.netty.handler.codec.http.HttpHeaders.Names.CONTENT_LENGTH;
+import static io.netty.handler.codec.http.HttpHeaderNames.CONTENT_LENGTH;
 
 import java.io.ByteArrayOutputStream;
 import java.net.URLEncoder;
@@ -11,17 +11,6 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
-import com.google.common.collect.Multimap;
-import io.netty.buffer.Unpooled;
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.channel.SimpleChannelInboundHandler;
-import io.netty.handler.codec.http.DefaultFullHttpResponse;
-import io.netty.handler.codec.http.FullHttpRequest;
-import io.netty.handler.codec.http.FullHttpResponse;
-import io.netty.handler.codec.http.HttpMethod;
-import io.netty.handler.codec.http.HttpResponseStatus;
-import io.netty.handler.codec.http.HttpVersion;
-import io.netty.util.ReferenceCountUtil;
 import org.apache.http.Header;
 import org.apache.http.client.methods.CloseableHttpResponse;
 import org.apache.http.client.methods.HttpGet;
@@ -33,6 +22,19 @@ import org.apache.http.message.BasicHeader;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.util.StreamUtils;
+
+import com.google.common.collect.Multimap;
+
+import io.netty.buffer.Unpooled;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.SimpleChannelInboundHandler;
+import io.netty.handler.codec.http.DefaultFullHttpResponse;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.handler.codec.http.FullHttpResponse;
+import io.netty.handler.codec.http.HttpMethod;
+import io.netty.handler.codec.http.HttpResponseStatus;
+import io.netty.handler.codec.http.HttpVersion;
+import io.netty.util.ReferenceCountUtil;
 import timely.api.request.AuthenticatedRequest;
 import timely.api.request.MetricRequest;
 import timely.api.request.timeseries.HttpRequest;
@@ -67,7 +69,7 @@ public class HttpRelayHandler extends SimpleChannelInboundHandler<HttpRequest> i
         try {
             try {
                 request = msg.getHttpRequest();
-                String originalURI = request.getUri();
+                String originalURI = request.uri();
                 originalURI = encodeURI(originalURI);
 
                 String metric = null;
@@ -88,7 +90,7 @@ public class HttpRelayHandler extends SimpleChannelInboundHandler<HttpRequest> i
                 }
                 client = httpClientPool.borrowObject(k);
 
-                Multimap<String, String> headers = HttpHeaderUtils.toMultimap(request.headers());
+                Multimap<String,String> headers = HttpHeaderUtils.toMultimap(request.headers());
                 if (msg instanceof AuthenticatedRequest) {
                     AuthenticatedRequest authenticatedRequest = (AuthenticatedRequest) msg;
                     TimelyAuthenticationToken token = authenticatedRequest.getToken();
@@ -100,8 +102,8 @@ public class HttpRelayHandler extends SimpleChannelInboundHandler<HttpRequest> i
                 }
 
                 List<Header> relayedHeaderList = new ArrayList<>();
-                for (Map.Entry<String, String> h : headers.entries()) {
-                    if (!h.getKey().equals(CONTENT_LENGTH)) {
+                for (Map.Entry<String,String> h : headers.entries()) {
+                    if (!h.getKey().equals(CONTENT_LENGTH.toString())) {
                         relayedHeaderList.add(new BasicHeader(h.getKey(), h.getValue()));
                     }
                 }
@@ -109,14 +111,14 @@ public class HttpRelayHandler extends SimpleChannelInboundHandler<HttpRequest> i
                 relayedHeaderList.toArray(headerArray);
 
                 String relayURI = "https://" + k.getHost() + ":" + k.getHttpPort() + originalURI;
-                if (request.getMethod().equals(HttpMethod.GET)) {
+                if (request.method().equals(HttpMethod.GET)) {
                     HttpUriRequest relayedRequest = new HttpGet(relayURI);
                     if (headerArray.length > 0) {
                         relayedRequest.setHeaders(headerArray);
                     }
                     relayedResponse = client.execute(relayedRequest);
 
-                } else if (request.getMethod().equals(HttpMethod.POST)) {
+                } else if (request.method().equals(HttpMethod.POST)) {
                     HttpPost relayedRequest = new HttpPost(relayURI);
 
                     String content = request.content().toString(StandardCharsets.UTF_8);
@@ -138,25 +140,22 @@ public class HttpRelayHandler extends SimpleChannelInboundHandler<HttpRequest> i
                         LOG.error(message, e);
                     }
                 }
-                this.sendHttpError(ctx, new TimelyException(HttpResponseStatus.INTERNAL_SERVER_ERROR.code(),
-                        e.getMessage(), e.getLocalizedMessage(), e));
+                this.sendHttpError(ctx, new TimelyException(HttpResponseStatus.INTERNAL_SERVER_ERROR.code(), e.getMessage(), e.getLocalizedMessage(), e));
                 return;
             } finally {
-                if (request != null && request instanceof AutoCloseable) {
+                if (request != null) {
                     ReferenceCountUtil.release(request);
                 }
             }
             FullHttpResponse response = null;
             if (relayedResponse == null) {
-                this.sendHttpError(ctx, new TimelyException(HttpResponseStatus.METHOD_NOT_ALLOWED.code(),
-                        "Method not allowed", "Method not allowed"));
+                this.sendHttpError(ctx, new TimelyException(HttpResponseStatus.METHOD_NOT_ALLOWED.code(), "Method not allowed", "Method not allowed"));
             } else {
                 ByteArrayOutputStream baos = new MyByteArrayOutputStream();
                 StreamUtils.copy(relayedResponse.getEntity().getContent(), baos);
 
-                response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1,
-                        HttpResponseStatus.valueOf(relayedResponse.getStatusLine().getStatusCode()),
-                        Unpooled.copiedBuffer(baos.toByteArray()));
+                response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.valueOf(relayedResponse.getStatusLine().getStatusCode()),
+                                Unpooled.copiedBuffer(baos.toByteArray()));
                 for (Header h : relayedResponse.getAllHeaders()) {
                     response.headers().add(h.getName(), h.getValue());
                 }
@@ -170,15 +169,14 @@ public class HttpRelayHandler extends SimpleChannelInboundHandler<HttpRequest> i
             if (client != null && k != null) {
                 httpClientPool.returnObject(k, client);
             } else {
-                LOG.error("NOT RETURNING CONNECTION! " + msg.getHttpRequest().getUri());
+                LOG.error("NOT RETURNING CONNECTION! " + msg.getHttpRequest().uri());
             }
         }
     }
 
     static public class MyByteArrayOutputStream extends ByteArrayOutputStream {
 
-        public MyByteArrayOutputStream() {
-        }
+        public MyByteArrayOutputStream() {}
 
         public MyByteArrayOutputStream(int size) {
             super(size);

balancer/src/main/java/timely/balancer/netty/tcp/TcpRelayHandler.java

@@ -4,13 +4,14 @@ import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.util.List;
 
+import org.apache.commons.lang3.tuple.Pair;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.SimpleChannelInboundHandler;
-import org.apache.commons.lang3.tuple.Pair;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 import timely.api.request.MetricRequest;
 import timely.api.request.TcpRequest;
 import timely.balancer.connection.TimelyBalancedHost;
@@ -44,7 +45,7 @@ public class TcpRelayHandler extends SimpleChannelInboundHandler<TcpRequest> {
         LOG.trace("Received {}", msg);
         try {
             String line;
-            Pair<TimelyBalancedHost, TcpClient> keyClientPair = null;
+            Pair<TimelyBalancedHost,TcpClient> keyClientPair = null;
             try {
                 if (msg instanceof MetricRequest) {
                     String metricName = ((MetricRequest) msg).getMetric().getName();
@@ -64,22 +65,20 @@ public class TcpRelayHandler extends SimpleChannelInboundHandler<TcpRequest> {
 
         } catch (IOException e) {
             LOG.error(LOG_ERR_MSG, msg, e);
-            ChannelFuture cf = ctx.writeAndFlush(
-                    Unpooled.copiedBuffer((ERR_MSG + e.getMessage() + "\n").getBytes(StandardCharsets.UTF_8)));
+            ChannelFuture cf = ctx.writeAndFlush(Unpooled.copiedBuffer((ERR_MSG + e.getMessage() + "\n").getBytes(StandardCharsets.UTF_8)));
             if (!cf.isSuccess()) {
                 LOG.error(Constants.ERR_WRITING_RESPONSE, cf.cause());
             }
         }
     }
 
-    private Pair<TimelyBalancedHost, TcpClient> getClient(String metric, boolean metricRequest) {
+    private Pair<TimelyBalancedHost,TcpClient> getClient(String metric, boolean metricRequest) {
         TcpClient client = null;
         TimelyBalancedHost k = null;
         int failures = 0;
         while (client == null) {
             try {
-                k = (metricRequest == true) ? metricResolver.getHostPortKeyIngest(metric)
-                        : metricResolver.getHostPortKey(metric);
+                k = (metricRequest == true) ? metricResolver.getHostPortKeyIngest(metric) : metricResolver.getHostPortKey(metric);
                 client = tcpClientPool().borrowObject(k);
             } catch (Exception e1) {
                 failures++;

balancer/src/main/java/timely/balancer/netty/udp/UdpRelayHandler.java

@@ -2,13 +2,14 @@ package timely.balancer.netty.udp;
 
 import java.nio.charset.StandardCharsets;
 
+import org.apache.commons.lang3.tuple.Pair;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.SimpleChannelInboundHandler;
-import org.apache.commons.lang3.tuple.Pair;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 import timely.api.request.MetricRequest;
 import timely.api.request.UdpRequest;
 import timely.balancer.connection.TimelyBalancedHost;
@@ -37,7 +38,7 @@ public class UdpRelayHandler extends SimpleChannelInboundHandler<UdpRequest> {
         try {
             MetricRequest metricRequest = (MetricRequest) msg;
             String metricName = metricRequest.getMetric().getName();
-            Pair<TimelyBalancedHost, UdpClient> keyClientPair = null;
+            Pair<TimelyBalancedHost,UdpClient> keyClientPair = null;
             try {
                 keyClientPair = getClient(metricName, true);
                 keyClientPair.getRight().write(metricRequest.getLine() + "\n");
@@ -50,22 +51,20 @@ public class UdpRelayHandler extends SimpleChannelInboundHandler<UdpRequest> {
 
         } catch (Exception e) {
             LOG.error(LOG_ERR_MSG, msg, e);
-            ChannelFuture cf = ctx.writeAndFlush(
-                    Unpooled.copiedBuffer((ERR_MSG + e.getMessage() + "\n").getBytes(StandardCharsets.UTF_8)));
+            ChannelFuture cf = ctx.writeAndFlush(Unpooled.copiedBuffer((ERR_MSG + e.getMessage() + "\n").getBytes(StandardCharsets.UTF_8)));
             if (!cf.isSuccess()) {
                 LOG.error(Constants.ERR_WRITING_RESPONSE, cf.cause());
             }
         }
     }
 
-    private Pair<TimelyBalancedHost, UdpClient> getClient(String metric, boolean metricRequest) {
+    private Pair<TimelyBalancedHost,UdpClient> getClient(String metric, boolean metricRequest) {
         UdpClient client = null;
         TimelyBalancedHost k = null;
         int failures = 0;
         while (client == null) {
             try {
-                k = (metricRequest == true) ? metricResolver.getHostPortKeyIngest(metric)
-                        : metricResolver.getHostPortKey(metric);
+                k = (metricRequest == true) ? metricResolver.getHostPortKeyIngest(metric) : metricResolver.getHostPortKey(metric);
                 client = udpClientPool.borrowObject(k);
             } catch (Exception e1) {
                 failures++;

balancer/src/main/java/timely/balancer/netty/ws/WsClientHandler.java

@@ -9,15 +9,17 @@ import javax.websocket.CloseReason;
 import javax.websocket.EndpointConfig;
 import javax.websocket.Session;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import com.google.common.collect.HashMultimap;
 import com.google.common.collect.Multimap;
+
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.http.HttpResponseStatus;
 import io.netty.handler.codec.http.websocketx.PingWebSocketFrame;
 import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
 import io.netty.util.concurrent.ScheduledFuture;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 import timely.api.response.TimelyException;
 import timely.auth.util.ProxiedEntityUtils;
 import timely.client.websocket.ClientHandler;
@@ -40,20 +42,20 @@ public class WsClientHandler extends ClientHandler {
     }
 
     @Override
-    public void beforeRequest(Map<String, List<String>> headers) {
+    public void beforeRequest(Map<String,List<String>> headers) {
         if (token.getClientCert() != null) {
-            Multimap<String, String> proxyRequestHeaders = HashMultimap.create();
+            Multimap<String,String> proxyRequestHeaders = HashMultimap.create();
             ProxiedEntityUtils.addProxyHeaders(proxyRequestHeaders, token.getClientCert());
             for (String s : proxyRequestHeaders.keySet()) {
-                headers.put(s, new ArrayList(proxyRequestHeaders.get(s)));
+                headers.put(s, new ArrayList<>(proxyRequestHeaders.get(s)));
             }
         }
 
-        Multimap<String, String> originalRequestHeaders = token.getHttpHeaders();
+        Multimap<String,String> originalRequestHeaders = token.getHttpHeaders();
         for (String s : originalRequestHeaders.keySet()) {
             if (!headers.containsKey(s)) {
                 // add pre-existing values if key does not exist in proxyRequest
-                headers.put(s, new ArrayList(originalRequestHeaders.get(s)));
+                headers.put(s, new ArrayList<>(originalRequestHeaders.get(s)));
             }
         }
     }
@@ -71,8 +73,7 @@ public class WsClientHandler extends ClientHandler {
         super.onClose(session, reason);
         if (!reason.getCloseCode().equals(CloseReason.CloseCodes.NORMAL_CLOSURE)) {
             LOG.error("Abnormal close: " + reason.getReasonPhrase());
-            Exception e = new TimelyException(HttpResponseStatus.INTERNAL_SERVER_ERROR.code(), reason.getReasonPhrase(),
-                    "");
+            Exception e = new TimelyException(HttpResponseStatus.INTERNAL_SERVER_ERROR.code(), reason.getReasonPhrase(), "");
             WsRelayHandler.sendErrorResponse(ctx, HttpResponseStatus.INTERNAL_SERVER_ERROR, e);
         }
         if (!ping.isCancelled()) {

balancer/src/main/java/timely/balancer/netty/ws/WsClientHolder.java

@@ -4,6 +4,7 @@ import java.io.IOException;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+
 import timely.balancer.connection.TimelyBalancedHost;
 import timely.balancer.connection.ws.WsClientPool;
 import timely.client.websocket.subscription.WebSocketSubscriptionClient;

balancer/src/main/java/timely/balancer/netty/ws/WsRelayHandler.java

@@ -5,11 +5,15 @@ import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.SerializationFeature;
 import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;
 import com.google.common.collect.Multimap;
+
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelFutureListener;
 import io.netty.channel.ChannelHandlerContext;
@@ -17,8 +21,6 @@ import io.netty.channel.SimpleChannelInboundHandler;
 import io.netty.handler.codec.http.HttpResponseStatus;
 import io.netty.handler.codec.http.websocketx.CloseWebSocketFrame;
 import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 import timely.api.request.subscription.AddSubscription;
 import timely.api.request.subscription.CloseSubscription;
 import timely.api.request.subscription.CreateSubscription;
@@ -41,8 +43,8 @@ public class WsRelayHandler extends SimpleChannelInboundHandler<SubscriptionRequ
     private final WsClientPool wsClientPool;
     private MetricResolver metricResolver;
     static private ObjectMapper mapper;
-    Map<String, Map<String, WsClientHolder>> wsClients = new ConcurrentHashMap<>();
-    Map<String, ChannelHandlerContext> wsSubscriptions = new ConcurrentHashMap<>();
+    Map<String,Map<String,WsClientHolder>> wsClients = new ConcurrentHashMap<>();
+    Map<String,ChannelHandlerContext> wsSubscriptions = new ConcurrentHashMap<>();
 
     static {
         mapper = new ObjectMapper();
@@ -52,8 +54,7 @@ public class WsRelayHandler extends SimpleChannelInboundHandler<SubscriptionRequ
         mapper.configure(SerializationFeature.WRAP_ROOT_VALUE, true);
     }
 
-    public WsRelayHandler(BalancerConfiguration balancerConfig, MetricResolver metricResolver,
-            WsClientPool wsClientPool) {
+    public WsRelayHandler(BalancerConfiguration balancerConfig, MetricResolver metricResolver, WsClientPool wsClientPool) {
         this.balancerConfig = balancerConfig;
         this.metricResolver = metricResolver;
         this.wsClientPool = wsClientPool;
@@ -67,7 +68,7 @@ public class WsRelayHandler extends SimpleChannelInboundHandler<SubscriptionRequ
         try {
             String metric = null;
 
-            Multimap<String, String> headers = msg.getRequestHeaders();
+            Multimap<String,String> headers = msg.getRequestHeaders();
             ProxiedEntityUtils.addProxyHeaders(headers, msg.getToken().getClientCert());
 
             if (msg instanceof CreateSubscription) {
@@ -83,14 +84,13 @@ public class WsRelayHandler extends SimpleChannelInboundHandler<SubscriptionRequ
 
                     @Override
                     public void operationComplete(ChannelFuture future) throws Exception {
-                        Map<String, WsClientHolder> metricToClientMap = wsClients.get(currentSubscriptionId);
+                        Map<String,WsClientHolder> metricToClientMap = wsClients.get(currentSubscriptionId);
 
                         if (metricToClientMap != null) {
                             synchronized (metricToClientMap) {
                                 // close all clients for this subscriptionId
-                                LOG.info("Channel closed, closing subscriptions for subscriptionId:%s",
-                                        currentSubscriptionId);
-                                for (Map.Entry<String, WsClientHolder> entry : metricToClientMap.entrySet()) {
+                                LOG.debug("Channel closed, closing subscriptions for subscriptionId:{}", currentSubscriptionId);
+                                for (Map.Entry<String,WsClientHolder> entry : metricToClientMap.entrySet()) {
                                     entry.getValue().close(wsClientPool);
                                 }
                                 wsClients.remove(currentSubscriptionId);
@@ -108,12 +108,10 @@ public class WsRelayHandler extends SimpleChannelInboundHandler<SubscriptionRequ
                 if (origContext == null) {
                     // send error because user never sent a CreateSubscription
                     // and we have nowhere to send the results
-                    LOG.info("ChannelHandlerContext not found for subscriptionId:%s - createSubscription not called?",
-                            subscriptionId);
-                    sendErrorResponse(ctx, HttpResponseStatus.BAD_REQUEST,
-                            new IllegalArgumentException("Must call create first"));
+                    LOG.info("ChannelHandlerContext not found for subscriptionId:{} - createSubscription not called?", subscriptionId);
+                    sendErrorResponse(ctx, HttpResponseStatus.BAD_REQUEST, new IllegalArgumentException("Must call create first"));
                 }
-                Map<String, WsClientHolder> metricToClientMap = wsClients.get(subscriptionId);
+                Map<String,WsClientHolder> metricToClientMap = wsClients.get(subscriptionId);
                 if (metricToClientMap == null) {
                     metricToClientMap = new HashMap<>();
                     wsClients.put(subscriptionId, metricToClientMap);
@@ -124,14 +122,13 @@ public class WsRelayHandler extends SimpleChannelInboundHandler<SubscriptionRequ
                     if (hostClientHolder == null) {
                         k = metricResolver.getHostPortKey(metric);
                         client = wsClientPool.borrowObject(k);
-                        client.open(new WsClientHandler(origContext, add.getToken(),
-                                (balancerConfig.getWebsocket().getTimeout() / 2)));
+                        client.open(new WsClientHandler(origContext, add.getToken(), (balancerConfig.getWebsocket().getTimeout() / 2)));
                         metricToClientMap.put(metric, new WsClientHolder(k, client));
                     } else {
                         client = hostClientHolder.getClient();
                     }
                 }
-                Map<String, String> tags = null;
+                Map<String,String> tags = null;
 
                 Long startTime = 0L;
                 Long endTime = 0L;
@@ -155,25 +152,25 @@ public class WsRelayHandler extends SimpleChannelInboundHandler<SubscriptionRequ
                 RemoveSubscription remove = (RemoveSubscription) msg;
                 metric = remove.getMetric();
                 subscriptionId = remove.getSubscriptionId();
-                Map<String, WsClientHolder> metricToClientMap = wsClients.get(subscriptionId);
+                Map<String,WsClientHolder> metricToClientMap = wsClients.get(subscriptionId);
                 if (metricToClientMap != null) {
                     synchronized (metricToClientMap) {
                         WsClientHolder hostClientHolder = metricToClientMap.get(metric);
                         if (hostClientHolder != null) {
                             hostClientHolder.getClient().removeSubscription(metric);
                         } else {
-                            LOG.info("client not found for subscriptionId:%s metric:%s", subscriptionId, metric);
+                            LOG.info("client not found for subscriptionId:{} metric:{}", subscriptionId, metric);
                         }
                     }
                 }
             } else if (msg instanceof CloseSubscription) {
                 CloseSubscription close = (CloseSubscription) msg;
                 subscriptionId = close.getSubscriptionId();
-                Map<String, WsClientHolder> metricToClientMap = wsClients.get(subscriptionId);
+                Map<String,WsClientHolder> metricToClientMap = wsClients.get(subscriptionId);
                 if (metricToClientMap != null) {
                     synchronized (metricToClientMap) {
                         // close all clients for this subscriptionId
-                        for (Map.Entry<String, WsClientHolder> entry : metricToClientMap.entrySet()) {
+                        for (Map.Entry<String,WsClientHolder> entry : metricToClientMap.entrySet()) {
                             entry.getValue().close(wsClientPool);
                         }
                     }

balancer/src/main/java/timely/balancer/resolver/BalancedMetricResolver.java

@@ -7,6 +7,7 @@ import static timely.balancer.Balancer.LEADER_LATCH_PATH;
 import static timely.store.cache.DataStoreCache.NON_CACHED_METRICS;
 import static timely.store.cache.DataStoreCache.NON_CACHED_METRICS_LOCK_PATH;
 
+import java.io.FileNotFoundException;
 import java.nio.charset.Charset;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -19,19 +20,17 @@ import java.util.List;
 import java.util.Map;
 import java.util.Random;
 import java.util.Set;
-import java.util.Timer;
-import java.util.TimerTask;
 import java.util.TreeMap;
 import java.util.TreeSet;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 
-import com.csvreader.CsvReader;
-import com.csvreader.CsvWriter;
-import org.apache.commons.lang.StringUtils;
 import org.apache.commons.lang3.SerializationUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.apache.curator.framework.CuratorFramework;
 import org.apache.curator.framework.recipes.atomic.DistributedAtomicLong;
 import org.apache.curator.framework.recipes.atomic.DistributedAtomicValue;
@@ -56,6 +55,10 @@ import org.apache.hadoop.fs.Path;
 import org.apache.zookeeper.CreateMode;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+
+import com.csvreader.CsvReader;
+import com.csvreader.CsvWriter;
+
 import timely.ServerDetails;
 import timely.balancer.ArrivalRate;
 import timely.balancer.configuration.BalancerConfiguration;
@@ -65,14 +68,14 @@ import timely.balancer.healthcheck.HealthChecker;
 public class BalancedMetricResolver implements MetricResolver {
 
     private static final Logger LOG = LoggerFactory.getLogger(BalancedMetricResolver.class);
-    private Map<String, TimelyBalancedHost> metricToHostMap = new TreeMap<>();
-    private Map<String, ArrivalRate> metricMap = new HashMap<>();
+    private Map<String,TimelyBalancedHost> metricToHostMap = new TreeMap<>();
+    private Map<String,ArrivalRate> metricMap = new HashMap<>();
     private ReentrantReadWriteLock balancerLock = new ReentrantReadWriteLock();
     private List<TimelyBalancedHost> serverList = new ArrayList<>();
     private Random r = new Random();
     final private HealthChecker healthChecker;
-    private Timer timer = new Timer("RebalanceTimer", true);
-    private Timer arrivalRateTimer = new Timer("ArrivalRateTimerResolver", true);
+    private ScheduledExecutorService assignmentExecutor = Executors.newScheduledThreadPool(2);
+    private ScheduledExecutorService arrivalRateExecutor = Executors.newScheduledThreadPool(2);
     private int roundRobinCounter = 0;
     private Set<String> nonCachedMetrics = new HashSet<>();
     private DistributedAtomicValue nonCachedMetricsIP;
@@ -89,8 +92,7 @@ public class BalancedMetricResolver implements MetricResolver {
         HIGH_LOW, HIGH_AVG, AVG_LOW
     }
 
-    public BalancedMetricResolver(CuratorFramework curatorFramework, BalancerConfiguration balancerConfig,
-            HealthChecker healthChecker) {
+    public BalancedMetricResolver(CuratorFramework curatorFramework, BalancerConfiguration balancerConfig, HealthChecker healthChecker) {
         this.balancerConfig = balancerConfig;
         this.healthChecker = healthChecker;
 
@@ -98,32 +100,21 @@ public class BalancedMetricResolver implements MetricResolver {
         testIPRWLock(curatorFramework, assignmentsIPRWLock, ASSIGNMENTS_LOCK_PATH);
         startLeaderLatch(curatorFramework);
         startServiceListener(curatorFramework);
-        assignmentsLastUpdatedInHdfs = new DistributedAtomicLong(curatorFramework, ASSIGNMENTS_LAST_UPDATED_PATH,
-                new RetryForever(1000));
+        assignmentsLastUpdatedInHdfs = new DistributedAtomicLong(curatorFramework, ASSIGNMENTS_LAST_UPDATED_PATH, new RetryForever(1000));
 
         TreeCacheListener assignmentListener = new TreeCacheListener() {
 
             @Override
             public void childEvent(CuratorFramework curatorFramework, TreeCacheEvent event) throws Exception {
                 LOG.debug("Handling assignments event {}. assignmentsLastUpdatedInHdfs:{}", event.getType().toString(),
-                        new Date(assignmentsLastUpdatedInHdfs.get().postValue()));
+                                new Date(assignmentsLastUpdatedInHdfs.get().postValue()));
                 if (event.getType().equals(TreeCacheEvent.Type.NODE_UPDATED)) {
-                    long lastLocalUpdate = assignmentsLastUpdatedLocal.get();
-                    long lastHdfsUpdate = assignmentsLastUpdatedInHdfs.get().postValue();
-                    if (lastHdfsUpdate > lastLocalUpdate) {
-                        LOG.debug("Reading assignments from hdfs lastHdfsUpdate ({}) > lastLocalUpdate ({})",
-                                new Date(lastHdfsUpdate), new Date(lastLocalUpdate));
-                        readAssignmentsFromHdfs();
-                    } else {
-                        LOG.debug("Not reading assignments from hdfs lastHdfsUpdate ({}) <= lastLocalUpdate ({})",
-                                new Date(lastHdfsUpdate), new Date(lastLocalUpdate));
-                    }
+                    readAssignmentsFromHdfs(true);
                 }
             }
         };
 
-        try {
-            TreeCache assignmentTreeCache = new TreeCache(curatorFramework, ASSIGNMENTS_LAST_UPDATED_PATH);
+        try (TreeCache assignmentTreeCache = new TreeCache(curatorFramework, ASSIGNMENTS_LAST_UPDATED_PATH)) {
             assignmentTreeCache.getListenable().addListener(assignmentListener);
             assignmentTreeCache.start();
         } catch (Exception e) {
@@ -144,8 +135,7 @@ public class BalancedMetricResolver implements MetricResolver {
             }
         };
 
-        try {
-            TreeCache nonCachedMetricsTreeCache = new TreeCache(curatorFramework, NON_CACHED_METRICS);
+        try (TreeCache nonCachedMetricsTreeCache = new TreeCache(curatorFramework, NON_CACHED_METRICS)) {
             nonCachedMetricsTreeCache.getListenable().addListener(nonCachedMetricsListener);
             nonCachedMetricsTreeCache.start();
         } catch (Exception e) {
@@ -160,55 +150,54 @@ public class BalancedMetricResolver implements MetricResolver {
         }
         readNonCachedMetricsIP();
 
-        readAssignmentsFromHdfs();
+        readAssignmentsFromHdfs(false);
 
-        timer.schedule(new TimerTask() {
-
-            @Override
-            public void run() {
-                if (isLeader.get()) {
-                    try {
-                        balance();
-                    } catch (Exception e) {
-                        LOG.error(e.getMessage(), e);
-                    }
-                }
-            }
-        }, 900000, 900000);
-
-        timer.schedule(new TimerTask() {
-
-            @Override
-            public void run() {
+        assignmentExecutor.scheduleAtFixedRate(() -> {
+            if (isLeader.get()) {
                 try {
-                    if (isLeader.get()) {
-                        long lastLocalUpdate = assignmentsLastUpdatedLocal.get();
-                        long lastHdfsUpdate = assignmentsLastUpdatedInHdfs.get().postValue();
-                        if (lastLocalUpdate > lastHdfsUpdate) {
-                            LOG.debug("Writing assignments to hdfs lastLocalUpdate ({}) > lastHdfsUpdate ({})",
-                                    new Date(lastLocalUpdate), new Date(lastHdfsUpdate));
-                            writeAssigmentsToHdfs();
-                        }
-                    }
+                    balance();
                 } catch (Exception e) {
                     LOG.error(e.getMessage(), e);
                 }
             }
-        }, 10000, 60000);
+        }, 15, 15, TimeUnit.MINUTES);
+
+        assignmentExecutor.scheduleAtFixedRate(() -> {
+            try {
+                if (isLeader.get()) {
+                    long lastLocalUpdate = assignmentsLastUpdatedLocal.get();
+                    long lastHdfsUpdate = assignmentsLastUpdatedInHdfs.get().postValue();
+                    if (lastLocalUpdate > lastHdfsUpdate) {
+                        LOG.debug("Leader writing assignments to hdfs lastLocalUpdate ({}) > lastHdfsUpdate ({})", new Date(lastLocalUpdate),
+                                        new Date(lastHdfsUpdate));
+                        writeAssignmentsToHdfs();
+                    } else {
+                        LOG.trace("Leader not writing assignments to hdfs lastLocalUpdate ({}) <= lastHdfsUpdate ({})", new Date(lastLocalUpdate),
+                                        new Date(lastHdfsUpdate));
+                    }
+                } else {
+                    readAssignmentsFromHdfs(true);
+                }
+            } catch (Exception e) {
+                LOG.error(e.getMessage(), e);
+            }
+        }, 10, 60, TimeUnit.SECONDS);
     }
 
     private void readNonCachedMetricsIP() {
 
         Set<String> currentNonCachedMetricsDistributed = new TreeSet<>();
         try {
-            nonCachedMetricsIPRWLock.readLock().acquire();
+            boolean acquired = false;
+            while (!acquired) {
+                acquired = nonCachedMetricsIPRWLock.readLock().acquire(60, TimeUnit.SECONDS);
+            }
             byte[] currentNonCachedMetricsDistributedBytes = nonCachedMetricsIP.get().postValue();
             if (currentNonCachedMetricsDistributedBytes != null) {
                 try {
-                    currentNonCachedMetricsDistributed = SerializationUtils
-                            .deserialize(currentNonCachedMetricsDistributedBytes);
+                    currentNonCachedMetricsDistributed = SerializationUtils.deserialize(currentNonCachedMetricsDistributedBytes);
                 } catch (Exception e) {
-                    LOG.error(e.getMessage());
+                    LOG.error(e.getMessage(), e);
                     currentNonCachedMetricsDistributed = new TreeSet<>();
                 }
             }
@@ -249,7 +238,7 @@ public class BalancedMetricResolver implements MetricResolver {
                 public void isLeader() {
                     LOG.info("this balancer is the leader");
                     isLeader.set(true);
-                    writeAssigmentsToHdfs();
+                    writeAssignmentsToHdfs();
                 }
 
                 @Override
@@ -265,19 +254,19 @@ public class BalancedMetricResolver implements MetricResolver {
 
     private void startServiceListener(CuratorFramework curatorFramework) {
         try {
-            ServiceDiscovery discovery = ServiceDiscoveryBuilder.builder(ServerDetails.class).client(curatorFramework)
-                    .basePath(SERVICE_DISCOVERY_PATH).build();
+            ServiceDiscovery<ServerDetails> discovery = ServiceDiscoveryBuilder.builder(ServerDetails.class).client(curatorFramework)
+                            .basePath(SERVICE_DISCOVERY_PATH).build();
             discovery.start();
-            Collection<ServiceInstance> instances = discovery.queryForInstances("timely-server");
+            Collection<ServiceInstance<ServerDetails>> instances = discovery.queryForInstances("timely-server");
 
             balancerLock.writeLock().lock();
             try {
-                for (ServiceInstance si : instances) {
-                    ServerDetails pl = (ServerDetails) si.getPayload();
-                    TimelyBalancedHost tbh = TimelyBalancedHost.of(pl.getHost(), pl.getTcpPort(), pl.getHttpPort(),
-                            pl.getWsPort(), pl.getUdpPort());
-                    LOG.info("adding service {} host:{} tcpPort:{} httpPort:{} wsPort:{} udpPort:{}", si.getId(),
-                            pl.getHost(), pl.getTcpPort(), pl.getHttpPort(), pl.getWsPort(), pl.getUdpPort());
+                for (ServiceInstance<ServerDetails> si : instances) {
+                    ServerDetails pl = si.getPayload();
+                    TimelyBalancedHost tbh = TimelyBalancedHost.of(pl.getHost(), pl.getTcpPort(), pl.getHttpPort(), pl.getWsPort(), pl.getUdpPort(),
+                                    new ArrivalRate(arrivalRateExecutor));
+                    LOG.info("adding service {} host:{} tcpPort:{} httpPort:{} wsPort:{} udpPort:{}", si.getId(), pl.getHost(), pl.getTcpPort(),
+                                    pl.getHttpPort(), pl.getWsPort(), pl.getUdpPort());
                     tbh.setBalancerConfig(balancerConfig);
                     serverList.add(tbh);
                 }
@@ -286,7 +275,7 @@ public class BalancedMetricResolver implements MetricResolver {
                 balancerLock.writeLock().unlock();
             }
 
-            final ServiceCache serviceCache = discovery.serviceCacheBuilder().name("timely-server").build();
+            final ServiceCache<ServerDetails> serviceCache = discovery.serviceCacheBuilder().name("timely-server").build();
             ServiceCacheListener listener = new ServiceCacheListener() {
 
                 @Override
@@ -294,12 +283,12 @@ public class BalancedMetricResolver implements MetricResolver {
                     boolean rebalanceNeeded = false;
                     balancerLock.writeLock().lock();
                     try {
-                        List<ServiceInstance> instances = serviceCache.getInstances();
+                        List<ServiceInstance<ServerDetails>> instances = serviceCache.getInstances();
                         Set<TimelyBalancedHost> availableHosts = new HashSet<>();
-                        for (ServiceInstance si : instances) {
+                        for (ServiceInstance<ServerDetails> si : instances) {
                             ServerDetails pl = (ServerDetails) si.getPayload();
-                            TimelyBalancedHost tbh = TimelyBalancedHost.of(pl.getHost(), pl.getTcpPort(),
-                                    pl.getHttpPort(), pl.getWsPort(), pl.getUdpPort());
+                            TimelyBalancedHost tbh = TimelyBalancedHost.of(pl.getHost(), pl.getTcpPort(), pl.getHttpPort(), pl.getWsPort(), pl.getUdpPort(),
+                                            new ArrivalRate(arrivalRateExecutor));
                             tbh.setBalancerConfig(balancerConfig);
                             availableHosts.add(tbh);
                         }
@@ -313,10 +302,9 @@ public class BalancedMetricResolver implements MetricResolver {
                                 availableHosts.remove(h);
                             } else {
                                 itr.remove();
-                                LOG.info("removing service {}:{} host:{} tcpPort:{} httpPort:{} wsPort:{} udpPort:{}",
-                                        h.getHost(), h.getTcpPort(), h.getHost(), h.getTcpPort(), h.getHttpPort(),
-                                        h.getWsPort(), h.getUdpPort());
-                                for (Map.Entry<String, TimelyBalancedHost> e : metricToHostMap.entrySet()) {
+                                LOG.info("removing service {}:{} host:{} tcpPort:{} httpPort:{} wsPort:{} udpPort:{}", h.getHost(), h.getTcpPort(), h.getHost(),
+                                                h.getTcpPort(), h.getHttpPort(), h.getWsPort(), h.getUdpPort());
+                                for (Map.Entry<String,TimelyBalancedHost> e : metricToHostMap.entrySet()) {
                                     if (e.getValue().equals(h)) {
                                         reassignMetrics.add(e.getKey());
                                     }
@@ -327,9 +315,8 @@ public class BalancedMetricResolver implements MetricResolver {
 
                         // add new hosts that were not previously known
                         for (TimelyBalancedHost h : availableHosts) {
-                            LOG.info("adding service {}:{} host:{} tcpPort:{} httpPort:{} wsPort:{} udpPort:{}",
-                                    h.getHost(), h.getTcpPort(), h.getHost(), h.getTcpPort(), h.getHttpPort(),
-                                    h.getWsPort(), h.getUdpPort());
+                            LOG.info("adding service {}:{} host:{} tcpPort:{} httpPort:{} wsPort:{} udpPort:{}", h.getHost(), h.getTcpPort(), h.getHost(),
+                                            h.getTcpPort(), h.getHttpPort(), h.getWsPort(), h.getUdpPort());
                             serverList.add(h);
                             rebalanceNeeded = true;
                         }
@@ -341,14 +328,16 @@ public class BalancedMetricResolver implements MetricResolver {
                                 assignMetric(s, h);
                                 LOG.debug("Assigned server removed.  Assigning {} to server {}:{}", s, h.getTcpPort());
                             }
-                            writeAssigmentsToHdfs();
                         }
 
                     } finally {
                         balancerLock.writeLock().unlock();
                     }
-                    if (isLeader.get() && rebalanceNeeded) {
-                        balance();
+                    if (isLeader.get()) {
+                        if (rebalanceNeeded) {
+                            balance();
+                        }
+                        writeAssignmentsToHdfs();
                     }
                 }
 
@@ -370,12 +359,12 @@ public class BalancedMetricResolver implements MetricResolver {
         TimelyBalancedHost tbh = null;
         balancerLock.readLock().lock();
         try {
-            Map<Double, TimelyBalancedHost> rateSortedHosts = new TreeMap<>();
+            Map<Double,TimelyBalancedHost> rateSortedHosts = new TreeMap<>();
             for (TimelyBalancedHost s : serverList) {
                 rateSortedHosts.put(s.getArrivalRate(), s);
             }
 
-            Iterator<Map.Entry<Double, TimelyBalancedHost>> itr = rateSortedHosts.entrySet().iterator();
+            Iterator<Map.Entry<Double,TimelyBalancedHost>> itr = rateSortedHosts.entrySet().iterator();
 
             while (itr.hasNext() && tbh == null) {
                 TimelyBalancedHost currentTBH = itr.next().getValue();
@@ -440,11 +429,11 @@ public class BalancedMetricResolver implements MetricResolver {
         return tbh;
     }
 
-    private TimelyBalancedHost chooseHost(Set<TimelyBalancedHost> potentialHosts,
-            Map<TimelyBalancedHost, Double> calculatedRates, double referenceRate, BalanceType balanceType) {
+    private TimelyBalancedHost chooseHost(Set<TimelyBalancedHost> potentialHosts, Map<TimelyBalancedHost,Double> calculatedRates, double referenceRate,
+                    BalanceType balanceType) {
 
         TimelyBalancedHost tbh = null;
-        Map<Long, TimelyBalancedHost> weightedList = new TreeMap<>();
+        Map<Long,TimelyBalancedHost> weightedList = new TreeMap<>();
         long cumulativeWeight = 0;
         for (TimelyBalancedHost h : potentialHosts) {
             double currentDiff;
@@ -459,7 +448,7 @@ public class BalancedMetricResolver implements MetricResolver {
 
         if (cumulativeWeight > 0) {
             long randomWeight = r.nextLong() % cumulativeWeight;
-            for (Map.Entry<Long, TimelyBalancedHost> e : weightedList.entrySet()) {
+            for (Map.Entry<Long,TimelyBalancedHost> e : weightedList.entrySet()) {
                 if (randomWeight <= e.getKey()) {
                     tbh = e.getValue();
                     break;
@@ -476,7 +465,7 @@ public class BalancedMetricResolver implements MetricResolver {
             double controlBandPercentage = balancerConfig.getControlBandPercentage();
             // save current rates so that we can modify
             double totalArrivalRate = 0;
-            Map<TimelyBalancedHost, Double> calculatedRates = new HashMap<>();
+            Map<TimelyBalancedHost,Double> calculatedRates = new HashMap<>();
             for (TimelyBalancedHost h : serverList) {
                 double tbhArrivalRate = h.getArrivalRate();
                 calculatedRates.put(h, tbhArrivalRate);
@@ -508,13 +497,11 @@ public class BalancedMetricResolver implements MetricResolver {
                 LOG.debug("Host's arrival rates are within {} of the average", controlBandPercentage);
             } else if (!highHosts.isEmpty() && !lowHosts.isEmpty()) {
                 LOG.debug("begin rebalancing {}", BalanceType.HIGH_LOW);
-                numReassigned = rebalance(highHosts, lowHosts, calculatedRates, averageArrivalRate,
-                        BalanceType.HIGH_LOW);
+                numReassigned = rebalance(highHosts, lowHosts, calculatedRates, averageArrivalRate, BalanceType.HIGH_LOW);
                 LOG.debug("end rebalancing {} - reassigned {}", BalanceType.HIGH_LOW, numReassigned);
             } else if (lowHosts.isEmpty()) {
                 LOG.debug("begin rebalancing {}", BalanceType.HIGH_AVG);
-                numReassigned = rebalance(highHosts, avgHosts, calculatedRates, averageArrivalRate,
-                        BalanceType.HIGH_AVG);
+                numReassigned = rebalance(highHosts, avgHosts, calculatedRates, averageArrivalRate, BalanceType.HIGH_AVG);
                 LOG.debug("end rebalancing {} - reassigned {}", BalanceType.HIGH_AVG, numReassigned);
             } else {
                 LOG.debug("begin rebalancing {}", BalanceType.AVG_LOW);
@@ -525,14 +512,14 @@ public class BalancedMetricResolver implements MetricResolver {
         return numReassigned;
     }
 
-    public int rebalance(Set<TimelyBalancedHost> losingHosts, Set<TimelyBalancedHost> gainingHosts,
-            Map<TimelyBalancedHost, Double> calculatedRates, double targetArrivalRate, BalanceType balanceType) {
+    public int rebalance(Set<TimelyBalancedHost> losingHosts, Set<TimelyBalancedHost> gainingHosts, Map<TimelyBalancedHost,Double> calculatedRates,
+                    double targetArrivalRate, BalanceType balanceType) {
 
         int numReassigned = 0;
         if (isLeader.get()) {
             balancerLock.writeLock().lock();
             try {
-                Map<String, ArrivalRate> tempMetricMap = new HashMap<>();
+                Map<String,ArrivalRate> tempMetricMap = new HashMap<>();
                 tempMetricMap.putAll(metricMap);
 
                 Set<TimelyBalancedHost> focusedHosts;
@@ -554,21 +541,22 @@ public class BalancedMetricResolver implements MetricResolver {
                     }
 
                     // sort metrics by rate
-                    Map<Double, String> rateSortedMetrics = new TreeMap<>(Collections.reverseOrder());
-                    for (Map.Entry<String, ArrivalRate> e : tempMetricMap.entrySet()) {
-                        if (metricToHostMap.get(e.getKey()).equals(h)) {
+                    Map<Double,String> rateSortedMetrics = new TreeMap<>(Collections.reverseOrder());
+                    for (Map.Entry<String,ArrivalRate> e : tempMetricMap.entrySet()) {
+                        TimelyBalancedHost tbh = metricToHostMap.get(e.getKey());
+                        if (tbh != null && tbh.equals(h)) {
                             rateSortedMetrics.put(e.getValue().getRate(), e.getKey());
                         }
                     }
 
-                    LOG.trace("focusHost {}:{} desiredChange:{} rateSortedMetrics.size():{}", h.getHost(),
-                            h.getTcpPort(), desiredChange, rateSortedMetrics.size());
+                    LOG.trace("focusHost {}:{} desiredChange:{} rateSortedMetrics.size():{}", h.getHost(), h.getTcpPort(), desiredChange,
+                                    rateSortedMetrics.size());
 
                     boolean doneWithHost = false;
                     while (!doneWithHost) {
-                        Iterator<Map.Entry<Double, String>> itr = rateSortedMetrics.entrySet().iterator();
+                        Iterator<Map.Entry<Double,String>> itr = rateSortedMetrics.entrySet().iterator();
                         while (!doneWithHost && itr.hasNext()) {
-                            Map.Entry<Double, String> e = null;
+                            Map.Entry<Double,String> e = null;
                             // find largest metric that does not exceed desired change
                             while (e == null && itr.hasNext()) {
                                 e = itr.next();
@@ -583,8 +571,7 @@ public class BalancedMetricResolver implements MetricResolver {
                                 doneWithHost = true;
                             } else {
                                 LOG.trace("Selected:{} rate:{}", e.getValue(), e.getKey());
-                                TimelyBalancedHost candidateHost = chooseHost(selectFromHosts, calculatedRates,
-                                        calculatedRates.get(h), balanceType);
+                                TimelyBalancedHost candidateHost = chooseHost(selectFromHosts, calculatedRates, calculatedRates.get(h), balanceType);
                                 if (candidateHost == null) {
                                     LOG.trace("candidate host is null");
                                     doneWithHost = true;
@@ -599,10 +586,8 @@ public class BalancedMetricResolver implements MetricResolver {
                                     // don't move this metric again this host or balance
                                     itr.remove();
                                     tempMetricMap.remove(metric);
-                                    LOG.info(
-                                            "rebalancing: reassigning metric:{} rate:{} from server {}:{} to {}:{} remaining delta {}",
-                                            metric, metricRate, h.getHost(), h.getTcpPort(), candidateHost.getHost(),
-                                            candidateHost.getTcpPort(), desiredChange);
+                                    LOG.info("rebalancing: reassigning metric:{} rate:{} from server {}:{} to {}:{} remaining delta {}", metric, metricRate,
+                                                    h.getHost(), h.getTcpPort(), candidateHost.getHost(), candidateHost.getTcpPort(), desiredChange);
                                 }
                             }
                         }
@@ -642,14 +627,16 @@ public class BalancedMetricResolver implements MetricResolver {
                 }
 
                 try {
-                    nonCachedMetricsIPRWLock.writeLock().acquire();
+                    boolean acquired = false;
+                    while (!acquired) {
+                        acquired = nonCachedMetricsIPRWLock.writeLock().acquire(60, TimeUnit.SECONDS);
+                    }
                     byte[] currentNonCachedMetricsDistributedBytes = nonCachedMetricsIP.get().postValue();
                     Set<String> currentNonCachedMetricsIP;
                     if (currentNonCachedMetricsDistributedBytes == null) {
                         currentNonCachedMetricsIP = new TreeSet<>();
                     } else {
-                        currentNonCachedMetricsIP = SerializationUtils
-                                .deserialize(currentNonCachedMetricsDistributedBytes);
+                        currentNonCachedMetricsIP = SerializationUtils.deserialize(currentNonCachedMetricsDistributedBytes);
                     }
                     if (currentNonCachedMetricsIP.containsAll(nonCachedMetricsUpdate)) {
                         LOG.debug("nonCachedMetricsIP already contains {}", nonCachedMetricsUpdate);
@@ -680,8 +667,7 @@ public class BalancedMetricResolver implements MetricResolver {
         } catch (Exception e1) {
             try {
                 curatorFramework.delete().deletingChildrenIfNeeded().forPath(path);
-                curatorFramework.create().creatingParentContainersIfNeeded().withMode(CreateMode.PERSISTENT)
-                        .forPath(path);
+                curatorFramework.create().creatingParentContainersIfNeeded().withMode(CreateMode.PERSISTENT).forPath(path);
             } catch (Exception e2) {
                 LOG.info(e2.getMessage(), e2);
             }
@@ -689,7 +675,7 @@ public class BalancedMetricResolver implements MetricResolver {
             try {
                 lock.writeLock().release();
             } catch (Exception e3) {
-                LOG.error(e3.getMessage());
+                LOG.error(e3.getMessage(), e3);
             }
         }
     }
@@ -740,18 +726,26 @@ public class BalancedMetricResolver implements MetricResolver {
         boolean chooseMetricSpecificHost;
         try {
             chooseMetricSpecificHost = shouldCache(metric) ? true : false;
+            ArrivalRate rate = metricMap.get(metric);
+            if ((chooseMetricSpecificHost && rate == null) || (!chooseMetricSpecificHost && rate != null)) {
+                if (!balancerLock.isWriteLockedByCurrentThread()) {
+                    balancerLock.readLock().unlock();
+                    balancerLock.writeLock().lock();
+                }
+            }
+
             if (chooseMetricSpecificHost) {
-                ArrivalRate rate = metricMap.get(metric);
                 if (rate == null) {
-                    rate = new ArrivalRate(arrivalRateTimer);
-                    if (!balancerLock.isWriteLockedByCurrentThread()) {
-                        balancerLock.readLock().unlock();
-                        balancerLock.writeLock().lock();
-                    }
+                    rate = new ArrivalRate(arrivalRateExecutor);
+                    // already write locked above
                     metricMap.put(metric, rate);
                 }
                 rate.arrived();
             } else {
+                if (rate != null) {
+                    // already write locked above
+                    metricMap.remove(metric);
+                }
                 metric = null;
             }
 
@@ -769,8 +763,8 @@ public class BalancedMetricResolver implements MetricResolver {
                 } else if (!tbh.isUp()) {
                     TimelyBalancedHost oldTbh = tbh;
                     tbh = getLeastUsedHost();
-                    LOG.debug("rebalancing from host that is down: reassigning metric {} from server {}:{} to {}:{}",
-                            metric, oldTbh.getHost(), oldTbh.getTcpPort(), tbh.getHost(), tbh.getTcpPort());
+                    LOG.debug("rebalancing from host that is down: reassigning metric {} from server {}:{} to {}:{}", metric, oldTbh.getHost(),
+                                    oldTbh.getTcpPort(), tbh.getHost(), tbh.getTcpPort());
                     if (!balancerLock.isWriteLockedByCurrentThread()) {
                         balancerLock.readLock().unlock();
                         balancerLock.writeLock().lock();
@@ -874,11 +868,43 @@ public class BalancedMetricResolver implements MetricResolver {
         return tbh;
     }
 
-    private void readAssignmentsFromHdfs() {
-
-        Map<String, TimelyBalancedHost> assignedMetricToHostMap = new TreeMap<>();
+    private void createAssignmentFile() {
         try {
-            assignmentsIPRWLock.readLock().acquire();
+            LOG.info("Creating assignment file: " + balancerConfig.getAssignmentFile());
+            Configuration configuration = new Configuration();
+            FileSystem fs = FileSystem.get(configuration);
+            Path assignmentFile = new Path(balancerConfig.getAssignmentFile());
+            fs.create(assignmentFile);
+        } catch (Exception e) {
+            LOG.error(e.getMessage(), e);
+        }
+    }
+
+    private void readAssignmentsFromHdfs(boolean checkIfNecessary) {
+
+        try {
+            long lastLocalUpdate = assignmentsLastUpdatedLocal.get();
+            long lastHdfsUpdate = assignmentsLastUpdatedInHdfs.get().postValue();
+            if (checkIfNecessary) {
+                if (lastHdfsUpdate <= lastLocalUpdate) {
+                    LOG.debug("Not reading assignments from hdfs lastHdfsUpdate ({}) <= lastLocalUpdate ({})", new Date(lastHdfsUpdate),
+                                    new Date(lastLocalUpdate));
+                    return;
+                }
+            }
+            LOG.debug("Reading assignments from hdfs lastHdfsUpdate ({}) > lastLocalUpdate ({})", new Date(lastHdfsUpdate), new Date(lastLocalUpdate));
+        } catch (Exception e) {
+            LOG.error(e.getMessage(), e);
+        }
+
+        // proceed with reading from HDFS
+
+        Map<String,TimelyBalancedHost> assignedMetricToHostMap = new TreeMap<>();
+        try {
+            boolean acquired = false;
+            while (!acquired) {
+                acquired = assignmentsIPRWLock.readLock().acquire(60, TimeUnit.SECONDS);
+            }
             balancerLock.writeLock().lock();
             Configuration configuration = new Configuration();
             FileSystem fs = FileSystem.get(configuration);
@@ -910,17 +936,22 @@ public class BalancedMetricResolver implements MetricResolver {
             }
 
             metricToHostMap.clear();
-            for (Map.Entry<String, TimelyBalancedHost> e : assignedMetricToHostMap.entrySet()) {
-                if (shouldCache(e.getKey())) {
-                    metricToHostMap.put(e.getKey(), e.getValue());
+            for (Map.Entry<String,TimelyBalancedHost> e : assignedMetricToHostMap.entrySet()) {
+                if (StringUtils.isNotBlank(e.getKey()) && e.getValue() != null) {
+                    if (shouldCache(e.getKey())) {
+                        metricToHostMap.put(e.getKey(), e.getValue());
+                    }
+                } else {
+                    Exception e1 = new IllegalStateException("Bad assignment metric:" + e.getKey() + " host:" + e.getValue());
+                    LOG.warn(e1.getMessage(), e1);
                 }
             }
 
             nonCachedMetricsLocalLock.readLock().lock();
             try {
-                Iterator<Map.Entry<String, TimelyBalancedHost>> itr = metricToHostMap.entrySet().iterator();
+                Iterator<Map.Entry<String,TimelyBalancedHost>> itr = metricToHostMap.entrySet().iterator();
                 while (itr.hasNext()) {
-                    Map.Entry<String, TimelyBalancedHost> e = itr.next();
+                    Map.Entry<String,TimelyBalancedHost> e = itr.next();
                     if (nonCachedMetrics.contains(e.getKey())) {
                         itr.remove();
                     }
@@ -928,9 +959,15 @@ public class BalancedMetricResolver implements MetricResolver {
             } finally {
                 nonCachedMetricsLocalLock.readLock().unlock();
             }
+            // remove metric from metricMap (ArrivalRate) if not being cached
+            metricMap.entrySet().removeIf(e -> !metricToHostMap.containsKey(e.getKey()));
+
             assignmentsLastUpdatedLocal.set(assignmentsLastUpdatedInHdfs.get().postValue());
             LOG.info("Read {} assignments from hdfs lastHdfsUpdate = lastLocalUpdate ({})", metricToHostMap.size(),
-                    new Date(assignmentsLastUpdatedLocal.get()));
+                            new Date(assignmentsLastUpdatedLocal.get()));
+        } catch (FileNotFoundException e) {
+            createAssignmentFile();
+            metricToHostMap.clear();
         } catch (Exception e) {
             LOG.error(e.getMessage(), e);
         } finally {
@@ -943,11 +980,14 @@ public class BalancedMetricResolver implements MetricResolver {
         }
     }
 
-    private void writeAssigmentsToHdfs() {
+    private void writeAssignmentsToHdfs() {
 
         CsvWriter writer = null;
         try {
-            assignmentsIPRWLock.writeLock().acquire();
+            boolean acquired = false;
+            while (!acquired) {
+                acquired = assignmentsIPRWLock.writeLock().acquire(60, TimeUnit.SECONDS);
+            }
             balancerLock.readLock().lock();
             nonCachedMetricsLocalLock.readLock().lock();
             try {
@@ -965,14 +1005,13 @@ public class BalancedMetricResolver implements MetricResolver {
                     writer.write("host");
                     writer.write("tcpPort");
                     writer.endRecord();
-                    for (Map.Entry<String, TimelyBalancedHost> e : metricToHostMap.entrySet()) {
+                    for (Map.Entry<String,TimelyBalancedHost> e : metricToHostMap.entrySet()) {
                         if (!nonCachedMetrics.contains(e.getKey())) {
                             writer.write(e.getKey());
                             writer.write(e.getValue().getHost());
                             writer.write(Integer.toString(e.getValue().getTcpPort()));
                             writer.endRecord();
-                            LOG.trace("Saving assigment: {} to {}:{}", e.getKey(), e.getValue().getHost(),
-                                    e.getValue().getTcpPort());
+                            LOG.trace("Saving assigment: {} to {}:{}", e.getKey(), e.getValue().getHost(), e.getValue().getTcpPort());
                         }
                     }
 
@@ -982,8 +1021,10 @@ public class BalancedMetricResolver implements MetricResolver {
                     if (!assignmentsLastUpdatedInHdfs.get().succeeded()) {
                         assignmentsLastUpdatedInHdfs.forceSet(now);
                     }
-                    LOG.debug("Wrote {} assignments to hdfs lastHdfsUpdate = lastLocalUpdate ({})",
-                            metricToHostMap.size(), new Date(assignmentsLastUpdatedLocal.get()));
+                    LOG.debug("Wrote {} assignments to hdfs lastHdfsUpdate = lastLocalUpdate ({})", metricToHostMap.size(),
+                                    new Date(assignmentsLastUpdatedLocal.get()));
+                    // remove metric from metricMap (ArrivalRate) if not being cached
+                    metricMap.entrySet().removeIf(e -> !metricToHostMap.containsKey(e.getKey()));
                 }
             } finally {
                 nonCachedMetricsLocalLock.readLock().unlock();
@@ -1005,13 +1046,50 @@ public class BalancedMetricResolver implements MetricResolver {
 
     private void assignMetric(String metric, TimelyBalancedHost tbh) {
         if (isLeader.get()) {
-            balancerLock.writeLock().lock();
-            try {
-                metricToHostMap.put(metric, tbh);
-                assignmentsLastUpdatedLocal.set(System.currentTimeMillis());
-            } finally {
-                balancerLock.writeLock().unlock();
+            if (StringUtils.isNotBlank(metric) && tbh != null) {
+                balancerLock.writeLock().lock();
+                try {
+                    metricToHostMap.put(metric, tbh);
+                    assignmentsLastUpdatedLocal.set(System.currentTimeMillis());
+                } finally {
+                    balancerLock.writeLock().unlock();
+                }
+            } else {
+                Exception e = new IllegalStateException("Bad assignment metric:" + metric + " host:" + tbh);
+                LOG.warn(e.getMessage(), e);
             }
         }
     }
+
+    @Override
+    public void close() throws Exception {
+
+        this.assignmentExecutor.shutdown();
+        try {
+            this.assignmentExecutor.awaitTermination(5, TimeUnit.SECONDS);
+        } catch (InterruptedException e) {
+
+        } finally {
+            if (!this.assignmentExecutor.isTerminated()) {
+                this.assignmentExecutor.shutdownNow();
+            }
+        }
+
+        this.arrivalRateExecutor.shutdown();
+        try {
+            this.arrivalRateExecutor.awaitTermination(5, TimeUnit.SECONDS);
+        } catch (InterruptedException e) {
+
+        } finally {
+            if (!this.arrivalRateExecutor.isTerminated()) {
+                this.arrivalRateExecutor.shutdownNow();
+            }
+        }
+
+        try {
+            this.healthChecker.close();
+        } catch (Exception e) {
+            LOG.error(e.getMessage(), e);
+        }
+    }
 }

balancer/src/main/java/timely/balancer/resolver/MetricResolver.java

@@ -7,4 +7,6 @@ public interface MetricResolver {
     public TimelyBalancedHost getHostPortKeyIngest(String metric);
 
     public TimelyBalancedHost getHostPortKey(String metric);
+
+    public void close() throws Exception;
 }

balancer/src/main/spotbugs/excludes.xml

@@ -10,4 +10,12 @@
     <Method name="getBuf" />
     <Bug pattern="EI_EXPOSE_REP" />
   </Match>
+  <Match>
+    <!-- these are probably avoidable, but needs further triage to fix -->
+    <Bug pattern="EI_EXPOSE_REP" />
+  </Match>
+  <Match>
+    <!-- these are probably avoidable, but needs further triage to fix -->
+    <Bug pattern="EI_EXPOSE_REP2" />
+  </Match>
 </FindBugsFilter>

client/pom.xml

@@ -4,12 +4,13 @@
   <parent>
     <groupId>timely</groupId>
     <artifactId>timely</artifactId>
-    <version>1.2.1</version>
+    <version>2.0.2</version>
   </parent>
   <artifactId>timely-client</artifactId>
   <properties>
     <!-- PEP 440 compliant version gets substituted into src/main/python/template/setup.py -->
-    <python.client.version>1.2.1</python.client.version>
+    <!-- use .dev0 instead of -SNAPSHOT -->
+    <python.client.version>2.0.2</python.client.version>
   </properties>
   <dependencies>
     <dependency>

client/src/main/java/timely/api/AddSubscription.java

@@ -7,7 +7,7 @@ public class AddSubscription extends SubscriptionRequest {
 
     private String operation = "add";
     private String metric = null;
-    private Optional<Map<String, String>> tags = Optional.empty();
+    private Optional<Map<String,String>> tags = Optional.empty();
     private Optional<Long> startTime = Optional.empty();
     private Optional<Long> endTime = Optional.empty();
     private Optional<Long> delayTime = Optional.empty();
@@ -20,7 +20,7 @@ public class AddSubscription extends SubscriptionRequest {
         return metric;
     }
 
-    public Optional<Map<String, String>> getTags() {
+    public Optional<Map<String,String>> getTags() {
         return tags;
     }
 
@@ -36,7 +36,7 @@ public class AddSubscription extends SubscriptionRequest {
         this.metric = metric;
     }
 
-    public void setTags(Optional<Map<String, String>> tags) {
+    public void setTags(Optional<Map<String,String>> tags) {
         this.tags = tags;
     }
 
@@ -71,9 +71,8 @@ public class AddSubscription extends SubscriptionRequest {
         }
         if (obj instanceof AddSubscription) {
             AddSubscription other = (AddSubscription) obj;
-            return (this.subscriptionId.equals(other.subscriptionId) && this.metric.equals(other.metric)
-                    && this.tags.equals(other.tags) && this.startTime.equals(other.startTime)
-                    && this.endTime.equals(other.endTime) && this.delayTime.equals(other.delayTime));
+            return (this.subscriptionId.equals(other.subscriptionId) && this.metric.equals(other.metric) && this.tags.equals(other.tags)
+                            && this.startTime.equals(other.startTime) && this.endTime.equals(other.endTime) && this.delayTime.equals(other.delayTime));
         } else {
             return false;
         }

client/src/main/java/timely/api/response/MetricResponse.java

@@ -5,9 +5,13 @@ import java.util.List;
 import org.apache.commons.lang3.builder.EqualsBuilder;
 import org.apache.commons.lang3.builder.HashCodeBuilder;
 import org.apache.commons.lang3.builder.ToStringBuilder;
+
+import com.fasterxml.jackson.annotation.JsonPropertyOrder;
+
 import timely.model.Metric;
 import timely.model.Tag;
 
+@JsonPropertyOrder({"metric", "timestamp", "value", "tags", "subscriptionId", "complete"})
 public class MetricResponse {
 
     private String metric;

client/src/main/java/timely/client/http/HttpClient.java

@@ -15,8 +15,8 @@ import org.glassfish.tyrus.client.SslContextConfigurator;
 
 public class HttpClient {
 
-    public static SSLContext getSSLContext(String trustStoreFile, String trustStoreType, String trustStorePass,
-            String keyStoreFile, String keyStoreType, String keyStorePass) {
+    public static SSLContext getSSLContext(String trustStoreFile, String trustStoreType, String trustStorePass, String keyStoreFile, String keyStoreType,
+                    String keyStorePass) {
         SslContextConfigurator scc = new SslContextConfigurator();
         scc.setTrustStoreFile(trustStoreFile);
         scc.setTrustStoreType(trustStoreType);
@@ -31,12 +31,10 @@ public class HttpClient {
         return scc.createSSLContext();
     }
 
-    public static CloseableHttpClient get(String trustStoreFile, String trustStoreType, String trustStorePass,
-            String keyStoreFile, String keyStoreType, String keyStorePass, CookieStore cookieStore,
-            boolean hostVerificationEnabled) {
+    public static CloseableHttpClient get(String trustStoreFile, String trustStoreType, String trustStorePass, String keyStoreFile, String keyStoreType,
+                    String keyStorePass, CookieStore cookieStore, boolean hostVerificationEnabled) {
 
-        SSLContext ssl = getSSLContext(trustStoreFile, trustStoreType, trustStorePass, keyStoreFile, keyStoreType,
-                keyStorePass);
+        SSLContext ssl = getSSLContext(trustStoreFile, trustStoreType, trustStorePass, keyStoreFile, keyStoreType, keyStorePass);
         return get(ssl, cookieStore, hostVerificationEnabled);
     }
 
@@ -44,8 +42,7 @@ public class HttpClient {
         return get(ssl, cookieStore, hostVerificationEnabled, false);
     }
 
-    public static CloseableHttpClient get(SSLContext ssl, CookieStore cookieStore, boolean hostVerificationEnabled,
-            boolean clientAuth) {
+    public static CloseableHttpClient get(SSLContext ssl, CookieStore cookieStore, boolean hostVerificationEnabled, boolean clientAuth) {
         HostnameVerifier hostnameVerifier;
         if (hostVerificationEnabled) {
             hostnameVerifier = SSLConnectionSocketFactory.getDefaultHostnameVerifier();
@@ -55,16 +52,15 @@ public class HttpClient {
         RequestConfig defaultRequestConfig = RequestConfig.custom().setCookieSpec(CookieSpecs.STANDARD).build();
         HttpClientBuilder builder;
         if (cookieStore == null) {
-            builder = HttpClients.custom().setSSLContext(ssl).disableCookieManagement()
-                    .setDefaultRequestConfig(defaultRequestConfig).setSSLHostnameVerifier(hostnameVerifier);
+            builder = HttpClients.custom().setSSLContext(ssl).disableCookieManagement().setDefaultRequestConfig(defaultRequestConfig)
+                            .setSSLHostnameVerifier(hostnameVerifier);
         } else {
-            builder = HttpClients.custom().setSSLContext(ssl).setDefaultCookieStore(cookieStore)
-                    .setDefaultRequestConfig(defaultRequestConfig).setSSLHostnameVerifier(hostnameVerifier);
+            builder = HttpClients.custom().setSSLContext(ssl).setDefaultCookieStore(cookieStore).setDefaultRequestConfig(defaultRequestConfig)
+                            .setSSLHostnameVerifier(hostnameVerifier);
         }
 
         if (clientAuth) {
-            SSLConnectionSocketFactory sslCSF = new SSLConnectionSocketFactory(ssl,
-                    new String[] { "TLSv1.1", "TLSv1.2" }, null, hostnameVerifier);
+            SSLConnectionSocketFactory sslCSF = new SSLConnectionSocketFactory(ssl, new String[] {"TLSv1.1", "TLSv1.2"}, null, hostnameVerifier);
             builder.setSSLSocketFactory(sslCSF);
         }
         return builder.build();

client/src/main/java/timely/client/tcp/TcpClient.java

@@ -1,7 +1,8 @@
 package timely.client.tcp;
 
+import java.io.BufferedWriter;
 import java.io.IOException;
-import java.io.PrintWriter;
+import java.io.OutputStreamWriter;
 import java.net.Socket;
 
 import org.slf4j.Logger;
@@ -14,7 +15,7 @@ public class TcpClient implements AutoCloseable {
     private final String host;
     private final int port;
     private Socket sock = null;
-    private PrintWriter out = null;
+    private BufferedWriter out = null;
     private long connectTime = 0L;
     private long backoff = 2000;
     private int bufferSize = -1;
@@ -32,7 +33,7 @@ public class TcpClient implements AutoCloseable {
 
     /**
      * Opens a TCP connection to the specified host and port
-     * 
+     *
      * @throws IOException
      *             if an error occurs
      */
@@ -44,10 +45,9 @@ public class TcpClient implements AutoCloseable {
 
     /**
      * Write a metric to Timely
-     * 
+     *
      * @param metric
      *            newline terminated string representation of Timely metric
-     * @throws IOException
      */
     public synchronized void write(String metric) throws IOException {
         if (connect() != 0) {
@@ -60,7 +60,7 @@ public class TcpClient implements AutoCloseable {
         }
     }
 
-    public synchronized void flush() {
+    public synchronized void flush() throws IOException {
         if (null != out) {
             out.flush();
             writesSinceFlush = 0;
@@ -69,7 +69,7 @@ public class TcpClient implements AutoCloseable {
 
     /**
      * Closes the tcp connection to Timely
-     * 
+     *
      * @throws IOException
      *             if an error occurs
      */
@@ -94,19 +94,44 @@ public class TcpClient implements AutoCloseable {
     }
 
     private synchronized int connect() {
-        if (null == sock || !sock.isConnected() || out.checkError()) {
+        if (null == sock || !sock.isConnected()) {
             if (System.currentTimeMillis() > (connectTime + backoff)) {
+                OutputStreamWriter osw = null;
                 try {
                     connectTime = System.currentTimeMillis();
                     sock = new Socket(host, port);
-                    out = new PrintWriter(sock.getOutputStream(), false);
+                    osw = new OutputStreamWriter(sock.getOutputStream());
+                    out = new BufferedWriter(osw);
                     backoff = 2000;
                     LOG.trace("Connected to Timely at {}:{}", host, port);
-                } catch (IOException e) {
-                    LOG.error("Error connecting to Timely at {}:" + host + ":" + port + ". Error: " + e.getMessage());
+                } catch (Exception e) {
+                    LOG.error("Error connecting to Timely at {}:{} - {}", host, port, e.getMessage());
+                    if (sock != null) {
+                        try {
+                            sock.close();
+                        } catch (IOException e1) {
+                            LOG.error(e1.getMessage());
+                        } finally {
+                            sock = null;
+                        }
+                    }
+                    if (osw != null) {
+                        try {
+                            osw.close();
+                        } catch (IOException e1) {
+                            LOG.error(e1.getMessage());
+                        }
+                    }
+                    if (out != null) {
+                        try {
+                            out.close();
+                        } catch (IOException e1) {
+                            LOG.error(e1.getMessage());
+                        } finally {
+                            out = null;
+                        }
+                    }
                     backoff = backoff * 2;
-                    sock = null;
-                    out = null;
                     LOG.info("Will retry connection in {} ms.", backoff);
                     return -1;
                 }

client/src/main/java/timely/client/udp/UdpClient.java

@@ -42,8 +42,7 @@ public class UdpClient implements AutoCloseable {
         this.sock.send(packet);
     }
 
-    public void flush() throws IOException {
-    }
+    public void flush() throws IOException {}
 
     public void close() throws IOException {
         if (null != sock) {

client/src/main/java/timely/client/websocket/ClientHandler.java

@@ -6,7 +6,6 @@ import java.util.Map;
 import javax.websocket.CloseReason;
 import javax.websocket.Endpoint;
 import javax.websocket.EndpointConfig;
-import javax.websocket.MessageHandler;
 import javax.websocket.Session;
 
 import org.slf4j.Logger;
@@ -19,12 +18,8 @@ public abstract class ClientHandler extends Endpoint {
     @Override
     public void onOpen(Session session, EndpointConfig config) {
         LOG.info("Websocket session {} opened.", session.getId());
-        session.addMessageHandler(new MessageHandler.Whole<String>() {
-
-            @Override
-            public void onMessage(String message) {
-                LOG.info("Message received on Websocket session {}: {}", session.getId(), message);
-            }
+        session.addMessageHandler(String.class, message -> {
+            LOG.info("Message received on Websocket session {}: {}", session.getId(), message);
         });
     }
 
@@ -38,6 +33,5 @@ public abstract class ClientHandler extends Endpoint {
         LOG.error("Error occurred on Websocket session" + session.getId(), error);
     }
 
-    public void beforeRequest(Map<String, List<String>> headers) {
-    }
+    public void beforeRequest(Map<String,List<String>> headers) {}
 }

client/src/main/java/timely/client/websocket/TimelyEndpointConfig.java

@@ -36,7 +36,7 @@ public class TimelyEndpointConfig implements ClientEndpointConfig {
     }
 
     @Override
-    public Map<String, Object> getUserProperties() {
+    public Map<String,Object> getUserProperties() {
         return Collections.emptyMap();
     }
 
@@ -55,7 +55,7 @@ public class TimelyEndpointConfig implements ClientEndpointConfig {
         return new Configurator() {
 
             @Override
-            public void beforeRequest(Map<String, List<String>> headers) {
+            public void beforeRequest(Map<String,List<String>> headers) {
                 super.beforeRequest(headers);
                 if (null != sessionCookie) {
                     headers.put("Cookie", Collections.singletonList(sessionCookie));

client/src/main/java/timely/client/websocket/WebSocketClient.java

@@ -10,7 +10,6 @@ import javax.net.ssl.SSLContext;
 import javax.websocket.DeploymentException;
 import javax.websocket.Session;
 
-import com.google.common.base.Preconditions;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.http.HttpResponse;
 import org.apache.http.HttpStatus;
@@ -28,6 +27,9 @@ import org.glassfish.tyrus.client.ClientProperties;
 import org.glassfish.tyrus.client.SslEngineConfigurator;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+
+import com.google.common.base.Preconditions;
+
 import timely.api.BasicAuthLogin;
 import timely.client.http.HttpClient;
 import timely.serialize.JsonSerializer;
@@ -51,9 +53,8 @@ public class WebSocketClient implements AutoCloseable {
     protected Session session = null;
     protected volatile boolean closed = true;
 
-    protected WebSocketClient(SSLContext ssl, String timelyHostname, int timelyHttpsPort, int timelyWssPort,
-            boolean clientAuth, boolean doLogin, String timelyUsername, String timelyPassword,
-            boolean hostVerificationEnabled, int bufferSize) {
+    protected WebSocketClient(SSLContext ssl, String timelyHostname, int timelyHttpsPort, int timelyWssPort, boolean clientAuth, boolean doLogin,
+                    String timelyUsername, String timelyPassword, boolean hostVerificationEnabled, int bufferSize) {
         this.ssl = ssl;
         this.timelyHostname = timelyHostname;
         this.timelyHttpsPort = timelyHttpsPort;
@@ -71,19 +72,17 @@ public class WebSocketClient implements AutoCloseable {
 
         if (doLogin && !clientAuth) {
             if ((StringUtils.isEmpty(timelyUsername) && !StringUtils.isEmpty(timelyPassword)
-                    || (!StringUtils.isEmpty(timelyUsername) && StringUtils.isEmpty(timelyPassword)))) {
+                            || (!StringUtils.isEmpty(timelyUsername) && StringUtils.isEmpty(timelyPassword)))) {
                 throw new IllegalArgumentException("Both Timely username and password must be empty or non-empty");
             }
         }
     }
 
-    protected WebSocketClient(String timelyHostname, int timelyHttpsPort, int timelyWssPort, boolean clientAuth,
-            boolean doLogin, String timelyUsername, String timelyPassword, String keyStoreFile, String keyStoreType,
-            String keyStorePass, String trustStoreFile, String trustStoreType, String trustStorePass,
-            boolean hostVerificationEnabled, int bufferSize) {
-        this(HttpClient.getSSLContext(trustStoreFile, trustStoreType, trustStorePass, keyStoreFile, keyStoreType,
-                keyStorePass), timelyHostname, timelyHttpsPort, timelyWssPort, clientAuth, doLogin, timelyUsername,
-                timelyPassword, hostVerificationEnabled, bufferSize);
+    protected WebSocketClient(String timelyHostname, int timelyHttpsPort, int timelyWssPort, boolean clientAuth, boolean doLogin, String timelyUsername,
+                    String timelyPassword, String keyStoreFile, String keyStoreType, String keyStorePass, String trustStoreFile, String trustStoreType,
+                    String trustStorePass, boolean hostVerificationEnabled, int bufferSize) {
+        this(HttpClient.getSSLContext(trustStoreFile, trustStoreType, trustStorePass, keyStoreFile, keyStoreType, keyStorePass), timelyHostname,
+                        timelyHttpsPort, timelyWssPort, clientAuth, doLogin, timelyUsername, timelyPassword, hostVerificationEnabled, bufferSize);
     }
 
     public void open(ClientHandler clientEndpoint) throws IOException, DeploymentException, URISyntaxException {
@@ -115,8 +114,7 @@ public class WebSocketClient implements AutoCloseable {
                 try {
                     response = client.execute(request);
                     if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
-                        throw new HttpResponseException(response.getStatusLine().getStatusCode(),
-                                response.getStatusLine().getReasonPhrase());
+                        throw new HttpResponseException(response.getStatusLine().getStatusCode(), response.getStatusLine().getReasonPhrase());
                     }
                     for (Cookie c : cookieJar.getCookies()) {
                         if (c.getName().equals("TSESSIONID")) {
@@ -125,8 +123,7 @@ public class WebSocketClient implements AutoCloseable {
                         }
                     }
                     if (null == sessionCookie) {
-                        throw new IllegalStateException(
-                                "Unable to find TSESSIONID cookie header in Timely login response");
+                        throw new IllegalStateException("Unable to find TSESSIONID cookie header in Timely login response");
                     }
                 } finally {
                     HttpClientUtils.closeQuietly(response);
@@ -142,8 +139,7 @@ public class WebSocketClient implements AutoCloseable {
         webSocketClient.getProperties().put(ClientProperties.SSL_ENGINE_CONFIGURATOR, sslEngine);
         webSocketClient.getProperties().put(ClientProperties.INCOMING_BUFFER_SIZE, bufferSize);
         String wssPath = "wss://" + timelyHostname + ":" + timelyWssPort + "/websocket";
-        session = webSocketClient.connectToServer(clientEndpoint,
-                new TimelyEndpointConfig(clientEndpoint, sessionCookie), new URI(wssPath));
+        session = webSocketClient.connectToServer(clientEndpoint, new TimelyEndpointConfig(clientEndpoint, sessionCookie), new URI(wssPath));
 
         final ByteBuffer pingData = ByteBuffer.allocate(0);
         webSocketClient.getScheduledExecutorService().scheduleAtFixedRate(() -> {

client/src/main/java/timely/client/websocket/subscription/WebSocketSubscriptionClient.java

@@ -13,6 +13,7 @@ import javax.websocket.DeploymentException;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+
 import timely.api.AddSubscription;
 import timely.api.CloseSubscription;
 import timely.api.CreateSubscription;
@@ -26,22 +27,18 @@ public class WebSocketSubscriptionClient extends WebSocketClient {
     private static final Logger LOG = LoggerFactory.getLogger(WebSocketSubscriptionClient.class);
     private final String subscriptionId;
 
-    public WebSocketSubscriptionClient(SSLContext ssl, String timelyHostname, int timelyHttpsPort, int timelyWssPort,
-            boolean clientAuth, boolean doLogin, String timelyUsername, String timelyPassword,
-            boolean hostVerificationEnabled, int bufferSize) {
-        super(ssl, timelyHostname, timelyHttpsPort, timelyWssPort, clientAuth, doLogin, timelyUsername, timelyPassword,
-                hostVerificationEnabled, bufferSize);
+    public WebSocketSubscriptionClient(SSLContext ssl, String timelyHostname, int timelyHttpsPort, int timelyWssPort, boolean clientAuth, boolean doLogin,
+                    String timelyUsername, String timelyPassword, boolean hostVerificationEnabled, int bufferSize) {
+        super(ssl, timelyHostname, timelyHttpsPort, timelyWssPort, clientAuth, doLogin, timelyUsername, timelyPassword, hostVerificationEnabled, bufferSize);
         subscriptionId = UUID.randomUUID().toString();
         LOG.trace("Created WebSocketClient with subscriptionId {}", this.subscriptionId);
     }
 
-    public WebSocketSubscriptionClient(String timelyHostname, int timelyHttpsPort, int timelyWssPort,
-            boolean clientAuth, boolean doLogin, String timelyUsername, String timelyPassword, String keyStoreFile,
-            String keyStoreType, String keyStorePass, String trustStoreFile, String trustStoreType,
-            String trustStorePass, boolean hostVerificationEnabled, int bufferSize) {
-        super(timelyHostname, timelyHttpsPort, timelyWssPort, clientAuth, doLogin, timelyUsername, timelyPassword,
-                keyStoreFile, keyStoreType, keyStorePass, trustStoreFile, trustStoreType, trustStorePass,
-                hostVerificationEnabled, bufferSize);
+    public WebSocketSubscriptionClient(String timelyHostname, int timelyHttpsPort, int timelyWssPort, boolean clientAuth, boolean doLogin,
+                    String timelyUsername, String timelyPassword, String keyStoreFile, String keyStoreType, String keyStorePass, String trustStoreFile,
+                    String trustStoreType, String trustStorePass, boolean hostVerificationEnabled, int bufferSize) {
+        super(timelyHostname, timelyHttpsPort, timelyWssPort, clientAuth, doLogin, timelyUsername, timelyPassword, keyStoreFile, keyStoreType, keyStorePass,
+                        trustStoreFile, trustStoreType, trustStorePass, hostVerificationEnabled, bufferSize);
         subscriptionId = UUID.randomUUID().toString();
         LOG.trace("Created WebSocketClient with subscriptionId {}", this.subscriptionId);
     }
@@ -69,8 +66,7 @@ public class WebSocketSubscriptionClient extends WebSocketClient {
         super.close();
     }
 
-    public Future<Void> addSubscription(String metric, Map<String, String> tags, long startTime, long endTime,
-            long delayTime) throws IOException {
+    public Future<Void> addSubscription(String metric, Map<String,String> tags, long startTime, long endTime, long delayTime) throws IOException {
         AddSubscription add = new AddSubscription();
         add.setSubscriptionId(subscriptionId);
         add.setMetric(metric);

client/src/main/java/timely/model/Metric.java

@@ -10,18 +10,18 @@ import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.annotation.JsonPropertyOrder;
 import com.fasterxml.jackson.annotation.JsonRootName;
 import com.fasterxml.jackson.annotation.JsonUnwrapped;
+
 import timely.model.parse.TagParser;
 
 /**
  * A Metric consists of a metric name, tags, and a Value
  *
- * Json has been flattened to reduce overhead. Example:
- * {"name":"m1","timestamp":1,"measure":1.0,"tags":[{"k1":"v1"}]}
+ * Json has been flattened to reduce overhead. Example: {"name":"m1","timestamp":1,"measure":1.0,"tags":[{"k1":"v1"}]}
  *
  */
 @JsonRootName("metric")
 @JsonInclude(JsonInclude.Include.NON_NULL)
-@JsonPropertyOrder({ "name" })
+@JsonPropertyOrder({"name"})
 public class Metric implements Serializable {
 
     private static final long serialVersionUID = 1L;
@@ -134,8 +134,7 @@ public class Metric implements Serializable {
     }
 
     /**
-     * Simple Builder for Metric. Note: cannot re-use a builder after build is
-     * called.
+     * Simple Builder for Metric. Note: cannot re-use a builder after build is called.
      */
     public static class Builder {
 

client/src/main/java/timely/model/ObjectSizeOf.java

@@ -2,12 +2,13 @@ package timely.model;
 
 import java.lang.reflect.Array;
 import java.lang.reflect.Field;
-import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.HashSet;
 import java.util.Set;
 import java.util.Stack;
-import java.util.logging.Logger;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * A simple interface that objects can implement to return the object size.
@@ -47,7 +48,7 @@ public interface ObjectSizeOf {
 
     public static class Sizer {
 
-        private static final Logger log = Logger.getLogger(Sizer.class.getCanonicalName());
+        private static final Logger LOG = LoggerFactory.getLogger(Sizer.class);
         public static final short OBJECT_OVERHEAD = 8;
         public static final short ARRAY_OVERHEAD = 12;
         public static final short REFERENCE = 4;
@@ -56,18 +57,14 @@ public interface ObjectSizeOf {
         public static final short NUMBER_SIZE = 16;
 
         /**
-         * Get the size of an object. Note that we want something relatively fast that
-         * gives us an order of magnitude here. The java Instrumentation agent mechanism
-         * is a little too costly for general use here. This will look for the
-         * ObjectSizeOf interface and if implemented on the object will use that.
+         * Get the size of an object. Note that we want something relatively fast that gives us an order of magnitude here. The java Instrumentation agent
+         * mechanism is a little too costly for general use here. This will look for the ObjectSizeOf interface and if implemented on the object will use that.
          * Otherwise it will do a simple navigation of the fields using reflection.
          *
-         * @param o
          * @return an approximation of the object size
          */
         public static long getObjectSize(Object o, boolean useSizeInBytesMethod, boolean debug) {
-            long estSize = getObjectSize(o, new HashSet<ObjectInstance>(), new Stack<ObjectInstance>(),
-                    useSizeInBytesMethod, debug);
+            long estSize = getObjectSize(o, new HashSet<ObjectInstance>(), new Stack<ObjectInstance>(), useSizeInBytesMethod, debug);
             return estSize;
         }
 
@@ -76,8 +73,7 @@ public interface ObjectSizeOf {
             return estSize;
         }
 
-        public static long getObjectSize(Object o, Set<ObjectInstance> visited, Stack<ObjectInstance> stack,
-                boolean useSizeInBytesMethod, boolean debug) {
+        public static long getObjectSize(Object o, Set<ObjectInstance> visited, Stack<ObjectInstance> stack, boolean useSizeInBytesMethod, boolean debug) {
             long totalSize = 0;
             stack.add(new ObjectInstance(o));
             while (!stack.isEmpty()) {
@@ -88,23 +84,16 @@ public interface ObjectSizeOf {
                     visited.add(oi);
                     try {
                         if (useSizeInBytesMethod) {
-                            try {
-                                if (o instanceof ObjectSizeOf) {
-                                    size = ((ObjectSizeOf) o).sizeInBytes();
-                                } else {
-                                    Method sizeInBytes = o.getClass().getMethod("sizeInBytes", (Class<?>[]) null);
-                                    size = (Long) sizeInBytes.invoke(o);
-                                }
-                            } catch (Throwable t) {
-                                // ok, lets do this the hard way...
+                            if (o instanceof ObjectSizeOf) {
+                                size = ((ObjectSizeOf) o).sizeInBytes();
                             }
                         }
                         if (size == 0) {
                             // the hard way...
                             // do not include Class related objects or
                             // reflection objects
-                            if ((o instanceof Class) || (o instanceof ClassLoader) || (o.getClass().getPackage() != null
-                                    && o.getClass().getPackage().getName().startsWith("java.lang.reflect"))) {
+                            if ((o instanceof Class) || (o instanceof ClassLoader)
+                                            || (o.getClass().getPackage() != null && o.getClass().getPackage().getName().startsWith("java.lang.reflect"))) {
                                 size = 0;
                             } else if (o instanceof Number || o instanceof Boolean || o instanceof Character) {
                                 size = NUMBER_SIZE;
@@ -159,7 +148,7 @@ public interface ObjectSizeOf {
                             }
                         }
                     } catch (Throwable t) {
-                        log.warning("Unable to determine object size for " + o);
+                        LOG.warn("Unable to determine object size for " + o, t);
                     }
                     if (debug) {
                         System.out.println(o.getClass().getCanonicalName() + "=" + size);

client/src/main/java/timely/model/Tag.java

@@ -5,13 +5,15 @@ import java.util.Map;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import org.apache.commons.lang3.builder.CompareToBuilder;
+import org.apache.commons.lang3.builder.EqualsBuilder;
+
 import com.fasterxml.jackson.annotation.JsonAnyGetter;
 import com.fasterxml.jackson.annotation.JsonAnySetter;
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonRootName;
 import com.google.common.base.Preconditions;
-import org.apache.commons.lang3.builder.CompareToBuilder;
-import org.apache.commons.lang3.builder.EqualsBuilder;
+
 import timely.model.parse.TagParser;
 
 /**
@@ -27,8 +29,7 @@ public class Tag implements Comparable<Tag>, Serializable {
     private String key;
     private String value;
 
-    public Tag() {
-    }
+    public Tag() {}
 
     public Tag(Tag other) {
         this.setKey(other.getKey());
@@ -47,7 +48,7 @@ public class Tag implements Comparable<Tag>, Serializable {
     }
 
     @JsonAnyGetter
-    public Map<String, String> get() {
+    public Map<String,String> get() {
         return Stream.of(this).collect(Collectors.toMap(Tag::getKey, Tag::getValue));
     }
 
@@ -77,8 +78,6 @@ public class Tag implements Comparable<Tag>, Serializable {
 
     /**
      * Joins key and value into key=value
-     * 
-     * @return
      */
     public String join() {
         return tagParser.combine(this);

client/src/main/java/timely/model/Value.java

@@ -18,8 +18,7 @@ public class Value implements Comparator<Value>, Serializable {
     private Long timestamp;
     private Double measure;
 
-    public Value() {
-    }
+    public Value() {}
 
     public Value(Value other) {
         this.setTimestamp(other.getTimestamp());
@@ -74,11 +73,9 @@ public class Value implements Comparator<Value>, Serializable {
         if (null == o || getClass() != o.getClass())
             return false;
 
-        if (getTimestamp() != null ? !getTimestamp().equals(((Value) o).getTimestamp())
-                : ((Value) o).getTimestamp() != null)
+        if (getTimestamp() != null ? !getTimestamp().equals(((Value) o).getTimestamp()) : ((Value) o).getTimestamp() != null)
             return false;
-        return !(getMeasure() != null ? !getMeasure().equals(((Value) o).getMeasure())
-                : ((Value) o).getMeasure() != null);
+        return !(getMeasure() != null ? !getMeasure().equals(((Value) o).getMeasure()) : ((Value) o).getMeasure() != null);
     }
 
     @Override

client/src/main/java/timely/model/parse/MetricParser.java

@@ -4,6 +4,7 @@ import java.util.List;
 
 import com.google.common.base.Preconditions;
 import com.google.common.base.Splitter;
+
 import timely.model.Metric;
 
 public class MetricParser implements Parser<Metric> {

client/src/main/java/timely/model/parse/TagListParser.java

@@ -8,8 +8,7 @@ import java.util.Map;
 import timely.model.Tag;
 
 /**
- * Parses tag1=val1,tag2=val2,tag3=val3 into a {@code List} of {@code Tag}
- * Combines {@code List} of {@code Tag} into {@code String} of
+ * Parses tag1=val1,tag2=val2,tag3=val3 into a {@code List} of {@code Tag} Combines {@code List} of {@code Tag} into {@code String} of
  * tag1=val1,tag2=val2,tag3=val3.
  */
 public class TagListParser implements Parser<List<Tag>>, Combiner<Collection<Tag>> {
@@ -44,13 +43,11 @@ public class TagListParser implements Parser<List<Tag>>, Combiner<Collection<Tag
     }
 
     /**
-     * An alternative combiner for a map of string to string instead of a list of
-     * tags
-     * 
-     * @param tags
+     * An alternative combiner for a map of string to string instead of a list of tags
+     *
      * @return string representation
      */
-    public String combine(Map<String, String> tags) {
+    public String combine(Map<String,String> tags) {
         StringBuilder builder = new StringBuilder();
         if (!tags.isEmpty()) {
             tags.forEach((k, v) -> builder.append(tagParser.combine(new Tag(k, v))).append(','));

client/src/main/java/timely/model/parse/TagParser.java

@@ -4,11 +4,11 @@ import java.util.List;
 
 import com.google.common.base.Joiner;
 import com.google.common.base.Splitter;
+
 import timely.model.Tag;
 
 /**
- * Parses tag1=val1 into a {@code Tag} Combines {@code Tag} into {@code String}
- * of tag1=val1
+ * Parses tag1=val1 into a {@code Tag} Combines {@code Tag} into {@code String} of tag1=val1
  */
 public class TagParser implements Parser<Tag>, Combiner<Tag> {
 

client/src/main/spotbugs/excludes.xml

@@ -5,4 +5,21 @@
     <Method name="connect" />
     <Class name="timely.client.tcp.TcpClient"/>
   </Match>
+  <Match>
+    <!-- Must ignore these everywhere, because of a javac byte code generation bug -->
+    <!-- https://github.com/spotbugs/spotbugs/issues/756 -->
+    <Bug pattern="RCN_REDUNDANT_NULLCHECK_WOULD_HAVE_BEEN_A_NPE" />
+  </Match>
+  <Match>
+    <!-- these are probably avoidable, but needs further triage to fix -->
+    <Bug pattern="MS_EXPOSE_REP" />
+  </Match>
+  <Match>
+    <!-- these are probably avoidable, but needs further triage to fix -->
+    <Bug pattern="EI_EXPOSE_REP" />
+  </Match>
+  <Match>
+    <!-- these are probably avoidable, but needs further triage to fix -->
+    <Bug pattern="EI_EXPOSE_REP2" />
+  </Match>
 </FindBugsFilter>

client/src/test/java/timely/api/SerializationTest.java

@@ -1,8 +1,10 @@
 package timely.api;
 
-import com.fasterxml.jackson.databind.ObjectMapper;
 import org.junit.Assert;
 import org.junit.Test;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
 import timely.serialize.JsonSerializer;
 
 public class SerializationTest {
@@ -47,9 +49,9 @@ public class SerializationTest {
         testSerialization(remove);
     }
 
-    @SuppressWarnings("unchecked")
     private <T> void testSerialization(T o) throws Exception {
         String ser = mapper.writeValueAsString(o);
+        @SuppressWarnings("unchecked")
         T des = mapper.readValue(ser, (Class<T>) o.getClass());
         Assert.assertEquals(o, des);
     }

client/src/test/java/timely/model/MetricTest.java

@@ -6,9 +6,10 @@ import static org.junit.Assert.assertTrue;
 
 import java.io.IOException;
 
-import com.fasterxml.jackson.databind.ObjectMapper;
 import org.junit.Test;
 
+import com.fasterxml.jackson.databind.ObjectMapper;
+
 /**
  *
  *
@@ -30,8 +31,7 @@ public class MetricTest {
         Metric m4 = Metric.newBuilder().name("m4").tag("t2", "v2").tag("t1", "v1").value(1, 0.0).build();
         assertFalse(m1.equals(m4));
 
-        Metric m5 = Metric.newBuilder().name("m1").tag("t3", "v3").tag("t2", "v2").tag("t1", "v1").value(1, 0.0)
-                .build();
+        Metric m5 = Metric.newBuilder().name("m1").tag("t3", "v3").tag("t2", "v2").tag("t1", "v1").value(1, 0.0).build();
         assertFalse(m1.equals(m5));
 
         Metric m6 = Metric.newBuilder().name("m1").tag("t2", "v2").tag("t1", "v1").value(2, 0.0).build();

client/src/test/java/timely/model/parse/MetricParserTest.java

@@ -5,6 +5,7 @@ import java.util.List;
 
 import org.junit.Assert;
 import org.junit.Test;
+
 import timely.model.Metric;
 import timely.model.Tag;
 

client/src/test/java/timely/model/parse/TagListParserTest.java

@@ -7,6 +7,7 @@ import java.util.TreeMap;
 
 import org.junit.Assert;
 import org.junit.Test;
+
 import timely.model.Tag;
 
 public class TagListParserTest {
@@ -31,7 +32,7 @@ public class TagListParserTest {
 
     @Test
     public void testListCombineMap() {
-        Map<String, String> map = new TreeMap<>();
+        Map<String,String> map = new TreeMap<>();
         map.put("tag1", "value1");
         map.put("tag2", "value2");
         String combined = new TagListParser().combine(map);

collectd-nsq-plugin/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>timely</groupId>
     <artifactId>timely</artifactId>
-    <version>1.2.1</version>
+    <version>2.0.2</version>
   </parent>
   <artifactId>collectd-nsq-plugin</artifactId>
   <dependencies>
@@ -34,6 +34,14 @@
           <artifactSet>
             <includes />
           </artifactSet>
+          <filters>
+            <filter>
+              <artifact>*:*</artifact>
+              <excludes>
+                <exclude>**/module-info.class</exclude>
+              </excludes>
+            </filter>
+          </filters>
           <createDependencyReducedPom>false</createDependencyReducedPom>
         </configuration>
         <executions>

collectd-nsq-plugin/src/main/java/timely/collectd/plugin/PooledCloseableHttpClientFactory.java

@@ -10,7 +10,7 @@ import org.apache.http.impl.client.CloseableHttpClient;
 import org.apache.http.impl.client.HttpClientBuilder;
 import org.collectd.api.OConfigItem;
 
-public class PooledCloseableHttpClientFactory implements PooledObjectFactory {
+public class PooledCloseableHttpClientFactory implements PooledObjectFactory<CloseableHttpClient> {
 
     private int connectionRequestTimeout = 10000; // 10 seconds in milliseconds
     private int connectTimeout = 30000; // 30 seconds in milliseconds
@@ -43,19 +43,19 @@ public class PooledCloseableHttpClientFactory implements PooledObjectFactory {
     }
 
     @Override
-    public PooledObject makeObject() throws Exception {
+    public PooledObject<CloseableHttpClient> makeObject() throws Exception {
         RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(connectionRequestTimeout)
                 .setConnectTimeout(connectTimeout).setSocketTimeout(socketTimeout).build();
         HttpClientBuilder builder = HttpClientBuilder.create();
         builder.setDefaultRequestConfig(requestConfig);
         builder.setConnectionTimeToLive(connectionTimeToLive, TimeUnit.MILLISECONDS);
-        return new DefaultPooledObject(builder.build());
+        return new DefaultPooledObject<>(builder.build());
     }
 
     @Override
-    public void destroyObject(PooledObject pooledObject) throws Exception {
+    public void destroyObject(PooledObject<CloseableHttpClient> pooledObject) throws Exception {
         try {
-            ((CloseableHttpClient) pooledObject.getObject()).close();
+            pooledObject.getObject().close();
         } catch (Exception e) {
             // do nothing
         } finally {
@@ -65,17 +65,17 @@ public class PooledCloseableHttpClientFactory implements PooledObjectFactory {
     }
 
     @Override
-    public boolean validateObject(PooledObject pooledObject) {
+    public boolean validateObject(PooledObject<CloseableHttpClient> pooledObject) {
         return pooledObject.getObject() != null;
     }
 
     @Override
-    public void activateObject(PooledObject pooledObject) throws Exception {
+    public void activateObject(PooledObject<CloseableHttpClient> pooledObject) throws Exception {
         // do nothing
     }
 
     @Override
-    public void passivateObject(PooledObject pooledObject) throws Exception {
+    public void passivateObject(PooledObject<CloseableHttpClient> pooledObject) throws Exception {
         // do nothing
     }
 

collectd-nsq-plugin/src/main/java/timely/collectd/plugin/WriteNSQPlugin.java

@@ -36,6 +36,7 @@ public class WriteNSQPlugin extends CollectDPluginParent
     private String topic = "metrics#ephemeral";
     private String endpoint = null;
     private GenericObjectPool<CloseableHttpClient> clientPool = null;
+    private Random random = new Random();
 
     // pool should be limited by the number of WriteThreads configured in
     // collectd
@@ -47,6 +48,7 @@ public class WriteNSQPlugin extends CollectDPluginParent
         Collectd.registerWrite(WriteNSQPlugin.class.getName(), this);
     }
 
+    @Override
     public int write(ValueList vl) {
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         DataOutputStream out = new DataOutputStream(baos);
@@ -87,11 +89,9 @@ public class WriteNSQPlugin extends CollectDPluginParent
             if (client != null) {
                 clientPool.returnObject(client);
             }
-            if (null != out) {
-                try {
-                    out.close();
-                } catch (IOException e) {
-                }
+            try {
+                out.close();
+            } catch (IOException e) {
             }
         }
         return 0;
@@ -110,15 +110,17 @@ public class WriteNSQPlugin extends CollectDPluginParent
         }
     }
 
+    @Override
     public int shutdown() {
         Collectd.logInfo("Shutting down connection to NSQ at " + host + ":" + port);
         clientPool.close();
         return 0;
     }
 
+    @Override
     public int config(OConfigItem config) {
         super.config(config);
-        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
+        GenericObjectPoolConfig<CloseableHttpClient> poolConfig = new GenericObjectPoolConfig<>();
         // use max size for maxTotal and maxIdle
         // no need to activate or passivate
         poolConfig.setMaxTotal(POOL_MAX_SIZE);
@@ -138,7 +140,7 @@ public class WriteNSQPlugin extends CollectDPluginParent
                     if (hosts.length == 1) {
                         host = hosts[0];
                     } else {
-                        host = hosts[new Random().nextInt(hosts.length)];
+                        host = hosts[random.nextInt(hosts.length)];
                     }
                     break;
                 case "Port":
@@ -156,7 +158,7 @@ public class WriteNSQPlugin extends CollectDPluginParent
             Collectd.logError("NSQ host, port, and topic must be configured");
             return -1;
         }
-        this.clientPool = new GenericObjectPool(pooledCloseableHttpClientFactory, poolConfig);
+        this.clientPool = new GenericObjectPool<>(pooledCloseableHttpClientFactory, poolConfig);
         this.endpoint = "http://" + host + ":" + port + "/mpub?topic=" + topic;
         return 0;
     }

collectd-plugin-parent/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>timely</groupId>
     <artifactId>timely</artifactId>
-    <version>1.2.1</version>
+    <version>2.0.2</version>
   </parent>
   <artifactId>collectd-plugin-parent</artifactId>
   <dependencies>

collectd-timely-plugin/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>timely</groupId>
     <artifactId>timely</artifactId>
-    <version>1.2.1</version>
+    <version>2.0.2</version>
   </parent>
   <artifactId>collectd-timely-plugin</artifactId>
   <dependencies>
@@ -51,6 +51,14 @@
           <artifactSet>
             <includes />
           </artifactSet>
+          <filters>
+            <filter>
+              <artifact>*:*</artifact>
+              <excludes>
+                <exclude>**/module-info.class</exclude>
+              </excludes>
+            </filter>
+          </filters>
           <createDependencyReducedPom>false</createDependencyReducedPom>
         </configuration>
         <executions>

collectd-timely-plugin/src/main/java/timely/collectd/plugin/PooledSocketFactory.java

@@ -8,7 +8,7 @@ import org.apache.commons.pool2.impl.DefaultPooledObject;
 import org.collectd.api.Collectd;
 import org.collectd.api.OConfigItem;
 
-public class PooledSocketFactory implements PooledObjectFactory {
+public class PooledSocketFactory implements PooledObjectFactory<Socket> {
 
     private String host = null;
     private int port = 0;
@@ -81,12 +81,12 @@ public class PooledSocketFactory implements PooledObjectFactory {
     }
 
     @Override
-    public PooledObject makeObject() throws Exception {
-        return new DefaultPooledObject(connect());
+    public PooledObject<Socket> makeObject() throws Exception {
+        return new DefaultPooledObject<>(connect());
     }
 
     @Override
-    public void destroyObject(PooledObject pooledObject) throws Exception {
+    public void destroyObject(PooledObject<Socket> pooledObject) throws Exception {
         try {
             Collectd.logDebug("Shutting down connection to Timely at " + host + ":" + port);
             Socket socket = (Socket) pooledObject.getObject();
@@ -103,7 +103,7 @@ public class PooledSocketFactory implements PooledObjectFactory {
     }
 
     @Override
-    public boolean validateObject(PooledObject pooledObject) {
+    public boolean validateObject(PooledObject<Socket> pooledObject) {
         if (connectionTimeToLive > -1) {
             if (System.currentTimeMillis() > pooledObject.getCreateTime() + connectionTimeToLive) {
                 return false;
@@ -114,12 +114,12 @@ public class PooledSocketFactory implements PooledObjectFactory {
     }
 
     @Override
-    public void activateObject(PooledObject pooledObject) throws Exception {
+    public void activateObject(PooledObject<Socket> pooledObject) throws Exception {
         // do nothing
     }
 
     @Override
-    public void passivateObject(PooledObject pooledObject) throws Exception {
+    public void passivateObject(PooledObject<Socket> pooledObject) throws Exception {
         // do nothing
     }
 }

collectd-timely-plugin/src/main/java/timely/collectd/plugin/WriteTimelyPlugin.java

@@ -86,13 +86,13 @@ public class WriteTimelyPlugin extends CollectDPluginParent
         PooledSocketFactory socketFactory = new PooledSocketFactory();
         retval = socketFactory.config(config);
         if (retval == 0) {
-            GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
+            GenericObjectPoolConfig<Socket> poolConfig = new GenericObjectPoolConfig<>();
             // use max size for maxTotal and maxIdle
             // no need to activate and passivate
             poolConfig.setMaxTotal(POOL_MAX_SIZE);
             poolConfig.setMaxIdle(POOL_MAX_SIZE);
             poolConfig.setTestOnReturn(true);
-            socketPool = new GenericObjectPool(socketFactory, poolConfig);
+            socketPool = new GenericObjectPool<>(socketFactory, poolConfig);
         }
         return retval;
     }

common/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>timely</groupId>
     <artifactId>timely</artifactId>
-    <version>1.2.1</version>
+    <version>2.0.2</version>
   </parent>
   <artifactId>timely-common</artifactId>
   <dependencies>

common/src/main/java/timely/test/IntegrationTest.java

@@ -1,4 +1,3 @@
 package timely.test;
 
-public interface IntegrationTest {
-}
+public interface IntegrationTest {}

grafana-auth/bin/grafana-auth.sh

@@ -1,43 +0,0 @@
-#!/bin/bash
-
-if [[ `uname` == "Darwin" ]]; then
-        THIS_SCRIPT=`python -c 'import os,sys; print os.path.realpath(sys.argv[1])' $0`
-        TCNATIVE_SUFFIX="jnilib"
-else
-        THIS_SCRIPT=`readlink -f $0`
-        TCNATIVE_SUFFIX="so"
-fi
-
-THIS_DIR="${THIS_SCRIPT%/*}"
-NATIVE_DIR="${THIS_DIR}/META-INF/native"
-BASE_DIR=${THIS_DIR}/..
-TMP_DIR="${BASE_DIR}/tmp"
-CONF_DIR="${BASE_DIR}/conf"
-LIB_DIR="${BASE_DIR}/lib"
-NUM_SERVER_THREADS=4
-
-if [[ -e ${TMP_DIR} ]]; then
-  rm -rf ${TMP_DIR}
-fi
-mkdir ${TMP_DIR}
-
-if [[ -e ${NATIVE_DIR} ]]; then
-  rm -rf ${NATIVE_DIR}
-fi
-mkdir -p ${NATIVE_DIR}
-
-pushd ${BASE_DIR}/bin
-$JAVA_HOME/bin/jar xf ${LIB_DIR}/netty-tcnative*.jar META-INF/native/libnetty_tcnative.${TCNATIVE_SUFFIX}
-$JAVA_HOME/bin/jar xf ${LIB_DIR}/netty-transport-native-epoll*.jar META-INF/native/libnetty_transport_native_epoll_x86_64.${TCNATIVE_SUFFIX}
-popd
-
-export CLASSPATH="${CONF_DIR}:${LIB_DIR}/*:${HADOOP_CONF_DIR}"
-JVM_ARGS="-Xmx1G -Xms1G -Dio.netty.eventLoopThreads=${NUM_SERVER_THREADS}"
-JVM_ARGS="${JVM_ARGS} -DLog4jContextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector"
-JVM_ARGS="${JVM_ARGS} -Djava.library.path=${NATIVE_DIR}"
-JVM_ARGS="${JVM_ARGS} -Djava.library.path=${NATIVE_DIR}/libnetty-${TCNATIVE_SUFFIX}"
-
-#JVM_ARGS="${JVM_ARGS} -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005"
-
-echo "$JAVA_HOME/bin/java ${JVM_ARGS} timely.grafana.auth.GrafanaAuth --spring.config.name=grafana-auth"
-$JAVA_HOME/bin/java ${JVM_ARGS} timely.grafana.auth.GrafanaAuth --spring.config.name=grafana-auth

grafana-auth/conf/grafana-auth.yml

@@ -1,53 +0,0 @@
-grafana-auth:
-  grafana:
-    host: localhost
-    port: 3001
-  security:
-    session-max-age: 86400
-    allow-anonymous-http-access: true
-    allow-anonymous-ws-access: true
-    serverSsl:
-      certificate-file:
-      key-file:
-      #key-password:
-      use-generated-keypair: true
-      trust-store-file:
-      use-openssl: true
-      #use-ciphers:
-    clientSsl:
-      keyFile:
-      keyType: pkcs12
-      #keyPassword:
-      trustStoreFile:
-      trustStoreType: jks
-      #trustStorePassword:
-  http:
-    host: localhost
-    ip: 127.0.0.1
-    port: 3000
-    redirect-path: /secure-me
-    strict-transport-max-age: 608400
-    cors:
-      allow-any-origin: false
-      allow-null-origin: false
-      allow-credentials: true
-      allowed-origins:
-      allowed-methods: DELETE,GET,HEAD,OPTIONS,PUT,POST
-      allowed-headers: content-type
-    httpClientPool:
-      minIdlePerKey: 0
-      maxIdlePerKey: 40
-      maxTotalPerKey: 40
-      maxTotal: -1
-      lifo: true
-      fairness: false
-      maxWaitMillis: -1
-      minEvictableIdleTimeMillis: 1800000
-      evictorShutdownTimeoutMillis: 10000
-      softMinEvictableIdleTimeMillis: -1
-      numTestsPerEvictionRun: 3
-      timeBetweenEvictionRunsMillis: -1
-      blockWhenExhausted: true
-      jmxEnabled: true
-      testOnBorrow: false
-      testOnReturn: false

grafana-auth/conf/log4j2-error-console.xml

@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Configuration status="warn" monitorInterval="60">
-  <Appenders>
-    <Console name="Console" target="SYSTEM_OUT">
-      <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
-    </Console>
-  </Appenders>
-  <Loggers>
-    <Root level="error" includeLocation="false">
-      <AppenderRef ref="Console" level="error" />
-    </Root>
-  </Loggers>
-</Configuration>

grafana-auth/conf/log4j2-spring.xml

@@ -1,29 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Configuration status="warn" monitorInterval="60">
-  <Properties>
-    <Property name="PID">????</Property>
-    <Property name="LOG_PATTERN">%clr{%d{yyyy-MM-dd HH:mm:ss.SSS}}{faint} %clr{%5p} %clr{${sys:PID}}{magenta} %clr{---}{faint} %clr{[%15.15t]}{faint} %clr{%-40.40c{1.}}{cyan} %clr{:}{faint} %m%n%wEx</Property>
-  </Properties>
-  <Appenders>
-    <RollingRandomAccessFile name="Rolling" fileName="/srv/logs/timely/grafana-auth.log"
-    						 filePattern="/srv/logs/timely/$${date:yyyy-MM}/grafana-auth-%d{MM-dd-yyyy}-%i.log.gz">
-      <PatternLayout pattern="${LOG_PATTERN}"/>
-      <Policies>
-      	<SizeBasedTriggeringPolicy size="1024 MB" />
-      </Policies>
-      <DefaultRolloverStrategy max="10" />
-    </RollingRandomAccessFile>
-    <Console name="Console" target="SYSTEM_OUT">
-      <PatternLayout pattern="${LOG_PATTERN}"/>
-    </Console>
-  </Appenders>
-  <Loggers>
-    <Root level="trace" includeLocation="false">
-      <AppenderRef ref="Console" level="warn" />
-      <AppenderRef ref="Rolling" level="trace" />
-    </Root>
-    <Logger name="timely" additivity="false">
-      <AppenderRef ref="Console" level="debug" />
-    </Logger>
-  </Loggers>
-</Configuration>

grafana-auth/conf/security.xml

@@ -1,71 +0,0 @@
-<beans:beans xmlns="http://www.springframework.org/schema/security"
-             xmlns:beans="http://www.springframework.org/schema/beans"
-             xmlns:util="http://www.springframework.org/schema/util"
-             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-             xsi:schemaLocation="http://www.springframework.org/schema/beans
-								 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
-								 http://www.springframework.org/schema/security
-								 http://www.springframework.org/schema/security/spring-security.xsd
-								 http://www.springframework.org/schema/util
-								 http://www.springframework.org/schema/util/spring-util.xsd">
-		          
-	<beans:bean id="x509PrincipalExtractor" class="org.springframework.security.web.authentication.preauth.x509.SubjectDnX509PrincipalExtractor">
-		<beans:property name="subjectDnRegex" value="CN=(.*?)(?:,|$)"/>
-	</beans:bean>
-
-	<beans:bean id="timelyUserDetailsService" class="timely.auth.UserDetailsService">
-		<beans:property name="users">
-			<util:list>
-				<beans:bean class="timely.auth.TimelyUser">
-					<beans:constructor-arg name="subjectDn">
-						<beans:value>CN=example.com</beans:value>
-					</beans:constructor-arg>
-					<beans:constructor-arg name="auths">
-						<util:list>
-							<beans:value>D</beans:value>
-							<beans:value>E</beans:value>
-							<beans:value>F</beans:value>
-						</util:list>
-					</beans:constructor-arg>
-					<beans:constructor-arg name="roles">
-						<util:list>
-							<beans:value>G</beans:value>
-							<beans:value>H</beans:value>
-							<beans:value>I</beans:value>
-						</util:list>
-					</beans:constructor-arg>
-				</beans:bean>
-			</util:list>
-		</beans:property>
-	</beans:bean>
-    
-    <beans:bean id="x509AuthorizationProvider" class="org.springframework.security.web.authentication.preauth.PreAuthenticatedAuthenticationProvider">
-    	<beans:property name="preAuthenticatedUserDetailsService" ref="timelyUserDetailsService" />
-    </beans:bean>
-    
-    <user-service id="usernamePasswordService">
-    	<user name="test" password="test1" authorities="A,B,C" />
-    </user-service>
-
-	<beans:bean id="noOpPasswordEncoder" class="org.springframework.security.crypto.password.NoOpPasswordEncoder"/>
-
-	<beans:bean id="UserNamePasswordAuthenticationProvider" class="org.springframework.security.authentication.dao.DaoAuthenticationProvider">
-		<beans:property name="userDetailsService" ref="usernamePasswordService"/>
-		<beans:property name="passwordEncoder" ref="noOpPasswordEncoder"/>
-	</beans:bean>
-	    
-	<authentication-manager alias="authenticationManager">
-		<!-- X509 PreAuthenticated authorization provider -->
-		<authentication-provider ref="x509AuthorizationProvider"/>
-		<!-- Basic authorization provider, validates provided username and password -->
-		<authentication-provider ref="UserNamePasswordAuthenticationProvider" />
-	</authentication-manager>
-
-	<util:list id="requiredRoles" value-type="java.lang.String">
-		<beans:value></beans:value>
-	</util:list>
-
-	<util:list id="requiredAuths" value-type="java.lang.String">
-		<beans:value></beans:value>
-	</util:list>
-</beans:beans>

grafana-auth/pom.xml

@@ -1,331 +0,0 @@
-<?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>
-  <parent>
-    <groupId>timely</groupId>
-    <artifactId>timely</artifactId>
-    <version>1.2.1</version>
-  </parent>
-  <artifactId>grafana-auth</artifactId>
-  <dependencies>
-    <dependency>
-      <groupId>com.fasterxml.jackson.core</groupId>
-      <artifactId>jackson-annotations</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>com.fasterxml.jackson.core</groupId>
-      <artifactId>jackson-core</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>com.fasterxml.jackson.core</groupId>
-      <artifactId>jackson-databind</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>com.fasterxml.jackson.datatype</groupId>
-      <artifactId>jackson-datatype-jdk8</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>com.github.ben-manes.caffeine</groupId>
-      <artifactId>caffeine</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>com.google.flatbuffers</groupId>
-      <artifactId>flatbuffers-java</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>commons-beanutils</groupId>
-      <artifactId>commons-beanutils</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>io.github.lukehutch</groupId>
-      <artifactId>fast-classpath-scanner</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>io.netty</groupId>
-      <artifactId>netty-all</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>net.sourceforge.javacsv</groupId>
-      <artifactId>javacsv</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.accumulo</groupId>
-      <artifactId>accumulo-core</artifactId>
-      <exclusions>
-        <exclusion>
-          <groupId>org.slf4j</groupId>
-          <artifactId>slf4j-log4j12</artifactId>
-        </exclusion>
-      </exclusions>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.accumulo</groupId>
-      <artifactId>accumulo-minicluster</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.commons</groupId>
-      <artifactId>commons-collections4</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.commons</groupId>
-      <artifactId>commons-lang3</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.commons</groupId>
-      <artifactId>commons-pool2</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.curator</groupId>
-      <artifactId>curator-client</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.curator</groupId>
-      <artifactId>curator-framework</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.curator</groupId>
-      <artifactId>curator-recipes</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.curator</groupId>
-      <artifactId>curator-x-discovery</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.hadoop</groupId>
-      <artifactId>hadoop-client</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.hadoop</groupId>
-      <artifactId>hadoop-common</artifactId>
-      <exclusions>
-        <exclusion>
-          <groupId>jdk.tools</groupId>
-          <artifactId>jdk.tools</artifactId>
-        </exclusion>
-      </exclusions>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.hadoop</groupId>
-      <artifactId>hadoop-minicluster</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>org.slf4j</groupId>
-      <artifactId>slf4j-api</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>org.springframework</groupId>
-      <artifactId>spring-websocket</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>org.springframework.boot</groupId>
-      <artifactId>spring-boot-starter</artifactId>
-      <exclusions>
-        <exclusion>
-          <groupId>org.springframework.boot</groupId>
-          <artifactId>spring-boot-starter-logging</artifactId>
-        </exclusion>
-      </exclusions>
-    </dependency>
-    <dependency>
-      <groupId>org.springframework.boot</groupId>
-      <artifactId>spring-boot-starter-log4j2</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>org.springframework.boot</groupId>
-      <artifactId>spring-boot-starter-validation</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>org.springframework.security</groupId>
-      <artifactId>spring-security-config</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>org.springframework.security</groupId>
-      <artifactId>spring-security-web</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>timely</groupId>
-      <artifactId>timely-balancer</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>timely</groupId>
-      <artifactId>timely-client</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>timely</groupId>
-      <artifactId>timely-common</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>timely</groupId>
-      <artifactId>timely-server</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>com.lmax</groupId>
-      <artifactId>disruptor</artifactId>
-      <scope>runtime</scope>
-    </dependency>
-    <dependency>
-      <groupId>io.netty</groupId>
-      <artifactId>netty-tcnative</artifactId>
-      <version>${version.netty-tcnative}</version>
-      <classifier>${os.detected.classifier}</classifier>
-      <scope>runtime</scope>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.logging.log4j</groupId>
-      <artifactId>log4j-api</artifactId>
-      <scope>runtime</scope>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.logging.log4j</groupId>
-      <artifactId>log4j-core</artifactId>
-      <scope>runtime</scope>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.logging.log4j</groupId>
-      <artifactId>log4j-slf4j-impl</artifactId>
-      <scope>runtime</scope>
-    </dependency>
-    <dependency>
-      <groupId>org.javassist</groupId>
-      <artifactId>javassist</artifactId>
-      <scope>runtime</scope>
-    </dependency>
-    <dependency>
-      <groupId>junit</groupId>
-      <artifactId>junit</artifactId>
-      <scope>test</scope>
-    </dependency>
-    <dependency>
-      <groupId>org.jsoup</groupId>
-      <artifactId>jsoup</artifactId>
-      <scope>test</scope>
-    </dependency>
-    <dependency>
-      <groupId>org.springframework.boot</groupId>
-      <artifactId>spring-boot-test-autoconfigure</artifactId>
-      <scope>test</scope>
-    </dependency>
-  </dependencies>
-  <build>
-    <plugins>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-assembly-plugin</artifactId>
-        <executions>
-          <execution>
-            <id>assemble</id>
-            <goals>
-              <goal>single</goal>
-            </goals>
-            <phase>package</phase>
-            <configuration>
-              <descriptors>
-                <descriptor>src/main/dist/assembly.xml</descriptor>
-              </descriptors>
-            </configuration>
-          </execution>
-        </executions>
-      </plugin>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-dependency-plugin</artifactId>
-        <executions>
-          <execution>
-            <id>copy-dependencies</id>
-            <goals>
-              <goal>copy-dependencies</goal>
-            </goals>
-            <phase>prepare-package</phase>
-            <configuration>
-              <excludeArtifactIds>junit</excludeArtifactIds>
-              <outputDirectory>${project.build.directory}/lib</outputDirectory>
-            </configuration>
-          </execution>
-          <execution>
-            <id>unpack-native</id>
-            <goals>
-              <goal>unpack</goal>
-            </goals>
-            <phase>process-test-classes</phase>
-            <configuration>
-              <artifactItems>
-                <artifactItem>
-                  <groupId>io.netty</groupId>
-                  <artifactId>netty-tcnative</artifactId>
-                  <version>${version.netty-tcnative}</version>
-                  <classifier>${os.detected.classifier}</classifier>
-                  <type>jar</type>
-                  <overWrite>false</overWrite>
-                  <outputDirectory>${project.build.directory}/native</outputDirectory>
-                  <includes>**/*.so</includes>
-                </artifactItem>
-              </artifactItems>
-            </configuration>
-          </execution>
-        </executions>
-      </plugin>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-failsafe-plugin</artifactId>
-      </plugin>
-      <plugin>
-        <groupId>org.codehaus.mojo</groupId>
-        <artifactId>build-helper-maven-plugin</artifactId>
-        <executions>
-          <execution>
-            <id>add-source</id>
-            <goals>
-              <goal>add-source</goal>
-            </goals>
-            <phase>generate-sources</phase>
-            <configuration>
-              <sources>
-                <source>src/main/generated-java</source>
-              </sources>
-            </configuration>
-          </execution>
-        </executions>
-      </plugin>
-    </plugins>
-    <extensions>
-      <!-- Use os-maven-plugin to initialize the "os.detected" properties -->
-      <extension>
-        <groupId>kr.motd.maven</groupId>
-        <artifactId>os-maven-plugin</artifactId>
-      </extension>
-    </extensions>
-  </build>
-  <profiles>
-    <profile>
-      <id>native-epoll-linux</id>
-      <activation>
-        <os>
-          <family>!mac</family>
-        </os>
-      </activation>
-      <dependencies>
-        <dependency>
-          <groupId>io.netty</groupId>
-          <artifactId>netty-transport-native-epoll</artifactId>
-          <version>${version.netty}</version>
-          <classifier>linux-x86_64</classifier>
-        </dependency>
-      </dependencies>
-    </profile>
-    <profile>
-      <id>native-epoll</id>
-      <activation>
-        <os>
-          <family>mac</family>
-        </os>
-      </activation>
-      <dependencies>
-        <dependency>
-          <groupId>io.netty</groupId>
-          <artifactId>netty-transport-native-epoll</artifactId>
-          <version>${version.netty}</version>
-        </dependency>
-      </dependencies>
-    </profile>
-  </profiles>
-</project>

grafana-auth/src/main/dist/assembly.xml

@@ -1,55 +0,0 @@
-<assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.3" 
-  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-  xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.3 http://maven.apache.org/xsd/assembly-1.1.3.xsd">
-  <id>dist</id>
-  <formats>
-    <format>tar.gz</format>
-  </formats>
-  <fileSets>
-    <fileSet>
-      <directory>${project.basedir}</directory>
-      <outputDirectory></outputDirectory>
-      <includes>
-        <include>README*</include>
-        <include>LICENSE*</include>
-        <include>NOTICE*</include>
-      </includes>
-    </fileSet>
-    <fileSet>
-      <directory>${project.build.directory}</directory>
-      <outputDirectory>lib</outputDirectory>
-      <includes>
-        <include>timely*.jar</include>
-        <include>grafana*.jar</include>
-      </includes>
-    </fileSet>
-    <fileSet>
-      <directory>${project.build.directory}/lib</directory>
-      <outputDirectory>lib</outputDirectory>
-      <includes>
-        <include>*.jar</include>
-      </includes>
-     </fileSet>
-    <fileSet>
-      <directory>${project.basedir}/bin</directory>
-      <outputDirectory>bin</outputDirectory>
-      <includes>
-        <include>**/*</include>
-      </includes>
-     </fileSet>
-    <fileSet>
-      <directory>${project.basedir}/conf</directory>
-      <outputDirectory>conf</outputDirectory>
-      <includes>
-        <include>*</include>
-      </includes>
-     </fileSet>
-	<fileSet>
-	  <directory>${project.basedir}/src/main/resources/webapp</directory>
-	  <outputDirectory>bin/webapp</outputDirectory>
-	  <includes>
-		<include>*</include>
-	  </includes>
-	</fileSet>
-  </fileSets>
-</assembly>

grafana-auth/src/main/java/timely/grafana/auth/GrafanaAuth.java

@@ -1,321 +0,0 @@
-package timely.grafana.auth;
-
-import java.io.File;
-import java.net.InetSocketAddress;
-import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-
-import javax.net.ssl.SSLContext;
-
-import io.netty.bootstrap.ServerBootstrap;
-import io.netty.buffer.PooledByteBufAllocator;
-import io.netty.channel.Channel;
-import io.netty.channel.ChannelFuture;
-import io.netty.channel.ChannelHandler;
-import io.netty.channel.ChannelInitializer;
-import io.netty.channel.ChannelOption;
-import io.netty.channel.EventLoopGroup;
-import io.netty.channel.epoll.EpollEventLoopGroup;
-import io.netty.channel.epoll.EpollServerSocketChannel;
-import io.netty.channel.nio.NioEventLoopGroup;
-import io.netty.channel.socket.ServerSocketChannel;
-import io.netty.channel.socket.SocketChannel;
-import io.netty.channel.socket.nio.NioServerSocketChannel;
-import io.netty.handler.codec.http.HttpContentCompressor;
-import io.netty.handler.codec.http.HttpContentDecompressor;
-import io.netty.handler.codec.http.HttpObjectAggregator;
-import io.netty.handler.codec.http.HttpRequestDecoder;
-import io.netty.handler.codec.http.HttpResponseEncoder;
-import io.netty.handler.logging.LoggingHandler;
-import io.netty.handler.ssl.ClientAuth;
-import io.netty.handler.ssl.OpenSslServerContext;
-import io.netty.handler.ssl.OpenSslServerSessionContext;
-import io.netty.handler.ssl.SslContext;
-import io.netty.handler.ssl.SslContextBuilder;
-import io.netty.handler.ssl.SslProvider;
-import io.netty.handler.ssl.util.SelfSignedCertificate;
-import io.netty.handler.stream.ChunkedWriteHandler;
-import io.netty.util.internal.SystemPropertyUtil;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.boot.WebApplicationType;
-import org.springframework.boot.builder.SpringApplicationBuilder;
-import org.springframework.context.ConfigurableApplicationContext;
-import timely.auth.AuthCache;
-import timely.balancer.configuration.ClientSsl;
-import timely.balancer.connection.http.HttpClientPool;
-import timely.client.http.HttpClient;
-import timely.configuration.ServerSsl;
-import timely.grafana.auth.configuration.GrafanaAuthConfiguration;
-import timely.grafana.auth.configuration.SpringBootstrap;
-import timely.grafana.auth.netty.http.GrafanaRelayHandler;
-import timely.grafana.auth.netty.http.GrafanaRequestDecoder;
-import timely.netty.http.HttpStaticFileServerHandler;
-import timely.netty.http.NonSslRedirectHandler;
-import timely.netty.http.TimelyExceptionHandler;
-import timely.netty.http.auth.X509LoginRequestHandler;
-
-public class GrafanaAuth {
-
-    private static final Logger LOG = LoggerFactory.getLogger(GrafanaAuth.class);
-    private static final int EPOLL_MIN_MAJOR_VERSION = 2;
-    private static final int EPOLL_MIN_MINOR_VERSION = 6;
-    private static final int EPOLL_MIN_PATCH_VERSION = 32;
-    private static final String OS_NAME = "os.name";
-    private static final String OS_VERSION = "os.version";
-    protected static final CountDownLatch LATCH = new CountDownLatch(1);
-    static ConfigurableApplicationContext applicationContext;
-
-    private final GrafanaAuthConfiguration grafanaAuthConfig;
-    private EventLoopGroup httpWorkerGroup = null;
-    private EventLoopGroup httpBossGroup = null;
-    protected Channel httpChannelHandle = null;
-    protected volatile boolean shutdown = false;
-
-    public GrafanaAuth(GrafanaAuthConfiguration grafanaAuthConfig) throws Exception {
-        this.grafanaAuthConfig = grafanaAuthConfig;
-    }
-
-    protected static ConfigurableApplicationContext initializeConfiguration(String[] args) {
-        return new SpringApplicationBuilder(SpringBootstrap.class).web(WebApplicationType.NONE).run(args);
-    }
-
-    private void shutdownHook() {
-
-        final Runnable shutdownRunner = () -> {
-            if (!shutdown) {
-                shutdown();
-            }
-        };
-        final Thread hook = new Thread(shutdownRunner, "shutdown-hook-thread");
-        Runtime.getRuntime().addShutdownHook(hook);
-    }
-
-    public void shutdown() {
-        List<ChannelFuture> channelFutures = new ArrayList<>();
-
-        if (httpChannelHandle != null) {
-            LOG.info("Closing httpChannelHandle");
-            channelFutures.add(httpChannelHandle.close());
-        }
-
-        // wait for the channels to shutdown
-        channelFutures.forEach(f -> {
-            try {
-                f.get();
-            } catch (final Exception e) {
-                LOG.error("Error while shutting down channel: {}", f.channel().config());
-                LOG.error("{}", e.getMessage());
-                e.printStackTrace();
-            }
-        });
-
-        Integer quietPeriod = grafanaAuthConfig.getShutdownQuietPeriod();
-        List<Future<?>> groupFutures = new ArrayList<>();
-
-        if (httpBossGroup != null) {
-            LOG.info("Shutting down httpBossGroup");
-            groupFutures.add(httpBossGroup.shutdownGracefully(quietPeriod, 10, TimeUnit.SECONDS));
-        }
-
-        if (httpWorkerGroup != null) {
-            LOG.info("Shutting down httpWorkerGroup");
-            groupFutures.add(httpWorkerGroup.shutdownGracefully(quietPeriod, 10, TimeUnit.SECONDS));
-        }
-
-        groupFutures.parallelStream().forEach(f -> {
-            try {
-                f.get();
-            } catch (final Exception e) {
-                LOG.error("Error while shutting down group: {}", f.toString());
-                LOG.error("{}", e.getMessage());
-                e.printStackTrace();
-            }
-        });
-
-        if (applicationContext != null) {
-            LOG.info("Closing applicationContext");
-            applicationContext.close();
-        }
-
-        this.shutdown = true;
-        LOG.info("Server shut down.");
-    }
-
-    private static boolean useEpoll() {
-
-        // Should we just return true if this is Linux and if we get an error
-        // during Epoll
-        // setup handle it there?
-        final String os = SystemPropertyUtil.get(OS_NAME).toLowerCase().trim();
-        final String[] version = SystemPropertyUtil.get(OS_VERSION).toLowerCase().trim().split("\\.");
-        if (os.startsWith("linux") && version.length >= 3) {
-            final int major = Integer.parseInt(version[0]);
-            if (major > EPOLL_MIN_MAJOR_VERSION) {
-                return true;
-            } else if (major == EPOLL_MIN_MAJOR_VERSION) {
-                final int minor = Integer.parseInt(version[1]);
-                if (minor > EPOLL_MIN_MINOR_VERSION) {
-                    return true;
-                } else if (minor == EPOLL_MIN_MINOR_VERSION) {
-                    final int patch = Integer.parseInt(version[2].substring(0, 2));
-                    return patch >= EPOLL_MIN_PATCH_VERSION;
-                } else {
-                    return false;
-                }
-            } else {
-                return false;
-            }
-        } else {
-            return false;
-        }
-    }
-
-    protected SslContext createSSLContext(GrafanaAuthConfiguration config) throws Exception {
-
-        ServerSsl sslCfg = config.getSecurity().getServerSsl();
-        Boolean generate = sslCfg.isUseGeneratedKeypair();
-        SslContextBuilder ssl;
-        if (generate) {
-            LOG.warn("Using generated self signed server certificate");
-            Date begin = new Date();
-            Date end = new Date(begin.getTime() + 86400000);
-            SelfSignedCertificate ssc = new SelfSignedCertificate("localhost", begin, end);
-            ssl = SslContextBuilder.forServer(ssc.certificate(), ssc.privateKey());
-        } else {
-            String cert = sslCfg.getCertificateFile();
-            String key = sslCfg.getKeyFile();
-            String keyPass = sslCfg.getKeyPassword();
-            if (null == cert || null == key) {
-                throw new IllegalArgumentException("Check your SSL properties, something is wrong.");
-            }
-            ssl = SslContextBuilder.forServer(new File(cert), new File(key), keyPass);
-        }
-
-        ssl.ciphers(sslCfg.getUseCiphers());
-
-        // Can't set to REQUIRE because the CORS pre-flight requests will fail.
-        ssl.clientAuth(ClientAuth.OPTIONAL);
-
-        Boolean useOpenSSL = sslCfg.isUseOpenssl();
-        if (useOpenSSL) {
-            ssl.sslProvider(SslProvider.OPENSSL);
-        } else {
-            ssl.sslProvider(SslProvider.JDK);
-        }
-        String trustStore = sslCfg.getTrustStoreFile();
-        if (null != trustStore) {
-            if (!trustStore.isEmpty()) {
-                ssl.trustManager(new File(trustStore));
-            }
-        }
-        return ssl.build();
-    }
-
-    protected SSLContext createSSLClientContext(GrafanaAuthConfiguration config) throws Exception {
-
-        ClientSsl ssl = config.getSecurity().getClientSsl();
-        return HttpClient.getSSLContext(ssl.getTrustStoreFile(), ssl.getTrustStoreType(), ssl.getTrustStorePassword(),
-                ssl.getKeyFile(), ssl.getKeyType(), ssl.getKeyPassword());
-    }
-
-    public void run() throws Exception {
-
-        AuthCache.setSessionMaxAge(grafanaAuthConfig.getSecurity());
-        final boolean useEpoll = useEpoll();
-        Class<? extends ServerSocketChannel> channelClass;
-        if (useEpoll) {
-            httpWorkerGroup = new EpollEventLoopGroup();
-            httpBossGroup = new EpollEventLoopGroup();
-            channelClass = EpollServerSocketChannel.class;
-        } else {
-            httpWorkerGroup = new NioEventLoopGroup();
-            httpBossGroup = new NioEventLoopGroup();
-            channelClass = NioServerSocketChannel.class;
-        }
-        LOG.info("Using channel class {}", channelClass.getSimpleName());
-
-        final int httpPort = grafanaAuthConfig.getHttp().getPort();
-        final String httpIp = grafanaAuthConfig.getHttp().getIp();
-        SslContext sslCtx = createSSLContext(grafanaAuthConfig);
-        if (sslCtx instanceof OpenSslServerContext) {
-            OpenSslServerContext openssl = (OpenSslServerContext) sslCtx;
-            String application = "GrafanaAuth_" + httpPort;
-            OpenSslServerSessionContext opensslCtx = openssl.sessionContext();
-            opensslCtx.setSessionCacheEnabled(true);
-            opensslCtx.setSessionCacheSize(128);
-            opensslCtx.setSessionIdContext(application.getBytes(StandardCharsets.UTF_8));
-            opensslCtx.setSessionTimeout(grafanaAuthConfig.getSecurity().getSessionMaxAge());
-        }
-        SSLContext clientSSLContext = createSSLClientContext(grafanaAuthConfig);
-        final ServerBootstrap httpServer = new ServerBootstrap();
-        httpServer.group(httpBossGroup, httpWorkerGroup);
-        httpServer.channel(channelClass);
-        httpServer.handler(new LoggingHandler());
-        HttpClientPool httpClientPool = new HttpClientPool(grafanaAuthConfig.getSecurity(), grafanaAuthConfig.getHttp(),
-                clientSSLContext);
-        httpServer.childHandler(setupHttpChannel(grafanaAuthConfig, sslCtx, httpClientPool));
-        httpServer.option(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT);
-        httpServer.option(ChannelOption.SO_BACKLOG, 128);
-        httpServer.option(ChannelOption.SO_KEEPALIVE, true);
-        httpChannelHandle = httpServer.bind(httpIp, httpPort).sync().channel();
-        final String httpAddress = ((InetSocketAddress) httpChannelHandle.localAddress()).getAddress().getHostAddress();
-
-        shutdownHook();
-        LOG.info("Server started. Listening on {}:{} for HTTP traffic", httpAddress, httpPort);
-    }
-
-    public static void main(String[] args) throws Exception {
-
-        GrafanaAuth.applicationContext = GrafanaAuth.initializeConfiguration(args);
-        GrafanaAuthConfiguration balancerConf = applicationContext.getBean(GrafanaAuthConfiguration.class);
-
-        GrafanaAuth b = new GrafanaAuth(balancerConf);
-        try {
-            b.run();
-            LATCH.await();
-        } catch (final InterruptedException e) {
-            LOG.info("Server shutting down.");
-        } catch (Exception e) {
-            LOG.error("Error running server.", e);
-        } finally {
-            try {
-                b.shutdown();
-            } catch (Exception e) {
-                System.exit(1);
-            }
-        }
-    }
-
-    protected ChannelHandler setupHttpChannel(GrafanaAuthConfiguration config, SslContext sslCtx,
-            HttpClientPool httpClientPool) {
-
-        return new ChannelInitializer<SocketChannel>() {
-
-            @Override
-            protected void initChannel(SocketChannel ch) throws Exception {
-
-                ch.pipeline().addLast("ssl", new NonSslRedirectHandler(config.getHttp(), sslCtx));
-                ch.pipeline().addLast("encoder", new HttpResponseEncoder());
-                ch.pipeline().addLast("decoder", new HttpRequestDecoder());
-                ch.pipeline().addLast("compressor", new HttpContentCompressor());
-                ch.pipeline().addLast("decompressor", new HttpContentDecompressor());
-                // high maximum contentLength so that grafana snapshots can be delivered
-                // might not be necessary if inbound chunking (while proxying) is handled
-                ch.pipeline().addLast("aggregator", new HttpObjectAggregator(2097152));
-                ch.pipeline().addLast("chunker", new ChunkedWriteHandler());
-                ch.pipeline().addLast("grafanaDecoder",
-                        new GrafanaRequestDecoder(config.getSecurity(), config.getHttp()));
-                ch.pipeline().addLast("fileServer", new HttpStaticFileServerHandler());
-                ch.pipeline().addLast("login", new X509LoginRequestHandler(config.getSecurity(), config.getHttp()));
-                ch.pipeline().addLast("httpRelay", new GrafanaRelayHandler(config, httpClientPool));
-                ch.pipeline().addLast("error", new TimelyExceptionHandler());
-            }
-        };
-    }
-}

grafana-auth/src/main/java/timely/grafana/auth/configuration/Grafana.java

@@ -1,32 +0,0 @@
-package timely.grafana.auth.configuration;
-
-public class Grafana {
-
-    private String host = "localhost";
-    private Integer port = 3000;
-    private String protocol = "http";
-
-    public void setHost(String host) {
-        this.host = host;
-    }
-
-    public String getHost() {
-        return host;
-    }
-
-    public void setPort(Integer port) {
-        this.port = port;
-    }
-
-    public Integer getPort() {
-        return port;
-    }
-
-    public void setProtocol(String protocol) {
-        this.protocol = protocol;
-    }
-
-    public String getProtocol() {
-        return protocol;
-    }
-}

grafana-auth/src/main/java/timely/grafana/auth/configuration/GrafanaAuthConfiguration.java

@@ -1,56 +0,0 @@
-package timely.grafana.auth.configuration;
-
-import javax.validation.Valid;
-
-import org.springframework.boot.context.properties.ConfigurationProperties;
-import org.springframework.boot.context.properties.NestedConfigurationProperty;
-import org.springframework.stereotype.Component;
-import org.springframework.validation.annotation.Validated;
-import timely.balancer.configuration.BalancerHttp;
-import timely.balancer.configuration.BalancerSecurity;
-
-@Validated
-@Component
-@ConfigurationProperties(prefix = "grafana-auth")
-public class GrafanaAuthConfiguration {
-
-    @Valid
-    @NestedConfigurationProperty
-    private BalancerHttp http = new BalancerHttp();
-
-    @Valid
-    @NestedConfigurationProperty
-    private BalancerSecurity security = new BalancerSecurity();
-
-    @Valid
-    @NestedConfigurationProperty
-    private Grafana grafana = new Grafana();
-
-    private Integer shutdownQuietPeriod = 5;
-
-    public BalancerSecurity getSecurity() {
-        return security;
-    }
-
-    public BalancerHttp getHttp() {
-        return http;
-    }
-
-    public Grafana getGrafana() {
-        return grafana;
-    }
-
-    /**
-     * Time to wait (in seconds) for connections to finish and to make sure no new
-     * connections happen before shutting down Netty event loop groups.
-     *
-     * @return
-     */
-    public int getShutdownQuietPeriod() {
-        return this.shutdownQuietPeriod;
-    }
-
-    public void setShutdownQuietPeriod(Integer quietPeriod) {
-        this.shutdownQuietPeriod = quietPeriod;
-    }
-}

grafana-auth/src/main/java/timely/grafana/auth/configuration/SpringBootstrap.java

@@ -1,7 +0,0 @@
-package timely.grafana.auth.configuration;
-
-import org.springframework.boot.autoconfigure.SpringBootApplication;
-
-@SpringBootApplication(scanBasePackageClasses = { SpringBootstrap.class })
-public class SpringBootstrap {
-}

grafana-auth/src/main/java/timely/grafana/auth/netty/http/GrafanaRelayHandler.java

@@ -1,234 +0,0 @@
-package timely.grafana.auth.netty.http;
-
-import static io.netty.handler.codec.http.HttpHeaders.Names.CONTENT_LENGTH;
-
-import java.io.ByteArrayOutputStream;
-import java.net.URLEncoder;
-import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-
-import com.google.common.collect.Multimap;
-import io.netty.buffer.Unpooled;
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.channel.SimpleChannelInboundHandler;
-import io.netty.handler.codec.http.DefaultFullHttpResponse;
-import io.netty.handler.codec.http.FullHttpRequest;
-import io.netty.handler.codec.http.FullHttpResponse;
-import io.netty.handler.codec.http.HttpMethod;
-import io.netty.handler.codec.http.HttpResponseStatus;
-import io.netty.handler.codec.http.HttpVersion;
-import io.netty.util.ReferenceCountUtil;
-import org.apache.http.Header;
-import org.apache.http.HttpEntity;
-import org.apache.http.client.methods.CloseableHttpResponse;
-import org.apache.http.client.methods.HttpDelete;
-import org.apache.http.client.methods.HttpGet;
-import org.apache.http.client.methods.HttpHead;
-import org.apache.http.client.methods.HttpOptions;
-import org.apache.http.client.methods.HttpPost;
-import org.apache.http.client.methods.HttpPut;
-import org.apache.http.entity.StringEntity;
-import org.apache.http.impl.client.CloseableHttpClient;
-import org.apache.http.message.BasicHeader;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.util.StreamUtils;
-import timely.api.request.timeseries.HttpRequest;
-import timely.api.response.TimelyException;
-import timely.auth.TimelyPrincipal;
-import timely.auth.TimelyUser;
-import timely.auth.util.DnUtils;
-import timely.auth.util.HttpHeaderUtils;
-import timely.balancer.connection.TimelyBalancedHost;
-import timely.balancer.connection.http.HttpClientPool;
-import timely.grafana.auth.configuration.GrafanaAuthConfiguration;
-import timely.grafana.request.GrafanaRequest;
-import timely.netty.http.TimelyHttpHandler;
-import timely.netty.http.auth.TimelyAuthenticationToken;
-
-public class GrafanaRelayHandler extends SimpleChannelInboundHandler<HttpRequest> implements TimelyHttpHandler {
-
-    private static final Logger LOG = LoggerFactory.getLogger(GrafanaRelayHandler.class);
-    private final HttpClientPool httpClientPool;
-    private GrafanaAuthConfiguration config;
-
-    public GrafanaRelayHandler(GrafanaAuthConfiguration config, HttpClientPool httpClientPool) {
-        this.config = config;
-        this.httpClientPool = httpClientPool;
-    }
-
-    @Override
-    public void channelRead0(ChannelHandlerContext ctx, HttpRequest msg) throws Exception {
-
-        CloseableHttpClient client = null;
-        CloseableHttpResponse relayedResponse = null;
-        FullHttpRequest request = null;
-        GrafanaRequest grafanaRequest;
-        TimelyBalancedHost k = null;
-        String relayURI = null;
-        try {
-            try {
-                request = msg.getHttpRequest();
-                String originalURI = request.getUri();
-                originalURI = encodeURI(originalURI);
-
-                if (msg instanceof GrafanaRequest) {
-                    grafanaRequest = (GrafanaRequest) msg;
-                } else {
-                    throw new UnsupportedOperationException("Request not supported");
-                }
-                TimelyAuthenticationToken token = grafanaRequest.getToken();
-                if (token == null) {
-                    throw new IllegalStateException("No token on grafana request");
-                }
-
-                String protocol = config.getGrafana().getProtocol();
-                String host = config.getGrafana().getHost();
-                Integer port = config.getGrafana().getPort();
-                k = TimelyBalancedHost.of(host, -1, port, -1, -1);
-                client = httpClientPool.borrowObject(k);
-                Multimap<String, String> headers = HttpHeaderUtils.toMultimap(request.headers());
-
-                // If incoming user sets these headers, do not relay them
-                headers.removeAll("X-WEBAUTH-USER");
-                headers.removeAll("X-WEBAUTH-NAME");
-                TimelyPrincipal principal = token.getTimelyPrincipal();
-                TimelyUser user = principal.getPrimaryUser();
-                String subjectDn = user.getDn().subjectDN();
-                String userName = DnUtils.getCommonName(subjectDn);
-                String loginName = DnUtils.getShortName(subjectDn);
-                headers.put("X-WEBAUTH-USER", loginName);
-                headers.put("X-WEBAUTH-NAME", userName);
-                List<Header> relayedHeaderList = new ArrayList<>();
-                for (Map.Entry<String, String> h : headers.entries()) {
-                    if (!h.getKey().equals(CONTENT_LENGTH)) {
-                        relayedHeaderList.add(new BasicHeader(h.getKey(), h.getValue()));
-                    }
-                }
-                Header[] headerArray = new Header[relayedHeaderList.size()];
-                relayedHeaderList.toArray(headerArray);
-                relayURI = protocol + "://" + host + ":" + port + originalURI;
-                if (request.getMethod().equals(HttpMethod.HEAD)) {
-                    HttpHead relayedRequest = new HttpHead(relayURI);
-                    if (headerArray.length > 0) {
-                        relayedRequest.setHeaders(headerArray);
-                    }
-                    relayedResponse = client.execute(relayedRequest);
-                } else if (request.getMethod().equals(HttpMethod.GET)) {
-                    HttpGet relayedRequest = new HttpGet(relayURI);
-                    if (headerArray.length > 0) {
-                        relayedRequest.setHeaders(headerArray);
-                    }
-                    relayedResponse = client.execute(relayedRequest);
-                } else if (request.getMethod().equals(HttpMethod.POST)) {
-                    HttpPost relayedRequest = new HttpPost(relayURI);
-                    String content = request.content().toString(StandardCharsets.UTF_8);
-                    StringEntity entity = new StringEntity(content);
-                    relayedRequest.setEntity(entity);
-                    if (headerArray.length > 0) {
-                        relayedRequest.setHeaders(headerArray);
-                    }
-                    relayedResponse = client.execute(relayedRequest);
-                } else if (request.getMethod().equals(HttpMethod.PUT)) {
-                    HttpPut relayedRequest = new HttpPut(relayURI);
-                    String content = request.content().toString(StandardCharsets.UTF_8);
-                    StringEntity entity = new StringEntity(content);
-                    relayedRequest.setEntity(entity);
-                    if (headerArray.length > 0) {
-                        relayedRequest.setHeaders(headerArray);
-                    }
-                    relayedResponse = client.execute(relayedRequest);
-                } else if (request.getMethod().equals(HttpMethod.DELETE)) {
-                    HttpDelete relayedRequest = new HttpDelete(relayURI);
-                    if (headerArray.length > 0) {
-                        relayedRequest.setHeaders(headerArray);
-                    }
-                    relayedResponse = client.execute(relayedRequest);
-                } else if (request.getMethod().equals(HttpMethod.OPTIONS)) {
-                    HttpOptions relayedRequest = new HttpOptions(relayURI);
-                    if (headerArray.length > 0) {
-                        relayedRequest.setHeaders(headerArray);
-                    }
-                    relayedResponse = client.execute(relayedRequest);
-                }
-            } catch (Exception e) {
-                String message = e.getMessage();
-                if (message == null) {
-                    LOG.error("", e);
-                } else {
-                    LOG.error(message, e);
-                }
-                this.sendHttpError(ctx, new TimelyException(HttpResponseStatus.INTERNAL_SERVER_ERROR.code(),
-                        e.getMessage(), e.getLocalizedMessage(), e));
-                return;
-            } finally {
-                if (request != null && request instanceof AutoCloseable) {
-                    ReferenceCountUtil.release(request);
-                }
-            }
-
-            FullHttpResponse response = null;
-            if (relayedResponse == null) {
-                this.sendHttpError(ctx, new TimelyException(HttpResponseStatus.METHOD_NOT_ALLOWED.code(),
-                        "Method not allowed", "Method not allowed"));
-            } else {
-                LOG.debug("RequestURL:{} ResponseCode:{}", relayURI, relayedResponse.getStatusLine().getStatusCode());
-                HttpEntity httpEntity = relayedResponse.getEntity();
-                if (httpEntity == null) {
-                    response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1,
-                            HttpResponseStatus.valueOf(relayedResponse.getStatusLine().getStatusCode()));
-                } else {
-                    ByteArrayOutputStream baos = new MyByteArrayOutputStream();
-                    StreamUtils.copy(httpEntity.getContent(), baos);
-                    response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1,
-                            HttpResponseStatus.valueOf(relayedResponse.getStatusLine().getStatusCode()),
-                            Unpooled.copiedBuffer(baos.toByteArray()));
-                    response.headers().set(CONTENT_LENGTH, response.content().readableBytes());
-                }
-                for (Header h : relayedResponse.getAllHeaders()) {
-                    response.headers().add(h.getName(), h.getValue());
-                }
-                sendResponse(ctx, response);
-            }
-        } finally {
-            if (relayedResponse != null) {
-                relayedResponse.close();
-            }
-            if (client != null && k != null) {
-                httpClientPool.returnObject(k, client);
-            } else {
-                LOG.error("NOT RETURNING CONNECTION! " + msg.getHttpRequest().getUri());
-            }
-        }
-    }
-
-    static public class MyByteArrayOutputStream extends ByteArrayOutputStream {
-
-        public MyByteArrayOutputStream() {
-        }
-
-        public MyByteArrayOutputStream(int size) {
-            super(size);
-        }
-
-        public int getCount() {
-            return count;
-        }
-
-        public byte[] getBuf() {
-            return buf;
-        }
-    }
-
-    static public String encodeURI(String s) {
-        try {
-            s = s.replaceAll("\\{", URLEncoder.encode("{", "UTF-8"));
-            s = s.replaceAll("\\}", URLEncoder.encode("}", "UTF-8"));
-        } catch (Exception e) {
-
-        }
-        return s;
-    }
-}

grafana-auth/src/main/java/timely/grafana/auth/netty/http/GrafanaRequestDecoder.java

@@ -1,133 +0,0 @@
-package timely.grafana.auth.netty.http;
-
-import java.security.cert.X509Certificate;
-import java.util.Collection;
-import java.util.List;
-
-import com.google.common.collect.Multimap;
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.handler.codec.MessageToMessageDecoder;
-import io.netty.handler.codec.http.FullHttpRequest;
-import io.netty.handler.codec.http.HttpHeaders.Names;
-import io.netty.handler.codec.http.QueryStringDecoder;
-import io.netty.handler.codec.http.cookie.ServerCookieDecoder;
-import org.apache.commons.lang3.StringUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import timely.api.request.AuthenticatedRequest;
-import timely.api.request.timeseries.HttpRequest;
-import timely.api.response.StrictTransportResponse;
-import timely.api.response.TimelyException;
-import timely.auth.AuthCache;
-import timely.auth.AuthenticationService;
-import timely.auth.SubjectIssuerDNPair;
-import timely.auth.TimelyPrincipal;
-import timely.auth.util.HttpHeaderUtils;
-import timely.configuration.Http;
-import timely.configuration.Security;
-import timely.grafana.request.GrafanaRequest;
-import timely.netty.Constants;
-import timely.netty.http.TimelyHttpHandler;
-import timely.netty.http.auth.TimelyAuthenticationToken;
-
-public class GrafanaRequestDecoder extends MessageToMessageDecoder<FullHttpRequest> implements TimelyHttpHandler {
-
-    private static final Logger LOG = LoggerFactory.getLogger(GrafanaRequestDecoder.class);
-    private static final String LOG_RECEIVED_REQUEST = "Received HTTP request {}";
-    private static final String LOG_PARSED_REQUEST = "Parsed request {}";
-
-    private final Security security;
-    private final String nonSecureRedirectAddress;
-
-    public GrafanaRequestDecoder(Security security, Http http) {
-
-        this.security = security;
-        this.nonSecureRedirectAddress = http.getRedirectPath();
-    }
-
-    public static String getSessionId(FullHttpRequest msg) {
-        Multimap<String, String> headers = HttpHeaderUtils.toMultimap(msg.headers());
-        Collection<String> cookies = headers.get(Names.COOKIE);
-        final StringBuilder buf = new StringBuilder();
-        cookies.forEach(h -> {
-            ServerCookieDecoder.STRICT.decode(h).forEach(c -> {
-                if (c.name().equals(Constants.COOKIE_NAME)) {
-                    if (buf.length() == 0) {
-                        buf.append(c.value());
-                    }
-                }
-            });
-        });
-        if (buf.length() == 0) {
-            return null;
-        } else {
-            return buf.toString();
-        }
-    }
-
-    @Override
-    protected void decode(ChannelHandlerContext ctx, FullHttpRequest msg, List<Object> out) throws Exception {
-
-        LOG.trace(LOG_RECEIVED_REQUEST, msg);
-
-        final String uri = msg.getUri();
-        final QueryStringDecoder decoder = new QueryStringDecoder(uri);
-        if (decoder.path().equals(nonSecureRedirectAddress)) {
-            out.add(new StrictTransportResponse());
-            return;
-        }
-
-        final String sessionId = getSessionId(msg);
-        LOG.trace("SessionID: " + sessionId);
-
-        HttpRequest request;
-        try {
-            request = new GrafanaRequest();
-            Multimap<String, String> headers = HttpHeaderUtils.toMultimap(msg.headers());
-            ((AuthenticatedRequest) request).addHeaders(headers);
-            X509Certificate clientCert = AuthenticationService.getClientCertificate(ctx);
-            TimelyAuthenticationToken token;
-            if (StringUtils.isNotBlank(sessionId)) {
-                TimelyPrincipal principal;
-                ((AuthenticatedRequest) request).setSessionId(sessionId);
-                if (AuthCache.containsKey(sessionId)) {
-                    principal = AuthCache.get(sessionId);
-                } else {
-                    principal = TimelyPrincipal.anonymousPrincipal();
-                }
-                SubjectIssuerDNPair dn = principal.getPrimaryUser().getDn();
-                token = AuthenticationService.getAuthenticationToken(null, dn.subjectDN(), dn.issuerDN());
-            } else if (clientCert != null) {
-                token = AuthenticationService.getAuthenticationToken(clientCert, headers);
-            } else {
-                SubjectIssuerDNPair dn = TimelyPrincipal.anonymousPrincipal().getPrimaryUser().getDn();
-                token = AuthenticationService.getAuthenticationToken(null, dn.subjectDN(), dn.issuerDN());
-            }
-            ((AuthenticatedRequest) request).setToken(token);
-            request.setHttpRequest(msg.copy());
-            LOG.trace(LOG_PARSED_REQUEST, request);
-            request.validate();
-            out.add(request);
-        } catch (UnsupportedOperationException | NullPointerException e) {
-            // Return the original http request to route to the static file
-            // server
-            msg.retain();
-            out.add(msg);
-            return;
-        }
-        try {
-            try {
-                AuthenticationService.enforceAccess((AuthenticatedRequest) request);
-            } catch (TimelyException e) {
-                if (!security.isAllowAnonymousHttpAccess()) {
-                    throw e;
-                }
-            }
-        } catch (Exception e) {
-            out.clear();
-            throw e;
-        }
-
-    }
-
-}

grafana-auth/src/main/java/timely/grafana/request/GrafanaRequest.java

@@ -1,32 +0,0 @@
-package timely.grafana.request;
-
-import io.netty.handler.codec.http.FullHttpRequest;
-import io.netty.handler.codec.http.QueryStringDecoder;
-import timely.api.annotation.Http;
-import timely.api.request.AuthenticatedRequest;
-import timely.api.request.HttpGetRequest;
-import timely.api.request.HttpPostRequest;
-
-@Http(path = "/")
-public class GrafanaRequest extends AuthenticatedRequest implements HttpGetRequest, HttpPostRequest {
-
-    private FullHttpRequest httpRequest = null;
-
-    @Override
-    public HttpGetRequest parseQueryParameters(QueryStringDecoder decoder) throws Exception {
-        return new GrafanaRequest();
-    }
-
-    @Override
-    public HttpPostRequest parseBody(String content) throws Exception {
-        return new GrafanaRequest();
-    }
-
-    public void setHttpRequest(FullHttpRequest httpRequest) {
-        this.httpRequest = httpRequest;
-    }
-
-    public FullHttpRequest getHttpRequest() {
-        return httpRequest;
-    }
-}

grafana-auth/src/main/spotbugs/excludes.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<FindBugsFilter>
-  <Match>
-    <Class name="timely.grafana.auth.netty.http.GrafanaRelayHandler$MyByteArrayOutputStream" />
-    <Method name="getBuf" />
-    <Bug pattern="EI_EXPOSE_REP" />
-  </Match>
-</FindBugsFilter>

grafana/assembly.xml

@@ -7,7 +7,7 @@
   </formats>
   <fileSets>
     <fileSet>
-      <directory>timely-app</directory>
+      <directory>timely-app/dist</directory>
       <outputDirectory>timely-app</outputDirectory>
     </fileSet>
   </fileSets>

grafana/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>timely</groupId>
     <artifactId>timely</artifactId>
-    <version>1.2.1</version>
+    <version>2.0.2</version>
   </parent>
   <artifactId>timely-app</artifactId>
   <packaging>pom</packaging>

grafana/timely-app/.prettierrc.js

@@ -0,0 +1,3 @@
+module.exports = {
+  ...require('@grafana/toolkit/src/config/prettier.plugin.config.json'),
+};

grafana/timely-app/Gruntfile.js

@@ -1,65 +0,0 @@
-module.exports = function(grunt) {
-
-  require('load-grunt-tasks')(grunt);
-
-  grunt.loadNpmTasks('grunt-execute');
-  grunt.loadNpmTasks('grunt-contrib-clean');
-
-  grunt.initConfig({
-
-    clean: ["dist"],
-
-    copy: {
-      src_to_dist: {
-        cwd: 'src',
-        expand: true,
-        src: ['**/*', '!**/*.js', '!**/*.scss'],
-        dest: 'dist'
-      },
-      img_to_dist: {
-        cwd: 'src',
-        expand: true,
-        src: ['img/*'],
-        dest: 'dist/src/'
-      },
-      pluginDef: {
-        expand: true,
-        src: ['plugin.json', 'README.md'],
-        dest: 'dist',
-      }
-    },
-    watch: {
-      rebuild_all: {
-        files: ['src/**/*', 'plugin.json', 'README.md'],
-        tasks: ['default'],
-        options: {spawn: false}
-      },
-    },
-
-    babel: {
-      options: {
-        sourceMap: true,
-        presets:  ["es2015"],
-        plugins: ['transform-es2015-modules-systemjs', "transform-es2015-for-of"],
-      },
-      dist: {
-        files: [{
-          cwd: 'src',
-          expand: true,
-          src: ['**/*.js'],
-          dest: 'dist',
-          ext:'.js'
-        }]
-      },
-    }
-
-  });
-
-  grunt.registerTask('default',
-  ['clean',
-  'copy:src_to_dist',
-  'copy:pluginDef',
-  'copy:img_to_dist',
-  'babel'
-]);
-};