diff --git a/be/CMakeLists.txt b/be/CMakeLists.txt
index 251ed8f846c087..9597102b9a1748 100644
--- a/be/CMakeLists.txt
+++ b/be/CMakeLists.txt
@@ -51,7 +51,7 @@ set(OUTPUT_DIR "${BASE_DIR}/output")
 if (DEFINED ENV{PALO_LLVM_HOME})
     set(LLVM_HOME "$ENV{PALO_LLVM_HOME}")
 else()
-    set(LLVM_HOME "${THIRDPARTY_DIR}")
+    set(LLVM_HOME "${THIRDPARTY_DIR}/llvm")
 endif()
 set(LLVM_BIN "${LLVM_HOME}/bin")
 
@@ -102,7 +102,7 @@ find_package(Boost 1.55.0 REQUIRED COMPONENTS thread regex filesystem system dat
 include_directories(${Boost_INCLUDE_DIRS})
 message(STATUS ${Boost_LIBRARIES})
 
-set(GPERFTOOLS_HOME "${THIRDPARTY_DIR}")
+set(GPERFTOOLS_HOME "${THIRDPARTY_DIR}/gperftools")
 
 # Set all libraries
 add_library(gflags STATIC IMPORTED)
@@ -256,7 +256,7 @@ set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -std=gnu++11")
 set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-deprecated -Wno-vla")
 set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -DBOOST_DATE_TIME_POSIX_TIME_STD_CONFIG")
 set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -DBOOST_SYSTEM_NO_DEPRECATED")
-set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -msse4.2 -D_GLIBCXX_USE_CXX11_ABI=0")
+set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -msse4.2")
 set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -DLLVM_ON_UNIX")
 
 # for bprc
@@ -443,7 +443,6 @@ set(PALO_LINK_LIBS
     Gutil
     Olap
     Runtime
-    RPC
     Service
     Udf
     Util
@@ -539,7 +538,6 @@ add_subdirectory(${SRC_DIR}/exprs)
 add_subdirectory(${SRC_DIR}/udf)
 add_subdirectory(${SRC_DIR}/runtime)
 add_subdirectory(${SRC_DIR}/testutil)
-add_subdirectory(${SRC_DIR}/rpc)
 
 # Utility CMake function to make specifying tests and benchmarks less verbose
 FUNCTION(ADD_BE_TEST TEST_NAME)
diff --git a/be/src/agent/heartbeat_server.cpp b/be/src/agent/heartbeat_server.cpp
index 3ccab0bc8b6c4e..5a862a098875c8 100644
--- a/be/src/agent/heartbeat_server.cpp
+++ b/be/src/agent/heartbeat_server.cpp
@@ -118,7 +118,7 @@ void HeartbeatServer::heartbeat(
     if (status == PALO_SUCCESS) {
         backend_info.__set_be_port(config::be_port);
         backend_info.__set_http_port(config::webserver_port);
-        backend_info.__set_be_rpc_port(config::be_rpc_port);
+        backend_info.__set_be_rpc_port(-1);
         backend_info.__set_brpc_port(config::brpc_port);
     } else {
         status_code = TStatusCode::RUNTIME_ERROR;
diff --git a/be/src/agent/task_worker_pool.cpp b/be/src/agent/task_worker_pool.cpp
index fec026a3682e88..8ec8ad850138e5 100644
--- a/be/src/agent/task_worker_pool.cpp
+++ b/be/src/agent/task_worker_pool.cpp
@@ -39,6 +39,7 @@
 #include "common/resource_tls.h"
 #include "agent/cgroups_mgr.h"
 #include "service/backend_options.h"
+#include "util/palo_metrics.h"
 
 using std::deque;
 using std::list;
@@ -60,7 +61,7 @@ const uint32_t REPORT_DISK_STATE_WORKER_COUNT = 1;
 const uint32_t REPORT_OLAP_TABLE_WORKER_COUNT = 1;
 const uint32_t LIST_REMOTE_FILE_TIMEOUT = 15;
 const std::string HTTP_REQUEST_PREFIX = "/api/_tablet/_download?";
-const std::string HTTP_REQUEST_TOKEN_PARAM = "&token=";
+const std::string HTTP_REQUEST_TOKEN_PARAM = "token=";
 const std::string HTTP_REQUEST_FILE_PARAM = "&file=";
 
 std::atomic_ulong TaskWorkerPool::_s_report_version(time(NULL) * 10000);
@@ -284,12 +285,14 @@ void TaskWorkerPool::_finish_task(const TFinishTaskRequest& finish_task_request)
     int32_t try_time = 0;
 
     while (try_time < TASK_FINISH_MAX_RETRY) {
+        PaloMetrics::finish_task_requests_total.increment(1);
         AgentStatus client_status = _master_client->finish_task(finish_task_request, &result);
 
         if (client_status == PALO_SUCCESS) {
             OLAP_LOG_INFO("finish task success.result: %d", result.status.status_code);
             break;
         } else {
+            PaloMetrics::finish_task_requests_failed.increment(1);
             OLAP_LOG_WARNING("finish task failed.result: %d", result.status.status_code);
             try_time += 1;
         }
@@ -818,6 +821,8 @@ void* TaskWorkerPool::_clone_worker_thread_callback(void* arg_this) {
             clone_req = agent_task_req.clone_req;
             worker_pool_this->_tasks.pop_front();
         }
+
+        PaloMetrics::clone_requests_total.increment(1);
         // Try to register to cgroups_mgr
         CgroupsMgr::apply_system_cgroup();
         OLAP_LOG_INFO("get clone task. signature: %ld", agent_task_req.signature);
@@ -971,6 +976,7 @@ void* TaskWorkerPool::_clone_worker_thread_callback(void* arg_this) {
 
         TStatusCode::type status_code = TStatusCode::OK;
         if (status != PALO_SUCCESS && status != PALO_CREATE_TABLE_EXIST) {
+            PaloMetrics::clone_requests_failed.increment(1);
             status_code = TStatusCode::RUNTIME_ERROR;
             OLAP_LOG_WARNING("clone failed. signature: %ld",
                              agent_task_req.signature);
@@ -1506,6 +1512,8 @@ void* TaskWorkerPool::_report_task_worker_thread_callback(void* arg_this) {
         OLAP_LOG_INFO("master host: %s, port: %d",
                       worker_pool_this->_master_info.network_address.hostname.c_str(),
                       worker_pool_this->_master_info.network_address.port);
+
+        PaloMetrics::report_task_requests_total.increment(1);
         TMasterResult result;
         AgentStatus status = worker_pool_this->_master_client->report(request, &result);
 
@@ -1513,6 +1521,7 @@ void* TaskWorkerPool::_report_task_worker_thread_callback(void* arg_this) {
             OLAP_LOG_INFO("finish report task success. return code: %d",
                           result.status.status_code);
         } else {
+            PaloMetrics::report_task_requests_failed.increment(1);
             OLAP_LOG_WARNING("finish report task failed. status: %d", status);
         }
 
@@ -1557,6 +1566,7 @@ void* TaskWorkerPool::_report_disk_state_worker_thread_callback(void* arg_this)
         }
         request.__set_disks(disks);
 
+        PaloMetrics::report_disk_requests_total.increment(1);
         TMasterResult result;
         AgentStatus status = worker_pool_this->_master_client->report(request, &result);
 
@@ -1564,6 +1574,7 @@ void* TaskWorkerPool::_report_disk_state_worker_thread_callback(void* arg_this)
             OLAP_LOG_INFO("finish report disk state success. return code: %d",
                           result.status.status_code);
         } else {
+            PaloMetrics::report_disk_requests_failed.increment(1);
             OLAP_LOG_WARNING("finish report disk state failed. status: %d", status);
         }
 
@@ -1631,6 +1642,7 @@ void* TaskWorkerPool::_report_olap_table_worker_thread_callback(void* arg_this)
             OLAP_LOG_INFO("finish report olap table success. return code: %d",
                           result.status.status_code);
         } else {
+            PaloMetrics::report_all_tablets_requests_failed.increment(1);
             OLAP_LOG_WARNING("finish report olap table failed. status: %d", status);
         }
 
diff --git a/be/src/common/config.h b/be/src/common/config.h
index f382c18aa17d27..71a6a4137afb53 100644
--- a/be/src/common/config.h
+++ b/be/src/common/config.h
@@ -29,7 +29,6 @@ namespace config {
     CONF_Int32(cluster_id, "-1");
     // port on which ImpalaInternalService is exported
     CONF_Int32(be_port, "9060");
-    CONF_Int32(be_rpc_port, "10060");
 
     // port for brpc
     CONF_Int32(brpc_port, "8060");
@@ -197,8 +196,8 @@ namespace config {
     CONF_Bool(dump_ir, "false");
     // if set, saves the generated IR to the output file.
     CONF_String(module_output, "");
-    // memory_limiation_per_thread_for_schema_change unit GB
-    CONF_Int32(memory_limiation_per_thread_for_schema_change, "2");
+    // memory_limitation_per_thread_for_schema_change unit GB
+    CONF_Int32(memory_limitation_per_thread_for_schema_change, "2");
 
     CONF_Int64(max_unpacked_row_block_size, "104857600");
 
@@ -247,15 +246,9 @@ namespace config {
     // Interface to start debug webserver on. If blank, webserver binds to 0.0.0.0
     CONF_String(webserver_interface, "");
     CONF_String(webserver_doc_root, "${PALO_HOME}");
+    CONF_Int32(webserver_num_workers, "5");
     // If true, webserver may serve static files from the webserver_doc_root
     CONF_Bool(enable_webserver_doc_root, "true");
-    // The number of times to retry connecting to an RPC server. If zero or less,
-    // connections will be retried until successful
-    CONF_Int32(rpc_retry_times, "10");
-    // The interval, in ms, between retrying connections to an RPC server
-    CONF_Int32(rpc_retry_interval_ms, "30000");
-    //reactor number
-    CONF_Int32(rpc_reactor_threads, "10")
     // Period to update rate counters and sampling counters in ms.
     CONF_Int32(periodic_counter_update_period_ms, "500");
 
diff --git a/be/src/common/status.cpp b/be/src/common/status.cpp
index 9e5bf3bc9aa2fc..e7b8361bb704c3 100644
--- a/be/src/common/status.cpp
+++ b/be/src/common/status.cpp
@@ -44,6 +44,14 @@ Status::ErrorDetail::ErrorDetail(const TStatus& status) :
     DCHECK_NE(error_code, TStatusCode::OK);
 }
 
+Status::ErrorDetail::ErrorDetail(const PStatus& pstatus)
+        : error_code((TStatusCode::type)pstatus.status_code()) {
+    DCHECK_NE(error_code, TStatusCode::OK);
+    for (auto& msg : pstatus.error_msgs()) {
+        error_msgs.push_back(msg);
+    }
+}
+
 Status::Status(const std::string& error_msg) : 
         _error_detail(new ErrorDetail(TStatusCode::INTERNAL_ERROR, error_msg)) {
     LOG(INFO) << error_msg << std::endl << get_stack_trace();
@@ -76,6 +84,21 @@ Status& Status::operator=(const TStatus& status) {
     return *this;
 }
 
+Status::Status(const PStatus& pstatus) :
+    _error_detail((TStatusCode::type)pstatus.status_code() == TStatusCode::OK
+                  ? nullptr : new ErrorDetail(pstatus)) {
+}
+
+Status& Status::operator=(const PStatus& status) {
+    delete _error_detail;
+    if (status.status_code() == (TStatusCode::type)TStatusCode::OK) {
+        _error_detail = nullptr;
+    } else {
+        _error_detail = new ErrorDetail(status);
+    }
+    return *this;
+}
+
 void Status::add_error_msg(TStatusCode::type code, const std::string& msg) {
     if (_error_detail == NULL) {
         _error_detail = new ErrorDetail(code, msg);
@@ -136,6 +159,19 @@ void Status::to_thrift(TStatus* status) const {
     }
 }
 
+void Status::to_protobuf(PStatus* pstatus) const {
+    pstatus->clear_error_msgs();
+    if (_error_detail == nullptr) {
+        pstatus->set_status_code((int)TStatusCode::OK);
+    } else {
+        pstatus->set_status_code(_error_detail->error_code);
+        pstatus->mutable_error_msgs()->Reserve(_error_detail->error_msgs.size());
+        for (auto& err_msg : _error_detail->error_msgs) {
+            pstatus->add_error_msgs(err_msg);
+        }
+    }
+}
+
 void Status::MergeStatus(const Status& status) {
   if (status.ok()) return;
   if (_error_detail == NULL) {
diff --git a/be/src/common/status.h b/be/src/common/status.h
index f10a8be969326d..3f16e480929039 100644
--- a/be/src/common/status.h
+++ b/be/src/common/status.h
@@ -27,6 +27,7 @@
 #include "common/logging.h"
 #include "common/compiler_util.h"
 #include "gen_cpp/Status_types.h"  // for TStatus
+#include "gen_cpp/status.pb.h" // for PStatus
 
 namespace palo {
 
@@ -107,6 +108,9 @@ class Status {
     // same as previous c'tor
     Status& operator=(const TStatus& status);
 
+    Status(const PStatus& pstatus);
+    Status& operator=(const PStatus& pstatus);
+
     // assign from stringstream
     Status& operator=(const std::stringstream& stream);
 
@@ -154,6 +158,7 @@ class Status {
 
     // Convert into TStatus.
     void to_thrift(TStatus* status) const;
+    void to_protobuf(PStatus* status) const;
 
     // Return all accumulated error msgs in a single string.
     void get_error_msg(std::string* msg) const;
@@ -175,6 +180,7 @@ class Status {
         std::vector<std::string> error_msgs;
 
         ErrorDetail(const TStatus& status);
+        ErrorDetail(const PStatus& status);
         ErrorDetail(TStatusCode::type code)
             : error_code(code) {}
         ErrorDetail(TStatusCode::type code, const std::string& msg)
@@ -193,6 +199,14 @@ class Status {
         } \
     } while (false)
 
+#define RETURN_IF_STATUS_ERROR(status, stmt) \
+    do { \
+        status = (stmt); \
+        if (UNLIKELY(!status.ok())) { \
+            return; \
+        } \
+    } while (false)
+
 #define EXIT_IF_ERROR(stmt) \
     do { \
         Status _status_ = (stmt); \
diff --git a/be/src/exec/broker_reader.cpp b/be/src/exec/broker_reader.cpp
index f3003c11a3e922..66d58abeac8966 100644
--- a/be/src/exec/broker_reader.cpp
+++ b/be/src/exec/broker_reader.cpp
@@ -83,8 +83,7 @@ Status BrokerReader::open() {
     TBrokerOpenReaderResponse response;
     try {
         Status status;
-        // 500ms is enough
-        BrokerServiceConnection client(client_cache(_state), broker_addr, 500, &status);
+        BrokerServiceConnection client(client_cache(_state), broker_addr, 10000, &status);
         if (!status.ok()) {
             LOG(WARNING) << "Create broker client failed. broker=" << broker_addr
                 << ", status=" << status.get_error_msg();
@@ -133,8 +132,7 @@ Status BrokerReader::read(uint8_t* buf, size_t* buf_len, bool* eof) {
     TBrokerReadResponse response;
     try {
         Status status;
-        // 500ms is enough
-        BrokerServiceConnection client(client_cache(_state), broker_addr, 500, &status);
+        BrokerServiceConnection client(client_cache(_state), broker_addr, 10000, &status);
         if (!status.ok()) {
             LOG(WARNING) << "Create broker client failed. broker=" << broker_addr
                 << ", status=" << status.get_error_msg();
@@ -189,7 +187,7 @@ void BrokerReader::close() {
     try {
         Status status;
         // 500ms is enough
-        BrokerServiceConnection client(client_cache(_state), broker_addr, 500, &status);
+        BrokerServiceConnection client(client_cache(_state), broker_addr, 10000, &status);
         if (!status.ok()) {
             LOG(WARNING) << "Create broker client failed. broker=" << broker_addr
                 << ", status=" << status.get_error_msg();
diff --git a/be/src/exec/broker_writer.cpp b/be/src/exec/broker_writer.cpp
index 9af818aa35a673..4742269165b345 100644
--- a/be/src/exec/broker_writer.cpp
+++ b/be/src/exec/broker_writer.cpp
@@ -138,8 +138,8 @@ Status BrokerWriter::write(const uint8_t* buf, size_t buf_len, size_t* written_l
     TBrokerOperationStatus response;
     try {
         Status status;
-        // we make timeout to be 5s, to avoid error in Network jitter scenarios.
-        BrokerServiceConnection client(client_cache(_state), broker_addr, 5000, &status);
+        // we make timeout to be 10s, to avoid error in Network jitter scenarios.
+        BrokerServiceConnection client(client_cache(_state), broker_addr, 10000, &status);
         if (!status.ok()) {
             LOG(WARNING) << "Create broker write client failed. "
                     << "broker=" << broker_addr
diff --git a/be/src/exec/new_partitioned_aggregation_node.cc b/be/src/exec/new_partitioned_aggregation_node.cc
index 3f65732f1cd7ca..2a57282c8b00ab 100644
--- a/be/src/exec/new_partitioned_aggregation_node.cc
+++ b/be/src/exec/new_partitioned_aggregation_node.cc
@@ -229,13 +229,14 @@ Status NewPartitionedAggregationNode::prepare(RuntimeState* state) {
   const RowDescriptor& row_desc = child(0)->row_desc();
   RETURN_IF_ERROR(NewAggFnEvaluator::Create(agg_fns_, state, _pool, agg_fn_pool_.get(),
       &agg_fn_evals_, expr_mem_tracker(), row_desc));
-  
+ 
+  expr_results_pool_.reset(new MemPool(_expr_mem_tracker.get()));
   if (!grouping_exprs_.empty()) {
     RowDescriptor build_row_desc(intermediate_tuple_desc_, false);
     RETURN_IF_ERROR(NewPartitionedHashTableCtx::Create(_pool, state, build_exprs_,
         grouping_exprs_, true, vector<bool>(build_exprs_.size(), true),
         state->fragment_hash_seed(), MAX_PARTITION_DEPTH, 1, expr_mem_pool(),
-        expr_mem_tracker(), build_row_desc, row_desc, &ht_ctx_));
+        expr_results_pool_.get(), expr_mem_tracker(), build_row_desc, row_desc, &ht_ctx_));
   }
   // AddCodegenDisabledMessage(state);
   return Status::OK;
@@ -413,6 +414,8 @@ Status NewPartitionedAggregationNode::GetNextInternal(RuntimeState* state,
   RETURN_IF_ERROR(exec_debug_action(TExecNodePhase::GETNEXT));
   RETURN_IF_CANCELLED(state);
   RETURN_IF_ERROR(state->check_query_state());
+  // clear tmp expr result alocations
+  expr_results_pool_->clear();
 
   if (reached_limit()) {
     *eos = true;
@@ -688,12 +691,14 @@ Status NewPartitionedAggregationNode::close(RuntimeState* state) {
   }
 
   ClosePartitions();
-
   child_batch_.reset();
 
   // Close all the agg-fn-evaluators
   NewAggFnEvaluator::Close(agg_fn_evals_, state);
-
+  
+  if (expr_results_pool_.get() != nullptr) {
+      expr_results_pool_->free_all();
+  }
   if (agg_fn_pool_.get() != nullptr) agg_fn_pool_->free_all();
   if (mem_pool_.get() != nullptr) mem_pool_->free_all();
   if (ht_ctx_.get() != nullptr) ht_ctx_->Close(state);
diff --git a/be/src/exec/new_partitioned_aggregation_node.h b/be/src/exec/new_partitioned_aggregation_node.h
index b0c699f3eeefc2..528fb561f2b577 100644
--- a/be/src/exec/new_partitioned_aggregation_node.h
+++ b/be/src/exec/new_partitioned_aggregation_node.h
@@ -250,6 +250,9 @@ class NewPartitionedAggregationNode : public ExecNode {
   /// memory allocation over a series of Reset()/Open()/GetNext()* calls.
   boost::scoped_ptr<MemPool> mem_pool_;
 
+  // MemPool for allocations made by copying expr results
+  boost::scoped_ptr<MemPool> expr_results_pool_;
+
   /// The current partition and iterator to the next row in its hash table that we need
   /// to return in GetNext()
   Partition* output_partition_;
diff --git a/be/src/exec/new_partitioned_hash_table.cc b/be/src/exec/new_partitioned_hash_table.cc
index 170507eb157e37..4fb1e4e29e5d0e 100644
--- a/be/src/exec/new_partitioned_hash_table.cc
+++ b/be/src/exec/new_partitioned_hash_table.cc
@@ -88,7 +88,7 @@ static int64_t NULL_VALUE[] = {
 NewPartitionedHashTableCtx::NewPartitionedHashTableCtx(const std::vector<Expr*>& build_exprs,
     const std::vector<Expr*>& probe_exprs, bool stores_nulls,
     const std::vector<bool>& finds_nulls, int32_t initial_seed,
-    int max_levels, MemPool* mem_pool)
+    int max_levels, MemPool* mem_pool, MemPool* expr_results_pool)
     : build_exprs_(build_exprs),
       probe_exprs_(probe_exprs),
       stores_nulls_(stores_nulls),
@@ -97,7 +97,8 @@ NewPartitionedHashTableCtx::NewPartitionedHashTableCtx(const std::vector<Expr*>&
           finds_nulls_.begin(), finds_nulls_.end(), false, std::logical_or<bool>())),
       level_(0),
       scratch_row_(NULL),
-      mem_pool_(mem_pool) {
+      mem_pool_(mem_pool),
+      expr_results_pool_(expr_results_pool) {
   DCHECK(!finds_some_nulls_ || stores_nulls_);
   // Compute the layout and buffer size to store the evaluated expr results
   DCHECK_EQ(build_exprs_.size(), probe_exprs_.size());
@@ -152,12 +153,12 @@ Status NewPartitionedHashTableCtx::Create(ObjectPool* pool, RuntimeState* state,
     const std::vector<Expr*>& build_exprs,
     const std::vector<Expr*>& probe_exprs, bool stores_nulls,
     const std::vector<bool>& finds_nulls, int32_t initial_seed, int max_levels,
-    int num_build_tuples, MemPool* mem_pool, 
+    int num_build_tuples, MemPool* mem_pool, MemPool* expr_results_pool, 
     MemTracker* tracker, const RowDescriptor& row_desc,
     const RowDescriptor& row_desc_probe,
     scoped_ptr<NewPartitionedHashTableCtx>* ht_ctx) {
   ht_ctx->reset(new NewPartitionedHashTableCtx(build_exprs, probe_exprs, stores_nulls,
-      finds_nulls, initial_seed, max_levels, mem_pool));
+      finds_nulls, initial_seed, max_levels, mem_pool, expr_results_pool));
   return (*ht_ctx)->Init(pool, state, num_build_tuples, tracker, row_desc, row_desc_probe);
 }
 
@@ -235,12 +236,15 @@ bool NewPartitionedHashTableCtx::EvalRow(TupleRow* row, const vector<ExprContext
       expr_values_null[i] = true;
       val = reinterpret_cast<void*>(&NULL_VALUE);
       has_null = true;
+      DCHECK_LE(build_exprs_[i]->type().get_slot_size(),
+          sizeof(NULL_VALUE));
+      RawValue::write(val, loc, build_exprs_[i]->type(), NULL);
     } else {
       expr_values_null[i] = false;
+      DCHECK_LE(build_exprs_[i]->type().get_slot_size(),
+          sizeof(NULL_VALUE));
+      RawValue::write(val, loc, build_exprs_[i]->type(), expr_results_pool_);
     }
-    DCHECK_LE(build_exprs_[i]->type().get_slot_size(),
-        sizeof(NULL_VALUE));
-    RawValue::write(val, loc, build_exprs_[i]->type(), NULL);
   }
   return has_null;
 }
diff --git a/be/src/exec/new_partitioned_hash_table.h b/be/src/exec/new_partitioned_hash_table.h
index 3b868803baf86d..3bd2972d06c99c 100644
--- a/be/src/exec/new_partitioned_hash_table.h
+++ b/be/src/exec/new_partitioned_hash_table.h
@@ -122,7 +122,7 @@ class NewPartitionedHashTableCtx {
       const std::vector<Expr*>& build_exprs,
       const std::vector<Expr*>& probe_exprs, bool stores_nulls,
       const std::vector<bool>& finds_nulls, int32_t initial_seed, int max_levels,
-      int num_build_tuples, MemPool* mem_pool, 
+      int num_build_tuples, MemPool* mem_pool, MemPool* expr_results_pool, 
       MemTracker* tracker, const RowDescriptor& row_desc,
       const RowDescriptor& row_desc_probe,
       boost::scoped_ptr<NewPartitionedHashTableCtx>* ht_ctx);
@@ -416,7 +416,7 @@ class NewPartitionedHashTableCtx {
   NewPartitionedHashTableCtx(const std::vector<Expr*>& build_exprs,
       const std::vector<Expr*>& probe_exprs, bool stores_nulls,
       const std::vector<bool>& finds_nulls, int32_t initial_seed,
-      int max_levels, MemPool* mem_pool);
+      int max_levels, MemPool* mem_pool, MemPool* expr_results_pool);
 
   /// Allocate various buffers for storing expression evaluation results, hash values,
   /// null bits etc. Also allocate evaluators for the build and probe expressions and
@@ -522,6 +522,9 @@ class NewPartitionedHashTableCtx {
   /// MemPool for 'build_expr_evals_' and 'probe_expr_evals_' to allocate expr-managed
   /// memory from. Not owned.
   MemPool* mem_pool_;
+
+  // MemPool for allocations by made EvalRow to copy expr's StringVal result. Not owned
+  MemPool* expr_results_pool_;
 };
 
 /// The hash table consists of a contiguous array of buckets that contain a pointer to the
diff --git a/be/src/http/CMakeLists.txt b/be/src/http/CMakeLists.txt
index f97072b5d3b7dc..1b3dd617f01b83 100644
--- a/be/src/http/CMakeLists.txt
+++ b/be/src/http/CMakeLists.txt
@@ -24,19 +24,17 @@ set(LIBRARY_OUTPUT_PATH "${BUILD_DIR}/src/http")
 set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/src/http")
 
 add_library(Webserver STATIC
-  mongoose.cpp
-  webserver.cpp
   download_action.cpp
   http_headers.cpp
   http_method.cpp
   http_request.cpp
-  http_response.cpp
   http_channel.cpp
   http_status.cpp
   http_parser.cpp
   web_page_handler.cpp
   monitor_action.cpp
   default_path_handlers.cpp
+  ev_http_server.cpp
   action/mini_load.cpp
   action/health_action.cpp
   action/checksum_action.cpp
diff --git a/be/src/http/action/checksum_action.cpp b/be/src/http/action/checksum_action.cpp
index 38a4948468871c..f921f86ff73144 100644
--- a/be/src/http/action/checksum_action.cpp
+++ b/be/src/http/action/checksum_action.cpp
@@ -41,7 +41,7 @@ ChecksumAction::ChecksumAction(ExecEnv* exec_env) :
     _command_executor = new CommandExecutor();
 }
 
-void ChecksumAction::handle(HttpRequest *req, HttpChannel *channel) {
+void ChecksumAction::handle(HttpRequest *req) {
     LOG(INFO) << "accept one request " << req->debug_string();
 
     // add tid to cgroup in order to limit read bandwidth
@@ -51,8 +51,8 @@ void ChecksumAction::handle(HttpRequest *req, HttpChannel *channel) {
     if (tablet_id_str.empty()) {
         std::string error_msg = std::string(
                 "parameter " + TABLET_ID + " not specified in url.");
-        HttpResponse response(HttpStatus::BAD_REQUEST, &error_msg);
-        channel->send_response(response);
+
+        HttpChannel::send_reply(req, HttpStatus::BAD_REQUEST, error_msg);
         return;
     }
 
@@ -61,8 +61,7 @@ void ChecksumAction::handle(HttpRequest *req, HttpChannel *channel) {
     if (version_str.empty()) {
         std::string error_msg = std::string(
                 "parameter " + TABLET_VERSION + " not specified in url.");
-        HttpResponse response(HttpStatus::BAD_REQUEST, &error_msg);
-        channel->send_response(response);
+        HttpChannel::send_reply(req, HttpStatus::BAD_REQUEST, error_msg);
         return;
     }
 
@@ -71,8 +70,7 @@ void ChecksumAction::handle(HttpRequest *req, HttpChannel *channel) {
     if (version_hash_str.empty()) {
         std::string error_msg = std::string(
                 "parameter " + VERSION_HASH + " not specified in url.");
-        HttpResponse response(HttpStatus::BAD_REQUEST, &error_msg);
-        channel->send_response(response);
+        HttpChannel::send_reply(req, HttpStatus::BAD_REQUEST, error_msg);
         return;
     }
 
@@ -81,8 +79,7 @@ void ChecksumAction::handle(HttpRequest *req, HttpChannel *channel) {
     if (schema_hash_str.empty()) {
         std::string error_msg = std::string(
                 "parameter " + SCHEMA_HASH + " not specified in url.");
-        HttpResponse response(HttpStatus::BAD_REQUEST, &error_msg);
-        channel->send_response(response);
+        HttpChannel::send_reply(req, HttpStatus::BAD_REQUEST, error_msg);
         return;
     }
 
@@ -98,33 +95,30 @@ void ChecksumAction::handle(HttpRequest *req, HttpChannel *channel) {
         schema_hash = boost::lexical_cast<int64_t>(schema_hash_str);
     } catch (boost::bad_lexical_cast& e) {
         std::string error_msg = std::string("param format is invalid: ") + std::string(e.what());
-        HttpResponse response(HttpStatus::BAD_REQUEST, &error_msg);
-        channel->send_response(response);
+        HttpChannel::send_reply(req, HttpStatus::BAD_REQUEST, error_msg);
         return;
     }
 
     VLOG_ROW << "get checksum tablet info: " << tablet_id << "-"
              << version << "-" << version_hash << "-" << schema_hash;
 
-    int64_t checksum = do_checksum(tablet_id, version, version_hash, schema_hash, req, channel);
+    int64_t checksum = do_checksum(tablet_id, version, version_hash, schema_hash, req);
     if (checksum == -1L) {
         std::string error_msg = std::string("checksum failed");
-        HttpResponse response(HttpStatus::INTERNAL_SERVER_ERROR, &error_msg);
-        channel->send_response(response);
+        HttpChannel::send_reply(req, HttpStatus::INTERNAL_SERVER_ERROR, error_msg);
         return;
     } else {
         std::stringstream result;
         result << checksum;
         std::string result_str = result.str();
-        HttpResponse response(HttpStatus::OK, &result_str);
-        channel->send_response(response);
+        HttpChannel::send_reply(req, result_str);
     }
 
     LOG(INFO) << "deal with checksum request finished! tablet id: " << tablet_id;
 }
 
 int64_t ChecksumAction::do_checksum(int64_t tablet_id, int64_t version, int64_t version_hash,
-        int32_t schema_hash, HttpRequest *req, HttpChannel *channel) {
+        int32_t schema_hash, HttpRequest *req) {
 
     OLAPStatus res = OLAPStatus::OLAP_SUCCESS;
     uint32_t checksum;
diff --git a/be/src/http/action/checksum_action.h b/be/src/http/action/checksum_action.h
index 52793c6fc944df..ed74b418d28c03 100644
--- a/be/src/http/action/checksum_action.h
+++ b/be/src/http/action/checksum_action.h
@@ -31,10 +31,10 @@ class ChecksumAction : public HttpHandler {
 
     virtual ~ChecksumAction();
 
-    virtual void handle(HttpRequest *req, HttpChannel *channel);
+    void handle(HttpRequest *req) override;
 private:
     int64_t do_checksum(int64_t tablet_id, int64_t version, int64_t version_hash,
-            int32_t schema_hash, HttpRequest *req, HttpChannel *channel);
+            int32_t schema_hash, HttpRequest *req);
 
     ExecEnv* _exec_env;
     CommandExecutor* _command_executor;
diff --git a/be/src/http/action/health_action.cpp b/be/src/http/action/health_action.cpp
index 7888339c502802..b7f42155758746 100644
--- a/be/src/http/action/health_action.cpp
+++ b/be/src/http/action/health_action.cpp
@@ -21,6 +21,7 @@
 #include "http/http_channel.h"
 #include "http/http_request.h"
 #include "http/http_response.h"
+#include "http/http_headers.h"
 #include "http/http_status.h"
 
 namespace palo {
@@ -31,7 +32,7 @@ HealthAction::HealthAction(ExecEnv* exec_env) :
         _exec_env(exec_env) {
 }
 
-void HealthAction::handle(HttpRequest *req, HttpChannel *channel) {
+void HealthAction::handle(HttpRequest *req) {
     std::stringstream ss;
     ss << "{";
     ss << "\"status\": \"OK\",";
@@ -39,8 +40,12 @@ void HealthAction::handle(HttpRequest *req, HttpChannel *channel) {
     ss << "}";
     std::string result = ss.str();
 
+    req->add_output_header(HttpHeaders::CONTENT_TYPE, HEADER_JSON.c_str());
+    HttpChannel::send_reply(req, HttpStatus::OK, result);
+#if 0
     HttpResponse response(HttpStatus::OK, HEADER_JSON, &result);
     channel->send_response(response);
+#endif
 }
 
 } // end namespace palo
diff --git a/be/src/http/action/health_action.h b/be/src/http/action/health_action.h
index 04e133f49f17d5..bb5da2f1add8bd 100644
--- a/be/src/http/action/health_action.h
+++ b/be/src/http/action/health_action.h
@@ -29,7 +29,7 @@ class HealthAction : public HttpHandler {
 
     virtual ~HealthAction() {};
 
-    virtual void handle(HttpRequest *req, HttpChannel *channel);
+    void handle(HttpRequest *req) override;
 
 private:
     ExecEnv* _exec_env;
diff --git a/be/src/http/action/metrics_action.cpp b/be/src/http/action/metrics_action.cpp
index 5e295baefa3f5e..cf4fcd19e1b0bd 100644
--- a/be/src/http/action/metrics_action.cpp
+++ b/be/src/http/action/metrics_action.cpp
@@ -21,7 +21,6 @@
 #include "http/http_response.h"
 #include "http/http_channel.h"
 #include "http/http_headers.h"
-#include "http/webserver.h"
 #include "runtime/exec_env.h"
 #include "util/metrics.h"
 
@@ -84,12 +83,13 @@ void PrometheusMetricsVisitor::_visit_simple_metric(
     _ss << " " << metric->to_string() << "\n";
 }
 
-void MetricsAction::handle(HttpRequest* req, HttpChannel* channel) {
+void MetricsAction::handle(HttpRequest* req) {
     PrometheusMetricsVisitor visitor;
     _metrics->collect(&visitor);
     std::string str = visitor.to_string();
-    HttpResponse response(HttpStatus::OK, "text/plain; version=0.0.4", &str);
-    channel->send_response(response);
+
+    req->add_output_header(HttpHeaders::CONTENT_TYPE, "text/plain; version=0.0.4");
+    HttpChannel::send_reply(req, str);
 }
 
 }
diff --git a/be/src/http/action/metrics_action.h b/be/src/http/action/metrics_action.h
index 8667ec9ae0c8a5..a39a59b19dc38c 100644
--- a/be/src/http/action/metrics_action.h
+++ b/be/src/http/action/metrics_action.h
@@ -22,7 +22,6 @@ namespace palo {
 class Webserver;
 class ExecEnv;
 class HttpRequest;
-class HttpChannel;
 class MetricRegistry;
 
 class MetricsAction : public HttpHandler {
@@ -30,7 +29,7 @@ class MetricsAction : public HttpHandler {
     MetricsAction(MetricRegistry* metrics) :_metrics(metrics) { }
     virtual ~MetricsAction() { }
 
-    void handle(HttpRequest *req, HttpChannel *channel) override;
+    void handle(HttpRequest *req) override;
 private:
     MetricRegistry* _metrics;
 };
diff --git a/be/src/http/action/mini_load.cpp b/be/src/http/action/mini_load.cpp
index b867812411e987..e5a16f6cba2f5c 100644
--- a/be/src/http/action/mini_load.cpp
+++ b/be/src/http/action/mini_load.cpp
@@ -30,6 +30,10 @@
 
 #include <functional>
 
+#include <event2/buffer.h>
+#include <event2/bufferevent.h>
+#include <event2/http.h>
+
 #include "agent/cgroups_mgr.h"
 #include "common/status.h"
 #include "http/http_request.h"
@@ -51,6 +55,34 @@
 
 namespace palo {
 
+// context used to handle mini-load in asynchronous mode
+struct MiniLoadCtx {
+    MiniLoadCtx(MiniLoadAction* handler_) : handler(handler_) { }
+    ~MiniLoadCtx() {
+        if (need_remove_handle) {
+            handler->erase_handle(load_handle);
+        }
+        if (fd >= 0) {
+            ::close(fd);
+        }
+    }
+
+    MiniLoadAction* handler;
+
+    // used to check duplicate
+    LoadHandle load_handle;
+    bool need_remove_handle = false;
+
+    // file to save
+    std::string file_path;
+    int fd = -1;
+
+    size_t body_bytes = 0;
+    size_t bytes_written = 0;
+
+    TLoadCheckRequest load_check_req;
+};
+
 const std::string CLUSTER_KEY = "cluster";
 const std::string DB_KEY = "db";
 const std::string TABLE_KEY = "table";
@@ -67,32 +99,6 @@ static bool is_name_valid(const std::string& name) {
     return !name.empty();
 }
 
-// send response
-static void send_response(const Status& status, HttpChannel *channel) {
-    std::stringstream ss;
-    ss << "{\n";
-    if (status.ok()) {
-        ss << "\t\"status\": \"Success\",\n";
-        ss << "\t\"msg\": \"OK\"\n";
-    } else {
-        ss << "\t\"status\": \"Fail\",\n";
-        ss << "\t\"msg\": \"" << status.get_error_msg() << "\"\n";
-    }
-    ss << "}\n";
-
-    std::string str = ss.str();
-    HttpResponse response(HttpStatus::OK, &str);
-
-    channel->send_response(response);
-}
-
-// send error
-static void send_100_continue(HttpChannel *channel) {
-    static HttpResponse response(HttpStatus::CONTINUE);
-
-    channel->send_response(response);
-}
-
 static Status check_request(HttpRequest* req) {
     std::map<std::string, std::string>& params = *req->params();
 
@@ -110,115 +116,6 @@ static Status check_request(HttpRequest* req) {
     return Status::OK;
 }
 
-// Receive 'Transfer-Encoding: chunked' data from client
-// Params:
-//  file_handler file descriptor and operation for output file
-//  channel      used to receive client data
-static Status save_chunked_data(FileHandler* file_handler, HttpChannel *channel) {
-    const int64_t BUF_SIZE = 4096;
-    char *buf = new char[BUF_SIZE];
-    DeferOp free_buf(std::bind<void>(std::default_delete<char[]>(), buf));
-    HttpChunkParseCtx ctx;
-    const uint8_t* pos = (const uint8_t*)buf;
-    const uint8_t* end = pos;
-    int64_t total_bytes = 0;
-    int64_t max_bytes = config::mini_load_max_mb * 1024 * 1024;
-    // To get length of first read
-    HttpParser::ParseState state = HttpParser::http_parse_chunked(&pos, end - pos, &ctx);
-    while (state != HttpParser::PARSE_DONE && state != HttpParser::PARSE_ERROR) {
-        if (pos == end) {
-            int64_t need_length = std::min(BUF_SIZE, ctx.length);
-            int64_t read_len = channel->read(buf, need_length);
-            if (read_len != need_length) {
-                char errmsg[64];
-                LOG(INFO) << "read chunked data failed, need=" << need_length
-                    << " and read=" << read_len << " and ctx=" << ctx
-                    << ",syserr=" << strerror_r(errno, errmsg, 64);
-                return Status("Failed when receiving http packet.");
-            }
-            pos = (const uint8_t*)buf;
-            end = pos + read_len;
-            total_bytes += read_len;
-        }
-        if (total_bytes > max_bytes) {
-            return Status("File size exceed max size we can support.");
-        }
-        state = HttpParser::http_parse_chunked(&pos, end - pos, &ctx);
-        switch (state) {
-        case HttpParser::PARSE_AGAIN:
-            // Do nothing
-            break;
-        case HttpParser::PARSE_OK: {
-            // data received
-            int64_t size = std::min(ctx.size, end - pos);
-            OLAPStatus wr_status = file_handler->write(pos, size);
-            if (wr_status != OLAP_SUCCESS) {
-                char errmsg[64];
-                LOG(WARNING) << "Write to file("
-                        << FileUtils::path_of_fd(file_handler->fd()) << ") failed. "
-                        << "need=" << size
-                        << ",syserr=" << strerror_r(errno, errmsg, 64);
-                return Status("Failed when saving uploaded data");
-            }
-            ctx.size -= size;
-            ctx.length -= size;
-            pos += size;
-            break;
-        }
-        case HttpParser::PARSE_DONE:
-            break;
-        case HttpParser::PARSE_ERROR:
-            break;
-        default:
-            // Impossible state, must be a bug, output all information
-            LOG(WARNING) << "Unknown http parse state(" << state << "), pos=" << pos
-                << ",end=" << end << ",ctx=" << ctx;
-            state = HttpParser::PARSE_ERROR;
-            break;
-        }
-    }
-
-    if (state == HttpParser::PARSE_DONE) {
-        LOG(INFO) << "Save file to path "
-            << FileUtils::path_of_fd(file_handler->fd()) << " success.";
-        return Status::OK;
-    } else {
-        return Status("Error happend when palo parse your http packet.");
-    }
-}
-
-static Status save_to_file(FileHandler* file_handler, int64_t len, HttpChannel* channel) {
-    const int64_t BUF_SIZE = 4096;
-    char *buf = new char[BUF_SIZE];
-    DeferOp free_buf(std::bind<void>(std::default_delete<char[]>(), buf));
-    int64_t to_read = len;
-    while (to_read > 0) {
-        int64_t to_read_this_time = std::min(to_read, BUF_SIZE);
-        int64_t read_this_time = channel->read(buf, to_read_this_time);
-        if (to_read_this_time != read_this_time) {
-            // what can i do??
-            char errmsg[64];
-            LOG(INFO) << "read chunked data failed, need=" << to_read_this_time
-                << " and read=" << read_this_time
-                << ",syserr=" << strerror_r(errno, errmsg, 64);
-            return Status("Failed when receiving http packet.");
-        }
-        OLAPStatus wr_status = file_handler->write(buf, read_this_time);
-        if (wr_status != OLAP_SUCCESS) {
-            char errmsg[64];
-            LOG(WARNING) << "Write to file("
-                    << FileUtils::path_of_fd(file_handler->fd()) << ") failed. "
-                    << "need=" << read_this_time
-                    << ",syserr=" << strerror_r(errno, errmsg, 64);
-            return Status("Failed when saving uploaded data");
-        }
-        // write will write all buf into file, so that write_len == read_this_time
-        to_read -= read_this_time;
-    }
-    LOG(INFO) << "Save file to path " << FileUtils::path_of_fd(file_handler->fd()) << " success.";
-    return Status::OK;
-}
-
 Status MiniLoadAction::data_saved_dir(const LoadHandle& desc,
                                       const std::string& table,
                                       std::string* file_path) {
@@ -239,61 +136,11 @@ Status MiniLoadAction::data_saved_dir(const LoadHandle& desc,
     return Status::OK;
 }
 
-// Receive data from client
-// TODO(zc): support range in HTTP
-Status MiniLoadAction::receive_data(const LoadHandle& desc, HttpRequest* req,
-                    HttpChannel *channel, std::string* file_path) {
-
-    // add tid to cgroup
-    CgroupsMgr::apply_system_cgroup();
-    RETURN_IF_ERROR(data_saved_dir(desc, req->param(TABLE_KEY), file_path));
-    // download
-
-    // destructor will close the file handle, not depend on DeferOp any more
-    FileHandler file_handler;
-    OLAPStatus open_status = file_handler.open_with_mode(file_path->c_str(),
-                                                        O_WRONLY | O_CREAT | O_TRUNC,
-                                                        0660);
-    if (open_status != OLAP_SUCCESS) {
-        // open failed
-        char buf[64];
-        LOG(ERROR) << "open file failed." << *file_path << strerror_r(errno, buf, 64);
-        return Status("Internal Error");
-    }
-
-    // After all thing prepare thing, then send '100-continue' to client
-    if (strcasecmp(req->header(HttpHeaders::EXPECT).c_str(), k_100_continue) == 0) {
-        // send 100 continue;
-        send_100_continue(channel);
-    }
-
-    // Check if chunk first according rfc2616
-    if (!req->header(HttpHeaders::TRANSFER_ENCODING).empty()) {
-        if (req->header(HttpHeaders::TRANSFER_ENCODING) != "chunked") {
-            std::stringstream ss;
-            ss << "Unknown " << HttpHeaders::TRANSFER_ENCODING << ": "
-                << req->header(HttpHeaders::TRANSFER_ENCODING);
-            return Status(ss.str());
-        }
-        return save_chunked_data(&file_handler, channel);
-    } else if (!req->header(HttpHeaders::CONTENT_LENGTH).empty()) {
-        int64_t len = std::stol(req->header(HttpHeaders::CONTENT_LENGTH));
-        if (len > config::mini_load_max_mb * 1024 * 1024) {
-            return Status("File size exceed max size we can support.");
-        }
-        return save_to_file(&file_handler, len, channel);
-    } else {
-        std::stringstream ss;
-        ss << "There is no " << HttpHeaders::TRANSFER_ENCODING << " nor "
-            << HttpHeaders::CONTENT_LENGTH << " in request headers, you need pass me one";
-        return Status(ss.str());
-    }
-
-    return Status::OK;
-}
-
-Status MiniLoadAction::load(
-        HttpRequest* http_req, const std::string& file_path) {
+Status MiniLoadAction::_load(
+        HttpRequest* http_req,
+        const std::string& file_path,
+        const std::string& user,
+        const std::string& cluster) {
     // Prepare request parameters.
     std::map<std::string, std::string> params(
             http_req->query_params().begin(), http_req->query_params().end());
@@ -317,12 +164,12 @@ Status MiniLoadAction::load(
         TMiniLoadRequest req;
         req.protocolVersion = FrontendServiceVersion::V1;
         req.__set_db(http_req->param(DB_KEY));
-        if (!_cluster.empty()) {
-            req.__set_cluster(_cluster);
+        if (!cluster.empty()) {
+            req.__set_cluster(cluster);
         }
         req.__set_tbl(http_req->param(TABLE_KEY));
         req.__set_label(http_req->param(LABEL_KEY));
-        req.__set_user(_user);
+        req.__set_user(user);
         // Belong to a multi-load transaction
         if (!http_req->param(SUB_LABEL_KEY).empty()) {
             req.__set_subLabel(http_req->param(SUB_LABEL_KEY));
@@ -384,12 +231,9 @@ static bool parse_auth(const std::string& auth, std::string* user,
     return true;
 }
 
-Status MiniLoadAction::check_auth(HttpRequest* http_req) {
-    const char k_basic[] = "Basic ";
-    const std::string& auth = http_req->header(HttpHeaders::AUTHORIZATION);
-    if (auth.compare(0, sizeof(k_basic) - 1, k_basic, sizeof(k_basic) - 1) != 0) {
-        return Status("Not support Basic authorization.");
-    }
+Status MiniLoadAction::check_auth(
+        const HttpRequest* http_req,
+        const TLoadCheckRequest& check_load_req) {
     // put here to log master information
     const TNetworkAddress& master_address = _exec_env->master_info()->network_address;
     Status status;
@@ -405,32 +249,8 @@ Status MiniLoadAction::check_auth(HttpRequest* http_req) {
 
     TFeResult res;
     try {
-        TLoadCheckRequest req;
-
-        req.protocolVersion = FrontendServiceVersion::V1;
-        // Skip "Basic "
-        std::string str = auth.substr(sizeof(k_basic) - 1);
-        std::string cluster;
-        if (!parse_auth(str, &req.user, &req.passwd, &cluster)) {
-            LOG(WARNING) << "parse auth string failed." << auth << " and str " << str;
-            return Status("Parse authorization failed.");
-        }
-        if (!cluster.empty()) {
-            req.__set_cluster(cluster);
-        }
-        req.db = http_req->param(DB_KEY);
-        if (http_req->param(SUB_LABEL_KEY).empty()) {
-            req.__set_label(http_req->param(LABEL_KEY));
-
-            struct timeval tv;
-            gettimeofday(&tv, NULL);
-            req.__set_timestamp(tv.tv_sec * 1000 + tv.tv_usec / 1000);
-        }
-
         try {
-            client->loadCheck(res, req);
-            _user.assign(req.user);
-            _cluster.assign(cluster);
+            client->loadCheck(res, check_load_req);
         } catch (apache::thrift::transport::TTransportException& e) {
             LOG(WARNING) << "Retrying mini load from master("
                     << master_address.hostname << ":" << master_address.port
@@ -441,9 +261,7 @@ Status MiniLoadAction::check_auth(HttpRequest* http_req) {
                     << master_address.hostname << ":" << master_address.port << ")";
                 return status;
             }
-            client->loadCheck(res, req);
-            _user.assign(req.user);
-            _cluster.assign(cluster);
+            client->loadCheck(res, check_load_req);
         }
     } catch (apache::thrift::TException& e) {
         // failed when retry.
@@ -464,61 +282,177 @@ void MiniLoadAction::erase_handle(const LoadHandle& desc) {
     _current_load.erase(desc);
 }
 
-void MiniLoadAction::handle(HttpRequest *req, HttpChannel *channel) {
-    LOG(INFO) << "accept one request " << req->debug_string();
-
+int MiniLoadAction::on_header(HttpRequest* req) {
     // check authorization first, make client know what happend
     if (req->header(HttpHeaders::AUTHORIZATION).empty()) {
-        channel->send_basic_challenge("mini_load");
-        return;
+        HttpChannel::send_basic_challenge(req, "mini_load");
+        return -1;
     }
-    Status status = check_request(req);
-    if (!status.ok()) {
-        send_response(status, channel);
-        return;
+    auto st = _on_header(req);
+    if (!st.ok()) {
+        HttpChannel::send_reply(req, HttpStatus::INTERNAL_SERVER_ERROR, st.get_error_msg());
+        return -1;
     }
-    LoadHandle desc;
-    desc.db = req->param(DB_KEY);
-    desc.label = req->param(LABEL_KEY);
-    desc.sub_label = req->param(SUB_LABEL_KEY);
+    return 0;
+}
+
+Status MiniLoadAction::_on_header(HttpRequest* req) {
+    size_t body_bytes = 0;
+    size_t max_body_bytes = config::mini_load_max_mb * 1024 * 1024;
+    if (!req->header(HttpHeaders::CONTENT_LENGTH).empty()) {
+        body_bytes = std::stol(req->header(HttpHeaders::CONTENT_LENGTH));
+        if (body_bytes > max_body_bytes) {
+            std::stringstream ss;
+            ss << "file size exceed max body size, max_body_bytes=" << max_body_bytes;
+            return Status(ss.str());
+        }
+    } else {
+        evhttp_connection_set_max_body_size(
+            evhttp_request_get_connection(req->get_evhttp_request()),
+            max_body_bytes);
+    }
+
+    RETURN_IF_ERROR(check_request(req));
+
+    std::unique_ptr<MiniLoadCtx> ctx(new MiniLoadCtx(this));
+    ctx->body_bytes = body_bytes;
+    ctx->load_handle.db = req->param(DB_KEY);
+    ctx->load_handle.label = req->param(LABEL_KEY);
+    ctx->load_handle.sub_label = req->param(SUB_LABEL_KEY);
 
     // check if duplicate
     // Use this to prevent that two callback function write to one file
     // that file may be writen bad
     {
         std::lock_guard<std::mutex> l(_lock);
-        if (_current_load.find(desc) != _current_load.end()) {
-            // Already exists.
-            status = Status("Duplicate mini load request.");
-        } else {
-            _current_load.insert(desc);
+        if (_current_load.find(ctx->load_handle) != _current_load.end()) {
+            return Status("Duplicate mini load request.");
         }
+        _current_load.insert(ctx->load_handle);
+        ctx->need_remove_handle = true;
     }
-    // Send response without lock
-    if (!status.ok()) {
-        send_response(status, channel);
-        return;
+    // generate load check request
+    RETURN_IF_ERROR(generate_check_load_req(req, &ctx->load_check_req));
+
+    // Check auth
+    RETURN_IF_ERROR(check_auth(req, ctx->load_check_req));
+
+    // Receive data first, keep things easy.
+    RETURN_IF_ERROR(data_saved_dir(ctx->load_handle, req->param(TABLE_KEY),
+                                   &ctx->file_path));
+    // destructor will close the file handle, not depend on DeferOp any more
+    ctx->fd = open(ctx->file_path.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0660);
+    if (ctx->fd < 0) {
+        char buf[64];
+        LOG(WARNING) << "open file failed, path=" << ctx->file_path
+            << ", errno=" << errno << ", errmsg=" << strerror_r(errno, buf, sizeof(buf));
+        return Status("open file failed");
     }
 
-    // Used to erase desc from map
-    DeferOp erase(std::bind<void>(&MiniLoadAction::erase_handle, this, desc));
+    req->set_handler_ctx(ctx.release());
+    return Status::OK;
+}
 
-    // Check auth
-    status = check_auth(req);
-    if (!status.ok()) {
-        send_response(status, channel);
+void MiniLoadAction::on_chunk_data(HttpRequest* http_req) {
+    MiniLoadCtx* ctx = (MiniLoadCtx*)http_req->handler_ctx();
+    if (ctx == nullptr) {
         return;
     }
 
-    // Receive data first, keep things easy.
-    std::string file_path;
-    status = receive_data(desc, req, channel, &file_path);
-    if (!status.ok()) {
-        send_response(status, channel);
+    struct evhttp_request* ev_req = http_req->get_evhttp_request();
+    auto evbuf = evhttp_request_get_input_buffer(ev_req);
+
+    char buf[4096];
+    while (evbuffer_get_length(evbuf) > 0) {
+        auto n = evbuffer_remove(evbuf, buf, sizeof(buf));
+        while (n > 0) {
+            auto res = write(ctx->fd, buf, n);
+            if (res < 0) {
+                char errbuf[64];
+                LOG(WARNING) << "write file failed, path=" << ctx->file_path
+                    << ", errno=" << errno
+                    << ", errmsg=" << strerror_r(errno, errbuf, sizeof(errbuf));
+                HttpChannel::send_reply(
+                    http_req, HttpStatus::INTERNAL_SERVER_ERROR, "write file failed");
+                delete ctx;
+                http_req->set_handler_ctx(nullptr);
+                return;
+            }
+            n -= res;
+            ctx->bytes_written += res;
+        }
+    }
+}
+
+void MiniLoadAction::free_handler_ctx(void* param) {
+    MiniLoadCtx* ctx = (MiniLoadCtx*)param;
+    delete ctx;
+}
+
+void MiniLoadAction::handle(HttpRequest *http_req) {
+    MiniLoadCtx* ctx = (MiniLoadCtx*)http_req->handler_ctx();
+    if (ctx == nullptr) {
+        // when ctx is nullptr, there must be error happend when on_chunk_data
+        // and reply is sent, we just return with no operation
+        LOG(WARNING) << "handler context is nullptr when MiniLoad callback execute, uri="
+            << http_req->uri();
         return;
     }
-    status = load(req, file_path);
-    send_response(status, channel);
+    if (ctx->body_bytes > 0 && ctx->bytes_written != ctx->body_bytes) {
+        LOG(WARNING) << "bytes written is not equal with body size, uri="
+            << http_req->uri()
+            << ", body_bytes=" << ctx->body_bytes
+            << ", bytes_written=" << ctx->bytes_written;
+        HttpChannel::send_reply(http_req, HttpStatus::INTERNAL_SERVER_ERROR,
+                                "rececpt size not equal with body size");
+        return;
+    }
+    auto st = _load(
+        http_req, ctx->file_path, ctx->load_check_req.user, ctx->load_check_req.cluster);
+    if (!st.ok()) {
+        HttpChannel::send_reply(http_req, HttpStatus::INTERNAL_SERVER_ERROR, st.get_error_msg());
+        return;
+    }
+
+    std::stringstream ss;
+    ss << "{\n";
+    ss << "\t\"status\": \"Success\",\n";
+    ss << "\t\"msg\": \"OK\"\n";
+    ss << "}\n";
+    std::string str = ss.str();
+    HttpChannel::send_reply(http_req, str);
+}
+
+Status MiniLoadAction::generate_check_load_req(
+        const HttpRequest* http_req,
+        TLoadCheckRequest* check_load_req) {
+
+    const char k_basic[] = "Basic ";
+    const std::string& auth = http_req->header(HttpHeaders::AUTHORIZATION);
+    if (auth.compare(0, sizeof(k_basic) - 1, k_basic, sizeof(k_basic) - 1) != 0) {
+        return Status("Not support Basic authorization.");
+    }
+
+    check_load_req->protocolVersion = FrontendServiceVersion::V1;
+    // Skip "Basic "
+    std::string str = auth.substr(sizeof(k_basic) - 1);
+    std::string cluster;
+    if (!parse_auth(str, &(check_load_req->user), &(check_load_req->passwd), &cluster)) {
+        LOG(WARNING) << "parse auth string failed." << auth << " and str " << str;
+        return Status("Parse authorization failed.");
+    }
+    if (!cluster.empty()) {
+        check_load_req->__set_cluster(cluster);
+    }
+    check_load_req->db = http_req->param(DB_KEY);
+    if (http_req->param(SUB_LABEL_KEY).empty()) {
+        check_load_req->__set_label(http_req->param(LABEL_KEY));
+
+        struct timeval tv;
+        gettimeofday(&tv, NULL);
+        check_load_req->__set_timestamp(tv.tv_sec * 1000 + tv.tv_usec / 1000);
+    }
+    return Status::OK;
 }
 
 bool LoadHandleCmp::operator() (const LoadHandle& lhs, const LoadHandle& rhs) const {
diff --git a/be/src/http/action/mini_load.h b/be/src/http/action/mini_load.h
index 751eb1c3f961c1..39d17bb39b7f8c 100644
--- a/be/src/http/action/mini_load.h
+++ b/be/src/http/action/mini_load.h
@@ -24,6 +24,7 @@
 #include "common/status.h"
 #include "http/http_handler.h"
 #include "util/defer_op.h"
+#include "gen_cpp/FrontendService.h"
 
 namespace palo {
 
@@ -50,32 +51,42 @@ class MiniLoadAction : public HttpHandler {
     virtual ~MiniLoadAction() {
     }
 
-    virtual void handle(HttpRequest *req, HttpChannel *channel);
+    void handle(HttpRequest *req) override;
 
+    bool request_will_be_read_progressively() override { return true; }
+
+    int on_header(HttpRequest* req) override;
+
+    void on_chunk_data(HttpRequest* req) override;
+    void free_handler_ctx(void* ctx) override;
+    
+    void erase_handle(const LoadHandle& handle);
 private:
-    Status load(
+    Status _load(
             HttpRequest* req, 
-            const std::string& file_path);
+            const std::string& file_path,
+            const std::string& user,
+            const std::string& cluster);
 
     Status data_saved_dir(const LoadHandle& desc, 
                           const std::string& table,
                           std::string* file_path);
 
-    Status receive_data(const LoadHandle& desc, HttpRequest* req, 
-                    HttpChannel *channel, std::string* file_path);
+    Status _on_header(HttpRequest* http_req);
 
-    Status check_auth(HttpRequest* http_req);
+    Status generate_check_load_req(
+            const HttpRequest* http_req,
+            TLoadCheckRequest* load_check_req);
 
-    void erase_handle(const LoadHandle& handle);
+    Status check_auth(
+            const HttpRequest* http_req,
+            const TLoadCheckRequest& load_check_req);
 
     ExecEnv* _exec_env;
 
     std::mutex _lock;
     // Used to check if load is duplicated in this instance.
     std::set<LoadHandle, LoadHandleCmp> _current_load;
-    
-    std::string _user;
-    std::string _cluster;
 };
 
 }
diff --git a/be/src/http/action/pprof_actions.cpp b/be/src/http/action/pprof_actions.cpp
index 5598606913ea7d..138939b8de1046 100644
--- a/be/src/http/action/pprof_actions.cpp
+++ b/be/src/http/action/pprof_actions.cpp
@@ -30,7 +30,7 @@
 #include "http/http_response.h"
 #include "http/http_channel.h"
 #include "http/http_headers.h"
-#include "http/webserver.h"
+#include "http/ev_http_server.h"
 #include "runtime/exec_env.h"
 #include "util/bfd_parser.h"
 
@@ -48,16 +48,16 @@ class HeapAction : public HttpHandler {
     HeapAction() { }
     virtual ~HeapAction() { }
 
-    virtual void handle(HttpRequest *req, HttpChannel *channel) override;
+    virtual void handle(HttpRequest *req) override;
 };
 
-void HeapAction::handle(HttpRequest* req, HttpChannel* channel) {
+void HeapAction::handle(HttpRequest* req) {
 #if defined(ADDRESS_SANITIZER) || defined(LEAK_SANITIZER) || defined(THREAD_SANITIZER)
     (void)kPprofDefaultSampleSecs; // Avoid unused variable warning.
 
     std::string str = "Heap profiling is not available with address sanitizer builds.";
-    HttpResponse response(HttpStatus::OK, &str);
-    channel->send_response(response);
+
+    HttpChannel::send_reply(req, str);
 #else
     std::lock_guard<std::mutex> lock(kPprofActionMutex);
 
@@ -79,8 +79,8 @@ void HeapAction::handle(HttpRequest* req, HttpChannel* channel) {
     HeapProfilerStop();
     std::string str = profile;
     delete profile;
-    HttpResponse response(HttpStatus::OK, &str);
-    channel->send_response(response);
+
+    HttpChannel::send_reply(req, str);
 #endif
 }
 
@@ -89,21 +89,20 @@ class GrowthAction : public HttpHandler {
     GrowthAction() { }
     virtual ~GrowthAction() { }
 
-    virtual void handle(HttpRequest *req, HttpChannel *channel) override;
+    virtual void handle(HttpRequest *req) override;
 };
 
-void GrowthAction::handle(HttpRequest* req, HttpChannel* channel) {
+void GrowthAction::handle(HttpRequest* req) {
 #if defined(ADDRESS_SANITIZER) || defined(LEAK_SANITIZER) || defined(THREAD_SANITIZER)
     std::string str = "Growth profiling is not available with address sanitizer builds.";
-    HttpResponse response(HttpStatus::OK, &str);
-    channel->send_response(response);
+    HttpChannel::send_reply(req, str);
 #else
     std::lock_guard<std::mutex> lock(kPprofActionMutex);
 
     std::string heap_growth_stack;
     MallocExtension::instance()->GetHeapGrowthStacks(&heap_growth_stack);
-    HttpResponse response(HttpStatus::OK, &heap_growth_stack);
-    channel->send_response(response);
+
+    HttpChannel::send_reply(req, heap_growth_stack);
 #endif
 }
 
@@ -112,14 +111,13 @@ class ProfileAction : public HttpHandler {
     ProfileAction() { }
     virtual ~ProfileAction() { }
 
-    virtual void handle(HttpRequest *req, HttpChannel *channel) override;
+    virtual void handle(HttpRequest *req) override;
 };
 
-void ProfileAction::handle(HttpRequest *req, HttpChannel *channel) {
+void ProfileAction::handle(HttpRequest *req) {
 #if defined(ADDRESS_SANITIZER) || defined(LEAK_SANITIZER) || defined(THREAD_SANITIZER)
     std::string str = "CPU profiling is not available with address sanitizer builds.";
-    HttpResponse response(HttpStatus::OK, &str);
-    channel->send_response(response);
+    HttpChannel::send_reply(req, str);
 #else
     std::lock_guard<std::mutex> lock(kPprofActionMutex);
 
@@ -141,15 +139,14 @@ void ProfileAction::handle(HttpRequest *req, HttpChannel *channel) {
     if (!prof_file.is_open()) {
         ss << "Unable to open cpu profile: " << tmp_prof_file_name.str();
         std::string str = ss.str();
-        HttpResponse response(HttpStatus::OK, &str);
-        channel->send_response(response);
+        HttpChannel::send_reply(req, str);
         return;
     }
     ss << prof_file.rdbuf();
     prof_file.close();
     std::string str = ss.str();
-    HttpResponse response(HttpStatus::OK, &str);
-    channel->send_response(response);
+
+    HttpChannel::send_reply(req, str);
 #endif
 }
 
@@ -157,7 +154,7 @@ class PmuProfileAction : public HttpHandler {
 public:
     PmuProfileAction() { }
     virtual ~PmuProfileAction() { }
-    virtual void handle(HttpRequest *req, HttpChannel *channel) override {
+    virtual void handle(HttpRequest *req) override {
     }
 };
 
@@ -166,7 +163,7 @@ class ContentionAction : public HttpHandler {
     ContentionAction() { }
     virtual ~ContentionAction() { }
 
-    virtual void handle(HttpRequest *req, HttpChannel *channel) override {
+    virtual void handle(HttpRequest *req) override {
     }
 };
 
@@ -174,23 +171,23 @@ class CmdlineAction : public HttpHandler {
 public:
     CmdlineAction() { }
     virtual ~CmdlineAction() { }
-    virtual void handle(HttpRequest *req, HttpChannel *channel) override;
+    virtual void handle(HttpRequest *req) override;
 };
 
-void CmdlineAction::handle(HttpRequest* req, HttpChannel* channel) {
+void CmdlineAction::handle(HttpRequest* req) {
     FILE* fp = fopen("/proc/self/cmdline", "r");
     if (fp == nullptr) {
         std::string str = "Unable to open file: /proc/self/cmdline";
-        HttpResponse response(HttpStatus::OK, &str);
-        channel->send_response(response);
+
+        HttpChannel::send_reply(req, str);
         return;
     }
     char buf[1024];
     fscanf(fp, "%s ", buf);
     fclose(fp);
     std::string str = buf;
-    HttpResponse response(HttpStatus::OK, &str);
-    channel->send_response(response);
+
+    HttpChannel::send_reply(req, str);
 }
 
 class SymbolAction : public HttpHandler {
@@ -198,81 +195,27 @@ class SymbolAction : public HttpHandler {
     SymbolAction(BfdParser* parser) : _parser(parser) { }
     virtual ~SymbolAction() { }
 
-    virtual void handle(HttpRequest *req, HttpChannel *channel) override;
+    virtual void handle(HttpRequest *req) override;
 
 private:
     BfdParser* _parser;
 };
 
-static Status save_to_string(std::string* str, int64_t len, HttpChannel* channel) {
-    const int64_t BUF_SIZE = 4096;
-    char buf[BUF_SIZE];
-    int64_t to_read = len;
-    while (to_read > 0) {
-        int64_t to_read_this_time = std::min(to_read, BUF_SIZE);
-        int64_t read_this_time = channel->read(buf, to_read_this_time);
-        if (to_read_this_time != read_this_time) {
-            // what can i do??
-            char errmsg[64];
-            LOG(INFO) << "read chunked data failed, need=" << to_read_this_time
-                << " and read=" << read_this_time
-                << ",syserr=" << strerror_r(errno, errmsg, 64);
-            return Status("Failed when receiving http packet.");
-        }
-        str->append(buf, read_this_time);
-        // write will write all buf into file, so that write_len == read_this_time
-        to_read -= read_this_time;
-    }
-    return Status::OK;
-}
-
-void SymbolAction::handle(HttpRequest* req, HttpChannel* channel) {
+void SymbolAction::handle(HttpRequest* req) {
     // TODO: Implement symbol resolution. Without this, the binary needs to be passed
     // to pprof to resolve all symbols.
     if (req->method() == HttpMethod::GET) {
         std::stringstream ss;
         ss << "num_symbols: " << _parser->num_symbols();
         std::string str = ss.str();
-        HttpResponse response(HttpStatus::OK, &str);
-        channel->send_response(response);
+
+        HttpChannel::send_reply(req, str);
         return;
     } else if (req->method() == HttpMethod::HEAD) {
-        HttpResponse response(HttpStatus::OK);
-#if 0
-        response.add_header(
-            std::string(HttpHeaders::CONTENT_LENGTH), std::to_string(file_size));
-        response.add_header(
-            std::string(HttpHeaders::CONTENT_TYPE),
-            get_content_type(file_path));
-#endif
-
-        channel->send_response_header(response);
+        HttpChannel::send_reply(req);
         return;
     } else if (req->method() == HttpMethod::POST) {
-        // read buf
-        std::string request;
-        if (!req->header(HttpHeaders::CONTENT_LENGTH).empty()) {
-            Status st;
-            int64_t len = std::stol(req->header(HttpHeaders::CONTENT_LENGTH));
-            if (len > 32 * 1024 * 1024) {
-                st = Status("File size exceed max size(32MB) we can support.");
-            } else {
-                st = save_to_string(&request, len, channel);
-            }
-            if (!st.ok()) {
-                std::string str = st.get_error_msg();
-                HttpResponse response(HttpStatus::OK, &str);
-                channel->send_response(response);
-                return;
-            }
-        } else {
-            std::stringstream ss;
-            ss << "There is no " << HttpHeaders::CONTENT_LENGTH << " in request headers";
-            std::string str = ss.str();
-            HttpResponse response(HttpStatus::OK, &str);
-            channel->send_response(response);
-            return;
-        }
+        std::string request = req->get_request_body();
         // parse address
         std::string result;
         const char* ptr = request.c_str();
@@ -292,12 +235,12 @@ void SymbolAction::handle(HttpRequest* req, HttpChannel* channel) {
                 ptr++;
             }
         }
-        HttpResponse response(HttpStatus::OK, &result);
-        channel->send_response(response);
+
+        HttpChannel::send_reply(req, result);
     }
 }
 
-Status PprofActions::setup(ExecEnv* exec_env, Webserver* http_server) {
+Status PprofActions::setup(ExecEnv* exec_env, EvHttpServer* http_server) {
     http_server->register_handler(HttpMethod::GET, "/pprof/heap",
                                   new HeapAction());
     http_server->register_handler(HttpMethod::GET, "/pprof/growth",
diff --git a/be/src/http/action/pprof_actions.h b/be/src/http/action/pprof_actions.h
index 84ebc37bee026a..33fcce2a390483 100644
--- a/be/src/http/action/pprof_actions.h
+++ b/be/src/http/action/pprof_actions.h
@@ -20,12 +20,12 @@
 
 namespace palo {
 
-class Webserver;
+class EvHttpServer;
 class ExecEnv;
 
 class PprofActions {
 public:
-    static Status setup(ExecEnv* exec_env, Webserver* http_server);
+    static Status setup(ExecEnv* exec_env, EvHttpServer* http_server);
 };
 
 }
diff --git a/be/src/http/action/reload_tablet_action.cpp b/be/src/http/action/reload_tablet_action.cpp
index 9177178347f804..54d9bb07b9ece0 100644
--- a/be/src/http/action/reload_tablet_action.cpp
+++ b/be/src/http/action/reload_tablet_action.cpp
@@ -38,7 +38,7 @@ ReloadTabletAction::ReloadTabletAction(ExecEnv* exec_env) :
     _command_executor = new CommandExecutor();
 }
 
-void ReloadTabletAction::handle(HttpRequest *req, HttpChannel *channel) {
+void ReloadTabletAction::handle(HttpRequest *req) {
     LOG(INFO) << "accept one request " << req->debug_string();
 
     // add tid to cgroup in order to limit read bandwidth
@@ -49,8 +49,7 @@ void ReloadTabletAction::handle(HttpRequest *req, HttpChannel *channel) {
     if (path.empty()) {
         std::string error_msg = std::string(
                 "parameter " + PATH + " not specified in url.");
-        HttpResponse response(HttpStatus::BAD_REQUEST, &error_msg);
-        channel->send_response(response);
+        HttpChannel::send_reply(req, HttpStatus::BAD_REQUEST, error_msg);
         return;
     }
 
@@ -59,8 +58,7 @@ void ReloadTabletAction::handle(HttpRequest *req, HttpChannel *channel) {
     if (tablet_id_str.empty()) {
         std::string error_msg = std::string(
                 "parameter " + TABLET_ID + " not specified in url.");
-        HttpResponse response(HttpStatus::BAD_REQUEST, &error_msg);
-        channel->send_response(response);
+        HttpChannel::send_reply(req, HttpStatus::BAD_REQUEST, error_msg);
         return;
     }
 
@@ -69,8 +67,7 @@ void ReloadTabletAction::handle(HttpRequest *req, HttpChannel *channel) {
     if (schema_hash_str.empty()) {
         std::string error_msg = std::string(
                 "parameter " + SCHEMA_HASH + " not specified in url.");
-        HttpResponse response(HttpStatus::BAD_REQUEST, &error_msg);
-        channel->send_response(response);
+        HttpChannel::send_reply(req, HttpStatus::BAD_REQUEST, error_msg);
         return;
     }
 
@@ -82,20 +79,19 @@ void ReloadTabletAction::handle(HttpRequest *req, HttpChannel *channel) {
         schema_hash = boost::lexical_cast<int64_t>(schema_hash_str);
     } catch (boost::bad_lexical_cast& e) {
         std::string error_msg = std::string("param format is invalid: ") + std::string(e.what());
-        HttpResponse response(HttpStatus::BAD_REQUEST, &error_msg);
-        channel->send_response(response);
+        HttpChannel::send_reply(req, HttpStatus::BAD_REQUEST, error_msg);
         return;
     }
 
     VLOG_ROW << "get reload tablet request: " << tablet_id << "-" << schema_hash;
 
-    reload(path, tablet_id, schema_hash, req, channel);
+    reload(path, tablet_id, schema_hash, req);
 
     LOG(INFO) << "deal with reload tablet request finished! tablet id: " << tablet_id;
 }
 
-void ReloadTabletAction::reload(const std::string& path, int64_t tablet_id, int32_t schema_hash,
-        HttpRequest *req, HttpChannel *channel) {
+void ReloadTabletAction::reload(
+        const std::string& path, int64_t tablet_id, int32_t schema_hash, HttpRequest *req) {
 
     TCloneReq clone_req;
     clone_req.__set_tablet_id(tablet_id);
@@ -107,15 +103,13 @@ void ReloadTabletAction::reload(const std::string& path, int64_t tablet_id, int3
         LOG(WARNING) << "load header failed. status: " << res
                      << ", signature: " << tablet_id;
         std::string error_msg = std::string("load header failed");
-        HttpResponse response(HttpStatus::INTERNAL_SERVER_ERROR, &error_msg);
-        channel->send_response(response);
+        HttpChannel::send_reply(req, HttpStatus::INTERNAL_SERVER_ERROR, error_msg);
         return;
     } else {
         LOG(INFO) << "load header success. status: " << res
                   << ", signature: " << tablet_id;
         std::string result_msg = std::string("load header succeed");
-        HttpResponse response(HttpStatus::OK, &result_msg);
-        channel->send_response(response);
+        HttpChannel::send_reply(req, result_msg);
         return;
     }
 } 
diff --git a/be/src/http/action/reload_tablet_action.h b/be/src/http/action/reload_tablet_action.h
index 0ba8df2cda3a12..b5bb1f156bb647 100644
--- a/be/src/http/action/reload_tablet_action.h
+++ b/be/src/http/action/reload_tablet_action.h
@@ -36,10 +36,10 @@ class ReloadTabletAction : public HttpHandler {
         }
     }
 
-    virtual void handle(HttpRequest *req, HttpChannel *channel);
+    void handle(HttpRequest *req) override;
 private:
     void reload(const std::string& path, int64_t tablet_id, int32_t schema_hash, 
-                HttpRequest *req, HttpChannel *channel);
+                HttpRequest *req);
 
     ExecEnv* _exec_env;
     CommandExecutor* _command_executor;
diff --git a/be/src/http/action/snapshot_action.cpp b/be/src/http/action/snapshot_action.cpp
index df5f330c900447..e842f7e1d26601 100644
--- a/be/src/http/action/snapshot_action.cpp
+++ b/be/src/http/action/snapshot_action.cpp
@@ -13,109 +13,105 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include "http/action/snapshot_action.h"
-
-#include <string>
-#include <sstream>
-
-#include "boost/lexical_cast.hpp"
-
-#include "agent/cgroups_mgr.h"
-#include "http/http_channel.h"
-#include "http/http_headers.h"
-#include "http/http_request.h"
-#include "http/http_response.h"
-#include "http/http_status.h"
-
-namespace palo {
-
-const std::string TABLET_ID = "tablet_id";
-const std::string SCHEMA_HASH = "schema_hash";
-
-SnapshotAction::SnapshotAction(ExecEnv* exec_env) :
-        _exec_env(exec_env) {
-    _command_executor = new CommandExecutor();
-}
-
-void SnapshotAction::handle(HttpRequest *req, HttpChannel *channel) {
-    LOG(INFO) << "accept one request " << req->debug_string();
-
-    // add tid to cgroup in order to limit read bandwidth
-    CgroupsMgr::apply_system_cgroup();
-    // Get tablet id
-    const std::string& tablet_id_str = req->param(TABLET_ID);
-    if (tablet_id_str.empty()) {
-        std::string error_msg = std::string(
-                "parameter " + TABLET_ID + " not specified in url.");
-        HttpResponse response(HttpStatus::BAD_REQUEST, &error_msg);
-        channel->send_response(response);
-        return;
-    }
-
-    // Get schema hash
-    const std::string& schema_hash_str = req->param(SCHEMA_HASH);
-    if (schema_hash_str.empty()) {
-        std::string error_msg = std::string(
-                "parameter " + SCHEMA_HASH + " not specified in url.");
-        HttpResponse response(HttpStatus::BAD_REQUEST, &error_msg);
-        channel->send_response(response);
-        return;
-    }
-
-    // valid str format
-    int64_t tablet_id;
-    int32_t schema_hash;
-    try {
-        tablet_id = boost::lexical_cast<int64_t>(tablet_id_str);
-        schema_hash = boost::lexical_cast<int64_t>(schema_hash_str);
-    } catch (boost::bad_lexical_cast& e) {
-        std::string error_msg = std::string("param format is invalid: ") + std::string(e.what());
-        HttpResponse response(HttpStatus::BAD_REQUEST, &error_msg);
-        channel->send_response(response);
-        return;
-    }
-
-    VLOG_ROW << "get make snapshot tablet info: " << tablet_id << "-" << schema_hash;
-
-    std::string snapshot_path;
-    int64_t ret = make_snapshot(tablet_id, schema_hash, &snapshot_path);
-    if (ret != 0L) {
-        std::string error_msg = std::string("make snapshot failed");
-        HttpResponse response(HttpStatus::INTERNAL_SERVER_ERROR, &error_msg);
-        channel->send_response(response);
-        return;
-    } else {
-        std::stringstream result;
-        result << snapshot_path;
-        std::string result_str = result.str();
-        HttpResponse response(HttpStatus::OK, &result_str);
-        channel->send_response(response);
-    }
-
-    LOG(INFO) << "deal with snapshot request finished! tablet id: " << tablet_id;
-}
-
-int64_t SnapshotAction::make_snapshot(int64_t tablet_id, int32_t schema_hash,
-                                      std::string* snapshot_path) {
-
-    OLAPStatus res = OLAPStatus::OLAP_SUCCESS;
-    res = _command_executor->make_snapshot(tablet_id, schema_hash, snapshot_path);
-    if (res != OLAPStatus::OLAP_SUCCESS) {
-        LOG(WARNING) << "make snapshot failed. status: " << res
-                     << ", signature: " << tablet_id;
-        return -1L;
-    } else {
-        LOG(INFO) << "make snapshot success. status: " << res
-                  << ", signature: " << tablet_id << ". path: " << *snapshot_path;
-    }
-
-    return 0L;
-} 
-
-SnapshotAction::~SnapshotAction() {
-    if (_command_executor != NULL) {
-        delete _command_executor;
-    }
-}
-
-} // end namespace palo
+#include "http/action/snapshot_action.h"
+
+#include <string>
+#include <sstream>
+
+#include "boost/lexical_cast.hpp"
+
+#include "agent/cgroups_mgr.h"
+#include "http/http_channel.h"
+#include "http/http_headers.h"
+#include "http/http_request.h"
+#include "http/http_response.h"
+#include "http/http_status.h"
+
+namespace palo {
+
+const std::string TABLET_ID = "tablet_id";
+const std::string SCHEMA_HASH = "schema_hash";
+
+SnapshotAction::SnapshotAction(ExecEnv* exec_env) :
+        _exec_env(exec_env) {
+    _command_executor = new CommandExecutor();
+}
+
+void SnapshotAction::handle(HttpRequest *req) {
+    LOG(INFO) << "accept one request " << req->debug_string();
+
+    // add tid to cgroup in order to limit read bandwidth
+    CgroupsMgr::apply_system_cgroup();
+    // Get tablet id
+    const std::string& tablet_id_str = req->param(TABLET_ID);
+    if (tablet_id_str.empty()) {
+        std::string error_msg = std::string(
+                "parameter " + TABLET_ID + " not specified in url.");
+
+        HttpChannel::send_reply(req, HttpStatus::BAD_REQUEST, error_msg);
+        return;
+    }
+
+    // Get schema hash
+    const std::string& schema_hash_str = req->param(SCHEMA_HASH);
+    if (schema_hash_str.empty()) {
+        std::string error_msg = std::string(
+                "parameter " + SCHEMA_HASH + " not specified in url.");
+        HttpChannel::send_reply(req, HttpStatus::BAD_REQUEST, error_msg);
+        return;
+    }
+
+    // valid str format
+    int64_t tablet_id;
+    int32_t schema_hash;
+    try {
+        tablet_id = boost::lexical_cast<int64_t>(tablet_id_str);
+        schema_hash = boost::lexical_cast<int64_t>(schema_hash_str);
+    } catch (boost::bad_lexical_cast& e) {
+        std::string error_msg = std::string("param format is invalid: ") + std::string(e.what());
+        HttpChannel::send_reply(req, HttpStatus::BAD_REQUEST, error_msg);
+        return;
+    }
+
+    VLOG_ROW << "get make snapshot tablet info: " << tablet_id << "-" << schema_hash;
+
+    std::string snapshot_path;
+    int64_t ret = make_snapshot(tablet_id, schema_hash, &snapshot_path);
+    if (ret != 0L) {
+        std::string error_msg = std::string("make snapshot failed");
+        HttpChannel::send_reply(req, HttpStatus::INTERNAL_SERVER_ERROR, error_msg);
+        return;
+    } else {
+        std::stringstream result;
+        result << snapshot_path;
+        std::string result_str = result.str();
+        HttpChannel::send_reply(req, result_str);
+    }
+
+    LOG(INFO) << "deal with snapshot request finished! tablet id: " << tablet_id;
+}
+
+int64_t SnapshotAction::make_snapshot(int64_t tablet_id, int32_t schema_hash,
+                                      std::string* snapshot_path) {
+
+    OLAPStatus res = OLAPStatus::OLAP_SUCCESS;
+    res = _command_executor->make_snapshot(tablet_id, schema_hash, snapshot_path);
+    if (res != OLAPStatus::OLAP_SUCCESS) {
+        LOG(WARNING) << "make snapshot failed. status: " << res
+                     << ", signature: " << tablet_id;
+        return -1L;
+    } else {
+        LOG(INFO) << "make snapshot success. status: " << res
+                  << ", signature: " << tablet_id << ". path: " << *snapshot_path;
+    }
+
+    return 0L;
+} 
+
+SnapshotAction::~SnapshotAction() {
+    if (_command_executor != NULL) {
+        delete _command_executor;
+    }
+}
+
+} // end namespace palo
diff --git a/be/src/http/action/snapshot_action.h b/be/src/http/action/snapshot_action.h
index 3cd5c8f99c32cf..915276ff55bdb5 100644
--- a/be/src/http/action/snapshot_action.h
+++ b/be/src/http/action/snapshot_action.h
@@ -13,34 +13,34 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#ifndef  BDG_PALO_BE_SRC_HTTP_SNAPSHOT_ACTION_H
-#define  BDG_PALO_BE_SRC_HTTP_SNAPSHOT_ACTION_H
-
-#include <boost/scoped_ptr.hpp>
-
-#include "http/http_handler.h"
-#include "olap/command_executor.h"
-
-namespace palo {
-
-class ExecEnv;
-
-// make snapshot
-// be_host:be_http_port/api/snapshot?tablet_id=123&schema_hash=456
-class SnapshotAction : public HttpHandler {
-public:
-    explicit SnapshotAction(ExecEnv* exec_env);
-
-    virtual ~SnapshotAction();
-
-    virtual void handle(HttpRequest *req, HttpChannel *channel);
-private:
-    int64_t make_snapshot(int64_t tablet_id, int schema_hash, std::string* snapshot_path);
-
-    ExecEnv* _exec_env;
-    CommandExecutor* _command_executor;
-
-}; // end class SnapshotAction
-
-} // end namespace palo
-#endif // BDG_PALO_BE_SRC_HTTP_SNAPSHOT_ACTION_H
+#ifndef  BDG_PALO_BE_SRC_HTTP_SNAPSHOT_ACTION_H
+#define  BDG_PALO_BE_SRC_HTTP_SNAPSHOT_ACTION_H
+
+#include <boost/scoped_ptr.hpp>
+
+#include "http/http_handler.h"
+#include "olap/command_executor.h"
+
+namespace palo {
+
+class ExecEnv;
+
+// make snapshot
+// be_host:be_http_port/api/snapshot?tablet_id=123&schema_hash=456
+class SnapshotAction : public HttpHandler {
+public:
+    explicit SnapshotAction(ExecEnv* exec_env);
+
+    virtual ~SnapshotAction();
+
+    void handle(HttpRequest *req) override;
+private:
+    int64_t make_snapshot(int64_t tablet_id, int schema_hash, std::string* snapshot_path);
+
+    ExecEnv* _exec_env;
+    CommandExecutor* _command_executor;
+
+}; // end class SnapshotAction
+
+} // end namespace palo
+#endif // BDG_PALO_BE_SRC_HTTP_SNAPSHOT_ACTION_H
diff --git a/be/src/http/download_action.cpp b/be/src/http/download_action.cpp
index 0edbdb3bcdbb7f..41ecb589040717 100644
--- a/be/src/http/download_action.cpp
+++ b/be/src/http/download_action.cpp
@@ -15,6 +15,11 @@
 
 #include "http/download_action.h"
 
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
 #include <string>
 #include <sstream>
 
@@ -54,7 +59,6 @@ DownloadAction::DownloadAction(ExecEnv* exec_env, const std::string& error_log_r
 
 void DownloadAction::handle_normal(
         HttpRequest *req,
-        HttpChannel *channel,
         const std::string& file_param) {
     // check token
     Status status;
@@ -62,8 +66,7 @@ void DownloadAction::handle_normal(
         status = check_token(req);
         if (!status.ok()) {
             std::string error_msg = status.get_error_msg();
-            HttpResponse response(HttpStatus::OK, &error_msg);
-            channel->send_response(response);
+            HttpChannel::send_reply(req, error_msg);
             return;
         }
     }
@@ -71,43 +74,39 @@ void DownloadAction::handle_normal(
     status = check_path_is_allowed(file_param);
     if (!status.ok()) {
         std::string error_msg = status.get_error_msg();
-        HttpResponse response(HttpStatus::OK, &error_msg);
-        channel->send_response(response);
+        HttpChannel::send_reply(req, error_msg);
         return;
     }
 
     if (FileUtils::is_dir(file_param)) {
-        do_dir_response(file_param, req, channel);
+        do_dir_response(file_param, req);
     } else {
-        do_file_response(file_param, req, channel);
+        do_file_response(file_param, req);
     }
 }
 
 void DownloadAction::handle_error_log(
         HttpRequest *req,
-        HttpChannel *channel,
         const std::string& file_param) {
     const std::string absolute_path = _error_log_root_dir + "/" + file_param;
 
     Status status = check_log_path_is_allowed(absolute_path);
     if (!status.ok()) {
         std::string error_msg = status.get_error_msg();
-        HttpResponse response(HttpStatus::OK, &error_msg);
-        channel->send_response(response);
+        HttpChannel::send_reply(req, error_msg);
         return;
     }
 
     if (FileUtils::is_dir(absolute_path)) {
         std::string error_msg = "error log can only be file.";
-        HttpResponse response(HttpStatus::OK, &error_msg);
-        channel->send_response(response);
+        HttpChannel::send_reply(req, error_msg);
         return;
     }
 
-    do_file_response(absolute_path, req, channel);
+    do_file_response(absolute_path, req);
 }
 
-void DownloadAction::handle(HttpRequest *req, HttpChannel *channel) {
+void DownloadAction::handle(HttpRequest *req) {
     LOG(INFO) << "accept one download request " << req->debug_string();
 
     // add tid to cgroup in order to limit read bandwidth
@@ -118,28 +117,26 @@ void DownloadAction::handle(HttpRequest *req, HttpChannel *channel) {
     if (file_path.empty()) {
         std::string error_msg = std::string(
                 "parameter " + FILE_PARAMETER + " not specified in url.");
-        HttpResponse response(HttpStatus::OK, &error_msg);
-        channel->send_response(response);
+        HttpChannel::send_reply(req, error_msg);
         return;
     }
 
     if (_download_type == ERROR_LOG) {
-        handle_error_log(req, channel, file_path);
+        handle_error_log(req, file_path);
     } else if (_download_type == NORMAL) {
-        handle_normal(req, channel, file_path);
+        handle_normal(req, file_path);
     }
 
     LOG(INFO) << "deal with download requesst finished! ";
 }
 
 void DownloadAction::do_dir_response(
-        const std::string& dir_path, HttpRequest *req, HttpChannel *channel) {
+        const std::string& dir_path, HttpRequest *req) {
     std::vector<std::string> files;
     Status status = FileUtils::scan_dir(dir_path, &files);
     if (!status.ok()) {
         LOG(WARNING) << "Failed to scan dir. dir=" << dir_path;
-        HttpResponse response(HttpStatus::INTERNAL_SERVER_ERROR);
-        channel->send_response(response);
+        HttpChannel::send_error(req, HttpStatus::INTERNAL_SERVER_ERROR);
     }
 
     const std::string FILE_DELIMETER_IN_DIR_RESPONSE = "\n";
@@ -150,23 +147,28 @@ void DownloadAction::do_dir_response(
     }
 
     std::string result_str = result.str();
-    HttpResponse response(HttpStatus::OK, &result_str);
-    channel->send_response(response);
+    HttpChannel::send_reply(req, result_str);
     return;
 }
 
-void DownloadAction::do_file_response(
-        const std::string& file_path, HttpRequest *req, HttpChannel *channel) {
+void DownloadAction::do_file_response(const std::string& file_path, HttpRequest *req) {
     // read file content and send response
-    FILE* fp = fopen(file_path.c_str(), "rb");
-    if (fp == nullptr) {
+    int fd = open(file_path.c_str(), O_RDONLY);
+    if (fd < 0) {
         LOG(WARNING) << "Failed to open file: " << file_path;
-        HttpResponse response(HttpStatus::NOT_FOUND);
-        channel->send_response(response);
+        HttpChannel::send_error(req, HttpStatus::NOT_FOUND);
         return;
     }
-    DeferOp close_file(std::bind(&fclose, fp));
-    int64_t file_size = get_file_size(fp);
+    struct stat st;
+    auto res = fstat(fd, &st);
+    if (res < 0) {
+        close(fd);
+        LOG(WARNING) << "Failed to open file: " << file_path;
+        HttpChannel::send_error(req, HttpStatus::NOT_FOUND);
+        return;
+    }
+
+    int64_t file_size = st.st_size;
 
     // TODO(lingbin): process "IF_MODIFIED_SINCE" header
     // TODO(lingbin): process "RANGE" header
@@ -175,58 +177,17 @@ void DownloadAction::do_file_response(
         // analyse range header
     }
 
-    HttpResponse response(HttpStatus::OK);
-    response.add_header(
-            std::string(HttpHeaders::CONTENT_LENGTH),
-            boost::lexical_cast<std::string>(file_size));
-    response.add_header(
-            std::string(HttpHeaders::CONTENT_TYPE),
-            get_content_type(file_path));
+    req->add_output_header(HttpHeaders::CONTENT_TYPE, get_content_type(file_path).c_str());
 
     if (req->method() == HttpMethod::HEAD) {
-        channel->send_response_header(response);
+        close(fd);
+        req->add_output_header(HttpHeaders::CONTENT_LENGTH,
+                               boost::lexical_cast<std::string>(file_size).c_str());
+        HttpChannel::send_reply(req);
         return;
     }
 
-    channel->send_response_header(response);
-    const int BUFFER_SIZE = 4096;
-    char *buffer = new char[BUFFER_SIZE];
-    int32_t readed_size = 0;
-    bool eos = false;
-    do {
-        Status status = get_file_content(fp, buffer, BUFFER_SIZE, &readed_size, &eos);
-        if (!status.ok()) {
-            LOG(ERROR) << "Something is wrong when read file: " << file_path;
-            break;
-        }
-        channel->append_response_content(response, buffer, readed_size);
-    } while (!eos);
-
-    delete[] buffer;
-}
-
-Status DownloadAction::get_file_content(
-        FILE* fp, char* buffer, int32_t buffer_size,
-        int32_t* readed_size, bool* eos) {
-    *readed_size = fread(buffer, sizeof(char), buffer_size, fp);
-    if (*readed_size != buffer_size) {
-        if (::ferror(fp)) {
-            return Status("something wrong when read file");
-        } else if (::feof(fp)) {
-            *eos = true;
-            return Status::OK;
-        }
-    }
-    *eos = false;
-    return Status::OK;
-}
-
-int64_t DownloadAction::get_file_size(FILE* fp) {
-    int64_t current_pos = ::ftell(fp);
-    ::fseek(fp, 0, SEEK_END);
-    int64_t file_size = ftell(fp);
-    ::fseek(fp, current_pos, SEEK_SET);
-    return file_size;
+    HttpChannel::send_file(req, fd, 0, file_size);
 }
 
 // If 'file_name' contains a dot but does not consist solely of one or to two dots,
diff --git a/be/src/http/download_action.h b/be/src/http/download_action.h
index bb8d35dc5a3d8c..528ec18a66ad66 100644
--- a/be/src/http/download_action.h
+++ b/be/src/http/download_action.h
@@ -39,7 +39,7 @@ class DownloadAction : public HttpHandler {
 
     virtual ~DownloadAction() {}
 
-    virtual void handle(HttpRequest *req, HttpChannel *channel);
+    void handle(HttpRequest *req) override;
 
 private:
     enum DOWNLOAD_TYPE {
@@ -51,14 +51,13 @@ class DownloadAction : public HttpHandler {
     Status check_path_is_allowed(const std::string& path);
     Status check_log_path_is_allowed(const std::string& file_path);
 
-    void handle_normal(HttpRequest *req, HttpChannel *channel, const std::string& file_param);
+    void handle_normal(HttpRequest *req, const std::string& file_param);
     void handle_error_log(
             HttpRequest *req,
-            HttpChannel *channel,
             const std::string& file_param);
 
-    void do_file_response(const std::string& dir_path, HttpRequest *req, HttpChannel *channel);
-    void do_dir_response(const std::string& dir_path, HttpRequest *req, HttpChannel *channel);
+    void do_file_response(const std::string& dir_path, HttpRequest *req);
+    void do_dir_response(const std::string& dir_path, HttpRequest *req);
 
     Status get_file_content(
             FILE* fp, char* buffer, int32_t buffer_size,
diff --git a/be/src/http/ev_http_server.cpp b/be/src/http/ev_http_server.cpp
new file mode 100644
index 00000000000000..0c4bc3368fbafc
--- /dev/null
+++ b/be/src/http/ev_http_server.cpp
@@ -0,0 +1,262 @@
+// Copyright (c) 2017, Baidu.com, Inc. All Rights Reserved
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "http/ev_http_server.h"
+
+#include <memory>
+#include <sstream>
+
+#include <event2/buffer.h>
+#include <event2/bufferevent.h>
+#include <event2/event.h>
+#include <event2/http.h>
+#include <event2/http_struct.h>
+#include <event2/keyvalq_struct.h>
+
+#include "common/logging.h"
+#include "service/brpc.h"
+#include "http/http_request.h"
+#include "http/http_handler.h"
+#include "http/http_headers.h"
+#include "http/http_channel.h"
+#include "util/debug_util.h"
+
+namespace palo {
+
+static void on_chunked(struct evhttp_request* ev_req, void* param) {
+    HttpRequest* request = (HttpRequest*)ev_req->on_free_cb_arg;
+    request->handler()->on_chunk_data(request);
+}
+
+static void on_free(struct evhttp_request* ev_req, void* arg) {
+    HttpRequest* request = (HttpRequest*)arg;
+    delete request;
+}
+
+static void on_request(struct evhttp_request *ev_req, void *arg) {
+    auto request = (HttpRequest*)ev_req->on_free_cb_arg;
+    if (request == nullptr) {
+        // In this case, request's on_header return -1
+        return;
+    }
+    request->handler()->handle(request);
+}
+
+static int on_header(struct evhttp_request* ev_req, void* param) {
+    EvHttpServer* server = (EvHttpServer*)ev_req->on_complete_cb_arg;
+    return server->on_header(ev_req);
+}
+
+// param is pointer of EvHttpServer
+static int on_connection(struct evhttp_request* req, void* param) {
+    evhttp_request_set_header_cb(req, on_header);
+    // only used on_complete_cb's argument
+    evhttp_request_set_on_complete_cb(req, nullptr, param);
+    return 0;
+}
+
+EvHttpServer::EvHttpServer(int port, int num_workers)
+        : _host("0.0.0.0"), _port(port), _num_workers(num_workers) {
+    DCHECK_GT(_num_workers, 0);
+    auto res = pthread_rwlock_init(&_rw_lock, nullptr);                
+    DCHECK_EQ(res, 0);
+}
+
+EvHttpServer::EvHttpServer(const std::string& host, int port, int num_workers)
+        : _host(host), _port(port), _num_workers(num_workers) {
+    DCHECK_GT(_num_workers, 0);
+    auto res = pthread_rwlock_init(&_rw_lock, nullptr);                
+    DCHECK_EQ(res, 0);
+}
+
+EvHttpServer::~EvHttpServer() {
+    pthread_rwlock_destroy(&_rw_lock);
+}
+
+Status EvHttpServer::start() {
+    // bind to 
+    RETURN_IF_ERROR(_bind());
+    for (int i = 0; i < _num_workers; ++i) {
+        auto worker = [this, i] () {
+            LOG(INFO) << "EvHttpSerer worker start, id=" << i;
+            std::shared_ptr<event_base> base(
+                event_base_new(), [] (event_base* base) { event_base_free(base); });
+            if (base == nullptr) {
+                LOG(WARNING) << "Couldn't create an event_base.";
+                return; 
+            }
+            /* Create a new evhttp object to handle requests. */
+            std::shared_ptr<evhttp> http(
+                evhttp_new(base.get()), [] (evhttp* http) { evhttp_free(http); });
+            if (http == nullptr) {
+                LOG(WARNING) << "Couldn't create an evhttp.";
+                return; 
+            }
+            auto res = evhttp_accept_socket(http.get(), _server_fd);
+            if (res < 0) {
+                LOG(WARNING) << "evhttp accept socket failed";
+                return;
+            }
+
+            evhttp_set_newreqcb(http.get(), on_connection, this);
+            evhttp_set_gencb(http.get(), on_request, this);
+
+            event_base_dispatch(base.get());
+        };
+        _workers.emplace_back(worker);
+    }
+    return Status::OK;
+}
+
+void EvHttpServer::stop() {
+}
+
+void EvHttpServer::join() {
+}
+
+Status EvHttpServer::_bind() {
+    butil::EndPoint point;
+    auto res = butil::hostname2endpoint(_host.c_str(), _port, &point);
+    if (res < 0) {
+        std::stringstream ss;
+        ss << "convert address failed, host=" << _host << ", port=" << _port;
+        return Status(ss.str());
+    }
+    _server_fd = butil::tcp_listen(point, true);
+    if (_server_fd < 0) {
+        char buf[64];
+        std::stringstream ss;
+        ss << "tcp listen failed, errno=" << errno
+            << ", errmsg=" << strerror_r(errno, buf, sizeof(buf));
+        return Status(ss.str());
+    }
+    res = butil::make_non_blocking(_server_fd);
+    if (res < 0) {
+        char buf[64];
+        std::stringstream ss;
+        ss << "make socket to non_blocking failed, errno=" << errno
+            << ", errmsg=" << strerror_r(errno, buf, sizeof(buf));
+        return Status(ss.str());
+    }
+    return Status::OK;
+}
+
+bool EvHttpServer::register_handler(
+        const HttpMethod& method, const std::string& path, HttpHandler* handler) {
+    if (handler == nullptr) {
+        LOG(WARNING) << "dummy handler for http method " << method << " with path " << path;
+        return false;
+    }
+
+    bool result = true;
+    pthread_rwlock_wrlock(&_rw_lock);
+    PathTrie<HttpHandler*>* root = nullptr;
+    switch (method) {
+    case GET:
+        root = &_get_handlers;
+        break;
+    case PUT:
+        root = &_put_handlers;
+        break;
+    case POST:
+        root = &_post_handlers;
+        break;
+    case DELETE:
+        root = &_delete_handlers;
+        break;
+    case HEAD:
+        root = &_head_handlers;
+        break;
+    case OPTIONS:
+        root = &_options_handlers;
+        break;
+    default:
+        LOG(WARNING) << "unknown HTTP method, method=" << method;
+        result = false;
+    }
+    if (result) {
+        result = root->insert(path, handler);
+    }
+    pthread_rwlock_unlock(&_rw_lock);
+    
+    return result;
+}
+
+int EvHttpServer::on_header(struct evhttp_request* ev_req) {
+    std::unique_ptr<HttpRequest> request(new HttpRequest(ev_req));
+    auto res = request->init_from_evhttp();
+    if (res < 0) {
+        return -1;
+    }
+    auto handler = _find_handler(request.get());
+    if (handler == nullptr) {
+        evhttp_remove_header(evhttp_request_get_input_headers(ev_req), HttpHeaders::EXPECT);
+        HttpChannel::send_reply(request.get(), HttpStatus::NOT_FOUND, "Not Found");
+        return 0;
+    }
+    // set handler before call on_header, because handler_ctx will set in on_header
+    request->set_handler(handler);
+    res = handler->on_header(request.get());
+    if (res < 0) {
+        // reply has already sent by handler's on_header
+        evhttp_remove_header(evhttp_request_get_input_headers(ev_req), HttpHeaders::EXPECT);
+        return 0;
+    }
+
+    // If request body would be big(greater than 1GB),
+    // it is better that request_will_be_read_progressively is set true, 
+    // this can make body read in chunk, not in total
+    if (handler->request_will_be_read_progressively()) {
+        evhttp_request_set_chunked_cb(ev_req, on_chunked);
+    }
+
+    evhttp_request_set_on_free_cb(ev_req, on_free, request.release());
+    return 0;
+}
+
+HttpHandler* EvHttpServer::_find_handler(HttpRequest* req) {
+    auto& path = req->raw_path();
+
+    HttpHandler* handler = nullptr;
+
+    pthread_rwlock_rdlock(&_rw_lock);
+    switch (req->method()) {
+    case GET:
+        _get_handlers.retrieve(path, &handler, req->params());
+        break;
+    case PUT:
+        _put_handlers.retrieve(path, &handler, req->params());
+        break;
+    case POST:
+        _post_handlers.retrieve(path, &handler, req->params());
+        break;
+    case DELETE:
+        _delete_handlers.retrieve(path, &handler, req->params());
+        break;
+    case HEAD:
+        _head_handlers.retrieve(path, &handler, req->params());
+        break;
+    case OPTIONS:
+        _options_handlers.retrieve(path, &handler, req->params());
+        break;
+    default:
+        LOG(WARNING) << "unknown HTTP method, method=" << req->method();
+        break;
+    }
+    pthread_rwlock_unlock(&_rw_lock);
+    return handler;
+}
+
+}
diff --git a/be/src/http/ev_http_server.h b/be/src/http/ev_http_server.h
new file mode 100644
index 00000000000000..0e7cad64fc3149
--- /dev/null
+++ b/be/src/http/ev_http_server.h
@@ -0,0 +1,70 @@
+// Copyright (c) 2017, Baidu.com, Inc. All Rights Reserved
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include <string>
+#include <thread>
+#include <vector>
+
+#include "common/status.h"
+#include "util/path_trie.hpp"
+#include "http/http_method.h"
+
+namespace palo {
+
+class HttpHandler;
+class HttpRequest;
+
+class EvHttpServer {
+public:
+    EvHttpServer(int port, int num_workers = 1);
+    EvHttpServer(const std::string& host, int port, int num_workers = 1);
+    ~EvHttpServer();
+
+    // register handler for an a path-method pair
+    bool register_handler(
+        const HttpMethod& method, const std::string& path, HttpHandler* handler);
+    Status start();
+    void stop();
+    void join();
+
+    // callback 
+    int on_header(struct evhttp_request* ev_req);
+
+private:
+    Status _bind();
+    HttpHandler* _find_handler(HttpRequest* req);
+
+private:
+    // input param
+    std::string _host;
+    int _port;
+    int _num_workers;
+
+    int _server_fd = -1;
+    std::vector<std::thread> _workers;
+
+    pthread_rwlock_t _rw_lock;
+
+    PathTrie<HttpHandler*> _get_handlers;
+    PathTrie<HttpHandler*> _put_handlers;
+    PathTrie<HttpHandler*> _post_handlers;
+    PathTrie<HttpHandler*> _delete_handlers;
+    PathTrie<HttpHandler*> _head_handlers;
+    PathTrie<HttpHandler*> _options_handlers;
+};
+
+}
diff --git a/be/src/http/http_channel.cpp b/be/src/http/http_channel.cpp
index 7949dbaf64bb4f..88b7931e930657 100644
--- a/be/src/http/http_channel.cpp
+++ b/be/src/http/http_channel.cpp
@@ -18,110 +18,50 @@
 #include <sstream>
 #include <string>
 
+#include <event2/buffer.h>
+#include <event2/http.h>
+
 #include "http/http_request.h"
 #include "http/http_response.h"
 #include "http/http_headers.h"
 #include "http/http_status.h"
-#include "http/mongoose.h"
 #include "common/logging.h"
 
 namespace palo {
 
-HttpChannel::HttpChannel(const HttpRequest& request, mg_connection* mg_conn) :
-        _request(request),
-        _mg_conn(mg_conn) {
-}
-
-void HttpChannel::send_response(const HttpResponse& response) {
-    // Send status line
-    mg_printf(_mg_conn, "HTTP/1.1 %s %s\r\n",
-              to_code(response.status()).c_str(),
-              defalut_reason(response.status()).c_str());
-    // send all headers
-    for (auto& it : response.headers()) {
-        mg_printf(_mg_conn, "%s: ", it.first.c_str());
-        for (int i = 0; i < it.second.size(); ++i) {
-            if (i != 0) {
-                mg_printf(_mg_conn, ",");
-            }
-            mg_printf(_mg_conn, "%s", it.second[i].c_str());
-        }
-        mg_printf(_mg_conn, "\r\n");
-    }
-    // Content type
-    const std::string* content = response.content();
-    bool contain_content =  content != nullptr && !content->empty();
-    if (contain_content) {
-        mg_printf(_mg_conn, "%s: %s\r\n",
-                  HttpHeaders::CONTENT_TYPE,
-                  response.content_type().c_str());
-        mg_printf(_mg_conn, "%s: %zu\r\n",
-                  HttpHeaders::CONTENT_LENGTH, content->length());
-    }
-    // customer headers
-    // End of header
-    mg_printf(_mg_conn, "\r\n");
-    if (contain_content) {
-        mg_write(_mg_conn, content->c_str(), content->length());
-        _send_bytes += content->length();
-    }
-}
-
 // Send Unauthorized status with basic challenge
-void HttpChannel::send_basic_challenge(const std::string& realm) {
+void HttpChannel::send_basic_challenge(HttpRequest* req, const std::string& realm) {
     static std::string s_prompt_str = "Please provide your userid and password\n";
-    HttpResponse response(HttpStatus::UNAUTHORIZED, &s_prompt_str);
     std::stringstream ss;
     ss << "Basic realm=\"" << realm << "\"";
-    response.add_header(HttpHeaders::WWW_AUTHENTICATE, ss.str());
-
-    send_response(response);
+    req->add_output_header(HttpHeaders::WWW_AUTHENTICATE, ss.str().c_str());
+    send_reply(req, HttpStatus::UNAUTHORIZED, s_prompt_str);
 }
 
-void HttpChannel::send_response_header(const HttpResponse& response) {
-    // Send status line
-    mg_printf(_mg_conn, "HTTP/1.1 %s %s\r\n",
-            to_code(response.status()).c_str(),
-            defalut_reason(response.status()).c_str());
-
-    // Headers
-    auto headers = response.headers();
-    auto iter = headers.begin();
-    for (; iter != headers.end(); ++iter) {
-        auto& header_values = iter->second;
-        auto value_iter = header_values.begin();
-        for (; value_iter != header_values.end(); ++value_iter) {
-            mg_printf(_mg_conn, "%s: %s\r\n",
-                    iter->first.c_str(),
-                    value_iter->c_str());
-        }
-    }
-
-    // End of header
-    mg_printf(_mg_conn, "\r\n");
+void HttpChannel::send_error(HttpRequest* request, HttpStatus status) {
+    evhttp_send_error(request->get_evhttp_request(), status, defalut_reason(status).c_str());
 }
 
-void HttpChannel::send_response_content(const HttpResponse& response) {
-    const std::string* content = response.content();
-    bool contain_content =  content != nullptr && !content->empty();
-    if (contain_content) {
-        mg_write(_mg_conn, content->c_str(), content->length());
-        _send_bytes += content->length();
-    }
+void HttpChannel::send_reply(HttpRequest* request, HttpStatus status) {
+    evhttp_send_reply(request->get_evhttp_request(), status,
+                      defalut_reason(status).c_str(), nullptr);
 }
 
-void HttpChannel::append_response_content(
-        const HttpResponse& response,
-        const char* content,
-        int32_t content_size) {
-    mg_write(_mg_conn, content, content_size);
-    _send_bytes += content_size;
+void HttpChannel::send_reply(
+        HttpRequest* request, HttpStatus status, const std::string& content) {
+    auto evb = evbuffer_new();
+    evbuffer_add(evb, content.c_str(), content.size());
+    evhttp_send_reply(request->get_evhttp_request(), status, defalut_reason(status).c_str(), evb);
+    evbuffer_free(evb);
 }
 
-int HttpChannel::read(char* buf, int len) {
-    return mg_read(_mg_conn, buf, len);
-}
-void HttpChannel::update_content_length(int64_t len) {
+void HttpChannel::send_file(HttpRequest* request, int fd, size_t off, size_t size) {
+    auto evb = evbuffer_new();
+    evbuffer_add_file(evb, fd, off, size);
+    evhttp_send_reply(request->get_evhttp_request(),
+                      HttpStatus::OK,
+                      defalut_reason(HttpStatus::OK).c_str(), evb);
+    evbuffer_free(evb);
 }
 
 }
diff --git a/be/src/http/http_channel.h b/be/src/http/http_channel.h
index 81d083ef8c419a..ae2587ba540d0b 100644
--- a/be/src/http/http_channel.h
+++ b/be/src/http/http_channel.h
@@ -19,6 +19,8 @@
 #include <string>
 #include <cstdint>
 
+#include "http/http_status.h"
+
 struct mg_connection;
 
 namespace palo {
@@ -28,36 +30,21 @@ class HttpResponse;
 
 class HttpChannel {
 public:
-    // Wrapper for mongoose
-    HttpChannel(const HttpRequest& request, mg_connection* mg_conn);
-
-    void send_response(const HttpResponse& response);
+    // Helper maybe used everywhere
+    static void send_basic_challenge(HttpRequest* req, const std::string& realm);
 
-    void send_response_header(const HttpResponse& response);
-    void send_response_content(const HttpResponse& response);
-    void append_response_content(
-            const HttpResponse& response,
-            const char* content,
-            int32_t content_size);
-    void send_status_line();
+    static void send_error(HttpRequest* request, HttpStatus status);
 
-    const HttpRequest& request() const {
-        return _request;
+    // send 200(OK) reply with content
+    static inline void send_reply(HttpRequest* request, const std::string& content) {
+        send_reply(request, HttpStatus::OK, content);
     }
 
-    void update_content_length(int64_t len);
+    static void send_reply(HttpRequest* request, HttpStatus status = HttpStatus::OK);
 
-    int read(char* buf, int len);
-
-    // Helper maybe used everywhere
-    void send_basic_challenge(const std::string& realm);
+    static void send_reply(HttpRequest* request, HttpStatus status, const std::string& content);
 
-    int64_t send_bytes() const { return _send_bytes; }
-private:
-    const HttpRequest& _request;
-    // save mongoose connection here
-    mg_connection* _mg_conn;
-    int64_t _send_bytes = 0;
+    static void send_file(HttpRequest* request, int fd, size_t off, size_t size);
 };
 
 }
diff --git a/be/src/http/http_handler.h b/be/src/http/http_handler.h
index 967d0da505dc97..6e8bb2a75247b1 100644
--- a/be/src/http/http_handler.h
+++ b/be/src/http/http_handler.h
@@ -24,8 +24,19 @@ class HttpChannel;
 // Handler for on http request
 class HttpHandler {
 public:
-    virtual ~HttpHandler() {}
-    virtual void handle(HttpRequest *req, HttpChannel *channel) = 0;
+    virtual ~HttpHandler() { }
+    virtual void handle(HttpRequest *req) = 0;
+
+    virtual bool request_will_be_read_progressively() { return false; }
+
+    // This funciton will called when all headers are recept.
+    // return 0 if process successfully. otherwise return -1;
+    // If return -1, on_header function should send_reply to HTTP client
+    // and function wont send any reply any more.
+    virtual int on_header(HttpRequest* req) { return 0; }
+
+    virtual void on_chunk_data(HttpRequest* req) { }
+    virtual void free_handler_ctx(void* handler_ctx) { }
 };
 
 }
diff --git a/be/src/http/http_method.h b/be/src/http/http_method.h
index bd112438fb5ff2..7dc1a991cb73bb 100644
--- a/be/src/http/http_method.h
+++ b/be/src/http/http_method.h
@@ -18,6 +18,8 @@
 
 #include <string>
 
+#include <event2/http.h>
+
 namespace palo {
 
 // Http method enumerate
@@ -34,6 +36,26 @@ enum HttpMethod {
 // Convert string to HttpMethod
 HttpMethod to_http_method(const char* method);
 
+inline HttpMethod to_http_method(evhttp_cmd_type type) {
+    switch (type) {
+    case EVHTTP_REQ_GET:
+        return HttpMethod::GET;
+    case EVHTTP_REQ_POST:
+        return HttpMethod::POST;
+    case EVHTTP_REQ_HEAD:
+        return HttpMethod::HEAD;
+    case EVHTTP_REQ_PUT:
+        return HttpMethod::PUT;
+    case EVHTTP_REQ_DELETE:
+        return HttpMethod::DELETE;
+    case EVHTTP_REQ_OPTIONS:
+        return HttpMethod::OPTIONS;
+    default:
+        return HttpMethod::UNKNOWN;
+    }
+    return HttpMethod::UNKNOWN;
+}
+
 std::string to_method_desc(const HttpMethod& method);
 
 }
diff --git a/be/src/http/http_request.cpp b/be/src/http/http_request.cpp
index d319b7a94ca247..feb6c69267ad16 100644
--- a/be/src/http/http_request.cpp
+++ b/be/src/http/http_request.cpp
@@ -21,7 +21,12 @@
 #include <boost/foreach.hpp>
 #include <boost/algorithm/string.hpp>
 
-#include "http/mongoose.h"
+#include <event2/buffer.h>
+#include <event2/bufferevent.h>
+#include <event2/http.h>
+#include <event2/keyvalq_struct.h>
+
+#include "http/http_handler.h"
 
 #include "common/logging.h"
 #include "util/url_coding.h"
@@ -30,66 +35,52 @@ namespace palo {
 
 static std::string s_empty = "";
 
-HttpRequest::HttpRequest(mg_connection* conn) :
-        _conn(conn) {
-    init();
+HttpRequest::HttpRequest(evhttp_request* evhttp_request)
+        : _ev_req(evhttp_request) {
 }
 
-bool HttpRequest::init() {
-    const mg_request_info* mg_req = mg_get_request_info(_conn);
-    _method = to_http_method(mg_req->request_method);
+HttpRequest::~HttpRequest() {
+    if (_handler != nullptr && _handler_ctx != nullptr) {
+        _handler->free_handler_ctx(_handler_ctx);
+    }
+}
 
-    // Method
+int HttpRequest::init_from_evhttp() {
+    _method = to_http_method(evhttp_request_get_command(_ev_req));
     if (_method == HttpMethod::UNKNOWN) {
-        LOG(WARNING) << "Unknown method of http requeset " << mg_req;
-        return false;
+        LOG(WARNING) << "unknown method of HTTP request, method="
+            << evhttp_request_get_command(_ev_req);
+        return -1;
     }
-    _uri = mg_req->uri;
-    _raw_path = mg_req->uri;
-    
-    // convert header
-    for (int i = 0; i < mg_req->num_headers; ++i) {
-        _headers.insert(std::make_pair(mg_req->http_headers[i].name, 
-                                       mg_req->http_headers[i].value));
+    _uri = evhttp_request_get_uri(_ev_req);
+    // conver header
+    auto headers = evhttp_request_get_input_headers(_ev_req);
+    for (auto header = headers->tqh_first;
+         header != nullptr;
+         header = header->next.tqe_next) {
+        _headers.emplace(header->key, header->value);
     }
-
-    // parse parameters in query string
-    if (mg_req->query_string != nullptr) {
-        parse_params(mg_req->query_string);
+    // parse
+    auto ev_uri = evhttp_request_get_evhttp_uri(_ev_req);
+    _raw_path = evhttp_uri_get_path(ev_uri);
+    auto query = evhttp_uri_get_query(ev_uri);
+    if (query == nullptr || *query == '\0') {
+        return 0;
     }
-
-    return true;
-}
-
-void HttpRequest::parse_params(const char* query) {
-    std::vector<std::string> arg_pairs;
-    // TODO(zc): remove boost
-    boost::split(arg_pairs, query, boost::is_any_of("&"));
-
-    BOOST_FOREACH(const std::string & arg_pair, arg_pairs) {
-        std::vector<std::string> key_value;
-        boost::split(key_value, arg_pair, boost::is_any_of("="));
-
-        if (key_value.empty()) {
-            continue;
-        }
-
-        std::string key;
-
-        if (!url_decode(key_value[0], &key)) {
-            continue;
-        }
-
-        std::string value;
-
-        if (!url_decode((key_value.size() >= 2 ? key_value[1] : ""), &value)) {
-            continue;
-        }
-
-        boost::algorithm::to_lower(key);
-        _query_params[key] = value;
+    struct evkeyvalq params;
+    auto res = evhttp_parse_query_str(query, &params);
+    if (res < 0) {
+        LOG(WARNING) << "parse query str failed, query=" << query;
+        return res;
+    }
+    for (auto param = params.tqh_first;
+         param != nullptr;
+         param = param->next.tqe_next) {
+        _query_params.emplace(param->key, param->value);
     }
     _params.insert(_query_params.begin(), _query_params.end());
+    evhttp_clear_headers(&params);
+    return 0;
 }
 
 std::string HttpRequest::debug_string() const {
@@ -126,4 +117,25 @@ const std::string& HttpRequest::param(const std::string& key) const {
     return iter->second;
 }
 
+void HttpRequest::add_output_header(const char* key, const char* value) {
+#ifndef BE_TEST
+    evhttp_add_header(evhttp_request_get_output_headers(_ev_req), key, value);
+#endif
+}
+
+std::string HttpRequest::get_request_body() {
+    if (!_request_body.empty()) {
+        return _request_body;
+    }
+    // read buf
+    auto evbuf = evhttp_request_get_input_buffer(_ev_req);
+    if (evbuf == nullptr) {
+        return _request_body;
+    }
+    auto length = evbuffer_get_length(evbuf);
+    _request_body.resize(length);
+    evbuffer_remove(evbuf, (char*)_request_body.data(), length);
+    return _request_body;
+}
+
 }
diff --git a/be/src/http/http_request.h b/be/src/http/http_request.h
index e412482988cf17..6832bd1caf444f 100644
--- a/be/src/http/http_request.h
+++ b/be/src/http/http_request.h
@@ -22,16 +22,19 @@
 #include "http/http_method.h"
 
 struct mg_connection;
+struct evhttp_request;
 
 namespace palo {
 
+class HttpHandler;
+
 class HttpRequest {
 public:
-    // Now we only construct http request from mongoose
-    HttpRequest(mg_connection* conn);
+    HttpRequest(evhttp_request* ev_req);
 
-    ~HttpRequest() {
-    }
+    ~HttpRequest();
+
+    int init_from_evhttp();
 
     HttpMethod method() const {
         return _method;
@@ -65,14 +68,21 @@ class HttpRequest {
         return _query_params;
     }
 
+    std::string get_request_body();
+
+    void add_output_header(const char* key, const char* value);
+
     std::string debug_string() const;
 
-private:
-    // construct from mg_connection
-    bool init();
+    void set_handler(HttpHandler* handler) { _handler = handler; }
+    HttpHandler* handler() const { return _handler; }
+
+    struct evhttp_request* get_evhttp_request() const { return _ev_req; }
 
-    void parse_params(const char* query);
+    void* handler_ctx() const { return _handler_ctx; }
+    void set_handler_ctx(void* ctx) { _handler_ctx = ctx; }
 
+private:
     HttpMethod _method;
     std::string _uri;
     std::string _raw_path;
@@ -80,8 +90,11 @@ class HttpRequest {
     std::map<std::string, std::string> _params;
     std::map<std::string, std::string> _query_params;
 
-    // save mongoose connection here
-    mg_connection* _conn;
+    struct evhttp_request* _ev_req = nullptr; 
+    HttpHandler* _handler = nullptr;
+
+    void* _handler_ctx = nullptr;
+    std::string _request_body;
 };
 
 }
diff --git a/be/src/http/mongoose.cpp b/be/src/http/mongoose.cpp
deleted file mode 100644
index f6e0c2aaef618e..00000000000000
--- a/be/src/http/mongoose.cpp
+++ /dev/null
@@ -1,4873 +0,0 @@
-// Copyright (c) 2004-2013 Sergey Lyubka <valenok@gmail.com>
-// Copyright (c) 2013-2018 Cesanta Software Limited
-// All rights reserved
-
-// This software is dual-licensed: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License version 2 as
-// published by the Free Software Foundation. For the terms of this
-// license, see <http://www.gnu.org/licenses/>.
-
-// You are free to use this software under the terms of the GNU General
-// Public License, but WITHOUT ANY WARRANTY; without even the implied
-// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-// See the GNU General Public License for more details.
-
-// Alternatively, you can license this software under a commercial
-// license, as set out in <https://www.cesanta.com/license>.
-
-#if defined(_WIN32)
-#define _CRT_SECURE_NO_WARNINGS // Disable deprecation warning in VS2005
-#else 
-#ifdef __linux__
-#define _XOPEN_SOURCE 600     // For flockfile() on Linux
-#endif
-#define _LARGEFILE_SOURCE     // Enable 64-bit file offsets
-#ifndef __STDC_FORMAT_MACROS
-#define __STDC_FORMAT_MACROS  // <inttypes.h> wants this for C++
-#endif
-#define __STDC_LIMIT_MACROS   // C++ wants that for INT64_MAX
-#endif
-
-#ifdef WIN32_LEAN_AND_MEAN
-#undef WIN32_LEAN_AND_MEAN    // Disable WIN32_LEAN_AND_MEAN, if necessary
-#endif
-
-#if defined(__SYMBIAN32__)
-#define NO_SSL // SSL is not supported
-#define NO_CGI // CGI is not supported
-#define PATH_MAX FILENAME_MAX
-#endif // __SYMBIAN32__
-
-#include <sys/epoll.h>
-
-#ifndef _WIN32_WCE // Some ANSI #includes are not available on Windows CE
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <errno.h>
-#include <signal.h>
-#include <fcntl.h>
-#endif // !_WIN32_WCE
-
-#include <time.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdarg.h>
-#include <assert.h>
-#include <string.h>
-#include <ctype.h>
-#include <limits.h>
-#include <stddef.h>
-#include <stdio.h>
-
-#if defined(_WIN32) && !defined(__SYMBIAN32__) // Windows specific
-#define _WIN32_WINNT 0x0400 // To make it link in VS2005
-#include <windows.h>
-#include <winsock2.h>
-#include <ws2tcpip.h>
-
-#ifndef PATH_MAX
-#define PATH_MAX MAX_PATH
-#endif
-
-#ifndef _WIN32_WCE
-#include <process.h>
-#include <direct.h>
-#include <io.h>
-#else // _WIN32_WCE
-#define NO_CGI // WinCE has no pipes
-
-typedef long off_t;
-
-#define errno   GetLastError()
-#define strerror(x)  _ultoa(x, (char *) _alloca(sizeof(x) *3 ), 10)
-#endif // _WIN32_WCE
-
-#define MAKEUQUAD(lo, hi) ((uint64_t)(((uint32_t)(lo)) | \
-      ((uint64_t)((uint32_t)(hi))) << 32))
-#define RATE_DIFF 10000000 // 100 nsecs
-#define EPOCH_DIFF MAKEUQUAD(0xd53e8000, 0x019db1de)
-#define SYS2UNIX_TIME(lo, hi) \
-  (time_t) ((MAKEUQUAD((lo), (hi)) - EPOCH_DIFF) / RATE_DIFF)
-
-// Visual Studio 6 does not know __func__ or __FUNCTION__
-// The rest of MS compilers use __FUNCTION__, not C99 __func__
-// Also use _strtoui64 on modern M$ compilers
-#if defined(_MSC_VER) && _MSC_VER < 1300
-#define STRX(x) #x
-#define STR(x) STRX(x)
-#define __func__ "line " STR(__LINE__)
-#define strtoull(x, y, z) strtoul(x, y, z)
-#define strtoll(x, y, z) strtol(x, y, z)
-#else
-#define __func__  __FUNCTION__
-#define strtoull(x, y, z) _strtoui64(x, y, z)
-#define strtoll(x, y, z) _strtoi64(x, y, z)
-#endif // _MSC_VER
-
-#define ERRNO   GetLastError()
-#define NO_SOCKLEN_T
-#define SSL_LIB   "ssleay32.dll"
-#define CRYPTO_LIB  "libeay32.dll"
-#define O_NONBLOCK  0
-#if !defined(EWOULDBLOCK)
-#define EWOULDBLOCK  WSAEWOULDBLOCK
-#endif // !EWOULDBLOCK
-#define _POSIX_
-#define INT64_FMT  "I64d"
-
-#define WINCDECL __cdecl
-#define SHUT_WR 1
-#define snprintf _snprintf
-#define vsnprintf _vsnprintf
-#define mg_sleep(x) Sleep(x)
-
-#define pipe(x) _pipe(x, MG_BUF_LEN, _O_BINARY)
-#define popen(x, y) _popen(x, y)
-#define pclose(x) _pclose(x)
-#define close(x) _close(x)
-#define dlsym(x,y) GetProcAddress((HINSTANCE) (x), (y))
-#define RTLD_LAZY  0
-#define fseeko(x, y, z) _lseeki64(_fileno(x), (y), (z))
-#define fdopen(x, y) _fdopen((x), (y))
-#define write(x, y, z) _write((x), (y), (unsigned) z)
-#define read(x, y, z) _read((x), (y), (unsigned) z)
-#define flockfile(x) EnterCriticalSection(&global_log_file_lock)
-#define funlockfile(x) LeaveCriticalSection(&global_log_file_lock)
-#define sleep(x) Sleep((x) * 1000)
-
-#if !defined(fileno)
-#define fileno(x) _fileno(x)
-#endif // !fileno MINGW #defines fileno
-
-typedef HANDLE pthread_mutex_t;
-typedef struct {HANDLE signal, broadcast;} pthread_cond_t;
-typedef DWORD pthread_t;
-#define pid_t HANDLE // MINGW typedefs pid_t to int. Using #define here.
-
-static int pthread_mutex_lock(pthread_mutex_t *);
-static int pthread_mutex_unlock(pthread_mutex_t *);
-static FILE *mg_fopen(const char *path, const char *mode);
-
-#if defined(HAVE_STDINT)
-#include <stdint.h>
-#else
-typedef unsigned int  uint32_t;
-typedef unsigned short  uint16_t;
-typedef unsigned __int64 uint64_t;
-typedef __int64   int64_t;
-#define INT64_MAX  9223372036854775807
-#endif // HAVE_STDINT
-
-// POSIX dirent interface
-struct dirent {
-  char d_name[PATH_MAX];
-};
-
-typedef struct DIR {
-  HANDLE   handle;
-  WIN32_FIND_DATAW info;
-  struct dirent  result;
-} DIR;
-
-// Mark required libraries
-#pragma comment(lib, "Ws2_32.lib")
-
-#else    // UNIX  specific
-#include <sys/wait.h>
-#include <sys/socket.h>
-#include <sys/select.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <sys/time.h>
-#include <stdint.h>
-#include <inttypes.h>
-#include <netdb.h>
-
-#include <pwd.h>
-#include <unistd.h>
-#include <dirent.h>
-#if !defined(NO_SSL_DL) && !defined(NO_SSL)
-#include <dlfcn.h>
-#endif
-#include <pthread.h>
-#if defined(__MACH__)
-#define SSL_LIB   "libssl.dylib"
-#define CRYPTO_LIB  "libcrypto.dylib"
-#else
-#if !defined(SSL_LIB)
-#define SSL_LIB   "libssl.so"
-#endif
-#if !defined(CRYPTO_LIB)
-#define CRYPTO_LIB  "libcrypto.so"
-#endif
-#endif
-#ifndef O_BINARY
-#define O_BINARY  0
-#endif // O_BINARY
-#define closesocket(a) close(a)
-#define mg_fopen(x, y) fopen(x, y)
-#define mg_mkdir(x, y) mkdir(x, y)
-#define mg_remove(x) remove(x)
-#define mg_rename(x, y) rename(x, y)
-#define mg_sleep(x) usleep((x) * 1000)
-#define ERRNO errno
-#define INVALID_SOCKET (-1)
-#define INT64_FMT PRId64
-typedef int SOCKET;
-#define WINCDECL
-
-#endif // End of Windows and UNIX specific includes
-
-#include "mongoose.h"
-
-#define MONGOOSE_VERSION "3.3"
-#define PASSWORDS_FILE_NAME ".htpasswd"
-#define CGI_ENVIRONMENT_SIZE 4096
-#define MAX_CGI_ENVIR_VARS 64
-#define MG_BUF_LEN 8192
-#define MAX_REQUEST_SIZE 16384
-#define ARRAY_SIZE(array) (sizeof(array) / sizeof(array[0]))
-
-#ifdef _WIN32
-static CRITICAL_SECTION global_log_file_lock;
-static pthread_t pthread_self(void) {
-  return GetCurrentThreadId();
-}
-#endif // _WIN32
-
-#ifdef DEBUG_TRACE
-#undef DEBUG_TRACE
-#define DEBUG_TRACE(x)
-#else
-#if defined(DEBUG)
-#define DEBUG_TRACE(x) do { \
-  flockfile(stdout); \
-  printf("*** %lu.%p.%s.%d: ", \
-         (unsigned long) time(NULL), (void *) pthread_self(), \
-         __func__, __LINE__); \
-  printf x; \
-  putchar('\n'); \
-  fflush(stdout); \
-  funlockfile(stdout); \
-} while (0)
-#else
-#define DEBUG_TRACE(x)
-#endif // DEBUG
-#endif // DEBUG_TRACE
-
-// Darwin prior to 7.0 and Win32 do not have socklen_t
-#ifdef NO_SOCKLEN_T
-typedef int socklen_t;
-#endif // NO_SOCKLEN_T
-#define _DARWIN_UNLIMITED_SELECT
-
-#if !defined(MSG_NOSIGNAL)
-#define MSG_NOSIGNAL 0
-#endif
-
-#if !defined(SOMAXCONN)
-#define SOMAXCONN 100
-#endif
-
-#if !defined(PATH_MAX)
-#define PATH_MAX 4096
-#endif
-
-static const char *http_500_error = "Internal Server Error";
-
-// Snatched from OpenSSL includes. I put the prototypes here to be independent
-// from the OpenSSL source installation. Having this, mongoose + SSL can be
-// built on any system with binary SSL libraries installed.
-typedef struct ssl_st SSL;
-typedef struct ssl_method_st SSL_METHOD;
-typedef struct ssl_ctx_st SSL_CTX;
-
-#define SSL_ERROR_WANT_READ 2
-#define SSL_ERROR_WANT_WRITE 3
-#define SSL_FILETYPE_PEM 1
-#define CRYPTO_LOCK  1
-
-#if defined(NO_SSL_DL)
-extern void SSL_free(SSL *);
-extern int SSL_accept(SSL *);
-extern int SSL_connect(SSL *);
-extern int SSL_read(SSL *, void *, int);
-extern int SSL_write(SSL *, const void *, int);
-extern int SSL_get_error(const SSL *, int);
-extern int SSL_set_fd(SSL *, int);
-extern SSL *SSL_new(SSL_CTX *);
-extern SSL_CTX *SSL_CTX_new(SSL_METHOD *);
-extern SSL_METHOD *SSLv23_server_method(void);
-extern SSL_METHOD *SSLv23_client_method(void);
-extern int SSL_library_init(void);
-extern void SSL_load_error_strings(void);
-extern int SSL_CTX_use_PrivateKey_file(SSL_CTX *, const char *, int);
-extern int SSL_CTX_use_certificate_file(SSL_CTX *, const char *, int);
-extern int SSL_CTX_use_certificate_chain_file(SSL_CTX *, const char *);
-extern void SSL_CTX_set_default_passwd_cb(SSL_CTX *, mg_callback_t);
-extern void SSL_CTX_free(SSL_CTX *);
-extern unsigned long ERR_get_error(void);
-extern char *ERR_error_string(unsigned long, char *);
-extern int CRYPTO_num_locks(void);
-extern void CRYPTO_set_locking_callback(void (*)(int, int, const char *, int));
-extern void CRYPTO_set_id_callback(unsigned long (*)(void));
-#else
-// Dynamically loaded SSL functionality
-struct ssl_func {
-  const char *name;   // SSL function name
-  void  (*ptr)(void); // Function pointer
-};
-
-#define SSL_free (* (void (*)(SSL *)) ssl_sw[0].ptr)
-#define SSL_accept (* (int (*)(SSL *)) ssl_sw[1].ptr)
-#define SSL_connect (* (int (*)(SSL *)) ssl_sw[2].ptr)
-#define SSL_read (* (int (*)(SSL *, void *, int)) ssl_sw[3].ptr)
-#define SSL_write (* (int (*)(SSL *, const void *,int)) ssl_sw[4].ptr)
-#define SSL_get_error (* (int (*)(SSL *, int)) ssl_sw[5].ptr)
-#define SSL_set_fd (* (int (*)(SSL *, SOCKET)) ssl_sw[6].ptr)
-#define SSL_new (* (SSL * (*)(SSL_CTX *)) ssl_sw[7].ptr)
-#define SSL_CTX_new (* (SSL_CTX * (*)(SSL_METHOD *)) ssl_sw[8].ptr)
-#define SSLv23_server_method (* (SSL_METHOD * (*)(void)) ssl_sw[9].ptr)
-#define SSL_library_init (* (int (*)(void)) ssl_sw[10].ptr)
-#define SSL_CTX_use_PrivateKey_file (* (int (*)(SSL_CTX *, \
-        const char *, int)) ssl_sw[11].ptr)
-#define SSL_CTX_use_certificate_file (* (int (*)(SSL_CTX *, \
-        const char *, int)) ssl_sw[12].ptr)
-#define SSL_CTX_set_default_passwd_cb \
-  (* (void (*)(SSL_CTX *, mg_callback_t)) ssl_sw[13].ptr)
-#define SSL_CTX_free (* (void (*)(SSL_CTX *)) ssl_sw[14].ptr)
-#define SSL_load_error_strings (* (void (*)(void)) ssl_sw[15].ptr)
-#define SSL_CTX_use_certificate_chain_file \
-  (* (int (*)(SSL_CTX *, const char *)) ssl_sw[16].ptr)
-#define SSLv23_client_method (* (SSL_METHOD * (*)(void)) ssl_sw[17].ptr)
-
-#define CRYPTO_num_locks (* (int (*)(void)) crypto_sw[0].ptr)
-#define CRYPTO_set_locking_callback \
-  (* (void (*)(void (*)(int, int, const char *, int))) crypto_sw[1].ptr)
-#define CRYPTO_set_id_callback \
-  (* (void (*)(unsigned long (*)(void))) crypto_sw[2].ptr)
-#define ERR_get_error (* (unsigned long (*)(void)) crypto_sw[3].ptr)
-#define ERR_error_string (* (char * (*)(unsigned long,char *)) crypto_sw[4].ptr)
-
-// set_ssl_option() function updates this array.
-// It loads SSL library dynamically and changes NULLs to the actual addresses
-// of respective functions. The macros above (like SSL_connect()) are really
-// just calling these functions indirectly via the pointer.
-static struct ssl_func ssl_sw[] = {
-  {"SSL_free",   NULL},
-  {"SSL_accept",   NULL},
-  {"SSL_connect",   NULL},
-  {"SSL_read",   NULL},
-  {"SSL_write",   NULL},
-  {"SSL_get_error",  NULL},
-  {"SSL_set_fd",   NULL},
-  {"SSL_new",   NULL},
-  {"SSL_CTX_new",   NULL},
-  {"SSLv23_server_method", NULL},
-  {"SSL_library_init",  NULL},
-  {"SSL_CTX_use_PrivateKey_file", NULL},
-  {"SSL_CTX_use_certificate_file",NULL},
-  {"SSL_CTX_set_default_passwd_cb",NULL},
-  {"SSL_CTX_free",  NULL},
-  {"SSL_load_error_strings", NULL},
-  {"SSL_CTX_use_certificate_chain_file", NULL},
-  {"SSLv23_client_method", NULL},
-  {NULL,    NULL}
-};
-
-// Similar array as ssl_sw. These functions could be located in different lib.
-#if !defined(NO_SSL)
-static struct ssl_func crypto_sw[] = {
-  {"CRYPTO_num_locks",  NULL},
-  {"CRYPTO_set_locking_callback", NULL},
-  {"CRYPTO_set_id_callback", NULL},
-  {"ERR_get_error",  NULL},
-  {"ERR_error_string", NULL},
-  {NULL,    NULL}
-};
-#endif // NO_SSL
-#endif // NO_SSL_DL
-
-static const char *month_names[] = {
-  "Jan", "Feb", "Mar", "Apr", "May", "Jun",
-  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
-};
-
-// Unified socket address. For IPv6 support, add IPv6 address structure
-// in the union u.
-union usa {
-  struct sockaddr sa;
-  struct sockaddr_in sin;
-#if defined(USE_IPV6)
-  struct sockaddr_in6 sin6;
-#endif
-};
-
-// Describes a string (chunk of memory).
-struct vec {
-  const char *ptr;
-  size_t len;
-};
-
-// Structure used by mg_stat() function. Uses 64 bit file length.
-struct mgstat {
-  int is_directory;  // Directory marker
-  int64_t size;      // File size
-  time_t mtime;      // Modification time
-};
-
-// Describes listening socket, or socket which was accept()-ed by the master
-// thread and queued for future handling by the worker thread.
-struct socket {
-  struct socket *next;  // Linkage
-  SOCKET sock;          // Listening socket
-  union usa lsa;        // Local socket address
-  union usa rsa;        // Remote socket address
-  int is_ssl;           // Is socket SSL-ed
-};
-
-// NOTE(lsm): this enum shoulds be in sync with the config_options below.
-enum {
-  CGI_EXTENSIONS, CGI_ENVIRONMENT, PUT_DELETE_PASSWORDS_FILE, CGI_INTERPRETER,
-  PROTECT_URI, AUTHENTICATION_DOMAIN, SSI_EXTENSIONS, THROTTLE,
-  ACCESS_LOG_FILE, ENABLE_DIRECTORY_LISTING, ERROR_LOG_FILE,
-  GLOBAL_PASSWORDS_FILE, INDEX_FILES, ENABLE_KEEP_ALIVE, ACCESS_CONTROL_LIST,
-  EXTRA_MIME_TYPES, LISTENING_PORTS, DOCUMENT_ROOT, SSL_CERTIFICATE,
-  NUM_THREADS, RUN_AS_USER, REWRITE, HIDE_FILES,
-  NUM_OPTIONS
-};
-
-static const char *config_options[] = {
-  "C", "cgi_pattern", "**.cgi$|**.pl$|**.php$",
-  "E", "cgi_environment", NULL,
-  "G", "put_delete_passwords_file", NULL,
-  "I", "cgi_interpreter", NULL,
-  "P", "protect_uri", NULL,
-  "R", "authentication_domain", "mydomain.com",
-  "S", "ssi_pattern", "**.shtml$|**.shtm$",
-  "T", "throttle", NULL,
-  "a", "access_log_file", NULL,
-  "d", "enable_directory_listing", "yes",
-  "e", "error_log_file", NULL,
-  "g", "global_passwords_file", NULL,
-  "i", "index_files", "index.html,index.htm,index.cgi,index.shtml,index.php",
-  "k", "enable_keep_alive", "no",
-  "l", "access_control_list", NULL,
-  "m", "extra_mime_types", NULL,
-  "p", "listening_ports", "8080",
-  "r", "document_root",  ".",
-  "s", "ssl_certificate", NULL,
-  "t", "num_threads", "20",
-  "u", "run_as_user", NULL,
-  "w", "url_rewrite_patterns", NULL,
-  "x", "hide_files_patterns", NULL,
-  NULL
-};
-#define ENTRIES_PER_CONFIG_OPTION 3
-
-struct mg_context {
-  volatile int stop_flag;       // Should we stop event loop
-  SSL_CTX *ssl_ctx;             // SSL context
-  SSL_CTX *client_ssl_ctx;      // Client SSL context
-  char *config[NUM_OPTIONS];    // Mongoose configuration parameters
-  mg_callback_t user_callback;  // User-defined callback function
-  void *user_data;              // User-defined data
-
-  struct socket *listening_sockets;
-
-  volatile int num_threads;  // Number of threads
-  pthread_mutex_t mutex;     // Protects (max|num)_threads
-  pthread_cond_t  cond;      // Condvar for tracking workers terminations
-
-  struct socket queue[20];   // Accepted sockets
-  volatile int sq_head;      // Head of the socket queue
-  volatile int sq_tail;      // Tail of the socket queue
-  pthread_cond_t sq_full;    // Signaled when socket is produced
-  pthread_cond_t sq_empty;   // Signaled when socket is consumed
-};
-
-struct mg_connection {
-  struct mg_request_info request_info;
-  struct mg_context *ctx;
-  SSL *ssl;                   // SSL descriptor
-  struct socket client;       // Connected client
-  time_t birth_time;          // Time when request was received
-  int64_t num_bytes_sent;     // Total bytes sent to client
-  int64_t content_len;        // Content-Length header value
-  int64_t consumed_content;   // How many bytes of content have been read
-  char *buf;                  // Buffer for received data
-  char *path_info;            // PATH_INFO part of the URL
-  char *log_message;          // Placeholder for the mongoose error log message
-  int must_close;             // 1 if connection must be closed
-  int buf_size;               // Buffer size
-  int request_len;            // Size of the request + headers in a buffer
-  int data_len;               // Total size of data in a buffer
-  int status_code;            // HTTP reply status code, e.g. 200
-  int throttle;               // Throttling, bytes/sec. <= 0 means no throttle
-  time_t last_throttle_time;  // Last time throttled data was sent
-  int64_t last_throttle_bytes;// Bytes sent this second
-
-  int ep_fd; // fd for epoll
-};
-
-const char **mg_get_valid_option_names(void) {
-  return config_options;
-}
-
-static void *call_user(struct mg_connection *conn, enum mg_event event) {
-  return conn == NULL || conn->ctx == NULL || conn->ctx->user_callback == NULL ?
-    NULL : conn->ctx->user_callback(event, conn);
-}
-
-void *mg_get_user_data(struct mg_connection *conn) {
-  return conn != NULL && conn->ctx != NULL ? conn->ctx->user_data : NULL;
-}
-
-const char *mg_get_log_message(const struct mg_connection *conn) {
-  return conn == NULL ? NULL : conn->log_message;
-}
-
-int mg_get_reply_status_code(const struct mg_connection *conn) {
-  return conn == NULL ? -1 : conn->status_code;
-}
-
-void *mg_get_ssl_context(const struct mg_connection *conn) {
-  return conn == NULL || conn->ctx == NULL ? NULL : conn->ctx->ssl_ctx;
-}
-
-static int get_option_index(const char *name) {
-  int i;
-
-  for (i = 0; config_options[i] != NULL; i += ENTRIES_PER_CONFIG_OPTION) {
-    if (strcmp(config_options[i], name) == 0 ||
-        strcmp(config_options[i + 1], name) == 0) {
-      return i / ENTRIES_PER_CONFIG_OPTION;
-    }
-  }
-  return -1;
-}
-
-const char *mg_get_option(const struct mg_context *ctx, const char *name) {
-  int i;
-  if ((i = get_option_index(name)) == -1) {
-    return NULL;
-  } else if (ctx->config[i] == NULL) {
-    return "";
-  } else {
-    return ctx->config[i];
-  }
-}
-
-static void sockaddr_to_string(char *buf, size_t len,
-                                     const union usa *usa) {
-  buf[0] = '\0';
-#if defined(USE_IPV6)
-  inet_ntop(usa->sa.sa_family, usa->sa.sa_family == AF_INET ?
-            (void *) &usa->sin.sin_addr :
-            (void *) &usa->sin6.sin6_addr, buf, len);
-#elif defined(_WIN32)
-  // Only Windoze Vista (and newer) have inet_ntop()
-  strncpy(buf, inet_ntoa(usa->sin.sin_addr), len);
-#else
-  inet_ntop(usa->sa.sa_family, (void *) &usa->sin.sin_addr, buf, len);
-#endif
-}
-
-static void cry(struct mg_connection *conn,
-                PRINTF_FORMAT_STRING(const char *fmt), ...) PRINTF_ARGS(2, 3);
-
-// Print error message to the opened error log stream.
-static void cry(struct mg_connection *conn, const char *fmt, ...) {
-  char buf[MG_BUF_LEN], src_addr[20];
-  va_list ap;
-  FILE *fp;
-  time_t timestamp;
-
-  va_start(ap, fmt);
-  (void) vsnprintf(buf, sizeof(buf), fmt, ap);
-  va_end(ap);
-
-  // Do not lock when getting the callback value, here and below.
-  // I suppose this is fine, since function cannot disappear in the
-  // same way string option can.
-  conn->log_message = buf;
-  if (call_user(conn, MG_EVENT_LOG) == NULL) {
-    fp = conn->ctx == NULL || conn->ctx->config[ERROR_LOG_FILE] == NULL ? NULL :
-      mg_fopen(conn->ctx->config[ERROR_LOG_FILE], "a+");
-
-    if (fp != NULL) {
-      flockfile(fp);
-      timestamp = time(NULL);
-
-      sockaddr_to_string(src_addr, sizeof(src_addr), &conn->client.rsa);
-      fprintf(fp, "[%010lu] [error] [client %s] ", (unsigned long) timestamp,
-              src_addr);
-
-      if (conn->request_info.request_method != NULL) {
-        fprintf(fp, "%s %s: ", conn->request_info.request_method,
-                conn->request_info.uri);
-      }
-
-      (void) fprintf(fp, "%s", buf);
-      fputc('\n', fp);
-      funlockfile(fp);
-      if (fp != stderr) {
-        fclose(fp);
-      }
-    }
-  }
-  conn->log_message = NULL;
-}
-
-// Return fake connection structure. Used for logging, if connection
-// is not applicable at the moment of logging.
-static struct mg_connection *fc(struct mg_context *ctx) {
-  static struct mg_connection fake_connection;
-  fake_connection.ctx = ctx;
-  return &fake_connection;
-}
-
-const char *mg_version(void) {
-  return MONGOOSE_VERSION;
-}
-
-const struct mg_request_info *
-mg_get_request_info(const struct mg_connection *conn) {
-  return &conn->request_info;
-}
-
-static void mg_strlcpy(register char *dst, register const char *src, size_t n) {
-  for (; *src != '\0' && n > 1; n--) {
-    *dst++ = *src++;
-  }
-  *dst = '\0';
-}
-
-static int lowercase(const char *s) {
-  return tolower(* (const unsigned char *) s);
-}
-
-static int mg_strncasecmp(const char *s1, const char *s2, size_t len) {
-  int diff = 0;
-
-  if (len > 0)
-    do {
-      diff = lowercase(s1++) - lowercase(s2++);
-    } while (diff == 0 && s1[-1] != '\0' && --len > 0);
-
-  return diff;
-}
-
-static int mg_strcasecmp(const char *s1, const char *s2) {
-  int diff;
-
-  do {
-    diff = lowercase(s1++) - lowercase(s2++);
-  } while (diff == 0 && s1[-1] != '\0');
-
-  return diff;
-}
-
-static char * mg_strndup(const char *ptr, size_t len) {
-  char *p;
-
-  if ((p = (char *) malloc(len + 1)) != NULL) {
-    mg_strlcpy(p, ptr, len + 1);
-  }
-
-  return p;
-}
-
-static char * mg_strdup(const char *str) {
-  return mg_strndup(str, strlen(str));
-}
-
-// Like snprintf(), but never returns negative value, or a value
-// that is larger than a supplied buffer.
-// Thanks to Adam Zeldis to pointing snprintf()-caused vulnerability
-// in his audit report.
-static int mg_vsnprintf(struct mg_connection *conn, char *buf, size_t buflen,
-                        const char *fmt, va_list ap) {
-  int n;
-
-  if (buflen == 0)
-    return 0;
-
-  n = vsnprintf(buf, buflen, fmt, ap);
-
-  if (n < 0) {
-    cry(conn, "vsnprintf error");
-    n = 0;
-  } else if (n >= (int) buflen) {
-    cry(conn, "truncating vsnprintf buffer: [%.*s]",
-        n > 200 ? 200 : n, buf);
-    n = (int) buflen - 1;
-  }
-  buf[n] = '\0';
-
-  return n;
-}
-
-static int mg_snprintf(struct mg_connection *conn, char *buf, size_t buflen,
-                       PRINTF_FORMAT_STRING(const char *fmt), ...)
-  PRINTF_ARGS(4, 5);
-
-static int mg_snprintf(struct mg_connection *conn, char *buf, size_t buflen,
-                       const char *fmt, ...) {
-  va_list ap;
-  int n;
-
-  va_start(ap, fmt);
-  n = mg_vsnprintf(conn, buf, buflen, fmt, ap);
-  va_end(ap);
-
-  return n;
-}
-
-// Skip the characters until one of the delimiters characters found.
-// 0-terminate resulting word. Skip the delimiter and following whitespaces if any.
-// Advance pointer to buffer to the next word. Return found 0-terminated word.
-// Delimiters can be quoted with quotechar.
-static char *skip_quoted(char **buf, const char *delimiters,
-                         const char *whitespace, char quotechar) {
-  char *p, *begin_word, *end_word, *end_whitespace;
-
-  begin_word = *buf;
-  end_word = begin_word + strcspn(begin_word, delimiters);
-
-  // Check for quotechar
-  if (end_word > begin_word) {
-    p = end_word - 1;
-    while (*p == quotechar) {
-      // If there is anything beyond end_word, copy it
-      if (*end_word == '\0') {
-        *p = '\0';
-        break;
-      } else {
-        size_t end_off = strcspn(end_word + 1, delimiters);
-        memmove (p, end_word, end_off + 1);
-        p += end_off; // p must correspond to end_word - 1
-        end_word += end_off + 1;
-      }
-    }
-    for (p++; p < end_word; p++) {
-      *p = '\0';
-    }
-  }
-
-  if (*end_word == '\0') {
-    *buf = end_word;
-  } else {
-    end_whitespace = end_word + 1 + strspn(end_word + 1, whitespace);
-
-    for (p = end_word; p < end_whitespace; p++) {
-      *p = '\0';
-    }
-
-    *buf = end_whitespace;
-  }
-
-  return begin_word;
-}
-
-// Simplified version of skip_quoted without quote char
-// and whitespace == delimiters
-static char *skip(char **buf, const char *delimiters) {
-  return skip_quoted(buf, delimiters, delimiters, 0);
-}
-
-
-// Return HTTP header value, or NULL if not found.
-static const char *get_header(const struct mg_request_info *ri,
-                              const char *name) {
-  int i;
-
-  for (i = 0; i < ri->num_headers; i++)
-    if (!mg_strcasecmp(name, ri->http_headers[i].name))
-      return ri->http_headers[i].value;
-
-  return NULL;
-}
-
-const char *mg_get_header(const struct mg_connection *conn, const char *name) {
-  return get_header(&conn->request_info, name);
-}
-
-// A helper function for traversing a comma separated list of values.
-// It returns a list pointer shifted to the next value, or NULL if the end
-// of the list found.
-// Value is stored in val vector. If value has form "x=y", then eq_val
-// vector is initialized to point to the "y" part, and val vector length
-// is adjusted to point only to "x".
-static const char *next_option(const char *list, struct vec *val,
-                               struct vec *eq_val) {
-  if (list == NULL || *list == '\0') {
-    // End of the list
-    list = NULL;
-  } else {
-    val->ptr = list;
-    if ((list = strchr(val->ptr, ',')) != NULL) {
-      // Comma found. Store length and shift the list ptr
-      val->len = list - val->ptr;
-      list++;
-    } else {
-      // This value is the last one
-      list = val->ptr + strlen(val->ptr);
-      val->len = list - val->ptr;
-    }
-
-    if (eq_val != NULL) {
-      // Value has form "x=y", adjust pointers and lengths
-      // so that val points to "x", and eq_val points to "y".
-      eq_val->len = 0;
-      eq_val->ptr = (const char *) memchr(val->ptr, '=', val->len);
-      if (eq_val->ptr != NULL) {
-        eq_val->ptr++;  // Skip over '=' character
-        eq_val->len = val->ptr + val->len - eq_val->ptr;
-        val->len = (eq_val->ptr - val->ptr) - 1;
-      }
-    }
-  }
-
-  return list;
-}
-
-static int match_prefix(const char *pattern, int pattern_len, const char *str) {
-  const char *or_str;
-  int i, j, len, res;
-
-  if ((or_str = (const char *) memchr(pattern, '|', pattern_len)) != NULL) {
-    res = match_prefix(pattern, or_str - pattern, str);
-    return res > 0 ? res :
-        match_prefix(or_str + 1, (pattern + pattern_len) - (or_str + 1), str);
-  }
-
-  i = j = 0;
-  res = -1;
-  for (; i < pattern_len; i++, j++) {
-    if (pattern[i] == '?' && str[j] != '\0') {
-      continue;
-    } else if (pattern[i] == '$') {
-      return str[j] == '\0' ? j : -1;
-    } else if (pattern[i] == '*') {
-      i++;
-      if (pattern[i] == '*') {
-        i++;
-        len = (int) strlen(str + j);
-      } else {
-        len = (int) strcspn(str + j, "/");
-      }
-      if (i == pattern_len) {
-        return j + len;
-      }
-      do {
-        res = match_prefix(pattern + i, pattern_len - i, str + j + len);
-      } while (res == -1 && len-- > 0);
-      return res == -1 ? -1 : j + res + len;
-    } else if (pattern[i] != str[j]) {
-      return -1;
-    }
-  }
-  return j;
-}
-
-// HTTP 1.1 assumes keep alive if "Connection:" header is not set
-// This function must tolerate situations when connection info is not
-// set up, for example if request parsing failed.
-static int should_keep_alive(const struct mg_connection *conn) {
-  const char *http_version = conn->request_info.http_version;
-  const char *header = mg_get_header(conn, "Connection");
-  if (conn->must_close ||
-      conn->status_code == 401 ||
-      mg_strcasecmp(conn->ctx->config[ENABLE_KEEP_ALIVE], "yes") != 0 ||
-      (header != NULL && mg_strcasecmp(header, "keep-alive") != 0) ||
-      (header == NULL && http_version && strcmp(http_version, "1.1"))) {
-    return 0;
-  }
-  return 1;
-}
-
-static const char *suggest_connection_header(const struct mg_connection *conn) {
-  return should_keep_alive(conn) ? "keep-alive" : "close";
-}
-
-static void send_http_error(struct mg_connection *, int, const char *,
-                            PRINTF_FORMAT_STRING(const char *fmt), ...)
-  PRINTF_ARGS(4, 5);
-
-
-static void send_http_error(struct mg_connection *conn, int status,
-                            const char *reason, const char *fmt, ...) {
-  char buf[MG_BUF_LEN];
-  va_list ap;
-  int len;
-
-  conn->status_code = status;
-  if (call_user(conn, MG_HTTP_ERROR) == NULL) {
-    buf[0] = '\0';
-    len = 0;
-
-    // Errors 1xx, 204 and 304 MUST NOT send a body
-    if (status > 199 && status != 204 && status != 304) {
-      len = mg_snprintf(conn, buf, sizeof(buf), "Error %d: %s", status, reason);
-      buf[len++] = '\n';
-
-      va_start(ap, fmt);
-      len += mg_vsnprintf(conn, buf + len, sizeof(buf) - len, fmt, ap);
-      va_end(ap);
-    }
-    DEBUG_TRACE(("[%s]", buf));
-
-    mg_printf(conn, "HTTP/1.1 %d %s\r\n"
-              "Content-Length: %d\r\n"
-              "Connection: %s\r\n\r\n", status, reason, len,
-              suggest_connection_header(conn));
-    conn->num_bytes_sent += mg_printf(conn, "%s", buf);
-  }
-}
-
-#if defined(_WIN32) && !defined(__SYMBIAN32__)
-static int pthread_mutex_init(pthread_mutex_t *mutex, void *unused) {
-  unused = NULL;
-  *mutex = CreateMutex(NULL, FALSE, NULL);
-  return *mutex == NULL ? -1 : 0;
-}
-
-static int pthread_mutex_destroy(pthread_mutex_t *mutex) {
-  return CloseHandle(*mutex) == 0 ? -1 : 0;
-}
-
-static int pthread_mutex_lock(pthread_mutex_t *mutex) {
-  return WaitForSingleObject(*mutex, INFINITE) == WAIT_OBJECT_0? 0 : -1;
-}
-
-static int pthread_mutex_unlock(pthread_mutex_t *mutex) {
-  return ReleaseMutex(*mutex) == 0 ? -1 : 0;
-}
-
-static int pthread_cond_init(pthread_cond_t *cv, const void *unused) {
-  unused = NULL;
-  cv->signal = CreateEvent(NULL, FALSE, FALSE, NULL);
-  cv->broadcast = CreateEvent(NULL, TRUE, FALSE, NULL);
-  return cv->signal != NULL && cv->broadcast != NULL ? 0 : -1;
-}
-
-static int pthread_cond_wait(pthread_cond_t *cv, pthread_mutex_t *mutex) {
-  HANDLE handles[] = {cv->signal, cv->broadcast};
-  ReleaseMutex(*mutex);
-  WaitForMultipleObjects(2, handles, FALSE, INFINITE);
-  return WaitForSingleObject(*mutex, INFINITE) == WAIT_OBJECT_0? 0 : -1;
-}
-
-static int pthread_cond_signal(pthread_cond_t *cv) {
-  return SetEvent(cv->signal) == 0 ? -1 : 0;
-}
-
-static int pthread_cond_broadcast(pthread_cond_t *cv) {
-  // Implementation with PulseEvent() has race condition, see
-  // http://www.cs.wustl.edu/~schmidt/win32-cv-1.html
-  return PulseEvent(cv->broadcast) == 0 ? -1 : 0;
-}
-
-static int pthread_cond_destroy(pthread_cond_t *cv) {
-  return CloseHandle(cv->signal) && CloseHandle(cv->broadcast) ? 0 : -1;
-}
-
-// For Windows, change all slashes to backslashes in path names.
-static void change_slashes_to_backslashes(char *path) {
-  int i;
-
-  for (i = 0; path[i] != '\0'; i++) {
-    if (path[i] == '/')
-      path[i] = '\\';
-    // i > 0 check is to preserve UNC paths, like \\server\file.txt
-    if (path[i] == '\\' && i > 0)
-      while (path[i + 1] == '\\' || path[i + 1] == '/')
-        (void) memmove(path + i + 1,
-            path + i + 2, strlen(path + i + 1));
-  }
-}
-
-// Encode 'path' which is assumed UTF-8 string, into UNICODE string.
-// wbuf and wbuf_len is a target buffer and its length.
-static void to_unicode(const char *path, wchar_t *wbuf, size_t wbuf_len) {
-  char buf[PATH_MAX], buf2[PATH_MAX], *p;
-
-  mg_strlcpy(buf, path, sizeof(buf));
-  change_slashes_to_backslashes(buf);
-
-  // Point p to the end of the file name
-  p = buf + strlen(buf) - 1;
-
-  // Trim trailing backslash character
-  while (p > buf && *p == '\\' && p[-1] != ':') {
-    *p-- = '\0';
-  }
-
-   // Protect from CGI code disclosure.
-   // This is very nasty hole. Windows happily opens files with
-   // some garbage in the end of file name. So fopen("a.cgi    ", "r")
-   // actually opens "a.cgi", and does not return an error!
-  if (*p == 0x20 ||               // No space at the end
-      (*p == 0x2e && p > buf) ||  // No '.' but allow '.' as full path
-      *p == 0x2b ||               // No '+'
-      (*p & ~0x7f)) {             // And generally no non-ASCII chars
-    (void) fprintf(stderr, "Rejecting suspicious path: [%s]", buf);
-    wbuf[0] = L'\0';
-  } else {
-    // Convert to Unicode and back. If doubly-converted string does not
-    // match the original, something is fishy, reject.
-    memset(wbuf, 0, wbuf_len * sizeof(wchar_t));
-    MultiByteToWideChar(CP_UTF8, 0, buf, -1, wbuf, (int) wbuf_len);
-    WideCharToMultiByte(CP_UTF8, 0, wbuf, (int) wbuf_len, buf2, sizeof(buf2),
-                        NULL, NULL);
-    if (strcmp(buf, buf2) != 0) {
-      wbuf[0] = L'\0';
-    }
-  }
-}
-
-#if defined(_WIN32_WCE)
-static time_t time(time_t *ptime) {
-  time_t t;
-  SYSTEMTIME st;
-  FILETIME ft;
-
-  GetSystemTime(&st);
-  SystemTimeToFileTime(&st, &ft);
-  t = SYS2UNIX_TIME(ft.dwLowDateTime, ft.dwHighDateTime);
-
-  if (ptime != NULL) {
-    *ptime = t;
-  }
-
-  return t;
-}
-
-static struct tm *localtime(const time_t *ptime, struct tm *ptm) {
-  int64_t t = ((int64_t) *ptime) * RATE_DIFF + EPOCH_DIFF;
-  FILETIME ft, lft;
-  SYSTEMTIME st;
-  TIME_ZONE_INFORMATION tzinfo;
-
-  if (ptm == NULL) {
-    return NULL;
-  }
-
-  * (int64_t *) &ft = t;
-  FileTimeToLocalFileTime(&ft, &lft);
-  FileTimeToSystemTime(&lft, &st);
-  ptm->tm_year = st.wYear - 1900;
-  ptm->tm_mon = st.wMonth - 1;
-  ptm->tm_wday = st.wDayOfWeek;
-  ptm->tm_mday = st.wDay;
-  ptm->tm_hour = st.wHour;
-  ptm->tm_min = st.wMinute;
-  ptm->tm_sec = st.wSecond;
-  ptm->tm_yday = 0; // hope nobody uses this
-  ptm->tm_isdst =
-    GetTimeZoneInformation(&tzinfo) == TIME_ZONE_ID_DAYLIGHT ? 1 : 0;
-
-  return ptm;
-}
-
-static struct tm *gmtime(const time_t *ptime, struct tm *ptm) {
-  // FIXME(lsm): fix this.
-  return localtime(ptime, ptm);
-}
-
-static size_t strftime(char *dst, size_t dst_size, const char *fmt,
-                       const struct tm *tm) {
-  (void) snprintf(dst, dst_size, "implement strftime() for WinCE");
-  return 0;
-}
-#endif
-
-static int mg_rename(const char* oldname, const char* newname) {
-  wchar_t woldbuf[PATH_MAX];
-  wchar_t wnewbuf[PATH_MAX];
-
-  to_unicode(oldname, woldbuf, ARRAY_SIZE(woldbuf));
-  to_unicode(newname, wnewbuf, ARRAY_SIZE(wnewbuf));
-
-  return MoveFileW(woldbuf, wnewbuf) ? 0 : -1;
-}
-
-
-static FILE *mg_fopen(const char *path, const char *mode) {
-  wchar_t wbuf[PATH_MAX], wmode[20];
-
-  to_unicode(path, wbuf, ARRAY_SIZE(wbuf));
-  MultiByteToWideChar(CP_UTF8, 0, mode, -1, wmode, ARRAY_SIZE(wmode));
-
-  return _wfopen(wbuf, wmode);
-}
-
-static int mg_stat(const char *path, struct mgstat *stp) {
-  int ok = -1; // Error
-  wchar_t wbuf[PATH_MAX];
-  WIN32_FILE_ATTRIBUTE_DATA info;
-
-  to_unicode(path, wbuf, ARRAY_SIZE(wbuf));
-
-  if (GetFileAttributesExW(wbuf, GetFileExInfoStandard, &info) != 0) {
-    stp->size = MAKEUQUAD(info.nFileSizeLow, info.nFileSizeHigh);
-    stp->mtime = SYS2UNIX_TIME(info.ftLastWriteTime.dwLowDateTime,
-                               info.ftLastWriteTime.dwHighDateTime);
-    stp->is_directory =
-      info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
-    ok = 0;  // Success
-  }
-
-  return ok;
-}
-
-static int mg_remove(const char *path) {
-  wchar_t wbuf[PATH_MAX];
-  to_unicode(path, wbuf, ARRAY_SIZE(wbuf));
-  return DeleteFileW(wbuf) ? 0 : -1;
-}
-
-static int mg_mkdir(const char *path, int mode) {
-  char buf[PATH_MAX];
-  wchar_t wbuf[PATH_MAX];
-
-  mode = 0; // Unused
-  mg_strlcpy(buf, path, sizeof(buf));
-  change_slashes_to_backslashes(buf);
-
-  (void) MultiByteToWideChar(CP_UTF8, 0, buf, -1, wbuf, sizeof(wbuf));
-
-  return CreateDirectoryW(wbuf, NULL) ? 0 : -1;
-}
-
-// Implementation of POSIX opendir/closedir/readdir for Windows.
-static DIR * opendir(const char *name) {
-  DIR *dir = NULL;
-  wchar_t wpath[PATH_MAX];
-  DWORD attrs;
-
-  if (name == NULL) {
-    SetLastError(ERROR_BAD_ARGUMENTS);
-  } else if ((dir = (DIR *) malloc(sizeof(*dir))) == NULL) {
-    SetLastError(ERROR_NOT_ENOUGH_MEMORY);
-  } else {
-    to_unicode(name, wpath, ARRAY_SIZE(wpath));
-    attrs = GetFileAttributesW(wpath);
-    if (attrs != 0xFFFFFFFF &&
-        ((attrs & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY)) {
-      (void) wcscat(wpath, L"\\*");
-      dir->handle = FindFirstFileW(wpath, &dir->info);
-      dir->result.d_name[0] = '\0';
-    } else {
-      free(dir);
-      dir = NULL;
-    }
-  }
-
-  return dir;
-}
-
-static int closedir(DIR *dir) {
-  int result = 0;
-
-  if (dir != NULL) {
-    if (dir->handle != INVALID_HANDLE_VALUE)
-      result = FindClose(dir->handle) ? 0 : -1;
-
-    free(dir);
-  } else {
-    result = -1;
-    SetLastError(ERROR_BAD_ARGUMENTS);
-  }
-
-  return result;
-}
-
-static struct dirent *readdir(DIR *dir) {
-  struct dirent *result = 0;
-
-  if (dir) {
-    if (dir->handle != INVALID_HANDLE_VALUE) {
-      result = &dir->result;
-      (void) WideCharToMultiByte(CP_UTF8, 0,
-          dir->info.cFileName, -1, result->d_name,
-          sizeof(result->d_name), NULL, NULL);
-
-      if (!FindNextFileW(dir->handle, &dir->info)) {
-        (void) FindClose(dir->handle);
-        dir->handle = INVALID_HANDLE_VALUE;
-      }
-
-    } else {
-      SetLastError(ERROR_FILE_NOT_FOUND);
-    }
-  } else {
-    SetLastError(ERROR_BAD_ARGUMENTS);
-  }
-
-  return result;
-}
-
-#define set_close_on_exec(fd) // No FD_CLOEXEC on Windows
-
-int mg_start_thread(mg_thread_func_t f, void *p) {
-  return _beginthread((void (__cdecl *)(void *)) f, 0, p) == -1L ? -1 : 0;
-}
-
-static HANDLE dlopen(const char *dll_name, int flags) {
-  wchar_t wbuf[PATH_MAX];
-  flags = 0; // Unused
-  to_unicode(dll_name, wbuf, ARRAY_SIZE(wbuf));
-  return LoadLibraryW(wbuf);
-}
-
-#if !defined(NO_CGI)
-#define SIGKILL 0
-static int kill(pid_t pid, int sig_num) {
-  (void) TerminateProcess(pid, sig_num);
-  (void) CloseHandle(pid);
-  return 0;
-}
-
-static pid_t spawn_process(struct mg_connection *conn, const char *prog,
-                           char *envblk, char *envp[], int fd_stdin,
-                           int fd_stdout, const char *dir) {
-  HANDLE me;
-  char *p, *interp, full_interp[PATH_MAX], cmdline[PATH_MAX], buf[PATH_MAX];
-  FILE *fp;
-  STARTUPINFOA si = { sizeof(si) };
-  PROCESS_INFORMATION pi = { 0 };
-
-  envp = NULL; // Unused
-
-  // TODO(lsm): redirect CGI errors to the error log file
-  si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
-  si.wShowWindow = SW_HIDE;
-
-  me = GetCurrentProcess();
-  DuplicateHandle(me, (HANDLE) _get_osfhandle(fd_stdin), me,
-                  &si.hStdInput, 0, TRUE, DUPLICATE_SAME_ACCESS);
-  DuplicateHandle(me, (HANDLE) _get_osfhandle(fd_stdout), me,
-                  &si.hStdOutput, 0, TRUE, DUPLICATE_SAME_ACCESS);
-
-  // If CGI file is a script, try to read the interpreter line
-  interp = conn->ctx->config[CGI_INTERPRETER];
-  if (interp == NULL) {
-    buf[0] = buf[2] = '\0';
-
-    // Read the first line of the script into the buffer
-    snprintf(cmdline, sizeof(cmdline), "%s%c%s", dir, '/', prog);
-    if ((fp = mg_fopen(cmdline, "r")) != NULL) {
-      fgets(buf, sizeof(buf), fp);
-      fclose(fp);
-      buf[sizeof(buf) - 1] = '\0';
-    }
-
-    if (buf[0] == '#' && buf[1] == '!') {
-      // Trim whitespace in interpreter name
-      for (p = buf + 2; *p != '\0' && isspace(* (unsigned char *) p); )
-        p++;
-      *p = '\0';
-    }
-    interp = buf + 2;
-  }
-
-  if (interp[0] != '\0') {
-    GetFullPathName(interp, sizeof(full_interp), full_interp, NULL);
-    interp = full_interp;
-  }
-
-  mg_snprintf(conn, cmdline, sizeof(cmdline), "%s%s%s",
-              interp, interp[0] == '\0' ? "" : " ", prog);
-
-  DEBUG_TRACE(("Running [%s]", cmdline));
-  if (CreateProcessA(NULL, cmdline, NULL, NULL, TRUE,
-        CREATE_NEW_PROCESS_GROUP, envblk, dir, &si, &pi) == 0) {
-    cry(conn, "%s: CreateProcess(%s): %d",
-        __func__, cmdline, ERRNO);
-    pi.hProcess = (pid_t) -1;
-  }
-
-  // Always close these to prevent handle leakage.
-  (void) close(fd_stdin);
-  (void) close(fd_stdout);
-
-  (void) CloseHandle(si.hStdOutput);
-  (void) CloseHandle(si.hStdInput);
-  (void) CloseHandle(pi.hThread);
-
-  return (pid_t) pi.hProcess;
-}
-#endif // !NO_CGI
-
-static int set_non_blocking_mode(SOCKET sock) {
-  unsigned long on = 1;
-  return ioctlsocket(sock, FIONBIO, &on);
-}
-
-#else
-static int mg_stat(const char *path, struct mgstat *stp) {
-  struct stat st;
-  int ok;
-
-  if (stat(path, &st) == 0) {
-    ok = 0;
-    stp->size = st.st_size;
-    stp->mtime = st.st_mtime;
-    stp->is_directory = S_ISDIR(st.st_mode);
-  } else {
-    ok = -1;
-  }
-
-  return ok;
-}
-
-static void set_close_on_exec(int fd) {
-  (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
-}
-
-int mg_start_thread(mg_thread_func_t func, void *param) {
-  pthread_t thread_id;
-  pthread_attr_t attr;
-
-  (void) pthread_attr_init(&attr);
-  (void) pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
-  // TODO(lsm): figure out why mongoose dies on Linux if next line is enabled
-  // (void) pthread_attr_setstacksize(&attr, sizeof(struct mg_connection) * 5);
-
-  return pthread_create(&thread_id, &attr, func, param);
-}
-
-#ifndef NO_CGI
-static pid_t spawn_process(struct mg_connection *conn, const char *prog,
-                           char *envblk, char *envp[], int fd_stdin,
-                           int fd_stdout, const char *dir) {
-  pid_t pid;
-  const char *interp;
-
-  envblk = NULL; // Unused
-
-  if ((pid = fork()) == -1) {
-    // Parent
-    send_http_error(conn, 500, http_500_error, "fork(): %s", strerror(ERRNO));
-  } else if (pid == 0) {
-    // Child
-    if (chdir(dir) != 0) {
-      cry(conn, "%s: chdir(%s): %s", __func__, dir, strerror(ERRNO));
-    } else if (dup2(fd_stdin, 0) == -1) {
-      cry(conn, "%s: dup2(%d, 0): %s", __func__, fd_stdin, strerror(ERRNO));
-    } else if (dup2(fd_stdout, 1) == -1) {
-      cry(conn, "%s: dup2(%d, 1): %s", __func__, fd_stdout, strerror(ERRNO));
-    } else {
-      (void) dup2(fd_stdout, 2);
-      (void) close(fd_stdin);
-      (void) close(fd_stdout);
-
-      interp = conn->ctx->config[CGI_INTERPRETER];
-      if (interp == NULL) {
-        (void) execle(prog, prog, NULL, envp);
-        cry(conn, "%s: execle(%s): %s", __func__, prog, strerror(ERRNO));
-      } else {
-        (void) execle(interp, interp, prog, NULL, envp);
-        cry(conn, "%s: execle(%s %s): %s", __func__, interp, prog,
-            strerror(ERRNO));
-      }
-    }
-    exit(EXIT_FAILURE);
-  }
-
-  // Parent. Close stdio descriptors
-  (void) close(fd_stdin);
-  (void) close(fd_stdout);
-
-  return pid;
-}
-#endif // !NO_CGI
-
-#endif // _WIN32
-
-// Write data to the IO channel - opened file descriptor, socket or SSL
-// descriptor. Return number of bytes written.
-static int64_t push(FILE *fp, SOCKET sock, SSL *ssl, const char *buf,
-                    int64_t len) {
-  int64_t sent;
-  int n, k;
-
-  sent = 0;
-  while (sent < len) {
-
-    // How many bytes we send in this iteration
-    k = len - sent > INT_MAX ? INT_MAX : (int) (len - sent);
-
-    if (ssl != NULL) {
-      n = SSL_write(ssl, buf + sent, k);
-    } else if (fp != NULL) {
-      n = (int) fwrite(buf + sent, 1, (size_t) k, fp);
-      if (ferror(fp))
-        n = -1;
-    } else {
-      n = send(sock, buf + sent, (size_t) k, MSG_NOSIGNAL);
-    }
-
-    if (n < 0)
-      break;
-
-    sent += n;
-  }
-
-  return sent;
-}
-
-// This function is needed to prevent Mongoose to be stuck in a blocking
-// socket read when user requested exit. To do that, we sleep in select
-// with a timeout, and when returned, check the context for the stop flag.
-// If it is set, we return 0, and this means that we must not continue
-// reading, must give up and close the connection and exit serving thread.
-
-#if 0
-static int wait_until_socket_is_readable(struct mg_connection *conn) {
-  int result;
-  struct timeval tv;
-  fd_set set;
-
-  do {
-    tv.tv_sec = 0;
-    tv.tv_usec = 300 * 1000;
-    FD_ZERO(&set);
-    FD_SET(conn->client.sock, &set);
-    result = select(conn->client.sock + 1, &set, NULL, NULL, &tv);
-  } while ((result == 0 || (result < 0 && ERRNO == EINTR)) &&
-           conn->ctx->stop_flag == 0);
-
-  return conn->ctx->stop_flag || result < 0 ? 0 : 1;
-}
-#else
-static int wait_until_socket_is_readable(struct mg_connection* conn) {
-    if (conn->ep_fd < 0) {
-        // create ep_fd if not opened before
-        conn->ep_fd = epoll_create(1024);
-        if (conn->ep_fd < 0) {
-            // epoll create failed, return -
-            return 0;
-        }
-        struct epoll_event event;
-        event.events = EPOLLIN | EPOLLERR | EPOLLHUP;
-        event.data.ptr = conn;
-        int ret = epoll_ctl(conn->ep_fd, EPOLL_CTL_ADD, conn->client.sock, &event);
-        if (ret < 0) {
-            // epoll_ctl failed.
-            return 0;
-        }
-    }
-    while (conn->ctx->stop_flag == 0) {
-        struct epoll_event events[5];
-        int num_event = epoll_wait(conn->ep_fd, events, 5, 300);
-        if (num_event > 0) {
-            assert(num_event == 1);
-            switch(events[0].events) {
-            case EPOLLIN:
-                // now, we can read
-                return 1;
-            case EPOLLERR:
-            case EPOLLHUP:
-            default:
-                return 0;
-            }
-        } else if (num_event == 0) {
-            // timedout, just continue;
-        } else {
-            // num_event < 0 and errno != EINTR means error happened.
-            if (ERRNO != EINTR) {
-                return 0;
-            }
-        }
-    }
-    // Only stop, we get here
-    return 0;
-}
-#endif
-
-// Read from IO channel - opened file descriptor, socket, or SSL descriptor.
-// Return negative value on error, or number of bytes read on success.
-static int pull(FILE *fp, struct mg_connection *conn, char *buf, int len) {
-  int nread;
-
-  if (fp != NULL) {
-    // Use read() instead of fread(), because if we're reading from the CGI
-    // pipe, fread() may block until IO buffer is filled up. We cannot afford
-    // to block and must pass all read bytes immediately to the client.
-    nread = read(fileno(fp), buf, (size_t) len);
-  } else if (!wait_until_socket_is_readable(conn)) {
-    nread = -1;
-  } else if (conn->ssl != NULL) {
-    nread = SSL_read(conn->ssl, buf, len);
-  } else {
-    nread = recv(conn->client.sock, buf, (size_t) len, 0);
-  }
-
-  return conn->ctx->stop_flag ? -1 : nread;
-}
-
-int mg_read(struct mg_connection *conn, void *buf, size_t len) {
-  // int n, buffered_len, nread;
-  // Modified by lingbin, make buffered_len to be int64_t to avoid overflow.
-  // see jira: PALO-1442
-  int n, nread; 
-  int64_t buffered_len;
-  const char *body;
-
-  nread = 0;
-  if (conn->consumed_content < conn->content_len) {
-    // Adjust number of bytes to read.
-    int64_t to_read = conn->content_len - conn->consumed_content;
-    if (to_read < (int64_t) len) {
-      len = (size_t) to_read;
-    }
-
-    // Return buffered data
-    body = conn->buf + conn->request_len + conn->consumed_content;
-    buffered_len = &conn->buf[conn->data_len] - body;
-    if (buffered_len > 0) {
-      if (len < (size_t) buffered_len) {
-        buffered_len = (int) len;
-      }
-      memcpy(buf, body, (size_t) buffered_len);
-      len -= buffered_len;
-      conn->consumed_content += buffered_len;
-      nread += buffered_len;
-      buf = (char *) buf + buffered_len;
-    }
-
-    // We have returned all buffered data. Read new data from the remote socket.
-    while (len > 0) {
-      n = pull(NULL, conn, (char *) buf, (int) len);
-      if (n < 0) {
-        nread = n;  // Propagate the error
-        break;
-      } else if (n == 0) {
-        break;  // No more data to read
-      } else {
-        buf = (char *) buf + n;
-        conn->consumed_content += n;
-        nread += n;
-        len -= n;
-      }
-    }
-  }
-  return nread;
-}
-
-int mg_write(struct mg_connection *conn, const void *buf, size_t len) {
-  time_t now;
-  int64_t n, total, allowed;
-
-  if (conn->throttle > 0) {
-    if ((now = time(NULL)) != conn->last_throttle_time) {
-      conn->last_throttle_time = now;
-      conn->last_throttle_bytes = 0;
-    }
-    allowed = conn->throttle - conn->last_throttle_bytes;
-    if (allowed > (int64_t) len) {
-      allowed = len;
-    }
-    if ((total = push(NULL, conn->client.sock, conn->ssl, (const char *) buf,
-                      (int64_t) allowed)) == allowed) {
-      buf = (char *) buf + total;
-      conn->last_throttle_bytes += total;
-      while (total < (int64_t) len && conn->ctx->stop_flag == 0) {
-        allowed = conn->throttle > (int64_t) len - total ?
-          len - total : conn->throttle;
-        if ((n = push(NULL, conn->client.sock, conn->ssl, (const char *) buf,
-                      (int64_t) allowed)) != allowed) {
-          break;
-        }
-        sleep(1);
-        conn->last_throttle_bytes = allowed;
-        conn->last_throttle_time = time(NULL);
-        buf = (char *) buf + n;
-        total += n;
-      }
-    }
-  } else {
-    total = push(NULL, conn->client.sock, conn->ssl, (const char *) buf,
-                 (int64_t) len);
-  }
-  return (int) total;
-}
-
-int mg_printf(struct mg_connection *conn, const char *fmt, ...) {
-  char mem[MG_BUF_LEN], *buf = mem;
-  int len;
-  va_list ap;
-
-  // Print in a local buffer first, hoping that it is large enough to
-  // hold the whole message
-  va_start(ap, fmt);
-  len = vsnprintf(mem, sizeof(mem), fmt, ap);
-  va_end(ap);
-
-  if (len == 0) {
-    // Do nothing. mg_printf(conn, "%s", "") was called.
-  } else if (len < 0) {
-    // vsnprintf() error, give up
-    len = -1;
-    cry(conn, "%s(%s, ...): vsnprintf() error", __func__, fmt);
-  } else if (len > (int) sizeof(mem) && (buf = (char *) malloc(len + 1)) != NULL) {
-    // Local buffer is not large enough, allocate big buffer on heap
-    va_start(ap, fmt);
-    vsnprintf(buf, len + 1, fmt, ap);
-    va_end(ap);
-    len = mg_write(conn, buf, (size_t) len);
-    free(buf);
-  } else if (len > (int) sizeof(mem)) {
-    // Failed to allocate large enough buffer, give up
-    cry(conn, "%s(%s, ...): Can't allocate %d bytes, not printing anything",
-        __func__, fmt, len);
-    len = -1;
-  } else {
-    // Copy to the local buffer succeeded
-    len = mg_write(conn, buf, (size_t) len);
-  }
-
-  return len;
-}
-
-// URL-decode input buffer into destination buffer.
-// 0-terminate the destination buffer. Return the length of decoded data.
-// form-url-encoded data differs from URI encoding in a way that it
-// uses '+' as character for space, see RFC 1866 section 8.2.1
-// http://ftp.ics.uci.edu/pub/ietf/html/rfc1866.txt
-static size_t url_decode(const char *src, size_t src_len, char *dst,
-                         size_t dst_len, int is_form_url_encoded) {
-  size_t i, j;
-  int a, b;
-#define HEXTOI(x) (isdigit(x) ? x - '0' : x - 'W')
-
-  for (i = j = 0; i < src_len && j < dst_len - 1; i++, j++) {
-    if (src[i] == '%' &&
-        isxdigit(* (const unsigned char *) (src + i + 1)) &&
-        isxdigit(* (const unsigned char *) (src + i + 2))) {
-      a = tolower(* (const unsigned char *) (src + i + 1));
-      b = tolower(* (const unsigned char *) (src + i + 2));
-      dst[j] = (char) ((HEXTOI(a) << 4) | HEXTOI(b));
-      i += 2;
-    } else if (is_form_url_encoded && src[i] == '+') {
-      dst[j] = ' ';
-    } else {
-      dst[j] = src[i];
-    }
-  }
-
-  dst[j] = '\0'; // Null-terminate the destination
-
-  return j;
-}
-
-// Scan given buffer and fetch the value of the given variable.
-// It can be specified in query string, or in the POST data.
-// Return -1 if the variable not found, or length of the URL-decoded value
-// stored in dst. The dst buffer is guaranteed to be NUL-terminated if it
-// is not NULL or zero-length. If dst is NULL or zero-length, then
-// -2 is returned.
-int mg_get_var(const char *buf, size_t buf_len, const char *name,
-               char *dst, size_t dst_len) {
-  const char *p, *e, *s;
-  size_t name_len;
-  int len;
-
-  if (dst == NULL || dst_len == 0) {
-    len = -2;
-  } else if (buf == NULL || name == NULL || buf_len == 0) {
-    len = -1;
-    dst[0] = '\0';
-  } else {
-    name_len = strlen(name);
-    e = buf + buf_len;
-    len = -1;
-    dst[0] = '\0';
-
-    // buf is "var1=val1&var2=val2...". Find variable first
-    for (p = buf; p + name_len < e; p++) {
-      if ((p == buf || p[-1] == '&') && p[name_len] == '=' &&
-          !mg_strncasecmp(name, p, name_len)) {
-
-        // Point p to variable value
-        p += name_len + 1;
-
-        // Point s to the end of the value
-        s = (const char *) memchr(p, '&', (size_t)(e - p));
-        if (s == NULL) {
-          s = e;
-        }
-        assert(s >= p);
-
-        // Decode variable into destination buffer
-        if ((size_t) (s - p) < dst_len) {
-          len = (int) url_decode(p, (size_t)(s - p), dst, dst_len, 1);
-        }
-        break;
-      }
-    }
-  }
-
-  return len;
-}
-
-int mg_get_cookie(const struct mg_connection *conn, const char *cookie_name,
-                  char *dst, size_t dst_size) {
-  const char *s, *p, *end;
-  int name_len, len = -1;
-
-  dst[0] = '\0';
-  if ((s = mg_get_header(conn, "Cookie")) == NULL) {
-    return -1;
-  }
-
-  name_len = (int) strlen(cookie_name);
-  end = s + strlen(s);
-
-  for (; (s = strstr(s, cookie_name)) != NULL; s += name_len)
-    if (s[name_len] == '=') {
-      s += name_len + 1;
-      if ((p = strchr(s, ' ')) == NULL)
-        p = end;
-      if (p[-1] == ';')
-        p--;
-      if (*s == '"' && p[-1] == '"' && p > s + 1) {
-        s++;
-        p--;
-      }
-      if ((size_t) (p - s) < dst_size) {
-        len = p - s;
-        mg_strlcpy(dst, s, (size_t) len + 1);
-      }
-      break;
-    }
-
-  return len;
-}
-
-static int convert_uri_to_file_name(struct mg_connection *conn, char *buf,
-                                    size_t buf_len, struct mgstat *st) {
-  struct vec a, b;
-  const char *rewrite, *uri = conn->request_info.uri;
-  char *p;
-  int match_len, stat_result;
-
-  buf_len--;  // This is because memmove() for PATH_INFO may shift part
-              // of the path one byte on the right.
-  mg_snprintf(conn, buf, buf_len, "%s%s", conn->ctx->config[DOCUMENT_ROOT],
-              uri);
-
-  rewrite = conn->ctx->config[REWRITE];
-  while ((rewrite = next_option(rewrite, &a, &b)) != NULL) {
-    if ((match_len = match_prefix(a.ptr, a.len, uri)) > 0) {
-      mg_snprintf(conn, buf, buf_len, "%.*s%s", (int) b.len, b.ptr,
-                  uri + match_len);
-      break;
-    }
-  }
-
-  if ((stat_result = mg_stat(buf, st)) != 0) {
-    // Support PATH_INFO for CGI scripts.
-    for (p = buf + strlen(buf); p > buf + 1; p--) {
-      if (*p == '/') {
-        *p = '\0';
-        if (match_prefix(conn->ctx->config[CGI_EXTENSIONS],
-                         strlen(conn->ctx->config[CGI_EXTENSIONS]), buf) > 0 &&
-            (stat_result = mg_stat(buf, st)) == 0) {
-          // Shift PATH_INFO block one character right, e.g.
-          //  "/x.cgi/foo/bar\x00" => "/x.cgi\x00/foo/bar\x00"
-          // conn->path_info is pointing to the local variable "path" declared
-          // in handle_request(), so PATH_INFO is not valid after
-          // handle_request returns.
-          conn->path_info = p + 1;
-          memmove(p + 2, p + 1, strlen(p + 1) + 1);  // +1 is for trailing \0
-          p[1] = '/';
-          break;
-        } else {
-          *p = '/';
-          stat_result = -1;
-        }
-      }
-    }
-  }
-
-  return stat_result;
-}
-
-static int sslize(struct mg_connection *conn, SSL_CTX *s, int (*func)(SSL *)) {
-  return (conn->ssl = SSL_new(s)) != NULL &&
-    SSL_set_fd(conn->ssl, conn->client.sock) == 1 &&
-    func(conn->ssl) == 1;
-}
-
-// Check whether full request is buffered. Return:
-//   -1  if request is malformed
-//    0  if request is not yet fully buffered
-//   >0  actual request length, including last \r\n\r\n
-static int get_request_len(const char *buf, int buflen) {
-  const char *s, *e;
-  int len = 0;
-
-  for (s = buf, e = s + buflen - 1; len <= 0 && s < e; s++)
-    // Control characters are not allowed but >=128 is.
-    if (!isprint(* (const unsigned char *) s) && *s != '\r' &&
-        *s != '\n' && * (const unsigned char *) s < 128) {
-      len = -1;
-      break; // [i_a] abort scan as soon as one malformed character is found; don't let subsequent \r\n\r\n win us over anyhow
-    } else if (s[0] == '\n' && s[1] == '\n') {
-      len = (int) (s - buf) + 2;
-    } else if (s[0] == '\n' && &s[1] < e &&
-        s[1] == '\r' && s[2] == '\n') {
-      len = (int) (s - buf) + 3;
-    }
-
-  return len;
-}
-
-// Convert month to the month number. Return -1 on error, or month number
-static int get_month_index(const char *s) {
-  size_t i;
-
-  for (i = 0; i < ARRAY_SIZE(month_names); i++)
-    if (!strcmp(s, month_names[i]))
-      return (int) i;
-
-  return -1;
-}
-
-static int num_leap_years(int year) {
-  return year / 4 - year / 100 + year / 400;
-}
-
-// Parse UTC date-time string, and return the corresponding time_t value.
-static time_t parse_date_string(const char *datetime) {
-  static const unsigned short days_before_month[] = {
-    0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334
-  };
-  char month_str[32];
-  int second, minute, hour, day, month, year, leap_days, days;
-  time_t result = (time_t) 0;
-
-  if (((sscanf(datetime, "%d/%3s/%d %d:%d:%d",
-               &day, month_str, &year, &hour, &minute, &second) == 6) ||
-       (sscanf(datetime, "%d %3s %d %d:%d:%d",
-               &day, month_str, &year, &hour, &minute, &second) == 6) ||
-       (sscanf(datetime, "%*3s, %d %3s %d %d:%d:%d",
-               &day, month_str, &year, &hour, &minute, &second) == 6) ||
-       (sscanf(datetime, "%d-%3s-%d %d:%d:%d",
-               &day, month_str, &year, &hour, &minute, &second) == 6)) &&
-      year > 1970 &&
-      (month = get_month_index(month_str)) != -1) {
-    leap_days = num_leap_years(year) - num_leap_years(1970);
-    year -= 1970;
-    days = year * 365 + days_before_month[month] + (day - 1) + leap_days;
-    result = days * 24 * 3600 + hour * 3600 + minute * 60 + second;
-  }
-
-  return result;
-}
-
-// Protect against directory disclosure attack by removing '..',
-// excessive '/' and '\' characters
-static void remove_double_dots_and_double_slashes(char *s) {
-  char *p = s;
-
-  while (*s != '\0') {
-    *p++ = *s++;
-    if (s[-1] == '/' || s[-1] == '\\') {
-      // Skip all following slashes, backslashes and double-dots
-      while (s[0] != '\0') {
-        if (s[0] == '/' || s[0] == '\\') {
-          s++;
-        } else if (s[0] == '.' && s[1] == '.') {
-          s += 2;
-        } else {
-          break;
-        }
-      }
-    }
-  }
-  *p = '\0';
-}
-
-static const struct {
-  const char *extension;
-  size_t ext_len;
-  const char *mime_type;
-} builtin_mime_types[] = {
-  {".html", 5, "text/html"},
-  {".htm", 4, "text/html"},
-  {".shtm", 5, "text/html"},
-  {".shtml", 6, "text/html"},
-  {".css", 4, "text/css"},
-  {".js",  3, "application/x-javascript"},
-  {".ico", 4, "image/x-icon"},
-  {".gif", 4, "image/gif"},
-  {".jpg", 4, "image/jpeg"},
-  {".jpeg", 5, "image/jpeg"},
-  {".png", 4, "image/png"},
-  {".svg", 4, "image/svg+xml"},
-  {".txt", 4, "text/plain"},
-  {".torrent", 8, "application/x-bittorrent"},
-  {".wav", 4, "audio/x-wav"},
-  {".mp3", 4, "audio/x-mp3"},
-  {".mid", 4, "audio/mid"},
-  {".m3u", 4, "audio/x-mpegurl"},
-  {".ram", 4, "audio/x-pn-realaudio"},
-  {".xml", 4, "text/xml"},
-  {".json",  5, "text/json"},
-  {".xslt", 5, "application/xml"},
-  {".ra",  3, "audio/x-pn-realaudio"},
-  {".doc", 4, "application/msword"},
-  {".exe", 4, "application/octet-stream"},
-  {".zip", 4, "application/x-zip-compressed"},
-  {".xls", 4, "application/excel"},
-  {".tgz", 4, "application/x-tar-gz"},
-  {".tar", 4, "application/x-tar"},
-  {".gz",  3, "application/x-gunzip"},
-  {".arj", 4, "application/x-arj-compressed"},
-  {".rar", 4, "application/x-arj-compressed"},
-  {".rtf", 4, "application/rtf"},
-  {".pdf", 4, "application/pdf"},
-  {".swf", 4, "application/x-shockwave-flash"},
-  {".mpg", 4, "video/mpeg"},
-  {".webm", 5, "video/webm"},
-  {".mpeg", 5, "video/mpeg"},
-  {".mp4", 4, "video/mp4"},
-  {".m4v", 4, "video/x-m4v"},
-  {".asf", 4, "video/x-ms-asf"},
-  {".avi", 4, "video/x-msvideo"},
-  {".bmp", 4, "image/bmp"},
-  {NULL,  0, NULL}
-};
-
-const char *mg_get_builtin_mime_type(const char *path) {
-  const char *ext;
-  size_t i, path_len;
-
-  path_len = strlen(path);
-
-  for (i = 0; builtin_mime_types[i].extension != NULL; i++) {
-    ext = path + (path_len - builtin_mime_types[i].ext_len);
-    if (path_len > builtin_mime_types[i].ext_len &&
-        mg_strcasecmp(ext, builtin_mime_types[i].extension) == 0) {
-      return builtin_mime_types[i].mime_type;
-    }
-  }
-
-  return "text/plain";
-}
-
-// Look at the "path" extension and figure what mime type it has.
-// Store mime type in the vector.
-static void get_mime_type(struct mg_context *ctx, const char *path,
-                          struct vec *vec) {
-  struct vec ext_vec, mime_vec;
-  const char *list, *ext;
-  size_t path_len;
-
-  path_len = strlen(path);
-
-  // Scan user-defined mime types first, in case user wants to
-  // override default mime types.
-  list = ctx->config[EXTRA_MIME_TYPES];
-  while ((list = next_option(list, &ext_vec, &mime_vec)) != NULL) {
-    // ext now points to the path suffix
-    ext = path + path_len - ext_vec.len;
-    if (mg_strncasecmp(ext, ext_vec.ptr, ext_vec.len) == 0) {
-      *vec = mime_vec;
-      return;
-    }
-  }
-
-  vec->ptr = mg_get_builtin_mime_type(path);
-  vec->len = strlen(vec->ptr);
-}
-
-#ifndef HAVE_MD5
-typedef struct MD5Context {
-  uint32_t buf[4];
-  uint32_t bits[2];
-  unsigned char in[64];
-} MD5_CTX;
-
-#if defined(__BYTE_ORDER) && (__BYTE_ORDER == 1234)
-#define byteReverse(buf, len) // Do nothing
-#else
-static void byteReverse(unsigned char *buf, unsigned longs) {
-  uint32_t t;
-  do {
-    t = (uint32_t) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
-      ((unsigned) buf[1] << 8 | buf[0]);
-    *(uint32_t *) buf = t;
-    buf += 4;
-  } while (--longs);
-}
-#endif
-
-#define F1(x, y, z) (z ^ (x & (y ^ z)))
-#define F2(x, y, z) F1(z, x, y)
-#define F3(x, y, z) (x ^ y ^ z)
-#define F4(x, y, z) (y ^ (x | ~z))
-
-#define MD5STEP(f, w, x, y, z, data, s) \
-  ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
-
-// Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
-// initialization constants.
-static void MD5Init(MD5_CTX *ctx) {
-  ctx->buf[0] = 0x67452301;
-  ctx->buf[1] = 0xefcdab89;
-  ctx->buf[2] = 0x98badcfe;
-  ctx->buf[3] = 0x10325476;
-
-  ctx->bits[0] = 0;
-  ctx->bits[1] = 0;
-}
-
-static void MD5Transform(uint32_t buf[4], uint32_t const in[16]) {
-  register uint32_t a, b, c, d;
-
-  a = buf[0];
-  b = buf[1];
-  c = buf[2];
-  d = buf[3];
-
-  MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
-  MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
-  MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
-  MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
-  MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
-  MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
-  MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
-  MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
-  MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
-  MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
-  MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
-  MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
-  MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
-  MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
-  MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
-  MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
-
-  MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
-  MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
-  MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
-  MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
-  MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
-  MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
-  MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
-  MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
-  MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
-  MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
-  MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
-  MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
-  MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
-  MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
-  MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
-  MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
-
-  MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
-  MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
-  MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
-  MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
-  MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
-  MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
-  MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
-  MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
-  MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
-  MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
-  MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
-  MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
-  MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
-  MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
-  MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
-  MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
-
-  MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
-  MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
-  MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
-  MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
-  MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
-  MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
-  MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
-  MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
-  MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
-  MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
-  MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
-  MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
-  MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
-  MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
-  MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
-  MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
-
-  buf[0] += a;
-  buf[1] += b;
-  buf[2] += c;
-  buf[3] += d;
-}
-
-static void MD5Update(MD5_CTX *ctx, unsigned char const *buf, unsigned len) {
-  uint32_t t;
-
-  t = ctx->bits[0];
-  if ((ctx->bits[0] = t + ((uint32_t) len << 3)) < t)
-    ctx->bits[1]++;
-  ctx->bits[1] += len >> 29;
-
-  t = (t >> 3) & 0x3f;
-
-  if (t) {
-    unsigned char *p = (unsigned char *) ctx->in + t;
-
-    t = 64 - t;
-    if (len < t) {
-      memcpy(p, buf, len);
-      return;
-    }
-    memcpy(p, buf, t);
-    byteReverse(ctx->in, 16);
-    MD5Transform(ctx->buf, (uint32_t *) ctx->in);
-    buf += t;
-    len -= t;
-  }
-
-  while (len >= 64) {
-    memcpy(ctx->in, buf, 64);
-    byteReverse(ctx->in, 16);
-    MD5Transform(ctx->buf, (uint32_t *) ctx->in);
-    buf += 64;
-    len -= 64;
-  }
-
-  memcpy(ctx->in, buf, len);
-}
-
-static void MD5Final(unsigned char digest[16], MD5_CTX *ctx) {
-  unsigned count;
-  unsigned char *p;
-
-  count = (ctx->bits[0] >> 3) & 0x3F;
-
-  p = ctx->in + count;
-  *p++ = 0x80;
-  count = 64 - 1 - count;
-  if (count < 8) {
-    memset(p, 0, count);
-    byteReverse(ctx->in, 16);
-    MD5Transform(ctx->buf, (uint32_t *) ctx->in);
-    memset(ctx->in, 0, 56);
-  } else {
-    memset(p, 0, count - 8);
-  }
-  byteReverse(ctx->in, 14);
-
-  ((uint32_t *) ctx->in)[14] = ctx->bits[0];
-  ((uint32_t *) ctx->in)[15] = ctx->bits[1];
-
-  MD5Transform(ctx->buf, (uint32_t *) ctx->in);
-  byteReverse((unsigned char *) ctx->buf, 4);
-  memcpy(digest, ctx->buf, 16);
-  memset((char *) ctx, 0, sizeof(*ctx));
-}
-#endif // !HAVE_MD5
-
-// Stringify binary data. Output buffer must be twice as big as input,
-// because each byte takes 2 bytes in string representation
-static void bin2str(char *to, const unsigned char *p, size_t len) {
-  static const char *hex = "0123456789abcdef";
-
-  for (; len--; p++) {
-    *to++ = hex[p[0] >> 4];
-    *to++ = hex[p[0] & 0x0f];
-  }
-  *to = '\0';
-}
-
-// Return stringified MD5 hash for list of strings. Buffer must be 33 bytes.
-void mg_md5(char buf[33], ...) {
-  unsigned char hash[16];
-  const char *p;
-  va_list ap;
-  MD5_CTX ctx;
-
-  MD5Init(&ctx);
-
-  va_start(ap, buf);
-  while ((p = va_arg(ap, const char *)) != NULL) {
-    MD5Update(&ctx, (const unsigned char *) p, (unsigned) strlen(p));
-  }
-  va_end(ap);
-
-  MD5Final(hash, &ctx);
-  bin2str(buf, hash, sizeof(hash));
-}
-
-// Check the user's password, return 1 if OK
-static int check_password(const char *method, const char *ha1, const char *uri,
-                          const char *nonce, const char *nc, const char *cnonce,
-                          const char *qop, const char *response) {
-  char ha2[32 + 1], expected_response[32 + 1];
-
-  // Some of the parameters may be NULL
-  if (method == NULL || nonce == NULL || nc == NULL || cnonce == NULL ||
-      qop == NULL || response == NULL) {
-    return 0;
-  }
-
-  // NOTE(lsm): due to a bug in MSIE, we do not compare the URI
-  // TODO(lsm): check for authentication timeout
-  if (// strcmp(dig->uri, c->ouri) != 0 ||
-      strlen(response) != 32
-      // || now - strtoul(dig->nonce, NULL, 10) > 3600
-      ) {
-    return 0;
-  }
-
-  mg_md5(ha2, method, ":", uri, NULL);
-  mg_md5(expected_response, ha1, ":", nonce, ":", nc,
-      ":", cnonce, ":", qop, ":", ha2, NULL);
-
-  return mg_strcasecmp(response, expected_response) == 0;
-}
-
-// Use the global passwords file, if specified by auth_gpass option,
-// or search for .htpasswd in the requested directory.
-static FILE *open_auth_file(struct mg_connection *conn, const char *path) {
-  struct mg_context *ctx = conn->ctx;
-  char name[PATH_MAX];
-  const char *p, *e;
-  struct mgstat st;
-  FILE *fp;
-
-  if (ctx->config[GLOBAL_PASSWORDS_FILE] != NULL) {
-    // Use global passwords file
-    fp =  mg_fopen(ctx->config[GLOBAL_PASSWORDS_FILE], "r");
-    if (fp == NULL)
-      cry(fc(ctx), "fopen(%s): %s",
-          ctx->config[GLOBAL_PASSWORDS_FILE], strerror(ERRNO));
-  } else if (!mg_stat(path, &st) && st.is_directory) {
-    (void) mg_snprintf(conn, name, sizeof(name), "%s%c%s",
-        path, '/', PASSWORDS_FILE_NAME);
-    fp = mg_fopen(name, "r");
-  } else {
-     // Try to find .htpasswd in requested directory.
-    for (p = path, e = p + strlen(p) - 1; e > p; e--)
-      if (e[0] == '/')
-        break;
-    (void) mg_snprintf(conn, name, sizeof(name), "%.*s%c%s",
-        (int) (e - p), p, '/', PASSWORDS_FILE_NAME);
-    fp = mg_fopen(name, "r");
-  }
-
-  return fp;
-}
-
-// Parsed Authorization header
-struct ah {
-  char *user, *uri, *cnonce, *response, *qop, *nc, *nonce;
-};
-
-// Return 1 on success. Always initializes the ah structure.
-static int parse_auth_header(struct mg_connection *conn, char *buf,
-                             size_t buf_size, struct ah *ah) {
-  char *name, *value, *s;
-  const char *auth_header;
-
-  (void) memset(ah, 0, sizeof(*ah));
-  if ((auth_header = mg_get_header(conn, "Authorization")) == NULL ||
-      mg_strncasecmp(auth_header, "Digest ", 7) != 0) {
-    return 0;
-  }
-
-  // Make modifiable copy of the auth header
-  (void) mg_strlcpy(buf, auth_header + 7, buf_size);
-  s = buf;
-
-  // Parse authorization header
-  for (;;) {
-    // Gobble initial spaces
-    while (isspace(* (unsigned char *) s)) {
-      s++;
-    }
-    name = skip_quoted(&s, "=", " ", 0);
-    // Value is either quote-delimited, or ends at first comma or space.
-    if (s[0] == '\"') {
-      s++;
-      value = skip_quoted(&s, "\"", " ", '\\');
-      if (s[0] == ',') {
-        s++;
-      }
-    } else {
-      value = skip_quoted(&s, ", ", " ", 0);  // IE uses commas, FF uses spaces
-    }
-    if (*name == '\0') {
-      break;
-    }
-
-    if (!strcmp(name, "username")) {
-      ah->user = value;
-    } else if (!strcmp(name, "cnonce")) {
-      ah->cnonce = value;
-    } else if (!strcmp(name, "response")) {
-      ah->response = value;
-    } else if (!strcmp(name, "uri")) {
-      ah->uri = value;
-    } else if (!strcmp(name, "qop")) {
-      ah->qop = value;
-    } else if (!strcmp(name, "nc")) {
-      ah->nc = value;
-    } else if (!strcmp(name, "nonce")) {
-      ah->nonce = value;
-    }
-  }
-
-  // CGI needs it as REMOTE_USER
-  if (ah->user != NULL) {
-    conn->request_info.remote_user = mg_strdup(ah->user);
-  } else {
-    return 0;
-  }
-
-  return 1;
-}
-
-// Authorize against the opened passwords file. Return 1 if authorized.
-static int authorize(struct mg_connection *conn, FILE *fp) {
-  struct ah ah;
-  char line[256], f_user[256], ha1[256], f_domain[256], buf[MG_BUF_LEN];
-
-  if (!parse_auth_header(conn, buf, sizeof(buf), &ah)) {
-    return 0;
-  }
-
-  // Loop over passwords file
-  while (fgets(line, sizeof(line), fp) != NULL) {
-    if (sscanf(line, "%[^:]:%[^:]:%s", f_user, f_domain, ha1) != 3) {
-      continue;
-    }
-
-    if (!strcmp(ah.user, f_user) &&
-        !strcmp(conn->ctx->config[AUTHENTICATION_DOMAIN], f_domain))
-      return check_password(
-            conn->request_info.request_method,
-            ha1, ah.uri, ah.nonce, ah.nc, ah.cnonce, ah.qop,
-            ah.response);
-  }
-
-  return 0;
-}
-
-// Return 1 if request is authorised, 0 otherwise.
-static int check_authorization(struct mg_connection *conn, const char *path) {
-  FILE *fp;
-  char fname[PATH_MAX];
-  struct vec uri_vec, filename_vec;
-  const char *list;
-  int authorized;
-
-  fp = NULL;
-  authorized = 1;
-
-  list = conn->ctx->config[PROTECT_URI];
-  while ((list = next_option(list, &uri_vec, &filename_vec)) != NULL) {
-    if (!memcmp(conn->request_info.uri, uri_vec.ptr, uri_vec.len)) {
-      mg_snprintf(conn, fname, sizeof(fname), "%.*s",
-                  (int) filename_vec.len, filename_vec.ptr);
-      if ((fp = mg_fopen(fname, "r")) == NULL) {
-        cry(conn, "%s: cannot open %s: %s", __func__, fname, strerror(errno));
-      }
-      break;
-    }
-  }
-
-  if (fp == NULL) {
-    fp = open_auth_file(conn, path);
-  }
-
-  if (fp != NULL) {
-    authorized = authorize(conn, fp);
-    (void) fclose(fp);
-  }
-
-  return authorized;
-}
-
-static void send_authorization_request(struct mg_connection *conn) {
-  conn->status_code = 401;
-  (void) mg_printf(conn,
-      "HTTP/1.1 401 Unauthorized\r\n"
-      "Content-Length: 0\r\n"
-      "WWW-Authenticate: Digest qop=\"auth\", "
-      "realm=\"%s\", nonce=\"%lu\"\r\n\r\n",
-      conn->ctx->config[AUTHENTICATION_DOMAIN],
-      (unsigned long) time(NULL));
-}
-
-static int is_authorized_for_put(struct mg_connection *conn) {
-  FILE *fp;
-  int ret = 0;
-
-  fp = conn->ctx->config[PUT_DELETE_PASSWORDS_FILE] == NULL ? NULL :
-    mg_fopen(conn->ctx->config[PUT_DELETE_PASSWORDS_FILE], "r");
-
-  if (fp != NULL) {
-    ret = authorize(conn, fp);
-    (void) fclose(fp);
-  }
-
-  return ret;
-}
-
-int mg_modify_passwords_file(const char *fname, const char *domain,
-                             const char *user, const char *pass) {
-  int found;
-  char line[512], u[512], d[512], ha1[33], tmp[PATH_MAX];
-  FILE *fp, *fp2;
-
-  found = 0;
-  fp = fp2 = NULL;
-
-  // Regard empty password as no password - remove user record.
-  if (pass != NULL && pass[0] == '\0') {
-    pass = NULL;
-  }
-
-  (void) snprintf(tmp, sizeof(tmp), "%s.tmp", fname);
-
-  // Create the file if does not exist
-  if ((fp = mg_fopen(fname, "a+")) != NULL) {
-    (void) fclose(fp);
-  }
-
-  // Open the given file and temporary file
-  if ((fp = mg_fopen(fname, "r")) == NULL) {
-    return 0;
-  } else if ((fp2 = mg_fopen(tmp, "w+")) == NULL) {
-    fclose(fp);
-    return 0;
-  }
-
-  // Copy the stuff to temporary file
-  while (fgets(line, sizeof(line), fp) != NULL) {
-    if (sscanf(line, "%[^:]:%[^:]:%*s", u, d) != 2) {
-      continue;
-    }
-
-    if (!strcmp(u, user) && !strcmp(d, domain)) {
-      found++;
-      if (pass != NULL) {
-        mg_md5(ha1, user, ":", domain, ":", pass, NULL);
-        fprintf(fp2, "%s:%s:%s\n", user, domain, ha1);
-      }
-    } else {
-      (void) fprintf(fp2, "%s", line);
-    }
-  }
-
-  // If new user, just add it
-  if (!found && pass != NULL) {
-    mg_md5(ha1, user, ":", domain, ":", pass, NULL);
-    (void) fprintf(fp2, "%s:%s:%s\n", user, domain, ha1);
-  }
-
-  // Close files
-  (void) fclose(fp);
-  (void) fclose(fp2);
-
-  // Put the temp file in place of real file
-  (void) mg_remove(fname);
-  (void) mg_rename(tmp, fname);
-
-  return 1;
-}
-
-struct de {
-  struct mg_connection *conn;
-  char *file_name;
-  struct mgstat st;
-};
-
-static void url_encode(const char *src, char *dst, size_t dst_len) {
-  static const char *dont_escape = "._-$,;~()";
-  static const char *hex = "0123456789abcdef";
-  const char *end = dst + dst_len - 1;
-
-  for (; *src != '\0' && dst < end; src++, dst++) {
-    if (isalnum(*(const unsigned char *) src) ||
-        strchr(dont_escape, * (const unsigned char *) src) != NULL) {
-      *dst = *src;
-    } else if (dst + 2 < end) {
-      dst[0] = '%';
-      dst[1] = hex[(* (const unsigned char *) src) >> 4];
-      dst[2] = hex[(* (const unsigned char *) src) & 0xf];
-      dst += 2;
-    }
-  }
-
-  *dst = '\0';
-}
-
-static void print_dir_entry(struct de *de) {
-  char size[64], mod[64], href[PATH_MAX];
-
-  if (de->st.is_directory) {
-    (void) mg_snprintf(de->conn, size, sizeof(size), "%s", "[DIRECTORY]");
-  } else {
-     // We use (signed) cast below because MSVC 6 compiler cannot
-     // convert unsigned __int64 to double. Sigh.
-    if (de->st.size < 1024) {
-      (void) mg_snprintf(de->conn, size, sizeof(size),
-          "%lu", (unsigned long) de->st.size);
-    } else if (de->st.size < 0x100000) {
-      (void) mg_snprintf(de->conn, size, sizeof(size),
-          "%.1fk", (double) de->st.size / 1024.0);
-    } else if (de->st.size < 0x40000000) {
-      (void) mg_snprintf(de->conn, size, sizeof(size),
-          "%.1fM", (double) de->st.size / 1048576);
-    } else {
-      (void) mg_snprintf(de->conn, size, sizeof(size),
-          "%.1fG", (double) de->st.size / 1073741824);
-    }
-  }
-  (void) strftime(mod, sizeof(mod), "%d-%b-%Y %H:%M", localtime(&de->st.mtime));
-  url_encode(de->file_name, href, sizeof(href));
-  de->conn->num_bytes_sent += mg_printf(de->conn,
-      "<tr><td><a href=\"%s%s%s\">%s%s</a></td>"
-      "<td>&nbsp;%s</td><td>&nbsp;&nbsp;%s</td></tr>\n",
-      de->conn->request_info.uri, href, de->st.is_directory ? "/" : "",
-      de->file_name, de->st.is_directory ? "/" : "", mod, size);
-}
-
-// This function is called from send_directory() and used for
-// sorting directory entries by size, or name, or modification time.
-// On windows, __cdecl specification is needed in case if project is built
-// with __stdcall convention. qsort always requires __cdels callback.
-static int WINCDECL compare_dir_entries(const void *p1, const void *p2) {
-  const struct de *a = (const struct de *) p1, *b = (const struct de *) p2;
-  const char *query_string = a->conn->request_info.query_string;
-  int cmp_result = 0;
-
-  if (query_string == NULL) {
-    query_string = "na";
-  }
-
-  if (a->st.is_directory && !b->st.is_directory) {
-    return -1;  // Always put directories on top
-  } else if (!a->st.is_directory && b->st.is_directory) {
-    return 1;   // Always put directories on top
-  } else if (*query_string == 'n') {
-    cmp_result = strcmp(a->file_name, b->file_name);
-  } else if (*query_string == 's') {
-    cmp_result = a->st.size == b->st.size ? 0 :
-      a->st.size > b->st.size ? 1 : -1;
-  } else if (*query_string == 'd') {
-    cmp_result = a->st.mtime == b->st.mtime ? 0 :
-      a->st.mtime > b->st.mtime ? 1 : -1;
-  }
-
-  return query_string[1] == 'd' ? -cmp_result : cmp_result;
-}
-
-static int must_hide_file(struct mg_connection *conn, const char *path) {
-  const char *pw_pattern = "**" PASSWORDS_FILE_NAME "$";
-  const char *pattern = conn->ctx->config[HIDE_FILES];
-  return match_prefix(pw_pattern, strlen(pw_pattern), path) > 0 ||
-    (pattern != NULL && match_prefix(pattern, strlen(pattern), path) > 0);
-}
-
-static int scan_directory(struct mg_connection *conn, const char *dir,
-                          void *data, void (*cb)(struct de *, void *)) {
-  char path[PATH_MAX];
-  struct dirent *dp;
-  DIR *dirp;
-  struct de de;
-
-  if ((dirp = opendir(dir)) == NULL) {
-    return 0;
-  } else {
-    de.conn = conn;
-
-    while ((dp = readdir(dirp)) != NULL) {
-      // Do not show current dir and hidden files
-      if (!strcmp(dp->d_name, ".") ||
-          !strcmp(dp->d_name, "..") ||
-          must_hide_file(conn, dp->d_name)) {
-        continue;
-      }
-
-      mg_snprintf(conn, path, sizeof(path), "%s%c%s", dir, '/', dp->d_name);
-
-      // If we don't memset stat structure to zero, mtime will have
-      // garbage and strftime() will segfault later on in
-      // print_dir_entry(). memset is required only if mg_stat()
-      // fails. For more details, see
-      // http://code.google.com/p/mongoose/issues/detail?id=79
-      if (mg_stat(path, &de.st) != 0) {
-        memset(&de.st, 0, sizeof(de.st));
-      }
-      de.file_name = dp->d_name;
-
-      cb(&de, data);
-    }
-    (void) closedir(dirp);
-  }
-  return 1;
-}
-
-struct dir_scan_data {
-  struct de *entries;
-  int num_entries;
-  int arr_size;
-};
-
-static void dir_scan_callback(struct de *de, void *data) {
-  struct dir_scan_data *dsd = (struct dir_scan_data *) data;
-
-  if (dsd->entries == NULL || dsd->num_entries >= dsd->arr_size) {
-    dsd->arr_size *= 2;
-    dsd->entries = (struct de *) realloc(dsd->entries, dsd->arr_size *
-                                         sizeof(dsd->entries[0]));
-  }
-  if (dsd->entries == NULL) {
-    // TODO(lsm): propagate an error to the caller
-    dsd->num_entries = 0;
-  } else {
-    dsd->entries[dsd->num_entries].file_name = mg_strdup(de->file_name);
-    dsd->entries[dsd->num_entries].st = de->st;
-    dsd->entries[dsd->num_entries].conn = de->conn;
-    dsd->num_entries++;
-  }
-}
-
-static void handle_directory_request(struct mg_connection *conn,
-                                     const char *dir) {
-  int i, sort_direction;
-  struct dir_scan_data data = { NULL, 0, 128 };
-
-  if (!scan_directory(conn, dir, &data, dir_scan_callback)) {
-    send_http_error(conn, 500, "Cannot open directory",
-                    "Error: opendir(%s): %s", dir, strerror(ERRNO));
-    return;
-  }
-
-  sort_direction = conn->request_info.query_string != NULL &&
-    conn->request_info.query_string[1] == 'd' ? 'a' : 'd';
-
-  conn->must_close = 1;
-  mg_printf(conn, "%s",
-            "HTTP/1.1 200 OK\r\n"
-            "Connection: close\r\n"
-            "Content-Type: text/html; charset=utf-8\r\n\r\n");
-
-  conn->num_bytes_sent += mg_printf(conn,
-      "<html><head><title>Index of %s</title>"
-      "<style>th {text-align: left;}</style></head>"
-      "<body><h1>Index of %s</h1><pre><table cellpadding=\"0\">"
-      "<tr><th><a href=\"?n%c\">Name</a></th>"
-      "<th><a href=\"?d%c\">Modified</a></th>"
-      "<th><a href=\"?s%c\">Size</a></th></tr>"
-      "<tr><td colspan=\"3\"><hr></td></tr>",
-      conn->request_info.uri, conn->request_info.uri,
-      sort_direction, sort_direction, sort_direction);
-
-  // Print first entry - link to a parent directory
-  conn->num_bytes_sent += mg_printf(conn,
-      "<tr><td><a href=\"%s%s\">%s</a></td>"
-      "<td>&nbsp;%s</td><td>&nbsp;&nbsp;%s</td></tr>\n",
-      conn->request_info.uri, "..", "Parent directory", "-", "-");
-
-  // Sort and print directory entries
-  qsort(data.entries, (size_t) data.num_entries, sizeof(data.entries[0]),
-        compare_dir_entries);
-  for (i = 0; i < data.num_entries; i++) {
-    print_dir_entry(&data.entries[i]);
-    free(data.entries[i].file_name);
-  }
-  free(data.entries);
-
-  conn->num_bytes_sent += mg_printf(conn, "%s", "</table></body></html>");
-  conn->status_code = 200;
-}
-
-// Send len bytes from the opened file to the client.
-static void send_file_data(struct mg_connection *conn, FILE *fp, int64_t len) {
-  char buf[MG_BUF_LEN];
-  int to_read, num_read, num_written;
-
-  while (len > 0) {
-    // Calculate how much to read from the file in the buffer
-    to_read = sizeof(buf);
-    if ((int64_t) to_read > len) {
-      to_read = (int) len;
-    }
-
-    // Read from file, exit the loop on error
-    if ((num_read = fread(buf, 1, (size_t)to_read, fp)) <= 0) {
-      break;
-    }
-
-    // Send read bytes to the client, exit the loop on error
-    if ((num_written = mg_write(conn, buf, (size_t)num_read)) != num_read) {
-      break;
-    }
-
-    // Both read and were successful, adjust counters
-    conn->num_bytes_sent += num_written;
-    len -= num_written;
-  }
-}
-
-static int parse_range_header(const char *header, int64_t *a, int64_t *b) {
-  return sscanf(header, "bytes=%" INT64_FMT "-%" INT64_FMT, a, b);
-}
-
-static void gmt_time_string(char *buf, size_t buf_len, time_t *t) {
-  strftime(buf, buf_len, "%a, %d %b %Y %H:%M:%S GMT", gmtime(t));
-}
-
-static void construct_etag(char *buf, size_t buf_len,
-                           const struct mgstat *stp) {
-  snprintf(buf, buf_len, "\"%lx.%" INT64_FMT "\"",
-           (unsigned long) stp->mtime, stp->size);
-}
-
-static void handle_file_request(struct mg_connection *conn, const char *path,
-                                struct mgstat *stp) {
-  char date[64], lm[64], etag[64], range[64];
-  const char *msg = "OK", *hdr;
-  time_t curtime = time(NULL);
-  int64_t cl, r1, r2;
-  struct vec mime_vec;
-  FILE *fp;
-  int n;
-
-  get_mime_type(conn->ctx, path, &mime_vec);
-  cl = stp->size;
-  conn->status_code = 200;
-  range[0] = '\0';
-
-  if ((fp = mg_fopen(path, "rb")) == NULL) {
-    send_http_error(conn, 500, http_500_error,
-        "fopen(%s): %s", path, strerror(ERRNO));
-    return;
-  }
-  set_close_on_exec(fileno(fp));
-
-  // If Range: header specified, act accordingly
-  r1 = r2 = 0;
-  hdr = mg_get_header(conn, "Range");
-  if (hdr != NULL && (n = parse_range_header(hdr, &r1, &r2)) > 0) {
-    conn->status_code = 206;
-    (void) fseeko(fp, r1, SEEK_SET);
-    cl = n == 2 ? r2 - r1 + 1: cl - r1;
-    (void) mg_snprintf(conn, range, sizeof(range),
-        "Content-Range: bytes "
-        "%" INT64_FMT "-%"
-        INT64_FMT "/%" INT64_FMT "\r\n",
-        r1, r1 + cl - 1, stp->size);
-    msg = "Partial Content";
-  }
-
-  // Prepare Etag, Date, Last-Modified headers. Must be in UTC, according to
-  // http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3
-  gmt_time_string(date, sizeof(date), &curtime);
-  gmt_time_string(lm, sizeof(lm), &stp->mtime);
-  construct_etag(etag, sizeof(etag), stp);
-
-  (void) mg_printf(conn,
-      "HTTP/1.1 %d %s\r\n"
-      "Date: %s\r\n"
-      "Last-Modified: %s\r\n"
-      "Etag: %s\r\n"
-      "Content-Type: %.*s\r\n"
-      "Content-Length: %" INT64_FMT "\r\n"
-      "Connection: %s\r\n"
-      "Accept-Ranges: bytes\r\n"
-      "%s\r\n",
-      conn->status_code, msg, date, lm, etag, (int) mime_vec.len,
-      mime_vec.ptr, cl, suggest_connection_header(conn), range);
-
-  if (strcmp(conn->request_info.request_method, "HEAD") != 0) {
-    send_file_data(conn, fp, cl);
-  }
-  (void) fclose(fp);
-}
-
-void mg_send_file(struct mg_connection *conn, const char *path) {
-  struct mgstat st;
-  if (mg_stat(path, &st) == 0) {
-    handle_file_request(conn, path, &st);
-  } else {
-    send_http_error(conn, 404, "Not Found", "%s", "File not found");
-  }
-}
-
-
-// Parse HTTP headers from the given buffer, advance buffer to the point
-// where parsing stopped.
-static void parse_http_headers(char **buf, struct mg_request_info *ri) {
-  int i;
-
-  for (i = 0; i < (int) ARRAY_SIZE(ri->http_headers); i++) {
-    ri->http_headers[i].name = skip_quoted(buf, ":", " ", 0);
-    ri->http_headers[i].value = skip(buf, "\r\n");
-    if (ri->http_headers[i].name[0] == '\0')
-      break;
-    ri->num_headers = i + 1;
-  }
-}
-
-static int is_valid_http_method(const char *method) {
-  return !strcmp(method, "GET") || !strcmp(method, "POST") ||
-    !strcmp(method, "HEAD") || !strcmp(method, "CONNECT") ||
-    !strcmp(method, "PUT") || !strcmp(method, "DELETE") ||
-    !strcmp(method, "OPTIONS") || !strcmp(method, "PROPFIND");
-}
-
-// Parse HTTP request, fill in mg_request_info structure.
-// This function modifies the buffer by NUL-terminating
-// HTTP request components, header names and header values.
-static int parse_http_message(char *buf, int len, struct mg_request_info *ri) {
-  int request_length = get_request_len(buf, len);
-  if (request_length > 0) {
-    // Reset attributes. DO NOT TOUCH is_ssl, remote_ip, remote_port
-    ri->remote_user = ri->request_method = ri->uri = ri->http_version = NULL;
-    ri->num_headers = 0;
-
-    buf[request_length - 1] = '\0';
-
-    // RFC says that all initial whitespaces should be ingored
-    while (*buf != '\0' && isspace(* (unsigned char *) buf)) {
-      buf++;
-    }
-    ri->request_method = skip(&buf, " ");
-    ri->uri = skip(&buf, " ");
-    ri->http_version = skip(&buf, "\r\n");
-    parse_http_headers(&buf, ri);
-  }
-  return request_length;
-}
-
-static int parse_http_request(char *buf, int len, struct mg_request_info *ri) {
-  int result = parse_http_message(buf, len, ri);
-  if (result > 0 &&
-      is_valid_http_method(ri->request_method) &&
-      !strncmp(ri->http_version, "HTTP/", 5)) {
-    ri->http_version += 5;   // Skip "HTTP/"
-  } else {
-    result = -1;
-  }
-  return result;
-}
-
-static int parse_http_response(char *buf, int len, struct mg_request_info *ri) {
-  int result = parse_http_message(buf, len, ri);
-  return result > 0 && !strncmp(ri->request_method, "HTTP/", 5) ? result : -1;
-}
-
-// Keep reading the input (either opened file descriptor fd, or socket sock,
-// or SSL descriptor ssl) into buffer buf, until \r\n\r\n appears in the
-// buffer (which marks the end of HTTP request). Buffer buf may already
-// have some data. The length of the data is stored in nread.
-// Upon every read operation, increase nread by the number of bytes read.
-static int read_request(FILE *fp, struct mg_connection *conn,
-                        char *buf, int bufsiz, int *nread) {
-  int request_len, n = 1;
-
-  request_len = get_request_len(buf, *nread);
-  while (*nread < bufsiz && request_len == 0 && n > 0) {
-    n = pull(fp, conn, buf + *nread, bufsiz - *nread);
-    if (n > 0) {
-      *nread += n;
-      request_len = get_request_len(buf, *nread);
-    }
-  }
-
-  if (n < 0) {
-    // recv() error -> propagate error; do not process a b0rked-with-very-high-probability request
-    return -1;
-  }
-  return request_len;
-}
-
-// For given directory path, substitute it to valid index file.
-// Return 0 if index file has been found, -1 if not found.
-// If the file is found, it's stats is returned in stp.
-static int substitute_index_file(struct mg_connection *conn, char *path,
-                                 size_t path_len, struct mgstat *stp) {
-  const char *list = conn->ctx->config[INDEX_FILES];
-  struct mgstat st;
-  struct vec filename_vec;
-  size_t n = strlen(path);
-  int found = 0;
-
-  // The 'path' given to us points to the directory. Remove all trailing
-  // directory separator characters from the end of the path, and
-  // then append single directory separator character.
-  while (n > 0 && path[n - 1] == '/') {
-    n--;
-  }
-  path[n] = '/';
-
-  // Traverse index files list. For each entry, append it to the given
-  // path and see if the file exists. If it exists, break the loop
-  while ((list = next_option(list, &filename_vec, NULL)) != NULL) {
-
-    // Ignore too long entries that may overflow path buffer
-    if (filename_vec.len > path_len - (n + 2))
-      continue;
-
-    // Prepare full path to the index file
-    (void) mg_strlcpy(path + n + 1, filename_vec.ptr, filename_vec.len + 1);
-
-    // Does it exist?
-    if (mg_stat(path, &st) == 0) {
-      // Yes it does, break the loop
-      *stp = st;
-      found = 1;
-      break;
-    }
-  }
-
-  // If no index file exists, restore directory path
-  if (!found) {
-    path[n] = '\0';
-  }
-
-  return found;
-}
-
-// Return True if we should reply 304 Not Modified.
-static int is_not_modified(const struct mg_connection *conn,
-                           const struct mgstat *stp) {
-  char etag[64];
-  const char *ims = mg_get_header(conn, "If-Modified-Since");
-  const char *inm = mg_get_header(conn, "If-None-Match");
-  construct_etag(etag, sizeof(etag), stp);
-  return (inm != NULL && !mg_strcasecmp(etag, inm)) ||
-    (ims != NULL && stp->mtime <= parse_date_string(ims));
-}
-
-static int forward_body_data(struct mg_connection *conn, FILE *fp,
-                             SOCKET sock, SSL *ssl) {
-  const char *expect, *body;
-  char buf[MG_BUF_LEN];
-  int to_read, nread, buffered_len, success = 0;
-
-  expect = mg_get_header(conn, "Expect");
-  assert(fp != NULL);
-
-  if (conn->content_len == -1) {
-    send_http_error(conn, 411, "Length Required", "%s", "");
-  } else if (expect != NULL && mg_strcasecmp(expect, "100-continue")) {
-    send_http_error(conn, 417, "Expectation Failed", "%s", "");
-  } else {
-    if (expect != NULL) {
-      (void) mg_printf(conn, "%s", "HTTP/1.1 100 Continue\r\n\r\n");
-    }
-
-    body = conn->buf + conn->request_len + conn->consumed_content;
-    buffered_len = &conn->buf[conn->data_len] - body;
-    assert(buffered_len >= 0);
-    assert(conn->consumed_content == 0);
-
-    if (buffered_len > 0) {
-      if ((int64_t) buffered_len > conn->content_len) {
-        buffered_len = (int) conn->content_len;
-      }
-      push(fp, sock, ssl, body, (int64_t) buffered_len);
-      conn->consumed_content += buffered_len;
-    }
-
-    nread = 0;
-    while (conn->consumed_content < conn->content_len) {
-      to_read = sizeof(buf);
-      if ((int64_t) to_read > conn->content_len - conn->consumed_content) {
-        to_read = (int) (conn->content_len - conn->consumed_content);
-      }
-      nread = pull(NULL, conn, buf, to_read);
-      if (nread <= 0 || push(fp, sock, ssl, buf, nread) != nread) {
-        break;
-      }
-      conn->consumed_content += nread;
-    }
-
-    if (conn->consumed_content == conn->content_len) {
-      success = nread >= 0;
-    }
-
-    // Each error code path in this function must send an error
-    if (!success) {
-      send_http_error(conn, 577, http_500_error, "%s", "");
-    }
-  }
-
-  return success;
-}
-
-#if !defined(NO_CGI)
-// This structure helps to create an environment for the spawned CGI program.
-// Environment is an array of "VARIABLE=VALUE\0" ASCIIZ strings,
-// last element must be NULL.
-// However, on Windows there is a requirement that all these VARIABLE=VALUE\0
-// strings must reside in a contiguous buffer. The end of the buffer is
-// marked by two '\0' characters.
-// We satisfy both worlds: we create an envp array (which is vars), all
-// entries are actually pointers inside buf.
-struct cgi_env_block {
-  struct mg_connection *conn;
-  char buf[CGI_ENVIRONMENT_SIZE]; // Environment buffer
-  int len; // Space taken
-  char *vars[MAX_CGI_ENVIR_VARS]; // char **envp
-  int nvars; // Number of variables
-};
-
-static char *addenv(struct cgi_env_block *block,
-                    PRINTF_FORMAT_STRING(const char *fmt), ...)
-  PRINTF_ARGS(2, 3);
-
-// Append VARIABLE=VALUE\0 string to the buffer, and add a respective
-// pointer into the vars array.
-static char *addenv(struct cgi_env_block *block, const char *fmt, ...) {
-  int n, space;
-  char *added;
-  va_list ap;
-
-  // Calculate how much space is left in the buffer
-  space = sizeof(block->buf) - block->len - 2;
-  assert(space >= 0);
-
-  // Make a pointer to the free space int the buffer
-  added = block->buf + block->len;
-
-  // Copy VARIABLE=VALUE\0 string into the free space
-  va_start(ap, fmt);
-  n = mg_vsnprintf(block->conn, added, (size_t) space, fmt, ap);
-  va_end(ap);
-
-  // Make sure we do not overflow buffer and the envp array
-  if (n > 0 && n + 1 < space &&
-      block->nvars < (int) ARRAY_SIZE(block->vars) - 2) {
-    // Append a pointer to the added string into the envp array
-    block->vars[block->nvars++] = added;
-    // Bump up used length counter. Include \0 terminator
-    block->len += n + 1;
-  } else {
-    cry(block->conn, "%s: CGI env buffer truncated for [%s]", __func__, fmt);
-  }
-
-  return added;
-}
-
-static void prepare_cgi_environment(struct mg_connection *conn,
-                                    const char *prog,
-                                    struct cgi_env_block *blk) {
-  const char *s, *slash;
-  struct vec var_vec;
-  char *p, src_addr[20];
-  int  i;
-
-  blk->len = blk->nvars = 0;
-  blk->conn = conn;
-  sockaddr_to_string(src_addr, sizeof(src_addr), &conn->client.rsa);
-
-  addenv(blk, "SERVER_NAME=%s", conn->ctx->config[AUTHENTICATION_DOMAIN]);
-  addenv(blk, "SERVER_ROOT=%s", conn->ctx->config[DOCUMENT_ROOT]);
-  addenv(blk, "DOCUMENT_ROOT=%s", conn->ctx->config[DOCUMENT_ROOT]);
-
-  // Prepare the environment block
-  addenv(blk, "%s", "GATEWAY_INTERFACE=CGI/1.1");
-  addenv(blk, "%s", "SERVER_PROTOCOL=HTTP/1.1");
-  addenv(blk, "%s", "REDIRECT_STATUS=200"); // For PHP
-
-  // TODO(lsm): fix this for IPv6 case
-  addenv(blk, "SERVER_PORT=%d", ntohs(conn->client.lsa.sin.sin_port));
-
-  addenv(blk, "REQUEST_METHOD=%s", conn->request_info.request_method);
-  addenv(blk, "REMOTE_ADDR=%s", src_addr);
-  addenv(blk, "REMOTE_PORT=%d", conn->request_info.remote_port);
-  addenv(blk, "REQUEST_URI=%s", conn->request_info.uri);
-
-  // SCRIPT_NAME
-  assert(conn->request_info.uri[0] == '/');
-  slash = strrchr(conn->request_info.uri, '/');
-  if ((s = strrchr(prog, '/')) == NULL)
-    s = prog;
-  addenv(blk, "SCRIPT_NAME=%.*s%s", (int) (slash - conn->request_info.uri),
-         conn->request_info.uri, s);
-
-  addenv(blk, "SCRIPT_FILENAME=%s", prog);
-  addenv(blk, "PATH_TRANSLATED=%s", prog);
-  addenv(blk, "HTTPS=%s", conn->ssl == NULL ? "off" : "on");
-
-  if ((s = mg_get_header(conn, "Content-Type")) != NULL)
-    addenv(blk, "CONTENT_TYPE=%s", s);
-
-  if (conn->request_info.query_string != NULL)
-    addenv(blk, "QUERY_STRING=%s", conn->request_info.query_string);
-
-  if ((s = mg_get_header(conn, "Content-Length")) != NULL)
-    addenv(blk, "CONTENT_LENGTH=%s", s);
-
-  if ((s = getenv("PATH")) != NULL)
-    addenv(blk, "PATH=%s", s);
-
-  if (conn->path_info != NULL) {
-    addenv(blk, "PATH_INFO=%s", conn->path_info);
-  }
-
-#if defined(_WIN32)
-  if ((s = getenv("COMSPEC")) != NULL) {
-    addenv(blk, "COMSPEC=%s", s);
-  }
-  if ((s = getenv("SYSTEMROOT")) != NULL) {
-    addenv(blk, "SYSTEMROOT=%s", s);
-  }
-  if ((s = getenv("SystemDrive")) != NULL) {
-    addenv(blk, "SystemDrive=%s", s);
-  }
-#else
-  if ((s = getenv("LD_LIBRARY_PATH")) != NULL)
-    addenv(blk, "LD_LIBRARY_PATH=%s", s);
-#endif // _WIN32
-
-  if ((s = getenv("PERLLIB")) != NULL)
-    addenv(blk, "PERLLIB=%s", s);
-
-  if (conn->request_info.remote_user != NULL) {
-    addenv(blk, "REMOTE_USER=%s", conn->request_info.remote_user);
-    addenv(blk, "%s", "AUTH_TYPE=Digest");
-  }
-
-  // Add all headers as HTTP_* variables
-  for (i = 0; i < conn->request_info.num_headers; i++) {
-    p = addenv(blk, "HTTP_%s=%s",
-        conn->request_info.http_headers[i].name,
-        conn->request_info.http_headers[i].value);
-
-    // Convert variable name into uppercase, and change - to _
-    for (; *p != '=' && *p != '\0'; p++) {
-      if (*p == '-')
-        *p = '_';
-      *p = (char) toupper(* (unsigned char *) p);
-    }
-  }
-
-  // Add user-specified variables
-  s = conn->ctx->config[CGI_ENVIRONMENT];
-  while ((s = next_option(s, &var_vec, NULL)) != NULL) {
-    addenv(blk, "%.*s", (int) var_vec.len, var_vec.ptr);
-  }
-
-  blk->vars[blk->nvars++] = NULL;
-  blk->buf[blk->len++] = '\0';
-
-  assert(blk->nvars < (int) ARRAY_SIZE(blk->vars));
-  assert(blk->len > 0);
-  assert(blk->len < (int) sizeof(blk->buf));
-}
-
-static void handle_cgi_request(struct mg_connection *conn, const char *prog) {
-  int headers_len, data_len, i, fd_stdin[2], fd_stdout[2];
-  const char *status, *status_text;
-  char buf[16384], *pbuf, dir[PATH_MAX], *p;
-  struct mg_request_info ri;
-  ri.num_headers = 0;
-  struct cgi_env_block blk;
-  FILE *in, *out;
-  pid_t pid;
-
-  prepare_cgi_environment(conn, prog, &blk);
-
-  // CGI must be executed in its own directory. 'dir' must point to the
-  // directory containing executable program, 'p' must point to the
-  // executable program name relative to 'dir'.
-  (void) mg_snprintf(conn, dir, sizeof(dir), "%s", prog);
-  if ((p = strrchr(dir, '/')) != NULL) {
-    *p++ = '\0';
-  } else {
-    dir[0] = '.', dir[1] = '\0';
-    p = (char *) prog;
-  }
-
-  pid = (pid_t) -1;
-  fd_stdin[0] = fd_stdin[1] = fd_stdout[0] = fd_stdout[1] = -1;
-  in = out = NULL;
-
-  if (pipe(fd_stdin) != 0 || pipe(fd_stdout) != 0) {
-    send_http_error(conn, 500, http_500_error,
-        "Cannot create CGI pipe: %s", strerror(ERRNO));
-    goto done;
-  } else if ((pid = spawn_process(conn, p, blk.buf, blk.vars,
-          fd_stdin[0], fd_stdout[1], dir)) == (pid_t) -1) {
-    send_http_error(conn, 500, http_500_error,
-        "Cannot spawn CGI process [%s]: %s", prog, strerror(ERRNO));
-    goto done;
-  }
-
-  // spawn_process() must close those!
-  // If we don't mark them as closed, close() attempt before
-  // return from this function throws an exception on Windows.
-  // Windows does not like when closed descriptor is closed again.
-  fd_stdin[0] = fd_stdout[1] = -1;
-
-  if ((in = fdopen(fd_stdin[1], "wb")) == NULL ||
-      (out = fdopen(fd_stdout[0], "rb")) == NULL) {
-    send_http_error(conn, 500, http_500_error,
-        "fopen: %s", strerror(ERRNO));
-    goto done;
-  }
-
-  setbuf(in, NULL);
-  setbuf(out, NULL);
-
-  // Send POST data to the CGI process if needed
-  if (!strcmp(conn->request_info.request_method, "POST") &&
-      !forward_body_data(conn, in, INVALID_SOCKET, NULL)) {
-    goto done;
-  }
-
-  // Close so child gets an EOF.
-  fclose(in);
-  in = NULL;
-  fd_stdin[1] = -1;
-
-  // Now read CGI reply into a buffer. We need to set correct
-  // status code, thus we need to see all HTTP headers first.
-  // Do not send anything back to client, until we buffer in all
-  // HTTP headers.
-  data_len = 0;
-  headers_len = read_request(out, conn, buf, sizeof(buf), &data_len);
-  if (headers_len <= 0) {
-    send_http_error(conn, 500, http_500_error,
-                    "CGI program sent malformed or too big (>%u bytes) "
-                    "HTTP headers: [%.*s]",
-                    (unsigned) sizeof(buf), data_len, buf);
-    goto done;
-  }
-  pbuf = buf;
-  buf[headers_len - 1] = '\0';
-  parse_http_headers(&pbuf, &ri);
-
-  // Make up and send the status line
-  status_text = "OK";
-  if ((status = get_header(&ri, "Status")) != NULL) {
-    conn->status_code = atoi(status);
-    status_text = status;
-    while (isdigit(* (unsigned char *) status_text) || *status_text == ' ') {
-      status_text++;
-    }
-  } else if (get_header(&ri, "Location") != NULL) {
-    conn->status_code = 302;
-  } else {
-    conn->status_code = 200;
-  }
-  if (get_header(&ri, "Connection") != NULL &&
-      !mg_strcasecmp(get_header(&ri, "Connection"), "keep-alive")) {
-    conn->must_close = 1;
-  }
-  (void) mg_printf(conn, "HTTP/1.1 %d %s\r\n", conn->status_code,
-                   status_text);
-
-  // Send headers
-  for (i = 0; i < ri.num_headers; i++) {
-    mg_printf(conn, "%s: %s\r\n",
-              ri.http_headers[i].name, ri.http_headers[i].value);
-  }
-  (void) mg_write(conn, "\r\n", 2);
-
-  // Send chunk of data that may have been read after the headers
-  conn->num_bytes_sent += mg_write(conn, buf + headers_len,
-                                   (size_t)(data_len - headers_len));
-
-  // Read the rest of CGI output and send to the client
-  send_file_data(conn, out, INT64_MAX);
-
-done:
-  if (pid != (pid_t) -1) {
-    kill(pid, SIGKILL);
-  }
-  if (fd_stdin[0] != -1) {
-    (void) close(fd_stdin[0]);
-  }
-  if (fd_stdout[1] != -1) {
-    (void) close(fd_stdout[1]);
-  }
-
-  if (in != NULL) {
-    (void) fclose(in);
-  } else if (fd_stdin[1] != -1) {
-    (void) close(fd_stdin[1]);
-  }
-
-  if (out != NULL) {
-    (void) fclose(out);
-  } else if (fd_stdout[0] != -1) {
-    (void) close(fd_stdout[0]);
-  }
-}
-#endif // !NO_CGI
-
-// For a given PUT path, create all intermediate subdirectories
-// for given path. Return 0 if the path itself is a directory,
-// or -1 on error, 1 if OK.
-static int put_dir(const char *path) {
-  char buf[PATH_MAX];
-  const char *s, *p;
-  struct mgstat st;
-  int len, res = 1;
-
-  for (s = p = path + 2; (p = strchr(s, '/')) != NULL; s = ++p) {
-    len = p - path;
-    if (len >= (int) sizeof(buf)) {
-      res = -1;
-      break;
-    }
-    memcpy(buf, path, len);
-    buf[len] = '\0';
-
-    // Try to create intermediate directory
-    DEBUG_TRACE(("mkdir(%s)", buf));
-    if (mg_stat(buf, &st) == -1 && mg_mkdir(buf, 0755) != 0) {
-      res = -1;
-      break;
-    }
-
-    // Is path itself a directory?
-    if (p[1] == '\0') {
-      res = 0;
-    }
-  }
-
-  return res;
-}
-
-static void put_file(struct mg_connection *conn, const char *path) {
-  struct mgstat st;
-  const char *range;
-  int64_t r1, r2;
-  FILE *fp;
-  int rc;
-
-  conn->status_code = mg_stat(path, &st) == 0 ? 200 : 201;
-
-  if ((rc = put_dir(path)) == 0) {
-    mg_printf(conn, "HTTP/1.1 %d OK\r\n\r\n", conn->status_code);
-  } else if (rc == -1) {
-    send_http_error(conn, 500, http_500_error,
-        "put_dir(%s): %s", path, strerror(ERRNO));
-  } else if ((fp = mg_fopen(path, "wb+")) == NULL) {
-    send_http_error(conn, 500, http_500_error,
-        "fopen(%s): %s", path, strerror(ERRNO));
-  } else {
-    set_close_on_exec(fileno(fp));
-    range = mg_get_header(conn, "Content-Range");
-    r1 = r2 = 0;
-    if (range != NULL && parse_range_header(range, &r1, &r2) > 0) {
-      conn->status_code = 206;
-      // TODO(lsm): handle seek error
-      (void) fseeko(fp, r1, SEEK_SET);
-    }
-    if (forward_body_data(conn, fp, INVALID_SOCKET, NULL)) {
-      (void) mg_printf(conn, "HTTP/1.1 %d OK\r\n\r\n", conn->status_code);
-    }
-    (void) fclose(fp);
-  }
-}
-
-static void send_ssi_file(struct mg_connection *, const char *, FILE *, int);
-
-static void do_ssi_include(struct mg_connection *conn, const char *ssi,
-                           char *tag, int include_level) {
-  char file_name[MG_BUF_LEN], path[PATH_MAX], *p;
-  FILE *fp;
-
-  // sscanf() is safe here, since send_ssi_file() also uses buffer
-  // of size MG_BUF_LEN to get the tag. So strlen(tag) is always < MG_BUF_LEN.
-  if (sscanf(tag, " virtual=\"%[^\"]\"", file_name) == 1) {
-    // File name is relative to the webserver root
-    (void) mg_snprintf(conn, path, sizeof(path), "%s%c%s",
-        conn->ctx->config[DOCUMENT_ROOT], '/', file_name);
-  } else if (sscanf(tag, " file=\"%[^\"]\"", file_name) == 1) {
-    // File name is relative to the webserver working directory
-    // or it is absolute system path
-    (void) mg_snprintf(conn, path, sizeof(path), "%s", file_name);
-  } else if (sscanf(tag, " \"%[^\"]\"", file_name) == 1) {
-    // File name is relative to the currect document
-    (void) mg_snprintf(conn, path, sizeof(path), "%s", ssi);
-    if ((p = strrchr(path, '/')) != NULL) {
-      p[1] = '\0';
-    }
-    (void) mg_snprintf(conn, path + strlen(path),
-        sizeof(path) - strlen(path), "%s", file_name);
-  } else {
-    cry(conn, "Bad SSI #include: [%s]", tag);
-    return;
-  }
-
-  if ((fp = mg_fopen(path, "rb")) == NULL) {
-    cry(conn, "Cannot open SSI #include: [%s]: fopen(%s): %s",
-        tag, path, strerror(ERRNO));
-  } else {
-    set_close_on_exec(fileno(fp));
-    if (match_prefix(conn->ctx->config[SSI_EXTENSIONS],
-                     strlen(conn->ctx->config[SSI_EXTENSIONS]), path) > 0) {
-      send_ssi_file(conn, path, fp, include_level + 1);
-    } else {
-      send_file_data(conn, fp, INT64_MAX);
-    }
-    (void) fclose(fp);
-  }
-}
-
-#if !defined(NO_POPEN)
-static void do_ssi_exec(struct mg_connection *conn, char *tag) {
-  char cmd[MG_BUF_LEN];
-  FILE *fp;
-
-  if (sscanf(tag, " \"%[^\"]\"", cmd) != 1) {
-    cry(conn, "Bad SSI #exec: [%s]", tag);
-  } else if ((fp = popen(cmd, "r")) == NULL) {
-    cry(conn, "Cannot SSI #exec: [%s]: %s", cmd, strerror(ERRNO));
-  } else {
-    send_file_data(conn, fp, INT64_MAX);
-    (void) pclose(fp);
-  }
-}
-#endif // !NO_POPEN
-
-static void send_ssi_file(struct mg_connection *conn, const char *path,
-                          FILE *fp, int include_level) {
-  char buf[MG_BUF_LEN];
-  int ch, len, in_ssi_tag;
-
-  if (include_level > 10) {
-    cry(conn, "SSI #include level is too deep (%s)", path);
-    return;
-  }
-
-  in_ssi_tag = 0;
-  len = 0;
-
-  while ((ch = fgetc(fp)) != EOF) {
-    if (in_ssi_tag && ch == '>') {
-      in_ssi_tag = 0;
-      buf[len++] = (char) ch;
-      buf[len] = '\0';
-      assert(len <= (int) sizeof(buf));
-      if (len < 6 || memcmp(buf, "<!--#", 5) != 0) {
-        // Not an SSI tag, pass it
-        (void) mg_write(conn, buf, (size_t)len);
-      } else {
-        if (!memcmp(buf + 5, "include", 7)) {
-          do_ssi_include(conn, path, buf + 12, include_level);
-#if !defined(NO_POPEN)
-        } else if (!memcmp(buf + 5, "exec", 4)) {
-          do_ssi_exec(conn, buf + 9);
-#endif // !NO_POPEN
-        } else {
-          cry(conn, "%s: unknown SSI " "command: \"%s\"", path, buf);
-        }
-      }
-      len = 0;
-    } else if (in_ssi_tag) {
-      if (len == 5 && memcmp(buf, "<!--#", 5) != 0) {
-        // Not an SSI tag
-        in_ssi_tag = 0;
-      } else if (len == (int) sizeof(buf) - 2) {
-        cry(conn, "%s: SSI tag is too large", path);
-        len = 0;
-      }
-      buf[len++] = ch & 0xff;
-    } else if (ch == '<') {
-      in_ssi_tag = 1;
-      if (len > 0) {
-        (void) mg_write(conn, buf, (size_t)len);
-      }
-      len = 0;
-      buf[len++] = ch & 0xff;
-    } else {
-      buf[len++] = ch & 0xff;
-      if (len == (int) sizeof(buf)) {
-        (void) mg_write(conn, buf, (size_t)len);
-        len = 0;
-      }
-    }
-  }
-
-  // Send the rest of buffered data
-  if (len > 0) {
-    (void) mg_write(conn, buf, (size_t)len);
-  }
-}
-
-static void handle_ssi_file_request(struct mg_connection *conn,
-                                    const char *path) {
-  FILE *fp;
-
-  if ((fp = mg_fopen(path, "rb")) == NULL) {
-    send_http_error(conn, 500, http_500_error, "fopen(%s): %s", path,
-                    strerror(ERRNO));
-  } else {
-    conn->must_close = 1;
-    set_close_on_exec(fileno(fp));
-    mg_printf(conn, "HTTP/1.1 200 OK\r\n"
-              "Content-Type: text/html\r\nConnection: %s\r\n\r\n",
-              suggest_connection_header(conn));
-    send_ssi_file(conn, path, fp, 0);
-    (void) fclose(fp);
-  }
-}
-
-static void send_options(struct mg_connection *conn) {
-  conn->status_code = 200;
-
-  (void) mg_printf(conn,
-      "HTTP/1.1 200 OK\r\n"
-      "Allow: GET, POST, HEAD, CONNECT, PUT, DELETE, OPTIONS\r\n"
-      "DAV: 1\r\n\r\n");
-}
-
-// Writes PROPFIND properties for a collection element
-static void print_props(struct mg_connection *conn, const char* uri,
-                        struct mgstat* st) {
-  char mtime[64];
-  gmt_time_string(mtime, sizeof(mtime), &st->mtime);
-  conn->num_bytes_sent += mg_printf(conn,
-      "<d:response>"
-       "<d:href>%s</d:href>"
-       "<d:propstat>"
-        "<d:prop>"
-         "<d:resourcetype>%s</d:resourcetype>"
-         "<d:getcontentlength>%" INT64_FMT "</d:getcontentlength>"
-         "<d:getlastmodified>%s</d:getlastmodified>"
-        "</d:prop>"
-        "<d:status>HTTP/1.1 200 OK</d:status>"
-       "</d:propstat>"
-      "</d:response>\n",
-      uri,
-      st->is_directory ? "<d:collection/>" : "",
-      st->size,
-      mtime);
-}
-
-static void print_dav_dir_entry(struct de *de, void *data) {
-  char href[PATH_MAX];
-  struct mg_connection *conn = (struct mg_connection *) data;
-  mg_snprintf(conn, href, sizeof(href), "%s%s",
-              conn->request_info.uri, de->file_name);
-  print_props(conn, href, &de->st);
-}
-
-static void handle_propfind(struct mg_connection *conn, const char* path,
-                            struct mgstat* st) {
-  const char *depth = mg_get_header(conn, "Depth");
-
-  conn->must_close = 1;
-  conn->status_code = 207;
-  mg_printf(conn, "HTTP/1.1 207 Multi-Status\r\n"
-            "Connection: close\r\n"
-            "Content-Type: text/xml; charset=utf-8\r\n\r\n");
-
-  conn->num_bytes_sent += mg_printf(conn,
-      "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
-      "<d:multistatus xmlns:d='DAV:'>\n");
-
-  // Print properties for the requested resource itself
-  print_props(conn, conn->request_info.uri, st);
-
-  // If it is a directory, print directory entries too if Depth is not 0
-  if (st->is_directory &&
-      !mg_strcasecmp(conn->ctx->config[ENABLE_DIRECTORY_LISTING], "yes") &&
-      (depth == NULL || strcmp(depth, "0") != 0)) {
-    scan_directory(conn, path, conn, &print_dav_dir_entry);
-  }
-
-  conn->num_bytes_sent += mg_printf(conn, "%s\n", "</d:multistatus>");
-}
-
-#if defined(USE_WEBSOCKET)
-
-// START OF SHA-1 code
-// Copyright(c) By Steve Reid <steve@edmweb.com>
-#define SHA1HANDSOFF
-#if defined(__sun)
-#include "solarisfixes.h"
-#endif
-#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
-#if BYTE_ORDER == LITTLE_ENDIAN
-#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
-    |(rol(block->l[i],8)&0x00FF00FF))
-#elif BYTE_ORDER == BIG_ENDIAN
-#define blk0(i) block->l[i]
-#else
-#error "Endianness not defined!"
-#endif
-#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
-    ^block->l[(i+2)&15]^block->l[i&15],1))
-#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
-#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
-#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
-#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
-#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
-
-typedef struct {
-    uint32_t state[5];
-    uint32_t count[2];
-    unsigned char buffer[64];
-} SHA1_CTX;
-
-static void SHA1Transform(uint32_t state[5], const unsigned char buffer[64]) {
-  uint32_t a, b, c, d, e;
-  typedef union { unsigned char c[64]; uint32_t l[16]; } CHAR64LONG16;
-
-  CHAR64LONG16 block[1];
-  memcpy(block, buffer, 64);
-  a = state[0];
-  b = state[1];
-  c = state[2];
-  d = state[3];
-  e = state[4];
-  R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
-  R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
-  R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
-  R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
-  R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
-  R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
-  R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
-  R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
-  R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
-  R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
-  R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
-  R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
-  R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
-  R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
-  R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
-  R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
-  R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
-  R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
-  R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
-  R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
-  state[0] += a;
-  state[1] += b;
-  state[2] += c;
-  state[3] += d;
-  state[4] += e;
-  a = b = c = d = e = 0;
-  memset(block, '\0', sizeof(block));
-}
-
-static void SHA1Init(SHA1_CTX* context) {
-  context->state[0] = 0x67452301;
-  context->state[1] = 0xEFCDAB89;
-  context->state[2] = 0x98BADCFE;
-  context->state[3] = 0x10325476;
-  context->state[4] = 0xC3D2E1F0;
-  context->count[0] = context->count[1] = 0;
-}
-
-static void SHA1Update(SHA1_CTX* context, const unsigned char* data,
-                       uint32_t len) {
-  uint32_t i, j;
-
-  j = context->count[0];
-  if ((context->count[0] += len << 3) < j)
-    context->count[1]++;
-  context->count[1] += (len>>29);
-  j = (j >> 3) & 63;
-  if ((j + len) > 63) {
-    memcpy(&context->buffer[j], data, (i = 64-j));
-    SHA1Transform(context->state, context->buffer);
-    for ( ; i + 63 < len; i += 64) {
-      SHA1Transform(context->state, &data[i]);
-    }
-    j = 0;
-  }
-  else i = 0;
-  memcpy(&context->buffer[j], &data[i], len - i);
-}
-
-static void SHA1Final(unsigned char digest[20], SHA1_CTX* context) {
-  unsigned i;
-  unsigned char finalcount[8], c;
-
-  for (i = 0; i < 8; i++) {
-    finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
-                                     >> ((3-(i & 3)) * 8) ) & 255);
-  }
-  c = 0200;
-  SHA1Update(context, &c, 1);
-  while ((context->count[0] & 504) != 448) {
-    c = 0000;
-    SHA1Update(context, &c, 1);
-  }
-  SHA1Update(context, finalcount, 8);
-  for (i = 0; i < 20; i++) {
-    digest[i] = (unsigned char)
-      ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
-  }
-  memset(context, '\0', sizeof(*context));
-  memset(&finalcount, '\0', sizeof(finalcount));
-}
-// END OF SHA1 CODE
-
-static void base64_encode(const unsigned char *src, int src_len, char *dst) {
-  static const char *b64 =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-  int i, j, a, b, c;
-
-  for (i = j = 0; i < src_len; i += 3) {
-    a = src[i];
-    b = i + 1 >= src_len ? 0 : src[i + 1];
-    c = i + 2 >= src_len ? 0 : src[i + 2];
-
-    dst[j++] = b64[a >> 2];
-    dst[j++] = b64[((a & 3) << 4) | (b >> 4)];
-    if (i + 1 < src_len) {
-      dst[j++] = b64[(b & 15) << 2 | (c >> 6)];
-    }
-    if (i + 2 < src_len) {
-      dst[j++] = b64[c & 63];
-    }
-  }
-  while (j % 4 != 0) {
-    dst[j++] = '=';
-  }
-  dst[j++] = '\0';
-}
-
-static void send_websocket_handshake(struct mg_connection *conn) {
-  static const char *magic = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
-  char buf[100], sha[20], b64_sha[sizeof(sha) * 2];
-  SHA1_CTX sha_ctx;
-
-  mg_snprintf(conn, buf, sizeof(buf), "%s%s",
-              mg_get_header(conn, "Sec-WebSocket-Key"), magic);
-  SHA1Init(&sha_ctx);
-  SHA1Update(&sha_ctx, (unsigned char *) buf, strlen(buf));
-  SHA1Final((unsigned char *) sha, &sha_ctx);
-  base64_encode((unsigned char *) sha, sizeof(sha), b64_sha);
-  mg_printf(conn, "%s%s%s",
-            "HTTP/1.1 101 Switching Protocols\r\n"
-            "Upgrade: websocket\r\n"
-            "Connection: Upgrade\r\n"
-            "Sec-WebSocket-Accept: ", b64_sha, "\r\n\r\n");
-}
-
-static void read_websocket(struct mg_connection *conn) {
-  unsigned char *mask, *buf = (unsigned char *) conn->buf + conn->request_len;
-  int n, len, mask_len, body_len, discard_len;
-
-  for (;;) {
-    if ((body_len = conn->data_len - conn->request_len) >= 2) {
-      len = buf[1] & 127;
-      mask_len = buf[1] & 128 ? 4 : 0;
-      if (len < 126) {
-        conn->content_len = 2 + mask_len + len;
-        mask = buf + 2;
-      } else if (len == 126 && body_len >= 4) {
-        conn->content_len = 2 + mask_len + ((((int) buf[2]) << 8) + buf[3]);
-        mask = buf + 4;
-      } else if (body_len >= 10) {
-        conn->content_len = 2 + mask_len +
-          ((uint64_t) htonl(* (uint32_t *) &buf[2])) << 32 |
-          htonl(* (uint32_t *) &buf[6]);
-        mask = buf + 10;
-      }
-    }
-
-    if (conn->content_len > 0) {
-      if (call_user(conn, MG_WEBSOCKET_MESSAGE) != NULL) {
-        break;  // Callback signalled to exit
-      }
-      discard_len = conn->content_len > body_len ? body_len : conn->content_len;
-      memmove(buf, buf + discard_len, conn->data_len - discard_len);
-      conn->data_len -= discard_len;
-      conn->content_len = conn->consumed_content = 0;
-    } else {
-      if (wait_until_socket_is_readable(conn) == 0) {
-        break;
-      }
-      n = pull(NULL, conn, conn->buf + conn->data_len,
-               conn->buf_size - conn->data_len);
-      if (n <= 0) {
-        break;
-      }
-      conn->data_len += n;
-    }
-  }
-}
-
-static void handle_websocket_request(struct mg_connection *conn) {
-  if (strcmp(mg_get_header(conn, "Sec-WebSocket-Version"), "13") != 0) {
-    send_http_error(conn, 426, "Upgrade Required", "%s", "Upgrade Required");
-  } else if (call_user(conn, MG_WEBSOCKET_CONNECT) != NULL) {
-    // Callback has returned non-NULL, do not proceed with handshake
-  } else {
-    send_websocket_handshake(conn);
-    call_user(conn, MG_WEBSOCKET_READY);
-    read_websocket(conn);
-    call_user(conn, MG_WEBSOCKET_CLOSE);
-  }
-}
-
-static int is_websocket_request(const struct mg_connection *conn) {
-  const char *host, *upgrade, *connection, *version, *key;
-
-  host = mg_get_header(conn, "Host");
-  upgrade = mg_get_header(conn, "Upgrade");
-  connection = mg_get_header(conn, "Connection");
-  key = mg_get_header(conn, "Sec-WebSocket-Key");
-  version = mg_get_header(conn, "Sec-WebSocket-Version");
-
-  return host != NULL && upgrade != NULL && connection != NULL &&
-    key != NULL && version != NULL &&
-    !mg_strcasecmp(upgrade, "websocket") &&
-    !mg_strcasecmp(connection, "Upgrade");
-}
-#endif // !USE_WEBSOCKET
-
-static int isbyte(int n) {
-  return n >= 0 && n <= 255;
-}
-
-static int parse_net(const char *spec, uint32_t *net, uint32_t *mask) {
-  int n, a, b, c, d, slash = 32, len = 0;
-
-  if ((sscanf(spec, "%d.%d.%d.%d/%d%n", &a, &b, &c, &d, &slash, &n) == 5 ||
-      sscanf(spec, "%d.%d.%d.%d%n", &a, &b, &c, &d, &n) == 4) &&
-      isbyte(a) && isbyte(b) && isbyte(c) && isbyte(d) &&
-      slash >= 0 && slash < 33) {
-    len = n;
-    *net = ((uint32_t)a << 24) | ((uint32_t)b << 16) | ((uint32_t)c << 8) | d;
-    *mask = slash ? 0xffffffffU << (32 - slash) : 0;
-  }
-
-  return len;
-}
-
-static int set_throttle(const char *spec, uint32_t remote_ip, const char *uri) {
-  int throttle = 0;
-  struct vec vec, val;
-  uint32_t net, mask;
-  char mult;
-  double v;
-
-  while ((spec = next_option(spec, &vec, &val)) != NULL) {
-    mult = ',';
-    if (sscanf(val.ptr, "%lf%c", &v, &mult) < 1 || v < 0 ||
-        (lowercase(&mult) != 'k' && lowercase(&mult) != 'm' && mult != ',')) {
-      continue;
-    }
-    v *= lowercase(&mult) == 'k' ? 1024 : lowercase(&mult) == 'm' ? 1048576 : 1;
-    if (vec.len == 1 && vec.ptr[0] == '*') {
-      throttle = (int) v;
-    } else if (parse_net(vec.ptr, &net, &mask) > 0) {
-      if ((remote_ip & mask) == net) {
-        throttle = (int) v;
-      }
-    } else if (match_prefix(vec.ptr, vec.len, uri) > 0) {
-      throttle = (int) v;
-    }
-  }
-
-  return throttle;
-}
-
-static uint32_t get_remote_ip(const struct mg_connection *conn) {
-  return ntohl(* (uint32_t *) &conn->client.rsa.sin.sin_addr);
-}
-
-// This is the heart of the Mongoose's logic.
-// This function is called when the request is read, parsed and validated,
-// and Mongoose must decide what action to take: serve a file, or
-// a directory, or call embedded function, etcetera.
-static void handle_request(struct mg_connection *conn) {
-  struct mg_request_info *ri = &conn->request_info;
-  char path[PATH_MAX];
-  int stat_result, uri_len;
-  struct mgstat st;
-
-  if ((conn->request_info.query_string = strchr(ri->uri, '?')) != NULL) {
-    *conn->request_info.query_string++ = '\0';
-  }
-  uri_len = (int) strlen(ri->uri);
-  url_decode(ri->uri, (size_t)uri_len, ri->uri, (size_t)(uri_len + 1), 0);
-  remove_double_dots_and_double_slashes(ri->uri);
-  stat_result = convert_uri_to_file_name(conn, path, sizeof(path), &st);
-  conn->throttle = set_throttle(conn->ctx->config[THROTTLE],
-                                get_remote_ip(conn), ri->uri);
-
-  DEBUG_TRACE(("%s", ri->uri));
-  if (!check_authorization(conn, path)) {
-    send_authorization_request(conn);
-#if defined(USE_WEBSOCKET)
-  } else if (is_websocket_request(conn)) {
-    handle_websocket_request(conn);
-#endif
-  } else if (call_user(conn, MG_NEW_REQUEST) != NULL) {
-    // Do nothing, callback has served the request
-  } else if (!strcmp(ri->request_method, "OPTIONS")) {
-    send_options(conn);
-  } else if (conn->ctx->config[DOCUMENT_ROOT] == NULL) {
-    send_http_error(conn, 404, "Not Found", "Not Found");
-  } else if ((!strcmp(ri->request_method, "PUT") ||
-        !strcmp(ri->request_method, "DELETE")) &&
-      (conn->ctx->config[PUT_DELETE_PASSWORDS_FILE] == NULL ||
-       is_authorized_for_put(conn) != 1)) {
-    send_authorization_request(conn);
-  } else if (!strcmp(ri->request_method, "PUT")) {
-    put_file(conn, path);
-  } else if (!strcmp(ri->request_method, "DELETE")) {
-    if (mg_remove(path) == 0) {
-      send_http_error(conn, 200, "OK", "%s", "");
-    } else {
-      send_http_error(conn, 500, http_500_error, "remove(%s): %s", path,
-                      strerror(ERRNO));
-    }
-  } else if (stat_result != 0 || must_hide_file(conn, path)) {
-    send_http_error(conn, 404, "Not Found", "%s", "File not found");
-  } else if (st.is_directory && ri->uri[uri_len - 1] != '/') {
-    (void) mg_printf(conn, "HTTP/1.1 301 Moved Permanently\r\n"
-                     "Location: %s/\r\n\r\n", ri->uri);
-  } else if (!strcmp(ri->request_method, "PROPFIND")) {
-    handle_propfind(conn, path, &st);
-  } else if (st.is_directory &&
-             !substitute_index_file(conn, path, sizeof(path), &st)) {
-    if (!mg_strcasecmp(conn->ctx->config[ENABLE_DIRECTORY_LISTING], "yes")) {
-      handle_directory_request(conn, path);
-    } else {
-      send_http_error(conn, 403, "Directory Listing Denied",
-          "Directory listing denied");
-    }
-#if !defined(NO_CGI)
-  } else if (match_prefix(conn->ctx->config[CGI_EXTENSIONS],
-                          strlen(conn->ctx->config[CGI_EXTENSIONS]),
-                          path) > 0) {
-    if (strcmp(ri->request_method, "POST") &&
-        strcmp(ri->request_method, "GET")) {
-      send_http_error(conn, 501, "Not Implemented",
-                      "Method %s is not implemented", ri->request_method);
-    } else {
-      handle_cgi_request(conn, path);
-    }
-#endif // !NO_CGI
-  } else if (match_prefix(conn->ctx->config[SSI_EXTENSIONS],
-                          strlen(conn->ctx->config[SSI_EXTENSIONS]),
-                          path) > 0) {
-    handle_ssi_file_request(conn, path);
-  } else if (is_not_modified(conn, &st)) {
-    send_http_error(conn, 304, "Not Modified", "%s", "");
-  } else {
-    handle_file_request(conn, path, &st);
-  }
-}
-
-static void close_all_listening_sockets(struct mg_context *ctx) {
-  struct socket *sp, *tmp;
-  for (sp = ctx->listening_sockets; sp != NULL; sp = tmp) {
-    tmp = sp->next;
-    (void) closesocket(sp->sock);
-    free(sp);
-  }
-}
-
-// Valid listening port specification is: [ip_address:]port[s]
-// Examples: 80, 443s, 127.0.0.1:3128, 1.2.3.4:8080s
-// TODO(lsm): add parsing of the IPv6 address
-static int parse_port_string(const struct vec *vec, struct socket *so) {
-  int a, b, c, d, port, len;
-
-  // MacOS needs that. If we do not zero it, subsequent bind() will fail.
-  // Also, all-zeroes in the socket address means binding to all addresses
-  // for both IPv4 and IPv6 (INADDR_ANY and IN6ADDR_ANY_INIT).
-  memset(so, 0, sizeof(*so));
-
-  if (sscanf(vec->ptr, "%d.%d.%d.%d:%d%n", &a, &b, &c, &d, &port, &len) == 5) {
-    // Bind to a specific IPv4 address
-    so->lsa.sin.sin_addr.s_addr = htonl((a << 24) | (b << 16) | (c << 8) | d);
-  } else if (sscanf(vec->ptr, "%d%n", &port, &len) != 1 ||
-             len <= 0 ||
-             len > (int) vec->len ||
-             (vec->ptr[len] && vec->ptr[len] != 's' && vec->ptr[len] != ',')) {
-    return 0;
-  }
-
-  so->is_ssl = vec->ptr[len] == 's';
-#if defined(USE_IPV6)
-  so->lsa.sin6.sin6_family = AF_INET6;
-  so->lsa.sin6.sin6_port = htons((uint16_t) port);
-#else
-  so->lsa.sin.sin_family = AF_INET;
-  so->lsa.sin.sin_port = htons((uint16_t) port);
-#endif
-
-  return 1;
-}
-
-static int set_ports_option(struct mg_context *ctx) {
-  const char *list = ctx->config[LISTENING_PORTS];
-  int on = 1, success = 1;
-  SOCKET sock;
-  struct vec vec;
-  struct socket so, *listener;
-
-  while (success && (list = next_option(list, &vec, NULL)) != NULL) {
-    if (!parse_port_string(&vec, &so)) {
-      cry(fc(ctx), "%s: %.*s: invalid port spec. Expecting list of: %s",
-          __func__, (int) vec.len, vec.ptr, "[IP_ADDRESS:]PORT[s|p]");
-      success = 0;
-    } else if (so.is_ssl &&
-               (ctx->ssl_ctx == NULL || ctx->config[SSL_CERTIFICATE] == NULL)) {
-      cry(fc(ctx), "Cannot add SSL socket, is -ssl_certificate option set?");
-      success = 0;
-    } else if ((sock = socket(so.lsa.sa.sa_family, SOCK_STREAM, 6)) ==
-               INVALID_SOCKET ||
-               // On Windows, SO_REUSEADDR is recommended only for
-               // broadcast UDP sockets
-               setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const char *) &on,
-                          sizeof(on)) != 0 ||
-               // Set TCP keep-alive. This is needed because if HTTP-level
-               // keep-alive is enabled, and client resets the connection,
-               // server won't get TCP FIN or RST and will keep the connection
-               // open forever. With TCP keep-alive, next keep-alive
-               // handshake will figure out that the client is down and
-               // will close the server end.
-               // Thanks to Igor Klopov who suggested the patch.
-               setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (char *) &on,
-                          sizeof(on)) != 0 ||
-               bind(sock, &so.lsa.sa, sizeof(so.lsa)) != 0 ||
-               listen(sock, SOMAXCONN) != 0) {
-      closesocket(sock);
-      cry(fc(ctx), "%s: cannot bind to %.*s: %s", __func__,
-          (int) vec.len, vec.ptr, strerror(ERRNO));
-      success = 0;
-    } else if ((listener = (struct socket *)
-                calloc(1, sizeof(*listener))) == NULL) {
-      // NOTE(lsm): order is important: call cry before closesocket(),
-      // cause closesocket() alters the errno.
-      cry(fc(ctx), "%s: %s", __func__, strerror(ERRNO));
-      closesocket(sock);
-      success = 0;
-    } else {
-      *listener = so;
-      listener->sock = sock;
-      set_close_on_exec(listener->sock);
-      listener->next = ctx->listening_sockets;
-      ctx->listening_sockets = listener;
-    }
-  }
-
-  if (!success) {
-    close_all_listening_sockets(ctx);
-  }
-
-  return success;
-}
-
-static void log_header(const struct mg_connection *conn, const char *header,
-                       FILE *fp) {
-  const char *header_value;
-
-  if ((header_value = mg_get_header(conn, header)) == NULL) {
-    (void) fprintf(fp, "%s", " -");
-  } else {
-    (void) fprintf(fp, " \"%s\"", header_value);
-  }
-}
-
-static void log_access(const struct mg_connection *conn) {
-  const struct mg_request_info *ri;
-  FILE *fp;
-  char date[64], src_addr[20];
-
-  fp = conn->ctx->config[ACCESS_LOG_FILE] == NULL ?  NULL :
-    mg_fopen(conn->ctx->config[ACCESS_LOG_FILE], "a+");
-
-  if (fp == NULL)
-    return;
-
-  strftime(date, sizeof(date), "%d/%b/%Y:%H:%M:%S %z",
-           localtime(&conn->birth_time));
-
-  ri = &conn->request_info;
-  flockfile(fp);
-
-  sockaddr_to_string(src_addr, sizeof(src_addr), &conn->client.rsa);
-  fprintf(fp, "%s - %s [%s] \"%s %s HTTP/%s\" %d %" INT64_FMT,
-          src_addr, ri->remote_user == NULL ? "-" : ri->remote_user, date,
-          ri->request_method ? ri->request_method : "-",
-          ri->uri ? ri->uri : "-", ri->http_version,
-          conn->status_code, conn->num_bytes_sent);
-  log_header(conn, "Referer", fp);
-  log_header(conn, "User-Agent", fp);
-  fputc('\n', fp);
-  fflush(fp);
-
-  funlockfile(fp);
-  fclose(fp);
-}
-
-// Verify given socket address against the ACL.
-// Return -1 if ACL is malformed, 0 if address is disallowed, 1 if allowed.
-static int check_acl(struct mg_context *ctx, uint32_t remote_ip) {
-  int allowed, flag;
-  uint32_t net, mask;
-  struct vec vec;
-  const char *list = ctx->config[ACCESS_CONTROL_LIST];
-
-  // If any ACL is set, deny by default
-  allowed = list == NULL ? '+' : '-';
-
-  while ((list = next_option(list, &vec, NULL)) != NULL) {
-    flag = vec.ptr[0];
-    if ((flag != '+' && flag != '-') ||
-        parse_net(&vec.ptr[1], &net, &mask) == 0) {
-      cry(fc(ctx), "%s: subnet must be [+|-]x.x.x.x[/x]", __func__);
-      return -1;
-    }
-
-    if (net == (remote_ip & mask)) {
-      allowed = flag;
-    }
-  }
-
-  return allowed == '+';
-}
-
-static void add_to_set(SOCKET fd, fd_set *set, int *max_fd) {
-  FD_SET(fd, set);
-  if (fd > (SOCKET) *max_fd) {
-    *max_fd = (int) fd;
-  }
-}
-
-#if !defined(_WIN32)
-static int set_uid_option(struct mg_context *ctx) {
-  struct passwd *pw;
-  const char *uid = ctx->config[RUN_AS_USER];
-  int success = 0;
-
-  if (uid == NULL) {
-    success = 1;
-  } else {
-    if ((pw = getpwnam(uid)) == NULL) {
-      cry(fc(ctx), "%s: unknown user [%s]", __func__, uid);
-    } else if (setgid(pw->pw_gid) == -1) {
-      cry(fc(ctx), "%s: setgid(%s): %s", __func__, uid, strerror(errno));
-    } else if (setuid(pw->pw_uid) == -1) {
-      cry(fc(ctx), "%s: setuid(%s): %s", __func__, uid, strerror(errno));
-    } else {
-      success = 1;
-    }
-  }
-
-  return success;
-}
-#endif // !_WIN32
-
-#if !defined(NO_SSL)
-static pthread_mutex_t *ssl_mutexes;
-
-// Return OpenSSL error message
-static const char *ssl_error(void) {
-  unsigned long err;
-  err = ERR_get_error();
-  return err == 0 ? "" : ERR_error_string(err, NULL);
-}
-
-static void ssl_locking_callback(int mode, int mutex_num, const char *file,
-                                 int line) {
-  line = 0;    // Unused
-  file = NULL; // Unused
-
-  if (mode & CRYPTO_LOCK) {
-    (void) pthread_mutex_lock(&ssl_mutexes[mutex_num]);
-  } else {
-    (void) pthread_mutex_unlock(&ssl_mutexes[mutex_num]);
-  }
-}
-
-static unsigned long ssl_id_callback(void) {
-  return (unsigned long) pthread_self();
-}
-
-#if !defined(NO_SSL_DL)
-static int load_dll(struct mg_context *ctx, const char *dll_name,
-                    struct ssl_func *sw) {
-  union {void *p; void (*fp)(void);} u;
-  void  *dll_handle;
-  struct ssl_func *fp;
-
-  if ((dll_handle = dlopen(dll_name, RTLD_LAZY)) == NULL) {
-    cry(fc(ctx), "%s: cannot load %s", __func__, dll_name);
-    return 0;
-  }
-
-  for (fp = sw; fp->name != NULL; fp++) {
-#ifdef _WIN32
-    // GetProcAddress() returns pointer to function
-    u.fp = (void (*)(void)) dlsym(dll_handle, fp->name);
-#else
-    // dlsym() on UNIX returns void *. ISO C forbids casts of data pointers to
-    // function pointers. We need to use a union to make a cast.
-    u.p = dlsym(dll_handle, fp->name);
-#endif // _WIN32
-    if (u.fp == NULL) {
-      cry(fc(ctx), "%s: %s: cannot find %s", __func__, dll_name, fp->name);
-      return 0;
-    } else {
-      fp->ptr = u.fp;
-    }
-  }
-
-  return 1;
-}
-#endif // NO_SSL_DL
-
-// Dynamically load SSL library. Set up ctx->ssl_ctx pointer.
-static int set_ssl_option(struct mg_context *ctx) {
-  int i, size;
-  const char *pem;
-  
-  // If PEM file is not specified, skip SSL initialization.
-  if ((pem = ctx->config[SSL_CERTIFICATE]) == NULL) {
-    return 1;
-  }
-
-#if !defined(NO_SSL_DL)
-  if (!load_dll(ctx, SSL_LIB, ssl_sw) ||
-      !load_dll(ctx, CRYPTO_LIB, crypto_sw)) {
-    return 0;
-  }
-#endif // NO_SSL_DL
-
-  // Initialize SSL crap
-  SSL_library_init();
-  SSL_load_error_strings();
-
-  if ((ctx->client_ssl_ctx = SSL_CTX_new(SSLv23_client_method())) == NULL) {
-    cry(fc(ctx), "SSL_CTX_new (client) error: %s", ssl_error());
-  }
-
-  if ((ctx->ssl_ctx = SSL_CTX_new(SSLv23_server_method())) == NULL) {
-    cry(fc(ctx), "SSL_CTX_new (server) error: %s", ssl_error());
-    return 0;
-  }
-  
-  // If user callback returned non-NULL, that means that user callback has
-  // set up certificate itself. In this case, skip sertificate setting.
-  if (call_user(fc(ctx), MG_INIT_SSL) == NULL &&
-      (SSL_CTX_use_certificate_file(ctx->ssl_ctx, pem, SSL_FILETYPE_PEM) == 0 ||
-       SSL_CTX_use_PrivateKey_file(ctx->ssl_ctx, pem, SSL_FILETYPE_PEM) == 0)) {
-    cry(fc(ctx), "%s: cannot open %s: %s", __func__, pem, ssl_error());
-    return 0;
-  }
-
-  if (pem != NULL) {
-    (void) SSL_CTX_use_certificate_chain_file(ctx->ssl_ctx, pem);
-  }
-
-  // Initialize locking callbacks, needed for thread safety.
-  // http://www.openssl.org/support/faq.html#PROG1
-  size = sizeof(pthread_mutex_t) * CRYPTO_num_locks();
-  if ((ssl_mutexes = (pthread_mutex_t *) malloc((size_t)size)) == NULL) {
-    cry(fc(ctx), "%s: cannot allocate mutexes: %s", __func__, ssl_error());
-    return 0;
-  }
-
-  for (i = 0; i < CRYPTO_num_locks(); i++) {
-    pthread_mutex_init(&ssl_mutexes[i], NULL);
-  }
-
-  CRYPTO_set_locking_callback(&ssl_locking_callback);
-  CRYPTO_set_id_callback(&ssl_id_callback);
-
-  return 1;
-}
-
-static void uninitialize_ssl(struct mg_context *ctx) {
-  int i;
-  if (ctx->ssl_ctx != NULL) {
-    CRYPTO_set_locking_callback(NULL);
-    for (i = 0; i < CRYPTO_num_locks(); i++) {
-      pthread_mutex_destroy(&ssl_mutexes[i]);
-    }
-    CRYPTO_set_locking_callback(NULL);
-    CRYPTO_set_id_callback(NULL);
-  }
-}
-#endif // !NO_SSL
-
-static int set_gpass_option(struct mg_context *ctx) {
-  struct mgstat mgstat;
-  const char *path = ctx->config[GLOBAL_PASSWORDS_FILE];
-  return path == NULL || mg_stat(path, &mgstat) == 0;
-}
-
-static int set_acl_option(struct mg_context *ctx) {
-  return check_acl(ctx, (uint32_t) 0x7f000001UL) != -1;
-}
-
-static void reset_per_request_attributes(struct mg_connection *conn) {
-  conn->path_info = conn->log_message = NULL;
-  conn->num_bytes_sent = conn->consumed_content = 0;
-  conn->status_code = -1;
-  conn->must_close = conn->request_len = conn->throttle = 0;
-}
-
-static void close_socket_gracefully(struct mg_connection *conn) {
-  struct linger linger;
-  int sock = conn->client.sock;
-
-  // Set linger option to avoid socket hanging out after close. This prevent
-  // ephemeral port exhaust problem under high QPS.
-  linger.l_onoff = 1;
-  linger.l_linger = 1;
-  setsockopt(sock, SOL_SOCKET, SO_LINGER, (char *) &linger, sizeof(linger));
-
-  // Send FIN to the client
-  (void) shutdown(sock, SHUT_WR);
-// mongoose bug in Linux
-// only used in windows 
-#if defined(_WIN32)
-  char buf[MG_BUF_LEN];
-  int n = 0;
-  set_non_blocking_mode(sock);
-
-  // Read and discard pending incoming data. If we do not do that and close the
-  // socket, the data in the send buffer may be discarded. This
-  // behaviour is seen on Windows, when client keeps sending data
-  // when server decides to close the connection; then when client
-  // does recv() it gets no data back.
-  do {
-    n = pull(NULL, conn, buf, sizeof(buf));
-  } while (n > 0);
-#endif
-  // Now we know that our FIN is ACK-ed, safe to close
-  (void) closesocket(sock);
-}
-
-static void close_connection(struct mg_connection *conn) {
-  if (conn->ssl) {
-    SSL_free(conn->ssl);
-    conn->ssl = NULL;
-  }
-
-  if (conn->client.sock != INVALID_SOCKET) {
-    close_socket_gracefully(conn);
-  }
-
-  if (conn->ep_fd >= 0) {
-      close(conn->ep_fd);
-      conn->ep_fd = -1;
-  }
-}
-
-void mg_close_connection(struct mg_connection *conn) {
-  close_connection(conn);
-  free(conn);
-}
-
-struct mg_connection *mg_connect(struct mg_context *ctx,
-                                 const char *host, int port, int use_ssl) {
-  struct mg_connection *newconn = NULL;
-  struct sockaddr_in sin;
-  struct hostent *he;
-  int sock;
-
-  if (use_ssl && (ctx == NULL || ctx->client_ssl_ctx == NULL)) {
-    cry(fc(ctx), "%s: SSL is not initialized", __func__);
-  } else if ((he = gethostbyname(host)) == NULL) {
-    cry(fc(ctx), "%s: gethostbyname(%s): %s", __func__, host, strerror(ERRNO));
-  } else if ((sock = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) {
-    cry(fc(ctx), "%s: socket: %s", __func__, strerror(ERRNO));
-  } else {
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons((uint16_t) port);
-    sin.sin_addr = * (struct in_addr *) he->h_addr_list[0];
-    if (connect(sock, (struct sockaddr *) &sin, sizeof(sin)) != 0) {
-      cry(fc(ctx), "%s: connect(%s:%d): %s", __func__, host, port,
-          strerror(ERRNO));
-      closesocket(sock);
-    } else if ((newconn = (struct mg_connection *)
-                calloc(1, sizeof(*newconn))) == NULL) {
-      cry(fc(ctx), "%s: calloc: %s", __func__, strerror(ERRNO));
-      closesocket(sock);
-    } else {
-      newconn->ctx = ctx;
-      newconn->client.sock = sock;
-      newconn->client.rsa.sin = sin;
-      newconn->client.is_ssl = use_ssl;
-      if (use_ssl) {
-        sslize(newconn, ctx->client_ssl_ctx, SSL_connect);
-      }
-    }
-  }
-
-  return newconn;
-}
-
-FILE *mg_fetch(struct mg_context *ctx, const char *url, const char *path,
-               char *buf, size_t buf_len, struct mg_request_info *ri) {
-  struct mg_connection *newconn;
-  int n, req_length, data_length, port;
-  char host[1025], proto[10], buf2[MG_BUF_LEN];
-  FILE *fp = NULL;
-
-  if (sscanf(url, "%9[htps]://%1024[^:]:%d/%n", proto, host, &port, &n) == 3) {
-  } else if (sscanf(url, "%9[htps]://%1024[^/]/%n", proto, host, &n) == 2) {
-    port = mg_strcasecmp(proto, "https") == 0 ? 443 : 80;
-  } else {
-    cry(fc(ctx), "%s: invalid URL: [%s]", __func__, url);
-    return NULL;
-  }
-
-  if ((newconn = mg_connect(ctx, host, port,
-                            !strcmp(proto, "https"))) == NULL) {
-    cry(fc(ctx), "%s: mg_connect(%s): %s", __func__, url, strerror(ERRNO));
-  } else {
-    mg_printf(newconn, "GET /%s HTTP/1.0\r\nHost: %s\r\n\r\n", url + n, host);
-    data_length = 0;
-    req_length = read_request(NULL, newconn, buf, buf_len, &data_length);
-    if (req_length <= 0) {
-      cry(fc(ctx), "%s(%s): invalid HTTP reply", __func__, url);
-    } else if (parse_http_response(buf, req_length, ri) <= 0) {
-      cry(fc(ctx), "%s(%s): cannot parse HTTP headers", __func__, url);
-    } else if ((fp = fopen(path, "w+b")) == NULL) {
-      cry(fc(ctx), "%s: fopen(%s): %s", __func__, path, strerror(ERRNO));
-    } else {
-      // Write chunk of data that may be in the user's buffer
-      data_length -= req_length;
-      if (data_length > 0 &&
-        fwrite(buf + req_length, 1, data_length, fp) != (size_t) data_length) {
-        cry(fc(ctx), "%s: fwrite(%s): %s", __func__, path, strerror(ERRNO));
-        fclose(fp);
-        fp = NULL;
-      }
-      // Read the rest of the response and write it to the file. Do not use
-      // mg_read() cause we didn't set newconn->content_len properly.
-      while (fp && (data_length = pull(0, newconn, buf2, sizeof(buf2))) > 0) {
-        if (fwrite(buf2, 1, data_length, fp) != (size_t) data_length) {
-          cry(fc(ctx), "%s: fwrite(%s): %s", __func__, path, strerror(ERRNO));
-          fclose(fp);
-          fp = NULL;
-          break;
-        }
-      }
-    }
-    mg_close_connection(newconn);
-  }
-
-  return fp;
-}
-
-static int is_valid_uri(const char *uri) {
-  // Conform to http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html#sec5.1.2
-  // URI can be an asterisk (*) or should start with slash.
-  return uri[0] == '/' || (uri[0] == '*' && uri[1] == '\0');
-}
-
-static void process_new_connection(struct mg_connection *conn) {
-  struct mg_request_info *ri = &conn->request_info;
-  int keep_alive_enabled, discard_len;
-  const char *cl;
-
-  keep_alive_enabled = !strcmp(conn->ctx->config[ENABLE_KEEP_ALIVE], "yes");
-
-  do {
-    reset_per_request_attributes(conn);
-    conn->request_len = read_request(NULL, conn, conn->buf, conn->buf_size,
-                                     &conn->data_len);
-    assert(conn->request_len < 0 || conn->data_len >= conn->request_len);
-    if (conn->request_len == 0 && conn->data_len == conn->buf_size) {
-      send_http_error(conn, 413, "Request Too Large", "%s", "");
-      return;
-    } if (conn->request_len <= 0) {
-      return;  // Remote end closed the connection
-    }
-    if (parse_http_request(conn->buf, conn->buf_size, ri) <= 0 ||
-        !is_valid_uri(ri->uri)) {
-      // Do not put garbage in the access log, just send it back to the client
-      send_http_error(conn, 400, "Bad Request",
-          "Cannot parse HTTP request: [%.*s]", conn->data_len, conn->buf);
-      conn->must_close = 1;
-    } else if (strcmp(ri->http_version, "1.0") &&
-               strcmp(ri->http_version, "1.1")) {
-      // Request seems valid, but HTTP version is strange
-      send_http_error(conn, 505, "HTTP version not supported", "%s", "");
-      log_access(conn);
-    } else {
-      // Request is valid, handle it
-      if ((cl = get_header(ri, "Content-Length")) != NULL) {
-        conn->content_len = strtoll(cl, NULL, 10);
-      } else if (!mg_strcasecmp(ri->request_method, "POST") ||
-                 !mg_strcasecmp(ri->request_method, "PUT")) {
-        // Add by zc, make it max
-        conn->content_len = INT64_MAX;
-      } else {
-        conn->content_len = 0;
-      }
-      conn->birth_time = time(NULL);
-      handle_request(conn);
-      call_user(conn, MG_REQUEST_COMPLETE);
-      log_access(conn);
-    }
-    if (ri->remote_user != NULL) {
-      free((void *) ri->remote_user);
-    }
-
-    // Discard all buffered data for this request
-    discard_len = conn->content_len >= 0 &&
-      conn->request_len + conn->content_len < (int64_t) conn->data_len ?
-      (int) (conn->request_len + conn->content_len) : conn->data_len;
-    memmove(conn->buf, conn->buf + discard_len, conn->data_len - discard_len);
-    conn->data_len -= discard_len;
-    assert(conn->data_len >= 0);
-    assert(conn->data_len <= conn->buf_size);
-
-  } while (conn->ctx->stop_flag == 0 &&
-           keep_alive_enabled &&
-           conn->content_len >= 0 &&
-           should_keep_alive(conn));
-}
-
-// Worker threads take accepted socket from the queue
-static int consume_socket(struct mg_context *ctx, struct socket *sp) {
-  (void) pthread_mutex_lock(&ctx->mutex);
-  DEBUG_TRACE(("going idle"));
-
-  // If the queue is empty, wait. We're idle at this point.
-  while (ctx->sq_head == ctx->sq_tail && ctx->stop_flag == 0) {
-    pthread_cond_wait(&ctx->sq_full, &ctx->mutex);
-  }
-
-  // If we're stopping, sq_head may be equal to sq_tail.
-  if (ctx->sq_head > ctx->sq_tail) {
-    // Copy socket from the queue and increment tail
-    *sp = ctx->queue[ctx->sq_tail % ARRAY_SIZE(ctx->queue)];
-    ctx->sq_tail++;
-    DEBUG_TRACE(("grabbed socket %d, going busy", sp->sock));
-
-    // Wrap pointers if needed
-    while (ctx->sq_tail > (int) ARRAY_SIZE(ctx->queue)) {
-      ctx->sq_tail -= ARRAY_SIZE(ctx->queue);
-      ctx->sq_head -= ARRAY_SIZE(ctx->queue);
-    }
-  }
-
-  (void) pthread_cond_signal(&ctx->sq_empty);
-  (void) pthread_mutex_unlock(&ctx->mutex);
-
-  return !ctx->stop_flag;
-}
-
-static void worker_thread(struct mg_context *ctx) {
-  struct mg_connection *conn;
-
-  conn = (struct mg_connection *) calloc(1, sizeof(*conn) + MAX_REQUEST_SIZE);
-  if (conn == NULL) {
-    cry(fc(ctx), "%s", "Cannot create new connection struct, OOM");
-  } else {
-    conn->buf_size = MAX_REQUEST_SIZE;
-    conn->buf = (char *) (conn + 1);
-
-    // initialize ep_fd to -1;
-    conn->ep_fd = -1;
-
-    // Call consume_socket() even when ctx->stop_flag > 0, to let it signal
-    // sq_empty condvar to wake up the master waiting in produce_socket()
-    while (consume_socket(ctx, &conn->client)) {
-      conn->birth_time = time(NULL);
-      conn->ctx = ctx;
-
-      // Fill in IP, port info early so even if SSL setup below fails,
-      // error handler would have the corresponding info.
-      // Thanks to Johannes Winkelmann for the patch.
-      // TODO(lsm): Fix IPv6 case
-      conn->request_info.remote_port = ntohs(conn->client.rsa.sin.sin_port);
-      memcpy(&conn->request_info.remote_ip,
-             &conn->client.rsa.sin.sin_addr.s_addr, 4);
-      conn->request_info.remote_ip = ntohl(conn->request_info.remote_ip);
-      conn->request_info.is_ssl = conn->client.is_ssl;
-      // Add by zc
-      conn->data_len = 0;
-
-      if (!conn->client.is_ssl ||
-          (conn->client.is_ssl &&
-           sslize(conn, conn->ctx->ssl_ctx, SSL_accept))) {
-        process_new_connection(conn);
-      }
-
-      close_connection(conn);
-    }
-    free(conn);
-  }
-
-  // Signal master that we're done with connection and exiting
-  (void) pthread_mutex_lock(&ctx->mutex);
-  ctx->num_threads--;
-  (void) pthread_cond_signal(&ctx->cond);
-  assert(ctx->num_threads >= 0);
-  (void) pthread_mutex_unlock(&ctx->mutex);
-
-  DEBUG_TRACE(("exiting"));
-}
-
-// Master thread adds accepted socket to a queue
-static void produce_socket(struct mg_context *ctx, const struct socket *sp) {
-  (void) pthread_mutex_lock(&ctx->mutex);
-
-  // If the queue is full, wait
-  while (ctx->stop_flag == 0 &&
-         ctx->sq_head - ctx->sq_tail >= (int) ARRAY_SIZE(ctx->queue)) {
-    (void) pthread_cond_wait(&ctx->sq_empty, &ctx->mutex);
-  }
-
-  if (ctx->sq_head - ctx->sq_tail < (int) ARRAY_SIZE(ctx->queue)) {
-    // Copy socket to the queue and increment head
-    ctx->queue[ctx->sq_head % ARRAY_SIZE(ctx->queue)] = *sp;
-    ctx->sq_head++;
-    DEBUG_TRACE(("queued socket %d", sp->sock));
-  }
-
-  (void) pthread_cond_signal(&ctx->sq_full);
-  (void) pthread_mutex_unlock(&ctx->mutex);
-}
-
-static void accept_new_connection(const struct socket *listener,
-                                  struct mg_context *ctx) {
-  struct socket accepted;
-  char src_addr[20];
-  socklen_t len;
-  int allowed;
-
-  len = sizeof(accepted.rsa);
-  accepted.lsa = listener->lsa;
-  accepted.sock = accept(listener->sock, &accepted.rsa.sa, &len);
-  if (accepted.sock != INVALID_SOCKET) {
-    allowed = check_acl(ctx, ntohl(* (uint32_t *) &accepted.rsa.sin.sin_addr));
-    if (allowed) {
-      // Put accepted socket structure into the queue
-      DEBUG_TRACE(("accepted socket %d", accepted.sock));
-      accepted.is_ssl = listener->is_ssl;
-      produce_socket(ctx, &accepted);
-    } else {
-      sockaddr_to_string(src_addr, sizeof(src_addr), &accepted.rsa);
-      cry(fc(ctx), "%s: %s is not allowed to connect", __func__, src_addr);
-      (void) closesocket(accepted.sock);
-    }
-  }
-}
-
-static void master_thread(struct mg_context *ctx) {
-  fd_set read_set;
-  struct timeval tv;
-  struct socket *sp;
-  int max_fd;
-
-  // Increase priority of the master thread
-#if defined(_WIN32)
-  SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL);
-#endif
-
-#if defined(ISSUE_317)
-  struct sched_param sched_param;
-  sched_param.sched_priority = sched_get_priority_max(SCHED_RR);
-  pthread_setschedparam(pthread_self(), SCHED_RR, &sched_param);
-#endif
-
-  while (ctx->stop_flag == 0) {
-    FD_ZERO(&read_set);
-    max_fd = -1;
-
-    // Add listening sockets to the read set
-    for (sp = ctx->listening_sockets; sp != NULL; sp = sp->next) {
-      add_to_set(sp->sock, &read_set, &max_fd);
-    }
-
-    tv.tv_sec = 0;
-    tv.tv_usec = 200 * 1000;
-
-    if (select(max_fd + 1, &read_set, NULL, NULL, &tv) < 0) {
-#ifdef _WIN32
-      // On windows, if read_set and write_set are empty,
-      // select() returns "Invalid parameter" error
-      // (at least on my Windows XP Pro). So in this case, we sleep here.
-      mg_sleep(1000);
-#endif // _WIN32
-    } else {
-      for (sp = ctx->listening_sockets; sp != NULL; sp = sp->next) {
-        if (ctx->stop_flag == 0 && FD_ISSET(sp->sock, &read_set)) {
-          accept_new_connection(sp, ctx);
-        }
-      }
-    }
-  }
-  DEBUG_TRACE(("stopping workers"));
-
-  // Stop signal received: somebody called mg_stop. Quit.
-  close_all_listening_sockets(ctx);
-
-  // Wakeup workers that are waiting for connections to handle.
-  pthread_cond_broadcast(&ctx->sq_full);
-
-  // Wait until all threads finish
-  (void) pthread_mutex_lock(&ctx->mutex);
-  while (ctx->num_threads > 0) {
-    (void) pthread_cond_wait(&ctx->cond, &ctx->mutex);
-  }
-  (void) pthread_mutex_unlock(&ctx->mutex);
-
-  // All threads exited, no sync is needed. Destroy mutex and condvars
-  (void) pthread_mutex_destroy(&ctx->mutex);
-  (void) pthread_cond_destroy(&ctx->cond);
-  (void) pthread_cond_destroy(&ctx->sq_empty);
-  (void) pthread_cond_destroy(&ctx->sq_full);
-
-#if !defined(NO_SSL)
-  uninitialize_ssl(ctx);
-#endif
-  DEBUG_TRACE(("exiting"));
-
-  // Signal mg_stop() that we're done.
-  // WARNING: This must be the very last thing this
-  // thread does, as ctx becomes invalid after this line.
-  ctx->stop_flag = 2;
-}
-
-static void free_context(struct mg_context *ctx) {
-  int i;
-
-  // Deallocate config parameters
-  for (i = 0; i < NUM_OPTIONS; i++) {
-    if (ctx->config[i] != NULL)
-      free(ctx->config[i]);
-  }
-
-  // Deallocate SSL context
-  if (ctx->ssl_ctx != NULL) {
-    SSL_CTX_free(ctx->ssl_ctx);
-  }
-  if (ctx->client_ssl_ctx != NULL) {
-    SSL_CTX_free(ctx->client_ssl_ctx);
-  }
-#ifndef NO_SSL
-  if (ssl_mutexes != NULL) {
-    free(ssl_mutexes);
-    ssl_mutexes = NULL;
-  }
-#endif // !NO_SSL
-
-  // Deallocate context itself
-  free(ctx);
-}
-
-void mg_stop(struct mg_context *ctx) {
-  ctx->stop_flag = 1;
-
-  // Wait until mg_fini() stops
-  while (ctx->stop_flag != 2) {
-    (void) mg_sleep(10);
-  }
-  free_context(ctx);
-
-#if defined(_WIN32) && !defined(__SYMBIAN32__)
-  (void) WSACleanup();
-#endif // _WIN32
-}
-
-struct mg_context *mg_start(mg_callback_t user_callback, void *user_data,
-                            const char **options) {
-  struct mg_context *ctx;
-  const char *name, *value, *default_value;
-  int i;
-
-#if defined(_WIN32) && !defined(__SYMBIAN32__)
-  WSADATA data;
-  WSAStartup(MAKEWORD(2,2), &data);
-  InitializeCriticalSection(&global_log_file_lock);
-#endif // _WIN32
-
-  // Allocate context and initialize reasonable general case defaults.
-  // TODO(lsm): do proper error handling here.
-  if ((ctx = (struct mg_context *) calloc(1, sizeof(*ctx))) == NULL) {
-    return NULL;
-  }
-  ctx->user_callback = user_callback;
-  ctx->user_data = user_data;
-
-  while (options && (name = *options++) != NULL) {
-    if ((i = get_option_index(name)) == -1) {
-      cry(fc(ctx), "Invalid option: %s", name);
-      free_context(ctx);
-      return NULL;
-    } else if ((value = *options++) == NULL) {
-      cry(fc(ctx), "%s: option value cannot be NULL", name);
-      free_context(ctx);
-      return NULL;
-    }
-    if (ctx->config[i] != NULL) {
-      cry(fc(ctx), "warning: %s: duplicate option", name);
-    }
-    ctx->config[i] = mg_strdup(value);
-    DEBUG_TRACE(("[%s] -> [%s]", name, value));
-  }
-
-  // Set default value if needed
-  for (i = 0; config_options[i * ENTRIES_PER_CONFIG_OPTION] != NULL; i++) {
-    default_value = config_options[i * ENTRIES_PER_CONFIG_OPTION + 2];
-    if (ctx->config[i] == NULL && default_value != NULL) {
-      ctx->config[i] = mg_strdup(default_value);
-      DEBUG_TRACE(("Setting default: [%s] -> [%s]",
-                   config_options[i * ENTRIES_PER_CONFIG_OPTION + 1],
-                   default_value));
-    }
-  }
-
-  // NOTE(lsm): order is important here. SSL certificates must
-  // be initialized before listening ports. UID must be set last.
-  if (!set_gpass_option(ctx) ||
-#if !defined(NO_SSL)
-      !set_ssl_option(ctx) ||
-#endif
-      !set_ports_option(ctx) ||
-#if !defined(_WIN32)
-      !set_uid_option(ctx) ||
-#endif
-      !set_acl_option(ctx)) {
-    free_context(ctx);
-    return NULL;
-  }
-
-#if !defined(_WIN32) && !defined(__SYMBIAN32__)
-  // Ignore SIGPIPE signal, so if browser cancels the request, it
-  // won't kill the whole process.
-  (void) signal(SIGPIPE, SIG_IGN);
-  // Also ignoring SIGCHLD to let the OS to reap zombies properly.
-  (void) signal(SIGCHLD, SIG_IGN);
-#endif // !_WIN32
-
-  (void) pthread_mutex_init(&ctx->mutex, NULL);
-  (void) pthread_cond_init(&ctx->cond, NULL);
-  (void) pthread_cond_init(&ctx->sq_empty, NULL);
-  (void) pthread_cond_init(&ctx->sq_full, NULL);
-
-  // Start master (listening) thread
-  mg_start_thread((mg_thread_func_t) master_thread, ctx);
-
-  // Start worker threads
-  for (i = 0; i < atoi(ctx->config[NUM_THREADS]); i++) {
-    if (mg_start_thread((mg_thread_func_t) worker_thread, ctx) != 0) {
-      cry(fc(ctx), "Cannot start worker thread: %d", ERRNO);
-    } else {
-      ctx->num_threads++;
-    }
-  }
-
-  return ctx;
-}
diff --git a/be/src/http/mongoose.h b/be/src/http/mongoose.h
deleted file mode 100644
index a8fffe2cf8df03..00000000000000
--- a/be/src/http/mongoose.h
+++ /dev/null
@@ -1,307 +0,0 @@
-// Copyright (c) 2004-2012 Sergey Lyubka
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef MONGOOSE_HEADER_INCLUDED
-#define  MONGOOSE_HEADER_INCLUDED
-
-#include <stdio.h>
-#include <stddef.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif // __cplusplus
-
-struct mg_context;     // Handle for the HTTP service itself
-struct mg_connection;  // Handle for the individual connection
-
-
-// This structure contains information about the HTTP request.
-struct mg_request_info {
-  char *request_method = nullptr;  // "GET", "POST", etc
-  char *uri = nullptr;             // URL-decoded URI
-  char *http_version = nullptr;    // E.g. "1.0", "1.1"
-  char *query_string = nullptr;    // URL part after '?' (not including '?') or NULL
-  char *remote_user = nullptr;     // Authenticated user, or NULL if no auth used
-  long remote_ip;                  // Client's IP address
-  int remote_port;                 // Client's port
-  int is_ssl;                      // 1 if SSL-ed, 0 if not
-  int num_headers;                 // Number of headers
-  struct mg_header {
-    char *name = nullptr;          // HTTP header name
-    char *value = nullptr;         // HTTP header value
-  } http_headers[64];              // Maximum 64 headers
-};
-
-
-// Various events on which user-defined function is called by Mongoose.
-enum mg_event {
-  MG_NEW_REQUEST,       // New HTTP request has arrived from the client
-  MG_REQUEST_COMPLETE,  // Mongoose has finished handling the request
-  MG_HTTP_ERROR,        // HTTP error must be returned to the client
-  MG_EVENT_LOG,         // Mongoose logs an event, request_info.log_message
-  MG_INIT_SSL,          // SSL initialization, sent before certificate setup
-  MG_WEBSOCKET_CONNECT, // Sent on HTTP connect, before websocket handshake.
-                        // If user callback returns NULL, then mongoose proceeds
-                        // with handshake, otherwise it closes the connection.
-  MG_WEBSOCKET_READY,   // Handshake has been successfully completed.
-  MG_WEBSOCKET_MESSAGE, // Incoming message from the client
-  MG_WEBSOCKET_CLOSE,   // Client has closed the connection
-};
-
-
-// Prototype for the user-defined function. Mongoose calls this function
-// on every MG_* event.
-//
-// Parameters:
-//   event: which event has been triggered.
-//   conn: opaque connection handler. Could be used to read, write data to the
-//         client, etc. See functions below that have "mg_connection *" arg.
-//
-// Return:
-//   If handler returns non-NULL, that means that handler has processed the
-//   request by sending appropriate HTTP reply to the client. Mongoose treats
-//   the request as served.
-//   If handler returns NULL, that means that handler has not processed
-//   the request. Handler must not send any data to the client in this case.
-//   Mongoose proceeds with request handling as if nothing happened.
-typedef void *(*mg_callback_t)(enum mg_event event, struct mg_connection *conn);
-
-
-// Start web server.
-//
-// Parameters:
-//   callback: user defined event handling function or NULL.
-//   options: NULL terminated list of option_name, option_value pairs that
-//            specify Mongoose configuration parameters.
-//
-// Side-effects: on UNIX, ignores SIGCHLD and SIGPIPE signals. If custom
-//    processing is required for these, signal handlers must be set up
-//    after calling mg_start().
-//
-//
-// Example:
-//   const char *options[] = {
-//     "document_root", "/var/www",
-//     "listening_ports", "80,443s",
-//     NULL
-//   };
-//   struct mg_context *ctx = mg_start(&my_func, NULL, options);
-//
-// Please refer to http://code.google.com/p/mongoose/wiki/MongooseManual
-// for the list of valid option and their possible values.
-//
-// Return:
-//   web server context, or NULL on error.
-struct mg_context *mg_start(mg_callback_t callback, void *user_data,
-                            const char **options);
-
-
-// Stop the web server.
-//
-// Must be called last, when an application wants to stop the web server and
-// release all associated resources. This function blocks until all Mongoose
-// threads are stopped. Context pointer becomes invalid.
-void mg_stop(struct mg_context *);
-
-
-// Get the value of particular configuration parameter.
-// The value returned is read-only. Mongoose does not allow changing
-// configuration at run time.
-// If given parameter name is not valid, NULL is returned. For valid
-// names, return value is guaranteed to be non-NULL. If parameter is not
-// set, zero-length string is returned.
-const char *mg_get_option(const struct mg_context *ctx, const char *name);
-
-
-// Return array of strings that represent valid configuration options.
-// For each option, a short name, long name, and default value is returned.
-// Array is NULL terminated.
-const char **mg_get_valid_option_names(void);
-
-
-// Add, edit or delete the entry in the passwords file.
-//
-// This function allows an application to manipulate .htpasswd files on the
-// fly by adding, deleting and changing user records. This is one of the
-// several ways of implementing authentication on the server side. For another,
-// cookie-based way please refer to the examples/chat.c in the source tree.
-//
-// If password is not NULL, entry is added (or modified if already exists).
-// If password is NULL, entry is deleted.
-//
-// Return:
-//   1 on success, 0 on error.
-int mg_modify_passwords_file(const char *passwords_file_name,
-                             const char *domain,
-                             const char *user,
-                             const char *password);
-
-
-// Return information associated with the request.
-// These functions always succeed.
-const struct mg_request_info *mg_get_request_info(const struct mg_connection *);
-void *mg_get_user_data(struct mg_connection *);
-const char *mg_get_log_message(const struct mg_connection *);
-int mg_get_reply_status_code(const struct mg_connection *);
-void *mg_get_ssl_context(const struct mg_connection *);
-
-
-// Send data to the client.
-// Return:
-//  0   when the connection has been closed
-//  -1  on error
-//  number of bytes written on success
-int mg_write(struct mg_connection *, const void *buf, size_t len);
-
-
-// Send data to the browser using printf() semantics.
-//
-// Works exactly like mg_write(), but allows to do message formatting.
-// Below are the macros for enabling compiler-specific checks for
-// printf-like arguments.
-
-#undef PRINTF_FORMAT_STRING
-#if _MSC_VER >= 1400
-#include <sal.h>
-#if _MSC_VER > 1400
-#define PRINTF_FORMAT_STRING(s) _Printf_format_string_ s
-#else
-#define PRINTF_FORMAT_STRING(s) __format_string s
-#endif
-#else
-#define PRINTF_FORMAT_STRING(s) s
-#endif
-
-#ifdef __GNUC__
-#define PRINTF_ARGS(x, y) __attribute__((format(printf, x, y)))
-#else
-#define PRINTF_ARGS(x, y)
-#endif
-
-int mg_printf(struct mg_connection *,
-              PRINTF_FORMAT_STRING(const char *fmt), ...) PRINTF_ARGS(2, 3);
-
-
-// Send contents of the entire file together with HTTP headers.
-void mg_send_file(struct mg_connection *conn, const char *path);
-
-
-// Read data from the remote end, return number of bytes read.
-int mg_read(struct mg_connection *, void *buf, size_t len);
-
-
-// Get the value of particular HTTP header.
-//
-// This is a helper function. It traverses request_info->http_headers array,
-// and if the header is present in the array, returns its value. If it is
-// not present, NULL is returned.
-const char *mg_get_header(const struct mg_connection *, const char *name);
-
-
-// Get a value of particular form variable.
-//
-// Parameters:
-//   data: pointer to form-uri-encoded buffer. This could be either POST data,
-//         or request_info.query_string.
-//   data_len: length of the encoded data.
-//   var_name: variable name to decode from the buffer
-//   buf: destination buffer for the decoded variable
-//   buf_len: length of the destination buffer
-//
-// Return:
-//   On success, length of the decoded variable.
-//   On error:
-//      -1 (variable not found, or destination buffer is too small).
-//      -2 (destination buffer is NULL or zero length).
-//
-// Destination buffer is guaranteed to be '\0' - terminated if it is not
-// NULL or zero length. In case of failure, dst[0] == '\0'.
-int mg_get_var(const char *data, size_t data_len,
-               const char *var_name, char *buf, size_t buf_len);
-
-// Fetch value of certain cookie variable into the destination buffer.
-//
-// Destination buffer is guaranteed to be '\0' - terminated. In case of
-// failure, dst[0] == '\0'. Note that RFC allows many occurrences of the same
-// parameter. This function returns only first occurrence.
-//
-// Return:
-//   On success, value length.
-//   On error, -1 (either "Cookie:" header is not present at all, or the
-//   requested parameter is not found, or destination buffer is too small
-//   to hold the value).
-int mg_get_cookie(const struct mg_connection *,
-                  const char *cookie_name, char *buf, size_t buf_len);
-
-
-// Connect to the remote web server.
-// Return:
-//   On success, valid pointer to the new connection
-//   On error, NULL
-struct mg_connection *mg_connect(struct mg_context *ctx,
-                                 const char *host, int port, int use_ssl);
-
-
-// Close the connection opened by mg_connect().
-void mg_close_connection(struct mg_connection *conn);
-
-
-// Download given URL to a given file.
-//   url: URL to download
-//   path: file name where to save the data
-//   request_info: pointer to a structure that will hold parsed reply headers
-//   buf, bul_len: a buffer for the reply headers
-// Return:
-//   On error, NULL
-//   On success, opened file stream to the downloaded contents. The stream
-//   is positioned to the end of the file. It is the user's responsibility
-//   to fclose() the opened file stream.
-FILE *mg_fetch(struct mg_context *ctx, const char *url, const char *path,
-               char *buf, size_t buf_len, struct mg_request_info *request_info);
-
-
-// Convenience function -- create detached thread.
-// Return: 0 on success, non-0 on error.
-typedef void * (*mg_thread_func_t)(void *);
-int mg_start_thread(mg_thread_func_t f, void *p);
-
-
-// Return builtin mime type for the given file name.
-// For unrecognized extensions, "text/plain" is returned.
-const char *mg_get_builtin_mime_type(const char *file_name);
-
-
-// Return Mongoose version.
-const char *mg_version(void);
-
-
-// MD5 hash given strings.
-// Buffer 'buf' must be 33 bytes long. Varargs is a NULL terminated list of
-// ASCIIz strings. When function returns, buf will contain human-readable
-// MD5 hash. Example:
-//   char buf[33];
-//   mg_md5(buf, "aa", "bb", NULL);
-void mg_md5(char buf[33], ...);
-
-
-#ifdef __cplusplus
-}
-#endif // __cplusplus
-
-#endif // MONGOOSE_HEADER_INCLUDED
diff --git a/be/src/http/monitor_action.cpp b/be/src/http/monitor_action.cpp
index 760ffecbffe724..bdbf89c7c26c1b 100644
--- a/be/src/http/monitor_action.cpp
+++ b/be/src/http/monitor_action.cpp
@@ -34,27 +34,36 @@ void MonitorAction::register_module(const std::string& name, RestMonitorIface* m
     _module_by_name.insert(std::make_pair(name, module));
 }
 
-void MonitorAction::handle(HttpRequest *req, HttpChannel *channel) {
+void MonitorAction::handle(HttpRequest *req) {
     LOG(INFO) << req->debug_string();
     const std::string& module = req->param(MODULE_KEY);
     if (module.empty()) {
         std::string err_msg = "No module params\n";
+#if 0
         HttpResponse response(HttpStatus::OK, &err_msg);
         channel->send_response(response);
+#endif
+        HttpChannel::send_reply(req, HttpStatus::OK, err_msg);
         return ;
     }
     if (_module_by_name.find(module) == _module_by_name.end()) {
         std::string err_msg = "Unknown module(";
         err_msg += module + ")\n";
+#if 0
         HttpResponse response(HttpStatus::OK, &err_msg);
         channel->send_response(response);
+#endif
+        HttpChannel::send_reply(req, HttpStatus::OK, err_msg);
         return ;
     }
     std::stringstream ss;
     _module_by_name[module]->debug(ss);
     std::string str = ss.str();
+#if 0
     HttpResponse response(HttpStatus::OK, &str);
     channel->send_response(response);
+#endif
+    HttpChannel::send_reply(req, HttpStatus::OK, str);
 }
 
 }
diff --git a/be/src/http/monitor_action.h b/be/src/http/monitor_action.h
index 3135d63b54d4d0..8ec1cfdbec5cad 100644
--- a/be/src/http/monitor_action.h
+++ b/be/src/http/monitor_action.h
@@ -34,7 +34,7 @@ class MonitorAction : public HttpHandler {
 
     void register_module(const std::string& name, RestMonitorIface* module);
 
-    virtual void handle(HttpRequest *req, HttpChannel* channel);
+    void handle(HttpRequest *req) override;
 private:
     std::map<std::string, RestMonitorIface*> _module_by_name;
 };
diff --git a/be/src/http/web_page_handler.cpp b/be/src/http/web_page_handler.cpp
index c9052eef849755..45eda3f25d7aaa 100644
--- a/be/src/http/web_page_handler.cpp
+++ b/be/src/http/web_page_handler.cpp
@@ -22,7 +22,8 @@
 #include "http/http_request.h"
 #include "http/http_response.h"
 #include "http/http_channel.h"
-#include "http/webserver.h"
+#include "http/http_headers.h"
+#include "http/ev_http_server.h"
 #include "util/debug_util.h"
 #include "util/cpu_info.h"
 #include "util/disk_info.h"
@@ -32,8 +33,8 @@ namespace palo {
 
 static std::string s_html_content_type = "text/html";
 
-WebPageHandler::WebPageHandler(Webserver* web) :
-        _web_server(web) {
+WebPageHandler::WebPageHandler(EvHttpServer* server) :
+        _http_server(server) {
     PageHandlerCallback default_callback =
             boost::bind<void>(boost::mem_fn(&WebPageHandler::root_handler), this, _1, _2);
     register_page("/", default_callback);
@@ -49,12 +50,12 @@ void WebPageHandler::register_page(
     auto map_iter = _page_map.find(path);
     if (map_iter == _page_map.end()) {
         // first time, register this to web server
-        _web_server->register_handler(HttpMethod::GET, path, this);
+        _http_server->register_handler(HttpMethod::GET, path, this);
     }
     _page_map[path].add_callback(callback);
 }
 
-void WebPageHandler::handle(HttpRequest *req, HttpChannel *channel) {
+void WebPageHandler::handle(HttpRequest *req) {
     // Should we render with css styles?
     bool use_style = true;
     std::map<std::string, std::string>& params = *req->params();
@@ -87,8 +88,13 @@ void WebPageHandler::handle(HttpRequest *req, HttpChannel *channel) {
         bootstrap_page_footer(&output);
     }
     std::string str = output.str();
+
+    req->add_output_header(HttpHeaders::CONTENT_TYPE, s_html_content_type.c_str());
+    HttpChannel::send_reply(req, HttpStatus::OK, str);
+#if 0
     HttpResponse response(HttpStatus::OK, s_html_content_type, &str);
     channel->send_response(response);
+#endif
 }
 
 static const std::string PAGE_HEADER = 
diff --git a/be/src/http/web_page_handler.h b/be/src/http/web_page_handler.h
index 9d1b9d3052e0bd..655ae6d58781f1 100644
--- a/be/src/http/web_page_handler.h
+++ b/be/src/http/web_page_handler.h
@@ -28,7 +28,7 @@
 
 namespace palo {
 
-class Webserver;
+class EvHttpServer;
 
 // This a handler for webpage request
 // and this handler manage all the page handler
@@ -37,12 +37,12 @@ class WebPageHandler : public HttpHandler {
     typedef std::map<std::string, std::string> ArgumentMap;
     typedef boost::function<void (const ArgumentMap& args, std::stringstream* output)> 
             PageHandlerCallback;
-    WebPageHandler(Webserver* webserver);
+    WebPageHandler(EvHttpServer* http_server);
 
     virtual ~WebPageHandler() {
     }
 
-    virtual void handle(HttpRequest *req, HttpChannel *channel);
+    void handle(HttpRequest *req) override;
 
     // Just use old code
     void register_page(const std::string& path, const PageHandlerCallback& callback);
@@ -65,7 +65,7 @@ class WebPageHandler : public HttpHandler {
         std::vector<PageHandlerCallback> _callbacks;
     };
 
-    Webserver* _web_server;
+    EvHttpServer* _http_server;
     // Lock guarding the _path_handlers map
     boost::mutex _map_lock;
     // Map of path to a PathHandler containing a list of handlers for that
diff --git a/be/src/http/webserver.cpp b/be/src/http/webserver.cpp
deleted file mode 100644
index 41eba59b50fe38..00000000000000
--- a/be/src/http/webserver.cpp
+++ /dev/null
@@ -1,248 +0,0 @@
-// Copyright (c) 2017, Baidu.com, Inc. All Rights Reserved
-
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#include "http/webserver.h"
-
-#include <stdio.h>
-#include <signal.h>
-#include <string>
-#include <map>
-#include <boost/lexical_cast.hpp>
-#include <boost/foreach.hpp>
-#include <boost/bind.hpp>
-#include <boost/mem_fn.hpp>
-#include <boost/algorithm/string.hpp>
-
-#include "common/logging.h"
-#include "util/cpu_info.h"
-#include "util/disk_info.h"
-#include "util/mem_info.h"
-#include "util/url_coding.h"
-#include "util/logging.h"
-#include "util/debug_util.h"
-#include "util/palo_metrics.h"
-#include "util/runtime_profile.h"
-#include "http/http_response.h"
-
-namespace palo {
-
-const char* get_default_documnet_root();
-
-// Mongoose requires a non-null return from the callback to signify successful processing
-static void* PROCESSING_COMPLETE = reinterpret_cast<void*>(1);
-
-// Returns $PALO_HOME if set, otherwise /tmp/impala_www
-const char* get_default_documnet_root() {
-    std::stringstream ss;
-    char* palo_home = getenv("PALO_HOME");
-
-    if (palo_home == NULL) {
-        return ""; // Empty document root means don't serve static files
-    } else {
-        ss << palo_home;
-    }
-
-    // Deliberate memory leak, but this should be called exactly once.
-    std::string* str = new std::string(ss.str());
-    return str->c_str();
-}
-
-Webserver::Webserver() : 
-        _port(config::webserver_port),
-        _interface(config::webserver_interface),
-        _context(nullptr) {
-    pthread_rwlock_init(&_rw_lock, nullptr);                
-}
-
-Webserver::~Webserver() {
-    stop();
-    pthread_rwlock_destroy(&_rw_lock);                
-}
-
-Status Webserver::start() {
-    LOG(INFO) << "Starting webserver on " << _interface
-              << (_interface.empty() ? "all interfaces, port " : ":") << _port;
-
-    std::string port_as_string = boost::lexical_cast<std::string>(_port);
-    std::stringstream listening_spec;
-    listening_spec << _interface << (_interface.empty() ? "" : ":") << port_as_string;
-    std::string listening_str = listening_spec.str();
-    std::vector<const char*> options;
-
-    if (!config::webserver_doc_root.empty() && config::enable_webserver_doc_root) {
-        LOG(INFO) << "Document root: " << config::webserver_doc_root;
-        options.push_back("document_root");
-        options.push_back(config::webserver_doc_root.c_str());
-    } else {
-        LOG(INFO) << "Document root disabled";
-    }
-
-    options.push_back("listening_ports");
-    options.push_back(listening_str.c_str());
-
-    // Options must be a NULL-terminated list
-    options.push_back(NULL);
-
-    // mongoose ignores SIGCHLD and we need it to run kinit. This means that since
-    // mongoose does not reap its own children CGI programs must be avoided.
-    // Save the signal handler so we can restore it after mongoose sets it to be ignored.
-    sighandler_t sig_chld = signal(SIGCHLD, SIG_DFL);
-
-    // To work around not being able to pass member functions as C callbacks, we store a
-    // pointer to this server in the per-server state, and register a static method as the
-    // default callback. That method unpacks the pointer to this and calls the real
-    // callback.
-    _context = mg_start(&Webserver::mongoose_callback_static, reinterpret_cast<void*>(this),
-                        &options[0]);
-
-    // Restore the child signal handler so wait() works properly.
-    signal(SIGCHLD, sig_chld);
-
-    if (_context == NULL) {
-        std::stringstream error_msg;
-        error_msg << "Could not start webserver on port: " << _port;
-        return Status(error_msg.str());
-    }
-
-    LOG(INFO) << "Webserver started";
-    return Status::OK;
-}
-
-void Webserver::stop() {
-    if (_context != NULL) {
-        mg_stop(_context);
-    }
-}
-
-bool Webserver::register_handler(const HttpMethod& method, 
-                                 const std::string& path, 
-                                 HttpHandler* handler) {
-    if (handler == nullptr) {
-        LOG(WARNING) << "dummy handler for http method " << method << " with path " << path;
-        return false;
-    }
-
-    bool result = false;
-    pthread_rwlock_wrlock(&_rw_lock);
-    PathTrie<HttpHandler*>* root = nullptr;
-    switch (method) {
-    case GET:
-        root = &_get_handlers;
-        break;
-    case PUT:
-        root = &_put_handlers;
-        break;
-    case POST:
-        root = &_post_handlers;
-        break;
-    case DELETE:
-        root = &_delete_handlers;
-        break;
-    case HEAD:
-        root = &_head_handlers;
-        break;
-    case OPTIONS:
-        root = &_options_handlers;
-        break;
-    default:
-        LOG(WARNING) << "No such method(" << method << ") for http";
-        result = false;
-    }
-    result = root->insert(path, handler);
-    pthread_rwlock_unlock(&_rw_lock);
-    return result;
-}
-
-HttpHandler* Webserver::get_handler(HttpRequest& req) {
-    std::string path = req.raw_path();
-
-    pthread_rwlock_rdlock(&_rw_lock);
-    HttpHandler* handler = nullptr;
-    switch (req.method()) {
-    case GET:
-        _get_handlers.retrieve(path, &handler, req.params());
-        break;
-    case PUT:
-        _put_handlers.retrieve(path, &handler, req.params());
-        break;
-    case POST:
-        _post_handlers.retrieve(path, &handler, req.params());
-        break;
-    case DELETE:
-        _delete_handlers.retrieve(path, &handler, req.params());
-        break;
-    case HEAD:
-        _head_handlers.retrieve(path, &handler, req.params());
-        break;
-    case OPTIONS:
-        _options_handlers.retrieve(path, &handler, req.params());
-        break;
-    default:
-        LOG(WARNING) << "No such method(" << req.method() << ") for http";
-        break;
-    }
-    pthread_rwlock_unlock(&_rw_lock);
-    return handler;
-}
-
-void* Webserver::mongoose_callback_static(
-        enum mg_event event,
-        struct mg_connection* connection) {
-    if (event == MG_NEW_REQUEST) {
-        Webserver* instance = reinterpret_cast<Webserver*>(mg_get_user_data(connection));
-        return instance->mongoose_callback(connection);
-    } else if (event == MG_EVENT_LOG) {
-        LOG(INFO) << "mongoose cry: " << mg_get_log_message(connection);
-        return PROCESSING_COMPLETE;
-    } else if (event == MG_REQUEST_COMPLETE) {
-        return PROCESSING_COMPLETE;
-    } 
-    LOG(INFO) << "unknown mongoose event " << event;
-    // No operation
-    return nullptr;
-}
-
-class PaloMetrics;
-void* Webserver::mongoose_callback(struct mg_connection* mg_conn) {
-    HttpRequest request(mg_conn);
-    HttpChannel channel(request, mg_conn);
-    
-    // No such handler
-    HttpHandler* handler = get_handler(request);
-    if (handler == nullptr) {
-        std::stringstream ss;
-        ss << "{\"status\":\"FAILED\","
-            << "\"msg\":\"No handler for URI " << request.uri() 
-            << " of method " << to_method_desc(request.method()) << "\"}";
-        std::string str = ss.str();
-        HttpResponse response(HttpStatus::NOT_FOUND, &str);
-        channel.send_response(response);
-        return PROCESSING_COMPLETE;
-    }
-
-    int64_t duration_ns = 0;
-    {
-        SCOPED_RAW_TIMER(&duration_ns);
-        handler->handle(&request, &channel);
-    }
-    PaloMetrics::http_requests_total.increment(1);
-    PaloMetrics::http_request_duration_us.increment(duration_ns / 1000);
-    PaloMetrics::http_request_send_bytes.increment(channel.send_bytes());
-
-    // return code to mongoose
-    return PROCESSING_COMPLETE;
-}
-
-}
diff --git a/be/src/http/webserver.h b/be/src/http/webserver.h
deleted file mode 100644
index bc96bdcf1a7d52..00000000000000
--- a/be/src/http/webserver.h
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright (c) 2017, Baidu.com, Inc. All Rights Reserved
-
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#ifndef BDG_PALO_BE_SRC_COMMON_UTIL_WEBSERVER_H
-#define BDG_PALO_BE_SRC_COMMON_UTIL_WEBSERVER_H
-
-#include <pthread.h>
-
-#include <string>
-#include <map>
-#include <boost/function.hpp>
-#include <boost/thread/mutex.hpp>
-
-#include "common/status.h"
-#include "http/http_method.h"
-#include "http/http_request.h"
-#include "http/http_channel.h"
-#include "http/http_handler.h"
-#include "http/mongoose.h"
-#include "util/path_trie.hpp"
-
-namespace palo {
-
-// Wrapper class for the Mongoose web server library. 
-// Clients may register request handler with its path and method
-class Webserver {
-public:
-    // Uses _config::webserver{port, interface}
-    Webserver();
-
-    ~Webserver();
-
-    // Starts a webserver on the port passed to the constructor. The webserver runs in a
-    // separate thread, so this call is non-blocking.
-    Status start();
-
-    // Stops the webserver synchronously.
-    void stop();
-
-    // Register one handler to 'path'.
-    bool register_handler(const HttpMethod& method, const std::string& path, 
-                          HttpHandler* handler);
-
-private:
-    // Get handler to this request
-    HttpHandler* get_handler(HttpRequest& req);
-
-    // Static so that it can act as a function pointer, and then call the next method
-    static void* mongoose_callback_static(
-            enum mg_event event,
-            struct mg_connection* connection);
-
-    // Dispatch point for all incoming requests.
-    void* mongoose_callback(struct mg_connection* connection);
-
-    PathTrie<HttpHandler*> _get_handlers;
-    PathTrie<HttpHandler*> _put_handlers;
-    PathTrie<HttpHandler*> _post_handlers;
-    PathTrie<HttpHandler*> _delete_handlers;
-    PathTrie<HttpHandler*> _head_handlers;
-    PathTrie<HttpHandler*> _options_handlers;
-
-    const int _port;
-    // If empty, webserver will bind to all interfaces.
-    const std::string _interface;
-
-    // Handle to Mongoose context; owned and freed by Mongoose internally
-    struct mg_context* _context;
-
-    pthread_rwlock_t _rw_lock;
-};
-
-}
-
-#endif
diff --git a/be/src/olap/command_executor.cpp b/be/src/olap/command_executor.cpp
index 8e4dd06dc56fd3..96af16ce0f1b25 100755
--- a/be/src/olap/command_executor.cpp
+++ b/be/src/olap/command_executor.cpp
@@ -306,6 +306,7 @@ OLAPStatus CommandExecutor::create_table(const TCreateTabletReq& request) {
 
     // 7. clear environment
     if (res != OLAP_SUCCESS) {
+        PaloMetrics::create_tablet_requests_failed.increment(1);
         if (is_table_added) {
             OLAPStatus status = OLAPEngine::get_instance()->drop_table(
                     request.tablet_id, request.tablet_schema.schema_hash);
@@ -356,6 +357,7 @@ OLAPStatus CommandExecutor::report_all_tablets_info(
     res = OLAPEngine::get_instance()->report_all_tablets_info(tablets_info);
     if (res != OLAP_SUCCESS) {
         OLAP_LOG_WARNING("fail to process report all tablets info. [res=%d]", res);
+        PaloMetrics::report_all_tablets_requests_failed.increment(1);
         return res;
     }
 
@@ -375,6 +377,7 @@ OLAPStatus CommandExecutor::report_tablet_info(TTabletInfo* tablet_info) {
     res = OLAPEngine::get_instance()->report_tablet_info(tablet_info);
     if (res != OLAP_SUCCESS) {
         OLAP_LOG_WARNING("fail to get tablet info. [res=%d]", res);
+        PaloMetrics::report_tablet_requests_failed.increment(1);
         return res;
     }
 
@@ -394,9 +397,10 @@ OLAPStatus CommandExecutor::schema_change(const TAlterTabletReq& request) {
     res = handler.process_alter_table(ALTER_TABLET_SCHEMA_CHANGE, request);
 
     if (res != OLAP_SUCCESS) {
-        OLAP_LOG_WARNING("fail to submit schema_change. "
+        OLAP_LOG_WARNING("failed to do schema change. "
                          "[base_table=%ld new_table=%ld] [res=%d]",
                          request.base_tablet_id, request.new_tablet_req.tablet_id, res);
+        PaloMetrics::schema_change_requests_failed.increment(1);
         return res;
     }
 
@@ -419,9 +423,10 @@ OLAPStatus CommandExecutor::create_rollup_table(const TAlterTabletReq& request)
     res = handler.process_alter_table(ALTER_TABLET_CREATE_ROLLUP_TABLE, request);
 
     if (res != OLAP_SUCCESS) {
-        OLAP_LOG_WARNING("failed to create rollup table. "
+        OLAP_LOG_WARNING("failed to do rollup. "
                          "[base_table=%ld new_table=%ld] [res=%d]",
                          request.base_tablet_id, request.new_tablet_req.tablet_id, res);
+        PaloMetrics::create_rollup_requests_failed.increment(1);
         return res;
     }
 
@@ -642,6 +647,7 @@ OLAPStatus CommandExecutor::delete_data(
         OLAP_LOG_WARNING("fail to push empty version for delete data. "
                          "[res=%d table='%s']",
                          res, table->full_name().c_str());
+        PaloMetrics::delete_requests_failed.increment(1);
         return res;
     }
 
diff --git a/be/src/olap/olap_engine.cpp b/be/src/olap/olap_engine.cpp
index f4989c52a2bc37..795007b2ba8ebf 100644
--- a/be/src/olap/olap_engine.cpp
+++ b/be/src/olap/olap_engine.cpp
@@ -38,6 +38,7 @@
 #include "olap/schema_change.h"
 #include "olap/utils.h"
 #include "olap/writer.h"
+#include "util/palo_metrics.h"
 
 using boost::filesystem::canonical;
 using boost::filesystem::directory_iterator;
@@ -982,10 +983,12 @@ void OLAPEngine::start_base_compaction(string* last_base_compaction_fs, TTabletI
 
     if (do_base_compaction) {
         OLAP_LOG_NOTICE_PUSH("request", "START_BASE_COMPACTION");
+        PaloMetrics::base_compaction_request_total.increment(1);
         OLAPStatus cmd_res = base_compaction.run();
         if (cmd_res != OLAP_SUCCESS) {
             OLAP_LOG_WARNING("failed to do base compaction. [tablet='%s']",
                              tablet->full_name().c_str());
+            PaloMetrics::base_compaction_request_failed.increment(1);
         }
     }
 }
@@ -1095,9 +1098,11 @@ void OLAPEngine::start_cumulative_priority() {
                 _tablet_map_lock.unlock();
 
                 // start cumulative
+                PaloMetrics::cumulative_compaction_request_total.increment(1);
                 if (cumulative_compaction.run() != OLAP_SUCCESS) {
                     OLAP_LOG_WARNING("failed to do cumulative. [tablet='%s']",
                                      j->full_name().c_str());
+                    PaloMetrics::cumulative_compaction_request_failed.increment(1);
                 }
 
                 _fs_task_mutex.lock();
diff --git a/be/src/olap/row_cursor.cpp b/be/src/olap/row_cursor.cpp
index a7c35715ce99ec..58c9bbb8cc3e43 100644
--- a/be/src/olap/row_cursor.cpp
+++ b/be/src/olap/row_cursor.cpp
@@ -238,7 +238,8 @@ OLAPStatus RowCursor::allocate_memory_for_string_type(
             StringSlice* slice = reinterpret_cast<StringSlice*>(fixed_ptr + 1);
             HllContext* context = nullptr;
             if (mem_pool != nullptr) {
-                context = reinterpret_cast<HllContext*>(mem_pool->allocate(sizeof(HllContext)));
+                char* mem = reinterpret_cast<char*>(mem_pool->allocate(sizeof(HllContext)));
+                context = new (mem) HllContext;
             } else {
                 // store context addr, which will be freed
                 // in deconstructor if allocated by new function
diff --git a/be/src/olap/schema_change.cpp b/be/src/olap/schema_change.cpp
index ab7643d205994e..c04ae7708a0f99 100644
--- a/be/src/olap/schema_change.cpp
+++ b/be/src/olap/schema_change.cpp
@@ -1676,7 +1676,7 @@ OLAPStatus SchemaChangeHandler::schema_version_convert(
     // b. 生成历史数据转换器
     SchemaChange* sc_procedure = NULL;
     if (true == sc_sorting) {
-        size_t memory_limitation = config::memory_limiation_per_thread_for_schema_change;
+        size_t memory_limitation = config::memory_limitation_per_thread_for_schema_change;
         OLAP_LOG_INFO("doing schema change with sorting.");
         sc_procedure = new(nothrow) SchemaChangeWithSorting(
                                 dest_olap_table,
@@ -1899,7 +1899,7 @@ OLAPStatus SchemaChangeHandler::_alter_table(SchemaChangeParams* sc_params) {
 
     // b. 生成历史数据转换器
     if (true == sc_sorting) {
-        size_t memory_limitation = config::memory_limiation_per_thread_for_schema_change;
+        size_t memory_limitation = config::memory_limitation_per_thread_for_schema_change;
         OLAP_LOG_INFO("doing schema change with sorting.");
         sc_procedure = new(nothrow) SchemaChangeWithSorting(
                                sc_params->new_olap_table,
diff --git a/be/src/rpc/CMakeLists.txt b/be/src/rpc/CMakeLists.txt
deleted file mode 100644
index 00988928daceeb..00000000000000
--- a/be/src/rpc/CMakeLists.txt
+++ /dev/null
@@ -1,50 +0,0 @@
-# Copyright (c) 2017, Baidu.com, Inc. All Rights Reserved
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-# where to put generated libraries
-set(LIBRARY_OUTPUT_PATH "${BUILD_DIR}/src/rpc")
-
-# where to put generated binaries
-set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/src/rpc")
-
-add_library(RPC STATIC
-    checksum.cpp
-    comm.cpp
-    comm_address.cpp
-    comm_header.cpp
-    connection_manager.cpp
-    dispatch_handler_synchronizer.cpp
-    error.cpp
-    event.cpp
-    fast_clock.cpp
-    file_utils.cpp
-    handler_map.cpp
-    inet_addr.cpp
-    io_handler.cpp
-    io_handler_accept.cpp
-    io_handler_data.cpp
-    io_handler_datagram.cpp
-    io_handler_raw.cpp
-    poll_event.cpp
-    protocol.cpp
-    proxy_map.cpp
-    random.cpp
-    reactor.cpp
-    reactor_factory.cpp
-    reactor_runner.cpp
-    request_cache.cpp
-    response_callback.cpp
-    util.cpp
-)
diff --git a/be/src/rpc/application_handler.h b/be/src/rpc/application_handler.h
deleted file mode 100644
index 96050a675b6115..00000000000000
--- a/be/src/rpc/application_handler.h
+++ /dev/null
@@ -1,132 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_APPLICATION_HANDLER_H
-#define BDG_PALO_BE_SRC_RPC_APPLICATION_HANDLER_H
-
-#include "clock.h"
-#include "event.h"
-#include "reactor_runner.h"
-
-namespace palo {
-/** Base clase for application handlers.  Objects of this type are what get
- * added to an ApplicationQueue.  Provides a constructor for initialization
- * from request MESSAGE event received from the comm layer.
- * There are two attributes of a request handler that control how it is
- * treated in the Application queue:
- *
- * <b>Group ID</b>
- *
- * The ApplicationQueue supports serial execution of requests that operate on
- * a shared resource.  This is achieved through the application request
- * handler <i>group ID</i>.  Application request handlers that contain the
- * same group ID will get executed in series.  When initialized from a MESSAGE
- * event, the group ID is the same as the CommHeader#gid field of the message
- * header, otherwise it is 0.
- *
- * <b>Urgency</b>
- *
- * The ApplicationQueue supports two-level request prioritization.  Requests
- * can be designated as <i>urgent</i> which will cause them to be executed
- * before other non-urgent requests.  Urgent requests will also be executed
- * even when the ApplicationQueue has been paused.  When initialized from a
- * MESSAGE Event, the #m_urgent field will get set to <i>true</i> if the
- * CommHeader::FLAGS_BIT_URGENT is set in the CommHeader#flags field of the
- * message header.
- */
-class ApplicationHandler {
-public:
-
-    /** Constructor initializing from an Event object.
-     * Initializes #m_event to <code>event</code> and sets #m_urgent to
-     * <i>true</i> if the CommHeader::FLAGS_BIT_URGENT is set in the
-     * flags field of Event#header member of <code>event</code>.
-     * @param event %Event that generated the request
-     */
-    ApplicationHandler(EventPtr &event) : m_event(event) {
-        if (m_event) {
-            m_urgent = (bool)(m_event->header.flags & CommHeader::FLAGS_BIT_URGENT);
-        } else {
-            m_urgent = false;
-        }
-    }
-
-    /** Default constructor with #m_urgent flag initialization.
-     * @param urgent Handler should be marked as urgent
-     */
-    ApplicationHandler(bool urgent = false) 
-        : m_urgent(urgent) { }
-
-    /** Destructor */
-    virtual ~ApplicationHandler() { }
-
-    /** Carries out the request.  Called by an ApplicationQueue worker thread.
-    */
-    virtual void run() = 0;
-
-    /** Returns the <i>group ID</i> that this handler belongs to.  This
-     * value is taken from the associated event object (see Event#group_id)
-     * if it exists, otherwise the value is 0 indicating that the handler
-     * does not belong to a group.
-     * @return Group ID
-     */
-    uint64_t get_group_id() {
-        return (m_event) ?  m_event->group_id : 0;
-    }
-
-    /** Returns <i>true</i> if request is urgent.
-     * @return <i>true</i> if urgent
-     */
-    bool is_urgent() { return m_urgent; }
-
-    /** Returns <i>true</i> if request has expired.
-     * @return <i>true</i> if request has expired.
-     */
-    bool is_expired() {
-        if (m_event && m_event->type == Event::MESSAGE &&
-                ReactorRunner::record_arrival_time &&
-                (m_event->header.flags & CommHeader::FLAGS_BIT_REQUEST)) {
-            auto now = ClockT::now();
-            uint32_t wait_ms = (uint32_t)std::chrono::duration_cast<std::chrono::milliseconds>(now - m_event->arrival_time).count();
-            if (wait_ms >= m_event->header.timeout_ms) {
-                if (m_event->header.flags & CommHeader::FLAGS_BIT_REQUEST)
-                    LOG(WARNING) << "Request expired, wait time %u > timeout %u" <<
-                        (unsigned)wait_ms << m_event->header.timeout_ms;
-                else
-                    LOG(WARNING) << "Response expired, wait time %u > timeout %u" << (unsigned)wait_ms <<
-                        m_event->header.timeout_ms;
-                if (m_event->header.timeout_ms == 0) {
-                    LOG(INFO) << "Changing zero timeout request to 120000 ms";
-                    m_event->header.timeout_ms = 120000;
-                    return false;
-                }
-                return true;
-            }
-        }
-        return false;
-    }
-
-protected:
-    EventPtr m_event; //!< MESSAGE Event from which handler was initialized
-    bool m_urgent;    //!< Flag indicating if handler is urgent
-};
-
-} // namespace palo
-
-#endif //BDG_PALO_BE_SRC_RPC_APPLICATION_HANDLER_H
diff --git a/be/src/rpc/application_queue.h b/be/src/rpc/application_queue.h
deleted file mode 100644
index f3569d541ae023..00000000000000
--- a/be/src/rpc/application_queue.h
+++ /dev/null
@@ -1,459 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_APPLICATION_QUEUE_H
-#define BDG_PALO_BE_SRC_RPC_APPLICATION_QUEUE_H
-
-#include "application_queue_interface.h"
-#include "application_handler.h"
-#include "common/logging.h"
-#include "string_ext.h"
-
-#include <boost/thread/thread.hpp>
-#include <cassert>
-#include <chrono>
-#include <condition_variable>
-#include <list>
-#include <map>
-#include <memory>
-#include <mutex>
-#include <unordered_map>
-#include <vector>
-
-namespace palo {
-
-/**
- * Application queue.  
- * Helper class for use by server applications that are driven by messages
- * received over the network.  This class can be used in conjunction with the
- * ApplicationHandler class to implement an incoming request queue.  Worker
- * threads pull handlers (requests) off the queue and carry them out.  The
- * following features are supported:
- *
- * <b>Groups</b>
- *
- * Because a set of worker threads pull requests from the queue and carry
- * them out independently, it is possible for requests to get executed out
- * of order relative to the order in which they arrived in the queue.  This
- * can cause problems for certain request sequences such as appending data
- * to a file in the FsBroker, or fetching scanner results from a scanner
- * using multiple readahead requests.  <i>Groups</i> are a way to give
- * applications the ability to serialize a set of requests.  Each request
- * has a <i>group ID</i> that is returned by 
- * the ApplicationHandler#get_group_id method.  Requests that have the
- * same group ID will get executed in series, in the order in which they
- * arrived in the application queue.  Requests with group ID 0 don't belong to
- * any group and will get executed independently with no serialization
- * order.
- *
- * <b>Prioritization</b>
- *
- * The ApplicationQueue supports two-level request prioritization.  Requests
- * can be designated as <i>urgent</i> which will cause them to be executed
- * before other non-urgent requests.  Urgent requests will also be executed
- * even when the ApplicationQueue has been paused.  In palo, METADATA
- * scans and updates are marked urgent which allows them procede and prevent
- * deadlocks when the application queue gets paused due to low memory
- * condition in the RangeServer.  The ApplicationHandler#is_urgent
- * method is used to signal if a request is urgent.
- */
-
-class ApplicationQueue : public ApplicationQueueInterface {
-/** Tracks group execution state.
- * A GroupState object is created for each unique group ID to track the
- * queue execution state of requests in the group.
- */
-    class GroupState {
-    public:
-        GroupState() : group_id(0), running(false), outstanding(1) { return; }
-        uint64_t group_id;    //!< Group ID
-        /** <i>true</i> if a request from this group is being executed */
-        bool     running;
-        /** Number of outstanding (uncompleted) requests in queue for this group*/
-        int      outstanding;
-    };
-
-    /** Hash map of thread group ID to GroupState
-    */ 
-    typedef std::unordered_map<uint64_t, GroupState *> GroupStateMap;
-
-    /** Request record.
-    */
-    class RequestRec {
-        public:
-            RequestRec(ApplicationHandler *arh) : handler(arh), group_state(0) { return; }
-            ~RequestRec() { delete handler; }
-            ApplicationHandler *handler; //!< Pointer to ApplicationHandler
-            GroupState *group_state;     //!< Pointer to GroupState to which request belongs
-    };
-
-    /** Individual request queue
-    */
-    typedef std::list<RequestRec *> RequestQueue;
-
-    /** Application queue state shared among worker threads.
-    */
-    class ApplicationQueueState {
-    public:
-        ApplicationQueueState() : threads_available(0), shutdown(false),
-        paused(false) { }
-        /// Normal request queue
-        RequestQueue queue;
-        /// Urgent request queue
-        RequestQueue urgent_queue;
-        /// Group ID to group state map
-        GroupStateMap group_state_map;
-        /// %Mutex for serializing concurrent access
-        std::mutex mutex;
-        /// Condition variable to signal pending handlers
-        std::condition_variable cond;
-        /// Condition variable used to signal <i>quiesced</i> queue
-        std::condition_variable quiesce_cond;
-        /// Idle thread count
-        size_t threads_available;
-        /// Total initial threads
-        size_t threads_total;
-        /// Flag indicating if shutdown is in progress
-        bool shutdown;
-        /// Flag indicating if queue has been paused
-        bool paused;
-    };
-
-    /** Application queue worker thread function (functor)
-    */
-    class Worker {
-    public:
-        Worker(ApplicationQueueState &qstate, bool one_shot = false) 
-            : m_state(qstate), m_one_shot(one_shot) { return; }
-        /** thread run method
-        */
-        void operator()() {
-            RequestRec *rec = 0;
-            RequestQueue::iterator iter;
-            while (true) {
-                {
-                    std::unique_lock<std::mutex> lock(m_state.mutex);
-                    m_state.threads_available++;
-                    while ((m_state.paused || m_state.queue.empty()) &&
-                            m_state.urgent_queue.empty()) {
-                        if (m_state.shutdown) {
-                            m_state.threads_available--;
-                            return;
-                        }
-                        if (m_state.threads_available == m_state.threads_total) {
-                            m_state.quiesce_cond.notify_all();
-                        }
-                        m_state.cond.wait(lock);
-                    }
-                    if (m_state.shutdown) {
-                        m_state.threads_available--;
-                        return;
-                    }
-                    rec = 0;
-                    iter = m_state.urgent_queue.begin();
-                    while (iter != m_state.urgent_queue.end()) {
-                        rec = (*iter);
-                        if (rec->group_state == 0 || !rec->group_state->running) {
-                            if (rec->group_state) {
-                                rec->group_state->running = true;
-                            }
-                            m_state.urgent_queue.erase(iter);
-                            break;
-                        }
-                        if (!rec->handler || rec->handler->is_expired()) {
-                            iter = m_state.urgent_queue.erase(iter);
-                            remove_expired(rec);
-                        }
-                        rec = 0;
-                        iter++;
-                    }
-                    if (rec == 0 && !m_state.paused) {
-                        iter = m_state.queue.begin();
-                        while (iter != m_state.queue.end()) {
-                            rec = (*iter);
-                            if (rec->group_state == 0 || !rec->group_state->running) {
-                                if (rec->group_state) {
-                                    rec->group_state->running = true;
-                                }
-                                m_state.queue.erase(iter);
-                                break;
-                            }
-                            if (!rec->handler || rec->handler->is_expired()) {
-                                iter = m_state.queue.erase(iter);
-                                remove_expired(rec);
-                            }
-                            rec = 0;
-                            iter++;
-                        }
-                    }
-                    if (rec == 0 && !m_one_shot) {
-                        if (m_state.shutdown) {
-                            m_state.threads_available--;
-                            return;
-                        }
-                        m_state.cond.wait(lock);
-                        if (m_state.shutdown) {
-                            m_state.threads_available--;
-                            return;
-                        }
-                    }
-                    m_state.threads_available--;
-                }
-                if (rec) {
-                    if (rec->handler) {
-                        rec->handler->run();
-                    }
-                    remove(rec);
-                    if (m_one_shot) {
-                        return;
-                    }
-                }
-                else if (m_one_shot) {
-                    return;
-                }
-            }
-            LOG(INFO) << "thread exit";
-        }
-
-    private:
-        /** Removes and deletes a request.  This method updates the group
-         * state associated with <code>rec</code> by setting the running flag to
-         * <i>false</i> and decrementing the outstanding count.  If the
-         * outstanding count for the group drops to 0, the group state record
-         * is removed from ApplicationQueueState::group_state_map and is deleted.
-         * @param rec Request record to remove
-         */
-        void remove(RequestRec *rec) {
-            if (rec->group_state) {
-                std::lock_guard<std::mutex> ulock(m_state.mutex);
-                rec->group_state->running = false;
-                rec->group_state->outstanding--;
-                if (rec->group_state->outstanding == 0) {
-                    m_state.group_state_map.erase(rec->group_state->group_id);
-                    delete rec->group_state;
-                }
-            }
-            delete rec;
-        }
-
-        /** Removes and deletes an expired request.  This method updates the group
-         * state associated with <code>rec</code> by decrementing the outstanding
-         * count.  If the outstanding count for the group drops to 0, the group
-         * state record is removed from ApplicationQueueState::group_state_map and
-         * is deleted.
-         * @param rec Request record to remove
-         */
-        void remove_expired(RequestRec *rec) {
-            if (rec->group_state) {
-                rec->group_state->outstanding--;
-                if (rec->group_state->outstanding == 0) {
-                    m_state.group_state_map.erase(rec->group_state->group_id);
-                    delete rec->group_state;
-                }
-            }
-            delete rec;
-        }
-
-        /// Shared application queue state object
-        ApplicationQueueState &m_state;
-
-        /// Set to <i>true</i> if thread should exit after executing request
-        bool m_one_shot;
-    };
-
-    /// Application queue state object
-    ApplicationQueueState m_state;
-
-    /// Boost thread group for managing threads
-    boost::thread_group m_threads;
-
-    /// Vector of thread IDs
-    std::vector<boost::thread::id> m_thread_ids;
-
-    /// Flag indicating if threads have joined after a shutdown
-    bool joined;
-
-    /** Set to <i>true</i> if queue is configured to allow dynamic thread
-     * creation
-     */
-    bool m_dynamic_threads;
-
-public:
-    /** Default constructor used by derived classes only
-    */
-    ApplicationQueue() : joined(true) {}
-
-    /**
-     * Constructor initialized with worker thread count.
-     * This constructor sets up the application queue with a number of worker
-     * threads specified by <code>worker_count</code>.
-     * @param worker_count Number of worker threads to create
-     * @param dynamic_threads Dynamically create temporary thread to carry out
-     * requests if none available.
-     */
-    ApplicationQueue(int worker_count, bool dynamic_threads = true) 
-        : joined(false), m_dynamic_threads(dynamic_threads) {
-            m_state.threads_total = worker_count;
-            Worker Worker(m_state);
-            assert(worker_count > 0);
-            for (int i = 0; i < worker_count; ++i) {
-                m_thread_ids.push_back(m_threads.create_thread(Worker)->get_id());
-            }
-            //threads
-        }
-
-    /** Destructor.
-    */
-    virtual ~ApplicationQueue() {
-        if (!joined) {
-            shutdown();
-            join();
-        }
-    }
-
-    /**
-     * Returns all the thread IDs for this threadgroup
-     * @return vector of thread::id
-     */
-    std::vector<boost::thread::id> get_thread_ids() const {
-        return m_thread_ids;
-    }
-
-    /**
-     * Shuts down the application queue.  All outstanding requests are carried
-     * out and then all threads exit.  #join can be called to wait for
-     * completion of the shutdown.
-     */
-    void shutdown() {
-        m_state.shutdown = true;
-        m_state.cond.notify_all();
-    }
-
-    /** Wait for queue to become idle (with timeout).
-     * @param deadline Return by this time if queue does not become idle
-     * @param reserve_threads Number of threads that can be active when queue is
-     * idle
-     * @return <i>false</i> if <code>deadline</code> was reached before queue
-     * became idle, <i>true</i> otherwise
-     */
-    bool wait_for_idle(std::chrono::time_point<std::chrono::steady_clock> deadline,
-            int reserve_threads = 0) {
-        std::unique_lock<std::mutex> lock(m_state.mutex);
-        return m_state.quiesce_cond.wait_until(lock, deadline, 
-            [this, reserve_threads](){ 
-                return m_state.threads_available >= (m_state.threads_total-reserve_threads); 
-            });
-    }
-
-    /**
-     * Waits for a shutdown to complete.  This method returns when all
-     * application queue threads exit.
-     */
-    void join() {
-        if (!joined) {
-            m_threads.join_all();
-            joined = true;
-        }
-    }
-
-    /** Starts application queue.
-    */
-    void start() {
-        std::lock_guard<std::mutex> lock(m_state.mutex);
-        m_state.paused = false;
-        m_state.cond.notify_all();
-    }
-
-    /** Stops (pauses) application queue, preventing non-urgent requests from
-     * being executed.  Any requests that are being executed at the time of the
-     * call are allowed to complete.
-     */
-    void stop() {
-        std::lock_guard<std::mutex> lock(m_state.mutex);
-        m_state.paused = true;
-    }
-
-    /** Adds a request (application request handler) to the application queue.
-     * The request queue is designed to support the serialization of related
-     * requests.  Requests are related by the thread group ID value in the
-     * ApplicationHandler.  This thread group ID is constructed in the
-     * Event object.
-     * @param app_handler Pointer to request to add
-     */
-    virtual void add(ApplicationHandler *app_handler) {
-        GroupStateMap::iterator uiter;
-        uint64_t group_id = app_handler->get_group_id();
-        RequestRec *rec = new RequestRec(app_handler);
-        rec->group_state = 0;
-        assert(app_handler);
-        if (group_id != 0) {
-            std::lock_guard<std::mutex> ulock(m_state.mutex);
-            if ((uiter = m_state.group_state_map.find(group_id))
-                    != m_state.group_state_map.end()) {
-                rec->group_state = (*uiter).second;
-                rec->group_state->outstanding++;
-            }
-            else {
-                rec->group_state = new GroupState();
-                rec->group_state->group_id = group_id;
-                m_state.group_state_map[group_id] = rec->group_state;
-            }
-        }
-        {
-            std::lock_guard<std::mutex> lock(m_state.mutex);
-            if (app_handler->is_urgent()) {
-                m_state.urgent_queue.push_back(rec);
-                if (m_dynamic_threads && m_state.threads_available == 0) {
-                    Worker worker(m_state, true);
-                    boost::thread t(worker);
-                }
-            }
-            else
-                m_state.queue.push_back(rec);
-            m_state.cond.notify_one();
-        }
-    }
-
-    /** Adds a request (application request handler) to the application queue.
-     * The request queue is designed to support the serialization of related
-     * requests.  Requests are related by the thread group ID value in the
-     * ApplicationHandler.  This thread group ID is constructed in the
-     * Event object.
-     * @note This method is defined for symmetry and just calls #add
-     * @param app_handler Pointer to request to add
-     */
-    virtual void add_unlocked(ApplicationHandler *app_handler) {
-        add(app_handler);
-    }
-
-    /// Returns the request backlog
-    /// Returns the request backlog, which is the number of requests waiting on
-    /// the request queues for a thread to become available
-    /// @return Request backlog
-    size_t backlog() {
-        std::lock_guard<std::mutex> lock(m_state.mutex);
-        return m_state.queue.size() + m_state.urgent_queue.size();
-    }
-};
-
-/// Shared smart pointer to ApplicationQueue object
-typedef std::shared_ptr<ApplicationQueue> ApplicationQueuePtr;
-}
-
-#endif //BDG_PALO_BE_SRC_RPC_APPLICATION_QUEUE_H
diff --git a/be/src/rpc/application_queue_interface.h b/be/src/rpc/application_queue_interface.h
deleted file mode 100644
index 8866e755307d65..00000000000000
--- a/be/src/rpc/application_queue_interface.h
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_APPLICATION_QUEUE_INTERFACE_H
-#define BDG_PALO_BE_SRC_RPC_APPLICATION_QUEUE_INTERFACE_H
-
-#include "application_handler.h"
-
-namespace palo {
-/** @addtogroup palo
- *  @{
- */
-
-/**
- * Abstract interface for application queue.
- */
-
-class ApplicationQueueInterface {
-public:
-    /** Adds an application handler to queue.
-    */
-    virtual void add(ApplicationHandler *app_handler) = 0;
-
-    /** Adds an application handler to queue without locking.
-     * This method is similar to #add except that it does not do any
-     * locking to serialize access to the queue.  It is for situations
-     * where access serialization is handled by the caller.
-     */
-    virtual void add_unlocked(ApplicationHandler *app_handler) = 0;
-};
-
-/// Smart pointer to ApplicationQueueInterface
-typedef std::shared_ptr<ApplicationQueueInterface> ApplicationQueueInterfacePtr;
-
-}
-
-#endif //BDG_PALO_BE_SRC_RPC_APPLICATION_QUEUE_INTERFACE_H
diff --git a/be/src/rpc/byte_string.h b/be/src/rpc/byte_string.h
deleted file mode 100644
index 42196871ee0d7e..00000000000000
--- a/be/src/rpc/byte_string.h
+++ /dev/null
@@ -1,145 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_BYTE_STRING_H
-#define BDG_PALO_BE_SRC_RPC_BYTE_STRING_H
-
-#include <iostream>
-#include <boost/shared_array.hpp>
-#include <boost/shared_ptr.hpp>
-#include "dynamic_buffer.h"
-#include "serialization.h"
-
-namespace palo {
-/** @addtogroup palo
- *  @{
- */
-
-/**
- * A class managing one or more serializable ByteStrings
- */
-
-class ByteString {
-public:
-    /** Default constructor: starts with an empty string */
-    ByteString() : ptr(0) { }
-
-    /** Overloaded constructor: takes ownership of a pointer
-     *
-     * @param buf The pointer with data
-     */
-    ByteString(const uint8_t *buf) : ptr(buf) { }
-
-    /** Retrieves the length of the serialized string
-     *
-     * @return The length of the serialized string
-     */
-    size_t length() const {
-        if (ptr == 0) {
-            return 1;
-        }
-        const uint8_t *tmp_ptr = ptr;
-        uint32_t len = serialization::decode_vi32(&tmp_ptr);
-        return (tmp_ptr - ptr) + len;
-    }
-
-    /** Retrieves the next serialized String in the buffer */
-    uint8_t *next() {
-        uint8_t *rptr = (uint8_t *)ptr;
-        uint32_t len = serialization::decode_vi32(&ptr);
-        ptr += len;
-        return rptr;
-    }
-
-    /** Retrieves the decoded length and returns a pointer to the string
-     *
-     * @param dptr A pointer to the string data
-     * @return The decoded length of the string data
-     */
-    size_t decode_length(const uint8_t **dptr) const {
-        *dptr = ptr;
-        return serialization::decode_vi32(dptr);
-    }
-
-    /** Writes the data of this ByteString into a pointer
-     *
-     * @param dst A pointer which will receive the serialized data
-     * @return The size of the data which was copied
-     */
-    size_t write(uint8_t *dst) const {
-        size_t len = length();
-        if (ptr == 0) {
-            serialization::encode_vi32(&dst, 0);
-        } else {
-            memcpy(dst, ptr, len);
-        }
-        return len;
-    }
-
-    /** Returns a pointer to the String's deserialized data
-     *
-     * @return A const char * pointer to the deserialized data
-     */
-    const char *str() const {
-        const uint8_t *rptr = ptr;
-        serialization::decode_vi32(&rptr);
-        return (const char *)rptr;
-    }
-
-    /** Returns true if this ByteArray is not empty
-     *
-     * @return True if this ByteArray is not empty, otherwise false
-     */
-    operator bool () const {
-        return ptr != 0;
-    }
-
-    /** The pointer to the serialized data */
-    const uint8_t *ptr;
-};
-
-/** Serializes and appends a byte array to a DynamicBuffer object
- *
- * @param dst_buf The DynamicBuffer which will receive the data
- * @param value A pointer to the data which is appended
- * @param value_len The size of the data, in bytes
- */
-inline void append_as_byte_string(DynamicBuffer &dst_buf, const void *value,
-        uint32_t value_len) {
-    dst_buf.ensure(7 + value_len);
-    serialization::encode_vi32(&dst_buf.ptr, value_len);
-    if (value_len > 0) {
-        memcpy(dst_buf.ptr, value, value_len);
-        dst_buf.ptr += value_len;
-        *dst_buf.ptr = 0;
-    }
-}
-
-/** Serializes and appends a string to a DynamicBuffer object
- *
- * @param dst_buf The DynamicBuffer which will receive the data
- * @param str A pointer to a zero-terminated buffer with the data
- */
-inline void append_as_byte_string(DynamicBuffer &dst_buf, const char *str) {
-    append_as_byte_string(dst_buf, str, strlen(str));
-}
-
-} // namespace palo
-
-#endif //BDG_PALO_BE_SRC_RPC_BYTE_STRING_H
diff --git a/be/src/rpc/checksum.cpp b/be/src/rpc/checksum.cpp
deleted file mode 100644
index 07393f2f1374e8..00000000000000
--- a/be/src/rpc/checksum.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include <arpa/inet.h>
-#include <zlib.h>
-
-#include "checksum.h"
-#include "compat.h"
-
-namespace palo {
-
-#define HT_F32_DO1(buf, i) \
-    sum1 += ((uint16_t)buf[i] << 8) | buf[i + 1]; sum2 += sum1
-#define HT_F32_DO2(buf, i)  HT_F32_DO1(buf, i); HT_F32_DO1(buf, i + 2);
-#define HT_F32_DO4(buf, i)  HT_F32_DO2(buf, i); HT_F32_DO2(buf, i + 4);
-#define HT_F32_DO8(buf, i)  HT_F32_DO4(buf, i); HT_F32_DO4(buf, i + 8);
-#define HT_F32_DO16(buf, i) HT_F32_DO8(buf, i); HT_F32_DO8(buf, i + 16);
-
-/* cf. http://en.wikipedia.org/wiki/Fletcher%27s_checksum
-*/
-uint32_t
-fletcher32(const void *data8, size_t len8) {
-    /* data may not be aligned properly and would segfault on
-     * many systems if cast and used as 16-bit words
-     */
-    const uint8_t *data = (const uint8_t *)data8;
-    uint32_t sum1 = 0xffff;
-    uint32_t sum2 = 0xffff;
-    size_t len = len8 / 2; /* loop works on 16-bit words */
-    while (len) {
-        /* 360 is the largest number of sums that can be
-         * performed without integer overflow
-         */
-        unsigned tlen = len > 360 ? 360 : len;
-        len -= tlen;
-        if (tlen >= 16) {
-            do {
-                HT_F32_DO16(data, 0);
-                data += 32;
-                tlen -= 16;
-            } while (tlen >= 16);
-        }
-        if (tlen != 0) {
-            do {
-                HT_F32_DO1(data, 0);
-                data += 2;
-            } while (--tlen);
-        }
-        sum1 = (sum1 & 0xffff) + (sum1 >> 16);
-        sum2 = (sum2 & 0xffff) + (sum2 >> 16);
-    }
-    /* Check for odd number of bytes */
-    if (len8 & 1) {
-        sum1 += ((uint16_t)*data) << 8;
-        sum2 += sum1;
-        sum1 = (sum1 & 0xffff) + (sum1 >> 16);
-        sum2 = (sum2 & 0xffff) + (sum2 >> 16);
-    }
-    /* Second reduction step to reduce sums to 16 bits */
-    sum1 = (sum1 & 0xffff) + (sum1 >> 16);
-    sum2 = (sum2 & 0xffff) + (sum2 >> 16);
-    return (sum2 << 16) | sum1;
-}
-
-} // namespace palo
diff --git a/be/src/rpc/checksum.h b/be/src/rpc/checksum.h
deleted file mode 100644
index 21ec260233066e..00000000000000
--- a/be/src/rpc/checksum.h
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_CHECKSUM_H
-#define BDG_PALO_BE_SRC_RPC_CHECKSUM_H
-
-namespace palo {
-
-/** Compute fletcher32 checksum for arbitary data. See
- * http://en.wikipedia.org/wiki/Fletcher%27s_checksum for more information
- * about the algorithm. Fletcher32 is the default checksum used in palo.
- *
- * @param data Pointer to the input data
- * @param len Input data length in bytes
- * @return The calculated checksum
- */
-    extern uint32_t fletcher32(const void *data, size_t len);
-} // namespace palo
-
-#endif //BDG_PALO_BE_SRC_RPC_CHECKSUM_H
diff --git a/be/src/rpc/clock.h b/be/src/rpc/clock.h
deleted file mode 100644
index 1a86bb4ee8ffaf..00000000000000
--- a/be/src/rpc/clock.h
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_CLOCK_H
-#define BDG_PALO_BE_SRC_RPC_CLOCK_H
-
-#include "fast_clock.h"
-
-namespace palo {
-
-    /// Clock used for AsyncComm timing needs
-    typedef std::chrono::FastClock ClockT;
-
-}
-
-#endif //BDG_PALO_BE_SRC_RPC_CLOCK_H
diff --git a/be/src/rpc/comm.cpp b/be/src/rpc/comm.cpp
deleted file mode 100644
index f532b00e416848..00000000000000
--- a/be/src/rpc/comm.cpp
+++ /dev/null
@@ -1,548 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "comm.h"
-
-extern "C" {
-#include <errno.h>
-#include <fcntl.h>
-#include <netdb.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <arpa/inet.h>
-}
-
-#include <cassert>
-#include <chrono>
-#include <iostream>
-#include <thread>
-#include "compat.h"
-#include "error.h"
-#include "file_utils.h"
-#include "inet_addr.h"
-#include "io_handler_accept.h"
-#include "io_handler_data.h"
-#include "reactor_factory.h"
-#include "reactor_runner.h"
-#include "service/backend_options.h"
-#include "scope_guard.h"
-
-namespace palo {
-
-std::atomic<uint32_t> Comm::ms_next_request_id(1);
-Comm *Comm::ms_instance = NULL;
-std::mutex Comm::ms_mutex;
-
-Comm::Comm() {
-    if (ReactorFactory::ms_reactors.size() == 0) {
-        LOG(ERROR) << "reactor_factory::initialize must be called before creating "
-                   << "rpc::comm object";
-        abort();
-    }
-    InetAddr::initialize(&m_local_addr, BackendOptions::get_localhost().c_str(), 0);
-    ReactorFactory::get_timer_reactor(m_timer_reactor);
-    m_handler_map = ReactorRunner::handler_map;
-}
-
-Comm::Comm(const char* host) {
-    if (ReactorFactory::ms_reactors.size() == 0) {
-        LOG(ERROR) << "reactor_factory::initialize must be called before creating "
-                   << "rpc::comm object";
-        abort();
-    }
-    InetAddr::initialize(&m_local_addr, host, 0);
-    ReactorFactory::get_timer_reactor(m_timer_reactor);
-    m_handler_map = ReactorRunner::handler_map;
-}
-
-Comm::~Comm() {
-    m_handler_map->decomission_all();
-    // wait for all decomissioned handlers to get purged by Reactor
-    m_handler_map->wait_for_empty();
-    // Since Comm is a singleton, this is OK
-    ReactorFactory::destroy();
-}
-
-void Comm::destroy() {
-    if (ms_instance) {
-        delete ms_instance;
-        ms_instance = 0;
-    }
-}
-
-int Comm::register_socket(int sd, const CommAddress &addr,
-                          RawSocketHandler *handler) {
-    IOHandlerRaw *io_handler = 0;
-    if (m_handler_map->checkout_handler(addr, &io_handler) == error::OK) {
-        m_handler_map->decrement_reference_count(io_handler);
-        return error::ALREADY_EXISTS;
-    }
-    assert(addr.is_inet());
-    io_handler = new IOHandlerRaw(sd, addr.inet, handler);
-    m_handler_map->insert_handler(io_handler);
-    int32_t error;
-    if ((error = io_handler->start_epolling(poll_event::READ | poll_event::WRITE)) != error::OK) {
-        delete io_handler;
-        LOG(ERROR) << "register socket to epoll failed."
-                   << "[addr=" << addr.to_str().c_str() << ", "
-                   << "socket=" << sd << ", "
-                   << "error=" << error::get_text(error) << "]";
-    }
-    return error::OK;
-}
-
-int
-Comm::connect(const CommAddress &addr, const DispatchHandlerPtr &default_handler) {
-    int sd = -1;
-    int error = m_handler_map->contains_data_handler(addr);
-    uint16_t port;
-    if (error == error::OK) {
-        return error::COMM_ALREADY_CONNECTED;
-    } else if (error != error::COMM_NOT_CONNECTED) {
-        return error;
-    }
-    while (true) {
-        if ((sd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
-            LOG(ERROR) << "create socket failed. [error=" << strerror(errno) << "]";
-            return error::COMM_SOCKET_ERROR;
-        }
-        // Get arbitray ephemeral port that won't conflict with our reserved ports
-        port = (uint16_t)(49152 + std::uniform_int_distribution<>(0, 16382)(ReactorFactory::rng));
-        m_local_addr.sin_port = htons(port);
-        // bind socket to local address
-        if ((::bind(sd, (const sockaddr *)&m_local_addr, sizeof(sockaddr_in))) < 0) {
-            if (errno == EADDRINUSE) {
-                ::close(sd);
-                continue;
-            }
-            LOG(ERROR) << "bind socket failed. [addr=" << m_local_addr.format().c_str()
-                       << ", error=" << strerror(errno) << "]";
-            return error::COMM_BIND_ERROR;
-        }
-        break;
-    }
-    return connect_socket(sd, addr, default_handler);
-}
-
-int
-Comm::connect(const CommAddress &addr, const CommAddress &local_addr,
-              const DispatchHandlerPtr &default_handler) {
-    int sd = -1;
-    int error = m_handler_map->contains_data_handler(addr);
-    assert(local_addr.is_inet());
-    if (error == error::OK) {
-        return error::COMM_ALREADY_CONNECTED;
-    } else if (error != error::COMM_NOT_CONNECTED) {
-        return error;
-    }
-    if ((sd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
-        LOG(ERROR) << "create socket failed. [error=" << strerror(errno) << "]";
-        return error::COMM_SOCKET_ERROR;
-    }
-    // bind socket to local address
-    if ((::bind(sd, (const sockaddr *)&local_addr.inet, sizeof(sockaddr_in))) < 0) {
-        LOG(ERROR) << "bind socket failed. [addr=" << local_addr.to_str().c_str() << ", "
-                   << "error=" << strerror(errno) << "]";
-        return error::COMM_BIND_ERROR;
-    }
-    return connect_socket(sd, addr, default_handler);
-}
-
-int Comm::set_alias(const InetAddr &addr, const InetAddr &alias) {
-    return m_handler_map->set_alias(addr, alias);
-}
-
-int Comm::listen(const CommAddress &addr, ConnectionHandlerFactoryPtr &chf) {
-    DispatchHandlerPtr null_handler(0);
-    return listen(addr, chf, null_handler);
-}
-
-int Comm::add_proxy(const std::string &proxy, const std::string &hostname, const InetAddr &addr) {
-    assert(ReactorFactory::proxy_master);
-    return m_handler_map->add_proxy(proxy, hostname, addr);
-}
-
-int Comm::remove_proxy(const std::string &proxy) {
-    assert(ReactorFactory::proxy_master);
-    return m_handler_map->remove_proxy(proxy);
-}
-
-bool Comm::translate_proxy(const std::string &proxy, InetAddr *addr) {
-    CommAddress proxy_addr;
-    proxy_addr.set_proxy(proxy);
-    return m_handler_map->translate_proxy_address(proxy_addr, addr);
-}
-
-void Comm::get_proxy_map(ProxyMapT &proxy_map) {
-    m_handler_map->get_proxy_map(proxy_map);
-}
-
-bool Comm::wait_for_proxy_load(Timer &timer) {
-    return m_handler_map->wait_for_proxy_map(timer);
-}
-
-int
-Comm::listen(const CommAddress &addr, ConnectionHandlerFactoryPtr &chf,
-             const DispatchHandlerPtr &default_handler) {
-    IOHandlerAccept *handler = 0;
-    int one = 1;
-    int sd = -1;
-    int32_t error = 0;
-    assert(addr.is_inet());
-    if ((sd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
-        LOG(ERROR) << "create socket failed."
-                   << "[socket=" << sd << ", error=" << strerror(errno) << "]";
-        return error::COMM_SOCKET_ERROR;
-    }
-    // Set to non-blocking
-    FileUtils::set_flags(sd, O_NONBLOCK);
-    if (setsockopt(sd, SOL_TCP, TCP_NODELAY, &one, sizeof(one)) < 0) {
-        LOG(ERROR) << "set socket TCP_NODELAY option failed."
-                   << "[socket=" << sd << ", error=" << strerror(errno) << "]";
-    }
-    if (setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)) < 0) {
-        LOG(ERROR) << "set socket SO_REUSEADDR option failed."
-                   << "[socket=" << sd << ", [error=" << strerror(errno) << "]";
-    }
-    int bind_attempts = 0;
-    while ((::bind(sd, (const sockaddr *)&addr.inet, sizeof(sockaddr_in))) < 0) {
-        if (bind_attempts == 24) {
-            LOG(ERROR) << "bind socket failed. [addr=" << addr.to_str().c_str() << ", "
-                       << "error=" << strerror(errno) << "]";
-            return error::COMM_BIND_ERROR;
-        }
-        std::this_thread::sleep_for(std::chrono::milliseconds(1));
-        bind_attempts++;
-    }
-    if (::listen(sd, 1000) < 0) {
-        LOG(ERROR) << "listen socket failed."
-                   << "[socket=" << sd << ", addr=" << addr.to_str().c_str() << ", "
-                   << "error=" << strerror(errno) << "]";
-        return error::COMM_LISTEN_ERROR;
-    }
-    handler = new IOHandlerAccept(sd, default_handler, m_handler_map, chf);
-    m_handler_map->insert_handler(handler);
-    if ((error = handler->start_epolling()) != error::OK) {
-        delete handler;
-        LOG(ERROR) << "register socket to epoll failed."
-                   << "[addr=" << addr.to_str().c_str() << ", "
-                   << "socket=" << sd << ", "
-                   << "error=" << error::get_text(error) << "]";
-    }
-    return error;
-}
-
-int Comm::send_request(const CommAddress &addr, uint32_t timeout_ms,
-                   CommBufPtr &cbuf, DispatchHandler *resp_handler) {
-    IOHandlerData *data_handler = 0;
-    int error = 0;
-    if ((error = m_handler_map->checkout_handler(addr, &data_handler)) != error::OK) {
-        LOG(WARNING) << "No connection. [addr=" << addr.to_str().c_str() << ", "
-                     << "error=" << error::get_text(error) << "]";
-        return error;
-    }
-    HT_ON_OBJ_SCOPE_EXIT(*
-        m_handler_map.get(), 
-        &HandlerMap::decrement_reference_count, 
-        data_handler);
-    return send_request(data_handler, timeout_ms, cbuf, resp_handler);
-}
-
-int Comm::send_request(IOHandlerData *data_handler, uint32_t timeout_ms,
-                       CommBufPtr &cbuf, DispatchHandler *resp_handler) {
-    cbuf->header.flags |= CommHeader::FLAGS_BIT_REQUEST;
-    if (resp_handler == 0) {
-        cbuf->header.flags |= CommHeader::FLAGS_BIT_IGNORE_RESPONSE;
-        cbuf->header.id = 0;
-    }
-    else {
-        cbuf->header.id = ms_next_request_id++;
-        if (cbuf->header.id == 0) {
-            cbuf->header.id = ms_next_request_id++;
-        }
-    }
-    cbuf->header.timeout_ms = timeout_ms;
-    cbuf->write_header_and_reset();
-    int error = data_handler->send_message(cbuf, timeout_ms, resp_handler);
-    if (error != error::OK) {
-        m_handler_map->decomission_handler(data_handler);
-    }
-
-    return error;
-}
-
-int Comm::send_response(const CommAddress &addr, CommBufPtr &cbuf) {
-    IOHandlerData *data_handler = 0;
-    int error = 0;
-    if ((error = m_handler_map->checkout_handler(addr, &data_handler)) != error::OK) {
-        LOG(ERROR) << "No connection. [addr=" << addr.to_str().c_str()  << ", "
-                   << "error=" << error::get_text(error) << "]";
-        return error;
-    }
-    HT_ON_OBJ_SCOPE_EXIT(
-        *m_handler_map.get(), 
-        &HandlerMap::decrement_reference_count, 
-        data_handler);
-    cbuf->header.flags &= CommHeader::FLAGS_MASK_REQUEST;
-    cbuf->write_header_and_reset();
-    error = data_handler->send_message(cbuf);
-    if (error != error::OK) {
-        m_handler_map->decomission_handler(data_handler);
-    }
-    return error;
-}
-
-int
-Comm::create_datagram_receive_socket(CommAddress &addr, int tos,
-                                     const DispatchHandlerPtr &dhp) {
-    IOHandlerDatagram *handler = 0;
-    int sd = -1;
-    int32_t error = 0;
-    assert(addr.is_inet());
-    if ((sd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
-        LOG(ERROR) << "create socket failed."
-                   << "[socket=" << sd << ", error=" << strerror(errno) << "]";
-        return error::COMM_SOCKET_ERROR;
-    }
-    // Set to non-blocking
-    FileUtils::set_flags(sd, O_NONBLOCK);
-    int bufsize = 4*32768;
-    if (setsockopt(sd, SOL_SOCKET, SO_SNDBUF, (char *)&bufsize, sizeof(bufsize)) < 0) {
-        LOG(ERROR) << "set socket SO_SNDBUF option failed. [error=" << strerror(errno) << "]";
-    }
-    if (setsockopt(sd, SOL_SOCKET, SO_RCVBUF, (char *)&bufsize, sizeof(bufsize)) < 0) {
-        LOG(ERROR) << "set sockopt SO_RCVBUF option failed. [error=" << strerror(errno) << "]";
-    }
-    Reactor::Priority reactor_priority {Reactor::Priority::NORMAL};
-    if (tos) {
-        int opt = tos;
-        setsockopt(sd, SOL_IP, IP_TOS, &opt, sizeof(opt));
-        opt = tos;
-        setsockopt(sd, SOL_SOCKET, SO_PRIORITY, &opt, sizeof(opt));
-        reactor_priority = Reactor::Priority::HIGH;
-    }
-    int bind_attempts = 0;
-    while ((::bind(sd, (const sockaddr *)&addr.inet, sizeof(sockaddr_in))) < 0) {
-        if (bind_attempts == 24) {
-            LOG(ERROR) << "bind socket failed. [addr=" << addr.to_str().c_str() << ", "
-                       << "error=" << strerror(errno) << "]";
-            return error::COMM_BIND_ERROR;
-        }
-        std::this_thread::sleep_for(std::chrono::milliseconds(10000));
-        bind_attempts++;
-    }
-    handler = new IOHandlerDatagram(sd, dhp, reactor_priority);
-    addr.set_inet( handler->get_address() );
-    m_handler_map->insert_handler(handler);
-    if ((error = handler->start_epolling()) != error::OK) {
-        delete handler;
-        LOG(ERROR) << "register socket to epoll failed."
-                   << "[addr=" << addr.to_str().c_str() << ", "
-                   << "socket=" << sd << ", "
-                   << "error=" << error::get_text(error) << "]";
-    }
-
-    return error;
-}
-
-int
-Comm::send_datagram(const CommAddress &addr, const CommAddress &send_addr,
-                    CommBufPtr &cbuf) {
-    IOHandlerDatagram *handler = 0;
-    int error = 0;
-    assert(addr.is_inet());
-    if ((error = m_handler_map->checkout_handler(send_addr, &handler)) != error::OK) {
-        LOG(ERROR) << "Datagram send/local address %s not registered" <<
-                   send_addr.to_str().c_str();
-        return error;
-    }
-    HT_ON_OBJ_SCOPE_EXIT(*m_handler_map.get(), &HandlerMap::decrement_reference_count, handler);
-    cbuf->header.flags |= (CommHeader::FLAGS_BIT_REQUEST |
-                           CommHeader::FLAGS_BIT_IGNORE_RESPONSE);
-    cbuf->write_header_and_reset();
-    error = handler->send_message(addr.inet, cbuf);
-    if (error != error::OK) {
-        m_handler_map->decomission_handler(handler);
-    }
-    return error;
-}
-
-int Comm::set_timer(uint32_t duration_millis, const DispatchHandlerPtr &handler) {
-    ExpireTimer timer;
-    timer.expire_time = ClockT::now() + std::chrono::milliseconds(duration_millis);
-    timer.handler = handler;
-    m_timer_reactor->add_timer(timer);
-    return error::OK;
-}
-
-int
-Comm::set_timer_absolute(ClockT::time_point expire_time, const DispatchHandlerPtr &handler) {
-    ExpireTimer timer;
-    timer.expire_time = expire_time;
-    timer.handler = handler;
-    m_timer_reactor->add_timer(timer);
-    return error::OK;
-}
-
-void Comm::cancel_timer(const DispatchHandlerPtr &handler) {
-    m_timer_reactor->cancel_timer(handler);
-}
-
-void Comm::close_socket(const CommAddress &addr) {
-    IOHandler *handler = 0;
-    IOHandlerAccept *accept_handler = 0;
-    IOHandlerData *data_handler = 0;
-    IOHandlerDatagram *datagram_handler = 0;
-    IOHandlerRaw *raw_handler = 0;
-    if (m_handler_map->checkout_handler(addr, &data_handler) == error::OK) {
-        handler = data_handler;
-    } else if (m_handler_map->checkout_handler(addr, &datagram_handler) == error::OK) {
-        handler = datagram_handler;
-    } else if (m_handler_map->checkout_handler(addr, &accept_handler) == error::OK) {
-        handler = accept_handler;
-    } else if (m_handler_map->checkout_handler(addr, &raw_handler) == error::OK) {
-        handler = raw_handler;
-    } else {
-        return;
-    }
-    HT_ON_OBJ_SCOPE_EXIT(*m_handler_map.get(), &HandlerMap::decrement_reference_count, handler);
-    m_handler_map->decomission_handler(handler);
-}
-
-void Comm::find_available_tcp_port(InetAddr &addr) {
-    int one = 1;
-    int sd = -1;
-    InetAddr check_addr;
-    uint16_t starting_port = ntohs(addr.sin_port);
-    for (size_t i=0; i<15; i++) {
-        if ((sd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
-            LOG(FATAL) << "create socket failed. [error=" << strerror(errno) << "]";
-        }
-        if (setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)) < 0) {
-            LOG(FATAL) << "set socket SO_REUSEADDR option for TCP failed."
-                       << "[error=" << strerror(errno) << "]";
-        }
-        check_addr = addr;
-        check_addr.sin_port = htons(starting_port+i);
-        if (::bind(sd, (const sockaddr *)&check_addr, sizeof(sockaddr_in)) == 0) {
-            ::close(sd);
-            addr.sin_port = check_addr.sin_port;
-            return;
-        }
-        ::close(sd);
-    }
-    LOG(FATAL) << "find available TCP port failed."
-               << "[range from " << (int)addr.sin_port << " "
-               << "to " << (int)addr.sin_port+14 << "]";
-}
-
-void Comm::find_available_udp_port(InetAddr &addr) {
-    int one = 1;
-    int sd = -1;
-    InetAddr check_addr;
-    uint16_t starting_port = ntohs(addr.sin_port);
-    for (size_t i=0; i<15; i++) {
-        if ((sd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
-            LOG(FATAL) << "create socket failed. [error=" << strerror(errno) << "]";
-        }
-        if (setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)) < 0) {
-            LOG(FATAL) << "set socket SO_REUSEADDR option for UDP failed."
-                       << "[error=" << strerror(errno) << "]";
-        }
-        check_addr = addr;
-        check_addr.sin_port = htons(starting_port+i);
-        if (::bind(sd, (const sockaddr *)&addr, sizeof(sockaddr_in)) == 0) {
-            ::close(sd);
-            addr.sin_port = check_addr.sin_port;
-            return;
-        }
-        ::close(sd);
-    }
-    LOG(FATAL) << "find available UDP port failed."
-               << "[range from " << (int)addr.sin_port << " "
-               << "to " << (int)addr.sin_port+14 << "]";
-}
-
-/**
- *  ----- Private methods -----
- */
-int
-Comm::connect_socket(int sd, const CommAddress &addr,
-                     const DispatchHandlerPtr &default_handler) {
-    IOHandlerData *handler = 0;
-    int32_t error = 0;
-    int one = 1;
-    CommAddress connectable_addr;
-    if (addr.is_proxy()) {
-        InetAddr inet_addr;
-        if (!m_handler_map->translate_proxy_address(addr, &inet_addr))
-            return error::COMM_INVALID_PROXY;
-        connectable_addr.set_inet(inet_addr);
-    }
-    else
-        connectable_addr = addr;
-    // Set to non-blocking
-    FileUtils::set_flags(sd, O_NONBLOCK);
-    if (setsockopt(sd, SOL_TCP, TCP_NODELAY, &one, sizeof(one)) < 0) {
-        LOG(ERROR) << "set socket TCP_NODELAY option failed. [error=" << strerror(errno) << "]";
-    }
-    handler = new IOHandlerData(sd, connectable_addr.inet, default_handler);
-    if (addr.is_proxy())
-        handler->set_proxy(addr.proxy);
-    m_handler_map->insert_handler(handler);
-    while (::connect(sd, (struct sockaddr *)&connectable_addr.inet, sizeof(struct sockaddr_in))
-            < 0) {
-        if (errno == EINTR) {
-            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
-            continue;
-        }
-        else if (errno == EINPROGRESS) {
-            LOG(INFO) << "socket are in progress and starting to poll. [socket=" << sd << "]";
-            error = handler->start_epolling(poll_event::READ | poll_event::WRITE);
-            if (error == error::COMM_POLL_ERROR) {
-                LOG(ERROR) << "register socket to epoll failed."
-                           << "[addr=" << connectable_addr.to_str().c_str() << ", "
-                           << "socket=" << sd << ", "
-                           << "error=" << error::get_text(error) << "]";
-                m_handler_map->remove_handler(handler);
-                delete handler;
-            }
-            return error;
-        }
-        m_handler_map->remove_handler(handler);
-        delete handler;
-        LOG(ERROR) << "connect to addr failed. [addr=" << connectable_addr.to_str().c_str() << ", "
-                   << "socket=" << sd << ", error=" << strerror(errno) << "]";
-        return error::COMM_CONNECT_ERROR;
-    }
-    error = handler->start_epolling(poll_event::READ|poll_event::WRITE);
-    if (error != error::OK) {
-        LOG(ERROR) << "register socket to epoll failed."
-                   << "[addr=" << connectable_addr.to_str().c_str() << ", "
-                   << "socket=" << sd << ", "
-                   << "error=" << error::get_text(error) << "]";
-        m_handler_map->remove_handler(handler);
-        delete handler;
-    }
-    return error;
-}
-
-} //nemespace palo
diff --git a/be/src/rpc/comm.h b/be/src/rpc/comm.h
deleted file mode 100644
index 3752d72c6bb35a..00000000000000
--- a/be/src/rpc/comm.h
+++ /dev/null
@@ -1,511 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_COMM_H
-#define BDG_PALO_BE_SRC_RPC_COMM_H
-
-#include "clock.h"
-#include "comm_address.h"
-#include "comm_buf.h"
-#include "connection_handler_factory.h"
-#include "dispatch_handler.h"
-#include "handler_map.h"
-#include "raw_socket_handler.h"
-
-#include <atomic>
-#include <mutex>
-
-namespace palo {
-
-/** @defgroup AsyncComm AsyncComm
- * Network communication library.
- * The AsyncComm module is designed for maximally efficient network
- * programming by 1) providing an asynchronous API to facilitate
- * multiprogramming, and 2) using the most efficient polling mechanism for
- * each supported system (<code>epoll</code> on Linux, <code>kqueue</code>
- * on OSX and FreeBSD, and <code>port_associate</code> on Solaris).
- * @{
- */
-
-/** Entry point to AsyncComm service.
- * There should be only one instance of this class per process and the static
- * method ReactorFactory#initialize must be called prior to constructing this
- * class in order to create the system-wide I/O reactor threads.
- */
-class Comm {
-public:
-
-    /** Creates/returns singleton instance of the Comm class.
-     * This method will construct a new instance of the Comm class if it has
-     * not already been created.  All calls to this method return a pointer
-     * to the same singleton instance of the Comm object between calls to
-     * #destroy.  The static method ReactorFactory#initialize must be called
-     * prior to calling this method for the first time, in order to create
-     * system-wide I/O reactor threads.
-     */
-    static Comm *instance() {
-        std::lock_guard<std::mutex> lock(ms_mutex);
-        if (!ms_instance)
-            ms_instance = new Comm();
-        return ms_instance;
-    }
-
-    /** Destroys singleton instance of the Comm class.
-     * This method deletes the singleton instance of the Comm class, setting
-     * the ms_instance pointer to 0.
-     */
-    static void destroy();
-
-    /// Registers an externally managed socket with comm event loop.
-    /// This function allows an application to register a socket with
-    /// the comm layer just for its the event loop.  The wire protocol
-    /// is handled entirely by the <code>handler</code> object.
-    /// @param sd Socket descriptor
-    /// @param addr Address structure for connection identification purposes
-    /// @param handler Raw connection handler
-    /// @return error::OK on success, error::ALREADY_EXISTS if <code>addr</code>
-    /// already registered with comm layer.
-    /// @throws Exception on polling error
-    int register_socket(int sd, const CommAddress &addr,
-            RawSocketHandler *handler);
-
-    /** Establishes a TCP connection and attaches a default dispatch handler.
-     * This method establishes a TCP connection to <code>addr</code>
-     * and associates it with <code>default_handler</code> as the default
-     * dispatch handler for the connection.  The two types of events that
-     * are delivered via the handler are CONNECTION_ESTABLISHED and DISCONNECT.
-     * No ERROR events will be deliverd via the handler because any errors that
-     * occur on the connection will result in the connection being closed,
-     * resulting in a DISCONNECT event only.  If this method fails and returns
-     * an error code, the connection will not have been setup and
-     * <code>default_handler</code> will not have been installed.
-     * The default dispatch handler, <code>default_handler</code>, will never be
-     * called back via the calling thread.  It will be called back from a
-     * reactor thread.  Because reactor threads are used to service I/O
-     * events on many different sockets, the default dispatch handler should
-     * return quickly from the callback.  When calling back into the default
-     * dispatch handler, the calling reactor thread does not hold any locks
-     * so the default dispatch handler callback may safely callback into the
-     * Comm object (e.g. #send_response).  Upon successful completion,
-     * <code>addr</code> can be used to subsequently refer to the connection.
-     * @param addr Address to connect to
-     * @param default_handler Smart pointer to default dispatch handler
-     * @return error::OK on success, or error::COMM_ALREADY_CONNECTED,
-     * error::COMM_SOCKET_ERROR, error::COMM_BIND_ERROR, or one of the
-     * errors returned by #connect_socket on error.
-     */
-    int connect(const CommAddress &addr, const DispatchHandlerPtr &default_handler);
-
-    /** Establishes a locally bound TCP connection and attaches a default
-     * dispatch handler.  Establishes a TCP connection to
-     * <code>addr</code> argument, binding the local side of the connection to
-     * <code>local_addr</code>.  A default dispatch handler is associated with the
-     * connection to receive CONNECTION_ESTABLISHED and DISCONNECT events.
-     * No ERROR events will be deliverd via the handler because any errors that
-     * occur on the connection will result in the connection being closed,
-     * resulting in a DISCONNECT event only.  If this method fails and returns
-     * an error code, the connection will not have been setup and
-     * <code>default_handler</code> will not have been installed.
-     * The default dispatch handler, <code>default_handler</code>, will never be
-     * called back via the calling thread.  It will be called back from a
-     * reactor thread.  Because reactor threads are used to service I/O
-     * events on many different sockets, the default dispatch handler should
-     * return quickly from the callback.  When calling back into the default
-     * dispatch handler, the calling reactor thread does not hold any locks
-     * so the default dispatch handler callback may safely callback into the
-     * Comm object (e.g. #send_response).  Upon successful completion,
-     * <code>addr</code> can be used to subsequently refer to the connection.
-     * @param addr address to connect to
-     * @param local_addr Local address to bind to
-     * @param default_handler smart pointer to default dispatch handler
-     * @return error::OK on success, or error::COMM_ALREADY_CONNECTED,
-     * error::COMM_SOCKET_ERROR, error::COMM_BIND_ERROR, or one of the
-     * errors returned by #connect_socket on error.
-     */
-    int connect(const CommAddress &addr, const CommAddress &local_addr,
-            const DispatchHandlerPtr &default_handler);
-
-    /** Sets an alias for a TCP connection.
-     * RangeServers listen on a well-known port defined by the
-     * <code>palo.RangeServer.Port</code> configuration property
-     * (default = 15865).  However, RangeServers connect to the master using
-     * an ephemeral port due to a bind conflict with its listen socket.  So that
-     * the Master can refer to the RangeServer using the well-known port, an
-     * alias address can be registered and subsequently used to reference the
-     * connection.
-     * @param addr Connection address (remote address)
-     * @param alias Alias address
-     * @return error::OK on success, or error::COMM_CONFLICTING_ADDRESS if
-     * alias is already registered, or error::COMM_NOT_CONNECTED if
-     * <code>addr</code> does not refer to an established connection.
-     */
-    int set_alias(const InetAddr &addr, const InetAddr &alias);
-
-    /** Adds a proxy name for a TCP connection.
-     * palo uses <i>proxy names</i> (e.g. "rs1") to refer to servers so
-     * that the system can continue to operate properly even when servers are
-     * reassigned IP addresses, such as starting and stopping palo running
-     * on EBS volumes in AWS EC2.  This method adds a proxy name for the
-     * connection identified by <code>addr</code> and pushes the new mapping
-     * to the remote end of all active connections.
-     * @note This method will assert if it is not called by the proxy master.
-     * @param proxy Proxy name
-     * @param hostname Hostname of remote machine
-     * @param addr Connection address (remote address)
-     * @return error::OK on success, or one of the errors returned by
-     * HandlerMap::propagate_proxy_map
-     */
-    int add_proxy(const std::string &proxy, const std::string &hostname, const InetAddr &addr);
-
-    /** Removes a proxy name for a TCP connection.
-     * palo uses <i>proxy names</i> (e.g. "rs1") to refer to servers so
-     * that the system can continue to operate properly even when servers are
-     * reassigned IP addresses, such as starting and stopping palo running
-     * on EBS volumes in AWS EC2.  This method removes the proxy name
-     * <code>proxy</code> locally and from the remote end of all active
-     * connections.
-     * @note This method will assert if it is not called by the proxy master.
-     * @param proxy Proxy name to remove
-     */
-    int remove_proxy(const std::string &proxy);
-
-    /** Translates a proxy name to an IP address.
-     * palo uses <i>proxy names</i> (e.g. "rs1") to refer to servers so
-     * that the system can continue to operate properly even when servers are
-     * reassigned IP addresses, such as starting and stopping palo running
-     * on EBS volumes in AWS EC2.  This method translates <code>proxy</code>
-     * to its associated address that was registered with a prior call to
-     * add_proxy().  If <code>addr</code> is NULL, then the method just checks
-     * to see if the proxy name has been registered and represents a valid
-     * mapping.
-     * @param proxy Proxy name to translate
-     * @param addr Address of object to hold translated address
-     * @return <i>true</i> if address was translated or could be translated,
-     * <i>false</i> otherwise
-     */
-    bool translate_proxy(const std::string &proxy, InetAddr *addr);
-
-    /** Returns the proxy map.
-     * @param proxy_map Reference to return proxy map
-     */
-    void get_proxy_map(ProxyMapT &proxy_map);
-
-    /** Waits until a CommHeader::FLAGS_BIT_PROXY_MAP_UPDATE message is
-     * received from the proxy master
-     *
-     * @param timer Expiration timer
-     * @return <i>true</i> if successful, <i>false</i> if timer expired
-     */
-    bool wait_for_proxy_load(Timer &timer);
-
-    /** Creates listen (accept) socket on <code>addr</code>.
-     * New connections will be assigned dispatch handlers by
-     * calling the ConnectionHandlerFactory::get_instance method of the handler
-     * factory pointed to by <code>chf</code>.  Since no default dispatch
-     * handler is supplied for this listen (accept) socket,
-     * Event::CONNECTION_ESTABLISHED events are logged, but not delivered to the
-     * application.
-     * @param addr IP address and port on which to listen for connections
-     * @param chf Smart pointer to connection handler factory
-     * @throws Exception Code set to error::COMM_SOCKET_ERROR,
-     * error::COMM_BIND_ERROR, error::COMM_LISTEN_ERROR,
-     * error::COMM_SEND_ERROR, or error::COMM_RECEIVE_ERROR
-     */
-    int listen(const CommAddress &addr, ConnectionHandlerFactoryPtr &chf);
-
-    /** Creates listen (accept) socket on <code>addr</code> and attaches a
-     * default dispatch handler.
-     * New connections will be assigned dispatch handlers by
-     * calling the ConnectionHandlerFactory::get_instance method of the handler
-     * factory pointed to by <code>chf</code>.  <code>default_handler</code>
-     * is registered as the default dispatch handler for the newly created
-     * listen (accept) socket and Event::CONNECTION_ESTABLISHED events will be
-     * delivered to the application via this handler.
-     * @param addr IP address and port on which to listen for connections
-     * @param chf Smart pointer to connection handler factory
-     * @param default_handler Smart pointer to default dispatch handler
-     * @throws Exception Code set to error::COMM_SOCKET_ERROR,
-     * error::COMM_BIND_ERROR, error::COMM_LISTEN_ERROR,
-     * error::COMM_SEND_ERROR, or error::COMM_RECEIVE_ERROR
-     */
-    int listen(const CommAddress &addr, ConnectionHandlerFactoryPtr &chf,
-            const DispatchHandlerPtr &default_handler);
-
-    /** Sends a request message over a connection, expecting a response.  The
-     * connection is specified by <code>addr</code> which is the remote end of
-     * the connection.  The request message to send is encapsulated in
-     * <code>cbuf</code> (see CommBuf) and should start with a valid header.
-     * The* <code>response_handler</code> argument will get called
-     * back with a response MESSAGE event, a TIMEOUT event if no response is
-     * received within the number of seconds specified by the timeout argument,
-     * or an ERROR event (see below).  The following errors may be returned by
-     * this method:
-     *
-     *   - error::COMM_NOT_CONNECTED
-     *   - error::COMM_BROKEN_CONNECTION
-     *
-     * A return value of error::COMM_NOT_CONNECTED implies that
-     * <code>response_handler</code> was not installed and an Event::ERROR event
-     * will <b>not</b> be delivered.  A return value of
-     * error::COMM_BROKEN_CONNECTION implies that <code>response_handler</code>
-     * was installed and an Event::ERROR event will be delivered to the
-     * application.  If the server at the other end of the connection uses an
-     * ApplicationQueue to carry out requests, then the gid field in the header
-     * can be used to serialize request execution.  For example, the following
-     * code serializes requests to the same file descriptor:
-     * <pre>
-     * HeaderBuilder hbuilder(Header::PROTOCOL_DFSBROKER);
-     * hbuilder.set_group_id(fd);
-     * CommBuf *cbuf = new CommBuf(hbuilder, 14);
-     * cbuf->AppendShort(COMMAND_READ);
-     * cbuf->AppendInt(fd);
-     * cbuf->AppendLong(amount);
-     * </pre>
-     *
-     * This method locates the I/O handler associated with <code>addr</code>
-     * and then calls the private method
-     * @ref private_send_request "send_request" to carry out the send request.
-     * If an error is encountered while trying to send the request, the
-     * associated handler will be decomissioned.
-     *
-     * @param addr Connection address (remote address)
-     * @param timeout_ms Number of milliseconds to wait before delivering
-     *        TIMEOUT event
-     * @param cbuf Request message to send (see CommBuf)
-     * @param response_handler Pointer to response handler associated with the
-     *        request
-     * @return error::OK on success or error code on failure (see above)
-     */
-    int send_request(const CommAddress &addr, uint32_t timeout_ms,
-            CommBufPtr &cbuf, DispatchHandler *response_handler);
-
-    /** Sends a response message back over a connection.  It is assumed that the
-     * CommHeader#id field of the header matches the id field of the request for
-     * which this is a response to.  The connection is specified by the
-     * <code>addr</code> which is the remote end of the connection.  The
-     * response message to send is encapsulated in the cbuf (see CommBuf) object
-     * and should start with a valid header.  The following code snippet
-     * illustrates how a simple response message gets created to send back to a
-     * client in response to a request message:
-     *
-     * <pre>
-     * CommHeader header;
-     * header.initialize_from_request_header(request_event->header);
-     * CommBufPtr cbp(new CommBuf(header, 4));
-     * cbp->append_i32(error::OK);
-     * </pre>
-     *
-     * If an error is encountered while trying to send the response, the
-     * associated handler will be decomissioned.
-     * @param addr Connection address (remote address)
-     * @param cbuf Response message to send (must have valid header with
-     *        matching request id)
-     * @return error::OK on success or error code on failure
-     */
-    int send_response(const CommAddress &addr, CommBufPtr &cbuf);
-
-    /** Creates a socket for receiving datagrams and attaches <code>handler</code>
-     * as the default dispatch handler.  This socket can
-     * also be used for sending datagrams.  The events delivered for this socket
-     * consist of either MESSAGE events or ERROR events.  In setting up the
-     * datagram (UDP) socket, the following setup is performed:
-     *
-     *   - <code>O_NONBLOCK</code> option is set on socket
-     *   - Socket send and receive buffers are set to <code>4*32768</code> bytes
-     *   - If <code>tos</code> is non-zero, <code>IP_TOS</code> and
-     *     <code>SO_PRIORITY</code> options are set using <code>tos</code> as
-     *     the argument (Linux only)
-     *   - If <code>tos</code> is non-zero, <code>IP_TOS</code> option is set
-     *     with <code>IPTOS_LOWDELAY</code> as the argument (Apple, Sun, and
-     *     FreeBSD)
-     *
-     * @param addr pointer to address structure
-     * @param tos TOS value to set on IP packet
-     * @param handler Default dispatch handler for socket
-     * @throws Exception Code set to error::COMM_SOCKET_ERROR or
-     * error::COMM_BIND_ERROR.
-     */
-    int create_datagram_receive_socket(CommAddress &addr, int tos,
-            const DispatchHandlerPtr &handler);
-
-    /** Sends a datagram to a remote address.  The remote address is specified
-     * by <code>addr</code> and the local socket address to send it from is
-     * specified by <code>send_addr</code>.  The <code>send_addr</code> argument
-     * must refer to a socket that was created with a call to
-     * #create_datagram_receive_socket.  If an error is encountered while trying
-     * to send the datagram, the associated handler will be decomissioned.
-     * @param addr Remote address to send datagram to
-     * @param send_addr Local socket address to send from
-     * @param cbuf Datagram message with valid header
-     * @return error::OK on success or error code on failure
-     */
-    int send_datagram(const CommAddress &addr, const CommAddress &send_addr,
-            CommBufPtr &cbuf);
-
-    /** Sets a timer for <code>duration_millis</code> milliseconds in the
-     * future.
-     * This method will cause a Event::TIMER event to be generated after
-     * <code>duration_millis</code> milliseconds have elapsed.
-     * <code>handler</code> is the dispatch handler registered with the timer
-     * to receive the Event::TIMER event.  This timer registration is
-     * <i>one shot</i>.  To set up a periodic timer event, the timer must
-     * be re-registered each time it is handled.
-     * @note This method sets a smart pointer to <code>handler</code>, so if
-     * the reference count to <code>handler</code> is zero when this method
-     * is called, it will be deleted after the event is delivered.  To prevent
-     * this from happening, the caller should hold a smart pointer
-     * (DispatchHandlerPtr) to <code>handler</code>.
-     * @param duration_millis Number of milliseconds to wait
-     * @param handler Dispatch handler to receive Event::TIMER event upon
-     *        expiration
-     * @return error::OK
-     */
-    int set_timer(uint32_t duration_millis, const DispatchHandlerPtr &handler);
-
-    /** Sets a timer for absolute time <code>expire_time</code>.
-     * This method will cause a Event::TIMER event to be generated at the
-     * absolute time specified by <code>expire_time</code>.
-     * <code>handler</code> is the dispatch handler registered with the
-     * timer to receive Event::TIMER events.  This timer registration is
-     * <i>one shot</i>.  To set up a periodic timer event, the timer must
-     * be re-registered each time it is handled.
-     * @note This method sets a smart pointer to <code>handler</code>, so if
-     * the reference count to <code>handler</code> is zero when this method
-     * is called, it will be deleted after the event is delivered.  To prevent
-     * this from happening, the caller should hold a smart pointer
-     * (DispatchHandlerPtr) to <code>handler</code>.
-     * @param expire_time Absolute expiration time
-     * @param handler Dispatch handler to receive Event::TIMER event upon
-     *        expiration
-     * @return error::OK
-     */
-    int set_timer_absolute(ClockT::time_point expire_time, const DispatchHandlerPtr &handler);
-
-    /** Cancels all scheduled timers registered with the dispatch handler
-     * <code>handler</code>.
-     *
-     * @param handler Dispatch handler for which all scheduled timer should
-     *        be cancelled
-     */
-    void cancel_timer(const DispatchHandlerPtr &handler);
-
-    /** Closes the socket specified by the addr argument.  This has
-     * the effect of closing the connection and removing it from the event
-     * demultiplexer (e.g epoll).  It also causes all outstanding requests on
-     * the connection to get purged.
-     * @param addr Connection or accept or datagram address
-     */
-    void close_socket(const CommAddress &addr);
-
-    /** Finds an unused TCP port starting from <code>addr</code>.
-     * This method iterates through 15 ports starting with
-     * <code>addr.sin_port</code> until it is able to bind to
-     * one.  If an available port is found, <code>addr.sin_port</code>
-     * will be set to the available port, otherwise the method will assert.
-     * @param addr Starting address template
-     */
-    void find_available_tcp_port(InetAddr &addr);
-
-    /** Finds an unused UDP port starting from <code>addr</code>.
-     * This method iterates through 15 ports starting with
-     * <code>addr.sin_port</code> until it is able to bind to
-     * one.  If an available port is found, <code>addr.sin_port</code>
-     * will be set to the available port, otherwise the method will assert.
-     * @param addr Starting address template
-     */
-    void find_available_udp_port(InetAddr &addr);
-
-private:
-
-    /** Private constructor (prevent non-singleton usage). */
-    Comm();
-    // used for test
-    Comm(const char* host);
-
-    /** Destructor */
-    ~Comm();
-
-    /** Sends a request message over a connection.
-     * @anchor private_send_request
-     * This method sets the CommHeader::FLAGS_BIT_REQUEST bit of the flags
-     * field of <code>cbuf->header</code>.  If <code>response_handler</code> is
-     * 0, then the CommHeader::FLAGS_BIT_IGNORE_RESPONSE is also set.  The
-     * CommHeader#id field of <code>cbuf->header</code> is assigned by
-     * incrementing #ms_next_request_id and the CommHeader#timeout_ms field of
-     * <code>cbuf->header</code> is set to <code>timeout_ms</code>.  Finally,
-     * <code>cbuf->write_header_and_reset()</code> is called and the message
-     * is sent via <code>data_handler</code>.
-     * @param data_handler I/O handler for connection.
-     * @param timeout_ms Number of milliseconds to wait before delivering
-     *        TIMEOUT event
-     * @param cbuf Request message to send (see CommBuf)
-     * @param response_handler Pointer to response handler associated with the
-     *        request
-     * @return error::OK on success or error code on failure
-     *         (<code>response_handler</code> is only installed on error::OK
-     *          or error::COMM_BROKEN_CONNECTION).
-     */
-    int send_request(IOHandlerData *data_handler, uint32_t timeout_ms,
-            CommBufPtr &cbuf, DispatchHandler *response_handler);
-
-    /** Creates a TCP socket connection.
-     * This method is called by the #connect methods to setup a socket,
-     * connect to a remote address, and attach a data handler.
-     * If <code>addr</code> is of type CommAddress::PROXY then it is
-     * translated.  Then the socket is setup as follows:
-     *
-     *   - <code>O_NONBLOCK</code> option is set
-     *   - <code>TCP_NODELAY</code> option is set (Linux and Sun)
-     *   - <code>SO_NOSIGPIPE</code> option is set (Apple and FreeBSD)
-     *
-     * Then a data (TCP) handler is created for the socket and added to
-     * the handler map.  Finally <code>connect</code> is called and
-     * polling is started on the socket.
-     * @param sd Socket descriptor
-     * @param addr Remote address to connect to
-     * @param default_handler Default dispatch handler
-     * @return error::OK on success, or one of error::COMM_INVALID_PROXY,
-     * error::COMM_CONNECT_ERROR, error::COMM_POLL_ERROR,
-     * error::COMM_SEND_ERROR, error::COMM_RECEIVE_ERROR on error.
-     */
-    int connect_socket(int sd, const CommAddress &addr,
-            const DispatchHandlerPtr &default_handler);
-
-    /// Pointer to singleton instance of this class
-    static Comm *ms_instance;
-
-    /// Atomic integer used for assinging request IDs
-    static std::atomic<uint32_t> ms_next_request_id;
-
-    /// %Mutex for serializing access to #ms_instance
-    static std::mutex ms_mutex;
-
-    /// Pointer to IOHandler map    
-    HandlerMapPtr m_handler_map;
-
-    /// Pointer to dedicated reactor for handling timer events
-    ReactorPtr m_timer_reactor;
-
-    /// Local address initialized to primary interface and empty port
-    InetAddr m_local_addr;
-};
-
-} //namespace palo
-
-#endif //BDG_PALO_BE_SRC_RPC_COMM_H
diff --git a/be/src/rpc/comm_address.cpp b/be/src/rpc/comm_address.cpp
deleted file mode 100644
index 2f3fb5766eceb5..00000000000000
--- a/be/src/rpc/comm_address.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "comm_address.h"
-
-namespace palo {
-
-std::string CommAddress::to_str() const {
-    if (m_type == PROXY) {
-        return proxy;
-    } else if (m_type == INET) {
-        return InetAddr::format(inet);
-    }
-    return "[NULL]";
-
-}
-
-} //namespace palo
diff --git a/be/src/rpc/comm_address.h b/be/src/rpc/comm_address.h
deleted file mode 100644
index fecef19bd3990c..00000000000000
--- a/be/src/rpc/comm_address.h
+++ /dev/null
@@ -1,229 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_COMM_ADDRESS_H
-#define BDG_PALO_BE_SRC_RPC_COMM_ADDRESS_H
-
-#include "inet_addr.h"
-#include "common/logging.h"
-#include "util.h"
-#include <functional>
-#include <set>
-#include <unordered_map>
-#include <assert.h>
-
-namespace palo {
-
-/** Address abstraction to hold either proxy name or IPv4:port address.
- * Proxy names are string mnemonics referring to IPv4:port addresses and are
- * defined or modified via Comm#add_proxy method.  Most Comm methods that
- * operate on an address are abstracted to accept either a proxy name
- * (translated internally) or an IPv4:port address.  The CommAddress class is
- * used to facilitate that abstraction.
- */
-class CommAddress {
-public:
-
-    /** Enumeration for address type.
-    */
-    enum AddressType { 
-        NONE = 0, /**< Uninitialized */
-        PROXY,  /**< Proxy name type */
-        INET    /**< IPv4:port address type */
-    };
-
-    /** Constructs an uninitialized CommAddress object.
-    */
-    CommAddress() : m_type(NONE) { }
-
-    /** Constructs a CommAddress object of type CommAddress#INET.
-     * @param addr IPv4:port address
-     */
-    CommAddress(const sockaddr_in addr) 
-        : m_type(INET) { 
-        inet = addr; 
-    }
-
-    /** Sets address type to CommAddress#PROXY and #proxy name to
-     * <code>p</code>.
-     * @param str proxy name
-     */
-    void set_proxy(const std::string &str) { 
-        proxy = str; 
-        m_type = PROXY; 
-    }
-
-    /** Sets address type to CommAddress#INET and #inet value to
-     * <code>addr</code>.
-     * @param addr IPv4:port address
-     */
-    void set_inet(sockaddr_in addr) { 
-        inet = addr; 
-        m_type = INET; 
-    }
-
-    /** Sets address type to CommAddress#INET and #inet value to
-     * <code>addr</code>.
-     * @param addr IPv4:port address
-     * @return reference to this CommAddress object
-     */
-    CommAddress &operator=(sockaddr_in addr) { 
-        inet = addr; 
-        m_type = INET; 
-        return *this; 
-    }
-
-    /** Equality operator.
-     * If address is of type CommAddress#PROXY,
-     * <code>std::string::compare</code> is used to compare #proxy members.  If
-     * address is of type CommAddress#INET, InetAddr#operator== is used to
-     * compare #inet members.  If both addresses are of type CommAddress#NONE,
-     * <i>true</i> is returned.  <i>false</i> is returned if the addresses
-     * are of different types.
-     * @param other object to compare to
-     * @return <i>true</i> if addresses are equal, <i>false</i> otherwise
-     */
-    bool operator==(const CommAddress &other) const {
-        if (m_type != other.m_type) {
-            return false;
-        }
-        if (m_type == PROXY) {
-            return proxy.compare(other.proxy) == 0;
-        } else if (m_type == INET) {
-            return inet == other.inet;
-        }
-        return true;
-    }
-
-    /** Inequality operator.
-     * Returns the exact opposite of what is returned by #operator==
-     * @param other object to compare to
-     * @return <i>true</i> if addresses are not equal, <i>false</i> otherwise
-     */
-    bool operator!=(const CommAddress &other) const {
-        return !(*this == other);
-    }
-
-    /** Less than operator.
-     * If address types differ, then an integer less than comparison of the
-     * AddressType values (#m_type) is returned.  If addresses are of type
-     * CommAddress#PROXY, then string less than comparison of the #proxy
-     * members is returned.  If addresses are of type CommAddress#INET then
-     * Inet#operator< is used to compare the IP addresses, and if addresses are
-     * of type CommAddress#NONE, <i>false</i> is returned.
-     * @param other object on right-hand side of comparison
-     * @return <i>true</i> if address is less than <code>other</code>,
-     * <i>false</i> otherwise
-     */
-    bool operator<(const CommAddress &other) const {
-        if (m_type != other.m_type) {
-            return m_type < other.m_type;
-        }
-        if (m_type == PROXY) {
-            return proxy < other.proxy;
-        } else if (m_type == INET) {
-            return inet < other.inet;
-        }
-        assert(m_type == NONE && other.m_type == NONE);
-        return false;
-    }
-
-    /** Returns <i>true</i> if address is of type CommAddress#PROXY.
-     * @return <i>true</i> if address is of type CommAddress#PROXY,
-     * <i>false</i> otherwise
-     */
-    bool is_proxy() const { return m_type == PROXY; }
-
-    /** Returns <i>true</i> if address is of type CommAddress#INET.
-     * @return <i>true</i> if address is of type CommAddress#INET, <i>false</i>
-     * otherwise
-     */
-    bool is_inet() const { 
-        return m_type == INET; 
-    }
-
-    /** Returns <i>true</i> if address has been initialized.
-     * @return <i>true</i> if address is of type CommAddress#PROXY or
-     * CommAddress#INET, <i>false</i> otherwise
-     */
-    bool is_set() const { 
-        return m_type == PROXY || m_type == INET; 
-    }
-
-    /** Clears address to uninitialized state.
-     * Sets address type to CommAddress#NONE
-     */
-    void clear() { 
-        proxy = ""; 
-        m_type = NONE; 
-    }
-
-    /** Returns string representation of address.
-     * If address is of type CommAddress#PROXY, the #proxy is returned.  If
-     * address is of type CommAddress#INET, InetAddr#format is used to return a
-     * string representation of #inet.  If address is of type CommAddress#NONE,
-     * the string "[NULL]" is returned.
-     * @return string representation of address
-     */
-    std::string to_str() const;
-
-    std::string proxy;   //!< Proxy name
-
-    InetAddr inet;  //!< IPv4:port address
-
-private:
-    int32_t m_type; //!< Address type
-};
-
-/** Hash function (functor) for CommAddress objets.
- * This class is defined for use with STL template classes that require a
- * hash functor (e.g. <code>std::unordered_map</code>).
- */
-class CommAddressHash {
-public:
-/** Parenthesis operator with a single CommAddress parameter.
- * This method returns the hash value for the object specified in the
- * <code>addr</code> parameter.  If the address type is CommAddress#INET,
- * then the hash code is computed as the bitwise exclusive OR of the IP
- * address and the port.  If the address is of type CommAddress#PROXY, then
- * the hash code is computed with <code>__gnu_cxx::hash<const char *></code>.
- * Otherwise the hash value is 0.
- * @return hash value
- */
-    size_t operator () (const CommAddress &addr) const {
-        if (addr.is_inet()) {
-            return (size_t)(addr.inet.sin_addr.s_addr ^ addr.inet.sin_port);
-        }
-        else if (addr.is_proxy()) {
-            return std::hash<std::string>()(addr.proxy);
-        }
-        return 0;
-    }
-};
-
-/// Parameterized hash map for mapping CommAddress to arbitrary type.
-template<typename TypeT, typename addr = CommAddress>
-class CommAddressMap : public std::unordered_map<addr, TypeT, CommAddressHash> {
-};
-
-/// Set of CommAddress objects
-typedef std::set<CommAddress> CommAddressSet;
-
-} // namespace palo
-#endif //BDG_PALO_BE_SRC_RPC_COMM_ADDRESS_H
diff --git a/be/src/rpc/comm_buf.h b/be/src/rpc/comm_buf.h
deleted file mode 100644
index 1c93c494c47ac7..00000000000000
--- a/be/src/rpc/comm_buf.h
+++ /dev/null
@@ -1,307 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_COMM_BUF_H
-#define BDG_PALO_BE_SRC_RPC_COMM_BUF_H
-
-#include "comm_header.h"
-#include "byte_string.h"
-#include "inet_addr.h"
-#include "common/logging.h"
-#include "serialization.h"
-#include "static_buffer.h"
-
-#include <boost/shared_array.hpp>
-#include <memory>
-#include <string>
-
-namespace palo {
-
-/** Message buffer for holding data to be transmitted over a network.
- * The CommBuf class contains a primary buffer and an extended buffer along
- * with buffer pointers to keep track of how much data has been written into
- * the buffers. These pointers are managed by the IOHandler while the buffer
- * is being transmitted. The following example illustrates how to build a
- * request message using the CommBuf.  
- *
- * <pre>
- *   CommHeader header(COMMAND_FETCH_SCANBLOCK);
- *   header.gid = scanner_id;
- *   CommBuf *cbuf = new CommBuf(header, 4);
- *   cbuf->append_i32(scanner_id);
- * </pre>
- *
- * The following is a real world example of a CommBuf being used
- * to send back a response from a read request.
- *
- * <pre>
- *   CommHeader header;
- *   header.initialize_from_request_header(m_event->header);
- *   CommBufPtr cbp(new CommBuf( header, 10, ext));
- *   cbp->append_i32(error::OK);
- *   cbp->append_i16(moreflag);
- *   cbp->append_i32(id);
- *   error = m_comm->send_response(m_event->addr, cbp);
- * </pre>
- *
- */
-class CommBuf {
-public:
-    /** Constructor.  This constructor initializes the CommBuf object by
-     * allocating a primary buffer of length len and writing the header into it.
-     * The internal pointer into the primary buffer is positioned to
-     * just after the header.
-     * @param hdr Comm header
-     * @param len Length of the primary buffer to allocate
-     */
-    CommBuf(CommHeader &hdr, uint32_t len = 0) : header(hdr), ext_ptr(0) {
-        len += header.encoded_length();
-        data.set(new uint8_t[len], len, true);
-        data_ptr = data.base + header.encoded_length();
-        header.set_total_length(len);
-    }
-
-    /** Constructor. This constructor initializes the CommBuf object by
-     * allocating a primary buffer of length len and writing the header into it.
-     * It also sets the extended buffer to ext and takes ownership of it.
-     * The total length written into the header is len plus ext.size.  The
-     * internal pointer into the primary buffer is positioned to just after
-     * the header.
-     * @param hdr Comm header
-     * @param len Length of the primary buffer to allocate
-     * @param buffer Extended buffer
-     */
-    CommBuf(CommHeader &hdr, uint32_t len, StaticBuffer &buffer)
-        : ext(buffer), header(hdr) {
-            len += header.encoded_length();
-            data.set(new uint8_t[len], len, true);
-            data_ptr = data.base + header.encoded_length();
-            header.set_total_length(len+buffer.size);
-            ext_ptr = ext.base;
-        }
-
-    /** Constructor. This constructor initializes the CommBuf object by
-     * allocating a primary buffer of length len and writing the header into it.
-     * It also sets the extended buffer to the buffer pointed to by ext_buffer.
-     * The total length written into the header is len plus ext_len.  The
-     * internal pointer into the primary buffer is positioned to just after
-     * the header.
-     * @param hdr Comm header
-     * @param len Length of the primary buffer to allocate
-     * @param ext_buffer Shared array pointer to extended buffer
-     * @param ext_len Length of valid data in ext_buffer
-     */
-    CommBuf(CommHeader &hdr, uint32_t len,
-            boost::shared_array<uint8_t> &ext_buffer, uint32_t ext_len) :
-        header(hdr), ext_shared_array(ext_buffer) {
-            len += header.encoded_length();
-            data.set(new uint8_t[len], len, true);
-            data_ptr = data.base + header.encoded_length();
-            ext.base = ext_shared_array.get();
-            ext.size = ext_len;
-            ext.own = false;
-            header.set_total_length(len+ext_len);
-            ext_ptr = ext.base;
-        }
-
-    ~CommBuf() { }
-
-    /** Encodes the header at the beginning of the primary buffer.
-     * This method resets the primary and extended data pointers to point to the
-     * beginning of their respective buffers.  The AsyncComm layer
-     * uses these pointers to track how much data has been sent and
-     * what is remaining to be sent.
-     */
-    void write_header_and_reset() {
-        uint8_t *buf = data.base;
-        assert((data_ptr-data.base) == (int)data.size || data_ptr == data.base);
-        header.encode(&buf);
-        data_ptr = data.base;
-        ext_ptr = ext.base;
-    }
-
-    /** Returns the primary buffer internal data pointer
-    */
-    void* get_data_ptr() { 
-        return data_ptr; 
-    }
-
-    // get user data ptr and size
-    void get_user_data(const uint8_t** ptr, uint32_t* size) {
-        *ptr = (const uint8_t*)data.base + header.encoded_length();
-        *size = header.total_len - header.encoded_length() - ext.size;
-    }
-
-    /** Returns address of the primary buffer internal data pointer
-    */
-    uint8_t** get_data_ptr_address() { 
-        return &data_ptr; 
-    }
-
-    /** Advance the primary buffer internal data pointer by <code>len</code>
-     * bytes
-     * @param len the number of bytes to advance the pointer by
-     * @return returns the advanced internal data pointer
-     */
-    void* advance_data_ptr(size_t len) { 
-        data_ptr += len; 
-        return data_ptr; 
-    }
-
-    /** Appends a boolean value to the primary buffer.  After appending, this
-     * method advances the primary buffer internal data pointer by 1
-     * @param bval Boolean value to append to primary buffer
-     */
-    void append_bool(bool bval) { 
-        serialization::encode_bool(&data_ptr, bval);
-    }
-
-    /** Appends a byte of data to the primary buffer.  After appending, this
-     * method advances the primary buffer internal data pointer by 1
-     * @param bval byte value to append into buffer
-     */
-    void append_byte(uint8_t bval) { 
-        *data_ptr++ = bval; 
-    }
-
-    /** Appends a sequence of bytes to the primary buffer.  After appending,
-     * this method advances the primary buffer internal data pointer by the
-     * number of bytes appended
-     * @param bytes Starting address of byte sequence
-     * @param len Number of bytes in sequence
-     */
-    void append_bytes(const uint8_t *bytes, uint32_t len) {
-        memcpy(data_ptr, bytes, len);
-        data_ptr += len;
-    }
-
-    /** Appends a c-style string to the primary buffer.  A string is encoded
-     * as a 16-bit length, followed by the characters, followed by
-     * a terminating '\\0'.
-     *
-     * @param str c-style string to append
-     * @see serialization::encode_str16
-     */
-    void append_str16(const char *str) {
-        serialization::encode_str16(&data_ptr, str);
-    }
-
-    /**
-     * Appends a std::string to the primary buffer.  A string is encoded as
-     * a 16-bit length, followed by the characters, followed by
-     * a terminating '\\0'.
-     *
-     * @param str std string to append
-     * @see serialization::encode_str16
-     */
-    void append_str16(const std::string &str) {
-        serialization::encode_str16(&data_ptr, str);
-    }
-
-    /**
-     * Appends a 16-bit integer to the primary buffer.  The integer is encoded
-     * in little endian order and the primary buffer internal data pointer is
-     * advanced to the position immediately following the encoded integer.
-     * @param sval Two-byte short integer to append into buffer
-     */
-    void append_i16(uint16_t sval) {
-        serialization::encode_i16(&data_ptr, sval);
-    }
-
-    /** Appends a 32-bit integer to the primary buffer.  The integer is encoded
-     * in little endian order and the primary buffer internal data pointer is
-     * advanced to the position immediately following the encoded integer.
-     * @param ival Four-byte integer value to append into buffer
-     */
-    void append_i32(uint32_t ival) {
-        serialization::encode_i32(&data_ptr, ival);
-    }
-
-    /** Appends a 64-bit integer to the primary buffer.  The integer is encoded
-     * in little endian order and the primary buffer pointer is advanced
-     * to the position immediately following the encoded integer.
-     * @param lval Eight-byte long integer value to append into buffer
-     */
-    void append_i64(uint64_t lval) {
-        serialization::encode_i64(&data_ptr, lval);
-    }
-
-    /** Appends a c-style string to the primary buffer.  A string is encoded
-     * as a vint64 length, followed by the characters, followed by
-     * a terminating '\\0'.
-     *
-     * @param str C-style string to append
-     * @see serialization::encode_vstr
-     */
-    void append_vstr(const char *str) {
-        serialization::encode_vstr(&data_ptr, str);
-    }
-
-    /** Appends a std::string to the primary buffer.  A string is encoded as
-     * a vint64 length, followed by the characters, followed by
-     * a terminating '\\0'.
-     * @param str C++ string to append
-     * @see serialization::encode_vstr
-     */
-    void append_vstr(const std::string &str) {
-        serialization::encode_vstr(&data_ptr, str);
-    }
-
-    /** Appends a variable sized string to the primary buffer.  The
-     * string is encoded as a vint length, followed by the bytes
-     * (followed by a terminating '\\0').
-     *
-     * @param str C-style string to encode
-     * @param len Length of string
-     * @see serialization::encode_vstr
-     */
-    void append_vstr(const void *str, uint32_t len) {
-        serialization::encode_vstr(&data_ptr, str, len);
-    }
-
-    /** Appends an InetAddr structure to the primary buffer.
-     *
-     * @param addr address structure
-     * @see serialization::encode_inet_addr
-     */
-    void append_inet_addr(const InetAddr &addr) {
-        serialization::encode_inet_addr(&data_ptr, addr);
-    }
-
-    friend class IOHandlerData;
-    friend class IOHandlerDatagram;
-    StaticBuffer data; //!< Primary data buffer
-    StaticBuffer ext;  //!< Extended buffer
-    CommHeader header; //!< Comm header
-
-protected:
-    /// Write pointer into #data buffer
-    uint8_t* data_ptr;
-    /// Write pointer into #ext buffer
-    const uint8_t* ext_ptr;
-    /// Smart pointer to extended buffer memory
-    boost::shared_array<uint8_t> ext_shared_array;
-};
-
-/// Smart pointer to CommBuf
-typedef std::shared_ptr<CommBuf> CommBufPtr;
-
-} // namespace palo
-
-#endif //BDG_PALO_BE_SRC_RPC_COMM_BUF_H
diff --git a/be/src/rpc/comm_header.cpp b/be/src/rpc/comm_header.cpp
deleted file mode 100644
index 744f22d3b5d31b..00000000000000
--- a/be/src/rpc/comm_header.cpp
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "checksum.h"
-#include "error.h"
-#include "serialization.h"
-#include "common/logging.h"
-#include "comm_header.h"
-
-namespace palo {
-
-void CommHeader::encode(uint8_t **bufp) {
-    uint8_t *base = *bufp;
-    serialization::encode_i8(bufp, version);
-    serialization::encode_i8(bufp, header_len);
-    serialization::encode_i16(bufp, alignment);
-    serialization::encode_i16(bufp, flags);
-    serialization::encode_i32(bufp, 0);
-    serialization::encode_i32(bufp, id);
-    serialization::encode_i32(bufp, gid);
-    serialization::encode_i32(bufp, total_len);
-    serialization::encode_i32(bufp, timeout_ms);
-    serialization::encode_i32(bufp, payload_checksum);
-    serialization::encode_i64(bufp, command);
-    // compute and serialize header checksum
-    header_checksum = fletcher32(base, (*bufp)-base);
-    base += 6;
-    serialization::encode_i32(&base, header_checksum);
-}
-
-void CommHeader::decode(const uint8_t **bufp, size_t *remainp) {
-    const uint8_t *base = *bufp;
-    if (*remainp < FIXED_LENGTH)
-        HT_THROWF(error::COMM_BAD_HEADER,
-                  "Header size %d is less than the minumum fixed length %d",
-                  (int)*remainp, (int)FIXED_LENGTH);
-    HT_TRY("decoding comm header",
-           version = serialization::decode_i8(bufp, remainp);
-           header_len = serialization::decode_i8(bufp, remainp);
-           alignment = serialization::decode_i16(bufp, remainp);
-           flags = serialization::decode_i16(bufp, remainp);
-           header_checksum = serialization::decode_i32(bufp, remainp);
-           id = serialization::decode_i32(bufp, remainp);
-           gid = serialization::decode_i32(bufp, remainp);
-           total_len = serialization::decode_i32(bufp, remainp);
-           timeout_ms = serialization::decode_i32(bufp, remainp);
-           payload_checksum = serialization::decode_i32(bufp, remainp);
-           command = serialization::decode_i64(bufp, remainp));
-    memset((void *)(base+6), 0, 4);
-    uint32_t checksum = fletcher32(base, *bufp-base);
-    if (checksum != header_checksum)
-        HT_THROWF(error::COMM_HEADER_CHECKSUM_MISMATCH, "%u != %u", checksum,
-                  header_checksum);
-}
-
-} //namespace palo
diff --git a/be/src/rpc/comm_header.h b/be/src/rpc/comm_header.h
deleted file mode 100644
index 7c8a2d21d9b2d9..00000000000000
--- a/be/src/rpc/comm_header.h
+++ /dev/null
@@ -1,133 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_COMM_HEADER_H
-#define BDG_PALO_BE_SRC_RPC_COMM_HEADER_H
-
-namespace palo {
-/** Header for messages transmitted via AsyncComm.
- */
-class CommHeader {
-public:
-    static const size_t FIXED_LENGTH = 38;
-    
-    /** Enumeration constants for bits in flags field
-    */
-    enum Flags {
-        FLAGS_BIT_REQUEST          = 0x0001, //!< Request message
-        FLAGS_BIT_IGNORE_RESPONSE  = 0x0002, //!< Response should be ignored
-        FLAGS_BIT_URGENT           = 0x0004, //!< Request is urgent
-        FLAGS_BIT_PROFILE          = 0x0008, //!< Request should be profiled
-        FLAGS_BIT_PROXY_MAP_UPDATE = 0x4000, //!< ProxyMap update message
-        FLAGS_BIT_PAYLOAD_CHECKSUM = 0x8000  //!< Payload checksumming is enabled
-    };
-
-    /** Enumeration constants for flags field bitmaks
-    */
-    enum FlagMask {
-        FLAGS_MASK_REQUEST          = 0xFFFE, //!< Request message bit
-        FLAGS_MASK_IGNORE_RESPONSE  = 0xFFFD, //!< Response should be ignored bit
-        FLAGS_MASK_URGENT           = 0xFFFB, //!< Request is urgent bit
-        FLAGS_MASK_PROFILE          = 0xFFF7, //!< Request should be profiled
-        FLAGS_MASK_PROXY_MAP_UPDATE = 0xBFFF, //!< ProxyMap update message bit
-        FLAGS_MASK_PAYLOAD_CHECKSUM = 0x7FFF  //!< Payload checksumming is enabled bit
-    };
-
-    /** Default constructor.
-    */
-    CommHeader()
-        : version(1), header_len(FIXED_LENGTH), alignment(0), flags(0),
-        header_checksum(0), id(0), gid(0), total_len(0),
-        timeout_ms(0), payload_checksum(0), command(0) {  }
-
-    /** Constructor taking command number and optional timeout.
-     * @param cmd Command number
-     * @param timeout Request timeout
-     */
-    CommHeader(uint64_t cmd, uint32_t timeout = 0)
-        : version(1), header_len(FIXED_LENGTH), alignment(0), flags(0),
-        header_checksum(0), id(0), gid(0), total_len(0),
-        timeout_ms(timeout), payload_checksum(0),
-        command(cmd) {  }
-
-    /** Returns fixed length of header.
-     * @return Fixed length of header
-     */
-    size_t fixed_length() const { return FIXED_LENGTH; }
-
-    /** Returns encoded length of header.
-     * @return Encoded length of header
-     */
-    size_t encoded_length() const { return FIXED_LENGTH; }
-
-    /** Encode header to memory pointed to by <code>*bufp</code>.
-     * The <code>bufp</code> pointer is advanced to address immediately
-     * following the encoded header.
-     * @param bufp Address of memory pointer to where header is to be encoded.
-     */
-    void encode(uint8_t **bufp);
-
-    /** Decode serialized header at <code>*bufp</code>
-     * The <code>bufp</code> pointer is advanced to the address immediately
-     * following the decoded header and <code>remainp</code> is decremented
-     * by the length of the serialized header.
-     * @param bufp Address of memory pointer to where header is to be encoded.
-     * @param remainp Pointer to valid bytes remaining in buffer (decremented
-     *                by call)
-     * @throws error::COMM_BAD_HEADER If fixed header size is less than
-     * <code>*remainp</code>.
-     * @throws error::COMM_HEADER_CHECKSUM_MISMATCH If computed checksum does
-     * not match checksum field
-     */
-    void decode(const uint8_t **bufp, size_t *remainp);
-
-    /** Set total length of message (header + payload).
-     * @param len Total length of message (header + payload)
-     */
-    void set_total_length(uint32_t len) { total_len = len; }
-
-    /** Initializes header from <code>req_header</code>.
-     * This method is typically used to initialize a response header
-     * from a corresponding request header.
-     * @param req_header Request header from which to initialize
-     */
-    void initialize_from_request_header(CommHeader &req_header) {
-        flags = req_header.flags;
-        id = req_header.id;
-        gid = req_header.gid;
-        command = req_header.command;
-        total_len = 0;
-    }
-
-    uint8_t version;     //!< Protocol version
-    uint8_t header_len;  //!< Length of header
-    uint16_t alignment;  //!< Align payload to this byte offset
-    uint16_t flags;      //!< Flags
-    uint32_t header_checksum; //!< Header checksum (computed with this member 0)
-    uint32_t id;         //!< Request ID
-    uint32_t gid;        //!< Group ID (see ApplicationQueue)
-    uint32_t total_len;  //!< Total length of message including header
-    uint32_t timeout_ms; //!< Request timeout
-    uint32_t payload_checksum; //!< Payload checksum (currently unused)
-    uint64_t command;    //!< Request command number
-};
-
-} //namespace palo
-
-#endif //BDG_PALO_BE_SRC_RPC_COMM_HEADER_H
diff --git a/be/src/rpc/command.h b/be/src/rpc/command.h
deleted file mode 100644
index 3257a71d1f0608..00000000000000
--- a/be/src/rpc/command.h
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#pragma once
-
-namespace palo {
-
-#define RPC_COMMAND_TRANSMIT_DATA           0
-#define RPC_COMMAND_TABLET_WRITER_OPEN      1
-#define RPC_COMMAND_TABLET_WRITER_ADD_BATCH 2
-#define RPC_COMMAND_TABLET_WRITER_CLOSE     3
-#define RPC_COMMAND_TABLET_WRITER_CANCEL    4
-
-}
diff --git a/be/src/rpc/compat.h b/be/src/rpc/compat.h
deleted file mode 100644
index 257db538dd2952..00000000000000
--- a/be/src/rpc/compat.h
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_COMPAT_H
-#define BDG_PALO_BE_SRC_RPC_COMPAT_H
-
-// The same stuff for C code
-#include "compat_c.h"
-#include <cstddef> // for std::size_t and std::ptrdiff_t
-#include <memory>
-
-// C++ specific stuff
-#ifndef BOOST_SPIRIT_THREADSAFE
-#  define BOOST_SPIRIT_THREADSAFE
-#endif
-#define BOOST_IOSTREAMS_USE_DEPRECATED
-#define BOOST_FILESYSTEM_VERSION 3
-#define BOOST_FILESYSTEM_DEPRECATED     1
-#define HT_UNUSED(x) static_cast<void>(x)
-
-template<typename T, typename... Ts>
-std::unique_ptr<T> make_unique(Ts&&... params) {
-    return std::unique_ptr<T>(new T(std::forward<Ts>(params)...));
-}
-
-#if defined(__APPLE__) || !defined(_GLIBCXX_HAVE_QUICK_EXIT)
-namespace std {
-    inline void quick_exit(int status) { _exit(status); }
-}
-#endif
-
-#endif //BDG_PALO_BE_SRC_RPC_COMPAT_H
diff --git a/be/src/rpc/compat_c.h b/be/src/rpc/compat_c.h
deleted file mode 100644
index 3ca69489aa4606..00000000000000
--- a/be/src/rpc/compat_c.h
+++ /dev/null
@@ -1,76 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_COMPAT_C_H
-#define BDG_PALO_BE_SRC_RPC_COMPAT_C_H
-
-/** @defgroup Common Common
- * General purpose utility library.
- * The %Common library contains general purpose utility classes used by all
- * other modules within palo.  It is not dependent on any other library
- * defined in %palo.
- */
-/* Portability macros for C code. */
-
-#ifdef __cplusplus
-#  define HT_EXTERN_C  extern "C"
-#else
-#  define HT_EXTERN_C  extern
-#endif
-
-/* Calling convention */
-#ifdef _MSC_VER
-#  define HT_CDECL      __cdecl
-#else
-#  define HT_CDECL
-#endif
-
-#define HT_PUBLIC(ret_type)     ret_type HT_CDECL
-#define HT_EXTERN(ret_type)     HT_EXTERN_C HT_PUBLIC(ret_type)
-
-#ifdef __GNUC__
-#  define HT_NORETURN __attribute__((__noreturn__))
-#  define HT_FORMAT(x) __attribute__((format x))
-#  define HT_FUNC __PRETTY_FUNCTION__
-#  define HT_COND(x, _prob_) __builtin_expect(x, _prob_)
-#else
-#  define HT_NORETURN
-#  define HT_FORMAT(x)
-#  ifndef __attribute__
-#    define __attribute__(x)
-#  endif
-#  define HT_FUNC __func__
-#  define HT_COND(x, _prob_) (x)
-#endif
-
-#define HT_LIKELY(x) HT_COND(x, 1)
-#define HT_UNLIKELY(x) HT_COND(x, 0)
-/* We want C limit macros, even when using C++ compilers */
-#ifndef __STDC_LIMIT_MACROS
-#  define __STDC_LIMIT_MACROS
-#endif
-
-#include <stdint.h>
-#include <stddef.h>
-#include <string.h>
-#include <strings.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#endif //BDG_PALO_BE_SRC_RPC_COMPAT_C_H
diff --git a/be/src/rpc/connection_handler_factory.h b/be/src/rpc/connection_handler_factory.h
deleted file mode 100644
index f675f87cac1009..00000000000000
--- a/be/src/rpc/connection_handler_factory.h
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_CONNECTION_HANDLER_FACTORY_H
-#define BDG_PALO_BE_SRC_RPC_CONNECTION_HANDLER_FACTORY_H
-
-#include "dispatch_handler.h"
-
-namespace palo {
-/** Abstract class for creating default application dispatch handlers.
- */
-class ConnectionHandlerFactory {
-public:
-    /** Destructor */
-    virtual ~ConnectionHandlerFactory() { }
-
-    /** Creates a connection dispatch handler.
-     * @param dhp Reference to created dispatch handler
-     */
-    virtual void get_instance(DispatchHandlerPtr &dhp) = 0;
-
-};
-/// Smart pointer to ConnectionHandlerFactory
-typedef std::shared_ptr<ConnectionHandlerFactory> ConnectionHandlerFactoryPtr;
-
-} //namespace palo
-
-#endif //BDG_PALO_BE_SRC_RPC_CONNECTION_HANDLER_FACTORY_H
diff --git a/be/src/rpc/connection_initializer.h b/be/src/rpc/connection_initializer.h
deleted file mode 100644
index 18fb9028bf8906..00000000000000
--- a/be/src/rpc/connection_initializer.h
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_CONNECTION_INITIALIZER_H
-#define BDG_PALO_BE_SRC_RPC_CONNECTION_INITIALIZER_H
-
-#include "comm_buf.h"
-
-namespace palo {
-
-class Event;
-
-/** Driver interface for connection initialization handshake in ConnectionManager.
- */
-class ConnectionInitializer {
-public:
-
-    /** Creates a connection initialization message.
-     * @return Initialization message (freed by caller)
-     */
-    virtual CommBuf *create_initialization_request() = 0;
-
-    /** Process response to initialization message.
-     * @param event Pointer to event object holding response message
-     * @return <i>true</i> on success, <i>false</i> on failure
-     */
-    virtual bool process_initialization_response(Event *event) = 0;
-
-    /** Command code (see CommHeader::command) for initialization response
-     * message.
-     * This method is used by the ConnectionManager to determine if a received
-     * message is part of the initialization handshake.
-     * @return Initialization command code
-     */
-    virtual uint64_t initialization_command() = 0;
-};
-
-/// Smart pointer to ConnectionInitializer
-typedef std::shared_ptr<ConnectionInitializer> ConnectionInitializerPtr;
-
-} //namespace palo
-
-#endif //BDG_PALO_BE_SRC_RPC_CONNECTION_INITIALIZER_H
diff --git a/be/src/rpc/connection_manager.cpp b/be/src/rpc/connection_manager.cpp
deleted file mode 100644
index 4d8bfcebe5d186..00000000000000
--- a/be/src/rpc/connection_manager.cpp
+++ /dev/null
@@ -1,504 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "connection_manager.h"
-#include "comm.h"
-#include "protocol.h"
-#include "error.h"
-#include "common/logging.h"
-#include "random.h"
-#include "serialization.h"
-
-#include <chrono>
-#include <cstdlib>
-#include <iostream>
-#include <unordered_map>
-
-extern "C" {
-#include <poll.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-}
-
-namespace palo {
-
-void
-ConnectionManager::add(const CommAddress &addr, uint32_t timeout_ms,
-                       const char *service_name, DispatchHandlerPtr &handler) {
-    CommAddress null_addr;
-    ConnectionInitializerPtr null_initializer;
-    add_internal(addr, null_addr, timeout_ms, service_name, handler, null_initializer);
-}
-
-void ConnectionManager::add_with_initializer(const CommAddress &addr,
-        uint32_t timeout_ms, const char *service_name,
-        DispatchHandlerPtr &handler, ConnectionInitializerPtr &initializer) {
-    CommAddress null_addr;
-    add_internal(addr, null_addr, timeout_ms, service_name, handler, initializer);
-}
-
-void
-ConnectionManager::add(const CommAddress &addr, uint32_t timeout_ms,
-                       const char *service_name) {
-    DispatchHandlerPtr null_disp_handler;
-    add(addr, timeout_ms, service_name, null_disp_handler);
-}
-
-void
-ConnectionManager::add(const CommAddress &addr, const CommAddress &local_addr,
-                       uint32_t timeout_ms, const char *service_name,
-                       DispatchHandlerPtr &handler) {
-    ConnectionInitializerPtr null_initializer;
-    add_internal(addr, local_addr, timeout_ms, service_name, handler, null_initializer);
-}
-
-void
-ConnectionManager::add(const CommAddress &addr, const CommAddress &local_addr,
-                       uint32_t timeout_ms, const char *service_name) {
-    DispatchHandlerPtr null_disp_handler;
-    add(addr, local_addr, timeout_ms, service_name, null_disp_handler);
-}
-
-void
-ConnectionManager::add_internal(const CommAddress &addr,
-                                const CommAddress &local_addr, uint32_t timeout_ms,
-                                const char *service_name, DispatchHandlerPtr &handler,
-                                ConnectionInitializerPtr &initializer) {
-    std::lock_guard<std::mutex> lock(m_impl->mutex);
-    ConnectionStatePtr conn_state;
-    /// Start retry thread
-    if (!m_impl->thread.joinable()) {
-        m_impl->thread = std::thread([=]() {
-            this->connect_retry_loop();
-        });
-    }
-    assert(addr.is_set());
-    if (addr.is_proxy()) {
-        auto iter = m_impl->conn_map_proxy.find(addr.proxy);
-        if (iter != m_impl->conn_map_proxy.end() && iter->second->state != State::DECOMMISSIONED)
-            return;
-    }
-    else if (addr.is_inet()) {
-        SockAddrMap<ConnectionStatePtr>::iterator iter =
-            m_impl->conn_map.find(addr.inet);
-        if (iter != m_impl->conn_map.end() && iter->second->state != State::DECOMMISSIONED)
-            return;
-    }
-    conn_state = std::make_shared<ConnectionState>();
-    conn_state->addr = addr;
-    conn_state->local_addr = local_addr;
-    conn_state->timeout_ms = timeout_ms;
-    conn_state->handler = handler;
-    conn_state->initializer = initializer;
-    conn_state->service_name = (service_name) ? service_name : "";
-    conn_state->next_retry = std::chrono::steady_clock::now();
-    conn_state->retry_number = 0;
-    if (addr.is_proxy())
-        m_impl->conn_map_proxy[addr.proxy] = conn_state;
-    else
-        m_impl->conn_map[addr.inet] = conn_state;
-    {
-        std::lock_guard<std::mutex> conn_lock(conn_state->mutex);
-        send_connect_request(conn_state);
-    }
-}
-
-bool
-ConnectionManager::wait_for_connection(const CommAddress &addr,
-                                       uint32_t max_wait_ms) {
-    Timer timer(max_wait_ms, true);
-    return wait_for_connection(addr, timer);
-}
-
-bool
-ConnectionManager::wait_for_connection(const CommAddress &addr,
-                                       Timer &timer) {
-    ConnectionStatePtr conn_state_ptr;
-    {
-        std::lock_guard<std::mutex> lock(m_impl->mutex);
-        if (addr.is_inet()) {
-            SockAddrMap<ConnectionStatePtr>::iterator iter =
-                m_impl->conn_map.find(addr.inet);
-            if (iter == m_impl->conn_map.end())
-                return false;
-            conn_state_ptr = (*iter).second;
-        }
-        else if (addr.is_proxy()) {
-            auto iter = m_impl->conn_map_proxy.find(addr.proxy);
-            if (iter == m_impl->conn_map_proxy.end())
-                return false;
-            conn_state_ptr = (*iter).second;
-        }
-    }
-    return wait_for_connection(conn_state_ptr, timer);
-}
-
-bool ConnectionManager::wait_for_connection(ConnectionStatePtr &conn_state,
-        Timer &timer) {
-    timer.start();
-    {
-        std::unique_lock<std::mutex> conn_lock(conn_state->mutex);
-        auto duration = std::chrono::milliseconds(timer.remaining());
-        if (!conn_state->cond.wait_for(conn_lock, duration,
-                [&conn_state]() {return conn_state->state == State::READY;})) {
-            return false;
-        }
-        if (conn_state->state == State::DECOMMISSIONED)
-            return false;
-    }
-    return true;
-}
-
-/**
- * Attempts to establish a connection for the given ConnectionState object.  If
- * a failure occurs, it prints an error message and then schedules a retry by
- * updating the next_retry member of the conn_state object and pushing it onto
- * the retry heap
- *
- * @param conn_state The connection state record
- */
-void
-ConnectionManager::send_connect_request(ConnectionStatePtr &conn_state) {
-    int error = 0;
-    if (conn_state->state == State::DECOMMISSIONED) {
-        LOG(FATAL) << "Attempt to connect decommissioned connection to service='%s'" <<
-                   conn_state->service_name.c_str();
-    }
-    if (!conn_state->local_addr.is_set()) {
-        error = m_impl->comm->connect(conn_state->addr, shared_from_this());
-    } else {
-        error = m_impl->comm->connect(conn_state->addr, conn_state->local_addr,
-                                      shared_from_this());
-    }
-    if (error == error::OK) {
-        return;
-    }
-    else if (error == error::COMM_ALREADY_CONNECTED) {
-        if (conn_state->state == State::DISCONNECTED)
-            conn_state->state = State::READY;
-        conn_state->cond.notify_all();
-    }
-    else if (error == error::COMM_INVALID_PROXY) {
-        m_impl->conn_map.erase(conn_state->inet_addr);
-        m_impl->conn_map_proxy.erase(conn_state->addr.proxy);
-        conn_state->state = State::DECOMMISSIONED;
-        conn_state->cond.notify_all();
-    }
-    else if (error != error::COMM_BROKEN_CONNECTION) {
-        if (!m_impl->quiet_mode) {
-            if (conn_state->service_name != "")
-                LOG(INFO) << "Connection attempt to %s at %s failed - %s.  Will retry "
-                          << "again in %d milliseconds..." << conn_state->service_name.c_str() <<
-                          conn_state->addr.to_str().c_str() << error::get_text(error) <<
-                          (int)conn_state->timeout_ms;
-            else
-                LOG(INFO) << "Connection attempt to service at %s failed - %s.  Will retry "
-                          << "again in %d milliseconds..." << conn_state->addr.to_str().c_str()
-                          << error::get_text(error) << (int)conn_state->timeout_ms;
-        }
-        // Reschedule (throw in a little randomness)
-        conn_state->next_retry = std::chrono::steady_clock::now() +
-                                 std::chrono::milliseconds(conn_state->timeout_ms);
-        if (Random::number32() & 1)
-            conn_state->next_retry -= Random::duration_millis(2000);
-        else
-            conn_state->next_retry += Random::duration_millis(2000);
-        // add to retry heap
-        m_impl->retry_queue.push(conn_state);
-        m_impl->retry_cond.notify_one();
-    }
-}
-
-int ConnectionManager::remove(const CommAddress &addr) {
-    bool check_inet_addr = false;
-    InetAddr inet_addr;
-    bool do_close = false;
-    int error = error::OK;
-    assert(addr.is_set());
-    {
-        std::lock_guard<std::mutex> lock(m_impl->mutex);
-        if (addr.is_proxy()) {
-            auto iter = m_impl->conn_map_proxy.find(addr.proxy);
-            if (iter != m_impl->conn_map_proxy.end()) {
-                {
-                    std::lock_guard<std::mutex> conn_lock((*iter).second->mutex);
-                    check_inet_addr = true;
-                    inet_addr = (*iter).second->inet_addr;
-                    if ((*iter).second->state == State::CONNECTED ||
-                            (*iter).second->state == State::READY) {
-                        do_close = true;
-                    }
-                    (*iter).second->state = State::DECOMMISSIONED;
-                    (*iter).second->cond.notify_all();
-                }
-                m_impl->conn_map_proxy.erase(iter);
-            }
-        }
-        else if (addr.is_inet()) {
-            check_inet_addr = true;
-            inet_addr = addr.inet;
-        }
-        if (check_inet_addr) {
-            SockAddrMap<ConnectionStatePtr>::iterator iter =
-                m_impl->conn_map.find(inet_addr);
-            if (iter != m_impl->conn_map.end()) {
-                {
-                    std::lock_guard<std::mutex> conn_lock((*iter).second->mutex);
-                    if ((*iter).second->state == State::CONNECTED ||
-                            (*iter).second->state == State::READY) {
-                        do_close = true;
-                    }
-                    (*iter).second->state = State::DECOMMISSIONED;
-                    (*iter).second->cond.notify_all();
-                }
-                m_impl->conn_map.erase(iter);
-            }
-        }
-    }
-    if (do_close) {
-        m_impl->comm->close_socket(addr);
-    }
-    return error;
-}
-
-int ConnectionManager::remove_unlocked(const CommAddress &addr) {
-    bool check_inet_addr = false;
-    InetAddr inet_addr;
-    bool do_close = false;
-    int error = error::OK;
-    assert(addr.is_set());
-    {
-        if (addr.is_proxy()) {
-            auto iter = m_impl->conn_map_proxy.find(addr.proxy);
-            if (iter != m_impl->conn_map_proxy.end()) {
-                {
-                    check_inet_addr = true;
-                    inet_addr = (*iter).second->inet_addr;
-                    if ((*iter).second->state == State::CONNECTED ||
-                            (*iter).second->state == State::READY) {
-                        do_close = true;
-                    }
-                    (*iter).second->state = State::DECOMMISSIONED;
-                    (*iter).second->cond.notify_all();
-                }
-                m_impl->conn_map_proxy.erase(iter);
-            }
-        }
-        else if (addr.is_inet()) {
-            check_inet_addr = true;
-            inet_addr = addr.inet;
-        }
-        if (check_inet_addr) {
-            SockAddrMap<ConnectionStatePtr>::iterator iter =
-                m_impl->conn_map.find(inet_addr);
-            if (iter != m_impl->conn_map.end()) {
-                {
-                    if ((*iter).second->state == State::CONNECTED ||
-                            (*iter).second->state == State::READY) {
-                        do_close = true;
-                    }
-                    (*iter).second->state = State::DECOMMISSIONED;
-                    (*iter).second->cond.notify_all();
-                }
-                m_impl->conn_map.erase(iter);
-            }
-        }
-    }
-    if (do_close) {
-        m_impl->comm->close_socket(addr);
-    }
-    return error;
-}
-
-/**
- * This is the AsyncComm dispatch handler method.  It gets called for each
- * connection related event (establishment, disconnect, etc.) for each
- * connection.  For connect events, the connection's connected flag is set to
- * true and it's condition variable is signaled.  For all other events (e.g.
- * disconnect or error), the connection's connected flag is set to false and a
- * retry is scheduled.
- *
- * @param event shared pointer to event object
- */
-void ConnectionManager::handle(EventPtr &event) {
-    std::lock_guard<std::mutex> lock(m_impl->mutex);
-    ConnectionStatePtr conn_state;
-    {
-        auto iter = m_impl->conn_map.find(event->addr);
-        if (iter != m_impl->conn_map.end())
-            conn_state = (*iter).second;
-    }
-    if (!conn_state && event->proxy) {
-        auto iter = m_impl->conn_map_proxy.find(event->proxy);
-        if (iter != m_impl->conn_map_proxy.end()) {
-            conn_state = (*iter).second;
-            /** register address **/
-            m_impl->conn_map[event->addr] = conn_state;
-        }
-    }
-    if (conn_state) {
-        std::lock_guard<std::mutex> conn_lock(conn_state->mutex);
-        if (event->type == Event::CONNECTION_ESTABLISHED) {
-            conn_state->inet_addr = event->addr;
-            if (conn_state->initializer) {
-                conn_state->state = State::CONNECTED;
-                send_initialization_request(conn_state);
-                return;
-            }
-            else {
-                conn_state->state = State::READY;
-                conn_state->cond.notify_all();
-            }
-        }
-        else if (event->type == Event::ERROR ||
-                 event->type == Event::DISCONNECT) {
-            if (event->proxy && !m_impl->comm->translate_proxy(event->proxy, 0)) {
-                m_impl->conn_map.erase(conn_state->inet_addr);
-                m_impl->conn_map_proxy.erase(conn_state->addr.proxy);
-                conn_state->state = State::DECOMMISSIONED;
-                conn_state->cond.notify_all();
-            }
-            else {
-                if (!m_impl->quiet_mode) {
-                    LOG(ERROR) << "received event." << "["
-                               << event->to_str().c_str() << "]";
-                }
-                std::string message = (event->type == Event::DISCONNECT) ?
-                                      "Disconnected" : error::get_text(event->error);
-                conn_state->state = State::DISCONNECTED;
-                schedule_retry(conn_state, message);
-            }
-        }
-        else if (event->type == Event::MESSAGE) {
-            if (conn_state->initializer && conn_state->state == State::CONNECTED) {
-                if (Protocol::response_code(event) == error::SERVER_NOT_READY) {
-                    schedule_retry(conn_state, error::get_text(error::SERVER_NOT_READY));
-                    return;
-                }
-                else if (event->header.command != conn_state->initializer->initialization_command()) {
-                    std::string err_msg = "Connection initialization not yet complete";
-                    CommHeader header;
-                    header.initialize_from_request_header(event->header);
-                    CommBufPtr cbuf( new CommBuf(header, 4 + serialization::encoded_length_str16(err_msg)) );
-                    cbuf->append_i32(error::CONNECTION_NOT_INITIALIZED);
-                    cbuf->append_str16(err_msg);
-                    m_impl->comm->send_response(event->addr, cbuf);
-                    return;
-                }
-                if (!conn_state->initializer->process_initialization_response(event.get()))
-                    LOG(FATAL) << "unable to initialize connection to %s, exiting ..." <<
-                               conn_state->service_name.c_str();
-                conn_state->state = State::READY;
-                conn_state->cond.notify_all();
-                return;
-            }
-        }
-        // Chain event to application supplied handler
-        if (conn_state->handler)
-            conn_state->handler->handle(event);
-    }
-    else {
-        LOG(WARNING) << "unable to find connection in map. addr="
-            << InetAddr::format(event->addr);
-    }
-}
-
-void ConnectionManager::send_initialization_request(ConnectionStatePtr &conn_state) {
-    CommBufPtr cbuf(conn_state->initializer->create_initialization_request());
-    int error = m_impl->comm->send_request(conn_state->inet_addr, 60000, cbuf, this);
-    if (error == error::COMM_BROKEN_CONNECTION ||
-            error == error::COMM_NOT_CONNECTED ||
-            error == error::COMM_INVALID_PROXY) {
-        if (!m_impl->quiet_mode)
-            LOG(INFO) << "Received error %d" << error;
-        conn_state->state = State::DISCONNECTED;
-        schedule_retry(conn_state, error::get_text(error));
-    }
-    else if (error != error::OK)
-        LOG(FATAL) << "Problem initializing connection to %s - %s" <<
-                   conn_state->service_name.c_str() << error::get_text(error);
-}
-
-void ConnectionManager::schedule_retry(ConnectionStatePtr &conn_state,
-                                       const std::string &message) {
-    if (!m_impl->quiet_mode) {
-        LOG(ERROR) << "connection falied, retry in " << conn_state->timeout_ms << "ms."
-                   << " addr=" << conn_state->addr.to_str()
-                   << ", error=" << message
-                   << ", service_name=" << conn_state->service_name;
-    }
-    // this logic could proably be smarter.  For example, if the last
-    // connection attempt was a long time ago, then schedule immediately
-    // otherwise, if this event is the result of an immediately prior connect
-    // attempt, then do the following
-    conn_state->next_retry = std::chrono::steady_clock::now() +
-                             std::chrono::milliseconds(conn_state->timeout_ms);
-    // add to retry heap
-    m_impl->retry_queue.push(conn_state);
-    m_impl->retry_cond.notify_one();
-}
-
-/**
- * This is the boost::thread run method.
- */
-void ConnectionManager::connect_retry_loop() {
-    std::unique_lock<std::mutex> lock(m_impl->mutex);
-    ConnectionStatePtr conn_state;
-    while (!m_impl->shutdown) {
-        while (m_impl->retry_queue.empty()) {
-            m_impl->retry_cond.wait(lock);
-            if (m_impl->shutdown)
-                break;
-        }
-        if (m_impl->shutdown)
-            break;
-        conn_state = m_impl->retry_queue.top();
-        {
-            std::lock_guard<std::mutex> conn_lock(conn_state->mutex);
-            if (conn_state->state == State::DISCONNECTED) {
-                if (conn_state->next_retry <= std::chrono::steady_clock::now()) {
-                    m_impl->retry_queue.pop();
-                    if (conn_state->retry_number++ >= 10) {
-                        remove_unlocked(conn_state->addr);
-                    } else {
-                        send_connect_request(conn_state);
-                    }
-                    continue;
-                }
-            }
-            else if (conn_state->state == State::CONNECTED && conn_state->initializer) {
-                if (conn_state->next_retry <= std::chrono::steady_clock::now()) {
-                    m_impl->retry_queue.pop();
-                    send_initialization_request(conn_state);
-                    continue;
-                }
-            }
-            else {
-                m_impl->retry_queue.pop();
-                continue;
-            }
-        }
-        m_impl->retry_cond.wait_until(lock, conn_state->next_retry);
-    }
-}
-
-} //namespace palo
diff --git a/be/src/rpc/connection_manager.h b/be/src/rpc/connection_manager.h
deleted file mode 100644
index 49d40314a50066..00000000000000
--- a/be/src/rpc/connection_manager.h
+++ /dev/null
@@ -1,405 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_CONNECTION_MANAGER_H
-#define BDG_PALO_BE_SRC_RPC_CONNECTION_MANAGER_H
-
-#include "comm.h"
-#include "comm_address.h"
-#include "connection_initializer.h"
-#include "dispatch_handler.h"
-#include "sock_addr_map.h"
-
-#include "timer.h"
-#include <chrono>
-#include <condition_variable>
-#include <mutex>
-#include <queue>
-#include <string>
-#include <thread>
-#include <unordered_map>
-
-namespace palo {
-
-class Event;
-
-/**
- * Establishes and maintains a set of TCP connections.  If any of the
- * connections gets broken, then this class will continuously attempt
- * to re-establish the connection, pausing for a while in between attempts.
- */
-class ConnectionManager : public DispatchHandler {
-    enum class State {
-        DISCONNECTED = 0,
-        CONNECTED,
-        READY,
-        DECOMMISSIONED
-    };
-
-    /** Per-connection state.
-     */
-    class ConnectionState {
-        public:
-            /// Connection address supplied to the #add methods
-            CommAddress addr;
-            /// Local address to bind to
-            CommAddress local_addr;
-            /// Address initialized from Event object
-            InetAddr inet_addr;
-            /// Retry connection attempt after this many milliseconds
-            uint32_t timeout_ms;
-            /// Registered connection handler
-            DispatchHandlerPtr handler;
-            /// Connection initializer
-            ConnectionInitializerPtr initializer;
-            /// Connection state
-            State state {};
-            /// Mutex to serialize concurrent access
-            std::mutex mutex;
-            /// Condition variable used to signal connection state change
-            std::condition_variable cond;
-            /// Absolute time of next connect attempt
-            std::chrono::steady_clock::time_point next_retry;
-            /// Service name of connection for log messages
-            std::string service_name;
-            /// retry number
-            uint32_t retry_number;
-    };
-
-    /// Smart pointer to ConnectionState
-    typedef std::shared_ptr<ConnectionState> ConnectionStatePtr;
-
-    /** StringWeakOrdering for connection retry heap
-    */
-    struct LtConnectionState {
-        bool operator()(const ConnectionStatePtr &cs1,
-                const ConnectionStatePtr &cs2) const {
-            return std::chrono::operator>(cs1->next_retry, cs2->next_retry);
-        }
-    };
-
-    /** Connection manager state shared between Connection manager objects.
-    */
-    class SharedImpl {
-    public:
-        /** Destructor.
-        */
-        ~SharedImpl() {
-            shutdown = true;
-            retry_cond.notify_one();
-            if (thread.joinable())
-                thread.join();
-        }
-        /// Pointer to Comm layer
-        Comm *comm;
-        /// Mutex to serialize concurrent access
-        std::mutex mutex;
-        /// Condition variable to signal if anything is on the retry heap
-        std::condition_variable retry_cond;
-        /// Pointer to connection manager thread object
-        std::thread thread;
-        /// InetAddr-to-ConnectionState map
-        SockAddrMap<ConnectionStatePtr> conn_map;
-        /// Proxy-to-ConnectionState map
-        std::unordered_map<std::string, ConnectionStatePtr> conn_map_proxy;
-        /// Connect retry heap
-        std::priority_queue<ConnectionStatePtr, std::vector<ConnectionStatePtr>,
-            LtConnectionState> retry_queue;
-        /// Set to <i>true</i> to prevent connect failure log message
-        bool quiet_mode;
-        /// Set to <i>true</i> to signal shutdown in progress
-        bool shutdown;
-    };
-
-    /// Smart pointer to SharedImpl object
-    typedef std::shared_ptr<SharedImpl> SharedImplPtr;
-    public:
-
-    /**
-     * Constructor.  Creates a thread to do connection retry attempts.
-     *
-     * @param comm Pointer to the comm object
-     */
-    ConnectionManager(Comm *comm = 0) {
-        m_impl = std::make_shared<SharedImpl>();
-        m_impl->comm = comm ? comm : Comm::instance();
-        m_impl->quiet_mode = false;
-        m_impl->shutdown = false;
-    }
-
-    ConnectionManager(const ConnectionManager &cm) = delete;
-
-    /** Destructor.
-    */
-    virtual ~ConnectionManager() { }
-
-    /** Adds a connection.  The <code>addr</code> parameter holds the address
-     * to which the connection manager should maintain a connection.
-     * This method first checks to see if the address is
-     * already registered with the connection manager and returns immediately
-     * if it is.  Otherwise, it adds the address to an internal connection map,
-     * attempts to establish a connection to the address, and then returns.
-     * Once a connection has been added, the internal manager thread will
-     * maintian the connection by continually re-establishing the connection if
-     * it ever gets broken.
-     *
-     * @param addr The address to maintain a connection to
-     * @param timeout_ms When connection dies, wait this many milliseconds
-     *        before attempting to reestablish
-     * @param service_name The name of the serivce at the other end of the
-     *        connection used for descriptive log messages
-     */
-    void add(const CommAddress &addr, uint32_t timeout_ms,
-            const char *service_name);
-
-    /** Adds a connection with a dispatch handler.  The <code>addr</code>
-     * parameter holds the address to which connection manager should maintain a
-     * connection.  This method first checks to see if the address is
-     * already registered with the connection manager and returns immediately
-     * if it is.  Otherwise, it adds the address to an internal connection map,
-     * attempts to establish a connection to the address, and then returns.
-     * Once a connection has been added, the internal manager thread will
-     * maintian the connection by continually re-establishing the connection if
-     * it ever gets broken.
-     *
-     * This version of add accepts a DispatchHandler argument,
-     * <code>handler</code>, which is registered as the connection handler for
-     * the connection and receives all events that occur on the connection
-     * (except for the initialization handshake messages).
-     *
-     * @param addr The address to maintain a connection to
-     * @param timeout_ms The timeout value (in milliseconds) that gets passed
-     *        into Comm::connect and also used as the waiting period betweeen
-     *        connection attempts
-     * @param service_name The name of the serivce at the other end of the
-     *        connection used for descriptive log messages
-     * @param handler This is the default handler to install on the connection.
-     *        All events get changed through to this handler.
-     */
-    void add(const CommAddress &addr, uint32_t timeout_ms,
-            const char *service_name, DispatchHandlerPtr &handler);
-
-    /** Adds a connection with a dispatch handler and connection initializer.
-     * The <code>addr</code> parameter holds the address to which connection
-     * manager should maintain a connection.  This method first checks to see
-     * if the address is already registered with the connection manager and
-     * returns immediately if it is.  Otherwise, it adds the address to an
-     * internal connection map, attempts to establish a connection to the
-     * address, and then returns.  Once a connection has been added, the
-     * internal manager thread will maintian the connection by continually
-     * re-establishing the connection if it ever gets broken.
-     *
-     * This version of add accepts a connection initializer,
-     * <code>initializer</code>, which is used to carry out an initialization
-     * handshake.  Once the connection has been established, the connection
-     * initializer is used to generate an initialization handshake message
-     * which is sent to the other end of the connection.  
-     * and process the response t
-     *
-     * @param addr Address to maintain a connection to
-     * @param timeout_ms Timeout value (in milliseconds) that gets passed into
-     * Comm#connect and also used as the waiting period between connection
-     * attempts
-     * @param service_name Name of the serivce at the other end of the
-     * connection used for descriptive log messages
-     * @param handler Default dispatch handler for connection.
-     * @param initializer Connection initialization handshake driver
-     */
-    void add_with_initializer(const CommAddress &addr, uint32_t timeout_ms,
-            const char *service_name,
-            DispatchHandlerPtr &handler,
-            ConnectionInitializerPtr &initializer);
-
-    /** Adds a connection bound to a local address.
-     * The <code>addr</code> holds the address to which the
-     * connection manager should maintain a connection.  This method first
-     * checks to see if the address is already registered with the connection
-     * manager and returns immediately if it is.  Otherwise, it adds the
-     * address to an internal connection map, attempts to establish a
-     * connection to the address, and then returns.  From here on out, the
-     * internal manager thread will maintian the connection by continually
-     * re-establishing the connection if it ever gets broken.
-     *
-     * @param addr The address to maintain a connection to
-     * @param local_addr The local address to bind to
-     * @param timeout_ms When connection dies, wait this many
-     *        milliseconds before attempting to reestablish
-     * @param service_name The name of the serivce at the other end of the
-     *        connection used for descriptive log messages
-     */
-    void add(const CommAddress &addr, const CommAddress &local_addr,
-            uint32_t timeout_ms, const char *service_name);
-
-    /** Adds a connection with a dispatch handler bound to a local address.
-     * The <code>addr</code> holds the address to which the
-     * connection manager should maintain a connection.  This method first
-     * checks to see if the address is already registered with the connection
-     * manager and returns immediately if it is.  Otherwise, it adds the
-     * address to an internal connection map, attempts to establish a
-     * connection to the address, and then returns.  From here on out, the
-     * internal manager thread will maintian the connection by continually
-     * re-establishing the connection if it ever gets broken.
-     *
-     * @param addr The address to maintain a connection to
-     * @param local_addr The local address to bind to
-     * @param timeout_ms The timeout value (in milliseconds) that gets passed
-     *        into Comm::connect and also used as the waiting period betweeen
-     *        connection attempts
-     * @param service_name The name of the serivce at the other end of the
-     *        connection used for descriptive log messages
-     * @param handler This is the default handler to install on the connection.
-     *        All events get changed through to this handler.
-     */
-    void add(const CommAddress &addr, const CommAddress &local_addr,
-            uint32_t timeout_ms, const char *service_name,
-            DispatchHandlerPtr &handler);
-
-    /** Removes a connection from the connection manager.
-     *
-     * @param addr remote address of connection to remove
-     * @return Error code (error::OK on success)
-     */
-    int remove(const CommAddress &addr);
-
-    /** Removes a connection from the connection manager.
-     *
-     * @param addr address of connection to remove
-     * @return Error code (error::OK on success)
-     */
-    int remove_unlocked(const CommAddress &addr);
-    /** Blocks until the connection to the given address is
-
-     * established.  The given address must have been previously added with a
-     * call to Add.  If the connection is not established within
-     * max_wait_ms, then the method returns false.
-     *
-     * @param addr the address of the connection to wait for
-     * @param max_wait_ms The maximum time to wait for the connection before
-     *        returning
-     * @return true if connected, false otherwise
-     */
-    bool wait_for_connection(const CommAddress &addr, uint32_t max_wait_ms);
-
-    /** Blocks until the connection to the given address is
-     * established.  The given address must have been previously added with a
-     * call to Add.  If the connection is not established before the timer
-     * expires, then the method returns false.
-     *
-     * @param addr the address of the connection to wait for
-     * @param timer running timer object
-     * @return true if connected, false otherwise
-     */
-    bool wait_for_connection(const CommAddress &addr, Timer &timer);
-
-    /** Returns the Comm object associated with this connection manager
-     *
-     * @return the assocated comm object
-     */
-    Comm *get_comm() { return m_impl->comm; }
-
-    /** Sets the SharedImpl#quiet_mode flag which will disable the
-     * generation of log messages upon failed connection attempts.  It is set
-     * to <i>false</i> by default.
-     *
-     * @param mode The new value for the SharedImpl#quiet_mode flag
-     */
-    void set_quiet_mode(bool mode) { m_impl->quiet_mode = mode; }
-
-    /** Primary dispatch handler method.  The ConnectionManager is a dispatch
-     * handler and is registered as the handler for all of the connections that
-     * it manages.  This method does the job of maintianing connections.
-     * This method will forward all events (except initialization handshake
-     * messages) to any dispatch handler registered for the connection on
-     * which the event was generated.
-     * @param event Comm layer event
-     */
-    void handle(EventPtr& event) override;
-
-    /** Connect retry loop.
-     * This method is called as the retry thread function.
-     */
-    void connect_retry_loop();
-
-private:
-    /** Called by the #add methods to add a connection.  This method creates
-     * and initializes a ConnectionState object for the connnection, adds
-     * it to either SharedImpl#conn_map or SharedImpl#conn_map_proxy depending
-     * on the type of address, and then issues a connect request.
-     *
-     * @param addr The address to maintain a connection to
-     * @param local_addr The local address to bind to
-     * @param timeout_ms The timeout value (in milliseconds) that gets passed
-     *        into Comm::connect and also used as the waiting period betweeen
-     *        connection attempts
-     * @param service_name The name of the serivce at the other end of the
-     *        connection used for descriptive log messages
-     * @param handler This is the default handler to install on the connection.
-     *        All events get changed through to this handler.
-     * @param initializer Connection initialization handshake driver
-     */
-    void add_internal(const CommAddress &addr, const CommAddress &local_addr,
-            uint32_t timeout_ms, const char *service_name,
-            DispatchHandlerPtr &handler,
-            ConnectionInitializerPtr &initializer);
-
-    /** This method blocks until the connection represented by
-     * <code>conn_state</code> is established.  If the connection is not
-     * established before <code>timer</code> expires, then the method
-     * returns <i>false</i>.
-     * @param conn_state Pointer to connection state object representing
-     * connection
-     * @param timer Maximum wait timer
-     * @return <i>true</i> if connected, <i>false</i> if <code>timer</code>
-     * expired before connection was established.
-     */
-    bool wait_for_connection(ConnectionStatePtr &conn_state, Timer &timer);
-
-    /** Calls Comm::connect to establish a connection.  If the connection
-     * attempt results in an error, an error message is logged indicating
-     * that the connection attempt to the given service failed, and another
-     * connection attempt is scheduled for ConnectionState#timeout_ms in the
-     * future.
-     * @param conn_state Pointer to connection state object representing
-     * connection
-     */
-    void send_connect_request(ConnectionStatePtr &conn_state);
-
-    /// Sends an initialization request.
-    /// @param conn_state Pointer to connection state object representing
-    /// connection
-    void send_initialization_request(ConnectionStatePtr &conn_state);
-
-    /** Schedules a connection retry attempt.  Sets <code>conn_state</code> to
-     * <i>disconnected</i> and schedules another connection attempt in the
-     * future.
-     * @param conn_state Pointer to connection state object representing
-     * connection
-     * @param message Message indicating why retry is being attempted
-     */
-    void schedule_retry(ConnectionStatePtr &conn_state, const std::string &message);
-
-    /// Smart pointer to connection manager state
-    SharedImplPtr m_impl;
-};
-
-/// Smart pointer to ConnectionManager
-typedef std::shared_ptr<ConnectionManager> ConnectionManagerPtr;
-
-}
-#endif //BDG_PALO_BE_SRC_RPC_CONNECTION_MANAGER_H
diff --git a/be/src/rpc/dispatch_handler.h b/be/src/rpc/dispatch_handler.h
deleted file mode 100644
index c19d3208b53772..00000000000000
--- a/be/src/rpc/dispatch_handler.h
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_DISPATCH_HANDLER_H 
-#define BDG_PALO_BE_SRC_RPC_DISPATCH_HANDLER_H 
-
-#include "event.h"
-#include <memory>
-
-namespace palo {
-
-class IOHandler;
-
-/** Abstract base class for application dispatch handlers registered with
- * AsyncComm.  Dispatch handlers are the mechanism by which an application
- * is notified of communication events.
- */
-class DispatchHandler : public std::enable_shared_from_this<DispatchHandler> {
-public:
-    /** Destructor
-    */
-    virtual ~DispatchHandler() { }
-    /** Callback method.  When the Comm layer needs to deliver an event to the
-     * application, this method is called to do so.  The set of event types
-     * include, CONNECTION_ESTABLISHED, DISCONNECT, MESSAGE, ERROR, and TIMER.
-     *
-     * @param event_ptr smart pointer to Event object
-     */
-    virtual void handle(EventPtr& event_ptr) = 0;
-};
-
-/// Smart pointer to DispatchHandler
-typedef std::shared_ptr<DispatchHandler> DispatchHandlerPtr;
-
-} //namespace palo
-
-#endif //BDG_PALO_BE_SRC_RPC_DISPATCH_HANDLER_H 
diff --git a/be/src/rpc/dispatch_handler_synchronizer.cpp b/be/src/rpc/dispatch_handler_synchronizer.cpp
deleted file mode 100644
index e73143ba809750..00000000000000
--- a/be/src/rpc/dispatch_handler_synchronizer.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "dispatch_handler_synchronizer.h"
-#include "protocol.h"
-#include "error.h"
-#include "common/logging.h"
-
-namespace palo {
-
-DispatchHandlerSynchronizer::DispatchHandlerSynchronizer() {
-    return;
-}
-
-void DispatchHandlerSynchronizer::handle(EventPtr &event_ptr) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    m_receive_queue.push(event_ptr);
-    m_cond.notify_one();
-}
-
-bool DispatchHandlerSynchronizer::wait_for_reply(EventPtr &event_ptr) {
-    std::unique_lock<std::mutex> lock(m_mutex);
-    m_cond.wait(lock, [this]() {
-        return !m_receive_queue.empty();
-    });
-    event_ptr = m_receive_queue.front();
-    m_receive_queue.pop();
-    if (event_ptr->type == Event::MESSAGE
-            && Protocol::response_code(event_ptr.get()) == error::OK) {
-        return true;
-    }
-    return false;
-}
-
-bool DispatchHandlerSynchronizer::wait_for_connection() {
-    std::unique_lock<std::mutex> lock(m_mutex);
-    m_cond.wait(lock, [this]() {
-        return !m_receive_queue.empty();
-    });
-    EventPtr event = m_receive_queue.front();
-    m_receive_queue.pop();
-    if (event->type == Event::ERROR)
-        HT_THROW(event->error, "");
-    if (event->type == Event::DISCONNECT)
-        return false;
-    assert(event->type == Event::CONNECTION_ESTABLISHED);
-    return true;
-}
-
-} //namespace palo
diff --git a/be/src/rpc/dispatch_handler_synchronizer.h b/be/src/rpc/dispatch_handler_synchronizer.h
deleted file mode 100644
index 6c03edf0e2f2bc..00000000000000
--- a/be/src/rpc/dispatch_handler_synchronizer.h
+++ /dev/null
@@ -1,114 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_DISPATCH_HANDLER_SYNCHRONIZER_H
-#define BDG_PALO_BE_SRC_RPC_DISPATCH_HANDLER_SYNCHRONIZER_H
-
-#include "dispatch_handler.h"
-#include "event.h"
-
-#include <condition_variable>
-#include <memory>
-#include <mutex>
-#include <queue>
-
-namespace palo {
-
-/** DispatchHandler class used to synchronize with response messages.
- * This class is a specialization of DispatchHandler that is used to
- * synchronize with responses resulting from previously sent request messages.
- * It contains a queue of events (response events) and a condition variable
- * that gets signalled when an event gets put on the queue.
- *
- * Example usage:
- *
- * <pre>
- * {
- *   DispatchHandlerSynchronizer sync_handler;
- *   EventPtr event;
- *   CommBufPtr cbp(... create protocol message here ...);
- *   if ((error = m_comm->send_request(m_addr, cbp, &sync_handler))
- *       != error::OK) {
- *      // log error message here ...
- *      return error;
- *   }
- *   if (!sync_handler.wait_for_reply(event))
- *       // log error message here ...
- *   error = (int)Protocol::response_code(event);
- *   return error;
- * } </pre>
- *
- */
-class DispatchHandlerSynchronizer : public DispatchHandler {
-public:
-
-    /** Constructor.  Initializes state.
-    */
-    DispatchHandlerSynchronizer();
-
-    virtual ~DispatchHandlerSynchronizer() {}
-
-    /** Event Dispatch method.  This gets called by the AsyncComm layer when an
-     * event occurs in response to a previously sent request that was supplied
-     * with this dispatch handler.  It pushes the event onto the event queue and
-     * signals (notify_one) the condition variable.
-     *
-     * @param event Smart pointer to event object
-     */
-    virtual void handle(EventPtr &event);
-
-    /** This method is used by a client to synchronize.  The client
-     * sends a request via the AsyncComm layer with this object
-     * as the dispatch handler.  It then calls this method to
-     * wait for the response (or timeout event).  This method
-     * just blocks on the condition variable until the event
-     * queue is non-empty and then removes and returns the head of the
-     * queue.
-     *
-     * @param event Smart pointer to event object
-     * @return true if next returned event is type MESSAGE and contains
-     *         status error::OK, false otherwise
-     */
-    bool wait_for_reply(EventPtr &event);
-
-    /// Waits for CONNECTION_ESTABLISHED event.
-    /// This function waits for an event to arrive on #m_receive_queue and if it
-    /// is an ERROR event, it throws an exception, if it is a DISCONNECT event
-    /// it returns <i>false</i>, and if it is a CONNECTION_ESTABLISHED event,
-    /// it returns <i>true</i>.
-    /// @return <i>true</i> if CONNECTION_ESTABLISHED event received,
-    /// <i>false</i> if DISCONNECT event received.
-    /// @throws Exception with code set to ERROR event error code.
-    bool wait_for_connection();
-
-private:
-    /// Mutex for serializing concurrent access
-    std::mutex m_mutex;
-    /// Condition variable for signalling change in queue state
-    std::condition_variable m_cond;
-    /// Event queue
-    std::queue<EventPtr> m_receive_queue;
-};
-
-/// Shared smart pointer to DispatchHandlerSynchronizer
-typedef std::shared_ptr<DispatchHandlerSynchronizer> DispatchHandlerSynchronizerPtr;
-
-} //namespace palo
-
-#endif //BDG_PALO_BE_SRC_RPC_DISPATCH_HANDLER_SYNCHRONIZER_H
diff --git a/be/src/rpc/dynamic_buffer.h b/be/src/rpc/dynamic_buffer.h
deleted file mode 100644
index d37a794e22813f..00000000000000
--- a/be/src/rpc/dynamic_buffer.h
+++ /dev/null
@@ -1,202 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_DYNAMIC_BUFFER_H 
-#define BDG_PALO_BE_SRC_RPC_DYNAMIC_BUFFER_H 
-
-#include <cstdint>
-#include <cstring>
-#include <memory>
-
-namespace palo {
-/**
- * A dynamic, resizable and reference counted memory buffer
- */
-class DynamicBuffer {
-public:
-    /**
-     * Constructor
-     *
-     * @param initial_size Initial size of the buffer
-     * @param own_buffer If true, then this object takes ownership of the
-     *      buffer and releases it when going out of scope
-     */
-    explicit DynamicBuffer(size_t initial_size = 0, bool own_buffer = true)
-        : size(initial_size), own(own_buffer) {
-            if (size) {
-                base = ptr = mark = new uint8_t[size];
-            } else {
-                base = ptr = mark = 0;
-            }
-        }
-
-    /** Destructor; releases the buffer if it "owns" it */
-    ~DynamicBuffer() {
-        if (own) {
-            delete [] base;
-        }
-    }
-
-    /** Returns the size of the unused portion */
-    size_t remaining() const { return size - (ptr - base); }
-
-    /** Returns the size of the used portion */
-    size_t fill() const { return ptr - base; }
-
-    /** Returns true if the buffer is empty */
-    bool empty() const { return ptr == base; }
-
-    /**
-     * Ensure space for additional data
-     * Will grow the space to 1.5 of the needed space with existing data
-     * unchanged.
-     *
-     * @param len Additional bytes to grow
-     */
-    void ensure(size_t len) {
-        if (len > remaining()) {
-            grow((fill() + len) * 3 / 2);
-        }
-    }
-
-    /**
-     * Reserve space for additional data
-     * Will grow the space to exactly what's needed. Existing data is NOT
-     * preserved by default
-     *
-     * @param len Size of the reserved space
-     * @param nocopy If true then the existing data is not preserved
-     */
-    void reserve(size_t len, bool nocopy = false) {
-        if (len > remaining()) {
-            grow(fill() + len, nocopy);
-        }
-    }
-
-    /** Adds additional data without boundary checks
-     *
-     * @param data A pointer to the new data
-     * @param len The size of the new data
-     * @return A pointer to the added data
-     */
-    uint8_t *add_unchecked(const void *data, size_t len) {
-        if (data == 0) {
-            return 0;
-        }
-        uint8_t *rptr = ptr;
-        memcpy(ptr, data, len);
-        ptr += len;
-        return rptr;
-    }
-
-    /** Adds more data WITH boundary checks; if required the buffer is resized
-     * and existing data is preserved
-     *
-     * @param data A pointer to the new data
-     * @param len The size of the new data
-     * @return A pointer to the added data
-     */
-    uint8_t *add(const void *data, size_t len) {
-        ensure(len);
-        return add_unchecked(data, len);
-    }
-
-    /** Overwrites the existing data
-     *
-     * @param data A pointer to the new data
-     * @param len The size of the new data
-     */
-    void set(const void *data, size_t len) {
-        clear();
-        reserve(len);
-        add_unchecked(data, len);
-    }
-
-    /** Clears the buffer */
-    void clear() {
-        ptr = base;
-    }
-
-    /** Sets the mark; the mark can be used by the caller just like a
-     * bookmark */
-    void set_mark() {
-        mark = ptr;
-    }
-
-    /** Frees resources */
-    void free() {
-        if (own) {
-            delete [] base;
-        }
-        base = ptr = mark = 0;
-        size = 0;
-    }
-
-    /** Moves ownership of the buffer to the caller
-     *
-     * @param lenp If not null then the length of the buffer is stored
-     * @return A pointer to the data
-     */
-    uint8_t *release(size_t *lenp = 0) {
-        uint8_t *rbuf = base;
-        if (lenp) {
-            *lenp = fill();
-        }
-        ptr = base = mark = 0;
-        size = 0;
-        return rbuf;
-    }
-
-    /** Grows the buffer and copies the data unless nocopy is true
-     *
-     * @param new_size The new buffer size
-     * @param nocopy If true then the data will not be preserved
-     */
-    void grow(size_t new_size, bool nocopy = false) {
-        uint8_t *new_buf = new uint8_t[new_size];
-        if (!nocopy && base) {
-            memcpy(new_buf, base, ptr-base);
-        }
-        ptr = new_buf + (ptr-base);
-        mark = new_buf + (mark-base);
-        if (own) {
-            delete [] base;
-        }
-        base = new_buf;
-        size = new_size;
-    }
-
-    /** Pointer to the allocated memory buffer */
-    uint8_t *base;
-    /** Pointer to the end of the used part of the buffer */
-    uint8_t *ptr;
-    /** A "bookmark", can be set by the caller */
-    uint8_t *mark;
-    /** The size of the allocated memory buffer (@ref base) */
-    uint32_t size;
-    /** If true then the buffer (@ref base) will be released when going out of
-     * scope; if false then the caller has to release it */
-    bool own;
-};
-
-typedef std::shared_ptr<DynamicBuffer> DynamicBufferPtr;
-
-} //namespace palo
-
-#endif //BDG_PALO_BE_SRC_RPC_DYNAMIC_BUFFER_H 
diff --git a/be/src/rpc/endian_c.h b/be/src/rpc/endian_c.h
deleted file mode 100644
index 1e7b445946b05d..00000000000000
--- a/be/src/rpc/endian_c.h
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_ENDIAN_C_H
-#define BDG_PALO_BE_SRC_RPC_ENDIAN_C_H
-
-/* GNU libc offers the helpful header <endian.h> which defines __BYTE_ORDER */
-#if defined (__GLIBC__)
-# include <endian.h>
-# if (__BYTE_ORDER == __LITTLE_ENDIAN)
-#  define HT_LITTLE_ENDIAN
-# elif (__BYTE_ORDER == __BIG_ENDIAN)
-#  define HT_BIG_ENDIAN
-# elif (__BYTE_ORDER == __PDP_ENDIAN)
-#  define HT_PDP_ENDIAN
-# else
-#  error Unknown machine endianness detected.
-# endif
-# define HT_BYTE_ORDER __BYTE_ORDER
-#elif defined(__sparc) || defined(__sparc__) \
-    || defined(_POWER) || defined(__powerpc__) \
-|| defined(__ppc__) || defined(__hpux) \
-|| defined(_MIPSEB) || defined(_POWER) \
-|| defined(__s390__)
-
-# define HT_BIG_ENDIAN
-# define HT_BYTE_ORDER 4321
-#elif defined(__i386__) || defined(__alpha__) \
-    || defined(__ia64) || defined(__ia64__) \
-|| defined(_M_IX86) || defined(_M_IA64) \
-|| defined(_M_ALPHA) || defined(__amd64) \
-|| defined(__amd64__) || defined(_M_AMD64) \
-|| defined(__x86_64) || defined(__x86_64__) \
-|| defined(_M_X64)
-# define HT_LITTLE_ENDIAN
-# define HT_BYTE_ORDER 1234
-#else
-# error The file endian.h needs to be set up for your CPU type.
-#endif
-
-#endif //BDG_PALO_BE_SRC_RPC_ENDIAN_C_H
diff --git a/be/src/rpc/error.cpp b/be/src/rpc/error.cpp
deleted file mode 100644
index fd903e9037613c..00000000000000
--- a/be/src/rpc/error.cpp
+++ /dev/null
@@ -1,450 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "error.h"
-#include "common/logging.h"
-#include <iomanip>
-#include <unordered_map>
-
-namespace palo {
-
-namespace error { 
-
-struct ErrorInfo {
-    int          code;
-    const char  *text;
-};
-
-ErrorInfo error_info[] = {
-    { error::UNPOSSIBLE,                  "But that's unpossible!" },
-    { error::EXTERNAL,                    "External error" },
-    { error::FAILED_EXPECTATION,          "PALO failed expectation" },
-    { error::OK,                          "PALO ok" },
-    { error::PROTOCOL_ERROR,              "PALO protocol error" },
-    { error::REQUEST_TRUNCATED,           "PALO request truncated" },
-    { error::RESPONSE_TRUNCATED,          "PALO response truncated" },
-    { error::REQUEST_TIMEOUT,             "PALO request timeout" },
-    { error::LOCAL_IO_ERROR,              "PALO local i/o error" },
-    { error::BAD_ROOT_LOCATION,           "PALO bad root location" },
-    { error::BAD_SCHEMA,                  "PALO bad schema" },
-    { error::INVALID_METADATA,            "PALO invalid metadata" },
-    { error::BAD_KEY,                     "PALO bad key" },
-    { error::METADATA_NOT_FOUND,          "PALO metadata not found" },
-    { error::HQL_PARSE_ERROR,             "PALO HQL parse error" },
-    { error::FILE_NOT_FOUND,              "PALO file not found" },
-    {   error::BLOCK_COMPRESSOR_UNSUPPORTED_TYPE,
-        "PALO block compressor unsupported type"
-    },
-    {   error::BLOCK_COMPRESSOR_INVALID_ARG,
-        "PALO block compressor invalid arg"
-    },
-    {   error::BLOCK_COMPRESSOR_TRUNCATED,
-        "PALO block compressor block truncated"
-    },
-    {   error::BLOCK_COMPRESSOR_BAD_HEADER,
-        "PALO block compressor bad block header"
-    },
-    {   error::BLOCK_COMPRESSOR_BAD_MAGIC,
-        "PALO block compressor bad magic string"
-    },
-    {   error::BLOCK_COMPRESSOR_CHECKSUM_MISMATCH,
-        "PALO block compressor block checksum mismatch"
-    },
-    {   error::BLOCK_COMPRESSOR_DEFLATE_ERROR,
-        "PALO block compressor deflate error"
-    },
-    {   error::BLOCK_COMPRESSOR_INFLATE_ERROR,
-        "PALO block compressor inflate error"
-    },
-    {   error::BLOCK_COMPRESSOR_INIT_ERROR,
-        "PALO block compressor initialization error"
-    },
-    { error::TABLE_NOT_FOUND,             "PALO table does not exist" },
-    { error::COMMAND_PARSE_ERROR,         "PALO command parse error" },
-    { error::CONNECT_ERROR_MASTER,        "PALO Master connect error" },
-    {   error::CONNECT_ERROR_HYPERSPACE,
-        "PALO Hyperspace client connect error"
-    },
-    { error::TOO_MANY_COLUMNS,            "PALO too many columns" },
-    { error::BAD_DOMAIN_NAME,             "PALO bad domain name" },
-    { error::MALFORMED_REQUEST,           "PALO malformed request" },
-    { error::BAD_MEMORY_ALLOCATION,       "PALO bad memory allocation"},
-    { error::BAD_SCAN_SPEC,               "PALO bad scan specification"},
-    { error::NOT_IMPLEMENTED,             "PALO not implemented"},
-    { error::VERSION_MISMATCH,            "PALO version mismatch"},
-    { error::CANCELLED,                   "PALO cancelled"},
-    { error::SCHEMA_PARSE_ERROR,          "PALO schema parse error" },
-    { error::SYNTAX_ERROR,                "PALO syntax error" },
-    { error::DOUBLE_UNGET,                  "PALO double unget" },
-    { error::EMPTY_BLOOMFILTER,             "PALO empty bloom filter" },
-    { error::BLOOMFILTER_CHECKSUM_MISMATCH, "PALO bloom filter checksum mismatch" },
-    { error::NAME_ALREADY_IN_USE,           "PALO name already in use" },
-    { error::NAMESPACE_DOES_NOT_EXIST,      "PALO namespace does not exist" },
-    { error::BAD_NAMESPACE,                 "PALO bad namespace" },
-    { error::NAMESPACE_EXISTS,              "PALO namespace exists" },
-    { error::NO_RESPONSE,                   "PALO no response" },
-    { error::NOT_ALLOWED,                   "PALO not allowed" },
-    { error::INDUCED_FAILURE,               "PALO induced failure" },
-    { error::SERVER_SHUTTING_DOWN,          "PALO server shutting down" },
-    { error::LOCATION_UNASSIGNED,           "PALO location unassigned" },
-    { error::ALREADY_EXISTS,                "PALO cell already exists" },
-    { error::CHECKSUM_MISMATCH,             "PALO checksum mismatch" },
-    { error::CLOSED,                        "PALO closed" },
-    { error::RANGESERVER_NOT_FOUND,         "PALO RangeServer not found" },
-    { error::CONNECTION_NOT_INITIALIZED,    "PALO connection not initialized" },
-    { error::DUPLICATE_RANGE,               "PALO duplicate range" },
-    { error::INVALID_PSEUDO_TABLE_NAME,     "PALO invalid pseudo-table name" },
-    { error::BAD_FORMAT,                    "PALO bad format" },
-    { error::INVALID_ARGUMENT,              "PALO invalid argument" },
-    { error::INVALID_OPERATION,             "PALO invalid operation" },
-    { error::UNSUPPORTED_OPERATION,         "PALO unsupported operation" },
-    { error::COLUMN_FAMILY_NOT_FOUND,       "PALO column family not found" },
-    { error::NOTHING_TO_DO,                 "PALO nothing to do" },
-    { error::INCOMPATIBLE_OPTIONS,          "PALO incompatible options" },
-    { error::BAD_VALUE,                     "PALO bad value" },
-    { error::SCHEMA_GENERATION_MISMATCH,    "PALO schema generation mismatch" },
-    { error::INVALID_METHOD_IDENTIFIER,     "PALO invalid method identifier" },
-    { error::SERVER_NOT_READY,              "PALO server not ready" },
-    { error::CONFIG_BAD_ARGUMENT,         "CONFIG bad argument(s)"},
-    { error::CONFIG_BAD_CFG_FILE,         "CONFIG bad cfg file"},
-    { error::CONFIG_GET_ERROR,            "CONFIG failed to get config value"},
-    { error::CONFIG_BAD_VALUE,            "CONFIG bad config value"},
-    { error::COMM_NOT_CONNECTED,          "COMM not connected" },
-    { error::COMM_BROKEN_CONNECTION,      "COMM broken connection" },
-    { error::COMM_CONNECT_ERROR,          "COMM connect error" },
-    { error::COMM_ALREADY_CONNECTED,      "COMM already connected" },
-    { error::COMM_SEND_ERROR,             "COMM send error" },
-    { error::COMM_RECEIVE_ERROR,          "COMM receive error" },
-    { error::COMM_POLL_ERROR,             "COMM poll error" },
-    { error::COMM_CONFLICTING_ADDRESS,    "COMM conflicting address" },
-    { error::COMM_SOCKET_ERROR,           "COMM socket error" },
-    { error::COMM_BIND_ERROR,             "COMM bind error" },
-    { error::COMM_LISTEN_ERROR,           "COMM listen error" },
-    { error::COMM_HEADER_CHECKSUM_MISMATCH,  "COMM header checksum mismatch" },
-    { error::COMM_PAYLOAD_CHECKSUM_MISMATCH, "COMM payload checksum mismatch" },
-    { error::COMM_BAD_HEADER,             "COMM bad header" },
-    { error::COMM_INVALID_PROXY,          "COMM invalid proxy" },
-    { error::FSBROKER_BAD_FILE_HANDLE,   "FS BROKER bad file handle" },
-    { error::FSBROKER_IO_ERROR,          "FS BROKER i/o error" },
-    { error::FSBROKER_FILE_NOT_FOUND,    "FS BROKER file not found" },
-    { error::FSBROKER_BAD_FILENAME,      "FS BROKER bad filename" },
-    { error::FSBROKER_PERMISSION_DENIED, "FS BROKER permission denied" },
-    { error::FSBROKER_INVALID_ARGUMENT,  "FS BROKER invalid argument" },
-    { error::FSBROKER_INVALID_CONFIG,    "FS BROKER invalid config value" },
-    { error::FSBROKER_EOF,               "FS BROKER end of file" },
-    { error::HYPERSPACE_IO_ERROR,          "HYPERSPACE i/o error" },
-    { error::HYPERSPACE_CREATE_FAILED,     "HYPERSPACE create failed" },
-    { error::HYPERSPACE_FILE_NOT_FOUND,    "HYPERSPACE file not found" },
-    { error::HYPERSPACE_ATTR_NOT_FOUND,    "HYPERSPACE attribute not found" },
-    { error::HYPERSPACE_DELETE_ERROR,      "HYPERSPACE delete error" },
-    { error::HYPERSPACE_BAD_PATHNAME,      "HYPERSPACE bad pathname" },
-    { error::HYPERSPACE_PERMISSION_DENIED, "HYPERSPACE permission denied" },
-    { error::HYPERSPACE_EXPIRED_SESSION,   "HYPERSPACE expired session" },
-    { error::HYPERSPACE_FILE_EXISTS,       "HYPERSPACE file exists" },
-    { error::HYPERSPACE_IS_DIRECTORY,      "HYPERSPACE is directory" },
-    { error::HYPERSPACE_INVALID_HANDLE,    "HYPERSPACE invalid handle" },
-    { error::HYPERSPACE_REQUEST_CANCELLED, "HYPERSPACE request cancelled" },
-    { error::HYPERSPACE_MODE_RESTRICTION,  "HYPERSPACE mode restriction" },
-    { error::HYPERSPACE_ALREADY_LOCKED,    "HYPERSPACE already locked" },
-    { error::HYPERSPACE_LOCK_CONFLICT,     "HYPERSPACE lock conflict" },
-    { error::HYPERSPACE_NOT_LOCKED,        "HYPERSPACE not locked" },
-    { error::HYPERSPACE_BAD_ATTRIBUTE,     "HYPERSPACE bad attribute" },
-    { error::HYPERSPACE_BERKELEYDB_ERROR,  "HYPERSPACE Berkeley DB error" },
-    { error::HYPERSPACE_DIR_NOT_EMPTY,     "HYPERSPACE directory not empty" },
-    {   error::HYPERSPACE_BERKELEYDB_DEADLOCK,
-        "HYPERSPACE Berkeley DB deadlock"
-    },
-    {   error::HYPERSPACE_BERKELEYDB_REP_HANDLE_DEAD,
-        "HYPERSPACE Berkeley DB replication handle dead"
-    },
-    { error::HYPERSPACE_FILE_OPEN,        "HYPERSPACE file open" },
-    { error::HYPERSPACE_CLI_PARSE_ERROR,  "HYPERSPACE CLI parse error" },
-    {   error::HYPERSPACE_CREATE_SESSION_FAILED,
-        "HYPERSPACE unable to create session "
-    },
-    {   error::HYPERSPACE_NOT_MASTER_LOCATION,
-        "HYPERSPACE not master location"
-    },
-    {   error::HYPERSPACE_STATEDB_ERROR,
-        "HYPERSPACE State DB error"
-    },
-    {   error::HYPERSPACE_STATEDB_DEADLOCK,
-        "HYPERSPACE State DB deadlock"
-    },
-    {   error::HYPERSPACE_STATEDB_BAD_KEY,
-        "HYPERSPACE State DB bad key"
-    },
-    {   error::HYPERSPACE_STATEDB_BAD_VALUE,
-        "HYPERSPACE State DB bad value"
-    },
-    {   error::HYPERSPACE_STATEDB_ALREADY_DELETED,
-        "HYPERSPACE State DB attempt to access/delete previously deleted state"
-    },
-    {   error::HYPERSPACE_STATEDB_EVENT_EXISTS,
-        "HYPERSPACE State DB event exists"
-    },
-    {   error::HYPERSPACE_STATEDB_EVENT_NOT_EXISTS,
-        "HYPERSPACE State DB event does not exist"
-    },
-    {   error::HYPERSPACE_STATEDB_EVENT_ATTR_NOT_FOUND,
-        "HYPERSPACE State DB event attr not found"
-    },
-    {   error::HYPERSPACE_STATEDB_SESSION_EXISTS,
-        "HYPERSPACE State DB session exists"
-    },
-    {   error::HYPERSPACE_STATEDB_SESSION_NOT_EXISTS,
-        "HYPERSPACE State DB session does not exist"
-    },
-    {   error::HYPERSPACE_STATEDB_SESSION_ATTR_NOT_FOUND,
-        "HYPERSPACE State DB session attr not found"
-    },
-    {   error::HYPERSPACE_STATEDB_HANDLE_EXISTS,
-        "HYPERSPACE State DB handle exists"
-    },
-    {   error::HYPERSPACE_STATEDB_HANDLE_NOT_EXISTS,
-        "HYPERSPACE State DB handle does not exist"
-    },
-    {   error::HYPERSPACE_STATEDB_HANDLE_ATTR_NOT_FOUND,
-        "HYPERSPACE State DB handle attr not found"
-    },
-    {   error::HYPERSPACE_STATEDB_NODE_EXISTS,
-        "HYPERSPACE State DB node exists"
-    },
-    {   error::HYPERSPACE_STATEDB_NODE_NOT_EXISTS,
-        "HYPERSPACE State DB node does not exist"
-    },
-    {   error::HYPERSPACE_STATEDB_NODE_ATTR_NOT_FOUND,
-        "HYPERSPACE State DB node attr not found"
-    },
-    {   error::HYPERSPACE_VERSION_MISMATCH,
-        "HYPERSPACE client/server protocol version mismatch"
-    },
-    { error::MASTER_TABLE_EXISTS,         "MASTER table exists" },
-    { error::MASTER_BAD_SCHEMA,           "MASTER bad schema" },
-    { error::MASTER_NOT_RUNNING,          "MASTER not running" },
-    { error::MASTER_NO_RANGESERVERS,      "MASTER no range servers" },
-    { error::MASTER_FILE_NOT_LOCKED,      "MASTER file not locked" },
-    {   error::MASTER_RANGESERVER_ALREADY_REGISTERED,
-        "MASTER range server with same location already registered"
-    },
-    { error::MASTER_BAD_COLUMN_FAMILY,    "MASTER bad column family" },
-    {   error::MASTER_SCHEMA_GENERATION_MISMATCH,
-        "Master schema generation mismatch"
-    },
-    {   error::MASTER_LOCATION_ALREADY_ASSIGNED,
-        "MASTER location already assigned"
-    },
-    { error::MASTER_LOCATION_INVALID, "MASTER location invalid" },
-    { error::MASTER_OPERATION_IN_PROGRESS, "MASTER operation in progress" },
-    { error::MASTER_RANGESERVER_IN_RECOVERY, "MASTER RangeServer in recovery" },
-    { error::MASTER_BALANCE_PREVENTED, "MASTER balance operation prevented" },
-    {   error::RANGESERVER_GENERATION_MISMATCH,
-        "RANGE SERVER generation mismatch"
-    },
-    {   error::RANGESERVER_RANGE_ALREADY_LOADED,
-        "RANGE SERVER range already loaded"
-    },
-    { error::RANGESERVER_RANGE_MISMATCH,       "RANGE SERVER range mismatch" },
-    {   error::RANGESERVER_NONEXISTENT_RANGE,
-        "RANGE SERVER non-existent range"
-    },
-    { error::RANGESERVER_OUT_OF_RANGE,         "RANGE SERVER out of range" },
-    { error::RANGESERVER_RANGE_NOT_FOUND,      "RANGE SERVER range not found" },
-    {   error::RANGESERVER_INVALID_SCANNER_ID,
-        "RANGE SERVER invalid scanner id"
-    },
-    {   error::RANGESERVER_SCHEMA_PARSE_ERROR,
-        "RANGE SERVER schema parse error"
-    },
-    {   error::RANGESERVER_SCHEMA_INVALID_CFID,
-        "RANGE SERVER invalid column family id"
-    },
-    {   error::RANGESERVER_INVALID_COLUMNFAMILY,
-        "RANGE SERVER invalid column family"
-    },
-    {   error::RANGESERVER_TRUNCATED_COMMIT_LOG,
-        "RANGE SERVER truncated commit log"
-    },
-    {   error::RANGESERVER_NO_METADATA_FOR_RANGE,
-        "RANGE SERVER no metadata for range"
-    },
-    { error::RANGESERVER_SHUTTING_DOWN,        "RANGE SERVER shutting down" },
-    {   error::RANGESERVER_CORRUPT_COMMIT_LOG,
-        "RANGE SERVER corrupt commit log"
-    },
-    { error::RANGESERVER_UNAVAILABLE,          "RANGE SERVER unavailable" },
-    {   error::RANGESERVER_REVISION_ORDER_ERROR,
-        "RANGE SERVER supplied revision is not strictly increasing"
-    },
-    { error::RANGESERVER_ROW_OVERFLOW,         "RANGE SERVER row overflow" },
-    { error::RANGESERVER_TABLE_NOT_FOUND,      "RANGE SERVER table not found" },
-    {   error::RANGESERVER_BAD_SCAN_SPEC,
-        "RANGE SERVER bad scan specification"
-    },
-    {   error::RANGESERVER_CLOCK_SKEW,
-        "RANGE SERVER clock skew detected"
-    },
-    {   error::RANGESERVER_BAD_CELLSTORE_FILENAME,
-        "RANGE SERVER bad CellStore filename"
-    },
-    {   error::RANGESERVER_CORRUPT_CELLSTORE,
-        "RANGE SERVER corrupt CellStore"
-    },
-    { error::RANGESERVER_TABLE_DROPPED, "RANGE SERVER table dropped" },
-    { error::RANGESERVER_UNEXPECTED_TABLE_ID, "RANGE SERVER unexpected table ID" },
-    { error::RANGESERVER_RANGE_BUSY, "RANGE SERVER range busy" },
-    { error::RANGESERVER_BAD_CELL_INTERVAL, "RANGE SERVER bad cell interval" },
-    { error::RANGESERVER_SHORT_CELLSTORE_READ, "RANGE SERVER short cellstore read" },
-    { error::RANGESERVER_RANGE_NOT_ACTIVE, "RANGE SERVER range no longer active" },
-    {   error::RANGESERVER_FRAGMENT_ALREADY_PROCESSED,
-        "RANGE SERVER fragment already processed"
-    },
-    {   error::RANGESERVER_RECOVERY_PLAN_GENERATION_MISMATCH,
-        "RANGE SERVER recovery plan generation mismatch"
-    },
-    {   error::RANGESERVER_PHANTOM_RANGE_MAP_NOT_FOUND,
-        "RANGE SERVER phantom range map not found"
-    },
-    {   error::RANGESERVER_RANGES_ALREADY_LIVE,
-        "RANGE SERVER ranges already live"
-    },
-    {   error::RANGESERVER_RANGE_NOT_YET_ACKNOWLEDGED,
-        "RANGE SERVER range not yet acknowledged"
-    },
-    {   error::RANGESERVER_SERVER_IN_READONLY_MODE,
-        "RANGE SERVER server in readonly mode"
-    },
-    {   error::RANGESERVER_RANGE_NOT_YET_RELINQUISHED,
-        "RANGE SERVER range not yet relinquished"
-    },
-    { error::HQL_BAD_LOAD_FILE_FORMAT,         "HQL bad load file format" },
-    { error::HQL_BAD_COMMAND, "HQL bad command" },
-    { error::METALOG_VERSION_MISMATCH, "METALOG version mismatch" },
-    { error::METALOG_BAD_RS_HEADER, "METALOG bad range server metalog header" },
-    { error::METALOG_BAD_HEADER,  "METALOG bad metalog header" },
-    { error::METALOG_ENTRY_TRUNCATED,   "METALOG entry truncated" },
-    { error::METALOG_CHECKSUM_MISMATCH, "METALOG checksum mismatch" },
-    { error::METALOG_ENTRY_BAD_TYPE, "METALOG bad entry type" },
-    { error::METALOG_ENTRY_BAD_ORDER, "METALOG entry out of order" },
-    { error::METALOG_MISSING_RECOVER_ENTITY, "METALOG missing RECOVER entity" },
-    { error::METALOG_BACKUP_FILE_MISMATCH, "METALOG backup file mismatch" },
-    { error::METALOG_READ_ERROR, "METALOG read error" },
-    {   error::SERIALIZATION_INPUT_OVERRUN,
-        "SERIALIZATION input buffer overrun"
-    },
-    { error::SERIALIZATION_BAD_VINT,      "SERIALIZATION bad vint encoding" },
-    { error::SERIALIZATION_BAD_VSTR,      "SERIALIZATION bad vstr encoding" },
-    { error::SERIALIZATION_VERSION_MISMATCH, "SERIALIZATION version mismatch" },
-    { error::THRIFTBROKER_BAD_SCANNER_ID, "THRIFT BROKER bad scanner id" },
-    { error::THRIFTBROKER_BAD_MUTATOR_ID, "THRIFT BROKER bad mutator id" },
-    { error::THRIFTBROKER_BAD_NAMESPACE_ID, "THRIFT BROKER bad namespace id" },
-    { error::THRIFTBROKER_BAD_FUTURE_ID,    "THRIFT BROKER bad future id" },
-    { 0, 0 }
-};
-
-typedef std::unordered_map<int, const char *>  TextMap;
-TextMap &build_text_map() {
-    TextMap *map = new TextMap();
-    for (int i = 0; error_info[i].text != 0; i++) {
-        (*map)[error_info[i].code] = error_info[i].text;
-    }
-    return *map;
-}
-
-TextMap &text_map = build_text_map();
-
-const char* get_text(int error) {
-    const char *text = text_map[error];
-    if (text == 0) {
-        return "ERROR NOT REGISTERED";
-    }
-    return text;
-}
-
-void generate_html_error_code_documentation(std::ostream &out) {
-    out << "<table border=\"1\" cellpadding=\"4\" cellspacing=\"1\" style=\"width: 720px; \">\n";
-    out << "<thead><tr><th scope=\"col\">Code<br />(hexidecimal)</th>\n";
-    out << "<th scope=\"col\">Code<br />(decimal)</th>\n";
-    out << "<th scope=\"col\">Description</th></tr></thead><tbody>\n";
-    for (size_t i = 0; error_info[i].text; i++) {
-        if (error_info[i].code >= 0) {
-            out << "<tr><td style=\"text-align: right; \"><code>0x" 
-                << std::hex << error_info[i].code << "</code></td>\n";
-        } else {
-            out << "<tr><td style=\"text-align: right; \"><code></code></td>\n";
-        }
-        out << "<td style=\"text-align: right; \"><code>" 
-            << std::dec << error_info[i].code << "</code></td>\n";
-        out << "<td>" << error_info[i].text << "</td></tr>\n";
-    }
-    out << "</tbody></table>\n" << std::flush;
-}
-
-} //namespace error
-
-const char *relative_fname(const Exception &e) {
-    if (e.file()) {
-        const char *ptr = strstr(e.file(), "src/cc/");
-        return ptr ? ptr : e.file();
-    }
-    return "";
-}
-
-std::ostream &operator<<(std::ostream &out, const Exception &e) {
-    out << "palo::Exception: " << e.message() << " - "
-        << error::get_text(e.code());
-    if (e.line()) {
-        out << "\n\tat " << e.func() << " (";
-        //if (Logger::get()->show_line_numbers())
-        if (true) {
-            out << e.file() << ':' << e.line();
-        } else {
-            out << relative_fname(e);
-        }
-        out << ')';
-    }
-    int prev_code = e.code();
-    for (Exception *prev = e.prev; prev; prev = prev->prev) {
-        out << "\n\tat " << (prev->func() ? prev->func() : "-") << " (";
-        //if (Logger::get()->show_line_numbers())
-        if (true) {
-            out << (prev->file() ? prev->file() : "-") << ':' << prev->line();
-        } else {
-            out << relative_fname(*prev);
-        }
-        out << "): " << prev->message();
-        if (prev->code() != prev_code) {
-            out << " - " << error::get_text(prev->code());
-            prev_code = prev->code();
-        }
-    }
-    return out;
-}
-
-std::ostream &
-Exception::render_messages(std::ostream &out, const char *sep) const {
-    out << message() << " - " << error::get_text(m_error);
-    for (Exception *p = prev; p; p = p->prev) {
-        out << sep << p->message();
-    }
-    return out;
-}
-
-} // namespace palo
diff --git a/be/src/rpc/error.h b/be/src/rpc/error.h
deleted file mode 100644
index 6568a6aabff234..00000000000000
--- a/be/src/rpc/error.h
+++ /dev/null
@@ -1,532 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_ERROR_H
-#define BDG_PALO_BE_SRC_RPC_ERROR_H
-
-#include "compat.h"
-#include "util.h"
-#include "common/logging.h"
-#include <ostream>
-#include <stdexcept>
-
-namespace palo { 
-
-namespace error {
-
-enum Code {
-    UNPOSSIBLE                                   = -3,
-    EXTERNAL                                     = -2,
-    FAILED_EXPECTATION                           = -1,
-    OK                                           = 0,
-    PROTOCOL_ERROR                               = 1,
-    REQUEST_TRUNCATED                            = 2,
-    RESPONSE_TRUNCATED                           = 3,
-    REQUEST_TIMEOUT                              = 4,
-    LOCAL_IO_ERROR                               = 5,
-    BAD_ROOT_LOCATION                            = 6,
-    BAD_SCHEMA                                   = 7,
-    INVALID_METADATA                             = 8,
-    BAD_KEY                                      = 9,
-    METADATA_NOT_FOUND                           = 10,
-    HQL_PARSE_ERROR                              = 11,
-    FILE_NOT_FOUND                               = 12,
-    BLOCK_COMPRESSOR_UNSUPPORTED_TYPE            = 13,
-    BLOCK_COMPRESSOR_INVALID_ARG                 = 14,
-    BLOCK_COMPRESSOR_TRUNCATED                   = 15,
-    BLOCK_COMPRESSOR_BAD_HEADER                  = 16,
-    BLOCK_COMPRESSOR_BAD_MAGIC                   = 17,
-    BLOCK_COMPRESSOR_CHECKSUM_MISMATCH           = 18,
-    BLOCK_COMPRESSOR_DEFLATE_ERROR               = 19,
-    BLOCK_COMPRESSOR_INFLATE_ERROR               = 20,
-    BLOCK_COMPRESSOR_INIT_ERROR                  = 21,
-    TABLE_NOT_FOUND                              = 22,
-    MALFORMED_REQUEST                            = 23,
-    TOO_MANY_COLUMNS                             = 24,
-    BAD_DOMAIN_NAME                              = 25,
-    COMMAND_PARSE_ERROR                          = 26,
-    CONNECT_ERROR_MASTER                         = 27,
-    CONNECT_ERROR_HYPERSPACE                     = 28,
-    BAD_MEMORY_ALLOCATION                        = 29,
-    BAD_SCAN_SPEC                                = 30,
-    NOT_IMPLEMENTED                              = 31,
-    VERSION_MISMATCH                             = 32,
-    CANCELLED                                    = 33,
-    SCHEMA_PARSE_ERROR                           = 34,
-    SYNTAX_ERROR                                 = 35,
-    DOUBLE_UNGET                                 = 36,
-    EMPTY_BLOOMFILTER                            = 37,
-    BLOOMFILTER_CHECKSUM_MISMATCH                = 38,
-    NAME_ALREADY_IN_USE                          = 39,
-    NAMESPACE_DOES_NOT_EXIST                     = 40,
-    BAD_NAMESPACE                                = 41,
-    NAMESPACE_EXISTS                             = 42,
-    NO_RESPONSE                                  = 43,
-    NOT_ALLOWED                                  = 44,
-    INDUCED_FAILURE                              = 45,
-    SERVER_SHUTTING_DOWN                         = 46,
-    LOCATION_UNASSIGNED                          = 47,
-    ALREADY_EXISTS                               = 48,
-    CHECKSUM_MISMATCH                            = 49,
-    CLOSED                                       = 50,
-    RANGESERVER_NOT_FOUND                        = 51,
-    CONNECTION_NOT_INITIALIZED                   = 52,
-    DUPLICATE_RANGE                              = 53,
-    INVALID_PSEUDO_TABLE_NAME                    = 54,
-    BAD_FORMAT                                   = 55,
-    INVALID_ARGUMENT                             = 56,
-    INVALID_OPERATION                            = 57,
-    UNSUPPORTED_OPERATION                        = 58,
-    COLUMN_FAMILY_NOT_FOUND                      = 59,
-    NOTHING_TO_DO                                = 60,
-    INCOMPATIBLE_OPTIONS                         = 61,
-    BAD_VALUE                                    = 62,
-    SCHEMA_GENERATION_MISMATCH                   = 63,
-    INVALID_METHOD_IDENTIFIER                    = 64,
-    SERVER_NOT_READY                             = 65,
-
-    CONFIG_BAD_ARGUMENT                          = 1001,
-    CONFIG_BAD_CFG_FILE                          = 1002,
-    CONFIG_GET_ERROR                             = 1003,
-    CONFIG_BAD_VALUE                             = 1004,
-
-    COMM_NOT_CONNECTED                           = 0x00010001,
-    COMM_BROKEN_CONNECTION                       = 0x00010002,
-    COMM_CONNECT_ERROR                           = 0x00010003,
-    COMM_ALREADY_CONNECTED                       = 0x00010004,
-
-    COMM_SEND_ERROR                              = 0x00010006,
-    COMM_RECEIVE_ERROR                           = 0x00010007,
-    COMM_POLL_ERROR                              = 0x00010008,
-    COMM_CONFLICTING_ADDRESS                     = 0x00010009,
-    COMM_SOCKET_ERROR                            = 0x0001000A,
-    COMM_BIND_ERROR                              = 0x0001000B,
-    COMM_LISTEN_ERROR                            = 0x0001000C,
-    COMM_HEADER_CHECKSUM_MISMATCH                = 0x0001000D,
-    COMM_PAYLOAD_CHECKSUM_MISMATCH               = 0x0001000E,
-    COMM_BAD_HEADER                              = 0x0001000F,
-    COMM_INVALID_PROXY                           = 0x00010010,
-
-    FSBROKER_BAD_FILE_HANDLE                    = 0x00020001,
-    FSBROKER_IO_ERROR                           = 0x00020002,
-    FSBROKER_FILE_NOT_FOUND                     = 0x00020003,
-    FSBROKER_BAD_FILENAME                       = 0x00020004,
-    FSBROKER_PERMISSION_DENIED                  = 0x00020005,
-    FSBROKER_INVALID_ARGUMENT                   = 0x00020006,
-    FSBROKER_INVALID_CONFIG                     = 0x00020007,
-    FSBROKER_EOF                                = 0x00020008,
-
-    HYPERSPACE_IO_ERROR                          = 0x00030001,
-    HYPERSPACE_CREATE_FAILED                     = 0x00030002,
-    HYPERSPACE_FILE_NOT_FOUND                    = 0x00030003,
-    HYPERSPACE_ATTR_NOT_FOUND                    = 0x00030004,
-    HYPERSPACE_DELETE_ERROR                      = 0x00030005,
-    HYPERSPACE_BAD_PATHNAME                      = 0x00030006,
-    HYPERSPACE_PERMISSION_DENIED                 = 0x00030007,
-    HYPERSPACE_EXPIRED_SESSION                   = 0x00030008,
-    HYPERSPACE_FILE_EXISTS                       = 0x00030009,
-    HYPERSPACE_IS_DIRECTORY                      = 0x0003000A,
-    HYPERSPACE_INVALID_HANDLE                    = 0x0003000B,
-    HYPERSPACE_REQUEST_CANCELLED                 = 0x0003000C,
-    HYPERSPACE_MODE_RESTRICTION                  = 0x0003000D,
-    HYPERSPACE_ALREADY_LOCKED                    = 0x0003000E,
-    HYPERSPACE_LOCK_CONFLICT                     = 0x0003000F,
-    HYPERSPACE_NOT_LOCKED                        = 0x00030010,
-    HYPERSPACE_BAD_ATTRIBUTE                     = 0x00030011,
-    HYPERSPACE_BERKELEYDB_ERROR                  = 0x00030012,
-    HYPERSPACE_DIR_NOT_EMPTY                     = 0x00030013,
-    HYPERSPACE_BERKELEYDB_DEADLOCK               = 0x00030014,
-    HYPERSPACE_BERKELEYDB_REP_HANDLE_DEAD        = 0x00030015,
-    HYPERSPACE_FILE_OPEN                         = 0x00030016,
-    HYPERSPACE_CLI_PARSE_ERROR                   = 0x00030017,
-    HYPERSPACE_CREATE_SESSION_FAILED             = 0x00030018,
-    HYPERSPACE_NOT_MASTER_LOCATION               = 0x00030019,
-
-    HYPERSPACE_STATEDB_ERROR                     = 0x0003001A,
-    HYPERSPACE_STATEDB_DEADLOCK                  = 0x0003001B,
-    HYPERSPACE_STATEDB_BAD_KEY                   = 0x0003001C,
-    HYPERSPACE_STATEDB_BAD_VALUE                 = 0x0003001D,
-    HYPERSPACE_STATEDB_ALREADY_DELETED           = 0x0003001E,
-    HYPERSPACE_STATEDB_EVENT_EXISTS              = 0x0003001F,
-    HYPERSPACE_STATEDB_EVENT_NOT_EXISTS          = 0x00030020,
-    HYPERSPACE_STATEDB_EVENT_ATTR_NOT_FOUND      = 0x00030021,
-    HYPERSPACE_STATEDB_SESSION_EXISTS            = 0x00030022,
-    HYPERSPACE_STATEDB_SESSION_NOT_EXISTS        = 0x00030023,
-    HYPERSPACE_STATEDB_SESSION_ATTR_NOT_FOUND    = 0x00030024,
-    HYPERSPACE_STATEDB_HANDLE_EXISTS             = 0x00030025,
-    HYPERSPACE_STATEDB_HANDLE_NOT_EXISTS         = 0x00030026,
-    HYPERSPACE_STATEDB_HANDLE_ATTR_NOT_FOUND     = 0x00030027,
-    HYPERSPACE_STATEDB_NODE_EXISTS               = 0x00030028,
-    HYPERSPACE_STATEDB_NODE_NOT_EXISTS           = 0x00030029,
-    HYPERSPACE_STATEDB_NODE_ATTR_NOT_FOUND       = 0x0003002A,
-
-    HYPERSPACE_VERSION_MISMATCH                  = 0x00030030,
-
-    MASTER_TABLE_EXISTS                          = 0x00040001,
-    MASTER_BAD_SCHEMA                            = 0x00040002,
-    MASTER_NOT_RUNNING                           = 0x00040003,
-    MASTER_NO_RANGESERVERS                       = 0x00040004,
-    MASTER_FILE_NOT_LOCKED                       = 0x00040005,
-    MASTER_RANGESERVER_ALREADY_REGISTERED        = 0x00040006,
-    MASTER_BAD_COLUMN_FAMILY                     = 0x00040007,
-    MASTER_SCHEMA_GENERATION_MISMATCH            = 0x00040008,
-    MASTER_LOCATION_ALREADY_ASSIGNED             = 0x00040009,
-    MASTER_LOCATION_INVALID                      = 0x0004000A,
-    MASTER_OPERATION_IN_PROGRESS                 = 0x0004000B,
-    MASTER_RANGESERVER_IN_RECOVERY               = 0x0004000C,
-    MASTER_BALANCE_PREVENTED                     = 0x0004000D,
-
-    RANGESERVER_GENERATION_MISMATCH              = 0x00050001,
-    RANGESERVER_RANGE_ALREADY_LOADED             = 0x00050002,
-    RANGESERVER_RANGE_MISMATCH                   = 0x00050003,
-    RANGESERVER_NONEXISTENT_RANGE                = 0x00050004,
-    RANGESERVER_OUT_OF_RANGE                     = 0x00050005,
-    RANGESERVER_RANGE_NOT_FOUND                  = 0x00050006,
-    RANGESERVER_INVALID_SCANNER_ID               = 0x00050007,
-    RANGESERVER_SCHEMA_PARSE_ERROR               = 0x00050008,
-    RANGESERVER_SCHEMA_INVALID_CFID              = 0x00050009,
-    RANGESERVER_INVALID_COLUMNFAMILY             = 0x0005000A,
-    RANGESERVER_TRUNCATED_COMMIT_LOG             = 0x0005000B,
-    RANGESERVER_NO_METADATA_FOR_RANGE            = 0x0005000C,
-    RANGESERVER_SHUTTING_DOWN                    = 0x0005000D,
-    RANGESERVER_CORRUPT_COMMIT_LOG               = 0x0005000E,
-    RANGESERVER_UNAVAILABLE                      = 0x0005000F,
-    RANGESERVER_REVISION_ORDER_ERROR             = 0x00050010,
-    RANGESERVER_ROW_OVERFLOW                     = 0x00050011,
-    RANGESERVER_TABLE_NOT_FOUND                  = 0x00050012,
-    RANGESERVER_BAD_SCAN_SPEC                    = 0x00050013,
-    RANGESERVER_CLOCK_SKEW                       = 0x00050014,
-    RANGESERVER_BAD_CELLSTORE_FILENAME           = 0x00050015,
-    RANGESERVER_CORRUPT_CELLSTORE                = 0x00050016,
-    RANGESERVER_TABLE_DROPPED                    = 0x00050017,
-    RANGESERVER_UNEXPECTED_TABLE_ID              = 0x00050018,
-    RANGESERVER_RANGE_BUSY                       = 0x00050019,
-    RANGESERVER_BAD_CELL_INTERVAL                = 0x0005001A,
-    RANGESERVER_SHORT_CELLSTORE_READ             = 0x0005001B,
-    RANGESERVER_RANGE_NOT_ACTIVE                 = 0x0005001C,
-    RANGESERVER_FRAGMENT_ALREADY_PROCESSED       = 0x0005001D,
-    RANGESERVER_RECOVERY_PLAN_GENERATION_MISMATCH = 0x0005001E,
-    RANGESERVER_PHANTOM_RANGE_MAP_NOT_FOUND      = 0x0005001F,
-    RANGESERVER_RANGES_ALREADY_LIVE              = 0x00050020,
-    RANGESERVER_RANGE_NOT_YET_ACKNOWLEDGED       = 0x00050021,
-    RANGESERVER_SERVER_IN_READONLY_MODE          = 0x00050022,
-    RANGESERVER_RANGE_NOT_YET_RELINQUISHED       = 0x00050023,
-
-    HQL_BAD_LOAD_FILE_FORMAT                     = 0x00060001,
-    HQL_BAD_COMMAND                              = 0x00060002,
-
-    METALOG_ERROR                                = 0x00070000,
-    METALOG_VERSION_MISMATCH                     = 0x00070001,
-    METALOG_BAD_RS_HEADER                        = 0x00070002,
-    METALOG_BAD_HEADER                           = 0x00070003,
-    METALOG_ENTRY_TRUNCATED                      = 0x00070004,
-    METALOG_CHECKSUM_MISMATCH                    = 0x00070005,
-    METALOG_ENTRY_BAD_TYPE                       = 0x00070006,
-    METALOG_ENTRY_BAD_ORDER                      = 0x00070007,
-    METALOG_MISSING_RECOVER_ENTITY               = 0x00070008,
-    METALOG_BACKUP_FILE_MISMATCH                 = 0x00070009,
-    METALOG_READ_ERROR                           = 0x0007000A,
-
-    SERIALIZATION_INPUT_OVERRUN                  = 0x00080001,
-    SERIALIZATION_BAD_VINT                       = 0x00080002,
-    SERIALIZATION_BAD_VSTR                       = 0x00080003,
-    SERIALIZATION_VERSION_MISMATCH               = 0x00080004,
-
-    THRIFTBROKER_BAD_SCANNER_ID                  = 0x00090001,
-    THRIFTBROKER_BAD_MUTATOR_ID                  = 0x00090002,
-    THRIFTBROKER_BAD_NAMESPACE_ID                = 0x00090003,
-    THRIFTBROKER_BAD_FUTURE_ID                   = 0x00090004
-};
-
-/** Returns a descriptive error message
- *
- * @param error The error code
- * @return The descriptive error message of this code
- */
-const char *get_text(int error);
-
-/** Generates and print the error documentation as html
- *
- * @param out The ostream which is used for printing
- */
-void generate_html_error_code_documentation(std::ostream &out);
-
-} // namespace Error
-
-class Exception;
-
-/** Helper class to render an exception message a la IO manipulators */
-struct ExceptionMessageRenderer {
-    ExceptionMessageRenderer(const Exception &e) : ex(e) { }
-
-    std::ostream &render(std::ostream &out) const;
-
-    const Exception &ex;
-};
-
-/** Helper class to render an exception message a la IO manipulators
- *
- * When printing an Exception, this class also appends a separator. This
- * is used for printing chained Exceptions
- */
-struct ExceptionMessagesRenderer {
-    ExceptionMessagesRenderer(const Exception &e, const char *sep = ": ")
-        : ex(e), separator(sep) { }
-
-    std::ostream &render(std::ostream &out) const;
-
-    const Exception &ex;
-    const char *separator;
-};
-
-/**
- * This is a generic exception class for palo.  It takes an error code
- * as a constructor argument and translates it into an error message.
- * Exceptions can be "chained".
- */
-class Exception : public std::runtime_error {
-    /** Do not allow assignments */
-    const Exception &operator=(const Exception &);
-
-    /** The error code */
-    int m_error;
-
-    /** The source code line where the exception was thrown */
-    int m_line;
-
-    /** The function name where the exception was thrown */
-    const char *m_func;
-
-    /** The source code file where the exception was thrown */
-    const char *m_file;
-
-public:
-    typedef std::runtime_error Parent;
-
-    /** Constructor
-     *
-     * @param error The error code
-     * @param l The source code line
-     * @param fn The function name
-     * @param fl The file name
-     */
-    Exception(int error, int l = 0, const char *fn = 0, const char *fl = 0)
-        : Parent(""), m_error(error), m_line(l), m_func(fn), m_file(fl), prev(0) {
-        }
-
-    /** Constructor
-     *
-     * @param error The error code
-     * @param msg An additional error message
-     * @param l The source code line
-     * @param fn The function name
-     * @param fl The file name
-     */
-    Exception(int error, const std::string &msg, int l = 0, const char *fn = 0,
-            const char *fl = 0)
-        : Parent(msg), m_error(error), m_line(l), m_func(fn), m_file(fl),
-        prev(0) {
-        }
-
-    /** Constructor
-     *
-     * @param error The error code
-     * @param msg An additional error message
-     * @param ex The previous exception in the exception chain
-     * @param l The source code line
-     * @param fn The function name
-     * @param fl The file name
-     */
-    Exception(int error, const std::string &msg, const Exception &ex, int l = 0,
-            const char *fn = 0, const char *fl = 0)
-        : Parent(msg), m_error(error), m_line(l), m_func(fn), m_file(fl),
-        prev(new Exception(ex)) {
-        }
-
-    /** Copy constructor
-     *
-     * @param ex The exception that is copied
-     */
-    Exception(const Exception &ex)
-        : Parent(ex), m_error(ex.m_error), m_line(ex.m_line), m_func(ex.m_func),
-        m_file(ex.m_file) {
-            prev = ex.prev ? new Exception(*ex.prev) : 0;
-        }
-
-    /** Destructor */
-    ~Exception() throw() { 
-        delete prev; 
-        prev = 0; 
-    }
-
-    /** Returns the error code
-     *
-     * @return The error code of this exception.
-     * @sa error::get_text to retrieve a descriptive error string
-     */
-    int code() const { return m_error; }
-
-    /** Returns the source code line number where the exception was thrown
-     *
-     * @return The line number
-     */
-    int line() const { return m_line; }
-
-    /** Returns the name of the function which threw the Exception
-     *
-     * @return The function name
-     */
-    const char *func() const { return m_func; }
-
-    /** Returns the source code line number where the exception was thrown
-     *
-     * @return The file name
-     */
-    const char *file() const { return m_file; }
-
-    /** Renders an Exception to an ostream
-     *
-     * @param out Reference to the ostream
-     */
-    virtual std::ostream &render_message(std::ostream &out) const {
-        return out << what(); // override for custom exceptions
-    }
-
-    // render messages for the entire exception chain
-    /** Renders multiple Exceptions to an ostream
-     *
-     * @param out Reference to the ostream
-     * @param sep The separator between the Exceptions, i.e. ':'
-     */
-    virtual std::ostream &render_messages(std::ostream &out,
-            const char *sep) const;
-
-    /** Retrieves a Renderer for this Exception */
-    ExceptionMessageRenderer message() const {
-        return ExceptionMessageRenderer(*this);
-    }
-
-    /** Retrieves a Renderer for chained Exceptions */
-    ExceptionMessagesRenderer messages(const char *sep = ": ") const {
-        return ExceptionMessagesRenderer(*this, sep);
-    }
-
-    /** The previous exception in the exception chain */
-    Exception *prev;
-};
-
-/** Global operator to print an Exception to a std::ostream */
-std::ostream &operator<<(std::ostream &out, const Exception &);
-
-/** Global helper function to print an Exception to a std::ostream */
-inline std::ostream &
-ExceptionMessageRenderer::render(std::ostream &out) const {
-    return ex.render_message(out);
-}
-
-/** Global helper function to print an Exception to a std::ostream */
-inline std::ostream &
-ExceptionMessagesRenderer::render(std::ostream &out) const {
-    return ex.render_messages(out, separator);
-}
-
-/** Global helper operator to print an Exception to a std::ostream */
-inline std::ostream &
-operator<<(std::ostream &out, const ExceptionMessageRenderer &r) {
-    return r.render(out);
-}
-
-/** Global helper operator to print an Exception to a std::ostream */
-inline std::ostream &
-operator<<(std::ostream &out, const ExceptionMessagesRenderer &r) {
-    return r.render(out);
-}
-
-/* Convenience macro to create an exception stack trace */
-#define HT_EXCEPTION(_code_, _msg_) \
-    Exception(_code_, _msg_, __LINE__, HT_FUNC, __FILE__)
-
-/* Convenience macro to create an chained exception */
-#define HT_EXCEPTION2(_code_, _ex_, _msg_) \
-    Exception(_code_, _msg_, _ex_, __LINE__, HT_FUNC, __FILE__)
-
-/* Convenience macro to throw an exception */
-#define HT_THROW(_code_, _msg_) throw HT_EXCEPTION(_code_, _msg_)
-
-/* Convenience macro to throw an exception */
-#define HT_THROW_(_code_) HT_THROW(_code_, "")
-
-/* Convenience macro to throw a chained exception */
-#define HT_THROW2(_code_, _ex_, _msg_) throw HT_EXCEPTION2(_code_, _ex_, _msg_)
-
-/* Convenience macro to throw a chained exception */
-#define HT_THROW2_(_code_, _ex_) HT_THROW2(_code_, _ex_, "")
-
-/* Convenience macro to throw an exception with a printf-like message */
-#define HT_THROWF(_code_, _fmt_, ...) \
-    throw HT_EXCEPTION(_code_, palo::format(_fmt_, __VA_ARGS__))
-
-/* Convenience macro to throw a chained exception with a printf-like message */
-#define HT_THROW2F(_code_, _ex_, _fmt_, ...) \
-    throw HT_EXCEPTION2(_code_, _ex_, palo::format(_fmt_, __VA_ARGS__))
-
-/* Convenience macro to catch and rethrow exceptions with a printf-like
- * message */
-#define HT_RETHROWF(_fmt_, ...) \
-    catch (Exception &e) { HT_THROW2F(e.code(), e, _fmt_, __VA_ARGS__); } \
-catch (std::bad_alloc &e) { \
-    HT_THROWF(error::BAD_MEMORY_ALLOCATION, _fmt_, __VA_ARGS__); \
-} \
-catch (std::exception &e) { \
-    HT_THROWF(error::EXTERNAL, "caught std::exception: %s " _fmt_,  e.what(), \
-            __VA_ARGS__); \
-} \
-catch (...) { \
-    LOG(ERROR) << "caught unknown exception "  << _fmt_ << __VA_ARGS__; \
-    throw; \
-}
-
-/* Convenience macro to catch and rethrow exceptions */
-#define HT_RETHROW(_s_) HT_RETHROWF("%s", _s_)
-
-/* Convenience macro to execute a code block and rethrow all exceptions */
-#define HT_TRY(_s_, _code_) do { \
-    try { _code_; } \
-    HT_RETHROW(_s_) \
-} while (0)
-
-/* Convenience macros for catching and logging exceptions in destructors */
-#define HT_LOG_EXCEPTION(_s_) \
-    catch (Exception &e) { HT_ERROR_OUT << e << ", " << _s_ << HT_END; } \
-catch (std::bad_alloc &e) { \
-    HT_ERROR_OUT << "Out of memory, " << _s_ << HT_END; } \
-catch (std::exception &e) { \
-    HT_ERROR_OUT << "Caught exception: " << e.what() << ", " << _s_ << HT_END; } \
-catch (...) { \
-    HT_ERROR_OUT << "Caught unknown exception, " << _s_ << HT_END; }
-
-/* Convenience macro to execute code and log all exceptions */
-#define HT_TRY_OR_LOG(_s_, _code_) do { \
-    try { _code_; } \
-    HT_LOG_EXCEPTION(_s_) \
-} while (0)
-
-} // namespace palo
-
-#endif //BDG_PALO_BE_SRC_RPC_ERROR_H
diff --git a/be/src/rpc/event.cpp b/be/src/rpc/event.cpp
deleted file mode 100644
index bc288707e4c73e..00000000000000
--- a/be/src/rpc/event.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include <iostream>
-
-extern "C" {
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-}
-
-#include "error.h"
-#include "string_ext.h"
-#include "reactor_runner.h"
-#include "event.h"
-
-namespace palo {
-
-std::string Event::to_str() const {
-    std::string dstr;
-    dstr = "Event: type=";
-
-    if (type == CONNECTION_ESTABLISHED) {
-        dstr += "CONNECTION_ESTABLISHED";
-    } else if (type == DISCONNECT) {
-        dstr += "DISCONNECT";
-    } else if (type == MESSAGE) {
-        dstr += "MESSAGE";
-        dstr += (std::string)" version=" + (int)header.version;
-        dstr += (std::string)" total_len=" + (int)header.total_len;
-        dstr += (std::string)" header_len=" + (int)header.header_len;
-        dstr += (std::string)" header_checksum=" + (int)header.header_checksum;
-        dstr += (std::string)" flags=" + (int)header.flags;
-        dstr += (std::string)" id=" + (int)header.id;
-        dstr += (std::string)" gid=" + (int)header.gid;
-        dstr += (std::string)" timeout_ms=" + (int)header.timeout_ms;
-        dstr += (std::string)" payload_checksum=" + (int)header.payload_checksum;
-        dstr += (std::string)" command=" + (int)header.command;
-    } else if (type == TIMER) {
-        dstr += "TIMER";
-    } else if (type == ERROR) {
-        dstr += "ERROR";
-    } else {
-        dstr += (int)type;
-    }
-
-    if (error != error::OK) {
-        dstr += (std::string)" \"" + error::get_text(error) + "\"";
-    }
-
-    if (type != TIMER) {
-        dstr += " from=";
-        dstr += addr.format();
-    }
-
-    return dstr;
-}
-
-} //namespace palo
diff --git a/be/src/rpc/event.h b/be/src/rpc/event.h
deleted file mode 100644
index 354796339413e2..00000000000000
--- a/be/src/rpc/event.h
+++ /dev/null
@@ -1,220 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_EVENT_H 
-#define BDG_PALO_BE_SRC_RPC_EVENT_H 
-
-#include "clock.h"
-#include "comm_header.h"
-#include "error.h"
-#include "inet_addr.h"
-#include "common/logging.h"
-#include "util.h"
-
-#include <iostream>
-#include <memory>
-#include <assert.h>
-
-namespace palo {
-
-/**
- * Network communication event.
- * Objects of this type get passed up to the application through dispatch
- * handlers (see DispatchHandler).
- */
-
-class Event {
-public:
-
-    /** Enumeration for event types.
-    */
-    enum Type { 
-        CONNECTION_ESTABLISHED, ///< Connection established event
-        DISCONNECT, ///< Connection disconnected event
-        MESSAGE,    ///< Request/response message event
-        ERROR,      ///< %Error event
-        TIMER       ///< %Timer event
-    };
-
-    /** Constructor initializing with InetAddr.
-     *
-     * @param type_ Type of event
-     * @param addr_ Remote address from which event originated
-     * @param error_ Error code associated with this event
-     */
-    Event(Type type_, const InetAddr& addr_, int error_ = error::OK)
-        : type(type_), addr(addr_), error(error_) {
-            proxy = 0;
-        }
-
-    /** Constructor initializing with InetAddr and proxy name.
-     *
-     * @param type_ Type of event
-     * @param addr_ Remote address from which event originated
-     * @param proxy_ Proxy name
-     * @param error_ Error code associated with this event
-     */
-    Event(Type type_, const sockaddr_in &addr_, const std::string &proxy_,
-            int error_ = error::OK) 
-        : type(type_), addr(addr_), error(error_) {
-            set_proxy(proxy_);
-        }
-
-    /** Constructor initializing with empty address.
-     *
-     * @param type_ Type of event
-     * @param error_ Error code associated with this event
-     */
-    Event(Type type_, int error_ = error::OK) 
-        : type(type_), error(error_) {
-            proxy = 0;
-        }
-
-    /** Constructor initialized with proxy name.
-     *
-     * @param type_ Type of event
-     * @param proxy_ Proxy name
-     * @param error_ Error code associated with this event
-     */
-    Event(Type type_, const std::string& proxy_, int error_ = 0) 
-        : type(type_), error(error_) {
-            set_proxy(proxy_);
-        }
-
-    /** Destructor.  Deallocates message payload buffer and proxy name buffer
-    */
-    ~Event() {
-        if (payload_aligned) {
-            free((void *)payload);
-        } else {
-            delete [] payload;
-        }
-        if (proxy_buf != proxy_buf_static) {
-            delete [] proxy_buf;
-        }
-    }
-
-    /** Loads header object from serialized message buffer.  This method
-     * also sets the group_id member.
-     *
-     * @param buf Buffer containing serialized header
-     * @param len Length of buffer
-     */
-    void load_message_header(const uint8_t *buf, size_t len) {
-        header.decode(&buf, &len);
-        group_id = header.gid;
-    }
-
-    /** Sets the address proxy name from which this event was generated.
-     * If the proxy name is less than 32 characters, then it is copied into
-     * #proxy_buf_static, otherwise a buffer is allocated to hold it.  #proxy
-     * is set to point to whichever buffer is chosen.
-     */
-    void set_proxy(const std::string &p) {
-        if (p.length() == 0) {
-            proxy = 0;
-        } else {
-            if (p.length() < 32) {
-                proxy = proxy_buf_static;
-            } else {
-                proxy_buf = new char[p.length() + 1];
-                proxy = proxy_buf;
-            }
-            snprintf((char *)proxy, p.size() + 1, "%s", p.c_str());
-        }
-    }
-
-    /** Deadline for request.
-     * @return Absolute deadline
-     */
-    ClockT::time_point deadline() {
-        assert(arrival_time.time_since_epoch().count() > 0);
-        return arrival_time + std::chrono::milliseconds(header.timeout_ms);
-    }
-
-    /** Type of event.  Can take one of values CONNECTION_ESTABLISHED,
-     * DISCONNECT, MESSAGE, ERROR, or TIMER
-     */
-    Type type;
-
-    /// Remote address from which event was generated.
-    InetAddr addr;
-
-    /// Address proxy name
-    const char *proxy {};
-
-    /// Pointer to allocated proxy name buffer
-    char *proxy_buf {};
-
-    /// Static proxy name buffer
-    char proxy_buf_static[32];
-
-    /// Local address to which event was delivered.
-    InetAddr local_addr;
-
-    /** Error code associated with this event.  DISCONNECT and
-     * ERROR events set this value
-     */
-    int error {};
-
-    /// Comm layer header for MESSAGE events
-    CommHeader header;
-
-    /// Points to a buffer containing the message payload
-    const uint8_t *payload {};
-
-    /// Length of the message
-    size_t payload_len {};
-
-    /** Thread group to which this message belongs.  Used to serialize
-     * messages destined for the same object.  This value is created in
-     * the constructor and is the combination of the socked descriptor from
-     * which the message was read and the gid field in the message header:
-     * <pre>
-     * group_id = ((uint64_t)sd << 32) | header->gid;
-     * </pre>
-     * If the gid is zero, then the group_id member is also set to zero
-     */
-    uint64_t group_id {};
-
-    /// time (seconds since epoch) when message arrived
-    ClockT::time_point arrival_time {};
-
-    /// Flag indicating if payload was allocated with posix_memalign
-    bool payload_aligned {};
-
-    /** Generates a one-line string representation of the event.  For example:
-     * <pre>
-     *   Event: type=MESSAGE id=2 gid=0 header_len=16 total_len=20 \
-     *   from=127.0.0.1:15861 ...
-     * </pre>
-     */
-    std::string to_str() const;
-
-    /** Displays a one-line string representation of the event to stdout.
-     * @see to_str
-     */
-    void display() { std::cerr << to_str() << std::endl; }
-};
-/// Smart pointer to Event
-typedef std::shared_ptr<Event> EventPtr;
-
-} // namespace palo
-
-#endif //BDG_PALO_BE_SRC_RPC_EVENT_H 
diff --git a/be/src/rpc/expire_timer.h b/be/src/rpc/expire_timer.h
deleted file mode 100644
index fe8b65522e7f06..00000000000000
--- a/be/src/rpc/expire_timer.h
+++ /dev/null
@@ -1,50 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_EXPIRE_TIMER_H
-#define BDG_PALO_BE_SRC_RPC_EXPIRE_TIMER_H
-
-#include "clock.h"
-#include "dispatch_handler.h"
-
-namespace palo {
-
-/** State record for timer.
-*/
-struct ExpireTimer {
-    ClockT::time_point expire_time;   //!< Absolute expiration time
-    DispatchHandlerPtr handler; //!< Dispatch handler to receive TIMER event
-};
-
-/** Comparison function (functor) for timer heap.
-*/
-struct LtTimerHeap {
-    /** Parenthesis operator with two ExpireTimer parameters.
-     * Provides "largest first" comparison.
-     * @param t1 Lefthand side of comparison
-     * @param t2 Righthand side of comparison
-     * @return true if <code>t1</code> is greater than <code>t2</code>
-     */
-    bool operator()(const ExpireTimer &t1, const ExpireTimer &t2) const {
-        return std::chrono::operator>(t1.expire_time, t2.expire_time);
-    }
-};
-
-} //namespace palo
-#endif //BDG_PALO_BE_SRC_RPC_EXPIRE_TIMER_H
diff --git a/be/src/rpc/fast_clock.cpp b/be/src/rpc/fast_clock.cpp
deleted file mode 100644
index 67875ecc1d7f2c..00000000000000
--- a/be/src/rpc/fast_clock.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "fast_clock.h"
-
-extern "C" {
-#include <sys/time.h>
-}
-
-std::chrono::FastClock::time_point std::chrono::FastClock::now() noexcept {
-    struct timeval tv;
-    gettimeofday(&tv, nullptr);
-    return std::chrono::FastClock::time_point(std::chrono::microseconds((tv.tv_sec * 1000000LL) + tv.tv_usec));
-}
-
-time_t std::chrono::FastClock::to_time_t (const std::chrono::FastClock::time_point& __t) noexcept {
-    return (time_t)(__t.time_since_epoch().count() / 1000000LL);
-}
-
-std::chrono::FastClock::time_point std::chrono::FastClock::from_time_t(time_t __t) noexcept {
-    return std::chrono::FastClock::time_point(std::chrono::microseconds(__t * 1000000LL));
-}
diff --git a/be/src/rpc/fast_clock.h b/be/src/rpc/fast_clock.h
deleted file mode 100644
index c48c396db258d3..00000000000000
--- a/be/src/rpc/fast_clock.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_FAST_CLOCK_H
-#define BDG_PALO_BE_SRC_RPC_FAST_CLOCK_H
-
-#include <chrono>
-#include <ctime>
-
-namespace std { namespace chrono {
-
-class FastClock {
-public:
-    typedef microseconds duration;
-    typedef duration::rep rep;
-    typedef duration::period period;
-    typedef chrono::time_point<FastClock> time_point;
-    static constexpr bool is_steady = false;
-    static time_point now() noexcept;
-    static time_t     to_time_t  (const time_point& __t) noexcept;
-    static time_point from_time_t(time_t __t) noexcept;
-};
-
-} //namespace chrono
-
-} //namespace std
-#endif // BDG_PALO_BE_SRC_RPC_FAST_CLOCK_H
diff --git a/be/src/rpc/file_utils.cpp b/be/src/rpc/file_utils.cpp
deleted file mode 100644
index 94a2839d2da231..00000000000000
--- a/be/src/rpc/file_utils.cpp
+++ /dev/null
@@ -1,463 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "common/logging.h"
-#include <iomanip>
-#include <iostream>
-#include <sstream>
-#include <cstdio>
-
-extern "C" {
-#include <unistd.h>
-#include <errno.h>
-#include <pwd.h>
-#include <fcntl.h>
-#include <string.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <sys/uio.h>
-}
-
-#include <boost/shared_array.hpp>
-#include <boost/shared_ptr.hpp>
-#include <re2/re2.h>
-#include "file_utils.h"
-
-namespace palo {
-
-std::mutex FileUtils::ms_mutex;
-
-bool FileUtils::read(const std::string &fname, std::string &contents) {
-    off_t len {};
-    char *buf = file_to_buffer(fname, &len);
-    if (buf != 0) {
-        contents.append(buf, len);
-        delete [] buf;
-        return true;
-    }
-    return false;
-}
-
-ssize_t FileUtils::read(int fd, void *vptr, size_t n) {
-    size_t nleft = 0;
-    ssize_t nread = 0;
-    char *ptr = 0;
-    ptr = (char *)vptr;
-    nleft = n;
-    while (nleft > 0) {
-        if ((nread = ::read(fd, ptr, nleft)) < 0) {
-            if (errno == EINTR)
-                nread = 0;/* and call read() again */
-            else if (errno == EAGAIN)
-                break;
-            else
-                return -1;
-        }
-        else if (nread == 0)
-            break; /* EOF */
-        nleft -= nread;
-        ptr   += nread;
-    }
-    return n - nleft;
-}
-
-ssize_t FileUtils::pread(int fd, void *vptr, size_t n, off_t offset) {
-    size_t nleft = 0;
-    ssize_t nread = 0;
-    char *ptr = 0;
-    ptr = (char *)vptr;
-    nleft = n;
-    while (nleft > 0) {
-        if ((nread = ::pread(fd, ptr, nleft, offset)) < 0) {
-            if (errno == EINTR)
-                nread = 0;/* and call read() again */
-            else if (errno == EAGAIN)
-                break;
-            else
-                return -1;
-        }
-        else if (nread == 0)
-            break; /* EOF */
-        nleft -= nread;
-        ptr   += nread;
-        offset += nread;
-    }
-    return n - nleft;
-}
-
-ssize_t FileUtils::write(const std::string &fname, const std::string &contents) {
-    int fd = open(fname.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0644);
-    if (fd < 0) {
-        int saved_errno = errno;
-        LOG(ERROR) << "Unable to open file \"%s\" for writing - %s" << fname.c_str() <<
-                   strerror(saved_errno);
-        errno = saved_errno;
-        return -1;
-    }
-    ssize_t rval = write(fd, contents);
-    ::close(fd);
-    return rval;
-}
-
-ssize_t FileUtils::write(int fd, const void *vptr, size_t n) {
-    size_t nleft = 0;
-    ssize_t nwritten = 0;
-    const char *ptr = 0;
-    ptr = (const char *)vptr;
-    nleft = n;
-    while (nleft > 0) {
-        if ((nwritten = ::write(fd, ptr, nleft)) <= 0) {
-            if (errno == EINTR)
-                nwritten = 0; /* and call write() again */
-            else if (errno == EAGAIN)
-                break;
-            else
-                return -1; /* error */
-        }
-        nleft -= nwritten;
-        ptr   += nwritten;
-    }
-    return n - nleft;
-}
-
-ssize_t FileUtils::writev(int fd, const struct iovec *vector, int count) {
-    ssize_t nwritten = 0;
-    while ((nwritten = ::writev(fd, vector, count)) <= 0) {
-        if (errno == EINTR)
-            nwritten = 0; /* and call write() again */
-        else if (errno == EAGAIN) {
-            nwritten = 0;
-            break;
-        }
-        else
-            return -1; /* error */
-    }
-    return nwritten;
-}
-
-ssize_t FileUtils::sendto(int fd, const void *vptr, size_t n,
-                          const sockaddr *to, socklen_t tolen) {
-    size_t nleft = 0;
-    ssize_t nsent = 0;
-    const char *ptr = 0;
-    ptr = (const char *)vptr;
-    nleft = n;
-    while (nleft > 0) {
-        if ((nsent = ::sendto(fd, ptr, nleft, 0, to, tolen)) <= 0) {
-            if (errno == EINTR)
-                nsent = 0; /* and call sendto() again */
-            else if (errno == EAGAIN || errno == ENOBUFS)
-                break;
-            else
-                return -1; /* error */
-        }
-        nleft -= nsent;
-        ptr   += nsent;
-    }
-    return n - nleft;
-}
-
-ssize_t FileUtils::send(int fd, const void *vptr, size_t n) {
-    size_t nleft = 0;
-    ssize_t nsent = 0 ;
-    const char *ptr = 0;
-    ptr = (const char *)vptr;
-    nleft = n;
-    while (nleft > 0) {
-        if ((nsent = ::send(fd, ptr, nleft, 0)) <= 0) {
-            if (errno == EINTR)
-                nsent = 0; /* and call sendto() again */
-            else if (errno == EAGAIN || errno == ENOBUFS)
-                break;
-            else
-                return -1; /* error */
-        }
-        nleft -= nsent;
-        ptr   += nsent;
-    }
-    return n - nleft;
-}
-
-ssize_t FileUtils::recvfrom(int fd, void *vptr, size_t n, sockaddr *from,
-                            socklen_t *fromlen) {
-    ssize_t nread = 0;
-    while (true) {
-        if ((nread = ::recvfrom(fd, vptr, n, 0, from, fromlen)) < 0) {
-            if (errno != EINTR)
-                break;
-        }
-        else
-            break;
-    }
-    return nread;
-}
-
-ssize_t FileUtils::recv(int fd, void *vptr, size_t n) {
-    ssize_t nread = 0;
-    while (true) {
-        if ((nread = ::recv(fd, vptr, n, 0)) < 0) {
-            if (errno != EINTR)
-                break;
-        }
-        else
-            break;
-    }
-    return nread;
-}
-
-bool FileUtils::set_flags(int fd, int flags) {
-    int val = 0;
-    bool ret = true;
-    if ((val = fcntl(fd, F_GETFL, 0)) < 0) {
-        int saved_errno = errno;
-        LOG(ERROR) << "fcnt(F_GETFL) failed : " << ::strerror(saved_errno);
-        errno = saved_errno;
-        ret = false;
-    }
-    val |= flags;
-    if (fcntl(fd, F_SETFL, val) < 0) {
-        int saved_errno = errno;
-        LOG(ERROR) << "fcnt(F_SETFL) failed : " << ::strerror(saved_errno);
-        errno = saved_errno;
-        ret = false;
-    }
-    return ret;
-}
-
-char *FileUtils::file_to_buffer(const std::string &fname, off_t *lenp) {
-    struct stat statbuf;
-    int fd= -1;
-    *lenp = 0;
-    if ((fd = open(fname.c_str(), O_RDONLY)) < 0) {
-        int saved_errno = errno;
-        LOG(ERROR) << "open(\"%s\") failure - %s" << fname.c_str() <<
-                   strerror(saved_errno);
-        errno = saved_errno;
-        return 0;
-    }
-    if (fstat(fd, &statbuf) < 0) {
-        int saved_errno = errno;
-        LOG(ERROR) << "fstat(\"%s\") failure - %s" << fname.c_str() <<
-                   strerror(saved_errno);
-        errno = saved_errno;
-        return 0;
-    }
-    *lenp = statbuf.st_size;
-    char *rbuf = new char [*lenp + 1];
-    ssize_t nread = FileUtils::read(fd, rbuf, *lenp);
-    ::close(fd);
-    if (nread == (ssize_t)-1) {
-        int saved_errno = errno;
-        LOG(ERROR) << "read(\"%s\") failure - %s" << fname.c_str() <<
-                   strerror(saved_errno);
-        errno = saved_errno;
-        delete [] rbuf;
-        *lenp = 0;
-        return 0;
-    }
-    if (nread < *lenp) {
-        LOG(WARNING) << "short read (%d of %d bytes)" << (int)nread << (int)*lenp;
-        *lenp = nread;
-    }
-    rbuf[nread] = 0;
-    return rbuf;
-}
-
-std::string FileUtils::file_to_string(const std::string &fname) {
-    std::string str;
-    off_t len;
-    char *contents = file_to_buffer(fname, &len);
-    str = (contents == 0) ? "" : contents;
-    delete [] contents;
-    return str;
-}
-
-void *FileUtils::mmap(const std::string &fname, off_t *lenp) {
-    int fd = -1;
-    struct stat statbuf;
-    void* map = 0;
-    if (::stat(fname.c_str(), &statbuf) != 0)
-        LOG(FATAL) << "Unable determine length of '%s' for memory mapping - %s" <<
-                   fname.c_str() << strerror(errno);
-    *lenp = (off_t)statbuf.st_size;
-    if ((fd = ::open(fname.c_str(), O_RDONLY)) == -1)
-        LOG(FATAL) << "Unable to open '%s' for memory mapping - %s" << fname.c_str()
-                   << strerror(errno);
-
-    if ((map = ::mmap(0, *lenp, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED)
-        LOG(FATAL) << "Unable to memory map file '%s' - %s" << fname.c_str() <<
-                   strerror(errno);
-    close(fd);
-    return map;
-}
-
-bool FileUtils::mkdirs(const std::string &dirname) {
-    struct stat statbuf;
-    boost::shared_array<char> tmp_dir(new char [dirname.length() + 1]);
-    char *tmpdir = tmp_dir.get();
-    char *ptr = tmpdir + 1;
-    strcpy(tmpdir, dirname.c_str());
-    while ((ptr = strchr(ptr, '/')) != 0) {
-        *ptr = 0;
-        if (stat(tmpdir, &statbuf) != 0) {
-            if (errno == ENOENT) {
-                if (mkdir(tmpdir, 0755) != 0) {
-                    int saved_errno = errno;
-                    LOG(ERROR) << "Problem creating directory '%s' - %s" << tmpdir
-                               << strerror(saved_errno);
-                    errno = saved_errno;
-                    return false;
-                }
-            }
-            else {
-                int saved_errno = errno;
-                LOG(ERROR) << "Problem stat'ing directory '%s' - %s" << tmpdir
-                           << strerror(saved_errno);
-                errno = saved_errno;
-                return false;
-            }
-        }
-        *ptr++ = '/';
-    }
-    if (stat(tmpdir, &statbuf) != 0) {
-        if (errno == ENOENT) {
-            if (mkdir(tmpdir, 0755) != 0) {
-                int saved_errno = errno;
-                LOG(ERROR) << "Problem creating directory '%s' - %s" << tmpdir
-                           << strerror(saved_errno);
-                errno = saved_errno;
-                return false;
-            }
-        }
-        else {
-            int saved_errno = errno;
-            LOG(ERROR) << "Problem stat'ing directory '%s' - %s" << tmpdir
-                       << strerror(saved_errno);
-            errno = saved_errno;
-            return false;
-        }
-    }
-    return true;
-}
-
-bool FileUtils::exists(const std::string &fname) {
-    struct stat statbuf;
-    if (stat(fname.c_str(), &statbuf) != 0)
-        return false;
-    return true;
-}
-
-bool FileUtils::unlink(const std::string &fname) {
-    if (::unlink(fname.c_str()) == -1) {
-        int saved_errno = errno;
-        LOG(ERROR) << "unlink(\"%s\") failed - %s" << fname.c_str()
-                   << strerror(saved_errno);
-        errno = saved_errno;
-        return false;
-    }
-    return true;
-}
-
-bool FileUtils::rename(const std::string &oldpath, const std::string &newpath) {
-    if (::rename(oldpath.c_str(), newpath.c_str()) == -1) {
-        int saved_errno = errno;
-        LOG(ERROR) << "rename(\"%s\", \"%s\") failed - %s"
-                   << oldpath.c_str() << newpath.c_str() << strerror(saved_errno);
-        errno = saved_errno;
-        return false;
-    }
-    return true;
-}
-
-uint64_t FileUtils::size(const std::string &fname) {
-    struct stat statbuf;
-    if (stat(fname.c_str(), &statbuf) != 0)
-        return 0;
-    return statbuf.st_size;
-}
-
-off_t FileUtils::length(const std::string &fname) {
-    struct stat statbuf;
-    if (stat(fname.c_str(), &statbuf) != 0)
-        return (off_t)-1;
-    return statbuf.st_size;
-}
-
-void FileUtils::add_trailing_slash(std::string &path) {
-    if (path.find('/', path.length() - 1) == std::string::npos)
-        path += "/";
-}
-
-bool FileUtils::expand_tilde(std::string &fname) {
-    if (fname[0] != '~')
-        return false;
-    std::lock_guard<std::mutex> lock(ms_mutex);
-    struct passwd pbuf;
-    struct passwd *prbuf;
-    char buf[256];
-    if (fname.length() == 1 || fname[1] == '/') {
-        if (getpwuid_r(getuid() , &pbuf, buf, 256, &prbuf) != 0 || prbuf == 0) {
-            return false;
-        }
-        fname = (std::string)pbuf.pw_dir + fname.substr(1);
-    }
-    else {
-        std::string name;
-        size_t first_slash = fname.find_first_of('/');
-        if (first_slash == std::string::npos) {
-            name = fname.substr(1);
-        } else {
-            name = fname.substr(1, first_slash-1);
-        }
-
-        if (getpwnam_r(name.c_str() , &pbuf, buf, 256, &prbuf) != 0 || prbuf == 0) {
-            return false;
-        }
-
-        if (first_slash == std::string::npos) {
-            fname = pbuf.pw_dir;
-        } else {
-            fname = (std::string)pbuf.pw_dir + fname.substr(first_slash);
-        }
-    }
-    return true;
-}
-
-void FileUtils::readdir(const std::string &dirname, const std::string &fname_regex,
-                        std::vector<struct dirent> &listing) {
-    int ret = 0;
-    DIR *dirp = opendir(dirname.c_str());
-    struct dirent de;
-    struct dirent *dep = 0;
-    boost::shared_ptr<re2::RE2> regex(fname_regex.length()
-                                 ? new re2::RE2(fname_regex)
-                                 : 0);
-    do {
-        if ((ret = readdir_r(dirp, &de, &dep)) != 0)
-            LOG(FATAL) << "Problem reading directory '%s' - %s" << dirname.c_str()
-                       << strerror(errno);
-        if (dep != 0 && (!regex || RE2::FullMatch(de.d_name, *regex)))
-            listing.push_back(de);
-    } while (dep != 0);
-    (void)closedir(dirp);
-}
-
-}
diff --git a/be/src/rpc/file_utils.h b/be/src/rpc/file_utils.h
deleted file mode 100644
index e3c7ef7d8b79f6..00000000000000
--- a/be/src/rpc/file_utils.h
+++ /dev/null
@@ -1,263 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_FILE_UTILS_H
-#define BDG_PALO_BE_SRC_RPC_FILE_UTILS_H
-
-#include "util.h"
-
-#include <mutex>
-#include <vector>
-
-extern "C" {
-#include <dirent.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-}
-
-namespace palo {
-
-/**
- * The FileUtils class provides static functions to easily access
- * and handle files and the file system.
- */
-class FileUtils {
-public:
-
-    /** Reads a whole file into a std::string
-     *
-     * @param fname The file name
-     * @param contents A reference to a std::string which will receive the data
-     * @return <i>true</i> on success, <i>false</i> on error
-     */
-    static bool read(const std::string &fname, std::string &contents);
-
-    /** Reads data from a file descriptor into a buffer
-     *
-     * @param fd The open file descriptor
-     * @param vptr Pointer to the memory buffer
-     * @param n Maximum size to read, in bytes
-     * @return The number of bytes read, or -1 on error
-     */
-    static ssize_t read(int fd, void *vptr, size_t n);
-
-    /** Reads positional data from a file descriptor into a buffer
-     *
-     * @param fd The open file descriptor
-     * @param vptr Pointer to the memory buffer
-     * @param n Maximum size to read, in bytes
-     * @param offset The start offset in the file
-     * @return The number of bytes read, or -1 on error
-     */
-    static ssize_t pread(int fd, void *vptr, size_t n, off_t offset);
-
-    /** Writes a std::string buffer to a file; the file is overwritten if it
-     * already exists
-     *
-     * @param fname Path of the file that is (over)written
-     * @param contents The string contents that are written to the file
-     * @return Number of bytes written, or -1 on error
-     */
-    static ssize_t write(const std::string &fname, const std::string &contents);
-
-    /** Writes a memory buffer to a file descriptor
-     *
-     * @param fd Open file handle
-     * @param vptr Pointer to the memory buffer
-     * @param n Size of the memory buffer, in bytes
-     * @return Number of bytes written, or -1 on error
-     */
-    static ssize_t write(int fd, const void *vptr, size_t n);
-
-    /** Writes a string to a file descriptor
-     *
-     * @param fd Open file handle
-     * @param str std::string to write to file
-     * @return Number of bytes written, or -1 on error
-     */
-    static ssize_t write(int fd, const std::string &str) {
-        return write(fd, str.c_str(), str.length());
-    }
-
-    /** Atomically writes data from multiple buffers to a file descriptor
-     *
-     *    struct iovec {
-     *      void  *iov_base;    // Starting address
-     *      size_t iov_len;     // Number of bytes to transfer
-     *    };
-     *
-     * @param fd Open file handle
-     * @param vector An iovec array holding pointers to the data
-     * @param count Number of iovec structures in @a vector
-     * @return Total number of bytes written, or -1 on error
-     */
-    static ssize_t writev(int fd, const struct iovec *vector, int count);
-
-    /** Sends data through a network connection; if the socket is TCP then
-     * the address is ignored. For UDP sockets the address structure
-     * specifies the recipient.
-     *
-     * @param fd Open file handle/socket descriptor
-     * @param vptr Pointer to the memory buffer which is sent
-     * @param n Size of the memory buffer, in bytes
-     * @param to The recipient's address (only UDP; ignored for TCP sockets)
-     * @param tolen Length of the sockaddr structure
-     * @return Total number of bytes sent, or -1 on error
-     */
-    static ssize_t sendto(int fd, const void *vptr, size_t n,
-            const sockaddr *to, socklen_t tolen);
-
-    /** Sends data through a network connection
-     *
-     * @param fd Open file handle/socket descriptor
-     * @param vptr Pointer to the memory buffer which is sent
-     * @param n Size of the memory buffer, in bytes
-     * @return Total number of bytes sent, or -1 on error
-     */
-    static ssize_t send(int fd, const void *vptr, size_t n);
-
-    /** Receives data from a network connection and returns the sender's
-     * address
-     *
-     * @param fd Open file handle/socket descriptor
-     * @param vptr Pointer to the memory buffer which receives the data
-     * @param n Capacity of the memory buffer, in bytes
-     * @param from The sender's address
-     * @param fromlen Length of the sockaddr structure
-     * @return Total number of bytes received, or -1 on error, 0 on eof
-     */
-    static ssize_t recvfrom(int fd, void *vptr, size_t n,
-            struct sockaddr *from, socklen_t *fromlen);
-
-    /** Receives data from a network connection
-     *
-     * @param fd Open file handle/socket descriptor
-     * @param vptr Pointer to the memory buffer which receives the data
-     * @param n Capacity of the memory buffer, in bytes
-     * @return Total number of bytes received, or -1 on error, 0 on eof
-     */
-    static ssize_t recv(int fd, void *vptr, size_t n);
-
-    /** Sets fcntl flags of a socket
-     *
-     * @param fd Open file handle/socket descriptor
-     * @param flags The fcntl flags; will be ORed with the existing flags
-     * @return true on success, otherwise false (sets errno)
-     */
-    static bool set_flags(int fd, int flags);
-
-    /** Reads a full file into a new buffer; the buffer is allocated with
-     * operator new[], and the caller has to delete[] it.
-     *
-     * @param fname The file name
-     * @param lenp Receives the length of the buffer, in bytes
-     * @return A pointer allocated with new[]; needs to be delete[]d by
-     *          the caller. Returns 0 on error (sets errno)
-     */
-    static char *file_to_buffer(const std::string &fname, off_t *lenp);
-
-    /** Reads a full file into a std::string
-     *
-     * @param fname The file name
-     * @return A string with the data, or an empty string on error (sets errno)
-     */
-    static std::string file_to_string(const std::string &fname);
-
-    /** Maps a full file into memory using mmap; the mapping will be released
-     * when the application terminates (there's currently no munmap)
-     *
-     * @param fname The file name
-     * @param lenp Receives the length of the buffer, in bytes
-     * @return A pointer to the mapped data
-     */
-    static void *mmap(const std::string &fname, off_t *lenp);
-
-    /** Creates a directory (with all parent directories, if required)
-     *
-     * @param dirname The directory name to create
-     * @return true on success, otherwise falls (sets errno)
-     */
-    static bool mkdirs(const std::string &dirname);
-
-    /** Checks if a file or directory exists
-     *
-     * @return true if the file or directory exists, otherwise false
-     */
-    static bool exists(const std::string &fname);
-
-    /** Unlinks (deletes) a file or directory
-     *
-     * @return true on success, otherwise false (sets errno)
-     */
-    static bool unlink(const std::string &fname);
-
-    /** Renames a file or directory
-     *
-     * @param oldpath The path of the file (or directory) to rename
-     * @param newpath The new filename
-     * @return true on success, otherwise false (sets errno)
-     */
-    static bool rename(const std::string &oldpath, const std::string &newpath);
-
-    /** Returns the size of a file (0 on error)
-     *
-     * @param fname The path of the file
-     * @return The file size (in bytes) or 0 on error (sets errno)
-     */
-    static uint64_t size(const std::string &fname);
-
-    /** Returns the size of a file (-1 on error)
-     *
-     * @param fname The path of the file
-     * @return The file size (in bytes) or -1 on error (sets errno)
-     */
-    static off_t length(const std::string &fname);
-
-    /** Adds a trailing slash to a path */
-    static void add_trailing_slash(std::string &path);
-
-    /** Expands a leading tilde character in a filename
-     *
-     *    Examples:
-     *
-     *      ~chris/foo -> /home/chris/foo
-     *      ~/foo      -> /home/$USER/foo
-     *
-     *  @return true on success, false on error
-     */
-    static bool expand_tilde(std::string &fname);
-
-    /** Reads all directory entries, applies a regular expression and returns
-     * those which match.
-     *
-     * This function will call HT_FATAL on error!
-     *
-     * @param dirname The directory name
-     * @param fname_regex The regular expression; can be empty
-     * @param listing Vector with the results
-     */
-    static void readdir(const std::string &dirname, const std::string &fname_regex,
-            std::vector<struct dirent> &listing);
-
-    /// Mutex for protecting thread-unsafe glibc library function calls
-    static std::mutex ms_mutex;
-};
-
-} //namespace palo
-#endif //BDG_PALO_BE_SRC_RPC_FILE_UTILS_H
diff --git a/be/src/rpc/handler_map.cpp b/be/src/rpc/handler_map.cpp
deleted file mode 100644
index 69f37d5763466a..00000000000000
--- a/be/src/rpc/handler_map.cpp
+++ /dev/null
@@ -1,430 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "io_handler_accept.h"
-#include "handler_map.h"
-#include "reactor_factory.h"
-
-#include <chrono>
-
-namespace palo {
-
-void HandlerMap::insert_handler(IOHandlerAccept *handler) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    assert(m_accept_handler_map.find(handler->get_address())
-           == m_accept_handler_map.end());
-    m_accept_handler_map[handler->get_local_address()] = handler;
-}
-
-void HandlerMap::insert_handler(IOHandlerData *handler, bool checkout) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    assert(m_data_handler_map.find(handler->get_address())
-           == m_data_handler_map.end());
-    m_data_handler_map[handler->get_address()] = handler;
-    if (checkout) {
-        handler->increment_reference_count();
-    }
-}
-
-void HandlerMap::insert_handler(IOHandlerDatagram *handler) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    assert(m_datagram_handler_map.find(handler->get_local_address())
-           == m_datagram_handler_map.end());
-    m_datagram_handler_map[handler->get_local_address()] = handler;
-}
-
-void HandlerMap::insert_handler(IOHandlerRaw *handler) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    assert(m_raw_handler_map.find(handler->get_address())
-           == m_raw_handler_map.end());
-    m_raw_handler_map[handler->get_address()] = handler;
-}
-
-int HandlerMap::checkout_handler(const CommAddress &addr,
-                                 IOHandlerAccept **handler) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    if ((*handler = lookup_accept_handler(addr.inet)) == 0) {
-        return error::COMM_NOT_CONNECTED;
-    }
-    assert(!(*handler)->is_decomissioned());
-    (*handler)->increment_reference_count();
-    return error::OK;
-}
-
-int HandlerMap::checkout_handler(const CommAddress &addr,
-                                 IOHandlerData **handler) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    InetAddr inet_addr;
-    int error = 0;
-    if ((error = translate_address(addr, &inet_addr)) != error::OK) {
-        return error;
-    }
-    if ((*handler = lookup_data_handler(inet_addr)) == 0) {
-        return error::COMM_NOT_CONNECTED;
-    }
-    assert(!(*handler)->is_decomissioned());
-    (*handler)->increment_reference_count();
-    return error::OK;
-}
-
-int HandlerMap::checkout_handler(const CommAddress &addr,
-                                 IOHandlerDatagram **handler) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    if ((*handler = lookup_datagram_handler(addr.inet)) == 0) {
-        return error::COMM_NOT_CONNECTED;
-    }
-    assert(!(*handler)->is_decomissioned());
-    (*handler)->increment_reference_count();
-    return error::OK;
-}
-
-int HandlerMap::checkout_handler(const CommAddress &addr,
-                                 IOHandlerRaw **handler) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    if ((*handler = lookup_raw_handler(addr.inet)) == 0) {
-        return error::COMM_NOT_CONNECTED;
-    }
-    assert(!(*handler)->is_decomissioned());
-    (*handler)->increment_reference_count();
-    return error::OK;
-}
-
-void HandlerMap::decrement_reference_count(IOHandler *handler) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    handler->decrement_reference_count();
-}
-
-int HandlerMap::contains_data_handler(const CommAddress &addr) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    IOHandlerData* handler = 0;
-    InetAddr inet_addr;
-    int error = 0;
-    if ((error = translate_address(addr, &inet_addr)) != error::OK) {
-        return error;
-    }
-    if ((handler = lookup_data_handler(inet_addr)) == 0) {
-        return error::COMM_NOT_CONNECTED;
-    }
-    return error::OK;
-}
-
-int HandlerMap::set_alias(const InetAddr &addr, const InetAddr &alias) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    SockAddrMap<IOHandlerData *>::iterator iter;
-    if (m_data_handler_map.find(alias) != m_data_handler_map.end()) {
-        return error::COMM_CONFLICTING_ADDRESS;
-    }
-    if ((iter = m_data_handler_map.find(addr)) == m_data_handler_map.end()) {
-        return error::COMM_NOT_CONNECTED;
-    }
-    (*iter).second->set_alias(alias);
-    m_data_handler_map[alias] = (*iter).second;
-    return error::OK;
-}
-
-int HandlerMap::remove_handler_unlocked(IOHandler *handler) {
-    SockAddrMap<IOHandlerAccept *>::iterator aiter;
-    SockAddrMap<IOHandlerData *>::iterator diter;
-    SockAddrMap<IOHandlerDatagram *>::iterator dgiter;
-    SockAddrMap<IOHandlerRaw *>::iterator riter;
-    InetAddr local_addr = handler->get_local_address();
-    InetAddr remote_addr;
-    int error = 0;
-    if ((error = translate_address(handler->get_address(), &remote_addr)) != error::OK) {
-        return error;
-    }
-    if ((diter = m_data_handler_map.find(remote_addr)) != m_data_handler_map.end()) {
-        assert(handler == diter->second);
-        m_data_handler_map.erase(diter);
-        // Remove alias
-        remote_addr = handler->get_alias();
-        if ((diter = m_data_handler_map.find(remote_addr)) != m_data_handler_map.end()) {
-            assert(handler == diter->second);
-            m_data_handler_map.erase(diter);
-        }
-    }
-    else if ((dgiter = m_datagram_handler_map.find(local_addr))
-             != m_datagram_handler_map.end()) {
-        assert(handler == dgiter->second);
-        m_datagram_handler_map.erase(dgiter);
-    }
-    else if ((aiter = m_accept_handler_map.find(local_addr))
-             != m_accept_handler_map.end()) {
-        assert(handler == aiter->second);
-        m_accept_handler_map.erase(aiter);
-    }
-    else if ((riter = m_raw_handler_map.find(remote_addr))
-             != m_raw_handler_map.end()) {
-        assert(handler == riter->second);
-        m_raw_handler_map.erase(riter);
-    }
-    else {
-        return error::COMM_NOT_CONNECTED;
-    }
-    return error::OK;
-}
-
-int HandlerMap::remove_handler(IOHandler *handler) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    return remove_handler_unlocked(handler);
-}
-
-void HandlerMap::decomission_handler_unlocked(IOHandler *handler) {
-    if (remove_handler_unlocked(handler) != error::OK) {
-        assert(m_decomissioned_handlers.count(handler) > 0);
-        return;
-    }
-    m_decomissioned_handlers.insert(handler);
-    handler->decomission();
-}
-
-void HandlerMap::decomission_all() {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    SockAddrMap<IOHandlerAccept *>::iterator aiter;
-    SockAddrMap<IOHandlerData *>::iterator diter;
-    SockAddrMap<IOHandlerDatagram *>::iterator dgiter;
-    SockAddrMap<IOHandlerRaw *>::iterator riter;
-    // IOHandlerData
-    for (diter = m_data_handler_map.begin(); diter != m_data_handler_map.end(); ++diter) {
-        m_decomissioned_handlers.insert(diter->second);
-        diter->second->decomission();
-    }
-    m_data_handler_map.clear();
-    // IOHandlerDatagram
-    for (dgiter = m_datagram_handler_map.begin();
-            dgiter != m_datagram_handler_map.end(); ++dgiter) {
-        m_decomissioned_handlers.insert(dgiter->second);
-        dgiter->second->decomission();
-    }
-    m_datagram_handler_map.clear();
-    // IOHandlerAccept
-    for (aiter = m_accept_handler_map.begin();
-            aiter != m_accept_handler_map.end(); ++aiter) {
-        m_decomissioned_handlers.insert(aiter->second);
-        aiter->second->decomission();
-    }
-    m_accept_handler_map.clear();
-    // IOHandlerRaw
-    for (riter = m_raw_handler_map.begin();
-            riter != m_raw_handler_map.end(); ++riter) {
-        m_decomissioned_handlers.insert(riter->second);
-        riter->second->decomission();
-    }
-    m_raw_handler_map.clear();
-}
-
-bool HandlerMap::destroy_ok(IOHandler *handler) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    bool is_decomissioned = m_decomissioned_handlers.count(handler) > 0;
-    assert(!is_decomissioned || handler->is_decomissioned());
-    return is_decomissioned && handler->reference_count() == 0;
-}
-
-bool HandlerMap::translate_proxy_address(const CommAddress &proxy_addr, InetAddr *addr) {
-    InetAddr inet_addr;
-    std::string hostname;
-    assert(proxy_addr.is_proxy());
-    if (!m_proxy_map.get_mapping(proxy_addr.proxy, hostname, inet_addr)) {
-        return false;
-    }
-    if (addr) {
-        *addr = inet_addr;
-    }
-    return true;
-}
-
-void HandlerMap::wait_for_empty() {
-    std::unique_lock<std::mutex> lock(m_mutex);
-    m_cond.wait(lock, [this]() {
-        return m_decomissioned_handlers.empty();
-    });
-}
-
-void HandlerMap::purge_handler(IOHandler *handler) {
-    {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        assert(m_decomissioned_handlers.count(handler) > 0);
-        assert(handler->reference_count() == 0);
-        m_decomissioned_handlers.erase(handler);
-        if (m_decomissioned_handlers.empty()) {
-            m_cond.notify_all();
-        }
-    }
-    handler->disconnect();
-    delete handler;
-}
-
-int HandlerMap::add_proxy(
-        const std::string &proxy, 
-        const std::string &hostname, 
-        const InetAddr &addr) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    ProxyMapT new_map;
-    ProxyMapT invalidated_map;
-    m_proxy_map.update_mapping(proxy, hostname, addr, invalidated_map, new_map);
-    for (const auto &v : new_map) {
-        IOHandler *handler = lookup_data_handler(v.second.addr);
-        if (handler)
-            handler->set_proxy(v.first);
-    }
-    return propagate_proxy_map(new_map);
-}
-
-int HandlerMap::remove_proxy(const std::string &proxy) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    ProxyMapT remove_map;
-    m_proxy_map.remove_mapping(proxy, remove_map);
-    if (!remove_map.empty()) {
-        IOHandler *handler = 0;
-        for (const auto &v : remove_map) {
-            handler = lookup_data_handler(v.second.addr);
-            if (handler)
-                decomission_handler_unlocked(handler);
-        }
-        return propagate_proxy_map(remove_map);
-    }
-    return error::OK;
-}
-
-void HandlerMap::get_proxy_map(ProxyMapT &proxy_map) {
-    m_proxy_map.get_map(proxy_map);
-}
-
-void HandlerMap::update_proxy_map(const char *message, size_t message_len) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    std::string mappings(message, message_len);
-    ProxyMapT new_map;
-    ProxyMapT invalidated_map;
-    assert(!ReactorFactory::proxy_master);
-    m_proxy_map.update_mappings(mappings, invalidated_map, new_map);
-    for (const auto &v : invalidated_map) {
-        IOHandler *handler = lookup_data_handler(v.second.addr);
-        if (handler) {
-            if (v.second.hostname == "--DELETED--")
-                decomission_handler_unlocked(handler);
-        }
-    }
-    for (const auto &v : new_map) {
-        IOHandler *handler = lookup_data_handler(v.second.addr);
-        if (handler)
-            handler->set_proxy(v.first);
-    }
-    //LOG(INFO) << "Updated proxy map = %s", m_proxy_map.to_str().c_str();
-    m_proxies_loaded = true;
-    m_cond_proxy.notify_all();
-}
-
-int32_t HandlerMap::propagate_proxy_map(IOHandlerData *handler) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    assert(ReactorFactory::proxy_master);
-    CommBufPtr comm_buf = m_proxy_map.create_update_message();
-    comm_buf->write_header_and_reset();
-    return handler->send_message(comm_buf);
-}
-
-bool HandlerMap::wait_for_proxy_map(Timer &timer) {
-    std::unique_lock<std::mutex> lock(m_mutex);
-    timer.start();
-    auto drop_time = std::chrono::steady_clock::now() +
-                     std::chrono::milliseconds(timer.remaining());
-    return m_cond_proxy.wait_until(lock, drop_time,
-    [this]() {
-        return m_proxies_loaded;
-    });
-}
-
-int HandlerMap::propagate_proxy_map(ProxyMapT &mappings) {
-    int last_error = error::OK;
-    if (mappings.empty())
-        return error::OK;
-    SockAddrMap<IOHandlerData *>::iterator iter;
-    std::string mapping;
-    for (const auto &v : mappings) {
-        mapping += v.first + "\t" + v.second.hostname + "\t" + InetAddr::format(v.second.addr) + "\n";
-    }
-    uint8_t *buffer = new uint8_t [ mapping.length() + 1 ];
-    strcpy((char *)buffer, mapping.c_str());
-    boost::shared_array<uint8_t> payload(buffer);
-    CommHeader header;
-    header.flags |= CommHeader::FLAGS_BIT_PROXY_MAP_UPDATE;
-    std::vector<IOHandler *> decomission;
-    for (iter = m_data_handler_map.begin(); iter != m_data_handler_map.end(); ++iter) {
-        IOHandlerData *handler = iter->second;
-        if (handler) {
-            CommBufPtr comm_buf = std::make_shared<CommBuf>(header, 0, payload, mapping.length()+1);
-            comm_buf->write_header_and_reset();
-            int error = handler->send_message(comm_buf);
-            if (error != error::OK) {
-                decomission.push_back(handler);
-                LOG(ERROR) << "Unable to propagate proxy mappings to %s - %s"
-                           << InetAddr(handler->get_address()).format().c_str()
-                           << error::get_text(error);
-                last_error = error;
-            }
-        }
-    }
-    // Decomission any handlers that failed
-    for (auto handler : decomission) {
-        decomission_handler_unlocked(handler);
-    }
-    return last_error;
-}
-
-int HandlerMap::translate_address(const CommAddress &addr, InetAddr *inet_addr) {
-    std::string hostname;
-    assert(addr.is_set());
-    if (addr.is_proxy()) {
-        if (!m_proxy_map.get_mapping(addr.proxy, hostname, *inet_addr))
-            return error::COMM_INVALID_PROXY;
-    }
-    else
-        memcpy(inet_addr, &addr.inet, sizeof(InetAddr));
-    return error::OK;
-}
-
-IOHandlerAccept *HandlerMap::lookup_accept_handler(const InetAddr &addr) {
-    SockAddrMap<IOHandlerAccept *>::iterator iter = m_accept_handler_map.find(addr);
-    if (iter != m_accept_handler_map.end())
-        return iter->second;
-    return 0;
-}
-
-IOHandlerData *HandlerMap::lookup_data_handler(const InetAddr &addr) {
-    SockAddrMap<IOHandlerData *>::iterator iter = m_data_handler_map.find(addr);
-    if (iter != m_data_handler_map.end())
-        return iter->second;
-    return 0;
-}
-
-IOHandlerDatagram *HandlerMap::lookup_datagram_handler(const InetAddr &addr) {
-    SockAddrMap<IOHandlerDatagram *>::iterator iter = m_datagram_handler_map.find(addr);
-    if (iter != m_datagram_handler_map.end())
-        return iter->second;
-    return 0;
-}
-
-IOHandlerRaw *HandlerMap::lookup_raw_handler(const InetAddr &addr) {
-    SockAddrMap<IOHandlerRaw *>::iterator iter = m_raw_handler_map.find(addr);
-    if (iter != m_raw_handler_map.end())
-        return iter->second;
-    return 0;
-}
-
-} //namespace palo
diff --git a/be/src/rpc/handler_map.h b/be/src/rpc/handler_map.h
deleted file mode 100644
index 63f50a0793b772..00000000000000
--- a/be/src/rpc/handler_map.h
+++ /dev/null
@@ -1,422 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_HANDLER_MAP_H
-#define BDG_PALO_BE_SRC_RPC_HANDLER_MAP_H
-
-#include "comm_address.h"
-#include "comm_buf.h"
-#include "io_handler_data.h"
-#include "io_handler_datagram.h"
-#include "io_handler_raw.h"
-#include "proxy_map.h"
-#include "error.h"
-#include "common/logging.h"
-#include "sock_addr_map.h"
-
-#include "timer.h"
-#include <condition_variable>
-#include <cassert>
-#include <memory>
-#include <mutex>
-
-namespace palo {
-class IOHandlerAccept;
-
-/** Data structure for mapping socket addresses to I/O handlers.
- * An I/O handler is associated with each socket connection and is used
- * to handle polling events on the socket descriptor.  Examples incude
- * writing a message to the socket, reading a message from the socket,
- * or completing a connection request.  This class maintains three maps,
- * one for TCP socket connections, UDP socket connections, and one for
- * accept sockets.  The Comm methods use this map to locate the I/O
- * handler for a given address.
- */
-class HandlerMap {
-public:
-
-    /** Constructor. */
-    HandlerMap() : m_proxies_loaded(false) { }
-
-    /** Inserts an accept handler.
-     * Uses IOHandler#m_local_addr as the key
-     * @param handler Accept I/O handler to insert
-     */
-    void insert_handler(IOHandlerAccept *handler);
-
-    /** Inserts a data (TCP) handler.
-     * Uses IOHandler#m_addr as the key.  If program is the proxy master,
-     * a proxy map update message with the new mapping is broadcast to
-     * all connections.
-     * @param handler Data (TCP) I/O handler to insert
-     * @param checkout Atomically checkout handler
-     */
-    void insert_handler(IOHandlerData *handler, bool checkout=false);
-
-    /** Inserts a datagram (UDP) handler.
-     * Uses IOHandler#m_local_addr as the key.
-     * @param handler Datagram (UDP) I/O handler to insert
-     */
-    void insert_handler(IOHandlerDatagram *handler);
-
-    /** Inserts a raw handler.
-     * Uses IOHandler#m_addr as the key.
-     * @param handler Raw I/O handler to insert
-     */
-    void insert_handler(IOHandlerRaw *handler);
-
-    /** Checks out accept I/O handler associated with <code>addr</code>.
-     * Looks up <code>addr</code> in accept map.  If an entry is found,
-     * then its reference count is incremented and it is returned
-     * in <code>handler</code>.
-     * @param addr Connection address
-     * @param handler Address of handler pointer returned
-     * @return error::OK on success, or error::COMM_NOT_CONNECTED if no mapping
-     * found for <code>addr</code>.
-     */
-    int checkout_handler(const CommAddress &addr, IOHandlerAccept **handler);
-
-    /** Checks out data (TCP) I/O handler associated with <code>addr</code>.
-     * First translates <code>addr</code> to socket address and then
-     * looks up translated address in data map.  If an entry is found,
-     * then its reference count is incremented and it is returned
-     * in <code>handler</code>.
-     * @param addr Connection address
-     * @param handler Address of handler pointer returned
-     * @return error::OK on success, error::COMM_INVALID_PROXY if
-     * <code>addr</code> is of type CommAddress::PROXY and no translation
-     * exists, or error::COMM_NOT_CONNECTED if no mapping found for
-     * translated address.
-     */
-    int checkout_handler(const CommAddress &addr, IOHandlerData **handler);
-
-    /** Checks out datagram (UDP) I/O handler associated with <code>addr</code>.
-     * Looks up <code>addr</code> in datagram map.  If an entry is found,
-     * then its reference count is incremented and it is returned
-     * in <code>handler</code>.
-     * @param addr Connection address
-     * @param handler Address of handler pointer returned
-     * @return error::OK on success, or error::COMM_NOT_CONNECTED if no mapping
-     * found for <code>addr</code>.
-     */
-    int checkout_handler(const CommAddress &addr, IOHandlerDatagram **handler);
-
-    /** Checks out raw I/O handler associated with <code>addr</code>.
-     * Looks up <code>addr</code> in raw map.  If an entry is found,
-     * then its reference count is incremented and it is returned
-     * in <code>handler</code>.
-     * @param addr Connection address
-     * @param handler Address of handler pointer returned
-     * @return error::OK on success, or error::COMM_NOT_CONNECTED if no mapping
-     * found for <code>addr</code>.
-     */
-    int checkout_handler(const CommAddress &addr, IOHandlerRaw **handler);
-
-    /** Checks to see if <code>addr</code> is contained in map.
-     * First translates <code>addr</code> to socket address and then
-     * looks up translated address in data map.
-     * @param addr Connection address
-     * @return error::OK if found, error::COMM_INVALID_PROXY if
-     * <code>addr</code> is of type CommAddress::PROXY and no translation
-     * exists, or error::COMM_NOT_CONNECTED if no mapping found for
-     * translated address.
-     */
-    int contains_data_handler(const CommAddress &addr);
-
-    /** Decrements the reference count of <code>handler</code>.
-     * The decrementing of a handler's reference count is done by this method
-     * with #m_mutex locked which avoids a race condition between checking
-     * out handlers and purging them.
-     * @param handler Pointer to I/O handler for which to decrement reference
-     * count
-     */
-    void decrement_reference_count(IOHandler *handler);
-
-    /** Sets an alias address for an existing TCP address in map.
-     * RangeServers listen on a well-known port defined by the
-     * <code>palo.RangeServer.Port</code> configuration property
-     * (default = 15865).  However, RangeServers connect to the master using
-     * an ephemeral port due to a bind conflict with its listen socket.  So that
-     * the Master can refer to the RangeServer using the well-known port, an
-     * alias address can be registered and subsequently used to reference the
-     * connection.  This method adds an entry to the data (TCP) map for
-     * <code>alias</code> which references the IOHandlerData object previously
-     * registered under <code>addr</code>.
-     * @param addr Address of previously registered data handler
-     * @param alias Alias address to add
-     * @return error::OK on success, or error::COMM_CONFLICTING_ADDRESS if
-     * <code>alias</code> is already in the data map, or
-     * error::COMM_NOT_CONNECTED if <code>addr</code> is not found in the data
-     * map.
-     */
-    int set_alias(const InetAddr &addr, const InetAddr &alias);
-
-    /** Removes <code>handler</code> from map.  This method removes
-     * <code>handler</code> from the data, datagram, or accept map, depending
-     * on the type of handler.  If <code>handler</code> refers to a data
-     * handler, then its alias address entry is also removed from the data map.
-     * @param handler IOHandler to remove
-     * @return error::OK on success, or error::COMM_NOT_CONNECTED if
-     * <code>handler</code> is not found in any of the maps.
-     */
-    int remove_handler(IOHandler *handler);
-
-    /** Decomissions <code>handler</code>.  Since handler pointers are passed
-     * into the polling mechanism and asynchronously referenced by reactor
-     * threads, care must be taken to not delete a handler until it has
-     * be removed from the polling mechanism.  This is accomplished by
-     * introducing a two-step removal process.  First a handler is decomissioned
-     * (by this method) by removing it from the associated map, adding it to the
-     * #m_decomissioned_handlers set and marking it decomissioned.  Once there
-     * are no more references to the handler, it may be safely removed.  The
-     * removal is accomplished via #purge_handler which is called by the reactor
-     * thread after it has been removed from the polling interface.
-     * @param handler Pointer to IOHandler to decomission
-     */
-    void decomission_handler_unlocked(IOHandler *handler);
-
-    /** Decomissions <code>handler</code> with #m_mutex locked.
-     * This method locks #m_mutex and calls #decomission_handler_unlocked
-     * @param handler Pointer to IOHandler to decomission
-     */
-    void decomission_handler(IOHandler *handler) {
-        std::lock_guard<std::mutex> lock(m_mutex);
-
-        decomission_handler_unlocked(handler);
-
-    }
-    /** Decomissions all handlers.  This method is called by the ~Comm to
-     * decomission all of the handlers in the map.
-     * @note It doesn't look like the Comm object ever gets deleted and
-     * therefore this method never gets called.  See issue 1031.
-     */
-    void decomission_all();
-
-    /** Determines if <code>handler</code> can be destoryed.  
-     * @return <i>true</i> if <code>handler</code> is decomissioned and
-     * has a reference count of 0.
-     */
-    bool destroy_ok(IOHandler *handler);
-
-    /** Translates <code>proxy_addr</code> to its corresponding IPV4 address.
-     * This method fetches the mapping for <code>proxy_addr</code> from
-     * #m_proxy_map and returns the associated IPV4 address in
-     * <code>addr</code>.  If <code>addr</code> is NULL, then no translation
-     * occurs but the return value can be checked to see if the proxy name
-     * contains a mapping.
-     * @param proxy_addr Reference to proxy address
-     * @param addr Pointer to return IPV4 address
-     * @return <i>true</i> if mapping found, <i>false</i> otherwise
-     */
-    bool translate_proxy_address(const CommAddress &proxy_addr, InetAddr *addr);
-
-    /** Purges (removes) <code>handler</code>.  This method removes
-     * <code>handler</code> from the #m_decomissioned_handlers set, signals
-     * #m_cond if #m_decomissioned_handlers becomes empty, calls
-     * <code>hander->disconnect()</code>, and then deletes the handler.
-     * This method must only be called from a reactor thread after the handler
-     * has been removed from the polling interface and #destroy_ok returns
-     * true for the handler.
-     * @param handler Handler to purge
-     */
-    void purge_handler(IOHandler *handler);
-
-    /** Waits for map to become empty.  This method assumes that all of the
-     * handlers in the map have been decomissioned.  It waits for the
-     * #m_decomissioned_handlers set to become empty, waiting on #m_cond
-     * until it does.
-     */
-    void wait_for_empty();
-
-    /** Adds or updates proxy information.  This method adds or updates proxy
-     * information in #m_proxy_map.  For the data handler to which
-     * <code>addr</code> refers, it updates its proxy name via a call to
-     * IOHandler::set_proxy and then calls #propagate_proxy_map with the newly
-     * added/updated proxy information to update all active data connections
-     * with the new proxy information.
-     * @note This method should only be called by the proxy master.
-     * @param proxy Proxy name of new/updated mapping
-     * @param hostname Hostname of new/updated mapping
-     * @param addr InetAddr of new/updated mapping
-     * @return error::OK on success, or one of the errors returned by
-     * #propagate_proxy_map
-     */
-    int add_proxy(const std::string &proxy, const std::string &hostname, const InetAddr &addr);
-
-    /** Removes a proxy name from the proxy map.  This method removes
-     * <code>proxy</code> from #m_proxy_map and then calls #propagate_proxy_map
-     * to propagate the removed mapping information to all connections.
-     * @note This method should only be called by the proxy master.
-     * @param proxy Proxy name to remove
-     * @return error::OK if <code>proxy</code> not found in proxy map or if
-     * it was successfully removed, or one of the errors returned by
-     * #propagate_proxy_map
-     */
-    int remove_proxy(const std::string &proxy);
-
-    /** Returns the proxy map
-     * @param proxy_map reference to returned proxy map
-     */
-    void get_proxy_map(ProxyMapT &proxy_map);
-
-    /** Updates the proxy map with a proxy map update message received from the
-     * proxy master.  Calls ProxyMap::update_mappings with <code>message</code>
-     * to update the proxy map.  If any of the proxy names have changed, the
-     * corresponding data handlers are updated with a call to
-     * IOHandler::set_proxy.  For each mapping in <code>message</code> that has
-     * the hostname set to <code>--DELETED--</code>, the associated data handler
-     * is decomissioned.  After the proxy map has been successfuly updated, the
-     * #m_proxies_loaded flag is set to <i>true</i> and the #m_cond_proxy
-     * condition variable is signalled.
-     * @param message Pointer to proxy map update message
-     * @param message_len Length of proxy map update message
-     */
-    void update_proxy_map(const char *message, size_t message_len);
-
-    /** Sends the current proxy map over connection identified by
-     * <code>handler</code>.  This method must only be called by the proxy
-     * master, otherwise it will assert.
-     * @param handler Connection over which to send proxy map
-     * @return Same set of error codes returned by IOHandlerData#send_message
-     */
-    int32_t propagate_proxy_map(IOHandlerData *handler);
-
-    /** Waits for proxy map to get updated from a proxy map update message
-     * received from the master.  This method waits on #m_cond_proxy for
-     * #m_proxies_loaded to become <i>true</i> or <code>timer</code> expires.
-     * @param timer Deadline timer
-     * @return <i>true</i> if proxy map was loaded, <i>false</i> if
-     * <code>timer</code> expired before proxy map was loaded.
-     */
-    bool wait_for_proxy_map(Timer &timer);
-
-private:
-    /** Propagates proxy map information in <code>mappings</code> to
-     * all active data (TCP) connections.  This method creates a proxy
-     * map update message from the mappings in <code>mappings</code>.
-     * The update message is just a list of mapping entries in the
-     * following format:
-     * @verbatim <proxy> '\t' <hostname> '\t' <addr> '\n' @endverbatim
-     * Then the proxy map update message is sent via each of the handlers in
-     * the data (TCP) handler map.  If an error is encountered on a
-     * handler when trying to send the proxy map, it will be decomissioned.
-     * @param mappings Proxy map information to propagate.
-     * @return error::OK if proxy map update message was successfully
-     * sent across all data handlers, otherwise one of the error
-     * codes returned by IOHandlerData#send_message
-     */
-    int propagate_proxy_map(ProxyMapT &mappings);
-
-    /** Translates <code>addr</code> to an InetAddr (IP address).
-     * If <code>addr</code> is of type CommAddress::PROXY, then the
-     * #m_proxy_map is consulted to translate the proxy name to an IP address,
-     * otherwise if <code>addr</code> is of type CommAddress::INET, the IP
-     * address held in <code>addr</code> is copied to <code>inet_addr</code>.
-     * @param addr Address to translate
-     * @param inet_addr Pointer to valid InetAddr object to hold translated
-     * address
-     * @return error::OK on success, error::COMM_INVALID_PROXY if
-     * <code>addr</code> is of type CommAddress::PROXY and no mapping is found.
-     */
-    int translate_address(const CommAddress &addr, InetAddr *inet_addr);
-
-    /** Removes <code>handler</code> from map without locking #m_mutex.  This
-     * method removes <code>handler</code> from the data, datagram, or accept
-     * map, depending on the type of handler.  If <code>handler</code> refers to
-     * a data handler, then its alias address entry is also removed from the
-     * data map.
-     * @param handler IOHandler to remove
-     * @return error::OK on success, or error::COMM_NOT_CONNECTED if
-     * <code>handler</code> is not found in any of the maps.
-     */
-    int remove_handler_unlocked(IOHandler *handler);
-
-    /** Finds <i>accept</i> I/O handler associated with <code>addr</code>.
-     * This method looks up <code>addr</code> in #m_accept_handler_map and
-     * returns the handler, if found.
-     * @param addr Address of accept handler to locate
-     * @return Pointer to IOHandlerAccept object associated with
-     * <code>addr</code>, or 0 if not found.
-     */
-    IOHandlerAccept *lookup_accept_handler(const InetAddr &addr);
-
-    /** Finds <i>data (TCP)</i> I/O handler associated with <code>addr</code>.
-     * This method looks up <code>addr</code> in #m_data_handler_map and
-     * returns the handler, if found.
-     * @param addr Address of data handler to locate
-     * @return Pointer to IOHandlerData object associated with
-     * <code>addr</code>, or 0 if not found.
-     */
-    IOHandlerData *lookup_data_handler(const InetAddr &addr);
-
-    /** Finds <i>datagram</i> I/O handler associated with <code>addr</code>.
-     * This method looks up <code>addr</code> in #m_datagram_handler_map and
-     * returns the handler, if found.
-     * @param addr Address of datagram handler to locate
-     * @return Pointer to IOHandlerDatagram object associated with
-     * <code>addr</code>, or 0 if not found.
-     */
-    IOHandlerDatagram *lookup_datagram_handler(const InetAddr &addr);
-
-    /** Finds <i>raw</i> I/O handler associated with <code>addr</code>.
-     * This method looks up <code>addr</code> in #m_raw_handler_map and
-     * returns the handler, if found.
-     * @param addr Address of raw handler to locate
-     * @return Pointer to IOHandlerRaw object associated with
-     * <code>addr</code>, or nullptr if not found.
-     */
-    IOHandlerRaw *lookup_raw_handler(const InetAddr &addr);
-
-    /// %Mutex for serializing concurrent access
-    std::mutex m_mutex;
-
-    /// Condition variable for signalling empty map
-    std::condition_variable m_cond;
-
-    /// Condition variable for signalling proxy map load
-    std::condition_variable m_cond_proxy;
-
-    /// Accept map (InetAddr-to-IOHandlerAccept)
-    SockAddrMap<IOHandlerAccept *> m_accept_handler_map;
-
-    /// Data (TCP) map (InetAddr-to-IOHandlerData)
-    SockAddrMap<IOHandlerData *> m_data_handler_map;
-
-    /// Datagram (UDP) map (InetAddr-to-IOHandlerDatagram)
-    SockAddrMap<IOHandlerDatagram *> m_datagram_handler_map;
-
-    /// Raw map (InetAddr-to-IOHandlerRaw)
-    SockAddrMap<IOHandlerRaw *> m_raw_handler_map;
-
-    /// Decomissioned handler set
-    std::set<IOHandler *> m_decomissioned_handlers;
-
-    /// Proxy map
-    ProxyMap m_proxy_map;
-
-    /// Flag indicating if proxy map has been loaded
-    bool m_proxies_loaded;
-
-};
-
-/// Smart pointer to HandlerMap
-typedef std::shared_ptr<HandlerMap> HandlerMapPtr;
-
-} //namespace palo
-#endif //BDG_PALO_BE_SRC_RPC_HANDLER_MAP_H
diff --git a/be/src/rpc/inet_addr.cpp b/be/src/rpc/inet_addr.cpp
deleted file mode 100644
index 9f69c469a65ee6..00000000000000
--- a/be/src/rpc/inet_addr.cpp
+++ /dev/null
@@ -1,302 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "serialization.h"
-#include "common/logging.h"
-#include <cstdlib>
-#include <cstring>
-#include <assert.h>
-
-extern "C" {
-#include <arpa/inet.h>
-#include <netdb.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-}
-
-#include "inet_addr.h"
-#include "string_ext.h"
-namespace palo {
-InetAddr::InetAddr() {
-    //HT_EXPECT(sizeof(sockaddr_in) == sizeof(InetAddr), error::UNPOSSIBLE);
-    assert(sizeof(sockaddr_in) == sizeof(InetAddr));
-    memset(this, 0, sizeof(InetAddr));
-}
-
-InetAddr::InetAddr(const std::string &host, uint16_t port) {
-    //HT_EXPECT(sizeof(sockaddr_in) == sizeof(InetAddr), error::UNPOSSIBLE);
-    //HT_EXPECT(initialize(this, host.c_str(), port), error::BAD_DOMAIN_NAME);
-    assert(sizeof(sockaddr_in) == sizeof(InetAddr));
-    initialize(this, host.c_str(), port);
-}
-
-InetAddr::InetAddr(const std::string &endpoint) {
-    //HT_EXPECT(sizeof(sockaddr_in) == sizeof(InetAddr), error::UNPOSSIBLE);
-    //HT_EXPECT(initialize(this, endpoint.c_str()), error::BAD_DOMAIN_NAME);
-    assert(sizeof(sockaddr_in) == sizeof(InetAddr));
-    initialize(this, endpoint.c_str());
-}
-
-InetAddr::InetAddr(uint32_t ip32, uint16_t port) {
-    //HT_EXPECT(sizeof(sockaddr_in) == sizeof(InetAddr), error::UNPOSSIBLE);
-    assert(sizeof(sockaddr_in) == sizeof(InetAddr));
-    initialize(this, ip32, port);
-}
-
-bool InetAddr::initialize(sockaddr_in *addr, const char *host, uint16_t port) {
-    memset(addr, 0, sizeof(struct sockaddr_in));
-    if (parse_ipv4(host, port, *addr)) {
-        return true;
-    }
-    else {
-        // Let's hope this is not broken in the glibc we're using
-        struct hostent hent;
-        struct hostent *he = 0;
-        char hbuf[2048];
-        int err = 0;
-        if (gethostbyname_r(host, &hent, hbuf, sizeof(hbuf), &he, &err) != 0 || he == 0) {
-            LOG(ERROR) << "gethostbyname host=" << host << ", error: " << err;
-            return false;
-        }
-        memcpy(&addr->sin_addr.s_addr, he->h_addr_list[0], sizeof(uint32_t));
-        if (addr->sin_addr.s_addr == 0) {
-            uint8_t *ip = (uint8_t *)&addr->sin_addr.s_addr;
-            ip[0] = 127;
-            ip[3] = 1;
-        }
-    }
-    addr->sin_family = AF_INET;
-    addr->sin_port = htons(port);
-    return true;
-}
-
-bool
-InetAddr::is_ipv4(const char *ipin) {
-    const char *ptr = ipin;
-    const char *end = ipin + strlen(ipin);
-    char* last = 0;
-    int component = 0;
-    int num_components = 0;
-    int base = 10;
-    while (ptr < end) {
-        component = strtol(ptr, &last, base);
-        num_components++;
-        if (last == end) {
-            break;
-        }
-        if (*last != '.' || last > end || component > 255
-                || component < 0 || num_components > 4) {
-            return false;
-        }
-        ptr = last + 1;
-    }
-    if (num_components != 4 || component > 255 || component < 0) {
-        return false;
-    }
-    return true;
-}
-
-bool
-InetAddr::parse_ipv4(const char *ipin, uint16_t port, sockaddr_in &addr,
-                     int base) {
-    uint8_t *ip = (uint8_t *)&addr.sin_addr.s_addr;
-    const char* ipstr = ipin;
-    const char* end = ipin + strlen(ipin);
-    char* last = 0;
-    int64_t n = strtoll(ipstr, &last, base);
-    addr.sin_family = AF_INET;
-    addr.sin_port = htons(port);
-    if (last == end && n > 0 && n < UINT32_MAX) {
-        addr.sin_addr.s_addr = htonl(n);
-        return true;
-    }
-    *ip++ = n;
-    if (last > end || *last != '.') {
-        return false;
-    }
-    ipstr = last + 1;
-    *ip++ = strtol(ipstr, &last, base);
-    if (last >= end || *last != '.') {
-        return false;
-    }
-    ipstr = last + 1;
-    *ip++ = strtol(ipstr, &last, base);
-    if (last >= end || *last != '.') {
-        return false;
-    }
-    ipstr = last + 1;
-    *ip++ = strtol(ipstr, &last, base);
-    if (last != end) {
-        return false;
-    }
-    if (addr.sin_addr.s_addr == 0) {
-        uint8_t *ip = (uint8_t *)&addr.sin_addr.s_addr;
-        ip[0] = 127;
-        ip[3] = 1;
-    }
-    return true;
-}
-
-Endpoint InetAddr::parse_endpoint(const char *endpoint, int default_port) {
-    const char *colon = strchr(endpoint, ':');
-    if (colon) {
-        std::string host = std::string(endpoint, colon - endpoint);
-        return Endpoint(host, atoi(colon + 1));
-    }
-    return Endpoint(endpoint, default_port);
-}
-
-bool InetAddr::initialize(sockaddr_in *addr, const char *addr_str) {
-    Endpoint e = parse_endpoint(addr_str);
-    if (e.port) {
-        return initialize(addr, e.host.c_str(), e.port);
-    }
-    return initialize(addr, "localhost", atoi(addr_str));
-}
-
-bool InetAddr::initialize(sockaddr_in *addr, uint32_t haddr, uint16_t port) {
-    memset(addr, 0, sizeof(sockaddr_in));
-    addr->sin_family = AF_INET;
-    addr->sin_addr.s_addr = htonl(haddr);
-    addr->sin_port = htons(port);
-    return true;
-}
-
-std::string InetAddr::format(const sockaddr_in &addr, int sep) {
-    // inet_ntoa is not thread safe on many platforms and deprecated
-    const uint8_t *ip = (uint8_t *)&addr.sin_addr.s_addr;
-    return palo::format("%d.%d.%d.%d%c%d", (int)ip[0], (int)ip[1],
-                        (int)ip[2], (int)ip[3], sep, (int)ntohs(addr.sin_port));
-}
-
-std::string InetAddr::format_ipaddress(const sockaddr_in &addr) {
-    // inet_ntoa is not thread safe on many platforms and deprecated
-    const uint8_t *ip = (uint8_t *)&addr.sin_addr.s_addr;
-    return palo::format("%d.%d.%d.%d", (int)ip[0], (int)ip[1],
-                        (int)ip[2], (int)ip[3]);
-}
-
-std::string InetAddr::hex(const sockaddr_in &addr, int sep) {
-    return palo::format("%x%c%x", ntohl(addr.sin_addr.s_addr), sep,
-                        ntohs(addr.sin_port));
-}
-
-size_t InetAddr::encoded_length() const {
-    size_t length = encoded_length_internal();
-    return 1 + serialization::encoded_length_vi32(length) + length;
-}
-
-/**
- * @details
- * Encoding is as follows:
- * <table>
- * <tr>
- * <th>Encoding</th>
- * <th>Description</th>
- * </tr>
- * <tr>
- * <td>1 byte</td>
- * <td>Encoding version as returned by encoding_version()</td>
- * </tr>
- * <tr>
- * <td>vint</td>
- * <td>Length of encoded object as returned by encoded_length_internal()</td>
- * </tr>
- * <tr>
- * <td>variable</td>
- * <td>Object encoded with encode_internal()</td>
- * </tr>
- * </table>
- */
-void InetAddr::encode(uint8_t **bufp) const {
-    serialization::encode_i8(bufp, encoding_version());
-    serialization::encode_vi32(bufp, encoded_length_internal());
-    encode_internal(bufp);
-}
-
-void InetAddr::decode(const uint8_t **bufp, size_t *remainp) {
-    uint8_t version = serialization::decode_i8(bufp, remainp);
-    //if (version > encoding_version())
-    //HT_THROWF(error::PROTOCOL_ERROR, "Unsupported InetAddr version %d", (int)version);
-    size_t encoding_length = serialization::decode_vi32(bufp, remainp);
-    const uint8_t *end = *bufp + encoding_length;
-    size_t tmp_remain = encoding_length;
-    decode_internal(version, bufp, &tmp_remain);
-    *remainp -= encoding_length;
-    // If encoding is longer than we expect, that means we're decoding a newer
-    // version, so skip the newer portion that we don't know about
-    if (*bufp < end) {
-        *bufp = end;
-    }
-}
-
-void InetAddr::legacy_decode(const uint8_t **bufp, size_t *remainp) {
-    serialization::decode_i8(bufp, remainp);
-    sin_family = serialization::decode_i8(bufp, remainp);
-    sin_port = serialization::decode_i16(bufp, remainp);
-    sin_addr.s_addr = serialization::decode_i32(bufp, remainp);
-}
-
-uint8_t InetAddr::encoding_version() const {
-    return 1;
-}
-
-size_t InetAddr::encoded_length_internal() const {
-    return 8;
-}
-
-/// @details
-/// Encoding is as follows:
-/// <table>
-/// <tr>
-/// <th>Encoding</th>
-/// <th>Description</th>
-/// </tr>
-/// <tr><td>i8</td><td>sizeof(sockaddr_in)</td></tr>
-/// <tr><td>i8</td><td>Address family (sin_family)</td></tr>
-/// <tr><td>i16</td><td>Port</td></tr>
-/// <tr><td>i16</td><td>Address (sin_addr.s_addr)</td></tr>
-/// </table>
-void InetAddr::encode_internal(uint8_t **bufp) const {
-    *(*bufp)++ = sizeof(sockaddr_in);
-    *(*bufp)++ = sin_family;
-    serialization::encode_i16(bufp, sin_port);
-    serialization::encode_i32(bufp, sin_addr.s_addr);
-}
-
-void InetAddr::decode_internal(uint8_t version, const uint8_t **bufp,
-                               size_t *remainp) {
-    serialization::decode_i8(bufp, remainp);
-    sin_family = serialization::decode_i8(bufp, remainp);
-    sin_port = serialization::decode_i16(bufp, remainp);
-    sin_addr.s_addr = serialization::decode_i32(bufp, remainp);
-}
-
-std::ostream &operator<<(std::ostream &out, const Endpoint &e) {
-    out << e.host << ':' << e.port;
-    return out;
-}
-
-std::ostream &operator<<(std::ostream &out, const sockaddr_in &a) {
-    out << InetAddr::format(a);
-    return out;
-}
-
-} // namespace palo
diff --git a/be/src/rpc/inet_addr.h b/be/src/rpc/inet_addr.h
deleted file mode 100644
index c42d002a579133..00000000000000
--- a/be/src/rpc/inet_addr.h
+++ /dev/null
@@ -1,280 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_INET_ADDR_H
-#define BDG_PALO_BE_SRC_RPC_INET_ADDR_H
-
-#include "util.h"
-#include <cstring>
-
-extern "C" {
-#include <netinet/in.h>
-}
-
-namespace palo {
-/**
- * High-level entry point to a service; wraps a host:port pair.
- */
-struct Endpoint {
-    Endpoint(const std::string &host, uint16_t port)
-        : host(host), port(port) {
-        }
-    Endpoint()
-        : port(0) {
-        }
-    std::string host;
-    uint16_t port;
-};
-
-/** Stream operator to print an Endpoint structure */
-std::ostream &operator<<(std::ostream &, const Endpoint &);
-
-/**
- * Encapsulate an internet address.
- *
- * Note, deriving from sockaddr_in is just a path of least resistance
- * and should ,e changed to aggregation if we decide to support ipv6
- */
-class InetAddr : public sockaddr_in {
-public:
-
-    /** Constructor creates an empty internet address */
-    InetAddr();
-
-    /** Constructor creates an internet address from an endpoint; resolves
-     * the hostname to an IP address
-     *
-     * @param host The hostname
-     * @param port The port of the remote service
-     * @throws error::BAD_DOMAIN_NAME if the host cannot be resolved
-     */
-
-    InetAddr(const std::string &host, uint16_t port);
-    /** Constructor creates an internet address from an endpoint encoded
-     * as "hostname:port"
-     *
-     * @param endpoint The remote addres ("hostname:port")
-     * @throws error::BAD_DOMAIN_NAME if the host cannot be resolved
-     */
-
-    InetAddr(const std::string &endpoint);
-    /** Constructor creates an internet address from a 32bit IP address
-     *
-     * @param ip32 The 32bit IP address
-     * @param port The port of the remote service
-     * @throws error::BAD_DOMAIN_NAME if the host cannot be resolved
-     */
-
-    InetAddr(uint32_t ip32, uint16_t port);
-    /** Constructor creates an internet address from a unix sockaddr_in
-     * structure
-     *
-     * @param addr The unix sockaddr_in structure
-     * @throws error::BAD_DOMAIN_NAME if the host cannot be resolved
-     */
-    InetAddr(const sockaddr_in &addr) { operator=(addr); }
-
-    /** Assigns a unix sockaddr_in address structure to this object */
-    InetAddr &operator=(const sockaddr_in &addr) {
-        if (this != &addr) {
-            memcpy(this, &addr, sizeof(sockaddr_in));
-        }
-        return *this;
-    }
-
-    bool operator==(const InetAddr &other) const {
-        return (bool)!memcmp(this, &other, sizeof(InetAddr));
-    }
-
-    bool operator!=(const InetAddr &other) const {
-        return !(*this == other);
-    }
-
-    bool operator<(const InetAddr &other) const {
-        if (sin_family != other.sin_family) {
-            return sin_family < other.sin_family;
-        }
-        if (sin_addr.s_addr != other.sin_addr.s_addr) {
-            return sin_addr.s_addr < other.sin_addr.s_addr;
-        }
-        return sin_port < other.sin_port;
-    }
-
-    /** Returns a string with a dotted notation ("127.0.0.1:8080") including
-     * the port */
-    std::string format(int sep = ':') const { return InetAddr::format(*this, sep); }
-
-    /** Returns a string with a dotted notation ("127.0.0.1") without!
-     * the port */
-    std::string format_ipaddress() { return InetAddr::format_ipaddress(*this); }
-
-    /** Returns a compact std::string representation ("0x2387646:80") including
-     * the port */
-    std::string hex(int sep = ':') { return InetAddr::hex(*this, sep); }
-
-    // convenient/legacy static methods
-    /** Initialize a sockaddr_in structure from host:port
-     *
-     * @param addr The sockaddr_in structure (or a pointer to an InetAddr)
-     * @param host The hostname of the remote service
-     * @param port The port of the remote service
-     * @return true on success, otherwise false
-     */
-    static bool initialize(sockaddr_in *addr, const char *host, uint16_t port);
-
-    /** Initialize addr from an endpoint string (host:port)
-     *
-     * @param addr The sockaddr_in structure (or a pointer to an InetAddr)
-     * @param addr_str A string with the remote address
-     * @return true on success, otherwise false
-     */
-    static bool initialize(sockaddr_in *addr, const char *addr_str);
-
-    /** Initializes addr from an integer ip address and port
-     *
-     * @param addr The sockaddr_in structure (or a pointer to an InetAddr)
-     * @param haddr The remote host's address (IPv4)
-     * @param port The remote host's port
-     * @return true on success, otherwise false
-     */
-    static bool initialize(sockaddr_in *addr, uint32_t haddr, uint16_t port);
-
-    /**
-     * Parse an endpoint string in (host:port) format
-     *
-     * @param endpoint Hostname or hostname:port of the endpoint
-     * @param defport Default port if the hostname does not include a port
-     * @return Endpoint tuple
-     */
-    static Endpoint parse_endpoint(const char *endpoint, int defport = 0);
-
-    /**
-     * Parse an endpoint string in (host:port) format
-     *
-     * @param endpoint Hostname or hostname:port of the endpoint
-     * @param defport Default port if the hostname does not include a port
-     * @return Endpoint tuple
-     */
-    static Endpoint parse_endpoint(const std::string &endpoint, int defport = 0) {
-        return parse_endpoint(endpoint.c_str(), defport);
-    }
-
-    /** Parses an ipv4 address string in dotted notiation ("n.n.n.n") or as a
-     * number and initializes a sockaddr_in structure with the address
-     *
-     * @param ip The ipv4 string in dotted notiation or the number
-     * @param port The port of the address
-     * @param addr Returns the parsed address
-     * @param base Base of the integer representation (default: 0, handle 0x)
-     * @return true on success, otherwise false
-     */
-    static bool parse_ipv4(const char *ip, uint16_t port, sockaddr_in &addr,
-            int base = 0);
-
-    /** Tests whether the input string in n.n.n.n format (base 10)
-     *
-     * @param ip - ipv4 string
-     * @return true if it's an address in dotted notation, otherwise false
-     */
-    static bool is_ipv4(const char *ip);
-
-    /** Formats a socket address
-     *
-     * @param addr The address structure
-     * @param sep The separator character between hostname and port
-     * @return A string with the formatted "hostname:port" tuple
-     */
-    static std::string format(const sockaddr_in &addr, int sep = ':');
-
-    /** Formats a socket address without the port
-     *
-     * @param addr The address structure
-     * @return A string with the formatted "hostname:port" tuple
-     */
-    static std::string format_ipaddress(const sockaddr_in &addr);
-
-    /** Returns a compact std::string representation ("0x2387646:80") including
-     * the port
-     *
-     * @param addr The address structure
-     * @param sep The separator character between hostname and port
-     * @return A string with the formatted tuple
-     */
-    static std::string hex(const sockaddr_in &addr, int sep = ':');
-
-    /// Returns serialized object length.
-    /// Returns the serialized length of the object as encoded by encode().
-    /// @see encode() for encoding format
-    /// @return Overall serialized object length
-    size_t encoded_length() const;
-
-    /// Writes serialized representation of object to a buffer.
-    /// This function encodes a serialized representation of the object,
-    /// starting with a header that includes the encoding version and the
-    /// serialized length of the object.  After the header, the object per-se is
-    /// encoded with encode_internal().
-    /// @param bufp Address of destination buffer pointer (advanced by call)
-    void encode(uint8_t **bufp) const;
-
-    /// Reads serialized representation of object from a buffer.
-    /// @param bufp Address of destination buffer pointer (advanced by call)
-    /// @param remainp Address of integer holding amount of remaining buffer
-    /// @see encode() for encoding format
-    /// @throws Exception with code error::PROTOCOL_ERROR if version being
-    /// decoded is greater than that returned by encoding_version().
-    void decode(const uint8_t **bufp, size_t *remainp);
-
-    /// Deserializes object from legacy serialization format.
-    void legacy_decode(const uint8_t **bufp, size_t *remainp);
-
-private:
-
-    /// Returns encoding version.
-    /// @return Encoding version
-    uint8_t encoding_version() const;
-
-    /// Returns internal serialized length.
-    /// This function is to be overridden by derived classes and should return
-    /// the length of the the serialized object per-se.
-    /// @return Internal serialized length
-    /// @see encode_internal() for encoding format
-    size_t encoded_length_internal() const;
-
-    /// Writes serialized representation of object to a buffer.
-    /// This function is to be overridden by derived classes and should encode
-    /// the object per-se.
-    /// @param bufp Address of destination buffer pointer (advanced by call)
-    void encode_internal(uint8_t **bufp) const;
-
-    /// Reads serialized representation of object from a buffer.
-    /// This function is to be overridden by derived classes and should decode
-    /// the object per-se as encoded with encode_internal().
-    /// @param version Encoding version
-    /// @param bufp Address of destination buffer pointer (advanced by call)
-    /// @param remainp Address of integer holding amount of serialized encoding remaining
-    /// @see encode_internal() for encoding format
-    void decode_internal(uint8_t version, const uint8_t **bufp, size_t *remainp);
-};
-
-/** Helper operator for streaming a sockaddr_in structure (or an InetAddr
- * object) */
-std::ostream &operator<<(std::ostream &, const sockaddr_in &);
-
-} //namespace palo
-#endif //BDG_PALO_BE_SRC_RPC_INET_ADDR_H
diff --git a/be/src/rpc/io_handler.cpp b/be/src/rpc/io_handler.cpp
deleted file mode 100644
index c143d2118a034c..00000000000000
--- a/be/src/rpc/io_handler.cpp
+++ /dev/null
@@ -1,131 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "io_handler.h"
-#include "reactor.h"
-#include "reactor_runner.h"
-#include "common/logging.h"
-
-#include <cstdio>
-#include <iostream>
-
-extern "C" {
-#include <errno.h>
-}
-
-namespace palo {
-
-int IOHandler::start_epolling(int mode) {
-    struct epoll_event event;
-    memset(&event, 0, sizeof(struct epoll_event));
-    event.data.ptr = this;
-    if (mode & poll_event::READ) {
-        event.events |= EPOLLIN;
-    }
-    if (mode & poll_event::WRITE) {
-        event.events |= EPOLLOUT;
-    }
-    if (ReactorFactory::ms_epollet) {
-        event.events |= EPOLLRDHUP | EPOLLET;
-    }
-    m_epoll_interest = mode;
-    if (epoll_ctl(m_reactor->epoll_fd, EPOLL_CTL_ADD, m_sd, &event) < 0) {
-        LOG(ERROR) << "add events to epoll failed."
-                   << "[epollfd=" << m_reactor->epoll_fd << ", "
-                   << "socket=" << m_sd << ", "
-                   << "events=" << event.events
-                   << "error=" <<  strerror(errno);
-        return error::COMM_POLL_ERROR;
-    }
-    return error::OK;
-}
-
-int IOHandler::add_epoll_interest(int mode) {
-    m_epoll_interest |= mode;
-    if (!ReactorFactory::ms_epollet) {
-        struct epoll_event event;
-        memset(&event, 0, sizeof(struct epoll_event));
-        event.data.ptr = this;
-        if (m_epoll_interest & poll_event::READ)
-            event.events |= EPOLLIN;
-        if (m_epoll_interest & poll_event::WRITE)
-            event.events |= EPOLLOUT;
-        if (epoll_ctl(m_reactor->epoll_fd, EPOLL_CTL_MOD, m_sd, &event) < 0) {
-            LOG(ERROR) << "modify socket in epoll failed."
-                       << "[epoll_fd=" << m_reactor->epoll_fd << ","
-                       << "socket=" << m_sd << ", "
-                       << "mode=" << mode << ","
-                       << "m_epoll_interest" << m_epoll_interest << ","
-                       << "error=" << strerror(errno) << "]";
-            return error::COMM_POLL_ERROR;
-        }
-    }
-    return error::OK;
-}
-
-int IOHandler::remove_epoll_interest(int mode) {
-    m_epoll_interest &= ~mode;
-    if (!ReactorFactory::ms_epollet) {
-        struct epoll_event event;
-        memset(&event, 0, sizeof(struct epoll_event));
-        event.data.ptr = this;
-        if (m_epoll_interest & poll_event::READ)
-            event.events |= EPOLLIN;
-        if (m_epoll_interest & poll_event::WRITE)
-            event.events |= EPOLLOUT;
-        if (epoll_ctl(m_reactor->epoll_fd, EPOLL_CTL_MOD, m_sd, &event) < 0) {
-            LOG(ERROR) << "modify socket in epoll failed."
-                       << "[epoll_fd=" << m_reactor->epoll_fd << ","
-                       << "socket=" << m_sd << ", "
-                       << "error=" << strerror(errno) << "]";
-            return error::COMM_POLL_ERROR;
-        }
-    }
-    return error::OK;
-}
-
-void IOHandler::display_event(struct epoll_event *event) {
-    char buf[128];
-    buf[0] = 0;
-    if (event->events & EPOLLIN)
-        strcat(buf, "EPOLLIN ");
-    else if (event->events & EPOLLOUT)
-        strcat(buf, "EPOLLOUT ");
-    else if (event->events & EPOLLPRI)
-        strcat(buf, "EPOLLPRI ");
-    else if (event->events & EPOLLERR)
-        strcat(buf, "EPOLLERR ");
-    else if (event->events & EPOLLHUP)
-        strcat(buf, "EPOLLHUP ");
-    else if (ReactorFactory::ms_epollet && event->events & EPOLLRDHUP)
-        strcat(buf, "EPOLLRDHUP ");
-    else if (event->events & EPOLLET)
-        strcat(buf, "EPOLLET ");
-#if defined(EPOLLONESHOT)
-    else if (event->events & EPOLLONESHOT)
-        strcat(buf, "EPOLLONESHOT ");
-#endif
-    if (buf[0] == 0)
-        sprintf(buf, "0x%x ", event->events);
-    std::clog << "epoll events = " << buf << std::endl;
-    return;
-}
-
-} //namespace palo
diff --git a/be/src/rpc/io_handler.h b/be/src/rpc/io_handler.h
deleted file mode 100644
index b83b9a988333c0..00000000000000
--- a/be/src/rpc/io_handler.h
+++ /dev/null
@@ -1,416 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_IO_HANDLER_H
-#define BDG_PALO_BE_SRC_RPC_IO_HANDLER_H
-
-#include "clock.h"
-#include "dispatch_handler.h"
-#include "poll_event.h"
-#include "reactor_factory.h"
-#include "expire_timer.h"
-#include "common/logging.h"
-#include "util/debug_util.h"
-
-#include <mutex>
-
-extern "C" {
-#include <errno.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <poll.h>
-#include <sys/epoll.h>
-}
-
-namespace palo {
-
-/** Base class for socket descriptor I/O handlers.
- * When a socket is created, an I/O handler object is allocated to handle
- * events that occur on the socket.  Events are encapsulated in the Event
- * class and are delivered to the application through a DispatchHandler.  For
- * example, a TCP socket will have an associated IOHandlerData object that
- * reads messages off the socket and sends then to the application via the
- * installed DispatchHandler object.
- */
-class IOHandler {
-public:
-    /** Constructor.
-     * Initializes the I/O handler, assigns it a Reactor, and sets #m_local_addr
-     * to the locally bound address (IPv4:port) of <code>sd</code> (see
-     * <code>getsockname</code>).
-     * @param sd Socket descriptor
-     * @param dhp Dispatch handler
-     */
-    IOHandler(int sd, const DispatchHandlerPtr &dhp,
-            Reactor::Priority rp = Reactor::Priority::NORMAL)
-        : m_reference_count(0), m_free_flag(0), m_error(error::OK),
-        m_sd(sd), m_dispatch_handler(dhp), m_decomissioned(false) {
-            ReactorFactory::get_reactor(m_reactor, rp);
-            m_epoll_interest = 0;
-            socklen_t namelen = sizeof(m_local_addr);
-            getsockname(m_sd, (sockaddr *)&m_local_addr, &namelen);
-            memset(&m_alias, 0, sizeof(m_alias));
-        }
-
-    /// Constructor.
-    /// Initializes handler for raw I/O.  Assigns it a Reactor and
-    /// sets #m_local_addr to the locally bound address (IPv4:port) of
-    /// <code>sd</code>.
-    /// @param sd Socket descriptor
-    IOHandler(int sd) : m_reference_count(0), m_free_flag(0),
-    m_error(error::OK), m_sd(sd),
-    m_decomissioned(false) {
-        ReactorFactory::get_reactor(m_reactor);
-        m_epoll_interest = 0;
-        socklen_t namelen = sizeof(m_local_addr);
-        getsockname(m_sd, (sockaddr *)&m_local_addr, &namelen);
-        memset(&m_alias, 0, sizeof(m_alias));
-    }
-
-    /** Event handler method for Linux <i>epoll</i> interface.
-     * @param event Pointer to <code>epoll_event</code> structure describing event
-     * @param arrival_time Arrival time of event
-     * @return <i>true</i> if socket should be closed, <i>false</i> otherwise
-     */
-    virtual bool handle_event(struct epoll_event *event,
-            ClockT::time_point arrival_time) = 0;
-
-    /// Destructor.
-    /// If #m_socket_internally_created is set to <i>true</i>, closes the socket
-    /// descriptor #m_sd.
-    virtual ~IOHandler() {
-        assert(m_free_flag != 0xdeadbeef);
-        m_free_flag = 0xdeadbeef;
-        if (m_socket_internally_created) {
-            ::close(m_sd);
-        }
-        return;
-    }
-
-    /** Convenience method for delivering event to application.
-     * This method will deliver <code>event</code> to the application via the
-     * event handler <code>dh</code> if supplied, otherwise the event will be
-     * delivered via the default event handler, or no default event handler
-     * exists, it will just log the event.  This method is (and should always)
-     * by called from a reactor thread.
-     * @param event pointer to Event (deleted by this method)
-     * @param dh Event handler via which to deliver event
-     */
-    void deliver_event(EventPtr &event, DispatchHandler *dh = 0) {
-        memcpy(&event->local_addr, &m_local_addr, sizeof(m_local_addr));
-        if (dh) {
-            dh->handle(event);
-        } else {
-            if (!m_dispatch_handler) {
-                LOG(INFO) << "event: " << event->to_str();
-            } else {
-                m_dispatch_handler->handle(event);
-            }
-        }
-    }
-
-    /** Start polling on the handler with the poll interest specified in
-     * <code>mode</code>.
-     * This method registers the poll interest, specified in <code>mode</code>,
-     * with the polling interface and sets #m_epoll_interest to
-     * <code>mode</code>.  If an error is encountered, #m_error is
-     * set to the approprate error code.
-     * @return error::OK on success, or one of error::COMM_POLL_ERROR,
-     * error::COMM_SEND_ERROR, or error::COMM_RECEIVE_ERROR on error
-     */
-    int start_epolling(int mode = poll_event::READ);
-
-    /** Adds the poll interest specified in <code>mode</code> to the polling
-     * interface for this handler.
-     * This method adds the poll interest, specified in <code>mode</code>,
-     * to the polling interface for this handler and merges <code>mode</code>
-     * into #m_epoll_interest using bitwise OR (|).  If an error is encountered,
-     * #m_error is set to the approprate error code.
-     * @return error::OK on success, or one of error::COMM_POLL_ERROR,
-     * error::COMM_SEND_ERROR, or error::COMM_RECEIVE_ERROR on error
-     */
-    int add_epoll_interest(int mode);
-
-    /** Removes the poll interest specified in <code>mode</code> to the polling
-     * interface for this handler.
-     * This method removes the poll interest, specified in <code>mode</code>,
-     * from the polling interface for this handler and strips <code>mode</code>
-     * from #m_epoll_interest using boolean operations.  If an error is
-     * encountered, #m_error is set to the approprate error code.
-     * @return error::OK on success, or one of error::COMM_POLL_ERROR,
-     * error::COMM_SEND_ERROR, or error::COMM_RECEIVE_ERROR on error
-     */
-    int remove_epoll_interest(int mode);
-
-    /** Resets poll interest by adding #m_epoll_interest to the polling interface
-     * for this handler.  If an error is encountered, #m_error is set to the
-     * approprate error code.
-     * @return error::OK on success, or one of error::COMM_POLL_ERROR,
-     * error::COMM_SEND_ERROR, or error::COMM_RECEIVE_ERROR on error
-     */
-    int reset_poll_interest() {
-        return add_epoll_interest(m_epoll_interest);
-    }
-
-    /** Gets the handler socket address.  The socket address is the
-     * address of the remote end of the connection for data (TCP) handlers,
-     * and the local socket address for datagram and accept handlers.
-     * @return Handler socket address
-     */
-    InetAddr get_address() { return m_addr; }
-
-    /** Get local socket address for connection.
-     * @return Local socket address for connection.
-     */
-    InetAddr get_local_address() { return m_local_addr; }
-
-    /** Sets the proxy name for this connection.
-     * @param proxy Proxy name to set for this connection.
-     */
-    void set_proxy(const std::string &proxy) {
-        /*
-        std::lock_guard<std::mutex> lock(m_mutex);
-        m_proxy = proxy;
-        */
-    }
-
-    /** Gets the proxy name for this connection.
-     * @return Proxy name for this connection.
-     */
-    const std::string get_proxy() {
-        return std::string("");
-        /*
-        std::lock_guard<std::mutex> lock(m_mutex);
-        return m_proxy;
-        */
-    }
-
-    /** Gets the socket descriptor for this connection.
-     * @return Socket descriptor for this connection.
-     */
-    int get_sd() { return m_sd; }
-
-    /** Get the reactor that this handler is assigned to.
-     * @param reactor Reference to returned reactor pointer
-     */
-    void get_reactor(ReactorPtr &reactor) { reactor = m_reactor; }
-
-    /** Display polling event from <code>epoll()</code> interface to
-     * <i>stderr</i>.
-     * @param event Pointer to <code>epoll_event</code> structure describing
-     * <code>epoll()</code> event.
-     */
-    void display_event(struct epoll_event *event);
-
-    friend class HandlerMap;
-
-protected:
-
-    /** Sets #m_error to <code>error</code> if it has not already been set.
-     * This method checks to see if #m_error is set to error::OK and if so, it
-     * sets #m_error to <code>error</code> and returns <i>true</i>.  Otherwise
-     * it does nothing and returns false.
-     * @return <i>true</i> if #m_error was set to <code>error</code>,
-     * <i>false</i> otherwise.
-     */
-    bool test_and_set_error(int32_t error) {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        if (m_error == error::OK) {
-            m_error = error;
-            return true;
-        }
-        return false;
-    }
-
-    /** Returns first error code encountered by handler.
-     * When an error is encountered during handler methods, the first error code
-     * that is encountered is recorded in #m_error.  This method returns that
-     * error or error::OK if no error has been encountered.
-     * @return First error code encountered by this handler, or error::OK if
-     * no error has been encountered
-     */
-    int32_t get_error() {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        return m_error;
-    }
-
-    /** Get alias address for this connection.
-     * @return Alias address for this connection.
-     */
-    InetAddr get_alias() {
-        return m_alias;
-    }
-
-    /** Set alias address for this connection.
-     * @param alias Reference to return alias address.
-     */
-    void set_alias(const InetAddr &alias) {
-        m_alias = alias;
-    }
-
-    /** Increment reference count.
-     * @note This method assumes the caller is serializing access to this and
-     * related methods with a mutex lock.
-     * @see #decrement_reference_count, #reference_count, and #decomission
-     */
-    void increment_reference_count() {
-        m_reference_count++;
-    }
-
-    /** Decrement reference count.
-     * If reference count drops to 0 and the handler is decomissioned
-     * then it is scheduled for removal with a call to
-     * <code>m_reactor->schedule_removal(this)</code>.
-     * @note This method assumes the caller is serializing access to this and
-     * related methods with a mutex lock.
-     * @see #increment_reference_count, #reference_count, and #decomission
-     */
-    void decrement_reference_count() {
-        assert(m_reference_count > 0);
-        m_reference_count--;
-        if (m_reference_count == 0 && m_decomissioned) {
-            m_reactor->schedule_removal(this);
-        }
-    }
-
-    /** Return reference count
-     * @note This method assumes the caller is serializing access to this and
-     * related methods with a mutex lock.
-     * @see #increment_reference_count, #decrement_reference_count, and
-     * #decomission
-     */
-    size_t reference_count() {
-        return m_reference_count;
-    }
-
-    /** Decomission handler.
-     * This method decomissions the handler by setting the #m_decomissioned
-     * flag to <i>true</i>.  If the reference count is 0, the handler is
-     * also scheduled for removal with a call to
-     * <code>m_reactor->schedule_removal(this)</code>.
-     * @note This method assumes the caller is serializing access to this and
-     * related methods with a mutex lock.
-     * @see #increment_reference_count, #decrement_reference_count,
-     * #reference_count, and #is_decomissioned
-     */
-    void decomission() {
-        if (!m_decomissioned) {
-            m_decomissioned = true;
-            if (m_reference_count == 0) {
-                m_reactor->schedule_removal(this);
-            }
-        }
-    }
-
-    /** Checks to see if handler is decomissioned.
-     * @return <i>true</i> if it is decomissioned, <i>false</i> otherwise.
-     */
-    bool is_decomissioned() {
-        return m_decomissioned;
-    }
-
-    /** Disconnect connection.
-    */
-    virtual void disconnect() { }
-
-    /** Return <code>poll()</code> interface events corresponding to the
-     * normalized polling interest in <code>mode</code>.  <code>mode</code>
-     * is some bitwise combination of the flags poll_event::READ and
-     * poll_event::WRITE.
-     * @return <code>poll()</code> events correspond to polling interest
-     * specified in <code>mode</code>.
-     */
-    short poll_events(int mode) {
-        short events = 0;
-        if (mode & poll_event::READ) {
-            events |= POLLIN;
-        }
-        if (mode & poll_event::WRITE) {
-            events |= POLLOUT;
-        }
-        return events;
-    }
-
-    /** Stops polling by removing socket from polling interface.
-     * Clears #m_epoll_interest.
-     */
-    void stop_polling() {
-        struct epoll_event event;  // this is necessary for < Linux 2.6.9
-        if (epoll_ctl(m_reactor->epoll_fd, EPOLL_CTL_DEL, m_sd, &event) < 0) {
-            LOG(ERROR) << "delete socket from epoll failed." 
-                << "[epoll_fd=" << m_reactor->epoll_fd << ","
-                << "socket=" << m_sd << ", "
-                << "error=" << strerror(errno) << "]";
-            exit(EXIT_FAILURE);
-        }
-        m_epoll_interest = 0;
-    }
-
-    /// %Mutex for serializing concurrent access
-    std::mutex m_mutex;
-
-    /** Reference count.  Calls to methods that reference this member
-     * must be mutex protected by caller.
-     */
-    size_t m_reference_count;
-
-    /// Free flag (for testing)
-    uint32_t m_free_flag;
-
-    /// Error code
-    int32_t m_error;
-
-    /// Proxy name for this connection
-    std::string m_proxy;
-
-    /// Handler socket address
-    InetAddr m_addr;
-
-    /// Local address of connection
-    InetAddr m_local_addr;
-
-    /// Address alias for connection
-    InetAddr m_alias;
-
-    /// Socket descriptor
-    int m_sd;
-
-    /// Default dispatch hander for connection
-    DispatchHandlerPtr m_dispatch_handler;
-
-    /// Reactor to which this handler is assigned
-    ReactorPtr m_reactor;
-
-    /** Current polling interest.  The polling interest is some bitwise
-     * combination of the flags poll_event::READ and
-     * poll_event::WRITE.
-     */
-    int m_epoll_interest;
-
-    /** Decomissioned flag.  Calls to methods that reference this member
-     * must be mutex protected by caller.
-     */
-    bool m_decomissioned;
-
-    /// Socket was internally created and should be closed on destroy.
-    bool m_socket_internally_created {true};
-};
-
-} //namespace palo
-#endif //BDG_PALO_BE_SRC_RPC_IO_HANDLER_H
diff --git a/be/src/rpc/io_handler_accept.cpp b/be/src/rpc/io_handler_accept.cpp
deleted file mode 100644
index 3c094495cc6d3a..00000000000000
--- a/be/src/rpc/io_handler_accept.cpp
+++ /dev/null
@@ -1,115 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "handler_map.h"
-#include "io_handler_accept.h"
-#include "io_handler_data.h"
-#include "reactor_factory.h"
-#include "reactor_runner.h"
-#include "error.h"
-#include "file_utils.h"
-#include "common/logging.h"
-
-#include <iostream>
-
-extern "C" {
-#include <errno.h>
-#include <netinet/tcp.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <fcntl.h>
-
-}
-namespace palo {
-
-bool IOHandlerAccept::handle_event(struct epoll_event *event,
-                                   ClockT::time_point) {
-    //DisplayEvent(event);
-    return handle_incoming_connection();
-}
-
-bool IOHandlerAccept::handle_incoming_connection() {
-    int sd = -1;
-    struct sockaddr_in addr;
-    socklen_t addr_len = sizeof(sockaddr_in);
-    int one = 1;
-    IOHandlerData *handler = 0;
-    while (true) {
-        if ((sd = accept(m_sd, (struct sockaddr *)&addr, &addr_len)) < 0) {
-            if (errno == EAGAIN) {
-                break;
-            }
-            LOG(ERROR) << "accept connection from client failed."
-                       << "[error=" << strerror(errno) << "]";
-            break;
-        }
-        VLOG(3) << "accepted incoming connection."
-                << "[socket=" << m_sd << ", "
-                << "client_addr=" << inet_ntoa(addr.sin_addr)
-                << "client_port=" <<  ntohs(addr.sin_port) << "]";
-        // Set to non-blocking
-        FileUtils::set_flags(sd, O_NONBLOCK);
-        if (setsockopt(sd, SOL_TCP, TCP_NODELAY, &one, sizeof(one)) < 0) {
-            LOG(ERROR) << "set socket TCP_NODELAY option failed."
-                       << "[socket=" << sd << ", error=" << strerror(errno) << "]";
-        }
-        if (setsockopt(m_sd, SOL_SOCKET, SO_KEEPALIVE, &one, sizeof(one)) < 0) {
-            LOG(ERROR) << "set socket SO_KEEPALIVE option failed."
-                       << "[socket=" << sd << ", [error=" << strerror(errno) << "]";
-        }
-        int bufsize = 4*32768;
-        if (setsockopt(sd, SOL_SOCKET, SO_SNDBUF, (char *)&bufsize, sizeof(bufsize)) < 0) {
-            LOG(ERROR) << "set socket SO_SNDBUF option failed. [error=" << strerror(errno) << "]";
-        }
-        if (setsockopt(sd, SOL_SOCKET, SO_RCVBUF, (char *)&bufsize, sizeof(bufsize)) < 0) {
-            LOG(ERROR) << "set sockopt SO_RCVBUF option failed. [error=" << strerror(errno) << "]";
-        }
-        DispatchHandlerPtr dhp;
-        m_handler_factory->get_instance(dhp);
-        handler = new IOHandlerData(sd, addr, dhp, true);
-        m_handler_map->insert_handler(handler, true);
-        int32_t error;
-        if ((error = handler->start_epolling(poll_event::READ |
-                                             poll_event::WRITE)) != error::OK) {
-            LOG(ERROR) << "Problem starting polling on incoming connection - %s"
-                       << error::get_text(error);
-            ReactorRunner::handler_map->decrement_reference_count(handler);
-            ReactorRunner::handler_map->decomission_handler(handler);
-            return false;
-        }
-        if (ReactorFactory::proxy_master) {
-            if ((error = ReactorRunner::handler_map->propagate_proxy_map(handler))
-                    != error::OK) {
-                LOG(ERROR) << "Problem sending proxy map to %s - %s"
-                           << m_addr.format().c_str() << error::get_text(error);
-                ReactorRunner::handler_map->decrement_reference_count(handler);
-                return false;
-            }
-        }
-        ReactorRunner::handler_map->decrement_reference_count(handler);
-        EventPtr event = std::make_shared<Event>(Event::CONNECTION_ESTABLISHED, addr, error::OK);
-        deliver_event(event);
-    }
-    return false;
-}
-
-} //namespace palo
diff --git a/be/src/rpc/io_handler_accept.h b/be/src/rpc/io_handler_accept.h
deleted file mode 100644
index 7b3f72a612075e..00000000000000
--- a/be/src/rpc/io_handler_accept.h
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_IO_HANDLER_ACCEPT_H
-#define BDG_PALO_BE_SRC_RPC_IO_HANDLER_ACCEPT_H
-
-#include "handler_map.h"
-#include "io_handler.h"
-#include "connection_handler_factory.h"
-
-namespace palo {
-
-/** I/O handler for accept (listen) sockets.
- */
-class IOHandlerAccept : public IOHandler {
-public:
-
-    /** Constructor.  Initializes member variables and sets #m_local_addr
-     * to the address of <code>sd</code> obtained via <code>getsockname</code>.
-     * @param sd Socket descriptor on which <code>listen</code> has been called
-     * @param dhp Reference to default dispatch handler
-     * @param hmap Reference to Handler map
-     * @param chfp Reference to connection handler factory
-     */
-    IOHandlerAccept(int sd, const DispatchHandlerPtr &dhp,
-            HandlerMapPtr &hmap, ConnectionHandlerFactoryPtr &chfp)
-        : IOHandler(sd, dhp), m_handler_map(hmap), m_handler_factory(chfp) {
-            memcpy(&m_addr, &m_local_addr, sizeof(InetAddr));
-        }
-
-    /** Destructor */
-    virtual ~IOHandlerAccept() { }
-
-    /** Handle <code>epoll()</code> interface events.  This method handles
-     * all events by calling #handle_incoming_connection.
-     * @param event Pointer to <code>epoll_event</code> structure describing
-     * event
-     * @param arrival_time Time of event arrival (not used)
-     * @return <i>false</i> on success, <i>true</i> if error encountered and
-     * handler was decomissioned
-     */
-    bool handle_event(struct epoll_event *event,
-            ClockT::time_point arrival_time) override;
-
-private:
-
-    /** Handles incoming connection requests.  This method is called in response
-     * to events that signal incoming connection requests.  It performs the
-     * following actions in a loop:
-     *   - Calls <code>accept</code> (returns on <code>EAGAIN</code>)
-     *   - On the socket returned by <code>accept</code>
-     *     - Sets <code>O_NONBLOCK</code> option
-     *     - Sets <code>TCP_NODELAY</code> option (Linux and Sun)
-     *     - Sets <code>SO_NOSIGPIPE</code> option (Apple and FreeBSD)
-     *     - Sets socket send and receive buffers to <code>4*32768</code>
-     *   - Creates a default dispatch handler using #m_handler_factory
-     *   - Creates an IOHandlerData object with socket returned by
-     *     <code>accept</code> and default dispatch handler
-     *   - Inserts newly created handler in #m_handler_map
-     *   - If <i>proxy master</i>, propagate proxy map over newly established
-     *     connection.
-     *   - Starts polling on newly created handler with poll_event::READ and
-     *     poll_event::WRITE interest
-     *   - Delivers Event::CONNECTION_ESTABLISHED event
-     */
-    bool handle_incoming_connection();
-
-    /// Handler map
-    HandlerMapPtr m_handler_map;
-
-    /** Connection handler factory for creating default dispatch handlers
-     * for incoming connections.
-     */
-    ConnectionHandlerFactoryPtr m_handler_factory;
-};
-
-} //namespace palo
-#endif //BDG_PALO_BE_SRC_RPC_IO_HANDLER_ACCEPT_H
diff --git a/be/src/rpc/io_handler_data.cpp b/be/src/rpc/io_handler_data.cpp
deleted file mode 100644
index bfedb26e6b6f33..00000000000000
--- a/be/src/rpc/io_handler_data.cpp
+++ /dev/null
@@ -1,474 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "io_handler_data.h"
-#include "reactor_runner.h"
-#include "error.h"
-#include "file_utils.h"
-#include "inet_addr.h"
-
-#include <cassert>
-#include <chrono>
-#include <iostream>
-
-extern "C" {
-#include <arpa/inet.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <sys/uio.h>
-}
-
-namespace palo {
-
-ssize_t
-IOHandlerData::et_socket_read(int fd, void *vptr, size_t n, int *errnop, bool *eofp) {
-    size_t nleft = n;
-    ssize_t nread = 0;
-    char *ptr = (char *)vptr;
-    while (nleft > 0) {
-        if ((nread = ::read(fd, ptr, nleft)) < 0) {
-            if (errno == EINTR) {
-                nread = 0; /* and call read() again */
-                continue;
-            }
-            *errnop = errno;
-            if (*errnop == EAGAIN || nleft < n) {
-                break;     /* already read something, most likely EAGAIN */
-            }
-            return -1;   /* other errors and nothing read */
-        }
-        else if (nread == 0) {
-            *eofp = true;
-            break;
-        }
-        nleft -= nread;
-        ptr   += nread;
-    }
-    return n - nleft;
-}
-
-ssize_t
-IOHandlerData::et_socket_writev(int fd, const iovec *vector, int count, int *errnop) {
-    ssize_t nwritten = 0;
-    while ((nwritten = writev(fd, vector, count)) <= 0) {
-        if (errno == EINTR) {
-            nwritten = 0; /* and call write() again */
-            continue;
-        }
-        *errnop = errno;
-        return -1;
-    }
-    return nwritten;
-}
-
-bool
-IOHandlerData::handle_event(struct epoll_event *event,
-                            ClockT::time_point arrival_time) {
-    int error = 0;
-    bool eof = false;
-    try {
-        if (event->events & EPOLLOUT) {
-            if (handle_write_readiness()) {
-                handle_disconnect();
-                return true;
-            }
-        }
-        if (event->events & EPOLLIN) {
-            size_t nread = 0;
-            while (true) {
-                if (!m_got_header) {
-                    nread = et_socket_read(m_sd, m_message_header_ptr,
-                                           m_message_header_remaining, &error, &eof);
-                    if (nread == (size_t)-1) {
-                        if (errno != ECONNREFUSED) {
-                            LOG(ERROR) << "read data from socket failed."
-                                << "[socket=" << m_sd << ", "
-                                << "remaining_message=" << (int)m_message_header_remaining << ", "
-                                << "error=" << strerror(errno) << "]";
-                        }
-                        else {
-                            test_and_set_error(error::COMM_CONNECT_ERROR);
-                        }
-                        handle_disconnect();
-                        return true;
-                    }
-                    else if (nread < m_message_header_remaining) {
-                        m_message_header_remaining -= nread;
-                        m_message_header_ptr += nread;
-                        if (error == EAGAIN) {
-                            break;
-                        }
-                        error = 0;
-                    }
-                    else {
-                        m_message_header_ptr += nread;
-                        handle_message_header(arrival_time);
-                    }
-                    if (eof) {
-                        break;
-                    }
-                }
-                else { // got header
-                    nread = et_socket_read(m_sd, m_message_ptr, m_message_remaining,
-                                           &error, &eof);
-                    if (nread == (size_t)-1) {
-                        LOG(ERROR) << "read data from socket failed."
-                                   << "[socket=" << m_sd << ", "
-                                   << "remaining_message=" << (int)m_message_header_remaining
-                                   << "error=" << strerror(errno) << "]";
-                        handle_disconnect();
-                        return true;
-                    }
-                    else if (nread < m_message_remaining) {
-                        m_message_ptr += nread;
-                        m_message_remaining -= nread;
-                        if (error == EAGAIN) {
-                            break;
-                        }
-                        error = 0;
-                    }
-                    else {
-                        handle_message_body();
-                    }
-                    if (eof) {
-                        break;
-                    }
-                }
-            }
-        }
-        if (ReactorFactory::ms_epollet) {
-            if (event->events & EPOLLRDHUP) {
-                LOG(ERROR) << "received EPOLLRDHUP on socket."
-                           << "[socket=" << m_sd << ", "
-                           << "addr=" << inet_ntoa(m_addr.sin_addr) << ", "
-                           << "port=" << ntohs(m_addr.sin_port) << "]";
-                handle_disconnect();
-                return true;
-            }
-        }
-        else {
-            if (eof) {
-                LOG(ERROR) << "received EOF on socket."
-                           << "[socket=" << m_sd << ", "
-                           << "addr=" << inet_ntoa(m_addr.sin_addr) << ", "
-                           << "port=" << ntohs(m_addr.sin_port) << "]";
-                handle_disconnect();
-                return true;
-            }
-        }
-        if (event->events & EPOLLERR) {
-            LOG(ERROR) << "received EPOLLERR on socket."
-                       << "[socket=" << m_sd << ", "
-                       << "addr=" << inet_ntoa(m_addr.sin_addr) << ", "
-                       << "port=" << ntohs(m_addr.sin_port) << "]";
-            handle_disconnect();
-            return true;
-        }
-        if (event->events & EPOLLHUP) {
-            LOG(ERROR) << "received EPOLLHUP on socket."
-                       << "[socket=" << m_sd << ", "
-                       << "addr=" << inet_ntoa(m_addr.sin_addr) << ", "
-                       << "port=" << ntohs(m_addr.sin_port) << "]";
-            handle_disconnect();
-            return true;
-        }
-    }
-    catch (palo::Exception &e) {
-        LOG(ERROR)  << e ;
-        handle_disconnect();
-        return true;
-    }
-    return false;
-}
-
-void IOHandlerData::handle_message_header(ClockT::time_point arrival_time) {
-    size_t header_len = (size_t)m_message_header[1];
-    // check to see if there is any variable length header
-    // after the fixed length portion that needs to be read
-    if (header_len > (size_t)(m_message_header_ptr - m_message_header)) {
-        m_message_header_remaining = header_len - (size_t)(m_message_header_ptr
-                                     - m_message_header);
-        return;
-    }
-    m_event = std::make_shared<Event>(Event::MESSAGE, m_addr);
-    m_event->load_message_header(m_message_header, header_len);
-    m_event->arrival_time = arrival_time;
-    m_message_aligned = false;
-    if (m_event->header.alignment > 0) {
-        void *vptr = 0;
-        posix_memalign(&vptr, m_event->header.alignment,
-                       m_event->header.total_len - header_len);
-        m_message = (uint8_t *)vptr;
-        m_message_aligned = true;
-    } else {
-        m_message = new uint8_t[m_event->header.total_len - header_len];
-    }
-    m_message_ptr = m_message;
-    m_message_remaining = m_event->header.total_len - header_len;
-    m_message_header_remaining = 0;
-    m_got_header = true;
-}
-
-void IOHandlerData::handle_message_body() {
-    DispatchHandlerPtr dhp;
-    if (m_event->header.flags & CommHeader::FLAGS_BIT_PROXY_MAP_UPDATE) {
-        ReactorRunner::handler_map->update_proxy_map((const char *)m_message,
-                m_event->header.total_len - m_event->header.header_len);
-        free_message_buffer();
-        m_event.reset();
-    }
-    else if ((m_event->header.flags & CommHeader::FLAGS_BIT_REQUEST) == 0 &&
-             (m_event->header.id == 0
-              || !m_reactor->remove_request(m_event->header.id, dhp))) {
-        if ((m_event->header.flags & CommHeader::FLAGS_BIT_IGNORE_RESPONSE) == 0) {
-            LOG(WARNING) << "received response for non-pending event."
-                         << "[request_id=" << m_event->header.id << ", "
-                         << "header_version=" << m_event->header.version << ", "
-                         << "total_len=" << m_event->header.total_len << "]";
-        }
-        free_message_buffer();
-        m_event.reset();
-    }
-    else {
-        m_event->payload = m_message;
-        m_event->payload_len = m_event->header.total_len
-                               - m_event->header.header_len;
-        m_event->payload_aligned = m_message_aligned;
-        {
-            std::lock_guard<std::mutex> lock(m_mutex);
-            m_event->set_proxy(m_proxy);
-        }
-        deliver_event(m_event, dhp.get());
-    }
-    reset_incoming_message_state();
-}
-
-void IOHandlerData::handle_disconnect() {
-    ReactorRunner::handler_map->decomission_handler(this);
-}
-
-bool IOHandlerData::handle_write_readiness() {
-    bool deliver_conn_estab_event = false;
-    bool rval = true;
-    int error = error::OK;
-    while (true) {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        if (m_connected == false) {
-            socklen_t name_len = sizeof(m_local_addr);
-            int sockerr = 0;
-            socklen_t sockerr_len = sizeof(sockerr);
-            if (getsockopt(m_sd, SOL_SOCKET, SO_ERROR, &sockerr, &sockerr_len) < 0) {
-                LOG(ERROR) << "get SO_ERROR socket option failed."
-                           << "[error=" << strerror(errno) << "]";
-            }
-            if (sockerr) {
-                LOG(ERROR) << "connect completion error."
-                           << "[error=" << strerror(sockerr) << "]";
-                break;
-            }
-            int bufsize = 4*32768;
-            if (setsockopt(m_sd, SOL_SOCKET, SO_SNDBUF, (char *)&bufsize,
-                           sizeof(bufsize)) < 0) {
-                LOG(ERROR) << "set SO_SNDBUF socket failed."
-                           << "[error=" << strerror(errno) << "]";
-            }
-            if (setsockopt(m_sd, SOL_SOCKET, SO_RCVBUF, (char *)&bufsize,
-                           sizeof(bufsize)) < 0) {
-                LOG(ERROR) << "set SO_RCVBUF socket option failed."
-                           << "[error=" << strerror(errno) << "]";
-            }
-            int one = 1;
-            if (setsockopt(m_sd, SOL_SOCKET, SO_KEEPALIVE, &one, sizeof(one)) < 0) {
-                LOG(ERROR) << "set SO_KEEPALIVE socket option failed."
-                           << "[error=" << strerror(errno) << "]";
-            }
-            if (getsockname(m_sd, (struct sockaddr *)&m_local_addr, &name_len) < 0) {
-                LOG(ERROR) << "get socket name failed."
-                           << "[socket=" << m_sd << ", "
-                           << "error=" << strerror(errno) << "]";
-                break;
-            }
-            //LOG(INFO) << "Connection established.";
-            m_connected = true;
-            deliver_conn_estab_event = true;
-        }
-        //LOG(INFO) << "about to flush send queue";
-        if ((error = flush_send_queue()) != error::OK) {
-            LOG(ERROR) << "flush send queue failed.";
-            if (m_error == error::OK)
-                m_error = error;
-            return true;
-        }
-        //LOG(INFO) << "about to remove poll interest";
-        if (m_send_queue.empty()) {
-            if ((error = remove_epoll_interest(poll_event::WRITE)) != error::OK) {
-                if (m_error == error::OK)
-                    m_error = error;
-                return true;
-            }
-        }
-        rval = false;
-        break;
-    }
-    if (deliver_conn_estab_event) {
-        if (ReactorFactory::proxy_master) {
-            if ((error = ReactorRunner::handler_map->propagate_proxy_map(this))
-                    != error::OK) {
-                LOG(ERROR) << "Problem sending proxy map to %s - %s"
-                           << m_addr.format().c_str() << error::get_text(error);
-                return true;
-            }
-        }
-        EventPtr event = std::make_shared<Event>(Event::CONNECTION_ESTABLISHED, m_addr,
-                         m_proxy, error::OK);
-        deliver_event(event);
-    }
-    return rval;
-}
-
-int
-IOHandlerData::send_message(CommBufPtr &cbp, uint32_t timeout_ms,
-                            DispatchHandler *disp_handler) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    bool initially_empty = m_send_queue.empty() ? true : false;
-    int error = error::OK;
-    if (m_decomissioned)
-        return error::COMM_NOT_CONNECTED;
-    // If request, Add message ID to request cache
-    if (cbp->header.id != 0 && disp_handler != 0
-            && cbp->header.flags & CommHeader::FLAGS_BIT_REQUEST) {
-        auto expire_time = ClockT::now() + std::chrono::milliseconds(timeout_ms);
-        m_reactor->add_request(cbp->header.id, this, disp_handler, expire_time);
-    }
-    //LOG(INFO) << "About to send message of size %d", cbp->header.total_len;
-    m_send_queue.push_back(cbp);
-    if (m_connected) {
-        if ((error = flush_send_queue()) != error::OK) {
-            LOG(ERROR) << "flush send queue failed."
-                       << "[error=" << error::get_text(error) << "]";
-            ReactorRunner::handler_map->decomission_handler(this);
-            if (m_error == error::OK) {
-                m_error = error;
-            }
-            return error;
-        }
-    }
-    if (initially_empty && !m_send_queue.empty()) {
-        error = add_epoll_interest(poll_event::WRITE);
-        if (error) {
-            LOG(ERROR) << "add write interest failed. [error=" << (unsigned)error << "]";
-        }
-    }
-    else if (!initially_empty && m_send_queue.empty()) {
-        error = remove_epoll_interest(poll_event::WRITE);
-        if (error) {
-            LOG(ERROR) << "remove write interest failed. [error=" << (unsigned)error << "]";
-        }
-    }
-    // Set m_error if not already set
-    if (error != error::OK && m_error == error::OK) {
-        m_error = error;
-    }
-    return error;
-}
-
-int IOHandlerData::flush_send_queue() {
-    ssize_t nwritten = 0;
-    ssize_t towrite = 0;
-    ssize_t remaining = 0;
-    struct iovec vec[2];
-    int count = 0;
-    int error = 0;
-    while (!m_send_queue.empty()) {
-        CommBufPtr &cbp = m_send_queue.front();
-        count = 0;
-        towrite = 0;
-        remaining = cbp->data.size - (cbp->data_ptr - cbp->data.base);
-        if (remaining > 0) {
-            vec[0].iov_base = (void *)cbp->data_ptr;
-            vec[0].iov_len = remaining;
-            towrite = remaining;
-            ++count;
-        }
-        if (cbp->ext.base != 0) {
-            remaining = cbp->ext.size - (cbp->ext_ptr - cbp->ext.base);
-            if (remaining > 0) {
-                vec[count].iov_base = (void *)cbp->ext_ptr;
-                vec[count].iov_len = remaining;
-                towrite += remaining;
-                ++count;
-            }
-        }
-        nwritten = et_socket_writev(m_sd, vec, count, &error);
-        if (nwritten == (ssize_t)-1) {
-            if (error == EAGAIN)
-                return error::OK;
-            LOG(ERROR) << "write socket failed."
-                       << "[socket=" << m_sd << ", "
-                       << "towrite=" << (int)towrite << ", "
-                       << "error=" << strerror(errno) << "]";
-            return error::COMM_BROKEN_CONNECTION;
-        }
-        else if (nwritten < towrite) {
-            if (nwritten == 0) {
-                if (error == EAGAIN)
-                    break;
-                if (error) {
-                    LOG(ERROR) << "write socket failed."
-                               << "[socket=" << m_sd << ", "
-                               << "towrite=" << (int)towrite << ", "
-                               << "error=" << strerror(errno) << "]";
-                    return error::COMM_BROKEN_CONNECTION;
-                }
-                continue;
-            }
-            remaining = cbp->data.size - (cbp->data_ptr - cbp->data.base);
-            if (remaining > 0) {
-                if (nwritten < remaining) {
-                    cbp->data_ptr += nwritten;
-                    if (error == EAGAIN) {
-                        break;
-                    }
-                    error = 0;
-                    continue;
-                }
-                else {
-                    nwritten -= remaining;
-                    cbp->data_ptr += remaining;
-                }
-            }
-            if (cbp->ext.base != 0) {
-                cbp->ext_ptr += nwritten;
-                if (error == EAGAIN) {
-                    break;
-                }
-                error = 0;
-                continue;
-            }
-        }
-        // buffer written successfully, now remove from queue (destroys buffer)
-        m_send_queue.pop_front();
-    }
-    return error::OK;
-}
-
-} //namespace palo
diff --git a/be/src/rpc/io_handler_data.h b/be/src/rpc/io_handler_data.h
deleted file mode 100644
index 7a8164b5a2be24..00000000000000
--- a/be/src/rpc/io_handler_data.h
+++ /dev/null
@@ -1,249 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_IO_HANDLER_DATA_H
-#define BDG_PALO_BE_SRC_RPC_IO_HANDLER_DATA_H
-
-#include "comm_buf.h"
-#include "io_handler.h"
-#include "error.h"
-
-#include <list>
-
-extern "C" {
-#include <netdb.h>
-#include <string.h>
-}
-
-namespace palo {
-
-/** I/O handler for TCP sockets.
- */
-class IOHandlerData : public IOHandler {
-public:
-
-    /** Constructor.
-     * @param sd Socket descriptor
-     * @param addr Address of remote end of connection
-     * @param dhp Default dispatch handler for connection
-     * @param connected Initial connection state for handler
-     */
-    IOHandlerData(int sd, const InetAddr& addr,
-            const DispatchHandlerPtr& dhp, bool connected = false)
-        : IOHandler(sd, dhp) {
-            memcpy(&m_addr, &addr, sizeof(InetAddr));
-            m_connected = connected;
-            reset_incoming_message_state();
-        }
-
-    /** Destructor */
-    virtual ~IOHandlerData() { }
-
-    /** Disconnects handler by delivering Event::DISCONNECT via default dispatch
-     * handler.
-     */
-    void disconnect() override {
-        EventPtr event = std::make_shared<Event>(Event::DISCONNECT, m_addr, m_proxy, m_error);
-        deliver_event(event);
-    }
-
-    /** Resets incoming message buffer state in preparation for next message.
-    */
-    void reset_incoming_message_state() {
-        m_got_header = false;
-        m_event.reset();
-        m_message_header_ptr = m_message_header;
-        m_message_header_remaining = CommHeader::FIXED_LENGTH;
-        m_message = 0;
-        m_message_ptr = 0;
-        m_message_remaining = 0;
-        m_message_aligned = false;
-    }
-
-    /// Frees the message buffer (#m_message).
-    /// If #m_message was allocated with posix_memalign(), as indicated by
-    /// #m_message_aligned, the free() function is used to deallocate the
-    /// memory.  Otherwise, the buffer is deallocated with delete []
-    void free_message_buffer() {
-        if (m_message_aligned) {
-            free(m_message);
-        } else {
-            delete [] m_message;
-        }
-        m_message = 0;
-    }
-
-    /** Sends message pointed to by <code>cbp</code> over socket associated
-     * with this I/O handler.  If the message being sent is a request
-     * message (has the CommHeader::FLAGS_BIT_REQUEST set) and
-     * <code>disp_handler</code> is not 0, then an entry is added to the
-     * reactor's request cache so that <code>disp_handler</code> will be
-     * called to handle the response or receive a TIMEOUT event if the
-     * response is not received within <code>timeout_ms</code> milliseconds.
-     * @param cbp Reference to CommBufPtr pointing to message to send
-     * @param timeout_ms Millisecond timeout used for request messages
-     * @param disp_handler Dispatch handler used for request messages
-     * @return error::OK on success, error::COMM_NOT_CONNECTED if handler has
-     * been decomissioned, or error::COMM_BROKEN_CONNECTION if a write error
-     * was encountered.
-     */
-    int send_message(CommBufPtr &cbp, uint32_t timeout_ms=0,
-            DispatchHandler *disp_handler=nullptr);
-
-    /** Flushes send queue.  When messages are sent, they are first added to a
-     * send queue (#m_send_queue) and then the messages in the send queue are
-     * written over the socket by calling this method.  This method attempts
-     * to write all of the messages in the queue and stops under the following
-     * conditions:
-     *   - Send queue becomes empty
-     *   - A write results in EAGAIN (socket buffer is full)
-     *   - An error is encountered during a write
-     * The send queue holds a list of CommBuf objects that contain <i>next
-     * write</i> pointers that are updated by this method and allow it to
-     * pick up where it left off in the event of EAGAIN.
-     * @return error::OK on success or EAGAIN, or error::COMM_BROKEN_CONNECTION
-     * if a write error was encountered.
-     */
-    int flush_send_queue();
-
-    /** Handle <code>epoll()</code> interface events.
-     * This method is called by its reactor thread to handle I/O events.
-     * It handles <code>EPOLLOUT</code> events with a call to
-     * #handle_write_readiness.  If #handle_write_readiness returns <i>true</i>
-     * the handler is disconnected with a call to #handle_disconnect and
-     * <i>true</i> is returned.  <code>EPOLLIN</code> events are handled by
-     * reading message data off the socket.  First the message header is read
-     * and decoded with #handle_message_header and then the message payload is
-     * read and delivered to the application with #handle_message_body.  If a
-     * read error is encountered, #m_error is set to the approprate error
-     * code (if not already set) and the handler is disconnected with
-     * a call to #handle_disconnect and <i>true</i> is returned.
-     * <i>EOF</i>, <code>EPOLLERR</code> events, <code>EPOLLHUP</code>, and
-     * <code>EPOLLRDHUP</code> events (level-triggered epoll only) are
-     * handled by disconnecting the handler with a call to #handle_disconnect
-     * and <i>true</i> is returned.  <code>arrival_time</code> is passed into
-     * #handle_message_header to be delivered to the applicaiton via the
-     * Event object.
-     * @param event Pointer to <code>epoll_event</code> structure describing
-     * event
-     * @param arrival_time Time of event arrival
-     * @return <i>false</i> on success, <i>true</i> if error encountered and
-     * handler was decomissioned
-     */
-    bool handle_event(struct epoll_event *event,
-            ClockT::time_point arrival_time) override;
-
-    /** Handles write readiness by completing connection and flushing send
-     * queue.  When a data handler is created after a call to
-     * <code>connect</code> it is in the disconnected state.  Once the socket
-     * becomes ready for writing, the connection request can be completed.
-     * This method handles the completion of the connection when the handler
-     * is in the disconnected state by doing the following:
-     *   - Sets the socket send and receive buffer to <code>4*32768</code>
-     *     bytes
-     *   - Reads the local socket address and initializes #m_local_addr
-     *   - Sets #m_connected to <i>true</i>
-     *   - If <i>proxy master</i>, propagate proxy map over newly established
-     *     connection.
-     *   - Delivers Event::CONNECTION_ESTABLISHED event via the default
-     *     dispatch handler
-     * After completion has been handled (if needed) then this method
-     * flushes the send queue with a call to #flush_send_queue.
-     * @return <i>false</i> on success, <i>true</i> if error encountered
-     */
-    bool handle_write_readiness();
-
-private:
-
-     /**
-     * Used to read data off a socket that is monotored with edge-triggered epoll.
-     * When this function returns with *errnop set to EAGAIN, it is safe to call
-     * epoll_wait on this socket.
-     */
-    ssize_t et_socket_read(int fd, void *vptr, size_t n, int *errnop, bool *eofp);
-
-    ssize_t et_socket_writev(int fd, const iovec *vector, int count, int *errnop);
-    /** Processes a message header.  This method is called when the fixed
-     * length portion of a header has been completely received.  It first
-     * checks to see if there is a variable portion of the header that has
-     * not yet been read, if so, it adjusts #m_message_header_remaining and
-     * returns.  If the header has been completely received, it allocates
-     * a new Event object and sets #m_event pointing to it.  It initializes
-     * the event object with the message header and <code>arrival_time</code>.
-     * It then allocates the message payload buffer (#m_message), initialzes
-     * the payload buffer pointers, and sets #m_got_header to <i>true</i>.
-     */
-    void handle_message_header(ClockT::time_point arrival_time);
-
-    /** Processes a message body.  This method is called when a message
-     * has been completely received (header + payload).  It first checks to
-     * see if the message is a proxy update message and if so, it updates
-     * its proxy map with a call to HandlerMap::update_proxy_map and returns.
-     * Otherwise if it is a response message and the
-     * CommHeader::FLAGS_BIT_IGNORE_RESPONSE bit is not set in the header
-     * flags, the corresponding dispatch handler is removed form request queue
-     * and the message is delivered to the applicaton using that handler.
-     * Otherwise, the message is delivered to the application using the
-     * default dispatch handler.  After the message has been delivered, the
-     * message receive state is reset with a call to
-     * #reset_incoming_message_state.
-     */
-    void handle_message_body();
-
-    /** Decomissions the handler.
-    */
-    void handle_disconnect();
-
-    /// Flag indicating if socket connection has been completed
-    bool m_connected {};
-
-    /// Flag indicating if message header has been completely received
-    bool m_got_header {};
-
-    /// Flag indicating if message buffer was allocated with posix_memalign()
-    bool m_message_aligned {};
-
-    /// Pointer to Event object holding message to deliver to application
-    EventPtr m_event;
-
-    /// Message header buffer
-    uint8_t m_message_header[64];
-
-    /// Pointer to next write position in #m_message_header
-    uint8_t *m_message_header_ptr {};
-
-    /// Amount of header remaining to be read
-    size_t m_message_header_remaining;
-
-    /// Poiner to message payload buffer
-    uint8_t *m_message {};
-
-    /// Pointer to next write position in #m_message
-    uint8_t *m_message_ptr {};
-
-    /// Amount of message payload remaining to be read
-    size_t m_message_remaining {};
-
-    /// Send queue
-    std::list<CommBufPtr> m_send_queue;
-
-};
-
-} //namespace palo
-#endif //BDG_PALO_BE_SRC_RPC_IO_HANDLER_DATA_H
diff --git a/be/src/rpc/io_handler_datagram.cpp b/be/src/rpc/io_handler_datagram.cpp
deleted file mode 100644
index d63c022a33b6d4..00000000000000
--- a/be/src/rpc/io_handler_datagram.cpp
+++ /dev/null
@@ -1,173 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "io_handler_datagram.h"
-#include "reactor_runner.h"
-#include "error.h"
-#include "file_utils.h"
-
-#include <cassert>
-#include <iostream>
-
-extern "C" {
-#include <arpa/inet.h>
-#include <errno.h>
-#include <netinet/in.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-}
-
-namespace palo {
-
-bool IOHandlerDatagram::handle_event(struct epoll_event *event,
-                                     ClockT::time_point arrival_time) {
-    int error = 0;
-    //DisplayEvent(event);
-    if (event->events & EPOLLOUT) {
-        if ((error = handle_write_readiness()) != error::OK) {
-            EventPtr event_ptr = std::make_shared<Event>(Event::ERROR, m_addr, error);
-            deliver_event(event_ptr);
-            ReactorRunner::handler_map->decomission_handler(this);
-            return true;
-        }
-    }
-    if (event->events & EPOLLIN) {
-        ssize_t nread = 0;
-        ssize_t payload_len = 0;
-        InetAddr addr;
-        socklen_t fromlen = sizeof(struct sockaddr_in);
-        while ((nread = FileUtils::recvfrom(m_sd, m_message, 65536,
-                                            (struct sockaddr *)&addr, &fromlen)) != (ssize_t)-1) {
-            EventPtr event_ptr = std::make_shared<Event>(Event::MESSAGE, addr, error::OK);
-            try {
-                event_ptr->load_message_header(m_message, (size_t)m_message[1]);
-            }
-            catch (palo::Exception &e) {
-                LOG(ERROR) << e << " from " << addr.format();
-                continue;
-            }
-            payload_len = nread - (ssize_t)event_ptr->header.header_len;
-            event_ptr->payload_len = payload_len;
-            event_ptr->payload = new uint8_t[payload_len];
-            event_ptr->arrival_time = arrival_time;
-            memcpy((void *)event_ptr->payload, m_message + event_ptr->header.header_len,
-                   payload_len);
-            deliver_event(event_ptr);
-            fromlen = sizeof(struct sockaddr_in);
-        }
-        if (errno != EAGAIN) {
-            LOG(ERROR) << "FileUtils::recvfrom(%d) failure : %s" << m_sd << strerror(errno);
-            EventPtr event_ptr = std::make_shared<Event>(Event::ERROR, addr,
-                                 error::COMM_RECEIVE_ERROR);
-            deliver_event(event_ptr);
-            ReactorRunner::handler_map->decomission_handler(this);
-            return true;
-        }
-        return false;
-    }
-    if (event->events & EPOLLERR) {
-        LOG(WARNING) << "Received EPOLLERR on descriptor " << m_sd << " ("
-                     << m_addr.format() << ")" ;
-        EventPtr event_ptr = std::make_shared<Event>(Event::ERROR, m_addr, error::COMM_POLL_ERROR);
-        deliver_event(event_ptr);
-        ReactorRunner::handler_map->decomission_handler(this);
-        return true;
-    }
-    return false;
-}
-
-int IOHandlerDatagram::handle_write_readiness() {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    int error = 0;
-    if ((error = flush_send_queue()) != error::OK) {
-        if (m_error == error::OK) {
-            m_error = error;
-        }
-        return error;
-    }
-    // is this necessary?
-    if (m_send_queue.empty()) {
-        error = remove_epoll_interest(poll_event::WRITE);
-    }
-    if (error != error::OK && m_error == error::OK) {
-        m_error = error;
-    }
-    return error;
-}
-
-int IOHandlerDatagram::send_message(const InetAddr &addr, CommBufPtr &cbp) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    int error = error::OK;
-    bool initially_empty = m_send_queue.empty() ? true : false;
-    //HT_LOG_ENTER;
-    m_send_queue.push_back(SendRec(addr, cbp));
-    if ((error = flush_send_queue()) != error::OK) {
-        if (m_error == error::OK) {
-            m_error = error;
-        }
-        return error;
-    }
-    if (initially_empty && !m_send_queue.empty()) {
-        error = add_epoll_interest(poll_event::WRITE);
-        //LOG(INFO) << "Adding Write interest";
-    }
-    else if (!initially_empty && m_send_queue.empty()) {
-        error = remove_epoll_interest(poll_event::WRITE);
-        //LOG(INFO) << "Removing Write interest";
-    }
-    if (error != error::OK && m_error == error::OK) {
-        m_error = error;
-    }
-    return error;
-}
-
-int IOHandlerDatagram::flush_send_queue() {
-    ssize_t nsent = 0;
-    ssize_t tosend = 0;
-    while (!m_send_queue.empty()) {
-        SendRec &send_rec = m_send_queue.front();
-        tosend = send_rec.second->data.size - (send_rec.second->data_ptr
-                                               - send_rec.second->data.base);
-        assert(tosend > 0);
-        assert(send_rec.second->ext.base == 0);
-        nsent = FileUtils::sendto(m_sd, send_rec.second->data_ptr, tosend,
-                                  (sockaddr *)&send_rec.first,
-                                  sizeof(struct sockaddr_in));
-        if (nsent == (ssize_t)-1) {
-            LOG(WARNING) << "FileUtils::sendto(%d, len=%d, addr=%s:%d) failed : %s" << m_sd <<
-                         (int)tosend << inet_ntoa(send_rec.first.sin_addr) <<
-                         ntohs(send_rec.first.sin_port) << strerror(errno);
-            return error::COMM_SEND_ERROR;
-        }
-        else if (nsent < tosend) {
-            LOG(WARNING) << "Only sent %d bytes" << (int)nsent;
-            if (nsent == 0) {
-                break;
-            }
-            send_rec.second->data_ptr += nsent;
-            break;
-        }
-        // buffer written successfully, now remove from queue (destroys buffer)
-        m_send_queue.pop_front();
-    }
-    return error::OK;
-}
-
-} //nemespace palo
diff --git a/be/src/rpc/io_handler_datagram.h b/be/src/rpc/io_handler_datagram.h
deleted file mode 100644
index a5d84b72d9efa0..00000000000000
--- a/be/src/rpc/io_handler_datagram.h
+++ /dev/null
@@ -1,118 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_IO_HANDLER_DATAGRAM_H
-#define BDG_PALO_BE_SRC_RPC_IO_HANDLER_DATAGRAM_H
-
-#include "comm_buf.h"
-#include "io_handler.h"
-#include <list>
-#include <utility>
-
-extern "C" {
-#include <netdb.h>
-#include <string.h>
-}
-
-namespace palo {
-
-/** I/O handler for datagram (UDP) sockets.
- */
-class IOHandlerDatagram : public IOHandler {
-public:
-
-    /** Constructor.  This method initializes the handler by allocating
-     * a receive buffer and copying the locally bound address to #m_addr.
-     * @param sd Socket descriptor bound to an address
-     * @param dhp Default dispatch handler
-     */
-    IOHandlerDatagram(int sd, const DispatchHandlerPtr &dhp,
-            Reactor::Priority rp) : IOHandler(sd, dhp, rp) {
-        m_message = new uint8_t[65536];
-        memcpy(&m_addr, &m_local_addr, sizeof(InetAddr));
-    }
-
-    /** Destructor. */
-    virtual ~IOHandlerDatagram() { delete [] m_message; }
-
-    /** Sends a message.  This method pushes the message pointed to by
-     * <code>cbp</code> onto the send queue, flushes the send queue with a call
-     * to #flush_send_queue, and then updates polling interest depending on
-     * the state of the send queue.
-     * @param addr Remote address to send message to
-     * @param cbp Pointer to message to send
-     * @return error::OK on success, or error::COMM_SEND_ERROR on send error
-     */
-    int send_message(const InetAddr &addr, CommBufPtr &cbp);
-
-    /** Flushes send queue.  This method tries to write all messages on the
-     * send queue.  If a write succeeds, but writes fewer bytes than requested,
-     * that implies the send buffer is full.  The send queue holds a list of
-     * CommBuf objects (and associated destination addresses) that contain
-     * <i>next write</i> pointers that are updated by this method and allow it to
-     * pick up where it left off in the event of a short write.
-     * @return error::OK on success, or error::COMM_SEND_ERROR on send error
-     */
-    int flush_send_queue();
-
-    /** Handle <code>epoll()</code> interface events.
-     * This method is called by its reactor thread to handle I/O events.
-     * It handles <code>EPOLLOUT</code> events with a call to
-     * #handle_write_readiness.  If #handle_write_readiness returns <i>true</i>
-     * the handler is disconnected with a call to handle_disconnect() and
-     * <i>true</i> is returned.  <code>EPOLLIN</code> events are handled in
-     * a loop by reading messages off the socket in their entirety with a call
-     * to <code>recvfrom</code>.  The message buffer is 65536 bytes in size
-     * and therefore this method can only handle messages of that size or
-     * less.  Messages are delivered to the application by creating an Event
-     * object, initializing it with the message header and
-     * <code>arrival_time</code>, and delivering it with the default dispatch
-     * handler.  <code>EPOLLERR</code> and errors are handled by decomissioning
-     * the handler and delivering an Event::ERROR event to the application.
-     * @warning This method assumes messages are less than 65535 bytes
-     * @param event Pointer to <code>pollfd</code> structure describing event
-     * @param arrival_time Time of event arrival
-     * @return <i>false</i> on success, <i>true</i> if error encountered and
-     * handler was decomissioned
-     */
-    bool handle_event(struct epoll_event *event,
-            ClockT::time_point arrival_time) override;
-
-    /** Handles write readiness.  This method handles write readiness by
-     * flushing the send queue with a call to #flush_send_queue and then
-     * removes write interest from the polling interface for this handler
-     * if the send queue becomes empty.
-     * @return error::OK on success, or error::COMM_SEND_ERROR on send error
-     */
-    int handle_write_readiness();
-
-private:
-
-    /// Send queue message record
-    typedef std::pair<struct sockaddr_in, CommBufPtr> SendRec;
-
-    /// Message receive buffer
-    uint8_t *m_message;
-
-    /// Send queue
-    std::list<SendRec> m_send_queue;
-};
-
-} //namespace palo
-#endif //BDG_PALO_BE_SRC_RPC_IO_HANDLER_DATAGRAM_H
diff --git a/be/src/rpc/io_handler_raw.cpp b/be/src/rpc/io_handler_raw.cpp
deleted file mode 100644
index 51d7a9dd2fed9c..00000000000000
--- a/be/src/rpc/io_handler_raw.cpp
+++ /dev/null
@@ -1,109 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "io_handler_raw.h"
-#include "poll_event.h"
-#include "reactor_runner.h"
-#include "error.h"
-#include "file_utils.h"
-#include "inet_addr.h"
-
-#include <cassert>
-#include <iostream>
-
-extern "C" {
-#include <arpa/inet.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <sys/uio.h>
-}
-
-namespace palo {
-
-bool
-IOHandlerRaw::handle_event(struct epoll_event *event,
-                           ClockT::time_point arrival_time) {
-    //display_event(event);
-    try {
-        if (ReactorFactory::ms_epollet && event->events & EPOLLRDHUP) {
-            VLOG(3) << "Received EPOLLRDHUP on descriptor %d (%s:%d)" << m_sd <<
-                    inet_ntoa(m_addr.sin_addr) << ntohs(m_addr.sin_port);
-            ReactorRunner::handler_map->decomission_handler(this);
-            return true;
-        }
-        if (event->events & EPOLLERR) {
-            LOG(INFO) << "Received EPOLLERR on descriptor %d (%s:%d)" << m_sd <<
-                      inet_ntoa(m_addr.sin_addr) << ntohs(m_addr.sin_port);
-            ReactorRunner::handler_map->decomission_handler(this);
-            return true;
-        }
-        if (event->events & EPOLLHUP) {
-            VLOG(3) << "Received EPOLLHUP on descriptor %d (%s:%d)" << m_sd <<
-                    inet_ntoa(m_addr.sin_addr) << ntohs(m_addr.sin_port);
-            ReactorRunner::handler_map->decomission_handler(this);
-            return true;
-        }
-        int events {};
-        if (event->events & EPOLLOUT)
-            events |= poll_event::WRITE;
-        if (event->events & EPOLLIN)
-            events |= poll_event::READ;
-        if (!m_handler->handle(m_sd, events))
-            return true;
-        update_poll_interest();
-    }
-    catch (palo::Exception &e) {
-        LOG(ERROR)  << e ;
-        ReactorRunner::handler_map->decomission_handler(this);
-        return true;
-    }
-    return m_error != error::OK;
-}
-
-void IOHandlerRaw::update_poll_interest() {
-    int error = 0;
-    int new_interest = m_handler->poll_interest(m_sd);
-    int changed = new_interest ^ m_epoll_interest;
-    int turn_off = changed ^ new_interest;
-    int turn_on  = changed ^ m_epoll_interest;
-    int mask = ~(turn_off & turn_on);
-    turn_off &= mask;
-    turn_on &= mask;
-    if (turn_off) {
-        VLOG(3) << "Turning poll interest OFF:  0x%x" << turn_off;
-        if ((error = remove_epoll_interest(turn_off)) != error::OK) {
-            if (m_error == error::OK)
-                m_error = error;
-            return;
-        }
-    }
-    if (turn_on) {
-        VLOG(3) << "Turning poll interest ON:  0x%x" << turn_on;
-        if ((error = add_epoll_interest(turn_on)) != error::OK) {
-            if (m_error == error::OK)
-                m_error = error;
-            return;
-        }
-    }
-}
-
-} //namespace palo
diff --git a/be/src/rpc/io_handler_raw.h b/be/src/rpc/io_handler_raw.h
deleted file mode 100644
index ccaf9bae7a19d0..00000000000000
--- a/be/src/rpc/io_handler_raw.h
+++ /dev/null
@@ -1,86 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_IO_HANDLER_RAW_H
-#define BDG_PALO_BE_SRC_RPC_IO_HANDLER_RAW_H
-
-#include "comm_buf.h"
-#include "io_handler.h"
-#include "raw_socket_handler.h"
-#include "error.h"
-
-namespace palo {
-
-/// I/O handler for raw sockets.
-class IOHandlerRaw : public IOHandler {
-public:
-
-    /// Constructor.
-    /// Initializes handler by setting #m_socket_internally_created to
-    /// <i>false</i> and setting #m_addr to <code>addr</code>.
-    /// @param sd Socket descriptor
-    /// @param addr Connection address for identification purposes
-    /// @param rhp Poiner to raw socket handler
-    IOHandlerRaw(int sd, const InetAddr &addr, RawSocketHandler *rhp)
-        : IOHandler(sd), m_handler(rhp) {
-            m_socket_internally_created = false;
-            memcpy(&m_addr, &addr, sizeof(InetAddr));
-        }
-
-    /// Destructor.
-    /// Calls the RawSocketHandler::deregister() function of #m_handler.
-    virtual ~IOHandlerRaw() {
-        m_handler->deregister(m_sd);
-    }
-
-    /// Handle <code>epoll()</code> interface events.
-    /// This method is called by its reactor thread to handle I/O events.
-    /// It handles <code>EPOLLRDHUP</code>, <code>EPOLLERR</code>, and
-    /// <code>EPOLLHUP</code> events by decomissing the handler and returning
-    /// <i>true</i> causing the reactor runner to remove the socket from the
-    /// event loop.  It handles <code>EPOLLIN</code> and <code>EPOLLOUT</code>
-    /// events by passing them to the RawSocketHandler::handle() function of
-    /// #m_handler and then calling update_poll_interest() to update the polling
-    /// interest.
-    /// @param event Pointer to <code>epoll_event</code> structure describing
-    /// event
-    /// @param arrival_time Time of event arrival
-    /// @return <i>false</i> on success, <i>true</i> if error encountered and
-    /// handler was decomissioned
-    bool handle_event(struct epoll_event *event,
-            ClockT::time_point arrival_time) override;
-
-    /// Updates polling interest for socket.
-    /// This function is called after the RawSocketHandler::handle() function is
-    /// called to updated the polling interest of the socket.  It first calls
-    /// RawSocketHandler::poll_interest() to obtain the new polling interest.
-    /// Based on the difference between the existing polling interest registered
-    /// for the socket and the new interest returned by
-    /// RawSocketHandler::poll_interest(), calls remove_epoll_interest() and
-    /// add_epoll_interest() to adjust the polling interest for the socket.
-    void update_poll_interest();
-
-private:
-
-    /// Raw socket handler
-    RawSocketHandler *m_handler;
-};
-
-} //namespace palo
-#endif //BDG_PALO_BE_SRC_RPC_IO_HANDLER_RAW_H
diff --git a/be/src/rpc/poll_event.cpp b/be/src/rpc/poll_event.cpp
deleted file mode 100644
index 5d6bb2b67baec1..00000000000000
--- a/be/src/rpc/poll_event.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "poll_event.h"
-
-#include <string>
-
-namespace palo {
-
-namespace poll_event {
-
-std::string to_string(int events) {
-    std::string str;
-    std::string or_str;
-    if (events & poll_event::READ) {
-        str.append("READ");
-        or_str = std::string("|");
-    }
-    if (events & poll_event::PRI) {
-        str += or_str + "PRI";
-        or_str = std::string("|");
-    }
-    if (events & poll_event::WRITE) {
-        str += or_str + "WRITE";
-        or_str = std::string("|");
-    }
-    if (events & poll_event::ERROR) {
-        str += or_str + "ERROR";
-        or_str = std::string("|");
-    }
-    if (events & poll_event::HUP) {
-        str += or_str + "HUP";
-        or_str = std::string("|");
-    }
-    if (events & poll_event::REMOVE) {
-        str += or_str + "REMOVE";
-        or_str = std::string("|");
-    }
-    if (events & poll_event::RDHUP) {
-        str += or_str + "RDHUP";
-        or_str = std::string("|");
-    }
-    return str;
-}
-
-} //namespace poll_event
-
-} //namespace palo
diff --git a/be/src/rpc/poll_event.h b/be/src/rpc/poll_event.h
deleted file mode 100644
index d9642a5ed8dcb5..00000000000000
--- a/be/src/rpc/poll_event.h
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_POLL_EVENT_H
-#define BDG_PALO_BE_SRC_RPC_POLL_EVENT_H
-
-namespace palo {
-
-/// Polling event constants (mechanism-independent).
-namespace poll_event {
-
-/// Enumeration for poll interest constants.
-    enum Flags {
-        /// Data available to read
-        READ   = 0x01,
-        /// Urgent data available to read
-        PRI    = 0x02,
-        /// Writing can be performed without blocking
-        WRITE  = 0x04,
-        /// %Error condition
-        ERROR  = 0x08,
-        /// Hang up
-        HUP    = 0x10,
-        REMOVE = 0x1000,
-        /// Stream socket peer closed connection
-        RDHUP  = 0x2000
-    };
-    /// Returns a string representation of polling events
-    /// @param events Bitmaks of polling events (::Flags)
-    /// @return string representation of polling events
-    std::string to_string(int events);
-}
-
-} // namespace palo
-#endif //BDG_PALO_BE_SRC_RPC_POLL_EVENT_H
diff --git a/be/src/rpc/poll_timeout.h b/be/src/rpc/poll_timeout.h
deleted file mode 100644
index a4651182a14233..00000000000000
--- a/be/src/rpc/poll_timeout.h
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_POLL_TIMEOUT_H
-#define BDG_PALO_BE_SRC_RPC_POLL_TIMEOUT_H
-
-#include "clock.h"
-#include <cassert>
-
-namespace palo {
-
-/** Maintains next timeout for event polling loop.  This class is used to
- * maintain and provide access to the next timeout for the event polling
- * loops.  It contains accessor methods to return the timeout in different
- * formats required by the various polling interfaces.
- */
-class PollTimeout {
-public:
-
-    /** Constructor. */
-    PollTimeout() { }
-
-    /** Sets the next timeout.
-     * @param now Current time
-     * @param expire Absolute time of next timeout
-     */
-    void set(ClockT::time_point now, ClockT::time_point expire) {
-        assert(std::chrono::operator<=(now, expire));
-        auto diff_usec = expire - now;
-        duration_ts.tv_sec = diff_usec.count() / 1000000;
-        duration_ts.tv_nsec = (diff_usec.count() % 1000000) * 1000;
-        ts_ptr = &duration_ts;
-        duration_millis = std::chrono::duration_cast<std::chrono::milliseconds>(diff_usec);
-    }
-
-    /** Sets the next timeout to be an indefinite time in the future.
-    */
-    void set_indefinite() {
-        ts_ptr = nullptr;
-        duration_millis = std::chrono::milliseconds(-1);
-    }
-
-    /** Gets duration until next timeout in the form of milliseconds.
-     * @return Milliseconds until next timeout
-     */
-    int get_millis() { return duration_millis.count(); }
-
-    /** Gets duration until next timeout in the form of a pointer to timespec.
-     * @return Pointer to timespec representing duration until next timeout.
-     */
-    struct timespec *get_timespec() { return ts_ptr; }
-
-private:
-
-    /// Pointer to to #duration_ts or 0 if indefinite
-    struct timespec *ts_ptr {};
-
-    /// timespec structure holding duration until next timeout
-    struct timespec duration_ts;
-
-    /// Duration until next timeout in milliseconds
-    std::chrono::milliseconds duration_millis {-1};
-};
-
-} //namespace palo
-#endif //BDG_PALO_BE_RPC_POLL_TIMEOUT_H
diff --git a/be/src/rpc/protocol.cpp b/be/src/rpc/protocol.cpp
deleted file mode 100644
index 1e091c792fccc4..00000000000000
--- a/be/src/rpc/protocol.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "comm_buf.h"
-#include "event.h"
-#include "protocol.h"
-#include "error.h"
-#include "common/logging.h"
-#include "serialization.h"
-
-#include <cassert>
-#include <iostream>
-
-namespace palo {
-
-int32_t Protocol::response_code(const Event *event) {
-    if (event->type == Event::ERROR) {
-        return event->error;
-    }
-    const uint8_t *msg = event->payload;
-    size_t remaining = event->payload_len;
-    try {
-        return serialization::decode_i32(&msg, &remaining);
-    } catch (Exception &e) {
-        return e.code();
-    }
-}
-
-std::string Protocol::string_format_message(const Event *event) {
-    int error = error::OK;
-    if (event == 0) {
-        return std::string("NULL event");
-    }
-    const uint8_t *msg = event->payload;
-    size_t remaining = event->payload_len;
-    if (event->type != Event::MESSAGE) {
-        return event->to_str();
-    }
-    try {
-        error = serialization::decode_i32(&msg, &remaining);
-        if (error == error::OK) {
-            return error::get_text(error);
-        }
-        uint16_t len;
-        const char *str = serialization::decode_str16(&msg, &remaining, &len);
-        return std::string(str, len > 150 ? 150 : len);
-    } catch (Exception &e) {
-        return format("%s - %s", e.what(), error::get_text(e.code()));
-    }
-}
-
-CommBufPtr
-Protocol::create_error_message(CommHeader &header, int error, const char *msg) {
-    CommBufPtr cbuf 
-        = std::make_shared<CommBuf>(header, 4 + serialization::encoded_length_str16(msg));
-    cbuf->append_i32(error);
-    cbuf->append_str16(msg);
-    return cbuf;
-}
-
-} //namespace palo
diff --git a/be/src/rpc/protocol.h b/be/src/rpc/protocol.h
deleted file mode 100644
index 7933c474e1bdd6..00000000000000
--- a/be/src/rpc/protocol.h
+++ /dev/null
@@ -1,130 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_PROTOCOL_H
-#define BDG_PALO_BE_SRC_RPC_PROTOCOL_H
-
-#include "event.h"
-#include "comm_header.h"
-#include "comm_buf.h"
-
-namespace palo {
-
-class CommBuf;
-
-/** Abstract base class for server protocol drivers.
- * This is the base class for all server protocol drivers.  A server protocol
- * driver is responsible for encoding and decoding messages sent and received
- * to and from a service.
- */
-class Protocol {
-public:
-
-    /** Destructor. */
-    virtual ~Protocol() { return; }
-
-    /** Returns the response code from an event <code>event</code> generated
-     * in response to a request message.
-     * If <code>event</code> is of type ERROR, then <code>event->error</code>
-     * is returned, otherwise the response code is decoded from the first four
-     * bytes of the message payload.
-     * @return Error or response code from <code>event</code> or
-     * error::SERIALIZATION_INPUT_OVERRUN if payload of MESSAGE event is less
-     * than 4 bytes.
-     */
-    static int32_t response_code(const Event *event);
-
-    /** Returns the response code from an event <code>event</code> generated
-     * in response to a request message.
-     * If <code>event</code> is of type ERROR, then <code>event->error</code>
-     * is returned, otherwise the response code is decoded from the first four
-     * bytes of the message payload.
-     * @return Error or response code from <code>event</code> or
-     * error::SERIALIZATION_INPUT_OVERRUN if payload of MESSAGE event is less
-     * than 4 bytes.
-     */
-    static int32_t response_code(const EventPtr &event) {
-        return response_code(event.get());
-    }
-
-    /** Returns error message decoded standard error MESSAGE generated
-     * in response to a request message.  When a request to a service method
-     * results in an error, the error code an message are typically returned
-     * in a response message encoded in the following format:
-     * <pre>
-     *   [int32] error code
-     *   [int16] error message length
-     *   [chars] error message
-     * </pre>
-     * This method extracts and returns the error message from a response
-     * MESSAGE event.
-     * @note The semantics of this method are wacky, it should be re-written
-     * @param event Pointer to MESSAGE event received in response to a request
-     * @return %Error message
-     */
-    static std::string string_format_message(const Event *event);
-
-    /** Returns error message decoded from standard error MESSAGE generated
-     * in response to a request message.  When a request to a service method
-     * results in an error, the error code an message are typically returned
-     * in a response message encoded in the following format:
-     * <pre>
-     *   [int32] error code
-     *   [int16] error message length
-     *   [chars] error message
-     * </pre>
-     * This method extracts and returns the error message from a response
-     * MESSAGE event.
-     * @note The semantics of this method are wacky, it should be re-written
-     * @param event Pointer to MESSAGE event received in response to a request
-     * @return %Error message
-     */
-    static std::string string_format_message(const EventPtr &event) {
-        return string_format_message(event.get());
-    }
-
-    /** Creates a standard error message response.  This method creates a
-     * standard error message response encoded in the following format:
-     * <pre>
-     *   [int32] error code
-     *   [int16] error message length
-     *   [chars] error message
-     * </pre>
-     * @param header Reference to header to use in response buffer
-     * @param error %Error code
-     * @param msg %Error message
-     * @return Pointer to Commbuf message holding standard error response
-     */
-    static CommBufPtr
-        create_error_message(CommHeader &header, int error, const char *msg);
-
-    /** Returns the string representation of a command code.  Each protocol
-     * defines a set of command codes that are sent in the CommHeader::command
-     * field of a reqeust's message header to indicate which server command
-     * (method) is to be executed.  This method returns a human readable
-     * string mnemonic for the command.
-     * @param command Command code
-     * @return Pointer to human readable string mnemonic for
-     * <code>command</code>.
-     */
-    virtual const char *command_text(uint64_t command) = 0;
-};
-
-} //namespace palo
-#endif //BDG_PALO_BE_SRC_RPC_PROTOCOL_H
diff --git a/be/src/rpc/proxy_map.cpp b/be/src/rpc/proxy_map.cpp
deleted file mode 100644
index e2f319fefeb07b..00000000000000
--- a/be/src/rpc/proxy_map.cpp
+++ /dev/null
@@ -1,188 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "proxy_map.h"
-#include "string_ext.h"
-
-namespace palo {
-
-void ProxyMap::update_mapping(const std::string &proxy, const std::string &hostname,
-                              const InetAddr &addr, ProxyMapT &invalidated_map,
-                              ProxyMapT &new_map) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    ProxyMapT::iterator iter = m_forward_map.find(proxy);
-    if (iter != m_forward_map.end() && (*iter).second.addr == addr) {
-        if ((*iter).second.hostname != hostname) {
-            (*iter).second.hostname = hostname;
-        }
-        return;
-    }
-    invalidate_old_mapping(proxy, addr, invalidated_map);
-    new_map[proxy] = ProxyAddressInfo(hostname, addr);
-    m_forward_map[proxy] = ProxyAddressInfo(hostname, addr);
-    m_reverse_map[addr] = proxy;
-}
-
-void ProxyMap::update_mappings(std::string &mappings, ProxyMapT &invalidated_map,
-                               ProxyMapT &new_map) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    char *line = 0;
-    char *proxy = 0;
-    char *hostname = 0;
-    char *addr_str = 0;
-    char *end_nl = 0;
-    char *end_tab = 0;
-    for (line = strtok_r((char *)mappings.c_str(), "\n", &end_nl); line;
-            line = strtok_r(0, "\n", &end_nl)) {
-        proxy = strtok_r(line, "\t", &end_tab);
-        assert(proxy);
-        hostname = strtok_r(0, "\t", &end_tab);
-        assert(hostname);
-        addr_str = strtok_r(0, "\t", &end_tab);
-        assert(addr_str);
-        InetAddr addr(addr_str);
-        ProxyMapT::iterator iter = m_forward_map.find(proxy);
-        if (!strcmp(hostname, "--DELETED--")) {
-            if (iter != m_forward_map.end()) {
-                if ((*iter).second.addr != addr) {
-                    LOG(WARNING) << "Proxy map removal message for %s contains %s, but map "
-                                 << "contains %s" << proxy << addr_str
-                                 << (*iter).second.addr.format().c_str();
-                }
-                invalidate(proxy, invalidated_map);
-            }
-            else {
-                LOG(WARNING) << "Removal message received for %s, but not in map." << proxy;
-            }
-        }
-        else {
-            if (iter != m_forward_map.end() && (*iter).second.addr == addr) {
-                if ((*iter).second.hostname != hostname) {
-                    (*iter).second.hostname = hostname;
-                }
-                continue;
-            }
-            invalidate_old_mapping(proxy, addr, invalidated_map);
-            new_map[proxy] = ProxyAddressInfo(hostname, addr);
-            m_forward_map[proxy] = ProxyAddressInfo(hostname, addr);
-            m_reverse_map[addr] = proxy;
-        }
-    }
-}
-
-void ProxyMap::remove_mapping(const std::string &proxy, ProxyMapT &remove_map) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    invalidate(proxy, remove_map);
-    return;
-}
-
-bool ProxyMap::get_mapping(const std::string &proxy, std::string &hostname, InetAddr &addr) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    ProxyMapT::iterator iter = m_forward_map.find(proxy);
-    if (iter == m_forward_map.end()) {
-        return false;
-    }
-    addr = (*iter).second.addr;
-    hostname = (*iter).second.hostname;
-    return true;
-}
-
-std::string ProxyMap::get_proxy(InetAddr &addr) {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    SockAddrMap<std::string>::iterator iter = m_reverse_map.find(addr);
-    if (iter != m_reverse_map.end()) {
-        return (*iter).second;
-    }
-    return "";
-}
-
-CommBufPtr ProxyMap::create_update_message() {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    std::string payload;
-    CommHeader header;
-    header.flags |= CommHeader::FLAGS_BIT_PROXY_MAP_UPDATE;
-    for (ProxyMapT::iterator iter = m_forward_map.begin(); iter != m_forward_map.end(); ++iter) {
-        payload += (*iter).first + "\t" 
-                   + (*iter).second.hostname + "\t" 
-                   + (*iter).second.addr.format() + "\n";
-    }
-    CommBufPtr cbuf = std::make_shared<CommBuf>(header, payload.length());
-    if (payload.length()) {
-        cbuf->append_bytes((uint8_t *)payload.c_str(), payload.length());
-    }
-    return cbuf;
-}
-
-void
-ProxyMap::invalidate_old_mapping(const std::string &proxy, const InetAddr &addr,
-                                 ProxyMapT &invalidated_map) {
-    ProxyMapT::iterator iter;
-    SockAddrMap<std::string>::iterator rev_iter;
-    // Invalidate entries from forward map, if changed
-    if ((iter = m_forward_map.find(proxy)) != m_forward_map.end()) {
-        if ((*iter).second.addr != addr) {
-            invalidated_map[(*iter).first] = (*iter).second;
-            m_reverse_map.erase((*iter).second.addr);
-            m_forward_map.erase((*iter).first);
-        }
-    }
-    // Invalidate entries from reverse map, if changed
-    if ((rev_iter = m_reverse_map.find(addr)) != m_reverse_map.end()) {
-        if ((*rev_iter).second != proxy) {
-            invalidated_map[(*rev_iter).second] = ProxyAddressInfo("unknown", (*rev_iter).first);
-            m_forward_map.erase((*rev_iter).second);
-            m_reverse_map.erase((*rev_iter).first);
-        }
-    }
-}
-
-void ProxyMap::invalidate(const std::string &proxy, ProxyMapT &invalidated_map) {
-    ProxyMapT::iterator iter;
-    SockAddrMap<std::string>::iterator rev_iter;
-    InetAddr addr;
-    // Invalidate entries from forward map
-    if ((iter = m_forward_map.find(proxy)) != m_forward_map.end()) {
-        (*iter).second.hostname = "--DELETED--";
-        invalidated_map[(*iter).first] = (*iter).second;
-        addr = (*iter).second.addr;
-        m_forward_map.erase((*iter).first);
-    }
-    else
-        return;
-    // Invalidate entries from reverse map
-    if ((rev_iter = m_reverse_map.find(addr)) != m_reverse_map.end()) {
-        if ((*rev_iter).second == proxy) {
-            m_reverse_map.erase((*rev_iter).first);
-        }
-    }
-}
-
-std::string ProxyMap::to_str() {
-    std::lock_guard<std::mutex> lock(m_mutex);
-    ProxyMapT::iterator iter;
-    std::string str;
-    for (iter = m_forward_map.begin(); iter != m_forward_map.end(); ++iter) {
-        str += format("(%s,%s,%s),", (*iter).first.c_str(),
-                      (*iter).second.hostname.c_str(), (*iter).second.addr.format().c_str());
-    }
-    return str;
-}
-
-} //namespace palo
diff --git a/be/src/rpc/proxy_map.h b/be/src/rpc/proxy_map.h
deleted file mode 100644
index 099184a1476d28..00000000000000
--- a/be/src/rpc/proxy_map.h
+++ /dev/null
@@ -1,209 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_PROXY_MAP_H
-#define BDG_PALO_BE_SRC_RPC_PROXY_MAP_H
-
-#include "comm_buf.h"
-#include "inet_addr.h"
-#include "sock_addr_map.h"
-#include "util.h"
-
-#include <mutex>
-
-namespace palo {
-
-/** Holds address and hostname associated with a proxy name.
- */
-class ProxyAddressInfo {
-public:
-    ProxyAddressInfo() { }
-    ProxyAddressInfo(const std::string &h, InetAddr a) : hostname(h), addr(a) { }
-    std::string hostname;
-    InetAddr addr;
-};
-
-/// Forward mapping hash type from proxy name to ProxyAddressInfo
-typedef std::unordered_map<std::string, ProxyAddressInfo> ProxyMapT;
-
-/** Maps a set of proxy names to their associated IP addresses.
- * palo uses <i>proxy names</i> (e.g. "rs1") to refer to servers so
- * that the system can continue to operate properly even when servers are
- * reassigned IP addresses, such as starting and stopping palo running
- * on EBS volumes in AWS EC2.  There is a single ProxyMap associated with
- * each Comm layer and one of the connected participants is designated as
- * the <i>proxy master</i> by setting the global variable
- * <code>ReactorFactory::proxy_master</code> to <i>true</i>.
- * In palo, the Master is designated as the proxy master.  The proxy
- * master is responsible for assigning proxy names which are just mnemonic
- * strings (e.g. "rs1").  Whenever a server connects to the proxy master,
- * the proxy master will either assign the newly connected server a proxy
- * name or obtain it via a handshake and should then update the proxy map with
- * the <i>{proxy name, IP address}</i> association and will propagate the new
- * proxy map information to all connected participants.  Once this is
- * complete, all connected participants and send and receive messages to any
- * participant using its proxy name.  The CommAddress class is an abstraction
- * that can hold either a proxy name or an IP address and used to identify
- * the destination of a message.
- */
-class ProxyMap {
-public:
-
-    /** Updates a proxy name mapping.  This method first checks to see if there
-     * is already a mapping from <code>proxy</code> to <code>addr</code> in the
-     * forawrd map.  If so, then it updates the hostname.  Otherwise, it
-     * invalidates <code>proxy</code> from the forward map and <code>addr</code>
-     * from the reverse map and adds entries to the forward and reverse maps
-     * for the new mapping.  Any invalidated mappings are added to
-     * <code>invalidated_map</code> and the new forward mapping from
-     * <code>proxy</code> to ProxyAddressInfo is added to <code>new_map</code>.
-     * @param proxy Proxy name of new/updated mapping
-     * @param hostname Hostname of new/updated mapping
-     * @param addr InetAddr of new/updated mapping
-     * @param invalidated_map Reference to return map to hold invalidated
-     *        mappings
-     * @param new_map Reference to return map to hold new forward mapping
-     */
-    void update_mapping(const std::string &proxy, const std::string &hostname,
-            const InetAddr &addr,ProxyMapT &invalidated_map,
-            ProxyMapT &new_map);
-
-    /** Update mappings from proxy map update message string.
-     * One process in the system is designated as the proxy master and is
-     * responsible for updating the proxy mappings for all connected
-     * processes.  This method is called by connected processes to update
-     * their proxy maps from a proxy map update message received by the
-     * proxy master.  The proxy map update message consists of a list of
-     * mappings in the following format:
-     * @verbatim <proxy> '\t' <hostname> '\t' <addr> '\n' @endverbatim
-     * For each mapping in <code>mappings</code> this method first checks to see
-     * if there is already a mapping from <code>proxy</code> to
-     * <code>addr</code> in the forawrd map.  If so, then it updates the
-     * hostname.  Otherwise, it invalidates <code>proxy</code> from the forward
-     * map and <code>addr</code> from the reverse map and adds entries to the
-     * forward and reverse maps for the new mapping.  Any invalidated mappings
-     * are added to <code>invalidated_map</code> and the new forward mapping
-     * from <code>proxy</code> to ProxyAddressInfo is added to
-     * <code>new_map</code>.  A hostname entry of <code>--DELETED--</code>
-     * means that the entry is to be removed.  In this situation, this method
-     * invalidates <code>proxy</code> from the forward map and <code>addr</code>
-     * from the reverse map and the invalidated mappings are added to
-     * <code>invalidated_map</code>.
-     * @param mappings Proxy map update message string
-     * @param invalidated_map Reference to return map to hold invalidated
-     *        mappings
-     * @param new_map Reference to return map to hold new forward mapping
-     */
-    void update_mappings(std::string &mappings, ProxyMapT &invalidated_map,
-            ProxyMapT &new_map);
-
-    /** Removes a mapping.  This method removes the mapping for
-     * <code>proxy</code> and adds the removed mapping to
-     * <code>remove_map</code> with the hostname set to
-     * <code>--DELETED--</code> (see #update_mappings).  The <i>proxy master</i>
-     * calls this method to remove a mapping and then propagates
-     * <code>remove_map</code> to all connections.
-     * @param proxy Proxy for which mapping is to be removed
-     * @param remove_map Reference to return map to hold removed mappings
-     */
-    void remove_mapping(const std::string &proxy, ProxyMapT &remove_map);
-
-    /** Returns proxy map data for <code>proxy</code>.
-     * This method looks up <code>proxy</code> in the forward map and returns
-     * the associated hostname and address information, if found.
-     * @param proxy Proxy name for which to fetch mapping information
-     * @param hostname Reference to returned hostname
-     * @param addr Reference to returned address
-     * @return <i>true</i> if mapping found, <i>false</i> otherwise.
-     */
-    bool get_mapping(const std::string &proxy, std::string &hostname, InetAddr &addr);
-
-    /** Returns proxy name for <code>addr</code>.  This method looks up
-     * <code>addr</code> in the reverse map and returns the proxy name,
-     * if found.
-     * @param addr Address for which to fetch proxy name
-     * @return Proxy name of <code>addr</code> if found in reverse map,
-     * otherwise the empty string.
-     */
-    std::string get_proxy(InetAddr &addr);
-
-    /** Returns the forward map (proxy name to ProxyAddressInfo)
-     * @param map Reference to return forward map
-     */
-    void get_map(ProxyMapT &map) {
-        map = m_forward_map;
-    }
-
-    /** Creates a proxy map update message.  This method is called by the proxy
-     * master to create a proxy map update message to be sent to all connected
-     * processes.  The proxy map update message consists of a list of proxy
-     * mappings in the following format:
-     * @verbatim <proxy> '\t' <hostname> '\t' <addr> '\n' @endverbatim
-     * The forward map is traversed to generate the list of mappings which are
-     * added to a newly allocated CommBuf object.  The CommBuf object is
-     * initialized with a CommHeader that has the
-     * CommHeader::FLAGS_BIT_PROXY_MAP_UPDATE bit set in its flags member.
-     * @return CommBuf object holding the proxy map update message (to be freed
-     * by caller).
-     */
-    CommBufPtr create_update_message();
-
-    std::string to_str();
-
-private:
-
-    /** Invalidates (removes) mapping, if changed, from forward and reverse maps.
-     * This method looks up <code>proxy</code> in the forward map and removes
-     * it if it exists but maps to an address different from <code>addr</code>.
-     * It also looks up <code>addr</code> in the reverse map
-     * and removes it if it exists and it maps to a proxy different than
-     * <code>proxy</code>.  The removed mappings are added to
-     * <code>invalidated_mappings</code>.
-     * @param proxy Proxy name to invalidate
-     * @param addr IP address to invalidate
-     * @param invalidated_mappings Reference to ProxyMapT object to hold
-     * invalidated mappings.
-     */
-    void invalidate_old_mapping(const std::string &proxy, const InetAddr &addr,
-            ProxyMapT &invalidated_mappings);
-
-    /** Invalidates (removes) mapping from forward and reverse maps.
-     * This method looks up <code>proxy</code> in the forward map and removes
-     * it, if it exists.  If mapping found in forward map, the corresponding
-     * mapping is also removed from the reverse map.  The removed mapping is
-     * added to <code>invalidated_mappings</code> with the hostname set to
-     * "--DELETED--".
-     * @param proxy Proxy name to invalidate
-     * @param invalidated_mappings Reference to ProxyMapT object to hold
-     * invalidated mapping.
-     */
-    void invalidate(const std::string &proxy, ProxyMapT &invalidated_mappings);
-
-    /// %Mutex for serializing concurrent access
-    std::mutex m_mutex;
-
-    /// Forward map from proxy name to ProxyAddressInfo
-    ProxyMapT m_forward_map;
-
-    /// Reverse map from IP address to proxy name
-    SockAddrMap<std::string> m_reverse_map;
-};
-
-} //namespace palo
-#endif //BDG_PALO_BE_SRC_RPC_PROXY_MAP_H
diff --git a/be/src/rpc/random.cpp b/be/src/rpc/random.cpp
deleted file mode 100644
index 69a46b09bc7550..00000000000000
--- a/be/src/rpc/random.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "random.h"
-
-#include <cassert>
-#include <mutex>
-#include <random>
-
-#define LOCK_GLOBAL_MUTEX(m) (void)m
-
-namespace palo {
-
-std::mt19937 g_random_engine {1};
-std::mutex g_random_mutex;
-
-void Random::seed(unsigned int s) {
-    LOCK_GLOBAL_MUTEX(g_random_mutex);
-    g_random_engine.seed(s);
-}
-
-uint32_t Random::number32(uint32_t maximum) {
-    LOCK_GLOBAL_MUTEX(g_random_mutex);
-    if (maximum) {
-        return std::uniform_int_distribution<uint32_t>(0, maximum-1)(g_random_engine);
-    }
-    return std::uniform_int_distribution<uint32_t>()(g_random_engine);
-}
-
-int64_t Random::number64(int64_t maximum) {
-    LOCK_GLOBAL_MUTEX(g_random_mutex);
-    if (maximum) {
-        assert(maximum > 0);
-        return std::uniform_int_distribution<int64_t>(0, maximum-1)(g_random_engine);
-    }
-    return std::uniform_int_distribution<int64_t>()(g_random_engine);
-}
-
-double Random::uniform01() {
-    LOCK_GLOBAL_MUTEX(g_random_mutex);
-    return std::uniform_real_distribution<>()(g_random_engine);
-}
-
-std::chrono::milliseconds Random::duration_millis(uint32_t maximum) {
-    LOCK_GLOBAL_MUTEX(g_random_mutex);
-    assert(maximum > 0);
-    std::uniform_int_distribution<uint32_t> di(0, maximum-1);
-    return std::chrono::milliseconds(di(g_random_engine));
-}
-
-}
diff --git a/be/src/rpc/random.h b/be/src/rpc/random.h
deleted file mode 100644
index b5b8e6d4214ca3..00000000000000
--- a/be/src/rpc/random.h
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_RANDOM_H
-#define BDG_PALO_BE_SRC_RPC_RANDOM_H
-
-#include <chrono>
-
-namespace palo {
-
-/// Convenience interface for random number and data generation.
-class Random {
-public:
-
-    /// Sets the seed of the random number generator.
-    /// @param s Seed value
-    static void seed(unsigned int s);
-
-    /// Returns a random 32-bit unsigned integer.
-    /// @return Random 32-bit integer in the range [0,<code>maximum</code>)
-    static uint32_t number32(uint32_t maximum = 0);
-
-    /// Returns a random 64-bit unsigned integer.
-    /// @return Random 64-bit integer in the range [0,<code>maximum</code>)
-    static int64_t number64(int64_t maximum = 0);
-
-    /// Returns a random double.
-    /// @return Random double in the range [0.0, 1.0)
-    static double uniform01();
-
-    /// Returns a random millisecond duration.
-    /// @return Random millisecond duration in the range [0,<code>maximum</code>)
-    static std::chrono::milliseconds duration_millis(uint32_t maximum);
-};
-
-} //namespace palo
-
-#endif //BDG_PALO_BE_SRC_RPC_RANDOM_H
diff --git a/be/src/rpc/raw_socket_handler.h b/be/src/rpc/raw_socket_handler.h
deleted file mode 100644
index 69c6777bc5fc3c..00000000000000
--- a/be/src/rpc/raw_socket_handler.h
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_RAW_SOCKET_HANDLER_H
-#define BDG_PALO_BE_SRC_RPC_RAW_SOCKET_HANDLER_H
-
-#include <string>
-
-namespace palo {
-
-/// Abstract base class for application raw socket handlers registered with
-/// AsyncComm.  Allows applications to register a socket with the AsyncComm
-/// polling mechanism and perform raw event handling on the socket.
-class RawSocketHandler {
-public:
-
-    /// Destructor
-    virtual ~RawSocketHandler() { return; }
-
-    /// Handle socket event.
-    /// @param sd Socket descriptor
-    /// @param events Bitmask of polling events
-    /// @see poll_event::Flags
-    virtual bool handle(int sd, int events) = 0;
-
-    /// Deregister handler for a given socket.
-    /// This method is called by the communication layer after the socket has
-    /// been removed from the polling mechanism.
-    /// @param sd Socket descripter that was deregistered
-    virtual void deregister(int sd) = 0;
-
-    /// Returns desired polling interest for a socket.
-    /// This method returns the current polling interest for socket
-    /// <code>sd</code>.  After calling handle(), the communication layer will
-    /// call this method to obtain the polling interest for <code>sd</code> and
-    /// will make the appropriate adjustments with the underlying polling
-    /// mechanism.
-    /// @param sd Socket descriptor 
-    /// @return Bitmask of desired polling interest for <code>sd</code>.
-    /// @see poll_event::Flags
-    virtual int poll_interest(int sd) = 0;
-};
-
-} // namespace palo
-#endif //BDG_PALO_BE_SRC_RPC_RAW_SOCKET_HANDLER_H
diff --git a/be/src/rpc/reactor.cpp b/be/src/rpc/reactor.cpp
deleted file mode 100644
index 80735e73d8febe..00000000000000
--- a/be/src/rpc/reactor.cpp
+++ /dev/null
@@ -1,251 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "io_handler_data.h"
-#include "reactor.h"
-#include "reactor_factory.h"
-#include "reactor_runner.h"
-#include "error.h"
-#include "file_utils.h"
-#include "common/logging.h"
-
-#include <cassert>
-#include <cstdio>
-#include <iostream>
-#include <set>
-
-extern "C" {
-#include <arpa/inet.h>
-#include <errno.h>
-#include <netinet/in.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/socket.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <fcntl.h>
-}
-
-namespace palo {
-
-Reactor::Reactor() {
-    struct sockaddr_in addr;
-    if ((epoll_fd = epoll_create(256)) < 0) {
-        perror("epoll_create");
-        exit(EXIT_FAILURE);
-    }
-    while (true) {
-        /**
-         * The following logic creates a UDP socket that is used to
-         * interrupt epoll_wait so that it can reset its timeout
-         * value
-         */
-        if ((m_interrupt_sd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
-            LOG(ERROR) << "socket() failure: %s" << strerror(errno);
-            exit(EXIT_FAILURE);
-        }
-        // Set to non-blocking (are we sure we should do this?)
-        FileUtils::set_flags(m_interrupt_sd, O_NONBLOCK);
-        // create address structure to bind to - any available port - any address
-        memset(&addr, 0, sizeof(sockaddr_in));
-        addr.sin_family = AF_INET;
-        addr.sin_addr.s_addr = inet_addr("127.0.0.1");
-        // Arbitray ephemeral port that won't conflict with our reserved ports
-        uint16_t port =
-            (uint16_t)(49152 + std::uniform_int_distribution<>(0, 16382)(ReactorFactory::rng));
-        addr.sin_port = htons(port);
-        // bind socket
-        if ((::bind(m_interrupt_sd, (sockaddr *)&addr, sizeof(sockaddr_in))) < 0) {
-            if (errno == EADDRINUSE) {
-                ::close(m_interrupt_sd);
-                continue;
-            }
-            LOG(ERROR) << "bind(%s) failure: %s" <<
-                       InetAddr::format(addr).c_str() << strerror(errno);
-        }
-        break;
-    }
-    // Connect to ourself
-    // NOTE: Here we assume that any error returned by connect implies
-    //       that it will be carried out asynchronously
-    if (connect(m_interrupt_sd, (sockaddr *)&addr, sizeof(addr)) < 0) {
-        LOG(INFO) << "connect(interrupt_sd) to port %d failed - %s" <<
-                  (int)ntohs(addr.sin_port) << strerror(errno);
-    }
-    if (ReactorFactory::ms_epollet) {
-        struct epoll_event event;
-        memset(&event, 0, sizeof(struct epoll_event));
-        event.events = EPOLLIN | EPOLLOUT | EPOLLRDHUP | EPOLLET;
-        if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, m_interrupt_sd, &event) < 0) {
-            LOG(ERROR) << "add events to epoll failed."
-                       << "[epollfd=" << epoll_fd << ", "
-                       << "socket=" << m_interrupt_sd << ", "
-                       << "events=" << event.events
-                       << "error=" <<  strerror(errno);
-            exit(EXIT_FAILURE);
-        }
-    }
-    else {
-        struct epoll_event event;
-        memset(&event, 0, sizeof(struct epoll_event));
-        if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, m_interrupt_sd, &event) < 0) {
-            LOG(ERROR) << "add events to epoll failed."
-                       << "[epollfd=" << epoll_fd << ", "
-                       << "socket=" << m_interrupt_sd << ", "
-                       << "events=" << event.events
-                       << "error=" <<  strerror(errno);
-            exit(EXIT_FAILURE);
-        }
-    }
-    m_next_wakeup = ClockT::time_point();
-}
-
-void Reactor::handle_timeouts(PollTimeout &next_timeout) {
-    std::vector<ExpireTimer> expired_timers;
-    EventPtr event;
-    ClockT::time_point now;
-    ClockT::time_point next_req_timeout;
-    ExpireTimer timer;
-    uint32_t header_id;
-    while (true) {
-        {
-            std::lock_guard<std::mutex> lock(m_mutex);
-            IOHandler *handler = 0;
-            DispatchHandlerPtr dhp;
-            now = ClockT::now();
-            while (m_request_cache.get_next_timeout(now, handler, dhp,
-                                                    &next_req_timeout, &header_id)) {
-                event = std::make_shared<Event>(
-                            Event::ERROR,
-                            ((IOHandlerData *)handler)->get_address(),
-                            error::REQUEST_TIMEOUT);
-                event->set_proxy(((IOHandlerData *)handler)->get_proxy());
-                event->header.id = header_id;
-                handler->deliver_event(event, dhp.get());
-            }
-            if (next_req_timeout != ClockT::time_point()) {
-                next_timeout.set(now, next_req_timeout);
-                m_next_wakeup = next_req_timeout;
-            } else {
-                next_timeout.set_indefinite();
-                m_next_wakeup = ClockT::time_point();
-            }
-            if (!m_timer_heap.empty()) {
-                ExpireTimer timer;
-                while (!m_timer_heap.empty()) {
-                    timer = m_timer_heap.top();
-                    if (timer.expire_time > now) {
-                        if (next_req_timeout == ClockT::time_point() ||
-                                timer.expire_time < next_req_timeout) {
-                            next_timeout.set(now, timer.expire_time);
-                            m_next_wakeup = timer.expire_time;
-                        }
-                        break;
-                    }
-                    expired_timers.push_back(timer);
-                    m_timer_heap.pop();
-                }
-            }
-        }
-        /**
-         * Deliver timer events
-         */
-        for (size_t i = 0; i < expired_timers.size(); i++) {
-            event = std::make_shared<Event>(Event::TIMER, error::OK);
-            if (expired_timers[i].handler) {
-                expired_timers[i].handler->handle(event);
-            }
-        }
-
-        {
-            std::lock_guard<std::mutex> lock(m_mutex);
-            if (!m_timer_heap.empty()) {
-                timer = m_timer_heap.top();
-                if (now > timer.expire_time) {
-                    continue;
-                }
-                if (next_req_timeout == ClockT::time_point()
-                        || timer.expire_time < next_req_timeout) {
-                    next_timeout.set(now, timer.expire_time);
-                    m_next_wakeup = timer.expire_time;
-                }
-            }
-            poll_loop_continue();
-        }
-        break;
-    }
-}
-
-int Reactor::poll_loop_interrupt() {
-    m_interrupt_in_progress = true;
-    if (ReactorFactory::ms_epollet) {
-        char buf[4];
-        ssize_t n = 0;
-        // Send and receive 1 byte to ourself to cause epoll_wait to return
-        if (FileUtils::send(m_interrupt_sd, "1", 1) < 0) {
-            LOG(ERROR) << "send message to socket failed."
-                       << "[socket=" << m_interrupt_sd << ", "
-                       << "[error=" << strerror(errno) << "]";
-            return error::COMM_SEND_ERROR;
-        }
-        if ((n = FileUtils::recv(m_interrupt_sd, buf, 1)) == -1) {
-            LOG(ERROR) << "recv message from socket failed."
-                       << "[socket=" << m_interrupt_sd << ", "
-                       << "[error=" << strerror(errno) << "]";
-            return error::COMM_RECEIVE_ERROR;
-        }
-    } else {
-        struct epoll_event event;
-        memset(&event, 0, sizeof(struct epoll_event));
-        event.events = EPOLLOUT;
-        if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, m_interrupt_sd, &event) < 0) {
-            LOG(ERROR) << "modify socket in epoll failed."
-                       << "[epoll_fd=" << epoll_fd << ","
-                       << "socket=" << m_interrupt_sd << ", "
-                       << "error=" << strerror(errno) << "]";
-            return error::COMM_POLL_ERROR;
-        }
-    }
-    return error::OK;
-}
-
-int Reactor::poll_loop_continue() {
-    if (!m_interrupt_in_progress) {
-        m_interrupt_in_progress = false;
-        return error::OK;
-    }
-    if (!ReactorFactory::ms_epollet) {
-        struct epoll_event event;
-        char buf[8];
-        // Receive message(s) we sent to ourself in poll_loop_interrupt()
-        while (FileUtils::recv(m_interrupt_sd, buf, 8) > 0) {}
-        memset(&event, 0, sizeof(struct epoll_event));
-        event.events = EPOLLERR | EPOLLHUP;
-        if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, m_interrupt_sd, &event) < 0) {
-            LOG(ERROR) << "epoll_ctl(EPOLL_CTL_MOD, sd=%d) : %s" << m_interrupt_sd <<
-                       strerror(errno);
-            return error::COMM_POLL_ERROR;
-        }
-    }
-    m_interrupt_in_progress = false;
-    return error::OK;
-}
-
-} //namespace palo
diff --git a/be/src/rpc/reactor.h b/be/src/rpc/reactor.h
deleted file mode 100644
index 974a67361af14c..00000000000000
--- a/be/src/rpc/reactor.h
+++ /dev/null
@@ -1,229 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_REACTOR_H
-#define BDG_PALO_BE_SRC_RPC_REACTOR_H
-
-#include "clock.h"
-#include "poll_timeout.h"
-#include "request_cache.h"
-#include "expire_timer.h"
-
-#include <boost/thread/thread.hpp>
-#include <memory>
-#include <mutex>
-#include <queue>
-#include <set>
-#include <vector>
-
-namespace palo {
-
-/** Manages reactor (polling thread) state including poll interest, request cache,
- * and timers.
- */
-class Reactor {
-
-friend class ReactorFactory;
-
-public:
-
-    /** Enumeration for reactor priority */
-    enum class Priority {
-        HIGH = 0, //< High
-        NORMAL    //< Normal
-    };
-
-    /** Constructor.
-     * Initializes polling interface and creates interrupt socket.
-     * If ReactorFactory::use_poll is set to <i>true</i>, then the reactor will
-     * use the POSIX <code>poll()</code> interface, otherwise <code>epoll</code>
-     * is used on Linux, <code>kqueue</code> on OSX and FreeBSD, and
-     * <code>port_associate</code> on Solaris.  For polling mechanisms that
-     * do not provide an interface for breaking out of the poll wait, a UDP
-     * socket #m_interrupt_sd is created (and connected to itself) and
-     * added to the poll set.
-     */
-    Reactor();
-
-    /** Destructor.
-    */
-    ~Reactor() {
-        poll_loop_interrupt();
-    }
-
-    /** Adds a request to request cache and adjusts poll timeout if necessary.
-     * @param id Request ID
-     * @param handler I/O handler with which request is associated
-     * @param dh Application dispatch handler for response MESSAGE events
-     * @param expire Absolute expiration time
-     */
-    void add_request(uint32_t id, IOHandler *handler, DispatchHandler *dh,
-            ClockT::time_point expire) {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        m_request_cache.insert(id, handler, dh, expire);
-        if (m_next_wakeup == ClockT::time_point() || expire < m_next_wakeup) {
-            poll_loop_interrupt();
-        }
-    }
-
-    /** Removes request associated with <code>id</code>
-     * @param id Request ID
-     * @param handler Removed dispatch handler
-     * @return <i>true</i> if request removed, <i>false</i> otherwise
-     */
-    bool remove_request(uint32_t id, DispatchHandlerPtr& handler) {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        return m_request_cache.remove(id, handler);
-    }
-
-    /** Cancels outstanding requests associated with <code>handler</code>
-     * @param handler I/O handler for which outstanding requests are to be
-     * cancelled
-     * @param error Error code to deliver with ERROR events
-     */
-    void cancel_requests(IOHandler *handler, int32_t error=error::COMM_BROKEN_CONNECTION) {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        m_request_cache.purge_requests(handler, error);
-    }
-
-    /** Adds a timer.
-     * Pushes timer onto #m_timer_heap and interrupts the polling loop so that
-     * the poll timeout can be adjusted if necessary.
-     * @param timer Reference to ExpireTimer object
-     */
-    void add_timer(ExpireTimer &timer) {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        m_timer_heap.push(timer);
-        poll_loop_interrupt();
-    }
-
-    /** Cancels timers associated with <code>handler</code>.
-     * @param handler Dispatch handler for which associated timers are to be
-     * cancelled
-     */
-    void cancel_timer(const DispatchHandlerPtr &handler) {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        typedef TimerHeap::container_type container_t;
-        container_t container;
-        container.reserve(m_timer_heap.size());
-        ExpireTimer timer;
-        while (!m_timer_heap.empty()) {
-            timer = m_timer_heap.top();
-            if (timer.handler.get() != handler.get()) {
-                container.push_back(timer);
-            }
-            m_timer_heap.pop();
-        }
-        for (const auto &t : container) {
-            m_timer_heap.push(t);
-        }
-    }
-
-    /** Schedules <code>handler</code> for removal.
-     * This method schedules an I/O handler for removal.  It should be called
-     * only when the handler has been decomissioned in the HandlerMap and when
-     * there are no outstanding references to the handler.  The handler is
-     * added to the #m_removed_handlers set and a timer is set for 200
-     * milliseconds in the future so that the ReactorRunner will wake up and
-     * complete the removal by removing it completely from the HandlerMap and
-     * delivering a DISCONNECT event if it is for a TCP socket.
-     * @param handler I/O handler to schedule for removal
-     */
-    void schedule_removal(IOHandler *handler) {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        m_removed_handlers.insert(handler);
-        ExpireTimer timer;
-        timer.expire_time = ClockT::now() + std::chrono::milliseconds(200);
-        timer.handler = 0;
-        m_timer_heap.push(timer);
-        poll_loop_interrupt();
-    }
-
-    /** Returns set of I/O handlers scheduled for removal.
-     * This is a one shot method adds the handlers that have been added to
-     * #m_removed_handlers and then clears the #m_removed_handlers set.
-     * @param dst reference to set filled in with removed handlers
-     */
-    void get_removed_handlers(std::set<IOHandler *> &dst) {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        dst = m_removed_handlers;
-        m_removed_handlers.clear();
-    }
-
-    /** Processes request timeouts and timers.
-     * This method removes timed out requests from the request cache, delivering
-     * ERROR events (with error == error::REQUEST_TIMEOUT) via each request's
-     * dispatch handler.  It also processes expired timers by removing them from
-     * #m_timer_heap and delivering a TIMEOUT event via the timer handler if
-     * it exsists.
-     * @param next_timeout Set to next earliest timeout of active requests and
-     * timers
-     */
-    void handle_timeouts(PollTimeout &next_timeout);
-
-    int epoll_fd;
-
-    /** Forces polling interface wait call to return.
-     * @return error::OK on success, or Error code on failure
-     */
-    int poll_loop_interrupt();
-
-    /** Reset state after call to #poll_loop_interrupt.
-     * After calling #poll_loop_interrupt and handling the interrupt, this
-     * method should be called to reset back to normal polling state.
-     * @return error::OK on success, or Error code on failure
-     */
-    int poll_loop_continue();
-
-    /** Returns interrupt socket.
-     * @return Interrupt socket
-     */
-    int interrupt_sd() { return m_interrupt_sd; }
-
-protected:
-
-    /** Priority queue for timers.
-    */
-    typedef std::priority_queue<ExpireTimer,
-            std::vector<ExpireTimer>, LtTimerHeap> TimerHeap;
-
-    std::mutex m_mutex;           //!< Mutex to protect members
-
-    RequestCache m_request_cache; //!< Request cache
-
-    TimerHeap m_timer_heap;       //!< ExpireTimer heap
-
-    int m_interrupt_sd;           //!< Interrupt socket
-
-    /// Set to <i>true</i> if poll loop interrupt in progress
-    bool m_interrupt_in_progress {};
-
-    /// Next polling interface wait timeout (absolute)
-    ClockT::time_point m_next_wakeup;
-
-    /// Set of IOHandler objects scheduled for removal
-    std::set<IOHandler *> m_removed_handlers;
-
-};
-
-/// Shared smart pointer to Reactor
-typedef std::shared_ptr<Reactor> ReactorPtr;
-
-} //namespace palo
-#endif //BDG_PALO_BE_SRC_RPC_REACTOR_H
diff --git a/be/src/rpc/reactor_factory.cpp b/be/src/rpc/reactor_factory.cpp
deleted file mode 100644
index 701838ac32c99b..00000000000000
--- a/be/src/rpc/reactor_factory.cpp
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "handler_map.h"
-#include "reactor_factory.h"
-#include "reactor_runner.h"
-
-#include <cassert>
-
-extern "C" {
-#include <signal.h>
-}
-
-namespace palo {
-
-std::vector<ReactorPtr> ReactorFactory::ms_reactors;
-boost::thread_group ReactorFactory::ms_threads;
-std::default_random_engine ReactorFactory::rng {1};
-std::mutex ReactorFactory::ms_mutex;
-std::atomic<int> ReactorFactory::ms_next_reactor(0);
-bool ReactorFactory::ms_epollet = true;
-bool ReactorFactory::proxy_master = false;
-
-void ReactorFactory::initialize(uint16_t reactor_count) {
-    std::lock_guard<std::mutex> lock(ms_mutex);
-    if (!ms_reactors.empty())
-        return;
-    ReactorPtr reactor;
-    ReactorRunner rrunner;
-    ReactorRunner::handler_map = std::make_shared<HandlerMap>();
-    signal(SIGPIPE, SIG_IGN);
-    assert(reactor_count > 0);
-    ms_reactors.reserve(reactor_count+2);
-    for (uint16_t i=0; i<reactor_count+2; i++) {
-        reactor = std::make_shared<Reactor>();
-        ms_reactors.push_back(reactor);
-        rrunner.set_reactor(reactor);
-        ms_threads.create_thread(rrunner);
-    }
-}
-
-void ReactorFactory::destroy() {
-    ReactorRunner::shutdown = true;
-    for (size_t i=0; i<ms_reactors.size(); i++) {
-        ms_reactors[i]->poll_loop_interrupt();
-    }
-    ms_threads.join_all();
-    ms_reactors.clear();
-    ReactorRunner::handler_map = 0;
-}
-
-void ReactorFactory::join() {
-    ms_threads.join_all();
-}
-
-} //namespace palo
diff --git a/be/src/rpc/reactor_factory.h b/be/src/rpc/reactor_factory.h
deleted file mode 100644
index fc6559a396715f..00000000000000
--- a/be/src/rpc/reactor_factory.h
+++ /dev/null
@@ -1,108 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_REACTOR_FACTORY_H
-#define BDG_PALO_BE_SRC_RPC_REACTOR_FACTORY_H
-
-#include "reactor.h"
-
-#include <boost/thread/thread.hpp>
-#include <atomic>
-#include <cassert>
-#include <mutex>
-#include <random>
-#include <set>
-#include <vector>
-
-namespace palo {
-
-/** Static class used to setup and manage I/O reactors.  Since the I/O reactor
- * threads are a process-wide resource, the methods of this class are static.
- */
-class ReactorFactory {
-public:
-
-    /** Initializes I/O reactors.  This method creates and initializes
-     * <code>reactor_count</code> reactors, plus an additional dedicated timer
-     * reactor.  It also initializes the #use_poll member based on the
-     * <code>Comm.UsePoll</code> property and sets the #ms_epollet
-     * ("edge triggered") flag to <i>false</i> if running on Linux version older
-     * than 2.6.17.  It also allocates a HandlerMap and initializes
-     * ReactorRunner::handler_map to point to it.
-     * @param reactor_count number of reactor threads to create
-     */
-    static void initialize(uint16_t reactor_count);
-
-    /** This method shuts down the reactors
-    */
-    static void destroy();
-
-    /// Joins with reactor threads
-    static void join();
-
-    /** This method returns the 'next' reactor.  It returns pointers to
-     * reactors in round-robin fashion and is used by the Comm subsystem to
-     * evenly distribute descriptors across all of the reactors.  The
-     * atomic integer variable #ms_next_reactor is used to keep track
-     * of the next reactor in the list.
-     * @param reactor Smart pointer reference to returned Reactor
-     */
-    static void get_reactor(ReactorPtr &reactor,
-            Reactor::Priority priority = Reactor::Priority::NORMAL) {
-        assert(ms_reactors.size() > 0);
-        if (priority == Reactor::Priority::HIGH)
-            reactor = ms_reactors.front();
-        else
-            reactor = ms_reactors[(ms_next_reactor++ % (ms_reactors.size()-2))+1];
-    }
-
-    /** This method returns the timer reactor.
-     * @param reactor Smart pointer reference to returned Reactor
-     */
-    static void get_timer_reactor(ReactorPtr &reactor) {
-        assert(ms_reactors.size() > 0);
-        reactor = ms_reactors.back();
-    }
-
-    /// Vector of reactors (last position is timer reactor)
-    static std::vector<ReactorPtr> ms_reactors;
-
-    /// Boost thread_group for managing reactor threads
-    static boost::thread_group ms_threads;
-
-    /// Pseudo random number generator
-    static std::default_random_engine rng;
-
-    /// Use "edge triggered" epoll
-    static bool ms_epollet;
-
-    /// Set to <i>true</i> if this process is acting as "Proxy Master"
-    static bool proxy_master;
-
-private:
-
-    /// Mutex to serialize calls to #initialize
-    static std::mutex ms_mutex;
-
-    /// Atomic integer used for round-robin assignment of reactors
-    static std::atomic<int> ms_next_reactor;
-};
-
-} //namespace palo
-#endif //BDG_PALO_BE_SRC_RPC_REACTOR_FACTORY_H
diff --git a/be/src/rpc/reactor_runner.cpp b/be/src/rpc/reactor_runner.cpp
deleted file mode 100644
index b15fd4fa1b66ab..00000000000000
--- a/be/src/rpc/reactor_runner.cpp
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "clock.h"
-#include "handler_map.h"
-#include "io_handler.h"
-#include "io_handler_data.h"
-#include "reactor_factory.h"
-#include "reactor_runner.h"
-#include "file_utils.h"
-
-#include "common/logging.h"
-#include <chrono>
-#include <thread>
-
-extern "C" {
-#include <errno.h>
-#include <poll.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <sys/types.h>
-#include <sys/time.h>
-}
-
-namespace palo {
-
-bool palo::ReactorRunner::shutdown = false;
-bool palo::ReactorRunner::record_arrival_time = false;
-HandlerMapPtr palo::ReactorRunner::handler_map;
-
-void ReactorRunner::operator()() {
-    int n = 0;
-    IOHandler *handler = 0;
-    std::set<IOHandler *> removed_handlers;
-    PollTimeout timeout;
-    bool did_delay = false;
-    ClockT::time_point arrival_time;
-    bool got_arrival_time = false;
-    std::vector<IOHandler*> handlers;
-    uint32_t dispatch_delay {};
-    struct epoll_event events[256];
-    while ((n = epoll_wait(m_reactor->epoll_fd, events, 256,
-                           timeout.get_millis())) >= 0 || errno == EINTR) {
-        if (record_arrival_time)
-            got_arrival_time = false;
-        if (dispatch_delay)
-            did_delay = false;
-        m_reactor->get_removed_handlers(removed_handlers);
-        if (!shutdown) {
-            VLOG(3) << "epoll_wait returned " << n << " events";
-        }
-        for (int i=0; i<n; i++) {
-            handler = (IOHandler *)events[i].data.ptr;
-            if (handler && removed_handlers.count(handler) == 0) {
-                // dispatch delay for testing
-                if (dispatch_delay && !did_delay && (events[i].events & EPOLLIN)) {
-                    std::this_thread::sleep_for(std::chrono::milliseconds((int)dispatch_delay));
-                    did_delay = true;
-                }
-                if (record_arrival_time && !got_arrival_time
-                        && (events[i].events & EPOLLIN)) {
-                    arrival_time = ClockT::now();
-                    got_arrival_time = true;
-                }
-                if (handler->handle_event(&events[i], arrival_time))
-                    removed_handlers.insert(handler);
-            }
-        }
-        if (!removed_handlers.empty()) {
-            cleanup_and_remove_handlers(removed_handlers);
-        }
-        m_reactor->handle_timeouts(timeout);
-        if (shutdown) {
-            return;
-        }
-    }
-    if (!shutdown) {
-        LOG(ERROR) << "epoll_wait " << m_reactor->epoll_fd << ","
-                   << "error: " << strerror(errno);
-    }
-}
-
-void
-ReactorRunner::cleanup_and_remove_handlers(std::set<IOHandler *> &handlers) {
-    for (auto handler : handlers) {
-        assert(handler);
-        if (!handler_map->destroy_ok(handler))
-            continue;
-        m_reactor->cancel_requests(handler);
-        struct epoll_event event;
-        memset(&event, 0, sizeof(struct epoll_event));
-        if (epoll_ctl(m_reactor->epoll_fd, EPOLL_CTL_DEL, handler->get_sd(), &event) < 0) {
-            if (!shutdown) {
-                LOG(ERROR) << "delete socket from epoll failed."
-                           << "[epoll_fd=" << m_reactor->epoll_fd << ","
-                           << "socket=" << handler->get_sd() << ", "
-                           << "error=" << strerror(errno) << "]";
-            }
-        }
-        handler_map->purge_handler(handler);
-    }
-}
-
-} //namespace palo
diff --git a/be/src/rpc/reactor_runner.h b/be/src/rpc/reactor_runner.h
deleted file mode 100644
index 762e065c85283b..00000000000000
--- a/be/src/rpc/reactor_runner.h
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_REACTOR_RUNNER_H
-#define BDG_PALO_BE_SRC_RPC_REACTOR_RUNNER_H
-
-#include "handler_map.h"
-#include "reactor.h"
-
-namespace palo {
-
-class IOHandler;
-
-/** Thread functor class for reacting to I/O events.
- * The AsyncComm layer is initialized with some number of <i>reactor</i>
- * threads (see ReactorFactory#initialize).  The ReactorRunner class
- * acts as the thread function for these reactor threads.  The primary
- * function of a reactor thread is to wait for I/O events (e.g. read/write
- * readiness) to occur on a set of registered socket descriptors and then
- * call into the associated IOHandler objects to handle the I/O events.
- * It also handles cleanup and removal of sockets that have been disconnected.
- */
-class ReactorRunner {
-public:
-
-    /** Primary thread entry point */
-    void operator()();
-
-    /** Assocates reactor state object with this ReactorRunner.
-     * @param reactor Reference to smart pointer to reactor state object
-     */
-    void set_reactor(ReactorPtr &reactor) { m_reactor = reactor; }
-
-    /// Flag indicating that reactor thread is being shut down
-    static bool shutdown;
-
-    /// If set to <i>true</i> arrival time is recorded and passed into
-    /// IOHandler#handle
-    static bool record_arrival_time;
-
-    /// Smart pointer to HandlerMap
-    static HandlerMapPtr handler_map;
-
-private:
-
-    /** Cleans up and removes a set of handlers.
-     * For each handler in <code>handlers</code>, this method destroys
-     * the handler in the HandlerMap, cancels any outstanding requests
-     * on the handler, removes polling interest from polling mechanism,
-     * an purges the handler from the HandlerMap.
-     * @param handlers Set of IOHandlers to remove
-     */
-    void cleanup_and_remove_handlers(std::set<IOHandler *> &handlers);
-
-    ReactorPtr m_reactor; //!< Smart pointer to reactor state object
-};
-
-} //namespace palo
-#endif //BDG_PALO_BE_SRC_RPC_REACTOR_RUNNER_H
diff --git a/be/src/rpc/request_cache.cpp b/be/src/rpc/request_cache.cpp
deleted file mode 100644
index 7082b7d26ec7c9..00000000000000
--- a/be/src/rpc/request_cache.cpp
+++ /dev/null
@@ -1,124 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "common/logging.h"
-#include "io_handler_data.h"
-#include "request_cache.h"
-
-#include <cassert>
-
-namespace palo {
-
-void
-RequestCache::insert(uint32_t id, IOHandler *handler, DispatchHandler *dh,
-                     ClockT::time_point &expire) {
-    VLOG(3) << "Adding id %d" << id;
-    assert(m_id_map.find(id) == m_id_map.end());
-    CacheNode *node = new CacheNode(id, handler, dh);
-    node->expire = expire;
-    if (m_head == 0) {
-        node->next = node->prev = 0;
-        m_head = m_tail = node;
-    }
-    else {
-        node->next = m_tail;
-        node->next->prev = node;
-        node->prev = 0;
-        m_tail = node;
-    }
-    m_id_map[id] = node;
-}
-
-bool RequestCache::remove(uint32_t id, DispatchHandlerPtr& handler) {
-    VLOG(3) << "remove request_id from request_cache. [request_id=" << id << "]";
-    IdHandlerMap::iterator iter = m_id_map.find(id);
-    if (iter == m_id_map.end()) {
-        VLOG(3) << "request_id not found in request cache"
-                << "[request_id=" << id << "]";
-        return false;
-    }
-    CacheNode *node = (*iter).second;
-    if (node->prev == 0) {
-        m_tail = node->next;
-    } else {
-        node->prev->next = node->next;
-    }
-
-    if (node->next == 0) {
-        m_head = node->prev;
-    } else {
-        node->next->prev = node->prev;
-    }
-    m_id_map.erase(iter);
-    handler = node->dhp;
-    delete node;
-    return true;
-}
-
-bool RequestCache::get_next_timeout(ClockT::time_point &now, IOHandler *&handlerp,
-                                    DispatchHandlerPtr& dhp,
-                                    ClockT::time_point *next_timeout, uint32_t* header_id) {
-    bool handler_removed = false;
-    while (m_head && !handler_removed && m_head->expire <= now) {
-        IdHandlerMap::iterator iter = m_id_map.find(m_head->id);
-        assert(iter != m_id_map.end());
-        CacheNode *node = m_head;
-        if (m_head->prev) {
-            m_head = m_head->prev;
-            m_head->next = 0;
-        }
-        else
-            m_head = m_tail = 0;
-        m_id_map.erase(iter);
-        if (node->handler != 0) {
-            handlerp = node->handler;
-            dhp = node->dhp;
-            *header_id = node->id;
-            handler_removed = true;
-        }
-        delete node;
-    }
-    if (m_head) {
-        *next_timeout = m_head->expire;
-    } else {
-        *next_timeout = ClockT::time_point();
-    }
-    return handler_removed;
-}
-
-void RequestCache::purge_requests(IOHandler *handler, int32_t error) {
-    for (CacheNode *node = m_tail; node != 0; node = node->next) {
-        if (node->handler == handler) {
-            std::string proxy = handler->get_proxy();
-            EventPtr event;
-            VLOG(3) << "purging request id from request cache."
-                    << "[request_id=" << node->id << "]";
-            if (proxy.empty()) {
-                event = std::make_shared<Event>(Event::ERROR, handler->get_address(), error);
-            } else {
-                event = std::make_shared<Event>(Event::ERROR, handler->get_address(), proxy, error);
-            }
-            handler->deliver_event(event, node->dhp.get());
-            node->handler = 0;  // mark for deletion
-        }
-    }
-}
-
-} //nemespace palo
diff --git a/be/src/rpc/request_cache.h b/be/src/rpc/request_cache.h
deleted file mode 100644
index 90973cf8f55075..00000000000000
--- a/be/src/rpc/request_cache.h
+++ /dev/null
@@ -1,124 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_REQUEST_CACHE_H
-#define BDG_PALO_BE_SRC_RPC_REQUEST_CACHE_H
-
-#include "clock.h"
-
-#include "dispatch_handler.h"
-#include <unordered_map>
-
-namespace palo {
-
-class IOHandler;
-
-/** Class used to hold pending request callback handlers.  One RequestCache object is
- * associated with each Reactor.  When a request is sent (see Comm#send_request)
- * an entry, which includes the response handler, is inserted into the
- * RequestCache.  When the corresponding response is receive, the response
- * handler is obtained by looking up the corresponding request ID in this cache.
- */
-class RequestCache {
-
-    /** Internal cache node structure.
-    */
-    class CacheNode {
-    public:
-        CacheNode(uint32_t id, IOHandler *handler, DispatchHandler *dh)
-                : id(id), handler(handler) {
-            if (dh != nullptr) {
-                dhp = dh->shared_from_this();
-            }
-        }
-        ~CacheNode() {}
-        CacheNode* prev;            //!< Doubly-linked list prev pointers
-        CacheNode* next;            //!< Doubly-linked list next pointers
-        ClockT::time_point expire;  //!< Absolute expiration time
-        uint32_t           id;      //!< Request ID
-        IOHandler         *handler; //!< IOHandler associated with this request
-        /// Callback handler to which MESSAGE, TIMEOUT, ERROR, and DISCONNECT
-        /// events are delivered
-        DispatchHandlerPtr dhp;
-    };
-
-    /// RequestID-to-CacheNode map
-    typedef std::unordered_map<uint32_t, CacheNode *> IdHandlerMap;
-
-public:
-
-    /// Constructor.
-    RequestCache() { }
-
-    /** Inserts pending request callback handler into cache.
-     * @param id Request ID
-     * @param handler IOHandler associated with
-     * @param dh Callback handler to which MESSAGE, TIMEOUT, DISCONNECT events
-     * are delivered
-     * @param expire Absolute expiration time of request
-     */
-    void insert(uint32_t id, IOHandler *handler, DispatchHandler *dh,
-                ClockT::time_point &expire);
-
-    /** Removes a request from the cache.
-     * @param id Request ID
-     * @param handler Removed dispatch handler
-     * @return <i>true</i> if removed, <i>false</i> if not found
-     */
-    bool remove(uint32_t id, DispatchHandlerPtr &handler);
-
-    /** Removes next request that has timed out.  This method finds the first
-     * request starting from the head of the list and removes it and returns
-     * it's associated handler information if it has timed out.  During the
-     * search, it physically removes any cache nodes corresponding to requests
-     * that have been purged.
-     * @param now Current time
-     * @param handlerp Return parameter to hold pointer to associated IOHandler
-     *                 of timed out request
-     * @param dh Removed dispatch handler
-     * @param next_timeout Pointer to variable to hold expiration time
-     * of next request <b>after</b> timed out request, set to 0 if cache is empty
-     * @return <i>true</i> if pointer to timed out dispatch handler was removed,
-     * <i>false</i> otherwise
-     */
-    bool get_next_timeout(ClockT::time_point &now, IOHandler *&handlerp,
-                          DispatchHandlerPtr& dhp,
-                          ClockT::time_point *next_timeout, uint32_t* header_id);
-
-    /** Purges all requests assocated with <code>handler</code>.  This
-     * method walks the entire cache and purges all requests whose
-     * handler is equal to <code>handler</code>.  For each purged
-     * request, an ERROR event with error code <code>error</code> is
-     * delivered via the request's dispatch handler.
-     * @param handler IOHandler of requests to purge
-     * @param error Error code to be delivered with ERROR event
-     */
-    void purge_requests(IOHandler *handler, int32_t error);
-
-private:
-
-    IdHandlerMap m_id_map; //!< RequestID-to-CacheNode map
-
-    CacheNode *m_head {};  //!< Head of doubly-linked list
-
-    CacheNode *m_tail {};  //!< Tail of doubly-linked list
-};
-
-} //namespace palo
-#endif //BDG_PALO_BE_SRC_RPC_REQUEST_CACHE_H
diff --git a/be/src/rpc/response_callback.cpp b/be/src/rpc/response_callback.cpp
deleted file mode 100644
index 24de3c5430ed15..00000000000000
--- a/be/src/rpc/response_callback.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "comm_buf.h"
-#include "comm_header.h"
-#include "protocol.h"
-#include "response_callback.h"
-#include "error.h"
-
-#include <limits>
-
-namespace palo {
-
-int ResponseCallback::error(int error, const std::string& msg) {
-    CommHeader header;
-    header.initialize_from_request_header(m_event->header);
-    CommBufPtr cbp;
-    size_t max_msg_size = std::numeric_limits<int16_t>::max();
-    if (msg.length() < max_msg_size) {
-        cbp = Protocol::create_error_message(header, error, msg.c_str());
-    } else {
-        cbp = Protocol::create_error_message(header, error, msg.substr(0, max_msg_size).c_str());
-    }
-    return m_comm->send_response(m_event->addr, cbp);
-}
-
-int ResponseCallback::response_ok() {
-    CommHeader header;
-    header.initialize_from_request_header(m_event->header);
-    CommBufPtr cbp(new CommBuf(header, 4));
-    cbp->append_i32(error::OK);
-    return m_comm->send_response(m_event->addr, cbp);
-}
-
-} //namespace palo
diff --git a/be/src/rpc/response_callback.h b/be/src/rpc/response_callback.h
deleted file mode 100644
index c5ea9c9ad2120b..00000000000000
--- a/be/src/rpc/response_callback.h
+++ /dev/null
@@ -1,97 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_RESPONSE_CALLBACK_H
-#define BDG_PALO_BE_SRC_RPC_RESPONSE_CALLBACK_H
-
-#include "util.h"
-#include "comm.h"
-#include "event.h"
-
-namespace palo {
-
-/** This class is used to generate and deliver standard responses back to a
- * client.
- */
-class ResponseCallback {
-public:
-
-    /** Constructor. Initializes a pointer to the Comm object and saves a
-     * pointer to the event that triggered the request.
-     *
-     * @param comm Pointer to the Comm object
-     * @param event Smart pointer to the event that generated the request
-     */
-    ResponseCallback(Comm *comm, EventPtr &event)
-        : m_comm(comm), m_event(event) { return; }
-
-    /** Default constructor.
-    */
-    ResponseCallback() : m_comm(0), m_event(0) { return; }
-
-    /** Destructor */
-    virtual ~ResponseCallback() { return; }
-
-    /** Sends a standard error response back to the client.  The response message
-     * that is generated and sent back has the following format:
-     * <pre>
-     *   [int32] error code
-     *   [int16] error message length
-     *   [chars] error message
-     * </pre>
-     * @param error %Error code
-     * @param msg %Error message
-     * @return error::OK on success or error code on failure
-     */
-    virtual int error(int error, const std::string &msg);
-
-    /** Sends a a simple success response back to the client which is just
-     * the 4-byte error code error::OK.  This can be used to signal success
-     * for all methods that don't have return values.
-     * @return error::OK on success or error code on failure
-     */
-    virtual int response_ok();
-
-    /** Gets the remote address of the requesting client.
-     * @param addr Reference to address structure to hold result
-     */
-    void get_address(struct sockaddr_in &addr) {
-        memcpy(&addr, &m_event->addr, sizeof(addr));
-    }
-
-    /** Gets the remote address of the requesting client.
-     * @return Remote address
-     */
-    const InetAddr get_address() const {
-        return m_event->addr;
-    }
-
-    /** Get smart pointer to event object that triggered the request.
-     * @return Smart pointer to event object that triggered the request.
-     */
-    EventPtr &event() { return m_event; }
-
-protected:
-
-    Comm     *m_comm; //!< Comm pointer
-    EventPtr m_event; //!< Smart pointer to event object
-};
-
-} // namespace palo
-#endif // BDG_PALO_BE_SRC_RPC_RESPONSE_CALLBACK_H
diff --git a/be/src/rpc/scope_guard.h b/be/src/rpc/scope_guard.h
deleted file mode 100644
index 29151b25775191..00000000000000
--- a/be/src/rpc/scope_guard.h
+++ /dev/null
@@ -1,283 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_SCOPE_GUARD_H
-#define BDG_PALO_BE_SRC_RPC_SCOPE_GUARD_H
-
-namespace palo {
-
-/** Base class for the ScopeGuards */
-class ScopeGuardImplBase {
-protected:
-    ~ScopeGuardImplBase() { }
-
-    ScopeGuardImplBase(const ScopeGuardImplBase& other) throw()
-        : m_dismissed(other.m_dismissed) {
-            other.dismiss();
-        }
-
-    template <typename GuardT>
-        static void safe_run(GuardT& guard) throw() {
-            if (!guard.m_dismissed) {
-                try {
-                    guard.run();
-                } catch (...) {}
-            }
-        }
-
-public:
-
-    ScopeGuardImplBase() throw() : m_dismissed(false) { }
-    void dismiss() const throw() { m_dismissed = true; }
-
-private:
-
-    ScopeGuardImplBase& operator=(const ScopeGuardImplBase&); // not assignable
-    mutable bool m_dismissed;
-};
-
-/*
- * According to the C++ standard, a reference initialized with a temporary
- * value makes that temporary value live for the lifetime of the reference
- * itself. This can save us from having to explicitly instantiate the guards
- * with long type parameters
- */
-typedef const ScopeGuardImplBase &ScopeGuard;
-
-/**
- * ScopeGuard implementation for free function with no paramter
- */
-template <typename FunT>
-class ScopeGuardImpl0 : public ScopeGuardImplBase {
-public:
-
-    static ScopeGuardImpl0<FunT> make_guard(FunT fun) {
-        return ScopeGuardImpl0<FunT>(fun);
-    }
-
-    ~ScopeGuardImpl0() throw() { safe_run(*this); }
-
-    void run() { m_fun(); }
-
-private:
-
-    ScopeGuardImpl0(FunT fun) : m_fun(fun) { }
-    FunT m_fun;
-};
-
-template <typename FunT>
-inline ScopeGuardImpl0<FunT> make_guard(FunT fun) {
-    return ScopeGuardImpl0<FunT>::make_guard(fun);
-}
-
-/**
- * ScopeGuard implementation for free function with 1 parameter
- */
-template <typename FunT, typename P1T>
-class ScopeGuardImpl1 : public ScopeGuardImplBase {
-    public:
-        static ScopeGuardImpl1<FunT, P1T> make_guard(FunT fun, P1T p1) {
-            return ScopeGuardImpl1<FunT, P1T>(fun, p1);
-        }
-        ~ScopeGuardImpl1() throw() { safe_run(*this); }
-        void run() { m_fun(m_p1); }
-    private:
-        ScopeGuardImpl1(FunT fun, P1T p1) : m_fun(fun), m_p1(p1) { }
-        FunT m_fun;
-        const P1T m_p1;
-};
-
-template <typename FunT, typename P1T>
-inline ScopeGuardImpl1<FunT, P1T> make_guard(FunT fun, P1T p1) {
-    return ScopeGuardImpl1<FunT, P1T>::make_guard(fun, p1);
-}
-
-/**
- * ScopeGuard implementation for free function with 2 parameters
- */
-template <typename FunT, typename P1T, typename P2T>
-class ScopeGuardImpl2: public ScopeGuardImplBase {
-    public:
-        static ScopeGuardImpl2<FunT, P1T, P2T> make_guard(FunT fun, P1T p1, P2T p2) {
-            return ScopeGuardImpl2<FunT, P1T, P2T>(fun, p1, p2);
-        }
-        ~ScopeGuardImpl2() throw() { safe_run(*this); }
-        void run() { m_fun(m_p1, m_p2); }
-    private:
-        ScopeGuardImpl2(FunT fun, P1T p1, P2T p2) : m_fun(fun), m_p1(p1), m_p2(p2) { }
-        FunT m_fun;
-        const P1T m_p1;
-        const P2T m_p2;
-};
-
-template <typename FunT, typename P1T, typename P2T>
-inline ScopeGuardImpl2<FunT, P1T, P2T> make_guard(FunT fun, P1T p1, P2T p2) {
-    return ScopeGuardImpl2<FunT, P1T, P2T>::make_guard(fun, p1, p2);
-}
-
-/**
- * ScopeGuard implementation for free function with 3 parameters
- */
-template <typename FunT, typename P1T, typename P2T, typename P3T>
-class ScopeGuardImpl3 : public ScopeGuardImplBase {
-    public:
-        static ScopeGuardImpl3<FunT, P1T, P2T, P3T>
-            make_guard(FunT fun, P1T p1, P2T p2, P3T p3) {
-                return ScopeGuardImpl3<FunT, P1T, P2T, P3T>(fun, p1, p2, p3);
-            }
-        ~ScopeGuardImpl3() throw() { safe_run(*this); }
-        void run() { m_fun(m_p1, m_p2, m_p3); }
-    private:
-        ScopeGuardImpl3(FunT fun, P1T p1, P2T p2, P3T p3)
-            : m_fun(fun), m_p1(p1), m_p2(p2), m_p3(p3) { }
-        FunT m_fun;
-        const P1T m_p1;
-        const P2T m_p2;
-        const P3T m_p3;
-};
-
-template <typename FunT, typename P1T, typename P2T, typename P3T>
-inline ScopeGuardImpl3<FunT, P1T, P2T, P3T>
-make_guard(FunT fun, P1T p1, P2T p2, P3T p3) {
-    return ScopeGuardImpl3<FunT, P1T, P2T, P3T>::make_guard(fun, p1, p2, p3);
-}
-
-/**
- * ScopeGuard implementation for method with no parameter
- */
-template <class ObjT, typename MethodT>
-class ObjScopeGuardImpl0 : public ScopeGuardImplBase {
-    public:
-        static ObjScopeGuardImpl0<ObjT, MethodT>
-            make_obj_guard(ObjT &obj, MethodT method) {
-                return ObjScopeGuardImpl0<ObjT, MethodT>(obj, method);
-            }
-        ~ObjScopeGuardImpl0() throw() { safe_run(*this); }
-        void run() { (m_obj.*m_method)(); }
-    private:
-        ObjScopeGuardImpl0(ObjT &obj, MethodT method)
-            : m_obj(obj), m_method(method) { }
-        ObjT &m_obj;
-        MethodT m_method;
-};
-
-template <class ObjT, typename MethodT>
-inline ObjScopeGuardImpl0<ObjT, MethodT>
-make_obj_guard(ObjT &obj, MethodT method) {
-    return ObjScopeGuardImpl0<ObjT, MethodT>::make_obj_guard(obj, method);
-}
-
-/**
- * ScopeGuard implementation for method with 1 parameter
- */
-template <class ObjT, typename MethodT, typename P1T>
-class ObjScopeGuardImpl1 : public ScopeGuardImplBase {
-    public:
-        static ObjScopeGuardImpl1<ObjT, MethodT, P1T>
-            make_obj_guard(ObjT &obj, MethodT method, P1T p1) {
-                return ObjScopeGuardImpl1<ObjT, MethodT, P1T>(obj, method, p1);
-            }
-        ~ObjScopeGuardImpl1() throw() { safe_run(*this); }
-        void run() { (m_obj.*m_method)(m_p1); }
-    protected:
-        ObjScopeGuardImpl1(ObjT &obj, MethodT method, P1T p1)
-            : m_obj(obj), m_method(method), m_p1(p1) { }
-        ObjT &m_obj;
-        MethodT m_method;
-        const P1T m_p1;
-};
-
-template <class ObjT, typename MethodT, typename P1T>
-inline ObjScopeGuardImpl1<ObjT, MethodT, P1T>
-make_obj_guard(ObjT &obj, MethodT method, P1T p1) {
-    return ObjScopeGuardImpl1<ObjT, MethodT, P1T>::make_obj_guard(obj, method, p1);
-}
-
-/**
- * ScopeGuard implementation for method with 2 parameters
- */
-template <class ObjT, typename MethodT, typename P1T, typename P2T>
-class ObjScopeGuardImpl2 : public ScopeGuardImplBase {
-    public:
-        static ObjScopeGuardImpl2<ObjT, MethodT, P1T, P2T>
-            make_obj_guard(ObjT &obj, MethodT method, P1T p1, P2T p2) {
-                return ObjScopeGuardImpl2<ObjT, MethodT, P1T, P2T>(obj, method, p1, p2);
-            }
-        ~ObjScopeGuardImpl2() throw() { safe_run(*this); }
-        void run() { (m_obj.*m_method)(m_p1, m_p2); }
-    private:
-        ObjScopeGuardImpl2(ObjT &obj, MethodT method, P1T p1, P2T p2)
-            : m_obj(obj), m_method(method), m_p1(p1), m_p2(p2) { }
-        ObjT &m_obj;
-        MethodT m_method;
-        const P1T m_p1;
-        const P2T m_p2;
-};
-
-template <class ObjT, typename MethodT, typename P1T, typename P2T>
-inline ObjScopeGuardImpl2<ObjT, MethodT, P1T, P2T>
-make_obj_guard(ObjT &obj, MethodT method, P1T p1, P2T p2) {
-    return ObjScopeGuardImpl2<ObjT, MethodT, P1T, P2T>::make_obj_guard(obj,
-            method, p1, p2);
-}
-
-/**
- * Helper class used to pass a parameter to the ScopeGuard by reference.
- *
- * e.g.:
- *     inline void decr(int &x) { --x; }
- *
- *     void example() {
- *       int i = 0;
- *       ScopedGuard guard = make_guard(decr, by_ref(i));
- *       // ...
- *     }
- */
-template <class T>
-class RefHolder {
-    public:
-        RefHolder(T& ref) : m_ref(ref) {}
-        operator T& () const { return m_ref; }
-    private:
-        RefHolder& operator=(const RefHolder&); // not assignable
-        T& m_ref;
-};
-
-template <class T>
-inline RefHolder<T> by_ref(T& t) {
-    return RefHolder<T>(t);
-}
-
-} // namespace palo
-
-// The two level macros are needed for var<lineno>.
-// Otherwise, it'd be literally var__LINE__
-#define HT_CONCAT_(s1, s2) s1##s2
-#define HT_CONCAT(s1, s2) HT_CONCAT_(s1, s2)
-#define HT_AUTO_VAR(var) HT_CONCAT(var, __LINE__)
-
-#define HT_ON_SCOPE_EXIT(...) \
-    ScopeGuard HT_AUTO_VAR(guard) = make_guard(__VA_ARGS__); \
-HT_UNUSED(HT_AUTO_VAR(guard))
-
-#define HT_ON_OBJ_SCOPE_EXIT(...) \
-    ScopeGuard HT_AUTO_VAR(guard) = make_obj_guard(__VA_ARGS__); \
-HT_UNUSED(HT_AUTO_VAR(guard))
-
-#endif //BDG_PALO_BE_SRC_RPC_SCOPE_GUARD_H
diff --git a/be/src/rpc/serialization.h b/be/src/rpc/serialization.h
deleted file mode 100644
index 680ab3619786b6..00000000000000
--- a/be/src/rpc/serialization.h
+++ /dev/null
@@ -1,599 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_SERIALIZATION_H
-#define BDG_PALO_BE_SRC_RPC_SERIALIZATION_H
-
-#include "inet_addr.h"
-#include "serialization_c.h"
-
-namespace palo { namespace serialization {
-    /**
-     * Encodes a byte into the given buffer.  Assumes there is
-     * enough space available.  Increments buffer pointer.
-     *
-     * @param bufp Address of the destination buffer
-     * @param val The byte
-     */
-    inline void encode_i8(uint8_t **bufp, uint8_t val) {
-        HT_ENCODE_I8(*bufp, val);
-    }
-
-    /**
-     * Decode a 8-bit integer (a byte/character)
-     *
-     * @param bufp The pointer to the source buffer
-     * @param remainp The pointer to the remaining size variable
-     * @return The decoded value
-     */
-    inline uint8_t decode_i8(const uint8_t **bufp, size_t *remainp) {
-        HT_DECODE_NEED(*remainp, 1);
-        return *(*bufp)++;
-    }
-
-    /**
-     * Decodes a single byte from the given buffer. Increments buffer pointer
-     * and decrements remainp on success.
-     *
-     * @param bufp Pointer to the source buffer pointer
-     * @param remainp Pointer to the number of bytes remaining in buffer
-     * @return The byte value
-     */
-    inline uint8_t decode_byte(const uint8_t **bufp, size_t *remainp) {
-        return decode_i8(bufp, remainp);
-    }
-
-    /**
-     * Encodes a boolean into the given buffer.  Assumes there is
-     * enough space available.  Increments buffer pointer.
-     *
-     * @param bufp Address of the destination buffer
-     * @param bval The boolean value
-     */
-    inline void encode_bool(uint8_t **bufp, bool bval) {
-        HT_ENCODE_BOOL(*bufp, bval);
-    }
-
-    /**
-     * Decodes a boolean value from the given buffer. Increments buffer pointer
-     * and decrements remainp on success.
-     *
-     * @param bufp Pointer to the source buffer pointer
-     * @param remainp Pointer to number of bytes remaining in buffer
-     * @return The boolean value
-     */
-    inline bool decode_bool(const uint8_t **bufp, size_t *remainp) {
-        return decode_i8(bufp, remainp) != 0;
-    }
-
-    /**
-     * Encode a 16-bit integer in little-endian order
-     *
-     * @param bufp Pointer to the destination buffer
-     * @param val The value to encode
-     */
-    inline void encode_i16(uint8_t **bufp, uint16_t val) {
-        HT_ENCODE_I16(*bufp, val);
-    }
-
-    /**
-     * Decode a 16-bit integer in little-endian order
-     *
-     * @param bufp Pointer to the source buffer pointer
-     * @param remainp Pointer to the remaining size variable
-     * @return The decoded value
-     */
-    inline uint16_t decode_i16(const uint8_t **bufp, size_t *remainp) {
-        uint16_t val;
-        HT_DECODE_I16(*bufp, *remainp, val);
-        return val;
-    }
-
-    /**
-     * Encode a 32-bit integer in little-endian order
-     *
-     * @param bufp Pointer to the destination buffer pointer
-     * @param val The value to encode
-     */
-    inline void encode_i32(uint8_t **bufp, uint32_t val) {
-        HT_ENCODE_I32(*bufp, val);
-    }
-
-    /**
-     * Decode a 32-bit integer in little-endian order
-     *
-     * @param bufp Pointer to the source buffer pointer
-     * @param remainp Pointer to the remaining size variable
-     * @return The decoded value
-     */
-    inline uint32_t decode_i32(const uint8_t **bufp, size_t *remainp) {
-        uint32_t val;
-        HT_DECODE_I32(*bufp, *remainp, val);
-        return val;
-    }
-
-    /**
-     * Encode a 64-bit integer in little-endian order
-     *
-     * @param bufp Pointer to the destination buffer pointer
-     * @param val The value to encode
-     */
-    inline void encode_i64(uint8_t **bufp, uint64_t val) {
-        HT_ENCODE_I64(*bufp, val);
-    }
-
-    /**
-     * Decode a 64-bit integer in little-endian order
-     *
-     * @param bufp Pointer to the source buffer pointer
-     * @param remainp Pointer to the remaining size variable
-     * @return The decoded value
-     */
-    inline uint64_t decode_i64(const uint8_t **bufp, size_t *remainp) {
-        uint64_t val;
-        HT_DECODE_I64(*bufp, *remainp, val);
-        return val;
-    }
-
-    /**
-     * Length of a variable length encoded 32-bit integer (up to 5 bytes)
-     *
-     * @param val The 32-bit integer to encode
-     * @return The number of bytes required for serializing this number
-     */
-    inline int encoded_length_vi32(uint32_t val) {
-        return HT_ENCODED_LEN_VI32(val);
-    }
-
-    /**
-     * Length of a variable length encoded 64-bit integer (up to 9 bytes)
-     *
-     * @param val The 64-bit integer to encode
-     * @return The number of bytes required for serializing this number
-     */
-    inline int encoded_length_vi64(uint64_t val) {
-        return HT_ENCODED_LEN_VI64(val);
-    }
-
-    /**
-     * Encode a integer (up to 32-bit) in variable length encoding
-     *
-     * @param bufp Pointer to the destination buffer pointer
-     * @param val The value to encode
-     */
-    inline void encode_vi32(uint8_t **bufp, uint32_t val) {
-        HT_ENCODE_VI32(*bufp, val, return);
-    }
-
-    /**
-     * Encode a integer (up to 64-bit) in variable length encoding
-     *
-     * @param bufp The pointer to the destination buffer pointer
-     * @param val The value to encode
-     */
-    inline void encode_vi64(uint8_t **bufp, uint64_t val) {
-        HT_ENCODE_VI64(*bufp, val, return);
-    }
-
-    /**
-     * Decode a variable length encoded integer up to 32-bit
-     *
-     * @param bufp Pointer to the source buffer pointer
-     * @param remainp Pointer to the remaining size variable
-     * @return The decoded value
-     */
-    inline uint32_t decode_vi32(const uint8_t **bufp, size_t *remainp) {
-        uint32_t n;
-        HT_DECODE_VI32(*bufp, *remainp, n, return n);
-    }
-
-    /**
-     * Decode a variable length encoded integer up to 64-bit
-     *
-     * @param bufp Pointer to the source buffer pointer
-     * @param remainp Pointer to the remaining size variable
-     * @return The decoded value
-     */
-    inline uint64_t decode_vi64(const uint8_t **bufp, size_t *remainp) {
-        uint64_t n;
-        HT_DECODE_VI64(*bufp, *remainp, n, return n);
-    }
-
-    /**
-     * Decode a variable length encoded integer up to 32-bit
-     *
-     * @param bufp Pointer to the source buffer pointer
-     * @return The decoded value
-     */
-    inline uint32_t decode_vi32(const uint8_t **bufp) {
-        size_t remain = 6;
-        return decode_vi32(bufp, &remain);
-    }
-
-    /**
-     * Decode a variable length encoded integer up to 64-bit
-     *
-     * @param bufp Pointer to the source buffer pointer
-     * @return The decoded value
-     */
-    inline uint64_t decode_vi64(const uint8_t **bufp) {
-        size_t remain = 12;
-        return decode_vi64(bufp, &remain);
-    }
-
-    /**
-     * Computes the encoded length of a 32-bit length byte array (i32, bytes)
-     *
-     * @param len Length of the byte array to be encoded
-     * @return The encoded length of a byte array of length len
-     */
-    inline size_t encoded_length_bytes32(int32_t len) {
-        return len + 4;
-    }
-
-    /**
-     * Encodes a variable sized byte array into the given buffer.  Encoded as a
-     * 4 byte length followed by the data.  Assumes there is enough space
-     * available.  Increments buffer pointer.
-     *
-     * @param bufp Address of the destination buffer
-     * @param data Pointer to array of bytes
-     * @param len The length of the byte array
-     */
-    inline void encode_bytes32(uint8_t **bufp, const void *data, int32_t len) {
-        HT_ENCODE_BYTES32(*bufp, data, len);
-    }
-
-    /**
-     * Decodes a variable sized byte array from the given buffer.  Byte array i
-     * encoded as a 4 byte length followed by the data.  Increments buffer
-     * pointer and decrements remainp on success.
-     *
-     * @param bufp Address of buffer containing encoded byte array
-     * @param remainp Address of variable containing number of bytes remaining
-     * @param lenp Address of length of decoded byte array
-     */
-    inline uint8_t *decode_bytes32(const uint8_t **bufp, size_t *remainp,
-            uint32_t *lenp) {
-        uint8_t *out;
-        HT_DECODE_BYTES32(*bufp, *remainp, out, *lenp);
-        return out;
-    }
-
-    /**
-     * Computes the encoded length of a string16 encoding
-     *
-     * @param str Pointer to the c-style string
-     * @return The encoded length of str
-     */
-    inline size_t encoded_length_str16(const char *str) {
-        return 2 + ((str == 0) ? 0 : strlen(str)) + 1;
-    }
-
-    /**
-     * Computes the encoded length of a std::string.
-     *
-     * @param str Reference to string object
-     * @return The encoded length of str
-     */
-    inline size_t encoded_length_str16(const std::string &str) {
-        return 2 + str.length() + 1;
-    }
-
-    /**
-     * Encodes a string buffer into the given buffer.
-     * Encoded as a 2 byte length followed by the string data, followed
-     * by a '\\0' termination byte.  The length value does not include
-     * the '\\0'.  Assumes there is enough space available.  Increments
-     * buffer pointer.
-     *
-     * @param bufp Address of the destination buffer
-     * @param str The c-style string to encode
-     * @param len Length of the string
-     */
-    inline void encode_str16(uint8_t **bufp, const void *str, uint16_t len) {
-        HT_ENCODE_STR16(*bufp, str, len);
-    }
-
-    /**
-     * Encodes a c-style null-terminated string into the given buffer.
-     * Encoded as a 2 byte length followed by the string data, followed
-     * by a '\\0' termination byte.  The length value does not include
-     * the '\\0'.  Assumes there is enough space available.  Increments
-     * buffer pointer.
-     *
-     * @param bufp Pointer to pointer of destination buffer
-     * @param str The c-style string to encode
-     */
-    inline void encode_str16(uint8_t **bufp, const char *str) {
-        uint16_t len = (str == 0) ? 0 : strlen(str);
-        encode_str16(bufp, str, len);
-    }
-
-    /**
-     * Encodes a string into the given buffer.  Encoded as a
-     * 2 byte length followed by the string data, followed by a '\\0'
-     * termination byte.  The length value does not include the '\\0'.
-     * Assumes there is enough space available.  Increments buffer
-     * pointer.
-     *
-     * @param bufp Pointer to pointer of the destinatin buffer
-     * @param str The std::string to encode
-     */
-    template <class StringT>
-        inline void encode_str16(uint8_t **bufp, const StringT &str) {
-            encode_str16(bufp, str.c_str(), str.length());
-        }
-
-    /**
-     * Decodes a c-style string from the given buffer.  The encoding of the
-     * string is a 2 byte length followed by the string, followed by a '\\0'
-     * termination byte.  The length does not include the '\\0' terminator.
-     * The decoded string pointer points back into the encoding buffer.
-     * Increments buffer pointer and decrements remainp on success.
-     *
-     * @param bufp Pointer to pointer of buffer containing encoded string
-     * @param remainp Address of variable of number of bytes remaining in buffer
-     * @return Pointer to a c-style string
-     */
-    inline const char *decode_str16(const uint8_t **bufp, size_t *remainp) {
-        const char *str;
-        uint16_t len;
-        HT_DECODE_STR16(*bufp, *remainp, str, len);
-        return str;
-    }
-
-    /**
-     * Decodes a c-style string from the given buffer.  The encoding of the
-     * string is a 2 byte length followed by the string, followed by a '\\0'
-     * termination byte.  The length does not include the '\\0' terminator.
-     * The decoded string pointer points back into the encoding buffer.
-     * Increments buffer pointer and decrements remainp on success.
-     *
-     * @param bufp Pointer to pointer of buffer containing encoded string
-     * @param remainp Address of variable of number of bytes remaining in buffer
-     * @param lenp Address of varaible to hold the len of the string
-     * @return Pointer to a c-style string
-     */
-    inline char *decode_str16(const uint8_t **bufp, size_t *remainp,
-            uint16_t *lenp) {
-        char *str;
-        HT_DECODE_STR16(*bufp, *remainp, str, *lenp);
-        return str;
-    }
-
-    /**
-     * Decodes a str16 from the given buffer to a std::string.  The encoding of the
-     * string is a 2 byte length followed by the string, followed by a '\\0'
-     * termination byte.  The length does not include the '\\0' terminator.
-     * Increments buffer pointer and decrements remainp on success.
-     *
-     * @param bufp Pointer to pointer of buffer containing encoded string
-     * @param remainp Address of variable of number of bytes remaining in buffer
-     * @return True on success, false if buffer has insufficient room
-     */
-    template <class StringT>
-        inline StringT decode_str16(const uint8_t **bufp, size_t *remainp) {
-            char *str;
-            uint16_t len;
-            HT_DECODE_STR16(*bufp, *remainp, str, len);
-            return StringT(str, len); // RVO hopeful
-        }
-
-    /**
-     * Computes the encoded length of vstr (vint64, data, null)
-     *
-     * @param len The string length
-     * @return The encoded length of str
-     */
-    inline size_t encoded_length_vstr(size_t len) {
-        return encoded_length_vi64(len) + len + 1;
-    }
-
-    /**
-     * Computes the encoded length of vstr. Assumes that the string length
-     * can be encoded in 32-bit integer
-     *
-     * @param s Pointer to the the c-style string
-     * @return The encoded length of s
-     */
-    inline size_t encoded_length_vstr(const char *s) {
-        return encoded_length_vstr(s ? strlen(s) : 0);
-    }
-
-    /**
-     * Computes the encoded length of vstr. Assumes that the string length
-     * can be encoded in 32-bit integer
-     *
-     * @param s The string to encode
-     * @return The encoded length of s
-     */
-    inline size_t encoded_length_vstr(const std::string &s) {
-        return encoded_length_vstr(s.length());
-    }
-
-    /**
-     * Encode a buffer as variable length string (vint64, data, null)
-     *
-     * @param bufp Pointer to pointer of destination buffer
-     * @param buf Pointer to the start of the input buffer
-     * @param len Length of the input buffer
-     */
-    inline void encode_vstr(uint8_t **bufp, const void *buf, size_t len) {
-        HT_ENCODE_VSTR(*bufp, buf, len);
-    }
-
-    /**
-     * Encode a c-style string as vstr
-     *
-     * @param bufp Pointer to pointer of destination buffer
-     * @param s Pointer to the start of the string
-     */
-    inline void encode_vstr(uint8_t **bufp, const char *s) {
-        encode_vstr(bufp, s, s ? strlen(s) : 0);
-    }
-
-    /**
-     * Encode a std::string as vstr
-     *
-     * @param bufp Pointer to pointer of destination buffer
-     * @param s The string to encode
-     */
-    template <class StringT>
-        inline void encode_vstr(uint8_t **bufp, const StringT &s) {
-            encode_vstr(bufp, s.data(), s.length());
-        }
-
-    /**
-     * Decode a vstr (vint64, data, null).
-     * Note: decoding a vstr longer than 4GiB on a 32-bit platform
-     * is obviously futile (throws bad vstr exception)
-     *
-     * @param bufp Pointer to pointer of the source buffer
-     * @param remainp Pointer to the remaining size variable
-     * @return Pointer to the decoded string data
-     */
-    inline char *decode_vstr(const uint8_t **bufp, size_t *remainp) {
-        char *buf;
-        size_t len;
-        HT_DECODE_VSTR(*bufp, *remainp, buf, len);
-        (void)len; // avoid warnings because len is assigned but never used
-        return buf;
-    }
-
-    /**
-     * Decode a vstr (vint64, data, null)
-     *
-     * @param bufp Pointer to pointer of the source buffer
-     * @param remainp Pointer to the remaining size variable
-     * @return The decoded string
-     */
-    template <class StringT>
-        inline std::string decode_vstr(const uint8_t **bufp, size_t *remainp) {
-            char *buf;
-            size_t len;
-            HT_DECODE_VSTR(*bufp, *remainp, buf, len);
-            return StringT(buf, len); // RVO
-        }
-
-    /**
-     * Decode a vstr (vint64, data, null)
-     *
-     * @param bufp Pointer to pointer of the source buffer
-     * @param remainp Pointer to the remaining size variable
-     * @param lenp Pointer to the string length
-     * @return Pointer to the decoded string
-     */
-    inline char *decode_vstr(const uint8_t **bufp, size_t *remainp,
-            uint32_t *lenp) {
-        char *buf;
-        HT_DECODE_VSTR(*bufp, *remainp, buf, *lenp);
-        return buf;
-    }
-
-    /**
-     * Encode an InetAddr structure
-     *
-     * @param bufp Pointer to pointer of the destination buffer
-     * @param addr Reference to the InetAddr object to encode
-     */
-    inline void encode_inet_addr(uint8_t **bufp, const InetAddr &addr) {
-        HT_ENCODE_I16(*bufp, addr.sin_family);
-        HT_ENCODE_I32(*bufp, addr.sin_addr.s_addr);
-        HT_ENCODE_I16(*bufp, addr.sin_port);
-    }
-
-    /**
-     * Decode an InetAddr structure
-     *
-     * @param bufp Pointer to pointer of the source buffer
-     * @param remainp Pointer to remaining size variable
-     * @return The decoded InetAddr object
-     */
-    inline InetAddr decode_inet_addr(const uint8_t **bufp, size_t *remainp) {
-        InetAddr addr;
-        HT_DECODE_I16(*bufp, *remainp, addr.sin_family);
-        HT_DECODE_I32(*bufp, *remainp, addr.sin_addr.s_addr);
-        HT_DECODE_I16(*bufp, *remainp, addr.sin_port);
-        return addr;
-    }
-
-    /**
-     * Encodes a double with 18 decimal digits of precision as 64-bit
-     * left-of-decimal, followed by 64-bit right-of-decimal, both in
-     * little-endian order
-     *
-     * @param bufp Pointer to the destination buffer
-     * @param val The double to encode
-     */
-    inline void encode_double(uint8_t **bufp, double val) {
-        int64_t lod = (int64_t)val;
-        int64_t rod = (int64_t)((val - (double)lod) * (double)1000000000000000000.00);
-        HT_ENCODE_I64(*bufp, lod);
-        HT_ENCODE_I64(*bufp, rod);
-    }
-
-    /**
-     * Decodes a double as 64-bit left-of-decimal, followed by
-     * 64-bit right-of-decimal, both in little-endian order
-     *
-     * @param bufp Pointer to pointer of the source buffer
-     * @param remainp Pointer to remaining size variable
-     * @return The decoded value
-     */
-    inline double decode_double(const uint8_t **bufp, size_t *remainp) {
-        int64_t lod;
-        int64_t rod;
-        HT_DECODE_I64(*bufp, *remainp, lod);
-        HT_DECODE_I64(*bufp, *remainp, rod);
-        return (double)lod + ((double)rod / (double)1000000000000000000.00);
-    }
-
-    /**
-     * Length of an encoded double (16 bytes)
-     *
-     * @return The number of bytes required to encode a double
-     */
-    inline int encoded_length_double() {
-        return 16;
-    }
-
-    /**
-     * Compare doubles that may have been serialized and unserialized.
-     * The serialization process loses precision, so this function is
-     * necessary to compare pre-serialized with post-serialized values
-     *
-     * @param a First value to compare
-     * @param b Second value to compare
-     * @return True of values are logically equal, false otherwise
-     */
-    inline bool equal(double a, double b) {
-        int64_t lod_a = (int64_t)a;
-        int64_t rod_a = (int64_t)((a - (double)lod_a) * (double)1000000000000000000.00);
-        double aprime = (double)lod_a + ((double)rod_a / (double)1000000000000000000.00);
-        int64_t lod_b = (int64_t)b;
-        int64_t rod_b = (int64_t)((b - (double)lod_b) * (double)1000000000000000000.00);
-        double bprime = (double)lod_b + ((double)rod_b / (double)1000000000000000000.00);
-        return aprime == bprime;
-    }
-} // namespace palo::serialization
-
-} // namespace palo
-
-#endif //BDG_PALO_BE_SRC_RPC_SERIALIZATION_H
diff --git a/be/src/rpc/serialization_c.h b/be/src/rpc/serialization_c.h
deleted file mode 100644
index 1cb2d8ec5ca2fc..00000000000000
--- a/be/src/rpc/serialization_c.h
+++ /dev/null
@@ -1,453 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_SERIALIZATION_C_H
-#define BDG_PALO_BE_SRC_RPC_SERIALIZATION_C_H
-
-/* Check if stdint is included correctly */
-#ifndef SIZE_MAX
-# error Forgot to include "compat.h" _first_ in your *.cc or *.c?
-#endif
-
-/* Selection of implementation */
-#ifdef HT_SERIALIZATION_GENERIC
-#undef HT_LITTLE_ENDIAN
-#else
-#include "endian_c.h"
-#endif
-
-/* Overridable error handling helper macros */
-#ifdef __cplusplus
-# include "error.h"
-# ifndef HT_THROW_INPUT_OVERRUN
-#   define HT_THROW_INPUT_OVERRUN(_r_, _l_) \
-    HT_THROWF(error::SERIALIZATION_INPUT_OVERRUN, \
-            "Need %lu bytes but only %lu remain", (Lu)(_l_), (Lu)(_r_))
-# endif
-# ifndef HT_THROW_BAD_VSTR
-#   define HT_THROW_BAD_VSTR(_s_) \
-    HT_THROWF(error::SERIALIZATION_BAD_VSTR, "Error decoding %s", _s_)
-# endif
-# ifndef HT_THROW_BAD_VINT
-#   define HT_THROW_BAD_VINT(_s_) \
-    HT_THROWF(error::SERIALIZATION_BAD_VINT, "Error decoding %s", _s_)
-# endif
-# ifndef HT_THROW_UNPOSSIBLE
-#   define HT_THROW_UNPOSSIBLE(_s_) \
-    HT_THROWF(error::UNPOSSIBLE, "%s", _s_)
-# endif
-#else
-# include <cstdio>
-# ifndef HT_THROW_INPUT_OVERRUN
-#   define HT_THROW_INPUT_OVERRUN(_s_) do { \
-    std::fprintf(stderr, "Error: %s (%s:%d): input overrun deocding %s", \
-            HT_FUNC, __FILE__, __LINE__, _s_); \
-    abort(); \
-} while (0)
-# endif
-# ifndef HT_THROW_BAD_VSTR
-#   define HT_THROW_BAD_VSTR(_s_) do { \
-    std::fprintf(stderr, "Error: %s (%s:%d): malformed input decoding %s", \
-            HT_FUNC, __FILE__, __LINE__, _s_); \
-    abort(); \
-} while (0)
-# endif
-# ifndef HT_THROW_BAD_VINT
-#   define HT_THROW_BAD_VINT(_s_) do { \
-    std::fprintf(stderr, "Error: %s (%s:%d): malformed input decoding %s", \
-            HT_FUNC, __FILE__, __LINE__, _s_); \
-    abort(); \
-} while (0)
-# endif
-# ifndef HT_THROW_UNPOSSIBLE
-#   define HT_THROW_UNPOSSIBLE(_s_) do { \
-    std::fprintf(stderr, "Error: %s (%s:%d): unpossible!: %s", \
-            HT_FUNC, __FILE__, __LINE__, _s_); \
-    abort(); \
-} while (0)
-# endif
-#endif
-#define HT_DECODE_NEED(_r_, _l_) do { \
-    if (_r_ < _l_) \
-    HT_THROW_INPUT_OVERRUN(_r_, _l_); \
-    _r_ -= _l_; \
-} while (0)
-
-/*
- * Encode a boolean value
- */
-#define HT_ENCODE_BOOL(_op_, _v_) *(_op_)++ = (_v_) ? 1 : 0
-
-/*
- * Encode a 8-bit integer (byte)
- */
-#define HT_ENCODE_I8(_op_, _v_) *(_op_)++ = _v_
-
-/*
- * Decode a 8-bit integer (a byte/character)
- */
-#define HT_DECODE_I8(_ip_, _r_, _v_) do { \
-    HT_DECODE_NEED(_r_, 1); \
-    _v_ = *(_ip_)++; \
-} while (0)
-
-/*
- * Encode a 16 bit integer in little endian format
- */
-#ifdef HT_LITTLE_ENDIAN
-# define HT_ENCODE_I16(_op_, _v_) do { \
-    memcpy(_op_, &(_v_), 2); \
-    _op_ += 2; \
-} while (0)
-#else
-# define HT_ENCODE_I16(_op_, _v_) do { \
-    *(_op_)++ = (uint8_t)(_v_); \
-    *(_op_)++ = (uint8_t)((_v_) >> 8); \
-} while (0)
-#endif
-
-/*
- * Decoded a 16 bit integer encoded in little endian format
- */
-#ifdef HT_LITTLE_ENDIAN
-# define HT_DECODE_I16(_ip_, _r_, _v_) do { \
-    HT_DECODE_NEED(_r_, 2); \
-    memcpy(&(_v_), _ip_, 2); \
-    _ip_ += 2; \
-} while (0)
-#else
-# define HT_DECODE_I16(_ip_, _r_, _v_) do { \
-    HT_DECODE_NEED(_r_, 2); \
-    _v_ = *(_ip_)++; \
-    _v_ |= (*(_ip_)++ << 8); \
-} while (0)
-#endif
-
-/*
- * Enocde a 32-bit integer in little endian format
- */
-#ifdef HT_LITTLE_ENDIAN
-# define HT_ENCODE_I32(_op_, _v_) do { \
-    memcpy(_op_, &(_v_), 4); \
-    _op_ += 4; \
-} while (0)
-#else
-# define HT_ENCODE_I32(_op_, _v_) do { \
-    *(_op_)++ = (uint8_t)(_v_); \
-    *(_op_)++ = (uint8_t)((_v_) >> 8); \
-    *(_op_)++ = (uint8_t)((_v_) >> 16); \
-    *(_op_)++ = (uint8_t)((_v_) >> 24); \
-} while (0)
-#endif
-
-/*
- * Decode a 32-bit integer encoded in little endian format
- */
-#ifdef HT_LITTLE_ENDIAN
-# define HT_DECODE_I32(_ip_, _r_, _v_) do { \
-    HT_DECODE_NEED(_r_, 4); \
-    memcpy(&_v_, _ip_, 4); \
-    _ip_ += 4; \
-} while (0)
-#else
-# define HT_DECODE_I32(_ip_, _r_, _v_) do { \
-    HT_DECODE_NEED(_r_, 4); \
-    _v_ = *(_ip_)++; \
-    _v_ |= (*(_ip_)++ << 8); \
-    _v_ |= (*(_ip_)++ << 16); \
-    _v_ |= (*(_ip_)++ << 24); \
-} while (0)
-#endif
-
-/*
- * Encode a 64-bit integer in little endian format
- */
-#ifdef HT_LITTLE_ENDIAN
-# define HT_ENCODE_I64(_op_, _v_) do { \
-    memcpy(_op_, &(_v_), 8); \
-    _op_ += 8; \
-} while (0)
-#else
-# define HT_ENCODE_I64(_op_, _v_) do { \
-    *(_op_)++ = (uint8_t)(_v_); \
-    *(_op_)++ = (uint8_t)((_v_) >> 8); \
-    *(_op_)++ = (uint8_t)((_v_) >> 16); \
-    *(_op_)++ = (uint8_t)((_v_) >> 24); \
-    *(_op_)++ = (uint8_t)((_v_) >> 32); \
-    *(_op_)++ = (uint8_t)((_v_) >> 40); \
-    *(_op_)++ = (uint8_t)((_v_) >> 48); \
-    *(_op_)++ = (uint8_t)((_v_) >> 56); \
-} while (0)
-#endif
-
-/*
- * Decode a 64-bit integer encoded in little endian format
- */
-#ifdef HT_LITTLE_ENDIAN
-# define HT_DECODE_I64(_ip_, _r_, _v_) do { \
-    HT_DECODE_NEED(_r_, 8); \
-    memcpy(&(_v_), _ip_, 8); \
-    _ip_ += 8; \
-} while (0)
-#else
-# define HT_DECODE_I64(_ip_, _r_, _v_) do { \
-    HT_DECODE_NEED(_r_, 8); \
-    _v_ = *(_ip_)++; \
-    _v_ |= (*(_ip_)++ << 8); \
-    _v_ |= (*(_ip_)++ << 16); \
-    _v_ |= ((uint64_t)(*(_ip_)++) << 24); \
-    _v_ |= ((uint64_t)(*(_ip_)++) << 32); \
-    _v_ |= ((uint64_t)(*(_ip_)++) << 40); \
-    _v_ |= ((uint64_t)(*(_ip_)++) << 48); \
-    _v_ |= ((uint64_t)(*(_ip_)++) << 56); \
-} while (0)
-#endif
-
-/* vint limits */
-#define HT_MAX_V1B 0x7f
-#define HT_MAX_V2B 0x3fff
-#define HT_MAX_V3B 0x1fffff
-#define HT_MAX_V4B 0xfffffff
-#define HT_MAX_V5B 0x7ffffffffull
-#define HT_MAX_V6B 0x3ffffffffffull
-#define HT_MAX_V7B 0x1ffffffffffffull
-#define HT_MAX_V8B 0xffffffffffffffull
-#define HT_MAX_V9B 0x7fffffffffffffffull
-#define HT_MAX_LEN_VINT32 5
-#define HT_MAX_LEN_VINT64 10
-
-/*
- * vint encoded length of a 32-bit integer
- */
-#define HT_ENCODED_LEN_VI32(_v_) \
-    (_v_ <= HT_MAX_V1B ? 1 : \
-     (_v_ <= HT_MAX_V2B ? 2 : \
-      (_v_ <= HT_MAX_V3B ? 3 : \
-       (_v_ <= HT_MAX_V4B ? 4 : 5))))
-
-/*
- * vint encoded length of a 64-bit integer
- */
-#define HT_ENCODED_LEN_VI64(_v_) \
-    (val <= HT_MAX_V1B ? 1 : \
-     (val <= HT_MAX_V2B ? 2 : \
-      (val <= HT_MAX_V3B ? 3 : \
-       (val <= HT_MAX_V4B ? 4 : \
-        (val <= HT_MAX_V5B ? 5 : \
-         (val <= HT_MAX_V6B ? 6 : \
-          (val <= HT_MAX_V7B ? 7 : \
-           (val <= HT_MAX_V8B ? 8 : \
-            (val <= HT_MAX_V9B ? 9 : 10)))))))))
-
-/* vint encode helpers */
-#define HT_ENCODE_VINT0(_op_, _v_, _done_) \
-    if (_v_ <= HT_MAX_V1B) { \
-        *(_op_)++ = (uint8_t)((_v_) & 0x7f); \
-        _done_; \
-    }
-
-#define HT_ENCODE_VINT_(_op_, _v_, _done_) \
-    *(_op_)++ = (uint8_t)((_v_) | 0x80); \
-_v_ >>= 7; \
-HT_ENCODE_VINT0(_op_, _v_, _done_)
-
-#define HT_ENCODE_VINT4(_op_, _v_, _done_) \
-    HT_ENCODE_VINT_(_op_, _v_, _done_) \
-HT_ENCODE_VINT_(_op_, _v_, _done_) \
-HT_ENCODE_VINT_(_op_, _v_, _done_) \
-HT_ENCODE_VINT_(_op_, _v_, _done_)
-/*
- * Encode a 32-bit integer in vint format
- *
- * @param _op_ - output buffer pointer
- * @param _v_ - value to encode
- * @param _done_ - return or break
- */
-#define HT_ENCODE_VI32(_op_, _v_, _done_) do { \
-    uint32_t _evtmp32_ = _v_; /* make sure these var names are not the same */ \
-    HT_ENCODE_VINT0(_op_, _evtmp32_, _done_) \
-    HT_ENCODE_VINT4(_op_, _evtmp32_, _done_) \
-    HT_ENCODE_VINT_(_op_, _evtmp32_, _done_) \
-    HT_THROW_UNPOSSIBLE("reach here encoding vint32"); \
-} while (0)
-
-/*
- * Encode a 64-bit integer in vint format
- *
- * @param _op_ - output buffer pointer
- * @param _v_ - value to encode
- * @param _done_ - return or break
- */
-#define HT_ENCODE_VI64(_op_, _v_, _done_) do { \
-    uint64_t _evtmp64_ = _v_; /* ditto */ \
-    HT_ENCODE_VINT0(_op_, _evtmp64_, _done_) \
-    HT_ENCODE_VINT4(_op_, _evtmp64_, _done_) \
-    HT_ENCODE_VINT4(_op_, _evtmp64_, _done_) \
-    HT_ENCODE_VINT_(_op_, _evtmp64_, _done_) \
-    HT_ENCODE_VINT_(_op_, _evtmp64_, _done_) \
-    HT_THROW_UNPOSSIBLE("reach here encoding vint64"); \
-} while (0)
-
-/* vint decode helpers */
-#define HT_DECODE_VINT0(_type_, _v_, _ip_, _r_) \
-    uint32_t _shift_ = 0; \
-HT_DECODE_NEED(_r_, 1); \
-_v_ = (*(_ip_)++ & 0x7f);
-#define HT_DECODE_VINT_(_type_, _v_, _ip_, _r_, _done_) \
-    _shift_ += 7; \
-if ((_ip_)[-1] & 0x80) { \
-    HT_DECODE_NEED(_r_, 1); \
-    _v_ |= ((_type_)(*(_ip_)++ & 0x7f) << _shift_); \
-} else _done_;
-
-#define HT_DECODE_VINT4(_type_, _v_, _ip_, _r_, _done_) \
-    HT_DECODE_VINT_(_type_, _v_, _ip_, _r_, _done_) \
-HT_DECODE_VINT_(_type_, _v_, _ip_, _r_, _done_) \
-HT_DECODE_VINT_(_type_, _v_, _ip_, _r_, _done_) \
-HT_DECODE_VINT_(_type_, _v_, _ip_, _r_, _done_)
-
-/*
- * Decode a 32-bit integer encoded in vint format
- *
- * @param _ip_ - input buffer pointer
- * @param _r_ - varable with remaining bytes
- * @param _v_ - variable for result
- * @param _done_ - return _v_ or break
- */
-
-#define HT_DECODE_VI32(_ip_, _r_, _v_, _done_) do { \
-    HT_DECODE_VINT0(uint32_t, _v_, _ip_, _r_) \
-    HT_DECODE_VINT4(uint32_t, _v_, _ip_, _r_, _done_) \
-    HT_DECODE_VINT_(uint32_t, _v_, _ip_, _r_, _done_) \
-    HT_THROW_BAD_VINT("vint32"); \
-} while (0)
-
-/*
- * Decode a 64-bit integer encoded in vint format
- *
- * @param _ip_ - input buffer pointer
- * @param _r_ - varable with remaining bytes
- * @param _v_ - variable for result
- * @param _done_ - return _v_ or break
- */
-#define HT_DECODE_VI64(_ip_, _r_, _v_, _done_) do { \
-    HT_DECODE_VINT0(uint64_t, _v_, _ip_, _r_) \
-    HT_DECODE_VINT4(uint64_t, _v_, _ip_, _r_, _done_) \
-    HT_DECODE_VINT4(uint64_t, _v_, _ip_, _r_, _done_) \
-    HT_DECODE_VINT_(uint64_t, _v_, _ip_, _r_, _done_) \
-    HT_DECODE_VINT_(uint64_t, _v_, _ip_, _r_, _done_) \
-    HT_THROW_BAD_VINT("vint64"); \
-} while (0)
-
-/*
- * Encode a buffer in bytes32 format (i32, data)
- *
- * @param _op_ - output buffer pointer
- * @param _ip_ - input buffer pointer
- * @param _len_ - input buffer length
- */
-#define HT_ENCODE_BYTES32(_op_, _ip_, _len_) do { \
-    HT_ENCODE_I32(_op_, _len_); \
-    memcpy(_op_, _ip_, _len_); \
-    _op_ += _len_; \
-} while (0)
-
-/*
- * Decode bytes32 (i32, data)
- *
- * @param _ip_ - input buffer pointer
- * @param _r_ - varable with remaining bytes
- * @param _out_ - variable for output
- * @param _len_ - variable for result length
- */
-#define HT_DECODE_BYTES32(_ip_, _r_, _out_, _len_) do { \
-    uint32_t _tmp_; \
-    HT_DECODE_I32(_ip_, _r_, _tmp_); \
-    HT_DECODE_NEED(_r_, _tmp_); \
-    _out_ = (uint8_t *)(_ip_); \
-    _ip_ += _tmp_; \
-    _len_ = _tmp_; \
-} while (0)
-
-/*
- * Encode a string buffer in str16 format (i16, data, null)
- *
- * @param _op_ - output buffer pointer
- * @param _s_ - input buffer pointer
- * @param _len_ - input buffer length
- */
-#define HT_ENCODE_STR16(_op_, _s_, _len_) do { \
-    uint16_t _s16tmp_ = _len_; /* just to be cautious */ \
-    HT_ENCODE_I16(_op_, _s16tmp_); /* length */ \
-    if (_s16tmp_ > 0) { \
-        memcpy(_op_, _s_, _s16tmp_); /* data */ \
-        _op_ += len; \
-    } \
-    *(*bufp)++ = 0; /* null */ \
-} while (0)
-
-/*
- * Decode str16 (i16, data, null)
- *
- * @param _ip_ - input buffer pointer
- * @param _r_ - varable with remaining bytes
- * @param _s_ - variable for result
- * @param _len_ - variable for result length
- */
-#define HT_DECODE_STR16(_ip_, _r_, _s_, _len_) do { \
-    HT_DECODE_I16(_ip_, _r_, _len_); \
-    _s_ = (char *)(_ip_); \
-    _r_ -= (size_t)(_len_) + 1; \
-    _ip_ += (size_t)(_len_) + 1; \
-} while (0)
-
-/*
- * Encode in vstr format (vint, data, null)
- *
- * @param _op_ - output buffer pointer
- * @param _s_ - input buffer pointer
- * @param _len_ - input buffer length
- */
-#define HT_ENCODE_VSTR(_op_, _s_, _len_) do { \
-    size_t _vs64tmp_ = _len_; /* ditto */ \
-    HT_ENCODE_VI64(_op_, _vs64tmp_, break); \
-    if (_vs64tmp_) { \
-        memcpy((_op_), _s_, _vs64tmp_); \
-        (_op_) += _vs64tmp_; \
-    } \
-    *(_op_)++ = 0; \
-} while (0)
-
-/*
- * Decode a vstr (vint, data, null)
- */
-#define HT_DECODE_VSTR(_ip_, _r_, _out_, _len_) do { \
-    uint64_t _tmp_; \
-    HT_DECODE_VI64(_ip_, _r_, _tmp_, break); \
-    if (_tmp_ > (uint64_t)(SIZE_MAX)) \
-    HT_THROW_BAD_VSTR("long vstr on 32-bit platform"); \
-    _out_ = (char *)(_ip_); \
-    _len_ = _tmp_++; \
-    HT_DECODE_NEED(_r_, _tmp_); \
-    _ip_ += _tmp_; \
-    if ((_ip_)[-1]) /* should be null */ \
-    HT_THROW_BAD_VSTR("vstr"); \
-} while (0)
-
-#endif //BDG_PALO_BE_SRC_RPC_SERIALIZATION_C_H
diff --git a/be/src/rpc/sock_addr_map.h b/be/src/rpc/sock_addr_map.h
deleted file mode 100644
index c9e0650b170cd8..00000000000000
--- a/be/src/rpc/sock_addr_map.h
+++ /dev/null
@@ -1,50 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_SOCK_ADDR_MAP_H
-#define BDG_PALO_BE_SRC_RPC_SOCK_ADDR_MAP_H
-
-#include <unordered_map>
-#include "inet_addr.h"
-
-namespace palo {
-
-/// Hash functor class for InetAddr.
-class SockAddrHash {
-public:
-    size_t operator () (const InetAddr &addr) const {
-        return (size_t)(addr.sin_addr.s_addr ^ addr.sin_port);
-    }
-};
-
-/// Equality predicate functor class for InetAddr.
-struct SockAddrEqual {
-    bool operator()(const InetAddr &addr1, const InetAddr &addr2) const {
-        return (addr1.sin_addr.s_addr == addr2.sin_addr.s_addr)
-            && (addr1.sin_port == addr2.sin_port);
-    }
-};
-
-/// Unordered map specialization for InetAddr keys.
-template<typename TypeT, typename addr = InetAddr>
-class SockAddrMap : public std::unordered_map<addr, TypeT, SockAddrHash, SockAddrEqual> {
-};
-
-} // namespace palo
-#endif //BDG_PALO_BE_SRC_RPC_SOCK_ADDR_MAP_H
diff --git a/be/src/rpc/static_buffer.h b/be/src/rpc/static_buffer.h
deleted file mode 100644
index 22be6114013c7f..00000000000000
--- a/be/src/rpc/static_buffer.h
+++ /dev/null
@@ -1,226 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_STATIC_BUFFER_H
-#define BDG_PALO_BE_SRC_RPC_STATIC_BUFFER_H
-
-#include "dynamic_buffer.h"
-#include <cstdlib>
-#include <memory>
-#include <assert.h>
-
-namespace palo {
-/** A memory buffer of static size. The actual buffer can be allocated or
- * assigned by the caller. If the StaticBuffer "owns" the pointer then it
- * will be released when going out of scope.
- */
-class StaticBuffer {
-public:
-
-    /** Constructor.  Creates an empty buffer */
-    StaticBuffer()
-        : base(0), alignment(0), size(0), own(true) {
-        }
-
-    /** Constructor.
-     * Allocates a new buffer of size <code>len</code>. If
-     * <code>alignment</code> is non-zero, then the posix_memalign() function
-     * will be called to obtain memory and #alignment is set to
-     * <code>alignment</code>.  Memory will be released when going out of scope.
-     *
-     * @param len The size of the new buffer, in bytes
-     * @param alignment Buffer alignment
-     */
-    explicit StaticBuffer(size_t len, size_t alignment=0)
-        : alignment(alignment), size(len), own(true) {
-            if (alignment > 0) {
-                void *vptr = nullptr;
-                size_t aligned_len = (len % alignment) == 0 ? len :
-                    ((len / alignment)+1)*alignment;
-                posix_memalign(&vptr, alignment, aligned_len);
-                assert(vptr != nullptr);
-                base = (uint8_t *)vptr;
-            }
-            else
-                base = new uint8_t[len];
-        }
-
-    /** Constructor; assigns an existing buffer and can take ownership of
-     * that buffer.
-     *
-     * @param data Pointer to the existing buffer
-     * @param len Size of the existing buffer
-     * @param take_ownership If yes, will "own" the existing buffer and
-     *      delete[] the memory when going out of scope. Make sure that the
-     *      buffer was allocated with new[]!
-     */
-    StaticBuffer(void *data, uint32_t len, bool take_ownership = true)
-        : base((uint8_t *)data), alignment(0), size(len), own(take_ownership) {
-        }
-
-    /** Constructor; takes ownership from a DynamicBuffer */
-    StaticBuffer(DynamicBuffer &dbuf) {
-        base = dbuf.base;
-        size = dbuf.fill();
-        own = dbuf.own;
-        alignment = 0;
-        if (own) {
-            dbuf.base = dbuf.ptr = 0;
-            dbuf.size = 0;
-        }
-    }
-
-    /** Destructor; if "own" is true then the buffer will be delete[]d */
-    ~StaticBuffer() {
-        free();
-    }
-
-    /**
-     * Copy constructor.
-     *
-     * WARNING: This assignment operator will cause the ownership of the buffer
-     * to transfer to the lvalue buffer if the own flag is set to 'true' in the
-     * buffer being copied.  The buffer being copied will be modified to have
-     * it's 'own' flag set to false and the 'base' pointer will be set to NULL.
-     * In other words, the buffer being copied is no longer usable after the
-     * assignment.
-     *
-     * @param other Reference to the original instance
-     */
-    StaticBuffer(StaticBuffer& other) {
-        base = other.base;
-        size = other.size;
-        own = other.own;
-        alignment = other.alignment;
-        if (own) {
-            other.own = false;
-            other.base = 0;
-        }
-    }
-
-    /**
-     * Assignment operator.
-     *
-     * WARNING: This assignment operator will cause the ownership of the buffer
-     * to transfer to the lvalue buffer if the own flag is set to 'true' in the
-     * buffer being copied.  The buffer being copied will be modified to have
-     * it's 'own' flag set to false and the 'base' pointer will be set to NULL.
-     * In other words, the buffer being copied is no longer usable after the
-     * assignment.
-     *
-     * @param other Reference to the original instance
-     */
-    StaticBuffer &operator=(StaticBuffer &other) {
-        base = other.base;
-        size = other.size;
-        own = other.own;
-        alignment = other.alignment;
-        if (own) {
-            other.own = false;
-            other.base = 0;
-        }
-        return *this;
-    }
-
-    /** Assignment operator for DynamicBuffer
-     *
-     * @param dbuf Reference to the original DynamicBuffer instance
-     */
-    StaticBuffer &operator=(DynamicBuffer &dbuf) {
-        base = dbuf.base;
-        size = dbuf.fill();
-        own = dbuf.own;
-        alignment = 0;
-        if (own) {
-            dbuf.base = dbuf.ptr = 0;
-            dbuf.size = 0;
-        }
-        return *this;
-    }
-
-    /** Sets data pointer; the existing buffer is discarded and deleted
-     *
-     * @param data Pointer to the existing buffer
-     * @param len Size of the existing buffer
-     * @param take_ownership If yes, will "own" the existing buffer and
-     *      delete[] the memory when going out of scope. Make sure that the
-     *      buffer was allocated with new[]!
-     */
-    void set(uint8_t *data, uint32_t len, bool take_ownership = true) {
-        free();
-        base = data;
-        size = len;
-        own = take_ownership;
-        alignment = 0;
-    }
-
-    /** Clears the data; if this object is owner of the data then the allocated
-     * buffer is delete[]d */
-    void free() {
-        if (own && base) {
-            if (alignment > 0)
-                ::free(base);
-            else
-                delete [] base;
-        }
-        base = 0;
-        size = 0;
-    }
-
-    size_t aligned_size() {
-        if (alignment == 0 || (size % alignment) == 0)
-            return size;
-        return ((size / alignment)+1) * alignment;
-    }
-
-    uint8_t *base;
-    size_t alignment;
-    uint32_t size;
-    bool own;
-};
-
-/** "Less than" operator for StaticBuffer; uses @a memcmp */
-inline bool operator<(const StaticBuffer& sb1, const StaticBuffer& sb2) {
-    size_t len = (sb1.size < sb2.size) ? sb1.size : sb2.size;
-    int cmp = memcmp(sb1.base, sb2.base, len);
-    return (cmp==0) ? sb1.size < sb2.size : cmp < 0;
-}
-
-/** Equality operator for StaticBuffer; uses @a memcmp */
-inline bool operator==(const StaticBuffer& sb1, const StaticBuffer& sb2) {
-    if (sb1.size != sb2.size)
-        return false;
-    size_t len = (sb1.size < sb2.size) ? sb1.size : sb2.size;
-    int equal = memcmp(sb1.base, sb2.base, len);
-    if (equal == 0 )
-        return true;
-    return false;
-}
-
-/** Inequality operator for StaticBuffer */
-inline bool operator!=(const StaticBuffer& sb1, const StaticBuffer& sb2) {
-    return !(sb1 == sb2);
-}
-
-/// Smart pointer to StaticBuffer
-typedef std::shared_ptr<StaticBuffer> StaticBufferPtr;
-
-} // namespace palo
-
-#endif //BDG_PALO_BE_SRC_RPC_STATIC_BUFFER_H
diff --git a/be/src/rpc/string_ext.h b/be/src/rpc/string_ext.h
deleted file mode 100644
index f5c76cc675071a..00000000000000
--- a/be/src/rpc/string_ext.h
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_STRING_EXT_H
-#define BDG_PALO_BE_SRC_RPC_STRING_EXT_H
-
-#include "util.h"
-
-#include <cstdio>
-#include <set>
-#include <map>
-
-namespace palo {
-
-/** STL Set managing std::strings */
-typedef std::set<std::string> StringSet;
-
-/** STL Strict Weak Ordering for comparing c-style strings */
-struct LtCstr {
-    bool operator()(const char *s1, const char *s2) const {
-        return strcmp(s1, s2) < 0;
-    }
-};
-
-/** STL Set managing c-style strings */
-typedef std::set<const char *, LtCstr> CstrSet;
-
-/** STL map from c-style string to int32_t */
-typedef std::map<const char *, int32_t, LtCstr> CstrToInt32Map;
-
-/** STL map from c-style string to int64_t */
-typedef std::map<const char *, int64_t, LtCstr> CstrToInt64MapT;
-
-/** Append operator for shorts */ 
-inline std::string operator+(const std::string &s1, short sval) {
-    return s1 + Int16Formatter(sval).c_str();
-}
-
-/** Append operator for ushorts */
-inline std::string operator+(const std::string &s1, uint16_t sval) {
-    return s1 + UInt16Formatter(sval).c_str();
-}
-
-/** Append operator for integers */ 
-inline std::string operator+(const std::string &s1, int ival) {
-    return s1 + Int32Formatter(ival).c_str();
-}
-
-/** Append operator for unsigned integers */ 
-inline std::string operator+(const std::string &s1, uint32_t ival) {
-    return s1 + UInt32Formatter(ival).c_str();
-}
-
-/** Append operator for 64bit integers */ 
-inline std::string operator+(const std::string &s1, int64_t llval) {
-    return s1 + Int64Formatter(llval).c_str();
-}
-
-/** Append operator for 64bit unsigned integers */ 
-inline std::string operator+(const std::string &s1, uint64_t llval) {
-    return s1 + UInt64Formatter(llval).c_str();
-}
-
-} //namespace palo
-#endif //BDG_PALO_BE_SRC_RPC_STRING_EXT_H
diff --git a/be/src/rpc/timer.h b/be/src/rpc/timer.h
deleted file mode 100644
index 8a218b49cee072..00000000000000
--- a/be/src/rpc/timer.h
+++ /dev/null
@@ -1,141 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_TIMER_H
-#define BDG_PALO_BE_SRC_RPC_TIMER_H
-
-#include "fast_clock.h"
-#include <cassert>
-#include <chrono>
-#include <cstring>
-
-namespace palo {
-
-/**
- * A timer class to keep timeout states across AsyncComm related calls.
- */
-class Timer {
-public:
-
-    /**
-     * Constructor; assigns number of milliseconds after which the timer will
-     * expire
-     *
-     * @param millis Number of milliseconds after timer will expire
-     * @param start_timer If true, timer is started immediately; otherwise
-     *      start with %start
-     */
-    Timer(uint32_t millis, bool start_timer = false)
-        : m_duration(std::chrono::milliseconds(millis)),
-        m_remaining(std::chrono::milliseconds(millis)) {
-            if (start_timer) {
-                start();
-            }
-        }
-
-    /**
-     * Starts the timer. Will have no effect if the timer is still running.
-     */
-    void start() {
-        if (!m_running) {
-            start_time = std::chrono::FastClock::now();
-            m_running = true;
-            if (!m_started) {
-                m_started = true;
-            }
-        }
-    }
-
-    /**
-     * Stops the timer. Will assert that the timer was started. Updates the
-     * remaining time (see %remaining).
-     */
-    void stop() {
-        assert(m_started);
-        auto adjustment = std::chrono::FastClock::now() - start_time;
-        m_remaining = (adjustment < m_remaining) ?
-            m_remaining - adjustment :
-            std::chrono::FastClock::duration::zero();
-        m_running = false;
-    }
-
-    /**
-     * Resets the timer
-     */
-    void reset(bool start_timer = false) {
-        m_running = false;
-        m_started = false;
-        m_remaining = m_duration;
-        if (start_timer)
-            start();
-    }
-
-    /**
-     * Returns the remaining time till expiry
-     * @return Remaining time in milliseconds
-     */
-    uint32_t remaining() {
-        if (m_running) {
-            stop();
-            start();
-        }
-        return std::chrono::duration_cast<std::chrono::milliseconds>(m_remaining).count();
-    }
-
-    /**
-     * Returns true if the timer is expired
-     */
-    bool expired() {
-        return remaining() == 0;
-    }
-
-    /**
-     * Returns true if the timer is still running (not yet expired
-     */
-    bool is_running() {
-        return m_running;
-    }
-
-    /**
-     * Returns the duration of the timer
-     * @return Timer duration in milliseconds
-     */
-    uint32_t duration() {
-        return (uint32_t)std::chrono::duration_cast<std::chrono::milliseconds>(m_duration).count();
-    }
-
-private:
-    /** The time when the timer was started */
-    std::chrono::FastClock::time_point start_time;
-
-    /// True if the timer is running
-    bool m_running {};
-
-    /// True if the timer was started
-    bool m_started {};
-
-    /// The duration of the timer
-    std::chrono::FastClock::duration m_duration;
-
-    /// The remaining time till expiration
-    std::chrono::FastClock::duration m_remaining;
-};
-
-} //namespace palo
-#endif //BDG_PALO_BE_SRC_RPC_TIMER_H
diff --git a/be/src/rpc/util.cpp b/be/src/rpc/util.cpp
deleted file mode 100644
index 3cc6c4422c9212..00000000000000
--- a/be/src/rpc/util.cpp
+++ /dev/null
@@ -1,111 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#include "compat.h"
-#include "util.h"
-
-#include <cstdarg>
-#include <cstdio>
-#include <algorithm>
-
-namespace palo {
-
-std::string format(const char *fmt, ...) {
-    char buf[1024];       // should be enough for most cases
-    int n = 0;
-    int size = sizeof(buf);
-    char *p = buf;
-    va_list ap;
-    do {
-        va_start(ap, fmt);
-        n = vsnprintf(p, size, fmt, ap);
-        va_end(ap);
-        if (n > -1 && n < size) {
-            break;    // worked!
-        }
-        if (n > -1) {        // glibc 2.1+/iso c99
-            size = n + 1;     //   exactly what's needed
-        } else {                // glibc 2.0
-            size *= 2;        //   double the size and try again
-        }
-        p = (char *)(p == buf ? malloc(size) : realloc(p, size));
-        if (!p) {
-            throw std::bad_alloc();
-        }
-    } while (true);
-    if (buf == p) {
-        return std::string(p, n);
-    }
-    std::string ret(p, n);
-    free(p);
-    return ret;
-}
-
-char const *const digits = "0123456789";
-
-std::string format_number(int64_t n, int sep) {
-    char buf[30];
-    char *p = buf;
-    char *p0 = buf;
-    int ndigits = 0;
-    uint64_t num; // for edge cases when -n is still negative when n < 0
-    if (n < 0) {
-        *p++ = '-';
-        p0 = p;
-        num = -n;
-    } else {
-        num = n;
-    }
-    if (num == 0) {
-        *p++ = '0';
-    } else {
-        for (; num != 0; num /= 10) {
-            *p++ = digits[num % 10];
-            ++ndigits;
-            if (num >= 10 && ndigits % 3 == 0) {
-                *p++ = sep;
-            }
-        }
-    }
-    int len = ndigits + (ndigits - 1) / 3;
-    std::reverse(p0, p0 + len);
-    return std::string(buf, len + p0 - buf);
-}
-
-std::string
-format_bytes(size_t n, const void *buf, size_t len, const char *trailer) {
-    if (buf) {
-        if (len <= n) {
-            return std::string((char *)buf, len);
-        }
-        std::string out((char *)buf, n);
-        out += trailer;
-        return out;
-    }
-    return "<null>";
-}
-
-const char NumericFormatterDigits::DIGITS[] =
-    "0001020304050607080910111213141516171819"
-    "2021222324252627282930313233343536373839"
-    "4041424344454647484950515253545556575859"
-    "6061626364656667686970717273747576777879"
-    "8081828384858687888990919293949596979899";
-
-} //namespace palo
diff --git a/be/src/rpc/util.h b/be/src/rpc/util.h
deleted file mode 100644
index 7ce9daddc79ef6..00000000000000
--- a/be/src/rpc/util.h
+++ /dev/null
@@ -1,243 +0,0 @@
-// Copyright (C) 2007-2016 Hypertable, Inc.
-//
-// This file is part of Hypertable.
-// 
-// Hypertable is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 3
-// of the License, or any later version.
-//
-// Hypertable is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA.
-
-#ifndef BDG_PALO_BE_SRC_RPC_UTIL_H
-#define BDG_PALO_BE_SRC_RPC_UTIL_H
-
-#include <string>
-#include <sstream>
-#include <limits>
-
-namespace palo {
-
-/**
- * this is a simple use for std::string
- *
- * In the future we might want to use something better later, as std::string
- * always causes a heap allocation, and is lacking in functionalities
- * cf. http://www.and.org/vstr/comparison
- */
-
-/** Shortcut for printf formats */
-typedef long unsigned int Lu;
-
-/** Shortcut for printf formats */
-typedef long long unsigned int Llu;
-
-/** Shortcut for printf formats */
-typedef long long int Lld;
-
-/**
- * Returns a std::string using printf like format facilities
- * Vanilla snprintf is about 1.5x faster than this, which is about:
- *   10x faster than boost::format;
- *   1.5x faster than std::string append (operator+=);
- *   3.5x faster than std::string operator+;
- *
- * @param fmt A printf-like format string
- * @return A new std::string with the formatted text
- */
-std::string format(const char *fmt, ...) __attribute__((format (printf, 1, 2)));
-
-/**
- * Return decimal number string separated by a separator (default: comma)
- * for every 3 digits. Only 10-15% slower than sprintf("%lld", n);
- *
- * @param n The 64-bit number
- * @param sep The separator for every 3 digits
- * @return A new std::string with the formatted text
- */
-std::string format_number(int64_t n, int sep = ',');
-
-/**
- * Return first n bytes of buffer with an optional trailer if the
- * size of the buffer exceeds n.
- *
- * @param n The max. displayed size of the buffer
- * @param buf The memory buffer
- * @param len The size of the memory buffer
- * @param trailer Appended if %len exceeds %n
- * @return A new std::string with the formatted text
- */
-std::string format_bytes(size_t n, const void *buf, size_t len,
-        const char *trailer = "...");
-
-/**
- * Return a string presentation of a sequence. Is quite slow but versatile,
- * as it uses ostringstream.
- *
- * @param seq A STL-compatible sequence with forward-directional iterators
- * @param sep A separator which is inserted after each list item
- * @return A new std::string with the formatted text
- */
-template <class SequenceT>
-    std::string format_list(const SequenceT &seq, const char *sep = ", ") {
-        typedef typename SequenceT::const_iterator Iterator;
-        Iterator it = seq.begin(), end = seq.end();
-        std::ostringstream out;
-        out << '[';
-        if (it != end) {
-            out << *it;
-            ++it;
-        }
-        for (; it != end; ++it)
-            out << sep << *it;
-        out << ']';
-        return out.str();
-    }
-
-/** Strips enclosing quotes.
- * Inspects the first and last characters of the string defined by
- * <code>input</code> and <code>input_len</code> and if they are either both
- * single quotes or double quotes, it sets <code>output</code> and
- * <code>output_len</code> to contained between them.  Otherwise,
- * <code>*output</code> is set to <code>input</code> and
- * <code>*output_len</code> is set to <code>input_len</code>.
- * @param input Input char string
- * @param input_len Input char string length
- * @param output Address of output char string pointer
- * @param output_len Address of output char string pointer
- * @return <i>true</i> if quotes were stripped, <i>false</i> otherwise.
- */
-inline bool strip_enclosing_quotes(const char *input, size_t input_len,
-        const char **output, size_t *output_len) {
-    if (input_len < 2 ||
-            !((*input == '\'' && input[input_len-1] == '\'') ||
-                (*input == '"' && input[input_len-1] == '"'))) {
-        *output = input;
-        *output_len = input_len;
-        return false;
-    }
-    *output = input + 1;
-    *output_len = input_len - 2;
-    return true;
-}
-
-/** The fast numeric formatters, very much inspired from http://cppformat.github.io/ */
-class NumericFormatterDigits {
-    protected:
-        static const char DIGITS[];
-};
-
-template<class T>
-class NumericFormatter : public NumericFormatterDigits {
-public:
-    
-    ~NumericFormatter() {}
-    
-    /**
-      Returns the number of characters written to the output buffer.
-      */
-    size_t size() const { return buf - s + BUFFER_SIZE - 1; }
-
-    /**
-      Returns a pointer to the output buffer content. No terminating null
-      character is appended.
-      */
-    const char *data() const { return str; }
-
-    /**
-      Returns a pointer to the output buffer content with terminating null
-      character appended.
-      */
-    const char *c_str() const {
-        return s;
-    }
-
-    /**
-      Returns the content of the output buffer as an `std::string`.
-      */
-    std::string str() const { return std::string(s, size()); }
-
-    /**
-      Appends the converted number to the buffer specified, returns the forwarded pointer.
-      */
-    char* append_to(char* p) const {
-        memcpy(p, s, size());
-        return p + size();
-    }
-
-protected:
-
-    NumericFormatter() {
-        buf[BUFFER_SIZE - 1] = '\0';
-    }
-
-    void format_unsigned(T value) {
-        s = buf + BUFFER_SIZE - 1;
-        while (value >= 100) {
-            // Integer division is slow so do it for a group of two digits instead
-            // of for every digit. The idea comes from the talk by Alexandrescu
-            // "Three Optimization Tips for C++". See speed-test for a comparison.
-            unsigned index = (value % 100) * 2;
-            value /= 100;
-            *--s = DIGITS[index + 1];
-            *--s = DIGITS[index];
-        }
-        if (value < 10) {
-            *--s = static_cast<char>('0' + value);
-            return;
-        }
-        unsigned index = static_cast<unsigned>(value * 2);
-        *--s = DIGITS[index + 1];
-        *--s = DIGITS[index];
-    }
-
-    void format_signed(T value) {
-        if (value >= 0) {
-            format_unsigned(value);
-        } else {
-            format_unsigned(-value);
-            *--s = '-';
-        }
-    }
-
-private:
-    enum { BUFFER_SIZE = std::numeric_limits<T>::digits10 + 3 };
-    char buf[BUFFER_SIZE];
-    char* s;
-};
-
-template<class T>
-class NumericSignedFormatter : public NumericFormatter<T> {
-    public:
-        explicit NumericSignedFormatter(T value) {
-            NumericFormatter<T>::format_signed(value);
-        }
-};
-
-template<class T>
-class NumericUnsignedFormatter : public NumericFormatter<T> {
-    public:
-        explicit NumericUnsignedFormatter(T value) {
-            NumericFormatter<T>::format_unsigned(value);
-        }
-};
-
-typedef NumericUnsignedFormatter<uint8_t> UInt8Formatter;
-typedef NumericUnsignedFormatter<uint16_t> UInt16Formatter;
-typedef NumericUnsignedFormatter<uint32_t> UInt32Formatter;
-typedef NumericUnsignedFormatter<uint64_t> UInt64Formatter;
-typedef NumericSignedFormatter<int8_t> Int8Formatter;
-typedef NumericSignedFormatter<int16_t> Int16Formatter;
-typedef NumericSignedFormatter<int32_t> Int32Formatter;
-typedef NumericSignedFormatter<int64_t> Int64Formatter;
-
-} // namespace palo
-#endif //BDG_PALO_BE_SRC_RPC_UTIL_H
diff --git a/be/src/runtime/buffer_control_block.cpp b/be/src/runtime/buffer_control_block.cpp
index bc2e6a516c6a14..b20dbd96a2a363 100644
--- a/be/src/runtime/buffer_control_block.cpp
+++ b/be/src/runtime/buffer_control_block.cpp
@@ -21,9 +21,45 @@
 #include "runtime/buffer_control_block.h"
 #include "runtime/raw_value.h"
 #include "gen_cpp/PaloInternalService_types.h"
+#include "gen_cpp/internal_service.pb.h"
+#include "util/thrift_util.h"
+#include "service/brpc.h"
 
 namespace palo {
 
+void GetResultBatchCtx::on_failure(const Status& status) {
+    DCHECK(!status.ok()) << "status is ok, errmsg=" << status.get_error_msg();
+    status.to_protobuf(result->mutable_status());
+    done->Run();
+    delete this;
+}
+
+void GetResultBatchCtx::on_close(int64_t packet_seq) {
+    Status status;
+    status.to_protobuf(result->mutable_status());
+    result->set_packet_seq(packet_seq);
+    result->set_eos(true);
+    done->Run();
+    delete this;
+}
+
+void GetResultBatchCtx::on_data(TFetchDataResult* t_result, int64_t packet_seq, bool eos) {
+    uint8_t* buf = nullptr;
+    uint32_t len = 0;
+    ThriftSerializer ser(false, 4096);
+    auto st = ser.serialize(&t_result->result_batch, &len, &buf);
+    if (st.ok()) {
+        cntl->response_attachment().append(buf, len);
+        result->set_packet_seq(packet_seq);
+        result->set_eos(eos);
+    } else {
+        LOG(WARNING) << "TFetchDataResult serialize failed, errmsg=" << st.get_error_msg();
+    }
+    st.to_protobuf(result->mutable_status());
+    done->Run();
+    delete this;
+}
+
 BufferControlBlock::BufferControlBlock(const TUniqueId& id, int buffer_size)
     : _fragment_id(id),
       _is_close(false),
@@ -64,9 +100,17 @@ Status BufferControlBlock::add_batch(TFetchDataResult* result) {
         return Status::CANCELLED;
     }
 
-    _buffer_rows += num_rows;
-    _batch_queue.push_back(result);
-    _data_arriaval.notify_one();
+    if (_waiting_rpc.empty()) {
+        _buffer_rows += num_rows;
+        _batch_queue.push_back(result);
+        _data_arriaval.notify_one();
+    } else {
+        auto ctx = _waiting_rpc.front();
+        _waiting_rpc.pop_front();
+        ctx->on_data(result, _packet_num);
+        delete result;
+        _packet_num++;
+    }
     return Status::OK;
 }
 
@@ -116,6 +160,39 @@ Status BufferControlBlock::get_batch(TFetchDataResult* result) {
     return Status::OK;
 }
 
+void BufferControlBlock::get_batch(GetResultBatchCtx* ctx) {
+    boost::lock_guard<boost::mutex> l(_lock);
+    if (!_status.ok()) {
+        ctx->on_failure(_status);
+        return;
+    }
+    if (_is_cancelled) {
+        ctx->on_failure(Status::CANCELLED);
+        return;
+    }
+    if (!_batch_queue.empty()) {
+        // get result
+        TFetchDataResult* result = _batch_queue.front();
+        _batch_queue.pop_front();
+        _buffer_rows -= result->result_batch.rows.size();
+        _data_removal.notify_one();
+
+        ctx->on_data(result, _packet_num);
+        _packet_num++;
+
+        delete result;
+        result = nullptr;
+
+        return;
+    }
+    if (_is_close) {
+        ctx->on_close(_packet_num);
+        return;
+    }
+    // no ready data, push ctx to waiting list
+    _waiting_rpc.push_back(ctx);
+}
+
 Status BufferControlBlock::close(Status exec_status) {
     boost::unique_lock<boost::mutex> l(_lock);
     _is_close = true;
@@ -123,6 +200,18 @@ Status BufferControlBlock::close(Status exec_status) {
 
     // notify blocked get thread
     _data_arriaval.notify_all();
+    if (!_waiting_rpc.empty()) {
+        if (_status.ok()) {
+            for (auto& ctx : _waiting_rpc) {
+                ctx->on_close(_packet_num);
+            }
+        } else {
+            for (auto& ctx : _waiting_rpc) {
+                ctx->on_failure(_status);
+            }
+        }
+        _waiting_rpc.clear();
+    }
     return Status::OK;
 }
 
@@ -131,8 +220,11 @@ Status BufferControlBlock::cancel() {
     _is_cancelled = true;
     _data_removal.notify_all();
     _data_arriaval.notify_all();
+    for (auto& ctx : _waiting_rpc) {
+        ctx->on_failure(Status::CANCELLED);
+    }
+    _waiting_rpc.clear();
     return Status::OK;
 }
 
 }
-/* vim: set ts=4 sw=4 sts=4 tw=100 noet: */
diff --git a/be/src/runtime/buffer_control_block.h b/be/src/runtime/buffer_control_block.h
index 1632acc537c982..252114643ddc68 100644
--- a/be/src/runtime/buffer_control_block.h
+++ b/be/src/runtime/buffer_control_block.h
@@ -22,14 +22,42 @@
 #define BDG_PALO_BE_RUNTIME_BUFFER_CONTROL_BLOCK_H
 
 #include <list>
+#include <deque>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/condition_variable.hpp>
 #include "common/status.h"
 #include "gen_cpp/Types_types.h"
 
+namespace google {
+namespace protobuf {
+class Closure;
+}
+}
+
+namespace brpc {
+class Controller;
+}
+
 namespace palo {
 
 class TFetchDataResult;
+class PFetchDataResult;
+
+struct GetResultBatchCtx {
+    brpc::Controller* cntl = nullptr;
+    PFetchDataResult* result = nullptr;
+    google::protobuf::Closure* done = nullptr;
+
+    GetResultBatchCtx(brpc::Controller* cntl_,
+                      PFetchDataResult* result_,
+                      google::protobuf::Closure* done_)
+        : cntl(cntl_), result(result_), done(done_) {
+    }
+
+    void on_failure(const Status& status);
+    void on_close(int64_t packet_seq);
+    void on_data(TFetchDataResult* t_result, int64_t packet_seq, bool eos = false);
+};
 
 // buffer used for result customer and productor
 class BufferControlBlock {
@@ -39,8 +67,12 @@ class BufferControlBlock {
 
     Status init();
     Status add_batch(TFetchDataResult* result);
+
     // get result from batch, use timeout?
     Status get_batch(TFetchDataResult* result);
+
+    void get_batch(GetResultBatchCtx* ctx);
+
     // close buffer block, set _status to exec_status and set _is_close to true;
     // called because data has been read or error happend.
     Status close(Status exec_status);
@@ -61,7 +93,7 @@ class BufferControlBlock {
     Status _status;
     int _buffer_rows;
     int _buffer_limit;
-    int _packet_num;
+    int64_t _packet_num;
 
     // blocking queue for batch
     ResultQueue _batch_queue;
@@ -71,6 +103,8 @@ class BufferControlBlock {
     boost::condition_variable _data_arriaval;
     // signal removal of data by stream consumer
     boost::condition_variable _data_removal;
+
+    std::deque<GetResultBatchCtx*> _waiting_rpc;
 };
 
 }
diff --git a/be/src/runtime/data_stream_mgr.cpp b/be/src/runtime/data_stream_mgr.cpp
index a0a3aa738a8709..3c405936fab6aa 100644
--- a/be/src/runtime/data_stream_mgr.cpp
+++ b/be/src/runtime/data_stream_mgr.cpp
@@ -31,9 +31,6 @@
 #include "runtime/runtime_state.h"
 #include "util/debug_util.h"
 
-#include "rpc/comm.h"
-#include "rpc/comm_buf.h"
-
 #include "gen_cpp/types.pb.h" // PUniqueId
 #include "gen_cpp/BackendService.h"
 #include "gen_cpp/PaloInternalService_types.h"
@@ -99,28 +96,6 @@ shared_ptr<DataStreamRecvr> DataStreamMgr::find_recvr(
     return shared_ptr<DataStreamRecvr>();
 }
 
-Status DataStreamMgr::add_data(
-        const TUniqueId& fragment_instance_id, PlanNodeId dest_node_id,
-        const TRowBatch& thrift_batch, int sender_id, bool* buffer_overflow,
-        std::pair<InetAddr, CommBufPtr> response) {
-    VLOG_ROW << "add_data(): fragment_instance_id=" << fragment_instance_id
-            << " node=" << dest_node_id
-            << " size=" << RowBatch::get_batch_size(thrift_batch);
-    shared_ptr<DataStreamRecvr> recvr = find_recvr(fragment_instance_id, dest_node_id);
-    if (recvr == NULL) {
-        // The receiver may remove itself from the receiver map via deregister_recvr()
-        // at any time without considering the remaining number of senders.
-        // As a consequence, find_recvr() may return an innocuous NULL if a thread
-        // calling deregister_recvr() beat the thread calling find_recvr()
-        // in acquiring _lock.
-        // TODO: Rethink the lifecycle of DataStreamRecvr to distinguish
-        // errors from receiver-initiated teardowns.
-        return Status::OK;
-    }
-    recvr->add_batch(thrift_batch, sender_id, buffer_overflow, response);
-    return Status::OK;
-}
-
 Status DataStreamMgr::add_data(
         const PUniqueId& finst_id, int32_t node_id,
         const PRowBatch& pb_batch, int32_t sender_id,
diff --git a/be/src/runtime/data_stream_mgr.h b/be/src/runtime/data_stream_mgr.h
index d1ef74526cfc88..8804697fbd203f 100644
--- a/be/src/runtime/data_stream_mgr.h
+++ b/be/src/runtime/data_stream_mgr.h
@@ -36,8 +36,6 @@
 #include "util/runtime_profile.h"
 #include "gen_cpp/Types_types.h"  // for TUniqueId
 
-#include "rpc/inet_addr.h"
-
 namespace google {
 namespace protobuf {
 class Closure;
@@ -50,11 +48,7 @@ class DescriptorTbl;
 class DataStreamRecvr;
 class RowBatch;
 class RuntimeState;
-class TRowBatch;
-class Comm;
-class CommBuf;
 class PRowBatch;
-typedef std::shared_ptr<CommBuf> CommBufPtr;
 class PUniqueId;
 
 // Singleton class which manages all incoming data streams at a backend node. It
@@ -96,10 +90,6 @@ class DataStreamMgr {
     // TODO: enforce per-sender quotas (something like 200% of buffer_size/#senders),
     // so that a single sender can't flood the buffer and stall everybody else.
     // Returns OK if successful, error status otherwise.
-    Status add_data(const TUniqueId& fragment_instance_id, PlanNodeId dest_node_id,
-            const TRowBatch& thrift_batch, int sender_id, bool* buffer_overflow,
-                    std::pair<InetAddr, CommBufPtr> response);
-
     Status add_data(const PUniqueId& fragment_instance_id, int32_t node_id,
                     const PRowBatch& pb_batch, int32_t sender_id,
                     int32_t be_number, int64_t packet_seq,
diff --git a/be/src/runtime/data_stream_recvr.cc b/be/src/runtime/data_stream_recvr.cc
index c8f39942c08e5a..e6b1f7d83267e1 100644
--- a/be/src/runtime/data_stream_recvr.cc
+++ b/be/src/runtime/data_stream_recvr.cc
@@ -29,7 +29,6 @@
 #include <google/protobuf/stubs/common.h>
 
 #include "gen_cpp/data.pb.h"
-#include "rpc/comm.h"
 #include "runtime/data_stream_mgr.h"
 #include "runtime/row_batch.h"
 #include "runtime/sorted_run_merger.h"
@@ -74,11 +73,6 @@ class DataStreamRecvr::SenderQueue {
     // blocks if this will make the stream exceed its buffer limit.
     // If the total size of the batches in this queue would exceed the allowed buffer size,
     // the queue is considered full and the call blocks until a batch is dequeued.
-    void add_batch(
-            const TRowBatch& batch,
-            bool* is_buf_overflow,
-            std::pair<InetAddr, CommBufPtr> response);
-
     void add_batch(
         const PRowBatch& pb_batch,
         int be_number, int64_t packet_seq,
@@ -137,9 +131,6 @@ class DataStreamRecvr::SenderQueue {
     std::unordered_set<int> _sender_eos_set; // sender_id
     std::unordered_map<int, int64_t> _packet_seq_map; // be_number => packet_seq
 
-    typedef std::list<std::pair<InetAddr, CommBufPtr>> ResponseQueue;
-    ResponseQueue _response_queue;
-
     std::deque<google::protobuf::Closure*> _pending_closures;
 };
 
@@ -188,14 +179,6 @@ Status DataStreamRecvr::SenderQueue::get_batch(RowBatch** next_batch) {
     _current_batch.reset(result);
     *next_batch = _current_batch.get();
 
-    {
-        Comm* comm = Comm::instance();
-        if (!_response_queue.empty()) {
-            std::pair<InetAddr, CommBufPtr> response = _response_queue.front();
-            comm->send_response(response.first, response.second);
-            _response_queue.pop_front();
-        }
-    }
     if (!_pending_closures.empty()) {
         auto done = _pending_closures.front();
         done->Run();
@@ -205,77 +188,6 @@ Status DataStreamRecvr::SenderQueue::get_batch(RowBatch** next_batch) {
     return Status::OK;
 }
 
-void DataStreamRecvr::SenderQueue::add_batch(const TRowBatch& thrift_batch,
-                                             bool* is_buf_overflow,
-                                             std::pair<InetAddr, CommBufPtr> response) {
-    unique_lock<mutex> l(_lock);
-    if (_is_cancelled) {
-        return;
-    }
-
-    auto iter = _packet_seq_map.find(thrift_batch.be_number);
-    if (iter != _packet_seq_map.end()) {
-        if (iter->second >= thrift_batch.packet_seq) {
-            // already recept
-            LOG(WARNING) << "packet already exist [cur_packet_id= " << iter->second
-                         << " receive_packet_id=" << thrift_batch.packet_seq << "]";
-            // COUNTER_UPDATE(_duplicate_packets_counter, 1);
-            return ;
-        }
-    }
-    _packet_seq_map[thrift_batch.be_number] = thrift_batch.packet_seq;
-
-    int batch_size = RowBatch::get_batch_size(thrift_batch);
-    COUNTER_UPDATE(_recvr->_bytes_received_counter, batch_size);
-
-    // Following situation will match the following condition.
-    // Sender send a packet failed, then close the channel.
-    // but closed packet reach first, then the failed packet.
-    // Then meet the assert
-    // we remove the assert
-    // DCHECK_GT(_num_remaining_senders, 0);
-    if (_num_remaining_senders <= 0) {
-        DCHECK(_sender_eos_set.end() != _sender_eos_set.find(thrift_batch.be_number));
-        return;
-    }
-
-    // We always accept the batch regardless of buffer limit, to avoid rpc pipeline stall.
-    // If exceed buffer limit, we just do not respoinse ACK to client, so the client won't
-    // send data until receive ACK.
-    // Note that if this be needs to receive data from N BEs, the size of buffer
-    // may reach as many as (buffer_size + n * buffer_size)
-    //
-    // Note: It's important that we enqueue thrift_batch regardless of buffer limit if
-    //  the queue is currently empty. In the case of a merging receiver, batches are
-    //  received from a specific queue based on data order, and the pipeline will stall
-    //  if the merger is waiting for data from an empty queue that cannot be filled
-    //  because the limit has been reached.
-
-    if (_is_cancelled) {
-        return;
-    }
-
-    RowBatch* batch = NULL;
-    {
-        SCOPED_TIMER(_recvr->_deserialize_row_batch_timer);
-        // Note: if this function makes a row batch, the batch *must* be added
-        // to _batch_queue. It is not valid to create the row batch and destroy
-        // it in this thread.
-        batch = new RowBatch(_recvr->row_desc(), thrift_batch, _recvr->mem_tracker());
-    }
-    VLOG_ROW << "added #rows=" << batch->num_rows()
-        << " batch_size=" << batch_size << "\n";
-    _batch_queue.push_back(make_pair(batch_size, batch));
-
-    if (_recvr->exceeds_limit(batch_size)) {
-        *is_buf_overflow = true;
-        _response_queue.push_back(response);
-    }
-
-    _recvr->_num_buffered_bytes += batch_size;
-    _data_arrival_cv.notify_one();
-}
-
 void DataStreamRecvr::SenderQueue::add_batch(
         const PRowBatch& pb_batch,
         int be_number, int64_t packet_seq,
@@ -383,13 +295,6 @@ void DataStreamRecvr::SenderQueue::cancel() {
 
     {
         boost::lock_guard<boost::mutex> l(_lock);
-        Comm* comm = Comm::instance();
-        while (!_response_queue.empty()) {
-            std::pair<InetAddr, CommBufPtr> response = _response_queue.front();
-            comm->send_response(response.first, response.second);
-            _response_queue.pop_front();
-        }
-
         for (auto done : _pending_closures) {
             done->Run();
         }
@@ -405,14 +310,6 @@ void DataStreamRecvr::SenderQueue::close() {
         boost::lock_guard<boost::mutex> l(_lock);
         _is_cancelled = true;
 
-        // make all pending RPC done
-        Comm* comm = Comm::instance();
-        while (!_response_queue.empty()) {
-            std::pair<InetAddr, CommBufPtr> response = _response_queue.front();
-            comm->send_response(response.first, response.second);
-            _response_queue.pop_front();
-        }
-
         for (auto done : _pending_closures) {
             done->Run();
         }
@@ -495,14 +392,6 @@ Status DataStreamRecvr::get_next(RowBatch* output_batch, bool* eos) {
     return _merger->get_next(output_batch, eos);
 }
 
-void DataStreamRecvr::add_batch(
-        const TRowBatch& thrift_batch, int sender_id,
-        bool* is_buf_overflow, std::pair<InetAddr, CommBufPtr> response) {
-    int use_sender_id = _is_merging ? sender_id : 0;
-    // Add all batches to the same queue if _is_merging is false.
-    _sender_queues[use_sender_id]->add_batch(thrift_batch, is_buf_overflow, response);
-}
-
 void DataStreamRecvr::add_batch(
         const PRowBatch& batch, int sender_id,
         int be_number, int64_t packet_seq,
diff --git a/be/src/runtime/data_stream_recvr.h b/be/src/runtime/data_stream_recvr.h
index 2a5a7aa7e97bb5..fc52f8826424ce 100644
--- a/be/src/runtime/data_stream_recvr.h
+++ b/be/src/runtime/data_stream_recvr.h
@@ -27,10 +27,8 @@
 #include "common/object_pool.h"
 #include "common/status.h"
 #include "gen_cpp/Types_types.h" // for TUniqueId
-#include "gen_cpp/Data_types.h"  // for TRowBatch
 #include "runtime/descriptors.h"
 #include "util/tuple_row_compare.h"
-#include "rpc/inet_addr.h"
 
 namespace google {
 namespace protobuf {
@@ -47,10 +45,6 @@ class RowBatch;
 class RuntimeProfile;
 class PRowBatch;
 
-class Comm;
-class CommBuf;
-typedef std::shared_ptr<CommBuf> CommBufPtr;
-
 // Single receiver of an m:n data stream.
 // DataStreamRecvr maintains one or more queues of row batches received by a
 // DataStreamMgr from one or more sender fragment instances.
@@ -117,11 +111,6 @@ class DataStreamRecvr {
             PlanNodeId dest_node_id, int num_senders, bool is_merging, int total_buffer_limit,
             RuntimeProfile* profile);
 
-    // Add a new batch of rows to the appropriate sender queue, blocking if the queue is
-    // full. Called from DataStreamMgr.
-    void add_batch(const TRowBatch& thrift_batch, int sender_id,
-                   bool* is_buf_overflow, std::pair<InetAddr, CommBufPtr> response);
-
     // If receive queue is full, done is enqueue pending, and return with *done is nullptr
     void add_batch(const PRowBatch& batch, int sender_id,
                    int be_number, int64_t packet_seq,
diff --git a/be/src/runtime/data_stream_sender.cpp b/be/src/runtime/data_stream_sender.cpp
index 539e729d428ebf..2afa6f9bbbb6e4 100644
--- a/be/src/runtime/data_stream_sender.cpp
+++ b/be/src/runtime/data_stream_sender.cpp
@@ -46,18 +46,11 @@
 #include "gen_cpp/BackendService.h"
 #include "gen_cpp/internal_service.pb.h"
 
-#include "rpc/connection_manager.h"
-#include "rpc/dispatch_handler_synchronizer.h"
-#include "rpc/event.h"
-#include "rpc/protocol.h"
-#include "rpc/error.h"
-#include "rpc/serialization.h"
 #include <arpa/inet.h>
 
 #include "service/brpc.h"
 
 #include "util/thrift_util.h"
-#include "util/rpc_channel.h"
 #include "util/brpc_stub_cache.h"
 
 namespace palo {
@@ -99,7 +92,6 @@ class DataStreamSender::Channel {
     // how much tuple data is getting accumulated before being sent; it only applies
     // when data is added via add_row() and not sent directly via send_batch().
     Channel(DataStreamSender* parent, const RowDescriptor& row_desc,
-            const TNetworkAddress& destination, 
             const TNetworkAddress& brpc_dest,
             const TUniqueId& fragment_instance_id,
             PlanNodeId dest_node_id, int buffer_size) :
@@ -111,8 +103,6 @@ class DataStreamSender::Channel {
         _num_data_bytes_sent(0),
         _packet_seq(0),
         _need_close(false),
-        _thrift_serializer(false, 1024),
-        _dest_addr(destination),
         _brpc_dest_addr(brpc_dest) {
     }
 
@@ -137,7 +127,6 @@ class DataStreamSender::Channel {
     // Returns the status of the most recently finished transmit_data
     // rpc (or OK if there wasn't one that hasn't been reported yet).
     // if batch is nullptr, send the eof packet
-    Status send_batch(TRowBatch* batch);
     Status send_batch(PRowBatch* batch, bool eos = false);
 
     // Flush buffered rows and close channel.
@@ -148,15 +137,9 @@ class DataStreamSender::Channel {
         return _num_data_bytes_sent;
     }
 
-    TRowBatch* thrift_batch() { 
-        return &_thrift_batch;
-    }
     PRowBatch* pb_batch() { 
         return &_pb_batch;
     }
-    bool use_brpc() const {
-        return _brpc_stub != nullptr;
-    }
 
 private:
     inline Status _wait_last_brpc() {
@@ -165,7 +148,7 @@ class DataStreamSender::Channel {
         if (cntl->Failed()) {
             LOG(WARNING) << "failed to send brpc batch, error=" << berror(cntl->ErrorCode())
                 << ", error_text=" << cntl->ErrorText();
-            return Status("failed to send batch");
+            return Status(TStatusCode::THRIFT_RPC_ERROR, "failed to send batch");
         }
         return Status::OK;
     }
@@ -190,19 +173,11 @@ class DataStreamSender::Channel {
 
     // we're accumulating rows into this batch
     boost::scoped_ptr<RowBatch> _batch;
-    TRowBatch _thrift_batch;
 
     bool _need_close;
     int _be_number;
 
-    ThriftSerializer _thrift_serializer;
-
-    TNetworkAddress _dest_addr;
     TNetworkAddress _brpc_dest_addr;
-    uint32_t _connect_timeout_ms = 500;
-    uint32_t _rpc_timeout_ms = 1000;
-
-    std::shared_ptr<RpcChannel> _rpc_channel;
 
     // TODO(zc): initused for brpc
     PUniqueId _finst_id;
@@ -220,57 +195,25 @@ Status DataStreamSender::Channel::init(RuntimeState* state) {
     int capacity = std::max(1, _buffer_size / std::max(_row_desc.get_row_size(), 1));
     _batch.reset(new RowBatch(_row_desc, capacity, _parent->_mem_tracker.get()));
 
-    {
-        // One hour is max rpc timeout
-        _rpc_timeout_ms = std::min(3600, std::max(1, state->query_options().query_timeout / 2)) * 1000;
-
-        _rpc_channel = std::make_shared<RpcChannel>(
-            Comm::instance(), state->exec_env()->get_conn_manager(), 0);
-        RETURN_IF_ERROR(_rpc_channel->init(_dest_addr.hostname, _dest_addr.port,
-                                           _connect_timeout_ms, _rpc_timeout_ms));
-    }
-    if (!_brpc_dest_addr.hostname.empty()) {
-        // initialize brpc request
-        _finst_id.set_hi(_fragment_instance_id.hi);
-        _finst_id.set_lo(_fragment_instance_id.lo);
-        _brpc_request.set_allocated_finst_id(&_finst_id);
-        _brpc_request.set_node_id(_dest_node_id);
-        _brpc_request.set_sender_id(_parent->_sender_id);
-        _brpc_request.set_be_number(_be_number);
-
-        _brpc_timeout_ms = std::min(3600, state->query_options().query_timeout) * 1000;
-        _brpc_stub = state->exec_env()->brpc_stub_cache()->get_stub(_brpc_dest_addr);
+    if (_brpc_dest_addr.hostname.empty()) {
+        LOG(WARNING) << "there is no brpc destination address's hostname"
+            ", maybe version is not compatible.";
+        return Status("no brpc destination");
     }
-    _need_close = true;
-    return Status::OK;
-}
-
-Status DataStreamSender::Channel::send_batch(TRowBatch* batch) {
-    VLOG_ROW << "Channel::send_batch() instance_id=" << _fragment_instance_id
-             << " dest_node=" << _dest_node_id;
-    TTransmitDataParams params;
-    params.protocol_version = PaloInternalServiceVersion::V1;
-    params.__set_dest_fragment_instance_id(_fragment_instance_id);
-    params.__set_dest_node_id(_dest_node_id);
-    params.__set_be_number(_be_number);
-    params.__set_sender_id(_parent->_sender_id);
 
-    if (batch != nullptr) {
-        batch->be_number = _be_number;
-        batch->packet_seq = _packet_seq++;
-        params.__set_row_batch(*batch);  // yet another copy
-        params.__set_packet_seq(batch->packet_seq);
-        params.__set_eos(false);
-    } else {
-        params.__set_packet_seq(_packet_seq++);
-        params.__set_eos(true);
-    }
+    // initialize brpc request
+    _finst_id.set_hi(_fragment_instance_id.hi);
+    _finst_id.set_lo(_fragment_instance_id.lo);
+    _brpc_request.set_allocated_finst_id(&_finst_id);
+    _brpc_request.set_node_id(_dest_node_id);
+    _brpc_request.set_sender_id(_parent->_sender_id);
+    _brpc_request.set_be_number(_be_number);
 
-    uint8_t* serialized_buf = nullptr;
-    uint32_t serialized_buf_bytes = 0;
-    _thrift_serializer.serialize(&params, &serialized_buf_bytes, &serialized_buf);
+    _brpc_timeout_ms = std::min(3600, state->query_options().query_timeout) * 1000;
+    _brpc_stub = state->exec_env()->brpc_stub_cache()->get_stub(_brpc_dest_addr);
 
-    return _rpc_channel->send_message(serialized_buf, serialized_buf_bytes);
+    _need_close = true;
+    return Status::OK;
 }
 
 Status DataStreamSender::Channel::send_batch(PRowBatch* batch, bool eos) {
@@ -328,25 +271,14 @@ Status DataStreamSender::Channel::add_row(TupleRow* row) {
 }
 
 Status DataStreamSender::Channel::send_current_batch(bool eos) {
-    if (use_brpc()) {
-        {
-            SCOPED_TIMER(_parent->_serialize_batch_timer);
-            int uncompressed_bytes = _batch->serialize(&_pb_batch);
-            COUNTER_UPDATE(_parent->_bytes_sent_counter, RowBatch::get_batch_size(_pb_batch));
-            COUNTER_UPDATE(_parent->_uncompressed_bytes_counter, uncompressed_bytes);
-        }
-        _batch->reset();
-        RETURN_IF_ERROR(send_batch(&_pb_batch, eos));
-    } else {
-        {
-            SCOPED_TIMER(_parent->_serialize_batch_timer);
-            int uncompressed_bytes = _batch->serialize(&_thrift_batch);
-            COUNTER_UPDATE(_parent->_bytes_sent_counter, RowBatch::get_batch_size(_thrift_batch));
-            COUNTER_UPDATE(_parent->_uncompressed_bytes_counter, uncompressed_bytes);
-        }
-        _batch->reset();
-        RETURN_IF_ERROR(send_batch(&_thrift_batch));
+    {
+        SCOPED_TIMER(_parent->_serialize_batch_timer);
+        int uncompressed_bytes = _batch->serialize(&_pb_batch);
+        COUNTER_UPDATE(_parent->_bytes_sent_counter, RowBatch::get_batch_size(_pb_batch));
+        COUNTER_UPDATE(_parent->_uncompressed_bytes_counter, uncompressed_bytes);
     }
+    _batch->reset();
+    RETURN_IF_ERROR(send_batch(&_pb_batch, eos));
     return Status::OK;
 }
 
@@ -357,20 +289,12 @@ Status DataStreamSender::Channel::close_internal() {
     VLOG_RPC << "Channel::close() instance_id=" << _fragment_instance_id
              << " dest_node=" << _dest_node_id
              << " #rows= " << _batch->num_rows();
-    if (use_brpc()) {
-        if (_batch != NULL && _batch->num_rows() > 0) {
-            RETURN_IF_ERROR(send_current_batch(true));
-        } else {
-            RETURN_IF_ERROR(send_batch(nullptr, true));
-        }
-        RETURN_IF_ERROR(_wait_last_brpc());
+    if (_batch != NULL && _batch->num_rows() > 0) {
+        RETURN_IF_ERROR(send_current_batch(true));
     } else {
-        if (_batch != NULL && _batch->num_rows() > 0) {
-            RETURN_IF_ERROR(send_current_batch());
-        }
-        RETURN_IF_ERROR(send_batch((TRowBatch*)nullptr));
-        RETURN_IF_ERROR(_rpc_channel->wait_last_sent());
+        RETURN_IF_ERROR(send_batch(nullptr, true));
     }
+    RETURN_IF_ERROR(_wait_last_brpc());
     _need_close = false;
     return Status::OK;
 }
@@ -391,7 +315,6 @@ DataStreamSender::DataStreamSender(
         _current_channel_idx(0),
         _part_type(sink.output_partition.type),
         _ignore_not_found(sink.__isset.ignore_not_found ? sink.ignore_not_found : true),
-        _current_thrift_batch(&_thrift_batch1),
         _current_pb_batch(&_pb_batch1),
         _profile(NULL),
         _serialize_batch_timer(NULL),
@@ -406,7 +329,7 @@ DataStreamSender::DataStreamSender(
     // TODO: use something like google3's linked_ptr here (scoped_ptr isn't copyable)
     for (int i = 0; i < destinations.size(); ++i) {
         _channel_shared_ptrs.emplace_back(
-            new Channel(this, row_desc, destinations[i].server,
+            new Channel(this, row_desc,
                         destinations[i].brpc_server,
                         destinations[i].fragment_instance_id,
                         sink.dest_node_id, per_channel_buffer_size));
@@ -493,13 +416,8 @@ Status DataStreamSender::prepare(RuntimeState* state) {
         profile()->add_derived_counter("OverallThroughput", TUnit::BYTES_PER_SECOND,
         boost::bind<int64_t>(&RuntimeProfile::units_per_second, _bytes_sent_counter,
                                              profile()->total_time_counter()), "");
-
-    _use_brpc = true;
     for (int i = 0; i < _channels.size(); ++i) {
         RETURN_IF_ERROR(_channels[i]->init(state));
-        if (_use_brpc && !_channels[i]->use_brpc()) {
-            _use_brpc = false;
-        }
     }
 
     return Status::OK;
@@ -525,40 +443,18 @@ Status DataStreamSender::send(RuntimeState* state, RowBatch* batch) {
 
     // Unpartition or _channel size
     if (_part_type == TPartitionType::UNPARTITIONED || _channels.size() == 1) {
-        if (_use_brpc) {
-            RETURN_IF_ERROR(serialize_batch(batch, _current_pb_batch, _channels.size()));
-            for (auto channel : _channels) {
-                RETURN_IF_ERROR(channel->send_batch(_current_pb_batch));
-            }
-            _current_pb_batch = (_current_pb_batch == &_pb_batch1 ? &_pb_batch2 : &_pb_batch1);
-        } else {
-            // _current_thrift_batch is *not* the one that was written by the last call
-            // to Serialize()
-            RETURN_IF_ERROR(serialize_batch(batch, _current_thrift_batch, _channels.size()));
-            // SendBatch() will block if there are still in-flight rpcs (and those will
-            // reference the previously written thrift batch)
-            for (int i = 0; i < _channels.size(); ++i) {
-                RETURN_IF_ERROR(_channels[i]->send_batch(_current_thrift_batch));
-            }
-            _current_thrift_batch =
-                (_current_thrift_batch == &_thrift_batch1 ? &_thrift_batch2 : &_thrift_batch1);
+        RETURN_IF_ERROR(serialize_batch(batch, _current_pb_batch, _channels.size()));
+        for (auto channel : _channels) {
+            RETURN_IF_ERROR(channel->send_batch(_current_pb_batch));
         }
+        _current_pb_batch = (_current_pb_batch == &_pb_batch1 ? &_pb_batch2 : &_pb_batch1);
     } else if (_part_type == TPartitionType::RANDOM) {
-        if (_use_brpc) {
-            // Round-robin batches among channels. Wait for the current channel to finish its
-            // rpc before overwriting its batch.
-            Channel* current_channel = _channels[_current_channel_idx];
-            RETURN_IF_ERROR(serialize_batch(batch, current_channel->pb_batch()));
-            RETURN_IF_ERROR(current_channel->send_batch(current_channel->pb_batch()));
-            _current_channel_idx = (_current_channel_idx + 1) % _channels.size();
-        } else {
-            // Round-robin batches among channels. Wait for the current channel to finish its
-            // rpc before overwriting its batch.
-            Channel* current_channel = _channels[_current_channel_idx];
-            RETURN_IF_ERROR(serialize_batch(batch, current_channel->thrift_batch()));
-            RETURN_IF_ERROR(current_channel->send_batch(current_channel->thrift_batch()));
-            _current_channel_idx = (_current_channel_idx + 1) % _channels.size();
-        }
+        // Round-robin batches among channels. Wait for the current channel to finish its
+        // rpc before overwriting its batch.
+        Channel* current_channel = _channels[_current_channel_idx];
+        RETURN_IF_ERROR(serialize_batch(batch, current_channel->pb_batch()));
+        RETURN_IF_ERROR(current_channel->send_batch(current_channel->pb_batch()));
+        _current_channel_idx = (_current_channel_idx + 1) % _channels.size();
     } else if (_part_type == TPartitionType::HASH_PARTITIONED) {
         // hash-partition batch's rows across channels
         int num_channels = _channels.size();
diff --git a/be/src/runtime/data_stream_sender.h b/be/src/runtime/data_stream_sender.h
index ba09e70dc5c2ec..afc006aa386b1c 100644
--- a/be/src/runtime/data_stream_sender.h
+++ b/be/src/runtime/data_stream_sender.h
@@ -29,13 +29,8 @@
 #include "common/object_pool.h"
 #include "common/status.h"
 #include "util/runtime_profile.h"
-#include "gen_cpp/Data_types.h"  // for TRowBatch
 #include "gen_cpp/data.pb.h"  // for PRowBatch
 
-#include "rpc/dispatch_handler.h"
-#include "rpc/io_handler.h"
-#include "rpc/poll_event.h"
-
 namespace palo {
 
 class ExprContext;
@@ -138,15 +133,8 @@ class DataStreamSender : public DataSink {
     TPartitionType::type _part_type;
     bool _ignore_not_found;
 
-    // use this flag to back-compatible for old data transmit
-    bool _use_brpc = false;
-
     // serialized batches for broadcasting; we need two so we can write
     // one while the other one is still being sent
-    TRowBatch _thrift_batch1;
-    TRowBatch _thrift_batch2;
-    TRowBatch* _current_thrift_batch;  // the next one to fill in send()
-
     PRowBatch _pb_batch1;
     PRowBatch _pb_batch2;
     PRowBatch* _current_pb_batch = nullptr;
diff --git a/be/src/runtime/etl_job_mgr.cpp b/be/src/runtime/etl_job_mgr.cpp
index 756a29b24675a0..272397b235dc94 100644
--- a/be/src/runtime/etl_job_mgr.cpp
+++ b/be/src/runtime/etl_job_mgr.cpp
@@ -49,7 +49,7 @@ std::string EtlJobMgr::to_load_error_http_path(const std::string& file_name) {
     std::stringstream url;
     url << "http://" << BackendOptions::get_localhost() << ":" << config::webserver_port
         << "/api/_load_error_log?"
-        << "&file=" << file_name;
+        << "file=" << file_name;
     return url.str();
 }
 
diff --git a/be/src/runtime/exec_env.cpp b/be/src/runtime/exec_env.cpp
index a9038c867865de..de00048cefe365 100644
--- a/be/src/runtime/exec_env.cpp
+++ b/be/src/runtime/exec_env.cpp
@@ -25,7 +25,6 @@
 #include <boost/algorithm/string.hpp>
 
 #include "common/logging.h"
-#include "rpc/connection_manager.h"
 #include "runtime/broker_mgr.h"
 #include "runtime/bufferpool/buffer_pool.h"
 #include "runtime/client_cache.h"
@@ -39,12 +38,12 @@
 #include "runtime/bufferpool/reservation_tracker.h"
 #include "util/metrics.h"
 #include "util/network_util.h"
-#include "http/webserver.h"
 #include "http/web_page_handler.h"
 #include "http/default_path_handlers.h"
 #include "util/parse_util.h"
 #include "util/mem_info.h"
 #include "util/debug_util.h"
+#include "http/ev_http_server.h"
 #include "http/action/mini_load.h"
 #include "http/action/checksum_action.h"
 #include "http/action/health_action.h"
@@ -79,8 +78,8 @@ ExecEnv::ExecEnv() :
         _client_cache(new BackendServiceClientCache()),
         _frontend_client_cache(new FrontendServiceClientCache()),
         _broker_client_cache(new BrokerServiceClientCache()),
-        _webserver(new Webserver()),
-        _web_page_handler(new WebPageHandler(_webserver.get())),
+        _ev_http_server(new EvHttpServer(config::webserver_port, config::webserver_num_workers)),
+        _web_page_handler(new WebPageHandler(_ev_http_server.get())),
         _mem_tracker(NULL),
         _pool_mem_trackers(new PoolMemTrackerRegistry),
         _thread_mgr(new ThreadResourceMgr),
@@ -133,9 +132,6 @@ Status ExecEnv::init_for_tests() {
 Status ExecEnv::start_services() {
     LOG(INFO) << "Starting global services";
 
-    //create connection manger
-    _conn_mgr = std::make_shared<ConnectionManager>();
-
     // Initialize global memory limit.
     int64_t bytes_limit = 0;
     bool is_percent = false;
@@ -202,7 +198,7 @@ Status ExecEnv::start_services() {
 
 Status ExecEnv::start_webserver() {
     add_default_path_handlers(_web_page_handler.get(), _mem_tracker.get());
-    _webserver->register_handler(HttpMethod::PUT,
+    _ev_http_server->register_handler(HttpMethod::PUT,
                                  "/api/{db}/{table}/_load",
                                  new MiniLoadAction(this));
 
@@ -210,57 +206,57 @@ Status ExecEnv::start_webserver() {
     OLAPRootPath::get_instance()->get_all_available_root_path(&allow_paths);
     DownloadAction* download_action = new DownloadAction(this, allow_paths);
     // = new DownloadAction(this, config::mini_load_download_path);
-    _webserver->register_handler(HttpMethod::GET, "/api/_download_load", download_action);
-    _webserver->register_handler(HttpMethod::HEAD, "/api/_download_load", download_action);
+    _ev_http_server->register_handler(HttpMethod::GET, "/api/_download_load", download_action);
+    _ev_http_server->register_handler(HttpMethod::HEAD, "/api/_download_load", download_action);
 
     DownloadAction* tablet_download_action = new DownloadAction(this, allow_paths);
-    _webserver->register_handler(HttpMethod::HEAD,
+    _ev_http_server->register_handler(HttpMethod::HEAD,
                                  "/api/_tablet/_download",
                                  tablet_download_action);
-    _webserver->register_handler(HttpMethod::GET,
+    _ev_http_server->register_handler(HttpMethod::GET,
                                  "/api/_tablet/_download",
                                  tablet_download_action);
 
     DownloadAction* error_log_download_action = new DownloadAction(
             this, _load_path_mgr->get_load_error_file_dir());
-    _webserver->register_handler(
+    _ev_http_server->register_handler(
             HttpMethod::GET, "/api/_load_error_log", error_log_download_action);
-    _webserver->register_handler(
+    _ev_http_server->register_handler(
             HttpMethod::HEAD, "/api/_load_error_log", error_log_download_action);
 
     // Register monitor
     MonitorAction* monitor_action = new MonitorAction();
     monitor_action->register_module("etl_mgr", etl_job_mgr());
     monitor_action->register_module("fragment_mgr", fragment_mgr());
-    _webserver->register_handler(HttpMethod::GET, "/_monitor/{module}", monitor_action);
+    _ev_http_server->register_handler(HttpMethod::GET, "/_monitor/{module}", monitor_action);
 
     // Register BE health action
     HealthAction* health_action = new HealthAction(this);
-    _webserver->register_handler(HttpMethod::GET, "/api/health", health_action);
+    _ev_http_server->register_handler(HttpMethod::GET, "/api/health", health_action);
 
     // register pprof actions
-    PprofActions::setup(this, _webserver.get());
+    PprofActions::setup(this, _ev_http_server.get());
 
     {
         auto action = _object_pool.add(new MetricsAction(PaloMetrics::metrics()));
-        _webserver->register_handler(HttpMethod::GET, "/metrics", action);
+        _ev_http_server->register_handler(HttpMethod::GET, "/metrics", action);
     }
 
 #ifndef BE_TEST
     // Register BE checksum action
     ChecksumAction* checksum_action = new ChecksumAction(this);
-    _webserver->register_handler(HttpMethod::GET, "/api/checksum", checksum_action);
+    _ev_http_server->register_handler(HttpMethod::GET, "/api/checksum", checksum_action);
 
     // Register BE reload tablet action
     ReloadTabletAction* reload_tablet_action = new ReloadTabletAction(this);
-    _webserver->register_handler(HttpMethod::GET, "/api/reload_tablet", reload_tablet_action);
+    _ev_http_server->register_handler(HttpMethod::GET, "/api/reload_tablet", reload_tablet_action);
 
     // Register BE snapshot action
     SnapshotAction* snapshot_action = new SnapshotAction(this);
-    _webserver->register_handler(HttpMethod::GET, "/api/snapshot", snapshot_action);
+    _ev_http_server->register_handler(HttpMethod::GET, "/api/snapshot", snapshot_action);
 #endif
 
-    RETURN_IF_ERROR(_webserver->start());
+    RETURN_IF_ERROR(_ev_http_server->start());
     return Status::OK;
 }
 
diff --git a/be/src/runtime/exec_env.h b/be/src/runtime/exec_env.h
index bde15b7b2c18a6..797a9ba3c1dc62 100644
--- a/be/src/runtime/exec_env.h
+++ b/be/src/runtime/exec_env.h
@@ -40,7 +40,7 @@ namespace palo {
 class DataStreamMgr;
 class ResultBufferMgr;
 class TestExecEnv;
-class Webserver;
+class EvHttpServer;
 class WebPageHandler;
 class MemTracker;
 class PoolMemTrackerRegistry;
@@ -57,7 +57,6 @@ class BrokerMgr;
 class MetricRegistry;
 class BufferPool;
 class ReservationTracker;
-class ConnectionManager;
 class BrpcStubCache;
 
 // Execution environment for queries/plan fragments.
@@ -98,9 +97,6 @@ class ExecEnv {
     BrokerServiceClientCache* broker_client_cache() {
         return _broker_client_cache.get();
     }
-    Webserver* webserver() {
-        return _webserver.get();
-    }
     WebPageHandler* web_page_handler() {
         return _web_page_handler.get();
     }
@@ -157,10 +153,6 @@ class ExecEnv {
         return _brpc_stub_cache.get();
     }
 
-    std::shared_ptr<ConnectionManager> get_conn_manager() {
-        return _conn_mgr;
-    }
-
     void set_enable_webserver(bool enable) {
         _enable_webserver = enable;
     }
@@ -187,7 +179,7 @@ class ExecEnv {
     boost::scoped_ptr<BackendServiceClientCache> _client_cache;
     boost::scoped_ptr<FrontendServiceClientCache> _frontend_client_cache;
     std::unique_ptr<BrokerServiceClientCache>_broker_client_cache;
-    boost::scoped_ptr<Webserver> _webserver;
+    boost::scoped_ptr<EvHttpServer> _ev_http_server;
     boost::scoped_ptr<WebPageHandler> _web_page_handler;
     boost::scoped_ptr<MemTracker> _mem_tracker;
     boost::scoped_ptr<PoolMemTrackerRegistry> _pool_mem_trackers;
@@ -211,13 +203,6 @@ class ExecEnv {
     boost::scoped_ptr<ReservationTracker> _buffer_reservation;
     boost::scoped_ptr<BufferPool> _buffer_pool;
 
-    /*
-    Comm* comm;
-    DispatchHandlerPtr dhp;
-    ApplicationQueue *app_queue;
-    */
-    std::shared_ptr<ConnectionManager> _conn_mgr;
-
     ObjectPool _object_pool;
 private:
     static ExecEnv* _exec_env;
diff --git a/be/src/runtime/fragment_mgr.cpp b/be/src/runtime/fragment_mgr.cpp
index 9927ace5140df5..f687d3f7f0d028 100644
--- a/be/src/runtime/fragment_mgr.cpp
+++ b/be/src/runtime/fragment_mgr.cpp
@@ -224,7 +224,7 @@ std::string FragmentExecState::to_load_error_http_path(const std::string& file_n
     std::stringstream url;
     url << "http://" << BackendOptions::get_localhost() << ":" << config::webserver_port
         << "/api/_load_error_log?"
-        << "&file=" << file_name;
+        << "file=" << file_name;
     return url.str();
 }
 
diff --git a/be/src/runtime/plan_fragment_executor.h b/be/src/runtime/plan_fragment_executor.h
index abc19b5dc2a865..da8c9d722d1107 100644
--- a/be/src/runtime/plan_fragment_executor.h
+++ b/be/src/runtime/plan_fragment_executor.h
@@ -39,7 +39,6 @@ class DataSink;
 class DataStreamMgr;
 class RuntimeProfile;
 class RuntimeState;
-class TRowBatch;
 class TPlanExecRequest;
 class TPlanFragment;
 class TPlanFragmentExecParams;
@@ -190,7 +189,6 @@ class PlanFragmentExecutor {
     boost::scoped_ptr<DataSink> _sink;
     boost::scoped_ptr<RuntimeState> _runtime_state;
     boost::scoped_ptr<RowBatch> _row_batch;
-    boost::scoped_ptr<TRowBatch> _thrift_batch;
 
     // Number of rows returned by this fragment
     RuntimeProfile::Counter* _rows_produced_counter;
diff --git a/be/src/runtime/result_buffer_mgr.cpp b/be/src/runtime/result_buffer_mgr.cpp
index 78dc1b6d68e779..10c01be8c1b340 100644
--- a/be/src/runtime/result_buffer_mgr.cpp
+++ b/be/src/runtime/result_buffer_mgr.cpp
@@ -24,6 +24,7 @@
 #include "runtime/raw_value.h"
 #include "util/debug_util.h"
 #include "gen_cpp/PaloInternalService_types.h"
+#include "gen_cpp/types.pb.h"
 
 namespace palo {
 
@@ -92,6 +93,19 @@ Status ResultBufferMgr::fetch_data(
     return cb->get_batch(result);
 }
 
+void ResultBufferMgr::fetch_data(const PUniqueId& finst_id, GetResultBatchCtx* ctx) {
+    TUniqueId tid;
+    tid.__set_hi(finst_id.hi());
+    tid.__set_lo(finst_id.lo());
+    boost::shared_ptr<BufferControlBlock> cb = find_control_block(tid);
+    if (cb == nullptr) {
+        LOG(WARNING) << "no result for this query, id=" << tid;
+        ctx->on_failure(Status("no result for this query"));
+        return;
+    }
+    cb->get_batch(ctx);
+}
+
 Status ResultBufferMgr::cancel(const TUniqueId& query_id) {
     boost::lock_guard<boost::mutex> l(_lock);
     BufferMap::iterator iter = _buffer_map.find(query_id);
@@ -150,4 +164,3 @@ void ResultBufferMgr::cancel_thread() {
 }
 
 }
-/* vim: set ts=4 sw=4 sts=4 tw=100 noet: */
diff --git a/be/src/runtime/result_buffer_mgr.h b/be/src/runtime/result_buffer_mgr.h
index 1846365ccf9ac0..ca482ef5b5329d 100644
--- a/be/src/runtime/result_buffer_mgr.h
+++ b/be/src/runtime/result_buffer_mgr.h
@@ -35,6 +35,9 @@ namespace palo {
 
 class TFetchDataResult;
 class BufferControlBlock;
+class GetResultBatchCtx;
+class PUniqueId;
+
 // manage all result buffer control block in one backend
 class ResultBufferMgr {
 public:
@@ -49,6 +52,9 @@ class ResultBufferMgr {
                         boost::shared_ptr<BufferControlBlock>* sender);
     // fetch data, used by RPC
     Status fetch_data(const TUniqueId& fragment_id, TFetchDataResult* result);
+
+    void fetch_data(const PUniqueId& finst_id, GetResultBatchCtx* ctx);
+
     // cancel
     Status cancel(const TUniqueId& fragment_id);
 
diff --git a/be/src/service/backend_service.cpp b/be/src/service/backend_service.cpp
index deb2230c4d50b3..245f4a3337df04 100644
--- a/be/src/service/backend_service.cpp
+++ b/be/src/service/backend_service.cpp
@@ -36,7 +36,6 @@
 #include "runtime/pull_load_task_mgr.h"
 #include "runtime/export_task_mgr.h"
 #include "runtime/result_buffer_mgr.h"
-#include "service/receiver_dispatcher.h"
 
 namespace palo {
 
@@ -80,25 +79,6 @@ Status BackendService::create_service(ExecEnv* exec_env, int port, ThriftServer*
     return Status::OK;
 }
 
-Status BackendService::create_rpc_service(ExecEnv* exec_env) {
-    ReactorFactory::initialize(config::rpc_reactor_threads);
-
-    struct sockaddr_in addr;
-    InetAddr::initialize(&addr, BackendOptions::get_localhost().c_str(), config::be_rpc_port);
-    Comm* comm = Comm::instance();
-
-    DispatchHandlerPtr dhp = std::make_shared<Dispatcher>(exec_env, comm, nullptr);
-    ConnectionHandlerFactoryPtr handler_factory = std::make_shared<HandlerFactory>(dhp);
-
-    Status status = Status::OK;
-    int error = comm->listen(addr, handler_factory, dhp);
-    if (error != error::OK) {
-        status = Status("create rpc server failed.");
-    }
-
-    return status;
-}
-
 void BackendService::exec_plan_fragment(TExecPlanFragmentResult& return_val,
                                         const TExecPlanFragmentParams& params) {
     LOG(INFO) << "exec_plan_fragment() instance_id=" << params.params.fragment_instance_id
diff --git a/be/src/service/backend_service.h b/be/src/service/backend_service.h
index 697a7bf1dc98a1..a84305b4a740b6 100644
--- a/be/src/service/backend_service.h
+++ b/be/src/service/backend_service.h
@@ -75,8 +75,6 @@ class BackendService : public BackendServiceIf {
     static Status create_service(
         ExecEnv* exec_env, int port, ThriftServer** server);
 
-    static Status create_rpc_service(ExecEnv* exec_env);
-
     // Agent service
     virtual void submit_tasks(
             TAgentResult& return_value,
diff --git a/be/src/service/brpc.h b/be/src/service/brpc.h
index de56c0790bd7d8..ffe0fcd7934ccc 100644
--- a/be/src/service/brpc.h
+++ b/be/src/service/brpc.h
@@ -49,6 +49,7 @@
 #include <butil/containers/flat_map_inl.h>
 #include <brpc/channel.h>
 #include <butil/endpoint.h>
+#include <butil/fd_utility.h>
 #include <butil/macros.h>
 #include <brpc/controller.h>
 #include <brpc/server.h>
diff --git a/be/src/service/brpc_service.cpp b/be/src/service/brpc_service.cpp
index 5d8ba779ef74fe..64d57e3c912c60 100644
--- a/be/src/service/brpc_service.cpp
+++ b/be/src/service/brpc_service.cpp
@@ -45,4 +45,8 @@ Status BRpcService::start(int port) {
     return Status::OK;
 }
 
+void BRpcService::join() {
+    _server->Join();
+}
+
 }
diff --git a/be/src/service/brpc_service.h b/be/src/service/brpc_service.h
index 72b319cc863086..e27d61a21f986e 100644
--- a/be/src/service/brpc_service.h
+++ b/be/src/service/brpc_service.h
@@ -34,6 +34,7 @@ class BRpcService {
     ~BRpcService();
 
     Status start(int port);
+    void join();
 
 private:
     ExecEnv* _exec_env;
diff --git a/be/src/service/internal_service.cpp b/be/src/service/internal_service.cpp
index ccfb56d44cd622..9212f0fefad662 100644
--- a/be/src/service/internal_service.cpp
+++ b/be/src/service/internal_service.cpp
@@ -15,9 +15,14 @@
 
 #include "service/internal_service.h"
 
+#include "gen_cpp/BackendService.h"
 #include "runtime/exec_env.h"
 #include "runtime/data_stream_mgr.h"
+#include "runtime/fragment_mgr.h"
 #include "service/brpc.h"
+#include "util/thrift_util.h"
+#include "runtime/buffer_control_block.h"
+#include "runtime/result_buffer_mgr.h"
 
 namespace palo {
 
@@ -52,4 +57,58 @@ void PInternalServiceImpl::transmit_data(google::protobuf::RpcController* cntl_b
     }
 }
 
+void PInternalServiceImpl::exec_plan_fragment(
+        google::protobuf::RpcController* cntl_base,
+        const PExecPlanFragmentRequest* request,
+        PExecPlanFragmentResult* response,
+        google::protobuf::Closure* done) {
+    brpc::ClosureGuard closure_guard(done);
+    brpc::Controller* cntl = static_cast<brpc::Controller*>(cntl_base);
+    auto st = _exec_plan_fragment(cntl);
+    if (!st.ok()) {
+        LOG(WARNING) << "exec plan fragment failed, errmsg=" << st.get_error_msg();
+    }
+    st.to_protobuf(response->mutable_status());
+}
+
+Status PInternalServiceImpl::_exec_plan_fragment(brpc::Controller* cntl) {
+    auto ser_request = cntl->request_attachment().to_string();
+    TExecPlanFragmentParams t_request;
+    {
+        const uint8_t* buf = (const uint8_t*)ser_request.data();
+        uint32_t len = ser_request.size();
+        RETURN_IF_ERROR(deserialize_thrift_msg(buf, &len, false, &t_request));
+    }
+    LOG(INFO) << "exec plan fragment, finst_id=" << t_request.params.fragment_instance_id
+        << ", coord=" << t_request.coord << ", backend=" << t_request.backend_num;
+    return _exec_env->fragment_mgr()->exec_plan_fragment(t_request);
+}
+
+void PInternalServiceImpl::cancel_plan_fragment(
+        google::protobuf::RpcController* cntl_base,
+        const PCancelPlanFragmentRequest* request,
+        PCancelPlanFragmentResult* result,
+        google::protobuf::Closure* done) {
+    brpc::ClosureGuard closure_guard(done);
+    TUniqueId tid;
+    tid.__set_hi(request->finst_id().hi());
+    tid.__set_lo(request->finst_id().lo());
+    LOG(INFO) << "cancel framgent, finst_id=" << tid;
+    auto st = _exec_env->fragment_mgr()->cancel(tid);
+    if (!st.ok()) {
+        LOG(WARNING) << "cancel plan fragment failed, errmsg=" << st.get_error_msg();
+    }
+    st.to_protobuf(result->mutable_status());
+}
+
+void PInternalServiceImpl::fetch_data(
+        google::protobuf::RpcController* cntl_base,
+        const PFetchDataRequest* request,
+        PFetchDataResult* result,
+        google::protobuf::Closure* done) {
+    brpc::Controller* cntl = static_cast<brpc::Controller*>(cntl_base);
+    GetResultBatchCtx* ctx = new GetResultBatchCtx(cntl, result, done);
+    _exec_env->result_mgr()->fetch_data(request->finst_id(), ctx);
+}
+
 }
diff --git a/be/src/service/internal_service.h b/be/src/service/internal_service.h
index aa3ce2eae3d98a..a86282673217d0 100644
--- a/be/src/service/internal_service.h
+++ b/be/src/service/internal_service.h
@@ -15,8 +15,13 @@
 
 #pragma once
 
+#include "common/status.h"
 #include "gen_cpp/internal_service.pb.h"
 
+namespace brpc {
+class Controller;
+}
+
 namespace palo {
 
 class ExecEnv;
@@ -30,6 +35,26 @@ class PInternalServiceImpl : public PInternalService {
                        const ::palo::PTransmitDataParams* request,
                        ::palo::PTransmitDataResult* response,
                        ::google::protobuf::Closure* done) override;
+    void exec_plan_fragment(
+        google::protobuf::RpcController* controller,
+        const PExecPlanFragmentRequest* request,
+        PExecPlanFragmentResult* result,
+        google::protobuf::Closure* done) override;
+
+    void cancel_plan_fragment(
+        google::protobuf::RpcController* controller,
+        const PCancelPlanFragmentRequest* request,
+        PCancelPlanFragmentResult* result,
+        google::protobuf::Closure* done) override;
+
+    void fetch_data(
+        google::protobuf::RpcController* controller,
+        const PFetchDataRequest* request,
+        PFetchDataResult* result,
+        google::protobuf::Closure* done) override;
+private:
+    Status _exec_plan_fragment(brpc::Controller* cntl);
+
 private:
     ExecEnv* _exec_env;
 };
diff --git a/be/src/service/palo_main.cpp b/be/src/service/palo_main.cpp
index 5831f398891ed9..18fff0c5e21ef8 100644
--- a/be/src/service/palo_main.cpp
+++ b/be/src/service/palo_main.cpp
@@ -24,6 +24,10 @@
 #include <boost/thread/thread.hpp>
 #include <gperftools/malloc_extension.h>
 
+#if defined(LEAK_SANITIZER)
+#include <sanitizer/lsan_interface.h>
+#endif
+
 #include "common/logging.h"
 #include "common/daemon.h"
 #include "common/config.h"
@@ -47,8 +51,6 @@
 #include "common/resource_tls.h"
 #include "exec/schema_scanner/frontend_helper.h"
 
-#include "rpc/reactor_factory.h"
-
 static void help(const char*);
 
 #include <dlfcn.h>
@@ -136,13 +138,6 @@ int main(int argc, char** argv) {
         exit(1);
     }
 
-    status = palo::BackendService::create_rpc_service(&exec_env);
-    if (!status.ok()) {
-        LOG(ERROR) << "Palo Be services did not start correctly, exiting";
-        palo::shutdown_logging();
-        exit(1);
-    }
-
     palo::BRpcService brpc_service(&exec_env);
     status = brpc_service.start(palo::config::brpc_port);
     if (!status.ok()) {
@@ -181,7 +176,14 @@ int main(int argc, char** argv) {
         exit(1);
     }
 
-    palo::ReactorFactory::join();
+#if defined(LEAK_SANITIZER)
+    // __lsan_enable();
+    while (true) {
+        __lsan_do_leak_check();
+        sleep(10);
+    }
+#endif
+    brpc_service.join();
 
     delete be_server;
     return 0;
diff --git a/be/src/service/receiver_dispatcher.h b/be/src/service/receiver_dispatcher.h
deleted file mode 100644
index 7eea87931c59a1..00000000000000
--- a/be/src/service/receiver_dispatcher.h
+++ /dev/null
@@ -1,176 +0,0 @@
-// Copyright (c) 2017, Baidu.com, Inc. All Rights Reserved
-
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#ifndef BDG_PALO_BE_SERVICE_RECEIVER_DISPATCHER_H
-#define BDG_PALO_BE_SERVICE_RECEIVER_DISPATCHER_H
-
-#include <arpa/inet.h>
-
-#include "rpc/application_handler.h"
-#include "rpc/application_queue.h"
-#include "rpc/compat.h"
-#include "rpc/comm.h"
-#include "rpc/connection_handler_factory.h"
-#include "rpc/dispatch_handler.h"
-#include "rpc/error.h"
-#include "rpc/event.h"
-#include "rpc/inet_addr.h"
-#include "rpc/reactor_factory.h"
-#include "rpc/serialization.h"
-#include "rpc/sock_addr_map.h"
-#include "runtime/data_stream_mgr.h"
-#include "util/thrift_util.h"
-
-namespace palo {
-
-class DataStreamMgr;
-
-class HandlerFactory : public ConnectionHandlerFactory {
-public:
-    HandlerFactory(DispatchHandlerPtr &dhp)
-        : _dispatch_handler_ptr(dhp) { return; }
-
-    virtual void get_instance(DispatchHandlerPtr &dhp) {
-        dhp = _dispatch_handler_ptr;
-    }
-
-private:
-    DispatchHandlerPtr _dispatch_handler_ptr;
-};
-
-class Dispatcher : public DispatchHandler {
-public:
-    Dispatcher(ExecEnv* exec_env, Comm *comm, ApplicationQueue *app_queue)
-        : _exec_env(exec_env), _comm(comm), _sender_thread(&Dispatcher::sender, this) {
-    }
-
-    virtual ~Dispatcher() {
-        _thread_stop = true;
-        _cond.notify_all();
-        _sender_thread.join();
-    }
-
-    void handle(EventPtr &event_ptr) override {
-        {
-            std::lock_guard<std::mutex> l(_lock);
-            _events.push_back(event_ptr);
-        }
-        _cond.notify_one();
-    }
-
-    void process(EventPtr& event_ptr) {
-        if (event_ptr->type == Event::CONNECTION_ESTABLISHED) {
-            LOG(INFO) << "Connection Established.";
-        }
-        else if (event_ptr->type == Event::DISCONNECT) {
-            if (event_ptr->error != 0) {
-                LOG(INFO) << "Disconnect : " << error::get_text(event_ptr->error);
-            } else {
-                LOG(INFO) << "Disconnect";
-            }
-        }
-        else if (event_ptr->type == Event::ERROR) {
-            LOG(ERROR) << "Error: " << error::get_text(event_ptr->error);
-        }
-        else if (event_ptr->type == Event::MESSAGE) {
-            const uint8_t *buf_ptr = (uint8_t*)event_ptr->payload;
-            uint32_t sz = event_ptr->payload_len;
-
-            TTransmitDataParams params;
-            deserialize_thrift_msg(buf_ptr, &sz, false, &params);
-
-            TTransmitDataResult return_val;
-            if (params.__isset.packet_seq) {
-                return_val.__set_packet_seq(params.packet_seq);
-                return_val.__set_dest_fragment_instance_id(params.dest_fragment_instance_id);
-                return_val.__set_dest_node_id(params.dest_node_id);
-                // TODO: how to return Error Status?
-                return_val.status.status_code = TStatusCode::OK;
-            }
-
-            uint8_t* buf_res = 0;
-            uint32_t size = 0;
-            ThriftSerializer thrift_serializer(false, 100);
-            thrift_serializer.serialize(&return_val, &size, &buf_res);
-
-            CommHeader header;
-            header.initialize_from_request_header(event_ptr->header);
-            CommBufPtr response(new CommBuf(header, size));
-            response->append_bytes(buf_res, size);
-
-            bool buffer_overflow = false;
-            if (params.row_batch.num_rows > 0) {
-                _exec_env->stream_mgr()->add_data(
-                        params.dest_fragment_instance_id,
-                        params.dest_node_id,
-                        params.row_batch,
-                        params.sender_id,
-                        &buffer_overflow,
-                        std::make_pair(event_ptr->addr, response));
-            }
-
-            if (params.eos) {
-                _exec_env->stream_mgr()->close_sender(
-                        params.dest_fragment_instance_id,
-                        params.dest_node_id,
-                        params.sender_id, 
-                        params.be_number);
-            }
-
-            if (params.eos || !buffer_overflow) {
-                VLOG(3) << "send last response to client"
-                    << ", send response header id:" << header.id
-                    << ", fragmentid: " << params.dest_fragment_instance_id;
-                int error = _comm->send_response(event_ptr->addr, response);
-                if (error != error::OK) {
-                    LOG(ERROR) << "Comm::send_response returned" << error::get_text(error);
-                }
-            }
-        }
-    }
-
-    void sender() {
-        while (!_thread_stop) {
-            EventPtr event;
-            {
-                std::unique_lock<std::mutex> l(_lock);
-                while (!_thread_stop && _events.empty()) {
-                    _cond.wait(l);
-                }
-                if (_thread_stop) {
-                    break;
-                }
-                DCHECK(!_events.empty());
-                event = _events.front();
-                _events.pop_front();
-            }
-            process(event);
-        }
-    }
-
-private:
-    ExecEnv* _exec_env;
-    Comm* _comm;
-
-    std::mutex _lock;
-    std::condition_variable _cond;
-    std::deque<EventPtr> _events;
-    std::thread _sender_thread;
-    bool _thread_stop = false;
-
-};
-
-} //namespace palo
-#endif //BDG_PALO_BE_SERVICE_RECEIVER_DISPATCHER_H
diff --git a/be/src/util/CMakeLists.txt b/be/src/util/CMakeLists.txt
index 14b7724c25a7fe..dc76bc5881b0b8 100644
--- a/be/src/util/CMakeLists.txt
+++ b/be/src/util/CMakeLists.txt
@@ -69,7 +69,6 @@ add_library(Util STATIC
 #  coding_util.cpp
   cidr.cpp
   core_local.cpp
-  rpc_channel.cpp
 )
 
 #ADD_BE_TEST(integer-array-test)
diff --git a/be/src/util/palo_metrics.cpp b/be/src/util/palo_metrics.cpp
index 6aa31344f47db1..86c9a5f57b55a8 100644
--- a/be/src/util/palo_metrics.cpp
+++ b/be/src/util/palo_metrics.cpp
@@ -37,18 +37,40 @@ IntCounter PaloMetrics::push_request_duration_us;
 IntCounter PaloMetrics::push_request_write_bytes;
 IntCounter PaloMetrics::push_request_write_rows;
 IntCounter PaloMetrics::create_tablet_requests_total;
+IntCounter PaloMetrics::create_tablet_requests_failed;
 IntCounter PaloMetrics::drop_tablet_requests_total;
+
 IntCounter PaloMetrics::report_all_tablets_requests_total;
+IntCounter PaloMetrics::report_all_tablets_requests_failed;
 IntCounter PaloMetrics::report_tablet_requests_total;
+IntCounter PaloMetrics::report_tablet_requests_failed;
+IntCounter PaloMetrics::report_disk_requests_total;
+IntCounter PaloMetrics::report_disk_requests_failed;
+IntCounter PaloMetrics::report_task_requests_total;
+IntCounter PaloMetrics::report_task_requests_failed;
+
 IntCounter PaloMetrics::schema_change_requests_total;
+IntCounter PaloMetrics::schema_change_requests_failed;
 IntCounter PaloMetrics::create_rollup_requests_total;
+IntCounter PaloMetrics::create_rollup_requests_failed;
 IntCounter PaloMetrics::storage_migrate_requests_total;
 IntCounter PaloMetrics::delete_requests_total;
+IntCounter PaloMetrics::delete_requests_failed;
 IntCounter PaloMetrics::cancel_delete_requests_total;
+IntCounter PaloMetrics::clone_requests_total;
+IntCounter PaloMetrics::clone_requests_failed;
+
+IntCounter PaloMetrics::finish_task_requests_total;
+IntCounter PaloMetrics::finish_task_requests_failed;
+
 IntCounter PaloMetrics::base_compaction_deltas_total;
 IntCounter PaloMetrics::base_compaction_bytes_total;
+IntCounter PaloMetrics::base_compaction_request_total;
+IntCounter PaloMetrics::base_compaction_request_failed;
 IntCounter PaloMetrics::cumulative_compaction_deltas_total;
 IntCounter PaloMetrics::cumulative_compaction_bytes_total;
+IntCounter PaloMetrics::cumulative_compaction_request_total;
+IntCounter PaloMetrics::cumulative_compaction_request_failed;
 
 // gauges
 IntGauge PaloMetrics::memory_pool_bytes_total;
@@ -89,19 +111,41 @@ void PaloMetrics::initialize(const std::string& name,
     REGISTER_PALO_METRIC(push_request_write_bytes);
     REGISTER_PALO_METRIC(push_request_write_rows);
 
-#define REGISTER_ENGINE_REQUEST_METRIC(type, metric) \
+#define REGISTER_ENGINE_REQUEST_METRIC(type, status, metric) \
     _metrics->register_metric( \
-        "engine_requests_total", MetricLabels().add("type", #type), &metric)
-
-    REGISTER_ENGINE_REQUEST_METRIC(create_tablet, create_tablet_requests_total);
-    REGISTER_ENGINE_REQUEST_METRIC(drop_tablet, drop_tablet_requests_total);
-    REGISTER_ENGINE_REQUEST_METRIC(report_all_tablets, report_all_tablets_requests_total);
-    REGISTER_ENGINE_REQUEST_METRIC(report_tablet, report_tablet_requests_total);
-    REGISTER_ENGINE_REQUEST_METRIC(schema_change, schema_change_requests_total);
-    REGISTER_ENGINE_REQUEST_METRIC(create_rollup, create_rollup_requests_total);
-    REGISTER_ENGINE_REQUEST_METRIC(storage_migrate, storage_migrate_requests_total);
-    REGISTER_ENGINE_REQUEST_METRIC(delete, delete_requests_total);
-    REGISTER_ENGINE_REQUEST_METRIC(cancel_delete, cancel_delete_requests_total);
+        "engine_requests_total", MetricLabels().add("type", #type).add("status", #status), &metric)
+
+    REGISTER_ENGINE_REQUEST_METRIC(create_tablet, total, create_tablet_requests_total);
+    REGISTER_ENGINE_REQUEST_METRIC(create_tablet, failed, create_tablet_requests_failed);
+    REGISTER_ENGINE_REQUEST_METRIC(drop_tablet, total, drop_tablet_requests_total);
+
+    REGISTER_ENGINE_REQUEST_METRIC(report_all_tablets, total, report_all_tablets_requests_total);
+    REGISTER_ENGINE_REQUEST_METRIC(report_all_tablets, failed, report_all_tablets_requests_failed);
+    REGISTER_ENGINE_REQUEST_METRIC(report_tablet, total, report_tablet_requests_total);
+    REGISTER_ENGINE_REQUEST_METRIC(report_tablet, failed, report_tablet_requests_failed);
+    REGISTER_ENGINE_REQUEST_METRIC(report_disk, total, report_disk_requests_total);
+    REGISTER_ENGINE_REQUEST_METRIC(report_disk, failed, report_disk_requests_failed);
+    REGISTER_ENGINE_REQUEST_METRIC(report_task, total, report_task_requests_total);
+    REGISTER_ENGINE_REQUEST_METRIC(report_task, failed, report_task_requests_failed);
+
+    REGISTER_ENGINE_REQUEST_METRIC(schema_change, total, schema_change_requests_total);
+    REGISTER_ENGINE_REQUEST_METRIC(schema_change, failed, schema_change_requests_failed);
+    REGISTER_ENGINE_REQUEST_METRIC(create_rollup, total, create_rollup_requests_total);
+    REGISTER_ENGINE_REQUEST_METRIC(create_rollup, failed, create_rollup_requests_failed);
+    REGISTER_ENGINE_REQUEST_METRIC(storage_migrate, total, storage_migrate_requests_total);
+    REGISTER_ENGINE_REQUEST_METRIC(delete, total, delete_requests_total);
+    REGISTER_ENGINE_REQUEST_METRIC(delete, failed, delete_requests_failed);
+    REGISTER_ENGINE_REQUEST_METRIC(cancel_delete, total, cancel_delete_requests_total);
+    REGISTER_ENGINE_REQUEST_METRIC(clone, total, clone_requests_total);
+    REGISTER_ENGINE_REQUEST_METRIC(clone, failed, clone_requests_failed);
+
+    REGISTER_ENGINE_REQUEST_METRIC(finish_task, total, finish_task_requests_total);
+    REGISTER_ENGINE_REQUEST_METRIC(finish_task, failed, finish_task_requests_failed);
+
+    REGISTER_ENGINE_REQUEST_METRIC(base_compaction, total, base_compaction_request_total);
+    REGISTER_ENGINE_REQUEST_METRIC(base_compaction, failed, base_compaction_request_failed);
+    REGISTER_ENGINE_REQUEST_METRIC(cumulative_compaction, total, cumulative_compaction_request_total);
+    REGISTER_ENGINE_REQUEST_METRIC(cumulative_compaction, failed, cumulative_compaction_request_failed);
 
     _metrics->register_metric(
         "compaction_deltas_total", MetricLabels().add("type", "base"),
diff --git a/be/src/util/palo_metrics.h b/be/src/util/palo_metrics.h
index 6b02ea8a4af720..9480c79919f77a 100644
--- a/be/src/util/palo_metrics.h
+++ b/be/src/util/palo_metrics.h
@@ -43,20 +43,45 @@ class PaloMetrics {
     static IntCounter push_request_write_bytes;
     static IntCounter push_request_write_rows;
     static IntCounter create_tablet_requests_total;
+    static IntCounter create_tablet_requests_failed;
     static IntCounter drop_tablet_requests_total;
+
     static IntCounter report_all_tablets_requests_total;
+    static IntCounter report_all_tablets_requests_failed;
     static IntCounter report_tablet_requests_total;
+    static IntCounter report_tablet_requests_failed;
+    static IntCounter report_disk_requests_total;
+    static IntCounter report_disk_requests_failed;
+    static IntCounter report_task_requests_total;
+    static IntCounter report_task_requests_failed;
+
     static IntCounter schema_change_requests_total;
+    static IntCounter schema_change_requests_failed;
     static IntCounter create_rollup_requests_total;
+    static IntCounter create_rollup_requests_failed;
     static IntCounter storage_migrate_requests_total;
     static IntCounter delete_requests_total;
+    static IntCounter delete_requests_failed;
     static IntCounter cancel_delete_requests_total;
+    static IntCounter clone_requests_total;
+    static IntCounter clone_requests_failed;
+
+    static IntCounter finish_task_requests_total;
+    static IntCounter finish_task_requests_failed;
+
+    static IntCounter base_compaction_request_total;
+    static IntCounter base_compaction_request_failed;
+    static IntCounter cumulative_compaction_request_total;
+    static IntCounter cumulative_compaction_request_failed;
 
     static IntCounter base_compaction_deltas_total;
     static IntCounter base_compaction_bytes_total;
     static IntCounter cumulative_compaction_deltas_total;
     static IntCounter cumulative_compaction_bytes_total;
 
+    static IntCounter alter_task_success_total;
+    static IntCounter alter_task_failed_total;
+
     // Gauges
     static IntGauge memory_pool_bytes_total;
 
diff --git a/be/src/util/path_trie.hpp b/be/src/util/path_trie.hpp
index 83f039be3e10a1..c816c779d580e1 100644
--- a/be/src/util/path_trie.hpp
+++ b/be/src/util/path_trie.hpp
@@ -18,8 +18,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#ifndef BDG_PALO_BE_SRC_COMMON_UTIL_PATH_TRIE_H
-#define BDG_PALO_BE_SRC_COMMON_UTIL_PATH_TRIR_H
+#pragma once
 
 #include <map>
 #include <memory>
@@ -289,6 +288,3 @@ class PathTrie {
 };
 
 }
-
-#endif
-
diff --git a/be/src/util/rpc_channel.cpp b/be/src/util/rpc_channel.cpp
deleted file mode 100644
index fbc17187a20f6a..00000000000000
--- a/be/src/util/rpc_channel.cpp
+++ /dev/null
@@ -1,175 +0,0 @@
-// Copyright (c) 2018, Baidu.com, Inc. All Rights Reserved
-
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#include "util/rpc_channel.h"
-
-#include "rpc/error.h"
-#include "rpc/protocol.h"
-#include "rpc/serialization.h"
-
-namespace palo {
-
-RpcChannel::RpcChannel(Comm* comm, ConnectionManagerPtr conn_mgr, uint64_t command)
-        : _comm(comm), _conn_mgr(conn_mgr), _command(command) {
-}
-
-RpcChannel::~RpcChannel() {
-}
-
-Status RpcChannel::init(const std::string& host, int port,
-                        uint32_t connect_timeout_ms,
-                        uint32_t rpc_timeout_ms) {
-    // Initialize InetAddr
-    struct sockaddr_in sockaddr_in;
-    if (!InetAddr::initialize(&sockaddr_in, host.c_str(), port)) {
-        std::stringstream ss;
-        ss << "invalid inet address: host=" << host << ", port=" << port;
-        return Status(ss.str());
-    }
-    _addr.set_inet(sockaddr_in);
-
-    // connect to remote servcie
-    _connect_timeout_ms = connect_timeout_ms;
-    _conn_mgr->add(_addr, _connect_timeout_ms, "PaloBeDataStreamMgr");
-
-    _rpc_timeout_ms = rpc_timeout_ms;
-    return Status::OK;
-}
-
-Status RpcChannel::get_response(const uint8_t** data, uint32_t* size) {
-    RETURN_IF_ERROR(_wait_for_last_sent());
-    DCHECK(_last_event != nullptr);
-    *data = _last_event->payload;
-    *size = _last_event->payload_len;
-    return Status::OK;
-}
-
-Status RpcChannel::send_message(const uint8_t* data, uint32_t size) {
-    // make sure 
-    RETURN_IF_ERROR(_wait_for_last_sent());
-    return _send_message(data, size);
-}
-
-Status RpcChannel::_send_message(const uint8_t* data, uint32_t size) {
-    DCHECK(!_rpc_in_flight);
-
-    CommHeader header(_command);
-    CommBufPtr new_comm_buf = std::make_shared<CommBuf>(header, size);
-    new_comm_buf->append_bytes(data, size);
-
-    auto res = _comm->send_request(_addr, _rpc_timeout_ms, new_comm_buf, this);
-    if (res != error::OK) {
-        LOG(WARNING) << "fail to send_request, addr=" << _addr.to_str()
-            << ", res=" << res << ", message=" << error::get_text(res);
-        // sleep 10ms to wait ConnectionManager to be notify
-        usleep(10 * 1000);
-        _conn_mgr->add(_addr, _connect_timeout_ms, "PaloBeDataStreamMgr");
-        bool is_connected = _conn_mgr->wait_for_connection(_addr, _connect_timeout_ms);
-        if (!is_connected) {
-            LOG(WARNING) << "fail to wait_for_connection, addr=" << _addr.to_str();
-            _conn_mgr->remove(_addr);
-            _rpc_status = Status(TStatusCode::THRIFT_RPC_ERROR, "connection to remote PaloBe failed");
-            return _rpc_status;
-        }
-        res = _comm->send_request(_addr, _rpc_timeout_ms, new_comm_buf, this);
-        if (res != error::OK) {
-            LOG(WARNING) << "fail to send_request, addr=" << _addr.to_str()
-                << ", res=" << res << ", message=" << error::get_text(res);
-            _rpc_status = Status(TStatusCode::THRIFT_RPC_ERROR, "fail to send_request");
-            return _rpc_status;
-        }
-    }
-    _cbp = new_comm_buf;
-    _rpc_in_flight = true;
-    return Status::OK;
-}
-
-Status RpcChannel::_wait_for_last_sent() {
-    if (!_rpc_in_flight) {
-        return _rpc_status;
-    }
-    int retry_times = 1;
-    while (true) {
-        EventPtr event;
-        {
-            std::unique_lock<std::mutex> l(_lock);
-            auto duration = std::chrono::milliseconds(2 * _rpc_timeout_ms);
-            if (_cond.wait_for(l, duration, [this]() { return !this->_events.empty(); })) {
-                event = _events.front();
-                _events.pop_front();
-            }
-        }
-        if (event == nullptr) {
-            LOG(WARNING) << "it's so weird, wait reponse event timeout, request="
-                << _cbp->header.id << ", addr=" << _addr.to_str();
-            _rpc_in_flight = false;
-            if (retry_times-- > 0) {
-                // timeout to receive response, to get user data to resend
-                const uint8_t* data = nullptr;
-                uint32_t size = 0;
-                _cbp->get_user_data(&data, &size);
-                RETURN_IF_ERROR(_send_message(data, size));
-            } else {
-                LOG(WARNING) << "fail to send batch, _add=" << _addr.to_str()
-                    << ", request_id="<< _cbp->header.id;
-                _rpc_status = Status(TStatusCode::THRIFT_RPC_ERROR, "fail to send batch");
-                break;
-            }
-            continue;
-        }
-        if (event->type == Event::MESSAGE) {
-            if (event->header.id != _cbp->header.id) {
-                LOG(WARNING) << "receive event id not equal with in-flight request, request_id="
-                    << _cbp->header.id << ", event=" << event->to_str();
-                continue;
-            }
-            // response recept
-            _rpc_in_flight = false;
-            _last_event = event;
-            return Status::OK;
-        } else if (event->type == Event::DISCONNECT || event->type == Event::ERROR) {
-            if (event->header.id != 0 && event->header.id != _cbp->header.id) {
-                LOG(WARNING) << "receive event id not equal with in-flight request, request_id="
-                    << _cbp->header.id << ", event=" << event->to_str();
-                continue;
-            }
-            LOG(WARNING) << "receive response failed, request_id=" << _cbp->header.id
-                << ", event=" << event->to_str();
-            _rpc_in_flight = false;
-            // error happend when receving response, we need to retry last request
-            if (retry_times-- > 0) {
-                // timeout to receive response
-                const uint8_t* data = nullptr;
-                uint32_t size = 0;
-                _cbp->get_user_data(&data, &size);
-                RETURN_IF_ERROR(_send_message(data, size));
-            } else {
-                LOG(WARNING) << "fail to send batch, request_id="<< _cbp->header.id
-                    << ", event=" << event->to_str();
-                _rpc_status = Status(TStatusCode::THRIFT_RPC_ERROR, "fail to send batch");
-                break;
-            }
-        } else {
-            _rpc_in_flight = false;
-            LOG(ERROR) << "recevie unexpect event, event=" << event->to_str();
-            _rpc_status = Status(TStatusCode::THRIFT_RPC_ERROR, "fail to send batch");
-            break;
-        }
-    }
-
-    return _rpc_status;
-}
-
-}
diff --git a/be/src/util/rpc_channel.h b/be/src/util/rpc_channel.h
deleted file mode 100644
index 66bf892a95f36d..00000000000000
--- a/be/src/util/rpc_channel.h
+++ /dev/null
@@ -1,91 +0,0 @@
-// Copyright (c) 2018, Baidu.com, Inc. All Rights Reserved
-
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#pragma once
-
-#include <stdint.h>
-
-#include <deque>
-#include <condition_variable>
-#include <memory>
-#include <mutex>
-
-#include "common/status.h"
-#include "rpc/comm.h"
-#include "rpc/comm_address.h"
-#include "rpc/comm_buf.h"
-#include "rpc/connection_manager.h"
-#include "rpc/dispatch_handler.h"
-#include "rpc/event.h"
-
-namespace palo {
-
-// this class is NOT thread safe.
-class RpcChannel : public DispatchHandler {
-public:
-    RpcChannel(Comm* comm, ConnectionManagerPtr conn_mgr, uint64_t command);
-    virtual ~RpcChannel();
-
-    Status init(const std::string& host, int port,
-                uint32_t connect_timeout_ms,
-                uint32_t rpc_timeout_ms);
-
-    // DispatchHandler handle, used to handle request event
-    void handle(EventPtr& event) override {
-        {
-            std::lock_guard<std::mutex> l(_lock);
-            _events.push_back(event);
-        }
-        _cond.notify_one();
-    }
-
-    Status wait_last_sent() {
-        return _wait_for_last_sent();
-    }
-    // get last send's response
-    Status get_response(const uint8_t** data, uint32_t* size);
-
-    // make sure
-    Status send_message(const uint8_t* data, uint32_t size);
-
-private:
-    Status _wait_for_last_sent();
-    Status _send_message(const uint8_t* data, uint32_t size);
-
-private:
-    Comm* _comm;
-    ConnectionManagerPtr _conn_mgr;
-    uint64_t _command;
-
-    CommAddress _addr;
-    uint32_t _connect_timeout_ms = 500;
-    uint32_t _rpc_timeout_ms = 1000;
-
-    bool _rpc_in_flight = false;
-    Status _rpc_status;
-
-    // only valid when _rpc_in_flight is true
-    CommBufPtr _cbp;
-    EventPtr _last_event;
-
-    // lock, protect variables
-    std::mutex _lock;
-    std::condition_variable _cond;
-    std::deque<EventPtr> _events;
-};
-
-using RpcChannelPtr = std::shared_ptr<RpcChannel>;
-
-}
diff --git a/be/test/http/metrics_action_test.cpp b/be/test/http/metrics_action_test.cpp
index 5c6b47eb5cc9b1..dfa03763163a37 100644
--- a/be/test/http/metrics_action_test.cpp
+++ b/be/test/http/metrics_action_test.cpp
@@ -27,16 +27,9 @@ namespace palo {
 // Mock part
 const char* s_expect_response = nullptr;
 
-HttpChannel::HttpChannel(const HttpRequest& request, mg_connection* mg_conn) :
-        _request(request),
-        _mg_conn(mg_conn) {
-}
-
-void HttpChannel::send_response(const HttpResponse& response) {
-    ASSERT_STREQ(s_expect_response, response.content()->c_str());
-}
-
-HttpRequest::HttpRequest(mg_connection* conn) {
+void HttpChannel::send_reply(
+        HttpRequest* request, HttpStatus status, const std::string& content) {
+    ASSERT_STREQ(s_expect_response, content.c_str());
 }
 
 class MetricsActionTest : public testing::Test {
@@ -62,9 +55,8 @@ TEST_F(MetricsActionTest, prometheus_output) {
         "# TYPE test_requests_total COUNTER\n"
         "test_requests_total{path=\"/sports\",type=\"put\"} 2345\n";
     HttpRequest request(nullptr);
-    HttpChannel channel(request, nullptr);
     MetricsAction action(&registry);
-    action.handle(&request, &channel);
+    action.handle(&request);
 }
 
 TEST_F(MetricsActionTest, prometheus_no_prefix) {
@@ -76,9 +68,8 @@ TEST_F(MetricsActionTest, prometheus_no_prefix) {
         "# TYPE cpu_idle GAUGE\n"
         "cpu_idle 50\n";
     HttpRequest request(nullptr);
-    HttpChannel channel(request, nullptr);
     MetricsAction action(&registry);
-    action.handle(&request, &channel);
+    action.handle(&request);
 }
 
 TEST_F(MetricsActionTest, prometheus_no_name) {
@@ -88,9 +79,8 @@ TEST_F(MetricsActionTest, prometheus_no_name) {
     registry.register_metric("", &cpu_idle);
     s_expect_response = "";
     HttpRequest request(nullptr);
-    HttpChannel channel(request, nullptr);
     MetricsAction action(&registry);
-    action.handle(&request, &channel);
+    action.handle(&request);
 }
 
 }
diff --git a/be/test/util/CMakeLists.txt b/be/test/util/CMakeLists.txt
index 6f9e54a10e5555..71d37deb0a8b96 100644
--- a/be/test/util/CMakeLists.txt
+++ b/be/test/util/CMakeLists.txt
@@ -34,4 +34,3 @@ ADD_BE_TEST(palo_metrics_test)
 ADD_BE_TEST(system_metrics_test)
 ADD_BE_TEST(core_local_test)
 ADD_BE_TEST(types_test)
-ADD_BE_TEST(rpc_channel_test)
diff --git a/be/test/util/palo_metrics_test.cpp b/be/test/util/palo_metrics_test.cpp
index da4bb407563401..c370275ca8a108 100644
--- a/be/test/util/palo_metrics_test.cpp
+++ b/be/test/util/palo_metrics_test.cpp
@@ -164,63 +164,72 @@ TEST_F(PaloMetricsTest, Normal) {
     {
         PaloMetrics::create_tablet_requests_total.increment(15);
         auto metric = metrics->get_metric("engine_requests_total",
-                                          MetricLabels().add("type", "create_tablet"));
+                                          MetricLabels().add("type", "create_tablet")
+                                          .add("status", "total"));
         ASSERT_TRUE(metric != nullptr);
         ASSERT_STREQ("15", ((SimpleMetric*)metric)->to_string().c_str());
     }
     {
         PaloMetrics::drop_tablet_requests_total.increment(16);
         auto metric = metrics->get_metric("engine_requests_total",
-                                          MetricLabels().add("type", "drop_tablet"));
+                                          MetricLabels().add("type", "drop_tablet")
+                                          .add("status", "total"));
         ASSERT_TRUE(metric != nullptr);
         ASSERT_STREQ("16", ((SimpleMetric*)metric)->to_string().c_str());
     }
     {
         PaloMetrics::report_all_tablets_requests_total.increment(17);
         auto metric = metrics->get_metric("engine_requests_total",
-                                          MetricLabels().add("type", "report_all_tablets"));
+                                          MetricLabels().add("type", "report_all_tablets")
+                                          .add("status", "total"));
         ASSERT_TRUE(metric != nullptr);
         ASSERT_STREQ("17", ((SimpleMetric*)metric)->to_string().c_str());
     }
     {
         PaloMetrics::report_tablet_requests_total.increment(18);
         auto metric = metrics->get_metric("engine_requests_total",
-                                          MetricLabels().add("type", "report_tablet"));
+                                          MetricLabels().add("type", "report_tablet")
+                                          .add("status", "total"));
         ASSERT_TRUE(metric != nullptr);
         ASSERT_STREQ("18", ((SimpleMetric*)metric)->to_string().c_str());
     }
     {
         PaloMetrics::schema_change_requests_total.increment(19);
         auto metric = metrics->get_metric("engine_requests_total",
-                                          MetricLabels().add("type", "schema_change"));
+                                          MetricLabels().add("type", "schema_change")
+                                          .add("status", "total"));
         ASSERT_TRUE(metric != nullptr);
         ASSERT_STREQ("19", ((SimpleMetric*)metric)->to_string().c_str());
     }
     {
         PaloMetrics::create_rollup_requests_total.increment(20);
         auto metric = metrics->get_metric("engine_requests_total",
-                                          MetricLabels().add("type", "create_rollup"));
+                                          MetricLabels().add("type", "create_rollup")
+                                          .add("status", "total"));
         ASSERT_TRUE(metric != nullptr);
         ASSERT_STREQ("20", ((SimpleMetric*)metric)->to_string().c_str());
     }
     {
         PaloMetrics::storage_migrate_requests_total.increment(21);
         auto metric = metrics->get_metric("engine_requests_total",
-                                          MetricLabels().add("type", "storage_migrate"));
+                                          MetricLabels().add("type", "storage_migrate")
+                                          .add("status", "total"));
         ASSERT_TRUE(metric != nullptr);
         ASSERT_STREQ("21", ((SimpleMetric*)metric)->to_string().c_str());
     }
     {
         PaloMetrics::delete_requests_total.increment(22);
         auto metric = metrics->get_metric("engine_requests_total",
-                                          MetricLabels().add("type", "delete"));
+                                          MetricLabels().add("type", "delete")
+                                          .add("status", "total"));
         ASSERT_TRUE(metric != nullptr);
         ASSERT_STREQ("22", ((SimpleMetric*)metric)->to_string().c_str());
     }
     {
         PaloMetrics::cancel_delete_requests_total.increment(23);
         auto metric = metrics->get_metric("engine_requests_total",
-                                          MetricLabels().add("type", "cancel_delete"));
+                                          MetricLabels().add("type", "cancel_delete")
+                                          .add("status", "total"));
         ASSERT_TRUE(metric != nullptr);
         ASSERT_STREQ("23", ((SimpleMetric*)metric)->to_string().c_str());
     }
diff --git a/be/test/util/rpc_channel_test.cpp b/be/test/util/rpc_channel_test.cpp
deleted file mode 100644
index 8723f7da5a86cd..00000000000000
--- a/be/test/util/rpc_channel_test.cpp
+++ /dev/null
@@ -1,185 +0,0 @@
-// Copyright (c) 2018, Baidu.com, Inc. All Rights Reserved
-
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#include "util/rpc_channel.h"
-
-#include <gtest/gtest.h>
-
-#include "rpc/connection_handler_factory.h"
-#include "rpc/connection_manager.h"
-#include "rpc/dispatch_handler.h"
-#include "rpc/error.h"
-#include "rpc/event.h"
-#include "rpc/reactor_factory.h"
-
-namespace palo {
-
-class TestFactory : public ConnectionHandlerFactory {
-public:
-    TestFactory(DispatchHandlerPtr handler) : _handler(handler) { }
-    virtual ~TestFactory() { }
-    void get_instance(DispatchHandlerPtr &dhp) override {
-        dhp = _handler;
-    }
-private:
-    DispatchHandlerPtr _handler;
-};
-
-class TestDispacher : public DispatchHandler {
-public:
-    TestDispacher(Comm* comm) : _comm(comm) { }
-    virtual ~TestDispacher() { }
-
-    void handle(EventPtr& event) override {
-        if (event->type == Event::CONNECTION_ESTABLISHED) {
-            LOG(INFO) << "Connection Established.";
-        } else if (event->type == Event::DISCONNECT) {
-            if (event->error != 0) {
-                LOG(INFO) << "Disconnect : " << error::get_text(event->error);
-            } else {
-                LOG(INFO) << "Disconnect";
-            }
-        } else if (event->type == Event::ERROR) {
-            LOG(ERROR) << "Error: " << error::get_text(event->error);
-        } else if (event->type == Event::MESSAGE) {
-            const uint8_t *buf_ptr = (const uint8_t*)event->payload;
-            if (buf_ptr[0] == 123) {
-                // ignore this packet
-                return;
-            }
-            CommHeader header;
-            header.initialize_from_request_header(event->header);
-            CommBufPtr response(new CommBuf(header, event->payload_len));
-            response->append_bytes(event->payload, event->payload_len);
-            int error = _comm->send_response(event->addr, response);
-            if (error != error::OK) {
-                LOG(ERROR) << "Comm::send_response returned" << error::get_text(error);
-            }
-        }
-    }
-private:
-    Comm* _comm;
-};
-
-class RpcChannelTest : public testing::Test {
-public:
-    RpcChannelTest() { }
-    virtual ~RpcChannelTest() {
-    }
-    static void SetUpTestCase() {
-        ReactorFactory::initialize(1);
-        _comm.reset(new Comm("127.0.0.1"));
-        _conn_mgr = std::make_shared<ConnectionManager>(_comm.get());
-        DispatchHandlerPtr dhp = std::make_shared<TestDispacher>(_comm.get());
-        ConnectionHandlerFactoryPtr factory = std::make_shared<TestFactory>(dhp);
-
-        struct sockaddr_in addr;
-        InetAddr::initialize(&addr, "127.0.0.1", 25437);
-        _comm->listen(addr, factory, dhp);
-    }
-    void SetUp() override { }
-
-private:
-    static std::unique_ptr<Comm> _comm;
-    static ConnectionManagerPtr _conn_mgr;
-};
-
-std::unique_ptr<Comm> RpcChannelTest::_comm;
-ConnectionManagerPtr RpcChannelTest::_conn_mgr;
-
-TEST_F(RpcChannelTest, normal) {
-    RpcChannelPtr channel = std::make_shared<RpcChannel>(_comm.get(), _conn_mgr, 0);
-    auto st = channel->init("127.0.0.1", 25437, 500, 1000);
-    ASSERT_TRUE(st.ok());
-
-    uint8_t buf[16];
-    for (int i = 0; i < 16; ++i) {
-        buf[i] = i;
-    }
-    st = channel->send_message(buf, 16);
-    ASSERT_TRUE(st.ok());
-    const uint8_t* rep_buf = nullptr;
-    uint32_t rep_size = 0;
-    st = channel->get_response(&rep_buf, &rep_size);
-    ASSERT_TRUE(st.ok());
-    ASSERT_EQ(16, rep_size);
-    for (int i = 0; i < rep_size; ++i) {
-        ASSERT_EQ(i, rep_buf[i]);
-    }
-}
-
-TEST_F(RpcChannelTest, send_fail) {
-    RpcChannelPtr channel = std::make_shared<RpcChannel>(_comm.get(), _conn_mgr, 0);
-    auto st = channel->init("127.0.0.1", 25437, 100, 100);
-    ASSERT_TRUE(st.ok());
-
-    uint8_t buf[16];
-    memset(buf, 0, 16);
-    // make reponse ignore this packet
-    buf[0] = 123;
-    st = channel->send_message(buf, 16);
-    ASSERT_TRUE(st.ok());
-    const uint8_t* rep_buf = nullptr;
-    uint32_t rep_size = 0;
-    st = channel->get_response(&rep_buf, &rep_size);
-    ASSERT_FALSE(st.ok());
-}
-
-TEST_F(RpcChannelTest, disconnect) {
-    RpcChannelPtr channel = std::make_shared<RpcChannel>(_comm.get(), _conn_mgr, 0);
-    auto st = channel->init("127.0.0.1", 25437, 100, 100);
-    ASSERT_TRUE(st.ok());
-
-    EventPtr event = std::make_shared<Event>(Event::DISCONNECT);
-    channel->handle(event);
-    uint8_t buf[16];
-    for (int i = 0; i < 16; ++i) {
-        buf[i] = i;
-    }
-    st = channel->send_message(buf, 16);
-    ASSERT_TRUE(st.ok());
-    const uint8_t* rep_buf = nullptr;
-    uint32_t rep_size = 0;
-    st = channel->get_response(&rep_buf, &rep_size);
-    ASSERT_TRUE(st.ok());
-    ASSERT_EQ(16, rep_size);
-    for (int i = 0; i < rep_size; ++i) {
-        ASSERT_EQ(i, rep_buf[i]);
-    }
-}
-
-TEST_F(RpcChannelTest, unknown_port) {
-    RpcChannelPtr channel = std::make_shared<RpcChannel>(_comm.get(), _conn_mgr, 0);
-    auto st = channel->init("127.0.0.1", 25438, 100, 100);
-    ASSERT_TRUE(st.ok());
-
-    EventPtr event = std::make_shared<Event>(Event::DISCONNECT);
-    channel->handle(event);
-    uint8_t buf[16];
-    memset(buf, 0, 16);
-    st = channel->send_message(buf, 16);
-    ASSERT_TRUE(st.ok());
-    const uint8_t* rep_buf = nullptr;
-    uint32_t rep_size = 0;
-    st = channel->get_response(&rep_buf, &rep_size);
-    ASSERT_FALSE(st.ok());
-}
-
-}
-
-int main(int argc, char** argv) {
-    ::testing::InitGoogleTest(&argc, argv);
-    return RUN_ALL_TESTS();
-}
diff --git a/docs/help/Contents/Data Manipulation/manipulation_stmt.md b/docs/help/Contents/Data Manipulation/manipulation_stmt.md
index 0ca29466d58537..3fa0148e2644dc 100644
--- a/docs/help/Contents/Data Manipulation/manipulation_stmt.md	
+++ b/docs/help/Contents/Data Manipulation/manipulation_stmt.md	
@@ -89,7 +89,16 @@
         用于指定导入使用的Broker
         语法：
         WITH BROKER broker_name ("key"="value"[,...])
-        这里需要指定具体的Broker name, 以及所需的Broker属性
+        这里需要指定具体的Broker name, 以及所需的Broker属性.
+        开源hdfs Broker支持的属性如下:
+        -   fs.defaultFS:默认文件系统
+        -   username: 访问hdfs的用户名
+        -   password: 访问hdfs的用户密码
+        -   dfs.nameservices: ha模式的hdfs中必须配置这个，指定hdfs服务的名字.以下参数都是在ha hdfs中需要指定.例子: "dfs.nameservices" = "palo"
+        -   dfs.ha.namenodes.xxx：ha模式中指定namenode的名字,多个名字以逗号分隔,ha模式中必须配置。其中xxx表示dfs.nameservices配置的value.例子: "dfs.ha.namenodes.palo" = "nn1,nn2"
+        -   dfs.namenode.rpc-address.xxx.nn: ha模式中指定namenode的rpc地址信息,ha模式中必须配置。其中nn表示dfs.ha.namenodes.xxx中配置的一个namenode的名字。例子: "dfs.namenode.rpc-address.palo.nn1" = "host:port"
+        -   dfs.client.failover.proxy.provider: ha模式中指定client连接namenode的provider,默认为:org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider
+
 
     4. opt_properties
         用于指定一些特殊参数。
@@ -227,6 +236,24 @@
         )
         WITH BROKER hdfs ("username"="hdfs_user", "password"="hdfs_password");
  
+    8. 从ha模式的hdfs的路径中导入数据
+         LOAD LABEL table1_20170707 (
+             DATA INFILE("hdfs://bdos/palo/table1_data")
+             INTO TABLE table1
+         )
+         WITH BROKER hdfs (
+             "fs.defaultFS"="hdfs://bdos",
+             "username"="hdfs_user",
+             "password"="hdfs_password",
+             "dfs.nameservices"="bdos",
+             "dfs.ha.namenodes.bdos"="nn1,nn2",
+             "dfs.namenode.rpc-address.bdos.nn1"="host1:port1",
+             "dfs.namenode.rpc-address.bdos.nn2"="host2:port2")
+         PROPERTIES (
+             "timeout"="3600",
+             "max_filter_ratio"="0.1"
+         );
+
 ## keyword
     LOAD,TABLE
     
diff --git a/fe/src/com/baidu/palo/analysis/CreateTableStmt.java b/fe/src/com/baidu/palo/analysis/CreateTableStmt.java
index d1dee35f925e21..820ef7a707a5ac 100644
--- a/fe/src/com/baidu/palo/analysis/CreateTableStmt.java
+++ b/fe/src/com/baidu/palo/analysis/CreateTableStmt.java
@@ -248,10 +248,6 @@ public void analyze(Analyzer analyzer) throws AnalysisException, InternalExcepti
             ErrorReport.reportAnalysisException(ErrorCode.ERR_TABLE_MUST_HAVE_COLUMNS);
         }
 
-        if (columns.size() > KuduUtil.MAX_COLUMN_NUM) {
-            throw new AnalysisException("Kudu table does not support column num more than 300");
-        }
-
         int rowLengthBytes = 0;
         boolean hasHll = false;
         Set<String> columnSet = Sets.newTreeSet(String.CASE_INSENSITIVE_ORDER);
diff --git a/fe/src/com/baidu/palo/analysis/InsertStmt.java b/fe/src/com/baidu/palo/analysis/InsertStmt.java
index 4807ac7bd66971..986bd2cd21ee39 100644
--- a/fe/src/com/baidu/palo/analysis/InsertStmt.java
+++ b/fe/src/com/baidu/palo/analysis/InsertStmt.java
@@ -371,4 +371,14 @@ public ArrayList<Expr> getResultExprs() {
     public DataPartition getDataPartition() {
         return dataPartition;
     }
+
+    @Override
+    public void reset() {
+        super.reset();
+        queryStmt.reset();
+        resultExprs.clear();
+        exprByName.clear();
+        dataSink = null;
+        dataPartition = null;
+    }
 }
diff --git a/fe/src/com/baidu/palo/catalog/Catalog.java b/fe/src/com/baidu/palo/catalog/Catalog.java
index 001cdca3a1e172..c1e8f700c31e76 100644
--- a/fe/src/com/baidu/palo/catalog/Catalog.java
+++ b/fe/src/com/baidu/palo/catalog/Catalog.java
@@ -2019,6 +2019,10 @@ public synchronized boolean replayJournal(long toJournalId) {
             if (!isMaster) {
                 journalObservable.notifyObservers(replayedJournalId.get());
             }
+            if (MetricRepo.isInit.get()) {
+                // Metric repo may not init after this replay thread start
+                MetricRepo.COUNTER_EDIT_LOG_READ.increase(1L);
+            }
         }
         long cost = System.currentTimeMillis() - startTime;
         if (cost >= 1000) {
diff --git a/fe/src/com/baidu/palo/common/Status.java b/fe/src/com/baidu/palo/common/Status.java
index 8ce9fa28b9ee0e..e07faf800a6e46 100644
--- a/fe/src/com/baidu/palo/common/Status.java
+++ b/fe/src/com/baidu/palo/common/Status.java
@@ -18,110 +18,118 @@
 // specific language governing permissions and limitations
 // under the License.
 
-package com.baidu.palo.common;
-
-import com.baidu.palo.thrift.TStatus;
-import com.baidu.palo.thrift.TStatusCode;
-
-public class Status {
-    public static final Status OK               = new Status();
-    public static final Status CANCELLED        = new Status(TStatusCode.CANCELLED, "Canelled");
-    public static final Status THRIFT_RPC_ERROR = 
-            new Status(TStatusCode.THRIFT_RPC_ERROR, "Thrift RPC failed");
-
-    public TStatusCode getErrorCode() {
-        return errorCode;
-    }
-
-    public String getErrorMsg() {
-        return errorMsg;
-    }
-
-    private TStatusCode  errorCode; // anything other than OK
-    private String errorMsg;
-    
-    public Status() {
-        this.errorCode = TStatusCode.OK;
-        this.errorMsg = null;
-    }
-    
-    public Status(Status status) {
-        this(status.getErrorCode(), status.getErrorMsg());
-    }
-
-    public Status(TStatusCode code, final String errorMsg) {
-        this.errorCode = code;
-        this.errorMsg = errorMsg;
-    }
-
-    public Status(final TStatus status) {
-        this.errorCode = status.status_code;
-        if (status.isSetError_msgs()) {
-            this.errorMsg = status.error_msgs.get(0);
-        }
-    }
-
-    public boolean ok() {
-        return this.errorCode == TStatusCode.OK;
-    }
-    
-    public boolean isCancelled() {
-        return this.errorCode == TStatusCode.CANCELLED;
-    }
-    
-    public boolean isRpcError() {
-        return this.errorCode == TStatusCode.THRIFT_RPC_ERROR;
-    }
-    
-    public void setStatus(Status status) {
-        this.errorCode = status.errorCode;
-        this.errorMsg = status.getErrorMsg();
-    }
-    
-    public void setStatus(String msg) {
-        this.errorCode = TStatusCode.INTERNAL_ERROR;
-        this.errorMsg = msg;
-    }
-
-    public void setRpcStatus(String msg) {
-        this.errorCode = TStatusCode.THRIFT_RPC_ERROR;
-        this.errorMsg = msg;
-    }
-
-    public void rewriteErrorMsg() {
-        if (ok()) {
-            return;
-        }
-        
-        switch (errorCode) {
-            case CANCELLED: {
-                this.errorMsg = "Cancelled";
-                break;
-            } case ANALYSIS_ERROR: {
-                this.errorMsg = "Analysis_error";
-                break;
-            } case NOT_IMPLEMENTED_ERROR: {
-                this.errorMsg = "Not_implemented_error";
-                break;
-            } case RUNTIME_ERROR: {
-                this.errorMsg = "Runtime_error";
-                break;
-            } case MEM_LIMIT_EXCEEDED: {
-                this.errorMsg = "Mem_limit_error";
-                break;
-            } case INTERNAL_ERROR: {
-                this.errorMsg = "Internal_error";
-                break;
-            } case THRIFT_RPC_ERROR: {
-                this.errorMsg = "Thrift_rpc_error";
-                break;
-            } case TIMEOUT: {
-                this.errorMsg = "Timeout";
-                break;
-            } default: {
-                this.errorMsg = "Unknown_error";
-                break;
-            }
-        }
-    }
-}
+package com.baidu.palo.common;
+
+import com.baidu.palo.rpc.PStatus;
+import com.baidu.palo.thrift.TStatus;
+import com.baidu.palo.thrift.TStatusCode;
+
+public class Status {
+    public static final Status OK               = new Status();
+    public static final Status CANCELLED        = new Status(TStatusCode.CANCELLED, "Canelled");
+    public static final Status THRIFT_RPC_ERROR = 
+            new Status(TStatusCode.THRIFT_RPC_ERROR, "Thrift RPC failed");
+
+    public TStatusCode getErrorCode() {
+        return errorCode;
+    }
+
+    public String getErrorMsg() {
+        return errorMsg;
+    }
+
+    private TStatusCode  errorCode; // anything other than OK
+    private String errorMsg;
+    
+    public Status() {
+        this.errorCode = TStatusCode.OK;
+        this.errorMsg = null;
+    }
+    
+    public Status(Status status) {
+        this(status.getErrorCode(), status.getErrorMsg());
+    }
+
+    public Status(TStatusCode code, final String errorMsg) {
+        this.errorCode = code;
+        this.errorMsg = errorMsg;
+    }
+
+    public Status(final TStatus status) {
+        this.errorCode = status.status_code;
+        if (status.isSetError_msgs()) {
+            this.errorMsg = status.error_msgs.get(0);
+        }
+    }
+
+    public boolean ok() {
+        return this.errorCode == TStatusCode.OK;
+    }
+    
+    public boolean isCancelled() {
+        return this.errorCode == TStatusCode.CANCELLED;
+    }
+    
+    public boolean isRpcError() {
+        return this.errorCode == TStatusCode.THRIFT_RPC_ERROR;
+    }
+    
+    public void setStatus(Status status) {
+        this.errorCode = status.errorCode;
+        this.errorMsg = status.getErrorMsg();
+    }
+    
+    public void setStatus(String msg) {
+        this.errorCode = TStatusCode.INTERNAL_ERROR;
+        this.errorMsg = msg;
+    }
+
+    public void setPstatus(PStatus status) {
+        this.errorCode = TStatusCode.findByValue(status.code);
+        if (status.msgs != null && !status.msgs.isEmpty()) {
+            this.errorMsg = status.msgs.get(0);
+        }
+    }
+
+    public void setRpcStatus(String msg) {
+        this.errorCode = TStatusCode.THRIFT_RPC_ERROR;
+        this.errorMsg = msg;
+    }
+
+    public void rewriteErrorMsg() {
+        if (ok()) {
+            return;
+        }
+        
+        switch (errorCode) {
+            case CANCELLED: {
+                this.errorMsg = "Cancelled";
+                break;
+            } case ANALYSIS_ERROR: {
+                this.errorMsg = "Analysis_error";
+                break;
+            } case NOT_IMPLEMENTED_ERROR: {
+                this.errorMsg = "Not_implemented_error";
+                break;
+            } case RUNTIME_ERROR: {
+                this.errorMsg = "Runtime_error";
+                break;
+            } case MEM_LIMIT_EXCEEDED: {
+                this.errorMsg = "Mem_limit_error";
+                break;
+            } case INTERNAL_ERROR: {
+                this.errorMsg = "Internal_error";
+                break;
+            } case THRIFT_RPC_ERROR: {
+                this.errorMsg = "Thrift_rpc_error";
+                break;
+            } case TIMEOUT: {
+                this.errorMsg = "Timeout";
+                break;
+            } default: {
+                this.errorMsg = "Unknown_error";
+                break;
+            }
+        }
+    }
+}
diff --git a/fe/src/com/baidu/palo/common/proc/TabletsProcDir.java b/fe/src/com/baidu/palo/common/proc/TabletsProcDir.java
index 5915b433c1fcf0..26990373fda7ce 100644
--- a/fe/src/com/baidu/palo/common/proc/TabletsProcDir.java
+++ b/fe/src/com/baidu/palo/common/proc/TabletsProcDir.java
@@ -93,6 +93,10 @@ public ProcResult fetchResult() {
                         long backendId = replica.getBackendId();
                         tabletInfo.add(replica.getBackendId());
                         Backend backend = Catalog.getCurrentSystemInfo().getBackend(backendId);
+                        // backend may be dropped concurrently, ignore it.
+                        if (backend == null) {
+                            continue;
+                        }
                         String hostName = null;
                         try {
                             InetAddress address = InetAddress.getByName(backend.getHost());
diff --git a/fe/src/com/baidu/palo/master/Checkpoint.java b/fe/src/com/baidu/palo/master/Checkpoint.java
index 9cefbaaf039200..5b35b2d73ec2b7 100644
--- a/fe/src/com/baidu/palo/master/Checkpoint.java
+++ b/fe/src/com/baidu/palo/master/Checkpoint.java
@@ -13,260 +13,276 @@
 // specific language governing permissions and limitations
 // under the License.
 
-package com.baidu.palo.master;
-
-import com.baidu.palo.catalog.Catalog;
-import com.baidu.palo.catalog.Database;
-import com.baidu.palo.catalog.MaterializedIndex;
-import com.baidu.palo.catalog.OlapTable;
-import com.baidu.palo.catalog.Partition;
-import com.baidu.palo.catalog.Table;
-import com.baidu.palo.catalog.Tablet;
-import com.baidu.palo.catalog.Table.TableType;
-import com.baidu.palo.common.Config;
-import com.baidu.palo.common.util.Daemon;
-import com.baidu.palo.persist.EditLog;
-import com.baidu.palo.persist.MetaCleaner;
-import com.baidu.palo.persist.Storage;
-
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.LogManager;
-
-import java.io.IOException;
-import java.io.OutputStream;
-import java.lang.management.ManagementFactory;
-import java.lang.management.MemoryUsage;
-import java.net.HttpURLConnection;
-import java.net.InetSocketAddress;
-import java.net.URL;
-import java.util.List;
-
-/**
- * Checkpoint daemon is running on master node. handle the checkpoint work for palo. 
- */
-public class Checkpoint extends Daemon {
-    public static final Logger LOG = LogManager.getLogger(Checkpoint.class);
-    private static final int PUT_TIMEOUT_SECOND = 3600;
-    private static final int CONNECT_TIMEOUT_SECOND = 1;
-    private static final int READ_TIMEOUT_SECOND = 1;
-    private static final int AVERAGE_PARTITION_SIZE = 64;
-    private static final int AVERAGE_INDEX_SIZE = 56;
-    private static final int AVERAGE_TABLET_SIZE = 16;
-    private static final int AVERAGE_REPLICA_SIZE = 56;
-    private static final int AVERAGE_LOADJOB_SIZE = 168;
-    private static final int MAX_MEMORY_USAGE_RATE = 90;
-    
-    private Catalog catalog;
-    private String imageDir;
-    private EditLog editLog;
-
-    public Checkpoint(EditLog editLog) throws IOException {
-        this.imageDir = Catalog.IMAGE_DIR;
-        this.editLog = editLog;
-    }
-    
-    public Checkpoint() {
-        
-    }
-
-    public static class NullOutputStream extends OutputStream {
-        public void write(byte[] b, int off, int len) throws IOException {
-        }
-
-        public void write(int b) throws IOException {
-        }
-    }
-
-    protected void runOneCycle() {
-        long imageVersion = 0;
-        long checkPointVersion = 0;
-        Storage storage = null;
-        try {
-            storage = new Storage(imageDir);
-            // get max image version
-            imageVersion = storage.getImageSeq();
-            // get max finalized journal id
-            checkPointVersion = editLog.getFinalizedJournalId();
-            LOG.info("checkpoint imageVersion {}, checkPointVersion {}", imageVersion, checkPointVersion);
-            if (imageVersion >= checkPointVersion) {
-                return;
-            }
-        } catch (IOException e) {
-            LOG.error("Does not get storage info", e);
-            return;
-        }
-        
-        if (!checkMemoryEnoughToDoCheckpoint()) {
-            return;
-        }
-       
-        long replayedJournalId = -1;
-        // generate new image file
-        catalog = Catalog.getCheckpoint();
-        catalog.setEditLog(editLog);
-        try {
-            catalog.loadImage(imageDir);
-            catalog.replayJournal(checkPointVersion);
-            if (catalog.getReplayedJournalId() != checkPointVersion) {
-                LOG.error("checkpoint version should be {}, actual replayed journal id is {}",
-                          checkPointVersion, catalog.getReplayedJournalId());
-                return;
-            }
-            catalog.saveImage();
-            replayedJournalId = catalog.getReplayedJournalId();
-            LOG.info("checkpoint finished save image.{}", replayedJournalId);
-        } catch (Exception e) {
-            e.printStackTrace();
-            LOG.error("Exception when generate new image file", e);
-            return;
-        } finally {
-            // destroy checkpoint catalog, reclaim memory
-            catalog = null;
-            Catalog.destroyCheckpoint(); 
-        }
-        
-        // push image file to all the other nodes
-        List<InetSocketAddress> otherNodes = Catalog.getInstance().getHaProtocol().getNoneLeaderNodes();
-        int successPushed = 0;
-        int otherNodesCount = 0;
-        if (otherNodes != null) {
-            otherNodesCount = otherNodes.size();
-            for (InetSocketAddress node : otherNodes) {
-                String host = node.getHostString();
-                int port = Config.http_port;
-                
-                String url = "http://" + host + ":" + port + "/put?version=" + replayedJournalId
-                        + "&port=" + port;
-                LOG.info("Put image:{}", url);
-
-                try {
-                    MetaHelper.getRemoteFile(url, PUT_TIMEOUT_SECOND * 1000, new NullOutputStream());
-                    successPushed++;
-                } catch (IOException e) {
-                    LOG.error("Exception when pushing image file. url = {}", url, e);
-                }
-            }
-            
-            LOG.info("push image.{} to other nodes. totally {} nodes, push successed {} nodes",
-                     replayedJournalId, otherNodesCount, successPushed);
-        }
-        
-        // Delete old journals
-        if (successPushed == otherNodesCount) {
-            long minOtherNodesJournalId = Long.MAX_VALUE;
-            long deleteVersion = checkPointVersion;
-            if (successPushed > 0) {
-                for (InetSocketAddress node : otherNodes) {
-                    String host = node.getHostString();
-                    int port = Config.http_port;
-                    URL idURL;
-                    HttpURLConnection conn = null;
-                    try {
-                        /*
-                         * get current replayed journal id of each non-master nodes.
-                         * when we delete bdb database, we cannot delete db newer than
-                         * any non-master node's current replayed journal id. otherwise,
-                         * this lagging node can never get the deleted journal.
-                         */
-                        idURL = new URL("http://" + host + ":" + port + "/journal_id");
-                        conn = (HttpURLConnection) idURL.openConnection();
-                        conn.setConnectTimeout(CONNECT_TIMEOUT_SECOND * 1000);
-                        conn.setReadTimeout(READ_TIMEOUT_SECOND * 1000);
-                        String idString = conn.getHeaderField("id");
-                        long id = Long.parseLong(idString);
-                        if (minOtherNodesJournalId > id) {
-                            minOtherNodesJournalId = id;
-                        }
-                    } catch (IOException e) {
-                        LOG.error("Exception when getting current replayed journal id. host={}, port={}",
-                                host, port, e);
-                        minOtherNodesJournalId = 0;
-                        break;
-                    } finally {
-                        if (conn != null) {
-                            conn.disconnect();
-                        }
-                    }
-                }
-                deleteVersion = (minOtherNodesJournalId > checkPointVersion)
-                        ? checkPointVersion : minOtherNodesJournalId;
-            }
-            editLog.deleteJournals(deleteVersion + 1);
-            LOG.info("journals <= {} are deleted. image version {}, other nodes min version {}", 
-                    deleteVersion, checkPointVersion, minOtherNodesJournalId);
-        }
-        
-        // Delete old image files
-        MetaCleaner cleaner = new MetaCleaner(Config.meta_dir + "/image");
-        try {
-            cleaner.clean();
-        } catch (IOException e) {
-            LOG.error("Master delete old image file fail.", e);
-        }
-    
-    }
-    
-    private boolean checkMemoryEnoughToDoCheckpoint() {
-        List<String> dbNames = Catalog.getInstance().getDbNames();
-        if (dbNames == null || dbNames.isEmpty()) {
-            return true;
-        }
-        
-        int totalPartitionNum = 0;
-        int totalIndexNum = 0;
-        int totalTabletNum = 0;
-        int totalReplicaNum = 0;
-        long stillNeedMemorySize = 0;
-        
-        for (String name : dbNames) {
-            Database db = Catalog.getInstance().getDb(name);
-            if (db == null) {
-                continue;
-            }
-
-            db.readLock();
-            try {
-                for (Table table : db.getTables()) {
-                    if (table.getType() != TableType.OLAP) {
-                        continue;
-                    }
-
-                    OlapTable olapTable = (OlapTable) table;
-                    for (Partition partition : olapTable.getPartitions()) {
-                        totalPartitionNum++;
-                        for (MaterializedIndex materializedIndex : partition.getMaterializedIndices()) {
-                            totalIndexNum++;
-                            for (Tablet tablet : materializedIndex.getTablets()) {
-                                totalTabletNum++;
-                                int replicaNum = tablet.getReplicas().size();
-                                totalReplicaNum += replicaNum;
-                            } // end for tablets
-                        } // end for indices
-                    } // end for partitions
-                } // end for tables
-            } finally {
-                db.readUnlock();
-            }
-        } // end for dbs
-        
-        int totalLoadJobNum = Catalog.getInstance().getLoadInstance().getLoadJobNumber();
-        stillNeedMemorySize += totalPartitionNum * AVERAGE_PARTITION_SIZE;
-        stillNeedMemorySize += totalIndexNum * AVERAGE_INDEX_SIZE;
-        stillNeedMemorySize += totalTabletNum * AVERAGE_TABLET_SIZE;
-        stillNeedMemorySize += totalReplicaNum * AVERAGE_REPLICA_SIZE;
-        stillNeedMemorySize += totalLoadJobNum * AVERAGE_LOADJOB_SIZE;
-        
-        MemoryUsage memoryUsage = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
-        /*
-         *  use memoryUsage.getUsed() * 2 instead of memoryUsage.getUsed() + stillNeedMemorySize?
-         *  stillNeedMemorySize is less than the actual memory needed to do checkpoint 
-         */
-        if (memoryUsage.getMax() * MAX_MEMORY_USAGE_RATE / 100 < memoryUsage.getUsed() + stillNeedMemorySize) {
-            LOG.warn("memory is not enough to do checkpoint. Committed memroy {} Bytes, used memory {} Bytes.",
-                    memoryUsage.getCommitted(), memoryUsage.getUsed());
-            return false;
-        }
-        return true;
-    }
-
-}
+package com.baidu.palo.master;
+
+import com.baidu.palo.catalog.Catalog;
+import com.baidu.palo.catalog.Database;
+import com.baidu.palo.catalog.MaterializedIndex;
+import com.baidu.palo.catalog.OlapTable;
+import com.baidu.palo.catalog.Partition;
+import com.baidu.palo.catalog.Table;
+import com.baidu.palo.catalog.Table.TableType;
+import com.baidu.palo.catalog.Tablet;
+import com.baidu.palo.common.Config;
+import com.baidu.palo.common.util.Daemon;
+import com.baidu.palo.metric.MetricRepo;
+import com.baidu.palo.persist.EditLog;
+import com.baidu.palo.persist.MetaCleaner;
+import com.baidu.palo.persist.Storage;
+import com.baidu.palo.system.Frontend;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.lang.management.ManagementFactory;
+import java.lang.management.MemoryUsage;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.List;
+
+/**
+ * Checkpoint daemon is running on master node. handle the checkpoint work for palo. 
+ */
+public class Checkpoint extends Daemon {
+    public static final Logger LOG = LogManager.getLogger(Checkpoint.class);
+    private static final int PUT_TIMEOUT_SECOND = 3600;
+    private static final int CONNECT_TIMEOUT_SECOND = 1;
+    private static final int READ_TIMEOUT_SECOND = 1;
+    private static final int AVERAGE_PARTITION_SIZE = 64;
+    private static final int AVERAGE_INDEX_SIZE = 56;
+    private static final int AVERAGE_TABLET_SIZE = 16;
+    private static final int AVERAGE_REPLICA_SIZE = 56;
+    private static final int AVERAGE_LOADJOB_SIZE = 168;
+    private static final int MAX_MEMORY_USAGE_RATE = 90;
+    
+    private Catalog catalog;
+    private String imageDir;
+    private EditLog editLog;
+
+    public Checkpoint(EditLog editLog) throws IOException {
+        this.imageDir = Catalog.IMAGE_DIR;
+        this.editLog = editLog;
+    }
+    
+    public Checkpoint() {
+        
+    }
+
+    public static class NullOutputStream extends OutputStream {
+        public void write(byte[] b, int off, int len) throws IOException {
+        }
+
+        public void write(int b) throws IOException {
+        }
+    }
+
+    protected void runOneCycle() {
+        long imageVersion = 0;
+        long checkPointVersion = 0;
+        Storage storage = null;
+        try {
+            storage = new Storage(imageDir);
+            // get max image version
+            imageVersion = storage.getImageSeq();
+            // get max finalized journal id
+            checkPointVersion = editLog.getFinalizedJournalId();
+            LOG.info("checkpoint imageVersion {}, checkPointVersion {}", imageVersion, checkPointVersion);
+            if (imageVersion >= checkPointVersion) {
+                return;
+            }
+        } catch (IOException e) {
+            LOG.error("Does not get storage info", e);
+            return;
+        }
+        
+        if (!checkMemoryEnoughToDoCheckpoint()) {
+            return;
+        }
+       
+        long replayedJournalId = -1;
+        // generate new image file
+        catalog = Catalog.getCheckpoint();
+        catalog.setEditLog(editLog);
+        try {
+            catalog.loadImage(imageDir);
+            catalog.replayJournal(checkPointVersion);
+            if (catalog.getReplayedJournalId() != checkPointVersion) {
+                LOG.error("checkpoint version should be {}, actual replayed journal id is {}",
+                          checkPointVersion, catalog.getReplayedJournalId());
+                return;
+            }
+            catalog.saveImage();
+            replayedJournalId = catalog.getReplayedJournalId();
+            if (MetricRepo.isInit.get()) {
+                MetricRepo.COUNTER_IMAGE_WRITE.increase(1L);
+            }
+            LOG.info("checkpoint finished save image.{}", replayedJournalId);
+        } catch (Exception e) {
+            e.printStackTrace();
+            LOG.error("Exception when generate new image file", e);
+            return;
+        } finally {
+            // destroy checkpoint catalog, reclaim memory
+            catalog = null;
+            Catalog.destroyCheckpoint(); 
+        }
+        
+        // push image file to all the other non master nodes
+        // DO NOT get other nodes from HaProtocol, because node may not in bdbje replication group yet.
+        List<Frontend> allFrontends = Catalog.getInstance().getFrontends(null);
+        int successPushed = 0;
+        int otherNodesCount = 0;
+        if (!allFrontends.isEmpty()) {
+            otherNodesCount = allFrontends.size() - 1; // skip master itself
+            for (Frontend fe : allFrontends) {
+                String host = fe.getHost();
+                if (host.equals(Catalog.getInstance().getMasterIp())) {
+                    // skip master itself
+                    continue;
+                }
+                int port = Config.http_port;
+                
+                String url = "http://" + host + ":" + port + "/put?version=" + replayedJournalId
+                        + "&port=" + port;
+                LOG.info("Put image:{}", url);
+
+                try {
+                    MetaHelper.getRemoteFile(url, PUT_TIMEOUT_SECOND * 1000, new NullOutputStream());
+                    successPushed++;
+                } catch (IOException e) {
+                    LOG.error("Exception when pushing image file. url = {}", url, e);
+                }
+            }
+            
+            LOG.info("push image.{} to other nodes. totally {} nodes, push successed {} nodes",
+                     replayedJournalId, otherNodesCount, successPushed);
+        }
+        
+        // Delete old journals
+        if (successPushed == otherNodesCount) {
+            long minOtherNodesJournalId = Long.MAX_VALUE;
+            long deleteVersion = checkPointVersion;
+            if (successPushed > 0) {
+                for (Frontend fe : allFrontends) {
+                    String host = fe.getHost();
+                    if (host.equals(Catalog.getInstance().getMasterIp())) {
+                        // skip master itself
+                        continue;
+                    }
+                    int port = Config.http_port;
+                    URL idURL;
+                    HttpURLConnection conn = null;
+                    try {
+                        /*
+                         * get current replayed journal id of each non-master nodes.
+                         * when we delete bdb database, we cannot delete db newer than
+                         * any non-master node's current replayed journal id. otherwise,
+                         * this lagging node can never get the deleted journal.
+                         */
+                        idURL = new URL("http://" + host + ":" + port + "/journal_id");
+                        conn = (HttpURLConnection) idURL.openConnection();
+                        conn.setConnectTimeout(CONNECT_TIMEOUT_SECOND * 1000);
+                        conn.setReadTimeout(READ_TIMEOUT_SECOND * 1000);
+                        String idString = conn.getHeaderField("id");
+                        long id = Long.parseLong(idString);
+                        if (minOtherNodesJournalId > id) {
+                            minOtherNodesJournalId = id;
+                        }
+                    } catch (IOException e) {
+                        LOG.error("Exception when getting current replayed journal id. host={}, port={}",
+                                host, port, e);
+                        minOtherNodesJournalId = 0;
+                        break;
+                    } finally {
+                        if (conn != null) {
+                            conn.disconnect();
+                        }
+                    }
+                }
+                deleteVersion = (minOtherNodesJournalId > checkPointVersion)
+                        ? checkPointVersion : minOtherNodesJournalId;
+            }
+            editLog.deleteJournals(deleteVersion + 1);
+            if (MetricRepo.isInit.get()) {
+                MetricRepo.COUNTER_IMAGE_PUSH.increase(1L);
+            }
+            LOG.info("journals <= {} are deleted. image version {}, other nodes min version {}", 
+                     deleteVersion, checkPointVersion, minOtherNodesJournalId);
+        }
+        
+        // Delete old image files
+        MetaCleaner cleaner = new MetaCleaner(Config.meta_dir + "/image");
+        try {
+            cleaner.clean();
+        } catch (IOException e) {
+            LOG.error("Master delete old image file fail.", e);
+        }
+    
+    }
+    
+    private boolean checkMemoryEnoughToDoCheckpoint() {
+        List<String> dbNames = Catalog.getInstance().getDbNames();
+        if (dbNames == null || dbNames.isEmpty()) {
+            return true;
+        }
+        
+        int totalPartitionNum = 0;
+        int totalIndexNum = 0;
+        int totalTabletNum = 0;
+        int totalReplicaNum = 0;
+        long stillNeedMemorySize = 0;
+        
+        for (String name : dbNames) {
+            Database db = Catalog.getInstance().getDb(name);
+            if (db == null) {
+                continue;
+            }
+
+            db.readLock();
+            try {
+                for (Table table : db.getTables()) {
+                    if (table.getType() != TableType.OLAP) {
+                        continue;
+                    }
+
+                    OlapTable olapTable = (OlapTable) table;
+                    for (Partition partition : olapTable.getPartitions()) {
+                        totalPartitionNum++;
+                        for (MaterializedIndex materializedIndex : partition.getMaterializedIndices()) {
+                            totalIndexNum++;
+                            for (Tablet tablet : materializedIndex.getTablets()) {
+                                totalTabletNum++;
+                                int replicaNum = tablet.getReplicas().size();
+                                totalReplicaNum += replicaNum;
+                            } // end for tablets
+                        } // end for indices
+                    } // end for partitions
+                } // end for tables
+            } finally {
+                db.readUnlock();
+            }
+        } // end for dbs
+        
+        int totalLoadJobNum = Catalog.getInstance().getLoadInstance().getLoadJobNumber();
+        stillNeedMemorySize += totalPartitionNum * AVERAGE_PARTITION_SIZE;
+        stillNeedMemorySize += totalIndexNum * AVERAGE_INDEX_SIZE;
+        stillNeedMemorySize += totalTabletNum * AVERAGE_TABLET_SIZE;
+        stillNeedMemorySize += totalReplicaNum * AVERAGE_REPLICA_SIZE;
+        stillNeedMemorySize += totalLoadJobNum * AVERAGE_LOADJOB_SIZE;
+        
+        MemoryUsage memoryUsage = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
+        /*
+         *  use memoryUsage.getUsed() * 2 instead of memoryUsage.getUsed() + stillNeedMemorySize?
+         *  stillNeedMemorySize is less than the actual memory needed to do checkpoint 
+         */
+        if (memoryUsage.getMax() * MAX_MEMORY_USAGE_RATE / 100 < memoryUsage.getUsed() + stillNeedMemorySize) {
+            LOG.warn("memory is not enough to do checkpoint. Committed memroy {} Bytes, used memory {} Bytes.",
+                    memoryUsage.getCommitted(), memoryUsage.getUsed());
+            return false;
+        }
+        return true;
+    }
+
+}
diff --git a/fe/src/com/baidu/palo/metric/MetricRepo.java b/fe/src/com/baidu/palo/metric/MetricRepo.java
index de8896fc7e4f98..9767150d15336b 100644
--- a/fe/src/com/baidu/palo/metric/MetricRepo.java
+++ b/fe/src/com/baidu/palo/metric/MetricRepo.java
@@ -29,6 +29,7 @@
 import com.baidu.palo.load.LoadJob.JobState;
 import com.baidu.palo.monitor.jvm.JvmService;
 import com.baidu.palo.monitor.jvm.JvmStats;
+import com.baidu.palo.persist.EditLog;
 import com.baidu.palo.service.ExecuteEnv;
 import com.baidu.palo.system.Backend;
 import com.baidu.palo.system.SystemInfoService;
@@ -41,6 +42,7 @@
 
 import java.util.Map;
 import java.util.SortedMap;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 public final class MetricRepo {
     private static final Logger LOG = LogManager.getLogger(MetricRepo.class);
@@ -48,17 +50,21 @@ public final class MetricRepo {
     private static final MetricRegistry METRIC_REGISTER = new MetricRegistry();
     private static final PaloMetricRegistry PALO_METRIC_REGISTER = new PaloMetricRegistry();
     
-    private static boolean isInit = false;
+    public static AtomicBoolean isInit = new AtomicBoolean(false);
 
     public static PaloLongCounterMetric COUNTER_REQUEST_ALL;
     public static PaloLongCounterMetric COUNTER_QUERY_ALL;
     public static PaloLongCounterMetric COUNTER_QUERY_ERR;
     public static PaloLongCounterMetric COUNTER_LOAD_ADD;
     public static PaloLongCounterMetric COUNTER_LOAD_FINISHED;
+    public static PaloLongCounterMetric COUNTER_EDIT_LOG_WRITE;
+    public static PaloLongCounterMetric COUNTER_EDIT_LOG_READ;
+    public static PaloLongCounterMetric COUNTER_IMAGE_WRITE;
+    public static PaloLongCounterMetric COUNTER_IMAGE_PUSH;
     public static Histogram HISTO_QUERY_LATENCY;
 
     public static synchronized void init() {
-        if (isInit) {
+        if (isInit.get()) {
             return;
         }
 
@@ -124,6 +130,20 @@ public Integer getValue() {
         };
         PALO_METRIC_REGISTER.addPaloMetrics(conections);
 
+        // journal id
+        PaloGaugeMetric<Long> maxJournalId = (PaloGaugeMetric<Long>) new PaloGaugeMetric<Long>(
+                "max_journal_id", "max journal id of this frontends") {
+            @Override
+            public Long getValue() {
+                EditLog editLog = Catalog.getInstance().getEditLog();
+                if (editLog == null) {
+                    return -1L;
+                }
+                return editLog.getMaxJournalId();
+            }
+        };
+        PALO_METRIC_REGISTER.addPaloMetrics(maxJournalId);
+
         // 2. counter
         COUNTER_REQUEST_ALL = new PaloLongCounterMetric("request_total", "total request");
         PALO_METRIC_REGISTER.addPaloMetrics(COUNTER_REQUEST_ALL);
@@ -135,11 +155,21 @@ public Integer getValue() {
         PALO_METRIC_REGISTER.addPaloMetrics(COUNTER_LOAD_ADD);
         COUNTER_LOAD_FINISHED = new PaloLongCounterMetric("load_finished", "total laod finished");
         PALO_METRIC_REGISTER.addPaloMetrics(COUNTER_LOAD_FINISHED);
+        COUNTER_EDIT_LOG_WRITE = new PaloLongCounterMetric("edit_log_write", "counter of edit log write into bdbje");
+        PALO_METRIC_REGISTER.addPaloMetrics(COUNTER_EDIT_LOG_WRITE);
+        COUNTER_EDIT_LOG_READ = new PaloLongCounterMetric("edit_log_read", "counter of edit log read from bdbje");
+        PALO_METRIC_REGISTER.addPaloMetrics(COUNTER_EDIT_LOG_READ);
+        COUNTER_IMAGE_WRITE = new PaloLongCounterMetric("image_write", "counter of image generated");
+        PALO_METRIC_REGISTER.addPaloMetrics(COUNTER_IMAGE_WRITE);
+        COUNTER_IMAGE_PUSH = new PaloLongCounterMetric("image_push",
+                "counter of image succeeded in pushing to other frontends");
+        PALO_METRIC_REGISTER.addPaloMetrics(COUNTER_IMAGE_PUSH);
 
         // 3. histogram
         HISTO_QUERY_LATENCY = METRIC_REGISTER.histogram(MetricRegistry.name("query", "latency", "ms"));
 
-        isInit = true;
+        isInit.set(true);
+        ;
     }
 
     // this metric is reentrant, so that we can add or remove metric along with the backend add or remove
@@ -195,7 +225,7 @@ public Long getValue() {
     }
 
     public static synchronized String getMetric(PaloMetricVisitor visitor) {
-        if (!isInit) {
+        if (!isInit.get()) {
             return "";
         }
         StringBuilder sb = new StringBuilder();
@@ -223,3 +253,4 @@ public static synchronized String getMetric(PaloMetricVisitor visitor) {
         return sb.toString();
     }
 }
+
diff --git a/fe/src/com/baidu/palo/persist/EditLog.java b/fe/src/com/baidu/palo/persist/EditLog.java
index e5202e72e6b2d1..9b8d2d772cda1d 100644
--- a/fe/src/com/baidu/palo/persist/EditLog.java
+++ b/fe/src/com/baidu/palo/persist/EditLog.java
@@ -44,6 +44,7 @@
 import com.baidu.palo.load.Load;
 import com.baidu.palo.load.LoadErrorHub;
 import com.baidu.palo.load.LoadJob;
+import com.baidu.palo.metric.MetricRepo;
 import com.baidu.palo.qe.SessionVariable;
 import com.baidu.palo.system.Backend;
 import com.baidu.palo.system.Frontend;
@@ -583,6 +584,10 @@ private synchronized void logEdit(short op, Writable writable) {
             rollEditLog();
             txId = 0;
         }
+
+        if (MetricRepo.isInit.get()) {
+            MetricRepo.COUNTER_EDIT_LOG_WRITE.increase(1L);
+        }
     }
 
     /**
diff --git a/fe/src/com/baidu/palo/planner/SingleNodePlanner.java b/fe/src/com/baidu/palo/planner/SingleNodePlanner.java
index 525bd4ce2d1747..f0fb8bac0bee3e 100644
--- a/fe/src/com/baidu/palo/planner/SingleNodePlanner.java
+++ b/fe/src/com/baidu/palo/planner/SingleNodePlanner.java
@@ -660,28 +660,11 @@ private PlanNode createSelectPlan(SelectStmt selectStmt, Analyzer analyzer, long
         
         // create left-deep sequence of binary hash joins; assign node ids as we go along
         TableRef tblRef = selectStmt.getTableRefs().get(0);
+        materializeTableResultForCrossJoinOrCountStar(tblRef, analyzer);
         PlanNode root = createTableRefNode(analyzer, tblRef);
         // to change the inner contains analytic function
         // selectStmt.seondSubstituteInlineViewExprs(analyzer.getChangeResSmap());
 
-        if (root instanceof ScanNode) {
-            if (tblRef.getDesc().getSlots().isEmpty()) {
-                Column minimuColumn = null;
-                for (Column col : tblRef.getTable().getBaseSchema()) {
-                    if (minimuColumn == null || col.getDataType().getSlotSize() < minimuColumn
-                            .getDataType().getSlotSize()) {
-                        minimuColumn = col;
-                    }
-                }
-                if (minimuColumn != null) {
-                    SlotDescriptor slot = analyzer.getDescTbl().addSlotDescriptor(tblRef.getDesc());
-                    slot.setColumn(minimuColumn);
-                    slot.setIsMaterialized(true);
-                }
-            }
-        }
-
-
         // add aggregate node here
         AggregateInfo aggInfo = selectStmt.getAggInfo();
 
@@ -1250,39 +1233,16 @@ private void getHashLookupJoinConjuncts(Analyzer analyzer, List<TupleId> lhsIds,
      */
     private PlanNode createJoinNode(Analyzer analyzer, PlanNode outer, TableRef outerRef, TableRef innerRef)
             throws InternalException, AnalysisException {
+         materializeTableResultForCrossJoinOrCountStar(innerRef, analyzer);
         // the rows coming from the build node only need to have space for the tuple
         // materialized by that node
         PlanNode inner = createTableRefNode(analyzer, innerRef);
 
-        // if (((outerRef instanceof InlineViewRef) || (innerRef instanceof InlineViewRef))
-        //         && (analyzer.getWindowBool())) {
-        //     throw new AnalysisException("can't support it");
-        // }
-
-        if (inner instanceof ScanNode) {
-            if (innerRef.getDesc().getSlots().isEmpty()) {
-                Column minimuColumn = null;
-                for (Column col : innerRef.getTable().getBaseSchema()) {
-                    if (minimuColumn == null || col.getDataType().getSlotSize() < minimuColumn
-                            .getDataType().getSlotSize()) {
-                        minimuColumn = col;
-                    }
-                }
-                if (minimuColumn != null) {
-                    SlotDescriptor slot = analyzer.getDescTbl().addSlotDescriptor(innerRef.getDesc());
-                    slot.setColumn(minimuColumn);
-                    slot.setIsMaterialized(true);
-                }
-            }
-        }
-
         List<Pair<Expr, Expr>> eqJoinConjuncts = Lists.newArrayList();
         List<Expr> eqJoinPredicates = Lists.newArrayList();
         Reference<String> errMsg = new Reference<String>();
         // get eq join predicates for the TableRefs' ids (not the PlanNodes' ids, which
         // are materialized)
-        // getHashLookupJoinConjuncts(analyzer, outer.getTupleIds(), innerRef, eqJoinConjuncts,
-        //                            eqJoinPredicates, errMsg);
         getHashLookupJoinConjuncts(analyzer, outer.getTblRefIds(), innerRef, eqJoinConjuncts,
                 eqJoinPredicates, errMsg);
         if (eqJoinPredicates.isEmpty()) {
@@ -1293,11 +1253,6 @@ private PlanNode createJoinNode(Analyzer analyzer, PlanNode outer, TableRef oute
                     + " is not supported");
             }
 
-            if (innerRef instanceof InlineViewRef) {
-                InlineViewRef inlineView = (InlineViewRef) innerRef;
-                inlineView.getAnalyzer().materializeSlots(inlineView.getViewStmt().getBaseTblResultExprs());
-            } 
-
             // construct cross join node
             LOG.info("Join between " + outerRef.getAliasAsName() + " and " + innerRef.getAliasAsName()
                     + "requires at least one conjunctive equality predicate between the two tables");
@@ -1461,4 +1416,95 @@ private PlanNode createUnionPlan(UnionStmt unionStmt, Analyzer analyzer, long de
         }
         return result;
     }
+
+    /**
+     * According to the way to materialize slots from top to bottom, Materialization will prune columns
+     * which are not referenced by Statement outside. However, in some cases, in order to ensure The
+     * correct execution, it is necessary to materialize the slots that are not needed by Statement
+     * outside.
+     * @param tblRef
+     * @param analyzer
+     */
+    private void materializeTableResultForCrossJoinOrCountStar(TableRef tblRef, Analyzer analyzer) {
+        if (tblRef instanceof BaseTableRef) {
+            materializeBaseTableRefResultForCrossJoinOrCountStar((BaseTableRef)tblRef, analyzer);
+        } else if (tblRef instanceof InlineViewRef) {
+            materializeInlineViewResultExprForCrossJoinOrCountStar((InlineViewRef)tblRef, analyzer);
+        } else {
+            Preconditions.checkArgument(false);
+        }
+    }
+
+    /**
+     * materialize BaseTableRef result' exprs for Cross Join or Count Star
+     * @param tblRef
+     * @param analyzer
+     */
+    private void materializeBaseTableRefResultForCrossJoinOrCountStar(BaseTableRef tblRef, Analyzer analyzer) {
+        if (tblRef.getDesc().getSlots().isEmpty()) {
+            Column minimuColumn = null;
+            for (Column col : tblRef.getTable().getBaseSchema()) {
+                if (minimuColumn == null || col.getDataType().getSlotSize() < minimuColumn
+                        .getDataType().getSlotSize()) {
+                    minimuColumn = col;
+                }
+            }
+            if (minimuColumn != null) {
+                SlotDescriptor slot = analyzer.getDescTbl().addSlotDescriptor(tblRef.getDesc());
+                slot.setColumn(minimuColumn);
+                slot.setIsMaterialized(true);
+            }
+        }
+    }
+
+    /**
+     * materialize InlineViewRef result'exprs for Cross Join or Count Star
+     * @param inlineView
+     * @param analyzer
+     */
+    private void materializeInlineViewResultExprForCrossJoinOrCountStar(InlineViewRef inlineView, Analyzer analyzer) {
+        final List<Expr> baseResultExprs = inlineView.getViewStmt().getBaseTblResultExprs();
+        if (baseResultExprs.size() <= 0) {
+            return;
+        }
+        Expr resultExprSelected = null;
+        int resultExprSelectedSize = 0;
+        // check whether inlineView contains materialized result expr
+        for (Expr e : baseResultExprs) {
+            final List<SlotId> slotIds = Lists.newArrayList();
+            e.getIds(null, slotIds);
+            boolean exprIsMaterialized = true;
+            int exprSize = 0;
+            for (SlotId id : slotIds) {
+                final SlotDescriptor slot = analyzer.getDescTbl().getSlotDesc(id);
+                if (!slot.isMaterialized()) {
+                    exprIsMaterialized = false;
+                }
+                exprSize += slot.getByteSize();
+            }
+
+            if (exprIsMaterialized && exprSize <= resultExprSelectedSize) {
+                resultExprSelectedSize = exprSize;
+                resultExprSelected = e;
+            }
+            // Result Expr contains materialized expr, return
+            if (exprIsMaterialized) {
+                return;
+            }
+        }
+
+        // materialize slots which expr refer and It's total size is smallest
+        final List<SlotId> slotIds = Lists.newArrayList();
+        final List<TupleId> tupleIds = Lists.newArrayList();
+        resultExprSelected.getIds(tupleIds, slotIds);
+        for (SlotId id : slotIds) {
+            final SlotDescriptor slot = analyzer.getDescTbl().getSlotDesc(id);
+            slot.setIsMaterialized(true);
+        }
+        for (TupleId id : tupleIds) {
+            final TupleDescriptor tuple = analyzer.getDescTbl().getTupleDesc(id);
+            tuple.setIsMaterialized(true);
+        }
+    }
+
 }
diff --git a/fe/src/com/baidu/palo/qe/Coordinator.java b/fe/src/com/baidu/palo/qe/Coordinator.java
index 4005266f9657cb..fd0b07ef9971b0 100644
--- a/fe/src/com/baidu/palo/qe/Coordinator.java
+++ b/fe/src/com/baidu/palo/qe/Coordinator.java
@@ -18,9 +18,9 @@
 import com.baidu.palo.analysis.Analyzer;
 import com.baidu.palo.analysis.DescriptorTable;
 import com.baidu.palo.catalog.Catalog;
-import com.baidu.palo.common.ClientPool;
 import com.baidu.palo.common.Config;
 import com.baidu.palo.common.InternalException;
+import com.baidu.palo.common.Pair;
 import com.baidu.palo.common.Reference;
 import com.baidu.palo.common.Status;
 import com.baidu.palo.common.util.DebugUtil;
@@ -39,25 +39,20 @@
 import com.baidu.palo.planner.ResultSink;
 import com.baidu.palo.planner.ScanNode;
 import com.baidu.palo.planner.UnionNode;
+import com.baidu.palo.rpc.BackendServiceProxy;
+import com.baidu.palo.rpc.PExecPlanFragmentResult;
+import com.baidu.palo.rpc.RpcException;
 import com.baidu.palo.service.FrontendOptions;
 import com.baidu.palo.system.Backend;
 import com.baidu.palo.task.LoadEtlTask;
-import com.baidu.palo.thrift.BackendService;
-import com.baidu.palo.thrift.PaloInternalServiceConstants;
 import com.baidu.palo.thrift.PaloInternalServiceVersion;
-import com.baidu.palo.thrift.TCancelPlanFragmentParams;
-import com.baidu.palo.thrift.TCancelPlanFragmentResult;
 import com.baidu.palo.thrift.TDescriptorTable;
 import com.baidu.palo.thrift.TExecPlanFragmentParams;
-import com.baidu.palo.thrift.TExecPlanFragmentResult;
 import com.baidu.palo.thrift.TNetworkAddress;
 import com.baidu.palo.thrift.TPaloScanRange;
 import com.baidu.palo.thrift.TPartitionType;
-import com.baidu.palo.thrift.TPlan;
 import com.baidu.palo.thrift.TPlanFragmentDestination;
 import com.baidu.palo.thrift.TPlanFragmentExecParams;
-import com.baidu.palo.thrift.TPlanNode;
-import com.baidu.palo.thrift.TPlanNodeType;
 import com.baidu.palo.thrift.TQueryGlobals;
 import com.baidu.palo.thrift.TQueryOptions;
 import com.baidu.palo.thrift.TQueryType;
@@ -77,17 +72,14 @@
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
-
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.thrift.TException;
-import org.apache.thrift.transport.TTransportException;
 
 import java.text.DateFormat;
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Collections;
-import java.util.Comparator;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -96,9 +88,10 @@
 import java.util.Set;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 
@@ -335,32 +328,6 @@ private void traceInstance() {
         LOG.info(sb.toString());
     }
 
-    private class ExecStatus {
-        private TStatusCode errCode;
-        private TNetworkAddress errAddress;
-
-        public synchronized TStatusCode getErrCode() {
-            return errCode;
-        }
-
-        public synchronized void setErrCode(TStatusCode errCode) {
-            this.errCode = errCode;
-        }
-
-        public synchronized TNetworkAddress getErrAddress() {
-            return errAddress;
-        }
-
-        public synchronized void setErrAddress(TNetworkAddress errAddress) {
-            this.errAddress = errAddress;
-        }
-
-        public ExecStatus() {
-            this.errCode = TStatusCode.OK;
-            this.errAddress = new TNetworkAddress();
-        }
-    }
-
     // Initiate asynchronous execution of query. Returns as soon as all plan fragments
     // have started executing at their respective backends.
     // 'Request' must contain at least a coordinator plan fragment (ie, can't
@@ -394,10 +361,10 @@ public void exec() throws Exception {
         PlanFragmentId topId = fragments.get(0).getFragmentId();
         FragmentExecParams topParams = fragmentExecParamsMap.get(topId);
         if (topParams.fragment.getSink() instanceof ResultSink) {
-            TPlanFragmentDestination rootSource = new TPlanFragmentDestination();
-            rootSource.fragment_instance_id = topParams.instanceExecParams.get(0).instanceId;
-            rootSource.server = topParams.instanceExecParams.get(0).host;
-            receiver = new ResultReceiver(rootSource, addressToBackendID.get(rootSource.server),
+            receiver = new ResultReceiver(
+                    topParams.instanceExecParams.get(0).instanceId,
+                    addressToBackendID.get(topParams.instanceExecParams.get(0).host),
+                    toBrpcHost(topParams.instanceExecParams.get(0).host),
                     queryOptions.query_timeout * 1000);
         } else {
             // This is a insert statement.
@@ -422,6 +389,7 @@ public void exec() throws Exception {
                 int instanceNum = params.instanceExecParams.size();
                 Preconditions.checkState(instanceNum > 0);
                 List<TExecPlanFragmentParams> tParams = params.toThrift(backendId);
+                List<Pair<BackendExecState, Future<PExecPlanFragmentResult>>> futures = Lists.newArrayList();
                 int instanceId = 0;
                 for (TExecPlanFragmentParams tParam : tParams) {
                     // TODO: pool of pre-formatted BackendExecStates?
@@ -430,23 +398,50 @@ public void exec() throws Exception {
                                     profileFragmentId, tParam, this.addressToBackendID);
                     backendExecStates.add(execState);
                     backendExecStateMap.put(tParam.params.getFragment_instance_id(), execState);
+
+                    futures.add(Pair.create(execState, execState.execRemoteFragmentAsync()));
+
                     backendId++;
                 }
-                // Issue all rpcs in parallel
-                ExecStatus status = new ExecStatus();
-                ParallelExecutor.exec(backendExecStates, backendId - instanceNum, instanceNum, status);
-                if (status.getErrCode() != TStatusCode.OK) {
-                    String errMsg = "exec rpc error";
-                    queryStatus.setStatus(errMsg);
-                    LOG.warn("ParallelExecutor exec rpc error, fragmentId={} errBackend={}",
-                            fragment.getFragmentId(), status.getErrAddress());
-                    cancelInternal(); // err msg: rpc exec error
-                    if (status.getErrCode() == TStatusCode.TIMEOUT) {
-                        throw new InternalException(errMsg + " TIMEOUT");
-                    } else if (status.getErrCode() == TStatusCode.THRIFT_RPC_ERROR) {
-                        throw new TTransportException(errMsg + " THRIFT_RPC_ERROR");
-                    } else {
-                        throw new InternalException(errMsg + "UNKONWN");
+
+                for (Pair<BackendExecState, Future<PExecPlanFragmentResult>> pair : futures) {
+                    TStatusCode code = TStatusCode.INTERNAL_ERROR;
+                    String errMsg = null;
+                    try {
+                        PExecPlanFragmentResult result = pair.second.get(5, TimeUnit.SECONDS);
+                        code = TStatusCode.findByValue(result.status.code);
+                        if (result.status.msgs != null && !result.status.msgs.isEmpty()) {
+                            errMsg = result.status.msgs.get(0);
+                        }
+                    } catch (ExecutionException e) {
+                        LOG.warn("catch a execute exception", e);
+                        code = TStatusCode.THRIFT_RPC_ERROR;
+                    } catch (InterruptedException e) {
+                        LOG.warn("catch a interrupt exception", e);
+                        code = TStatusCode.INTERNAL_ERROR;
+                    } catch (TimeoutException e) {
+                        LOG.warn("catch a timeout exception", e);
+                        code = TStatusCode.TIMEOUT;
+                    }
+
+                    if (code != TStatusCode.OK) {
+                        if (errMsg == null) {
+                            errMsg = "exec rpc error";
+                        }
+                        queryStatus.setStatus(errMsg);
+                        LOG.warn("exec plan fragment failed, errmsg={}, fragmentId={}, backend={}:{}",
+                                errMsg, fragment.getFragmentId(),
+                                pair.first.address.hostname, pair.first.address.port);
+                        cancelInternal();
+                        switch (code) {
+                            case TIMEOUT:
+                                throw new InternalException("query timeout");
+                            case THRIFT_RPC_ERROR:
+                                SimpleScheduler.updateBlacklistBackends(pair.first.systemBackendId);
+                                throw new RpcException("rpc failed");
+                            default:
+                                throw new InternalException(errMsg);
+                        }
                     }
                 }
                 profileFragmentId += 1;
@@ -562,7 +557,7 @@ TResultBatch getNext() throws Exception {
                 copyStatus.rewriteErrorMsg();
             }
             if (copyStatus.isRpcError()) {
-                throw new TTransportException(copyStatus.getErrorMsg());
+                throw new RpcException(copyStatus.getErrorMsg());
             } else {
 
                 String errMsg = copyStatus.getErrorMsg();
@@ -617,19 +612,15 @@ private void cancelInternal() {
         if (null != receiver) {
             receiver.cancel();
         }
-        cancelRemoteFragments();
+        cancelRemoteFragmentsAsync();
     }
 
-    private void cancelRemoteFragments() {
+    private void cancelRemoteFragmentsAsync() {
         for (BackendExecState backendExecState : backendExecStates) {
             LOG.warn("cancelRemoteFragments initiated={} done={} hasCanceled={}",
-                backendExecState.initiated, backendExecState.done, backendExecState.hasCanceled);
-            BackendService.Client client = null;
-            TNetworkAddress address = null;
-            boolean isReturnToPool = false;
+                    backendExecState.initiated, backendExecState.done, backendExecState.hasCanceled);
+            backendExecState.lock();
             try {
-                backendExecState.lock();
-
                 if (!backendExecState.initiated) {
                     continue;
                 }
@@ -640,66 +631,31 @@ private void cancelRemoteFragments() {
                 if (backendExecState.hasCanceled) {
                     continue;
                 }
-                TCancelPlanFragmentResult thriftResult = null;
-                TCancelPlanFragmentParams rpcParams = new TCancelPlanFragmentParams();
-                rpcParams.setProtocol_version(PaloInternalServiceVersion.V1);
-                rpcParams.setFragment_instance_id(backendExecState.getFragmentInstanceId());
-                int cancelTimeoutMs = 5 * 1000;
+                TNetworkAddress address = backendExecState.getBackendAddress();
+                TNetworkAddress brcAddress = toBrpcHost(address);
+
+                LOG.info("cancelRemoteFragments ip={} port={} rpcParams={}", address.hostname, address.port,
+                        DebugUtil.printId(backendExecState.getFragmentInstanceId()));
+
                 try {
-                    address = backendExecState.getBackendAddress();
-                    client = ClientPool.backendPool.borrowObject(address,
-                            cancelTimeoutMs);
-                    LOG.info("cancelRemoteFragments ip={} port={} rpcParams={}", address.hostname, address.port,
-                            DebugUtil.printId(rpcParams.fragment_instance_id));
-                    thriftResult = client.cancel_plan_fragment(rpcParams);
-                    if (thriftResult.status.status_code == TStatusCode.OK) {
-                        backendExecState.hasCanceled = true;
-                    }
-                    isReturnToPool = true;
-                } catch (TTransportException e) {
-                    LOG.warn("cancelRemoteFragments ip={} port={}", address.hostname, address.port);
-                    LOG.warn("", e);
-                    // retry
-                    boolean ok = false;
-                    if (client == null) {
-                        client = ClientPool.backendPool.borrowObject(address, cancelTimeoutMs);
-                        ok = true;
-                    } else {
-                        ok = ClientPool.backendPool.reopen(client,
-                                cancelTimeoutMs);
-                    }
-                    if (!ok) {
-                        LOG.warn("reopen rpc error" + address.hostname + " exception", e);
-                        if (address != null) {
-                            SimpleScheduler.updateBlacklistBackends(
-                                    this.addressToBackendID.get(address));
-                        }
-                        continue;
-                    }
-                    if (e.getType() == TTransportException.TIMED_OUT) {
-                        LOG.warn("reopen rpc error" + address.hostname + " exception", e);
-                        continue;
-                    } else {
-                        thriftResult = client.cancel_plan_fragment(rpcParams);
-                        isReturnToPool = true;
-                    }
+                    BackendServiceProxy.getInstance().cancelPlanFragmentAsync(
+                            brcAddress, backendExecState.getFragmentInstanceId());
+                } catch (RpcException e) {
+                    LOG.warn("cancel plan fragment get a exception, address={}:{}",
+                            brcAddress.getHostname(), brcAddress.getPort());
+                    SimpleScheduler.updateBlacklistBackends(addressToBackendID.get(brcAddress));
                 }
+
+                backendExecState.hasCanceled = true;
             } catch (Exception e) {
-                LOG.warn("cancelRemoteFragments fail ip={} port={}", address.hostname, address.port);
-                LOG.warn("", e);
+                LOG.warn("catch a exception", e);
             } finally {
-                if (isReturnToPool) {
-                    ClientPool.backendPool.returnObject(address, client);
-                } else {
-                    ClientPool.backendPool.invalidateObject(address, client);
-                }
                 backendExecState.unlock();
             }
         }
     }
 
-
-   private void computeFragmentExecParams() throws Exception {
+    private void computeFragmentExecParams() throws Exception {
         // fill hosts field in fragmentExecParams
         computeFragmentHosts();
 
@@ -874,8 +830,7 @@ private void computeFragmentHosts() throws Exception {
             }
         }
     }
-    
- 
+
     private void computeFragmentExecParamsForParallelExec() throws Exception {
         // create exec params and set instance_id, host, per_node_scan_ranges
         computeFragmentInstances(fragmentExecParamsMap.get(fragments.get(0).getFragmentId()));
@@ -1166,7 +1121,6 @@ public void createUnionInstance(FragmentExecParams fragmentExecParams) {
         }
     }
     
-
     // Returns the id of the leftmost node of any of the gives types in 'plan_root',
     // or INVALID_PLAN_NODE_ID if no such node present.
     private PlanNode findLeftmostNode(PlanNode plan) {
@@ -1389,7 +1343,8 @@ public class BackendExecState {
         private Lock lock = new ReentrantLock();
         private int profileFragmentId;
         RuntimeProfile profile;
-        Map<TNetworkAddress, Long> addressToBackendID;
+        TNetworkAddress address;
+        Long systemBackendId;
 
         public int profileFragmentId() {
             return profileFragmentId;
@@ -1419,89 +1374,37 @@ public BackendExecState(PlanFragmentId fragmentId, int instanceId, int profileFr
             this.rpcParams = rpcParams;
             this.initiated = false;
             this.done = false;
+            this.address = fragmentExecParamsMap.get(fragmentId).instanceExecParams.get(instanceId).host;
+            this.systemBackendId = addressToBackendID.get(address);
+
             String name = "Instance " + DebugUtil.printId(fragmentExecParamsMap.get(fragmentId)
-                    .instanceExecParams.get(instanceId).instanceId) + " (host=" + getBackendAddress() + ")";
+                    .instanceExecParams.get(instanceId).instanceId) + " (host=" + address + ")";
             this.profile = new RuntimeProfile(name);
             this.hasCanceled = false;
-            this.addressToBackendID = addressToBackendID;
         }
 
         public TNetworkAddress getBackendAddress() {
-            return fragmentExecParamsMap.get(fragmentId).instanceExecParams.get(instanceId).host;
+            return address;
         }
 
         public TUniqueId getFragmentInstanceId() {
             return this.rpcParams.params.getFragment_instance_id();
         }
 
-        public void execRemoteFragment() throws Exception {
-            TExecPlanFragmentResult thriftResult = null;
-            BackendService.Client client = null;
-            TNetworkAddress address = null;
-            int execRemoteTimeoutMs = 5 * 1000;
-            boolean isReturnToPool = false;
+        public Future<PExecPlanFragmentResult> execRemoteFragmentAsync() throws TException, RpcException {
+            TNetworkAddress brpcAddress = null;
             try {
-                try {
-                    address = getBackendAddress();
-                    if (LOG.isDebugEnabled()) {
-                        LOG.debug("exec address={} fragmentInstanceId={} rpcParams={}", address,
-                                DebugUtil.printId(rpcParams.params.fragment_instance_id), rpcParams);
-                    }
-                    client = ClientPool.backendPool.borrowObject(address, execRemoteTimeoutMs);
-                    thriftResult = client.exec_plan_fragment(rpcParams);
-                    isReturnToPool = true;
-                } catch (TTransportException e) {
-                    LOG.warn("execRemoteFragment TTransporxception address={}", address, e);
-                    // retry
-                    if (client == null) {
-                        LOG.warn("may be connection refuse, try to retry from top");
-                        if (address != null) {
-                            SimpleScheduler.updateBlacklistBackends(
-                                    this.addressToBackendID.get(address));
-                        }
-                        throw e; // may be connection refuse, we may retry from top 3 retry.
-                    }
-                    boolean ok = ClientPool.backendPool.reopen(client,
-                            execRemoteTimeoutMs);
-                    if (!ok) {
-                        if (address != null) {
-                            SimpleScheduler.updateBlacklistBackends(
-                                    this.addressToBackendID.get(address));
-                        }
-                        LOG.warn("reopen rpc error address=" + address);
-                        throw e;
-                    }
-
-                    if (e.getType() == TTransportException.TIMED_OUT) {
-                        throw e;
-                    } else {
-                        thriftResult = client.exec_plan_fragment(rpcParams);
-                        isReturnToPool = true;
-                    }
-                }
-            } catch (org.apache.thrift.TApplicationException e) {
-                SimpleScheduler.updateBlacklistBackends(this.addressToBackendID.get(address));
-                LOG.warn("execRemoteFragment Exception ", e);
-                throw e;
+                brpcAddress = toBrpcHost(address);
             } catch (Exception e) {
-                LOG.warn("execRemoteFragment Exception " + DebugUtil.getStackTrace(e));
-                throw e;
-            } finally {
-                if (isReturnToPool) {
-                    ClientPool.backendPool.returnObject(address, client);
-                } else {
-                    ClientPool.backendPool.invalidateObject(address, client);
-                }
-            }
-            if (thriftResult != null) {
-                if (!thriftResult.getStatus().getStatus_code().equals(TStatusCode.OK)) {
-                    String errMsg = thriftResult.getStatus().getError_msgs().get(0);
-                    LOG.warn("exec_plan_fragment get wrong result, err_msg =" + errMsg);
-                    throw new Exception(errMsg);
-                }
+                throw new TException(e.getMessage());
             }
-
             initiated = true;
+            try {
+                return BackendServiceProxy.getInstance().execPlanFragmentAsync(brpcAddress, rpcParams);
+            } catch (RpcException e) {
+                SimpleScheduler.updateBlacklistBackends(systemBackendId);
+                throw e;
+            }
         }
     }
 
@@ -1636,62 +1539,4 @@ public PlanFragment fragment() {
         }
     }
 
-    private static class ParallelExecutor {
-        private static final ExecutorService EXECUTOR = Executors.newCachedThreadPool();
-
-        public static void exec(List<Coordinator.BackendExecState> args,
-                int beginPos,
-                int numArgs,
-                ExecStatus status)
-                throws InterruptedException, TException {
-            CountDownLatch latch = new CountDownLatch(numArgs);
-            for (int i = 0; i < numArgs; ++i) {
-                Runnable r = new RpcThread(args.get(beginPos + i), latch, status);
-                EXECUTOR.submit(r);
-            }
-            // timeOut cancel, no need to lock
-            // for after do exec, we can cancel and update
-            // thrift rpc default timeout is 5 secs.
-            // we make latch wait 10 secs(> 5 sec) to avoid false timeout
-            if (!latch.await(10, TimeUnit.SECONDS)) {
-                status.setErrCode(TStatusCode.TIMEOUT);
-            }
-        }
-
-        private static class RpcThread implements Runnable {
-            private Coordinator.BackendExecState parameter;
-            private CountDownLatch               latch;
-            private ExecStatus status;
-
-            public RpcThread(Coordinator.BackendExecState parameter, CountDownLatch latch,
-                    ExecStatus status) {
-                // store parameter for later user
-                this.parameter = parameter;
-                this.latch = latch;
-                // there is no need to lock needCanceled, because we only set needCanceled true
-                this.status = status;
-            }
-
-            public void run() {
-                try {
-                    parameter.execRemoteFragment();
-                } catch (TTransportException e) {
-                    if (e.getType() == TTransportException.TIMED_OUT) {
-                        status.setErrCode(TStatusCode.TIMEOUT);
-                        status.setErrAddress(parameter.getBackendAddress());
-                    } else {
-                        status.setErrCode(TStatusCode.THRIFT_RPC_ERROR);
-                        status.setErrAddress(parameter.getBackendAddress());
-                    }
-                    LOG.warn("ParallelExecutor get exception: {}", parameter.getBackendAddress(), e);
-                } catch (Exception e) {
-                    status.setErrCode(TStatusCode.INTERNAL_ERROR);
-                    status.setErrAddress(parameter.getBackendAddress());
-                    LOG.warn("ParallelExecutor get exception: {}", parameter.getBackendAddress(), e);
-                }
-                latch.countDown();
-            }
-        }
-    }
-
 }
diff --git a/fe/src/com/baidu/palo/qe/ResultReceiver.java b/fe/src/com/baidu/palo/qe/ResultReceiver.java
index 84bf64e40adcfe..640173997c1edc 100644
--- a/fe/src/com/baidu/palo/qe/ResultReceiver.java
+++ b/fe/src/com/baidu/palo/qe/ResultReceiver.java
@@ -13,127 +13,128 @@
 // specific language governing permissions and limitations
 // under the License.
 
-package com.baidu.palo.qe;
-
-import com.baidu.palo.common.ClientPool;
-import com.baidu.palo.common.InternalException;
-import com.baidu.palo.common.Status;
-import com.baidu.palo.thrift.BackendService;
-import com.baidu.palo.thrift.PaloInternalServiceVersion;
-import com.baidu.palo.thrift.TFetchDataParams;
-import com.baidu.palo.thrift.TFetchDataResult;
-import com.baidu.palo.thrift.TNetworkAddress;
-import com.baidu.palo.thrift.TPlanFragmentDestination;
-import com.baidu.palo.thrift.TResultBatch;
-import com.baidu.palo.thrift.TStatusCode;
-
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.LogManager;
-
-public class ResultReceiver {
-    private static final Logger LOG = LogManager.getLogger(ResultReceiver.class);
-    private boolean isDone    = false;
-    private boolean isCancel  = false;
-    private int     packetIdx = 0;
-    private int              timeoutMs;
-    private TNetworkAddress  rootFragmentAddress;
-    private TFetchDataResult thriftResult;
-    private TFetchDataParams thriftParams;
-    private Long backendID;
-
-    public ResultReceiver(TPlanFragmentDestination resultSource, 
-            Long backendID, int timeoutMs) {
-        this.timeoutMs = timeoutMs;
-        thriftParams = new TFetchDataParams();
-        thriftParams.setProtocol_version(PaloInternalServiceVersion.V1);
-        thriftParams.setFragment_instance_id(resultSource.fragment_instance_id);
-        rootFragmentAddress =
-                new TNetworkAddress(resultSource.server.hostname, resultSource.server.port);
-        this.backendID = backendID;
-    }
-
-    public TResultBatch getNext(Status status) {
-        if (isDone) {
-            return null;
-        }
-        
-        try {
-            while (!isDone && !isCancel) {
-                getNextFromRpc();
-                // check packet num
-                if (packetIdx != thriftResult.packet_num) {
-                    status.setStatus("receive packet failed, expect " + packetIdx 
-                            + " but recept is " + thriftResult.packet_num);
-                    return null;
-                }
-    
-                packetIdx++;
-                isDone = thriftResult.eos;
-                if (thriftResult.result_batch.rows.size() > 0) {
-                    return thriftResult.result_batch;
-                }
-            }
-        } catch (org.apache.thrift.transport.TTransportException e)  {
-            if (e.getType() == org.apache.thrift.transport.TTransportException.TIMED_OUT) {
-                // not set rpcError, for it dosn't retry
-                status.setStatus(e.getMessage());
-            } else {
-                status.setRpcStatus(e.getMessage());
-            }
-        } catch (Exception e) {
-            status.setStatus(e.getMessage());
-        }
-        
-        if (isCancel) {
-            status.setStatus(Status.CANCELLED);
-        }
-        return null;
-    }
-
-    public void cancel() {
-        isCancel = true;
-    }
-
-    void getNextFromRpc() throws Exception {
-        BackendService.Client client = null;
-        TNetworkAddress address = null;
-        boolean isReturnToPool = false;
-
-        try {
-            // there is no need to retry for read socket
-            address = new TNetworkAddress(rootFragmentAddress.hostname,
-                    rootFragmentAddress.port);
-            client = ClientPool.backendPool.borrowObject(address, timeoutMs);
-            thriftResult = client.fetch_data(thriftParams);
-            isReturnToPool = true;
-        } catch (org.apache.thrift.transport.TTransportException e) {
-            boolean ok = ClientPool.backendPool.reopen(client, timeoutMs);
-            if (!ok) {
-                String errMsg = "reopen rpc error, address=" + address;
-                LOG.warn(errMsg);
-                SimpleScheduler.updateBlacklistBackends(this.backendID);
-                throw new InternalException(errMsg);
-            }
-            if (e.getType() == org.apache.thrift.transport.TTransportException.TIMED_OUT) {
-                throw e;
-            } else {
-                thriftResult = client.fetch_data(thriftParams);
-                isReturnToPool = true;
-            }
-        } finally {
-            if (isReturnToPool) {
-                ClientPool.backendPool.returnObject(address, client);
-            } else {
-                ClientPool.backendPool.invalidateObject(address, client);
-            }
-        }
-        
-        if (thriftResult != null) {
-            if (!thriftResult.getStatus().getStatus_code().equals(TStatusCode.OK)) {
-                String errMsg = thriftResult.getStatus().getError_msgs().get(0);
-                LOG.warn("root fragment {} return error, errMsg = {}", address, errMsg);
-                throw new InternalException(errMsg);
-            }
-        }
-    }
-}
+package com.baidu.palo.qe;
+
+import com.baidu.palo.common.Status;
+import com.baidu.palo.rpc.BackendServiceProxy;
+import com.baidu.palo.rpc.PFetchDataRequest;
+import com.baidu.palo.rpc.PFetchDataResult;
+import com.baidu.palo.rpc.PUniqueId;
+import com.baidu.palo.rpc.RpcException;
+import com.baidu.palo.thrift.TNetworkAddress;
+import com.baidu.palo.thrift.TResultBatch;
+import com.baidu.palo.thrift.TStatusCode;
+import com.baidu.palo.thrift.TUniqueId;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.thrift.TDeserializer;
+import org.apache.thrift.TException;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+public class ResultReceiver {
+    private static final Logger LOG = LogManager.getLogger(ResultReceiver.class);
+    private boolean isDone    = false;
+    private boolean isCancel  = false;
+    private long packetIdx = 0;
+    private long timeoutTs = 0;
+    private TNetworkAddress address;
+    private PUniqueId finstId;
+    private Long backendId;
+    private Thread currentThread;
+
+    public ResultReceiver(TUniqueId tid, Long backendId, TNetworkAddress address, int timeoutMs) {
+        this.finstId = new PUniqueId(tid);
+        this.backendId = backendId;
+        this.address = address;
+        this.timeoutTs = System.currentTimeMillis() + timeoutMs;
+    }
+
+    public TResultBatch getNext(Status status) throws TException {
+        if (isDone) {
+            return null;
+        }
+
+        try {
+            while (!isDone && !isCancel) {
+                PFetchDataRequest request = new PFetchDataRequest(finstId);
+
+                currentThread = Thread.currentThread();
+                Future<PFetchDataResult> future = BackendServiceProxy.getInstance().fetchDataAsync(address, request);
+                PFetchDataResult pResult = null;
+                while (pResult == null) {
+                    long currentTs = System.currentTimeMillis();
+                    if (currentTs >= timeoutTs) {
+                        throw new TimeoutException("query timeout");
+                    }
+                    try {
+                        pResult = future.get(timeoutTs - currentTs, TimeUnit.MILLISECONDS);
+                    } catch (InterruptedException e) {
+                        // continue to get result
+                        LOG.info("future get interrupted Exception");
+                        if (isCancel) {
+                            status.setStatus(Status.CANCELLED);
+                            return null;
+                        }
+                    }
+                }
+                TStatusCode code = TStatusCode.findByValue(pResult.status.code);
+                if (code != TStatusCode.OK) {
+                    status.setPstatus(pResult.status);
+                    return null;
+                }
+
+                if (packetIdx != pResult.packetSeq) {
+                    LOG.warn("receive packet failed, expect={}, receive={}", packetIdx, pResult.packetSeq);
+                    status.setRpcStatus("receive error packet");
+                    return null;
+                }
+
+                packetIdx++;
+                isDone = pResult.eos;
+
+                byte[] serialResult = request.getSerializedResult();
+                if (serialResult != null && serialResult.length > 0) {
+                    TResultBatch resultBatch = new TResultBatch();
+                    TDeserializer deserializer = new TDeserializer();
+                    deserializer.deserialize(resultBatch, serialResult);
+                    return resultBatch;
+                }
+            }
+        } catch (RpcException e) {
+            LOG.warn("fetch result rpc exception, finstId={}", finstId, e);
+            status.setRpcStatus(e.getMessage());
+            SimpleScheduler.updateBlacklistBackends(backendId);
+        } catch (ExecutionException e) {
+            LOG.warn("fetch result execution exception, finstId={}", finstId, e);
+            status.setRpcStatus(e.getMessage());
+            SimpleScheduler.updateBlacklistBackends(backendId);
+        } catch (TimeoutException e) {
+            LOG.warn("fetch result timeout, finstId={}", finstId, e);
+            status.setStatus("query timeout");
+        } finally {
+            synchronized (this) {
+                currentThread = null;
+            }
+        }
+
+        if (isCancel) {
+            status.setStatus(Status.CANCELLED);
+        }
+        return null;
+    }
+
+    public void cancel() {
+        isCancel = true;
+        synchronized (this) {
+            if (currentThread != null) {
+                currentThread.interrupt();
+            }
+
+        }
+    }
+}
diff --git a/fe/src/com/baidu/palo/qe/SimpleScheduler.java b/fe/src/com/baidu/palo/qe/SimpleScheduler.java
index 37b96f517c46b2..33b758ad75e563 100644
--- a/fe/src/com/baidu/palo/qe/SimpleScheduler.java
+++ b/fe/src/com/baidu/palo/qe/SimpleScheduler.java
@@ -1,18 +1,18 @@
-// Copyright (c) 2017, Baidu.com, Inc. All Rights Reserved
-
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
+// Copyright (c) 2017, Baidu.com, Inc. All Rights Reserved
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
 package com.baidu.palo.qe;
 
 import com.baidu.palo.catalog.Catalog;
@@ -129,6 +129,9 @@ public static TNetworkAddress getHost(ImmutableMap<Long, Backend> backends,
     }
     
     public static void updateBlacklistBackends(Long backendID) {
+        if (backendID == null) {
+            return;
+        }
         lock.lock();
         try {
             int tryTime = FeConstants.heartbeat_interval_second + 1;
diff --git a/fe/src/com/baidu/palo/qe/StmtExecutor.java b/fe/src/com/baidu/palo/qe/StmtExecutor.java
index b8549910cd8832..8220f82fdd3cfd 100644
--- a/fe/src/com/baidu/palo/qe/StmtExecutor.java
+++ b/fe/src/com/baidu/palo/qe/StmtExecutor.java
@@ -55,6 +55,7 @@
 import com.baidu.palo.mysql.MysqlSerializer;
 import com.baidu.palo.planner.Planner;
 import com.baidu.palo.rewrite.ExprRewriter;
+import com.baidu.palo.rpc.RpcException;
 import com.baidu.palo.thrift.TExplainLevel;
 import com.baidu.palo.thrift.TQueryOptions;
 import com.baidu.palo.thrift.TResultBatch;
@@ -204,7 +205,7 @@ public void execute() throws Exception {
                             writeProfile(beginTimeInNanoSecond);
                         }
                         break;
-                    } catch (TTransportException e) {
+                    } catch (RpcException e) {
                         if (i == retryTime - 1) {
                             throw e;
                         }
@@ -396,9 +397,16 @@ private void analyze() throws AnalysisException, InternalException,
 
                         // Re-analyze the stmt with a new analyzer.
                         analyzer = new Analyzer(context.getCatalog(), context);
-                        parsedStmt.reset();
-                        parsedStmt.analyze(analyzer);
-
+                        // TODO chenhao16 , merge Impala
+                        // insert re-analyze
+                        if (originStmt != null) {
+                            originStmt.reset();
+                            originStmt.analyze(analyzer);
+                        } else {
+                            // query re-analyze
+                            parsedStmt.reset();
+                            parsedStmt.analyze(analyzer);
+                        }
                         // Restore the original result types and column labels.
                         queryStmt1.castResultExprs(origResultTypes);
                         queryStmt1.setColLabels(origColLabels);
diff --git a/fe/src/com/baidu/palo/rpc/AttachmentRequest.java b/fe/src/com/baidu/palo/rpc/AttachmentRequest.java
new file mode 100644
index 00000000000000..d97b1c0024f865
--- /dev/null
+++ b/fe/src/com/baidu/palo/rpc/AttachmentRequest.java
@@ -0,0 +1,48 @@
+// Copyright (c) 2017, Baidu.com, Inc. All Rights Reserved
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package com.baidu.palo.rpc;
+
+import org.apache.thrift.TBase;
+import org.apache.thrift.TDeserializer;
+import org.apache.thrift.TException;
+import org.apache.thrift.TSerializer;
+
+// used to compatible with older our thrift protocol
+public class AttachmentRequest {
+    protected byte[] serializedRequest;
+    protected byte[] serializedResult;
+
+    public void setRequest(TBase request) throws TException {
+        TSerializer serializer = new TSerializer();
+        serializedRequest = serializer.serialize(request);
+    }
+    public void setSerializedRequest(byte[] request) {
+        this.serializedRequest = request;
+    }
+    public byte[] getSerializedRequest() {
+        return serializedRequest;
+    }
+    public void setSerializedResult(byte[] result) {
+        this.serializedResult = result;
+    }
+    public byte[] getSerializedResult() {
+        return serializedResult;
+    }
+    public void getResult(TBase result) throws TException {
+        TDeserializer deserializer = new TDeserializer();
+        deserializer.deserialize(result, serializedResult);
+    }
+}
diff --git a/fe/src/com/baidu/palo/rpc/BackendServiceProxy.java b/fe/src/com/baidu/palo/rpc/BackendServiceProxy.java
new file mode 100644
index 00000000000000..c10ed78dc77c94
--- /dev/null
+++ b/fe/src/com/baidu/palo/rpc/BackendServiceProxy.java
@@ -0,0 +1,107 @@
+// Copyright (c) 2017, Baidu.com, Inc. All Rights Reserved
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package com.baidu.palo.rpc;
+
+import com.baidu.jprotobuf.pbrpc.client.ProtobufRpcProxy;
+import com.baidu.jprotobuf.pbrpc.transport.RpcClient;
+import com.baidu.jprotobuf.pbrpc.transport.RpcClientOptions;
+import com.baidu.palo.qe.SimpleScheduler;
+import com.baidu.palo.thrift.TExecPlanFragmentParams;
+import com.baidu.palo.thrift.TNetworkAddress;
+import com.baidu.palo.thrift.TUniqueId;
+
+import com.google.common.collect.Maps;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.thrift.TException;
+
+import java.util.Map;
+import java.util.concurrent.Future;
+
+public class BackendServiceProxy {
+    private static final Logger LOG = LogManager.getLogger(BackendServiceProxy.class);
+
+    private RpcClient rpcClient;
+    // TODO(zc): use TNetworkAddress,
+    private Map<TNetworkAddress, PInternalService> serviceMap;
+
+    private static BackendServiceProxy INSTANCE;
+
+    public BackendServiceProxy() {
+        rpcClient = new RpcClient(new RpcClientOptions());
+        serviceMap = Maps.newHashMap();
+    }
+
+    public static BackendServiceProxy getInstance() {
+        if (INSTANCE == null) {
+            INSTANCE = new BackendServiceProxy();
+        }
+        return INSTANCE;
+    }
+
+    private synchronized PInternalService getProxy(TNetworkAddress address) {
+        PInternalService service = serviceMap.get(address);
+        if (service != null) {
+            return service;
+        }
+        ProtobufRpcProxy<PInternalService> proxy = new ProtobufRpcProxy(rpcClient, PInternalService.class);
+        proxy.setHost(address.getHostname());
+        proxy.setPort(address.getPort());
+        service = proxy.proxy();
+        serviceMap.put(address, service);
+        return service;
+    }
+
+    public Future<PExecPlanFragmentResult> execPlanFragmentAsync(
+            TNetworkAddress address, TExecPlanFragmentParams tRequest)
+            throws TException, RpcException {
+        try {
+            PExecPlanFragmentRequest pRequest = new PExecPlanFragmentRequest();
+            pRequest.setRequest(tRequest);
+            PInternalService service = getProxy(address);
+            return service.execPlanFragmentAsync(pRequest);
+        } catch (Throwable e) {
+            LOG.warn("execute plan fragment catch a exception, address={}:{}",
+                    address.getHostname(), address.getPort(), e);
+            throw new RpcException(e.getMessage());
+        }
+    }
+
+    public Future<PCancelPlanFragmentResult> cancelPlanFragmentAsync(
+            TNetworkAddress address, TUniqueId finstId) throws RpcException {
+        try {
+            PCancelPlanFragmentRequest pRequest = new PCancelPlanFragmentRequest(new PUniqueId(finstId));
+            PInternalService service = getProxy(address);
+            return service.cancelPlanFragmentAsync(pRequest);
+        } catch (Throwable e) {
+            LOG.warn("cancel plan fragment catch a exception, address={}:{}",
+                    address.getHostname(), address.getPort(), e);
+            throw new RpcException(e.getMessage());
+        }
+    }
+
+    public Future<PFetchDataResult> fetchDataAsync(
+            TNetworkAddress address, PFetchDataRequest request) throws RpcException {
+        try {
+            PInternalService service = getProxy(address);
+            return service.fetchDataAsync(request);
+        } catch (Throwable e) {
+            LOG.warn("fetch data catch a exception, address={}:{}",
+                    address.getHostname(), address.getPort(), e);
+            throw new RpcException(e.getMessage());
+        }
+    }
+}
diff --git a/fe/src/com/baidu/palo/rpc/PCancelPlanFragmentRequest.java b/fe/src/com/baidu/palo/rpc/PCancelPlanFragmentRequest.java
new file mode 100644
index 00000000000000..d5d9d3aa133585
--- /dev/null
+++ b/fe/src/com/baidu/palo/rpc/PCancelPlanFragmentRequest.java
@@ -0,0 +1,30 @@
+// Copyright (c) 2017, Baidu.com, Inc. All Rights Reserved
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package com.baidu.palo.rpc;
+
+import com.baidu.bjf.remoting.protobuf.annotation.Protobuf;
+import com.baidu.bjf.remoting.protobuf.annotation.ProtobufClass;
+
+@ProtobufClass
+public class PCancelPlanFragmentRequest {
+    public PCancelPlanFragmentRequest() { }
+    public PCancelPlanFragmentRequest(PUniqueId finstId) {
+        this.finstId = finstId;
+    }
+
+    @Protobuf(order = 1, required = true)
+    public PUniqueId finstId;
+}
diff --git a/fe/src/com/baidu/palo/rpc/PCancelPlanFragmentResult.java b/fe/src/com/baidu/palo/rpc/PCancelPlanFragmentResult.java
new file mode 100644
index 00000000000000..60d509ca909d6d
--- /dev/null
+++ b/fe/src/com/baidu/palo/rpc/PCancelPlanFragmentResult.java
@@ -0,0 +1,25 @@
+// Copyright (c) 2017, Baidu.com, Inc. All Rights Reserved
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package com.baidu.palo.rpc;
+
+import com.baidu.bjf.remoting.protobuf.annotation.Protobuf;
+import com.baidu.bjf.remoting.protobuf.annotation.ProtobufClass;
+
+@ProtobufClass
+public class PCancelPlanFragmentResult {
+    @Protobuf(order = 1, required = true)
+    public PStatus status;
+}
diff --git a/fe/src/com/baidu/palo/rpc/PExecPlanFragmentRequest.java b/fe/src/com/baidu/palo/rpc/PExecPlanFragmentRequest.java
new file mode 100644
index 00000000000000..d69e09cdd56e1b
--- /dev/null
+++ b/fe/src/com/baidu/palo/rpc/PExecPlanFragmentRequest.java
@@ -0,0 +1,22 @@
+// Copyright (c) 2017, Baidu.com, Inc. All Rights Reserved
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package com.baidu.palo.rpc;
+
+import com.baidu.bjf.remoting.protobuf.annotation.ProtobufClass;
+
+@ProtobufClass
+public class PExecPlanFragmentRequest extends AttachmentRequest {
+}
diff --git a/fe/src/com/baidu/palo/rpc/PExecPlanFragmentResult.java b/fe/src/com/baidu/palo/rpc/PExecPlanFragmentResult.java
new file mode 100644
index 00000000000000..1b609228d86ce3
--- /dev/null
+++ b/fe/src/com/baidu/palo/rpc/PExecPlanFragmentResult.java
@@ -0,0 +1,25 @@
+// Copyright (c) 2017, Baidu.com, Inc. All Rights Reserved
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package com.baidu.palo.rpc;
+
+import com.baidu.bjf.remoting.protobuf.annotation.Protobuf;
+import com.baidu.bjf.remoting.protobuf.annotation.ProtobufClass;
+
+@ProtobufClass
+public class PExecPlanFragmentResult {
+    @Protobuf(order = 1, required = true)
+    public PStatus status;
+}
diff --git a/fe/src/com/baidu/palo/rpc/PFetchDataRequest.java b/fe/src/com/baidu/palo/rpc/PFetchDataRequest.java
new file mode 100644
index 00000000000000..f036a6f6d646ad
--- /dev/null
+++ b/fe/src/com/baidu/palo/rpc/PFetchDataRequest.java
@@ -0,0 +1,29 @@
+// Copyright (c) 2017, Baidu.com, Inc. All Rights Reserved
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package com.baidu.palo.rpc;
+
+import com.baidu.bjf.remoting.protobuf.annotation.Protobuf;
+import com.baidu.bjf.remoting.protobuf.annotation.ProtobufClass;
+
+@ProtobufClass
+public class PFetchDataRequest extends AttachmentRequest {
+    public PFetchDataRequest() {}
+    public PFetchDataRequest(PUniqueId finstId) {
+        this.finstId = finstId;
+    }
+    @Protobuf(order = 1, required = true)
+    public PUniqueId finstId;
+}
diff --git a/fe/src/com/baidu/palo/rpc/PFetchDataResult.java b/fe/src/com/baidu/palo/rpc/PFetchDataResult.java
new file mode 100644
index 00000000000000..78f4fbee6998b2
--- /dev/null
+++ b/fe/src/com/baidu/palo/rpc/PFetchDataResult.java
@@ -0,0 +1,29 @@
+// Copyright (c) 2017, Baidu.com, Inc. All Rights Reserved
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package com.baidu.palo.rpc;
+
+import com.baidu.bjf.remoting.protobuf.annotation.Protobuf;
+import com.baidu.bjf.remoting.protobuf.annotation.ProtobufClass;
+
+@ProtobufClass
+public class PFetchDataResult {
+    @Protobuf(order = 1, required = true)
+    public PStatus status;
+    @Protobuf(order = 2, required = false)
+    public long packetSeq;
+    @Protobuf(order = 3, required = false)
+    public boolean eos;
+}
diff --git a/fe/src/com/baidu/palo/rpc/PInternalService.java b/fe/src/com/baidu/palo/rpc/PInternalService.java
new file mode 100644
index 00000000000000..8e998cd1b4eb99
--- /dev/null
+++ b/fe/src/com/baidu/palo/rpc/PInternalService.java
@@ -0,0 +1,35 @@
+// Copyright (c) 2017, Baidu.com, Inc. All Rights Reserved
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package com.baidu.palo.rpc;
+
+import com.baidu.jprotobuf.pbrpc.ProtobufRPC;
+
+import java.util.concurrent.Future;
+
+public interface PInternalService {
+    @ProtobufRPC(serviceName = "PInternalService", methodName = "exec_plan_fragment",
+            attachmentHandler = ThriftClientAttachmentHandler.class, onceTalkTimeout = 2000)
+    Future<PExecPlanFragmentResult> execPlanFragmentAsync(PExecPlanFragmentRequest request);
+
+    @ProtobufRPC(serviceName = "PInternalService", methodName = "cancel_plan_fragment",
+            onceTalkTimeout = 1000)
+    Future<PCancelPlanFragmentResult> cancelPlanFragmentAsync(PCancelPlanFragmentRequest request);
+
+    // we set timeout to 1 day, because now there is no way to give different timeout for each RPC call
+    @ProtobufRPC(serviceName = "PInternalService", methodName = "fetch_data",
+            attachmentHandler = ThriftClientAttachmentHandler.class, onceTalkTimeout = 86400000)
+    Future<PFetchDataResult> fetchDataAsync(PFetchDataRequest request);
+}
diff --git a/fe/src/com/baidu/palo/rpc/PStatus.java b/fe/src/com/baidu/palo/rpc/PStatus.java
new file mode 100644
index 00000000000000..4b55b71ba72637
--- /dev/null
+++ b/fe/src/com/baidu/palo/rpc/PStatus.java
@@ -0,0 +1,29 @@
+// Copyright (c) 2017, Baidu.com, Inc. All Rights Reserved
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package com.baidu.palo.rpc;
+
+import com.baidu.bjf.remoting.protobuf.annotation.Protobuf;
+import com.baidu.bjf.remoting.protobuf.annotation.ProtobufClass;
+
+import java.util.List;
+
+@ProtobufClass
+public class PStatus {
+    @Protobuf(order = 1, required = true)
+    public int code;
+    @Protobuf(order = 2)
+    public List<String> msgs;
+}
diff --git a/fe/src/com/baidu/palo/rpc/PUniqueId.java b/fe/src/com/baidu/palo/rpc/PUniqueId.java
new file mode 100644
index 00000000000000..c63686cde9ea04
--- /dev/null
+++ b/fe/src/com/baidu/palo/rpc/PUniqueId.java
@@ -0,0 +1,34 @@
+// Copyright (c) 2017, Baidu.com, Inc. All Rights Reserved
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package com.baidu.palo.rpc;
+
+import com.baidu.bjf.remoting.protobuf.annotation.Protobuf;
+import com.baidu.bjf.remoting.protobuf.annotation.ProtobufClass;
+import com.baidu.palo.thrift.TUniqueId;
+
+@ProtobufClass
+public class PUniqueId {
+    public PUniqueId() {}
+    public PUniqueId(TUniqueId tid) {
+        hi = tid.getHi();
+        lo = tid.getLo();
+    }
+
+    @Protobuf(order = 1, required = true)
+    public long hi;
+    @Protobuf(order = 2, required = true)
+    public long lo;
+}
diff --git a/fe/src/com/baidu/palo/rpc/RpcException.java b/fe/src/com/baidu/palo/rpc/RpcException.java
new file mode 100644
index 00000000000000..beeee26b872ab1
--- /dev/null
+++ b/fe/src/com/baidu/palo/rpc/RpcException.java
@@ -0,0 +1,37 @@
+// Copyright (c) 2017, Baidu.com, Inc. All Rights Reserved
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package com.baidu.palo.rpc;
+
+public class RpcException extends Exception {
+    public RpcException() {
+    }
+
+    public RpcException(String message) {
+        super(message);
+    }
+
+    public RpcException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public RpcException(Throwable cause) {
+        super(cause);
+    }
+
+    public RpcException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
+        super(message, cause, enableSuppression, writableStackTrace);
+    }
+}
diff --git a/fe/src/com/baidu/palo/rpc/ThriftClientAttachmentHandler.java b/fe/src/com/baidu/palo/rpc/ThriftClientAttachmentHandler.java
new file mode 100644
index 00000000000000..c3264695d90b7e
--- /dev/null
+++ b/fe/src/com/baidu/palo/rpc/ThriftClientAttachmentHandler.java
@@ -0,0 +1,31 @@
+// Copyright (c) 2017, Baidu.com, Inc. All Rights Reserved
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package com.baidu.palo.rpc;
+
+import com.baidu.jprotobuf.pbrpc.ClientAttachmentHandler;
+
+public class ThriftClientAttachmentHandler implements ClientAttachmentHandler {
+    @Override
+    public byte[] handleRequest(String serviceName, String methodName, Object... objects) {
+        AttachmentRequest request = (AttachmentRequest) objects[0];
+        return request.getSerializedRequest();
+    }
+    @Override
+    public void handleResponse(byte[] bytes, String serviceName, String methodName, Object... objects) {
+        AttachmentRequest result = (AttachmentRequest) objects[0];
+        result.setSerializedResult(bytes);
+    }
+}
diff --git a/fe/test/com/baidu/palo/qe/CoordinatorTest.java b/fe/test/com/baidu/palo/qe/CoordinatorTest.java
index 5fd78385d21e98..01c0695299e681 100644
--- a/fe/test/com/baidu/palo/qe/CoordinatorTest.java
+++ b/fe/test/com/baidu/palo/qe/CoordinatorTest.java
@@ -18,8 +18,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
-package com.baidu.palo.qe;
-
+package com.baidu.palo.qe;
+
 import com.baidu.palo.analysis.Analyzer;
 import com.baidu.palo.analysis.TupleDescriptor;
 import com.baidu.palo.analysis.TupleId;
@@ -63,341 +63,341 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.ConcurrentMap;
-
-@RunWith(PowerMockRunner.class)
-@PowerMockIgnore({"org.apache.log4j.*", "javax.management.*"})
-@PrepareForTest(Catalog.class)
-public class CoordinatorTest extends Coordinator {
-    static Planner planner = new Planner();
-    static ConnectContext context = new ConnectContext(null);
-    static Catalog catalog;
-    static EditLog editLog;
-    static Analyzer analyzer = new Analyzer(catalog, null);
-    static Backend backendA;
-    static Backend backendB;
-    static Backend backendC;
-    static Backend backendD;
-
-    public CoordinatorTest() {
-        super(context, analyzer, planner);
-    }
-
-    private static Coordinator coor;
-
-    @BeforeClass
-    public static void beforeTest() throws IllegalAccessException, IllegalArgumentException,
-            InvocationTargetException, NoSuchFieldException,
-            SecurityException, NoSuchMethodException {
-        coor = new Coordinator(context, analyzer, planner);
-
-        editLog = EasyMock.createMock(EditLog.class);
-        editLog.logAddBackend(EasyMock.anyObject(Backend.class));
-        EasyMock.expectLastCall().anyTimes();
-        editLog.logDropBackend(EasyMock.anyObject(Backend.class));
-        EasyMock.expectLastCall().anyTimes();
-        editLog.logBackendStateChange(EasyMock.anyObject(Backend.class));
-        EasyMock.expectLastCall().anyTimes();
-        EasyMock.replay(editLog);
-
-        catalog = EasyMock.createMock(Catalog.class);
-        EasyMock.expect(catalog.getEditLog()).andReturn(editLog).anyTimes();
-        EasyMock.replay(catalog);
-
-        PowerMock.mockStatic(Catalog.class);
-        EasyMock.expect(Catalog.getInstance()).andReturn(catalog).anyTimes();
-        PowerMock.replay(Catalog.class);
-
-        FeConstants.heartbeat_interval_second = Integer.MAX_VALUE;
-        backendA = new Backend(0, "machineA", 0);
-        backendA.updateOnce(10000, 0, 0);
-        backendB = new Backend(1, "machineB", 0);
-        backendB.updateOnce(10000, 0, 0);
-        backendC = new Backend(2, "machineC", 0);
-        backendC.updateOnce(10000, 0, 0);
-        backendD = new Backend(3, "machineD", 0);
-        backendD.updateOnce(10000, 0, 0);
-
-        // private 方法赋值
-        Field field = coor.getClass().getDeclaredField("idToBackend");
-        field.setAccessible(true);
-        Map<Long, Backend> backendMap = new HashMap<Long, Backend>();
-        backendMap.put(Long.valueOf(0), backendA);
-        backendMap.put(Long.valueOf(1), backendB);
-        ImmutableMap<Long, Backend> idToBackendAB = ImmutableMap.copyOf(backendMap);
-        field.set(coor, idToBackendAB);
-    }
-
-    static void invokeFunction(String functionName) throws IllegalAccessException,
-            IllegalArgumentException, InvocationTargetException, NoSuchFieldException,
-            SecurityException, NoSuchMethodException {
-        Method method = coor.getClass().getDeclaredMethod(functionName);
-        method.setAccessible(true);
-        method.invoke(coor);
-    }
-
-    static Object getField(Object object, String fieldName) throws NoSuchFieldException,
-            SecurityException, IllegalArgumentException, IllegalAccessException {
-        Field field = object.getClass().getDeclaredField(fieldName);
-        field.setAccessible(true);
-        Object after = field.get(object);
-        return after;
-    }
-
-    /*
-     * 场景1：扫描2个scanRange，每个scanRange都分布在两台机器上（MachineA，machineB）
-     * 返回结果： 根据调度策略，machineA和machineB各扫描1个scanRange
-     *
-     * 场景2：扫描3个scanRange，每个scanRange都分布在两台机器上（MachineA，machineB）
-     * 返回结果： 根据调度策略，machineA扫描2个scanRange，machineB扫描1个scanRange
-     *
-     * 场景3：扫描3个scanRange，每个scanRange分布在不同的两台机器上（分别分布在（MachineA，machineB），（MachineA，machineC）
-     *      （MachineC，machineB）上。
-     * 返回结果：根据调度策略，machineA，machineB，machineC分布扫描1个scanRange
-     */
-    // TODO(lingbin): PALO-2051.
-    // Comment out these code temporatily.
-    // @Test
-    public void testComputeScanRangeAssignment() throws IllegalAccessException,
-            IllegalArgumentException, InvocationTargetException, NoSuchFieldException,
-            SecurityException, NoSuchMethodException {
-        Method method = coor.getClass().getDeclaredMethod(
-                "computeScanRangeAssignment",
-                PlanNodeId.class,
-                List.class,
-                Coordinator.FragmentScanRangeAssignment.class);
-        method.setAccessible(true);
-        int planNodeId = 2;
-        // 输出参数
-        FragmentScanRangeAssignment assignment = coor.new FragmentScanRangeAssignment();
-        // 输入参数
-        List<TScanRangeLocations> locations = new ArrayList<TScanRangeLocations>();
-
-        TScanRangeLocations scanRangeLocationsA = new TScanRangeLocations();
-        List<TScanRangeLocation> listLocationsA = new ArrayList<TScanRangeLocation>();
-        listLocationsA.add((new TScanRangeLocation())
-                .setServer(new TNetworkAddress("machineA", 10000)).setBackend_id(0));
-        listLocationsA.add((new TScanRangeLocation())
-                .setServer(new TNetworkAddress("machineB", 10000)).setBackend_id(1));
-        scanRangeLocationsA.setLocations(listLocationsA).setScan_range(new TScanRange());
-
-        TScanRangeLocations scanRangeLocationsB = new TScanRangeLocations();
-        List<TScanRangeLocation> listLocationsB = new ArrayList<TScanRangeLocation>();
-        listLocationsB.add((new TScanRangeLocation())
-                .setServer(new TNetworkAddress("machineB", 10000)).setBackend_id(1));
-        listLocationsB.add((new TScanRangeLocation())
-                .setServer(new TNetworkAddress("machineC", 10000)).setBackend_id(2));
-        scanRangeLocationsB.setLocations(listLocationsB).setScan_range(new TScanRange());
-
-        TScanRangeLocations scanRangeLocationsC = new TScanRangeLocations();
-        List<TScanRangeLocation> listLocationsC = new ArrayList<TScanRangeLocation>();
-        listLocationsC.add((new TScanRangeLocation())
-                .setServer(new TNetworkAddress("machineC", 10000)).setBackend_id(2));
-        listLocationsC.add((new TScanRangeLocation())
-                .setServer(new TNetworkAddress("machineA", 10000)).setBackend_id(0));
-        scanRangeLocationsC.setLocations(listLocationsC).setScan_range(new TScanRange());
-
-        // 场景1： 2个scanRange
-        {
-            assignment.clear();
-            locations.clear();
-            locations.add(scanRangeLocationsA);
-            locations.add(scanRangeLocationsA);
-            // 调用函数
-            method.invoke(
-                    coor,
-                    new PlanNodeId(planNodeId),
-                    locations,
-                    assignment);
-            // 判断返回值
-            Assert.assertEquals(assignment.get(new TNetworkAddress("machineA", 10000))
-                    .get(planNodeId).size(), 1);
-            Assert.assertEquals(assignment.get(new TNetworkAddress("machineB", 10000))
-                    .get(planNodeId).size(), 1);
-        }
-        // 场景2： 3个scanRange，每个scan_range都分布在两台机器上（A和B）
-        {
-            assignment.clear();
-            locations.clear();
-            locations.add(scanRangeLocationsA);
-            locations.add(scanRangeLocationsA);
-            locations.add(scanRangeLocationsA);
-
-            // 调用函数
-            method.invoke(
-                    coor,
-                    new PlanNodeId(planNodeId),
-                    locations,
-                    assignment);
-            // 判断返回值
-            Assert.assertEquals(assignment.get(new TNetworkAddress("machineA", 10000))
-                    .get(planNodeId).size(), 2);
-            Assert.assertEquals(assignment.get(new TNetworkAddress("machineB", 10000))
-                    .get(planNodeId).size(), 1);
-        }
-        // 场景3： 3个scanRange，scan_range分别分布在（A，B）（A，C）（C,B）上
-        {
-            Field field = coor.getClass().getDeclaredField("idToBackend");
-            field.setAccessible(true);
-            Map<Long, Backend> backendMap = new HashMap<Long, Backend>();
-            backendMap.put(Long.valueOf(0), backendA);
-            backendMap.put(Long.valueOf(1), backendB);
-            backendMap.put(Long.valueOf(2), backendC);
-            ImmutableMap<Long, Backend> idToBackendAB = ImmutableMap.copyOf(backendMap);
-            field.set(coor, idToBackendAB);
-
-            assignment.clear();
-            locations.clear();
-            locations.add(scanRangeLocationsA);
-            locations.add(scanRangeLocationsB);
-            locations.add(scanRangeLocationsC);
-            // 调用函数
-            method.invoke(
-                    coor,
-                    new PlanNodeId(planNodeId),
-                    locations,
-                    assignment);
-            // 判断返回值
-            Assert.assertEquals(assignment.get(new TNetworkAddress("machineA", 10000))
-                    .get(planNodeId).size(), 1);
-            Assert.assertEquals(assignment.get(new TNetworkAddress("machineB", 10000))
-                    .get(planNodeId).size(), 1);
-            Assert.assertEquals(assignment.get(new TNetworkAddress("machineC", 10000))
-                    .get(planNodeId).size(), 1);
-        }
-    }
-    /*
-     * 场景1：扫描UNPARTITIONED的fragment
-     * 返回结果： fragment执行参数的host列表为随机分配fragment
-     *
-     * 场景2：fragment的最左节点为ScanNode
-     * 返回结果：fragment执行参数的host列表为ScanNode的host列表
-     *
-     * 场景3：fragment的最左节点为非ScanNode
-     * 返回结果：fragment执行参数的host列表为来源fragment的执行参数的host列表
-     */
-    // TODO(lingbin): PALO-2051.
-    // Comment out these code temporatily.
-    // @Test
-    public void testcomputeFragmentHosts() throws NoSuchMethodException, SecurityException,
-            IllegalAccessException, IllegalArgumentException,
-            InvocationTargetException, NoSuchFieldException {
-        Method method = coor.getClass().getDeclaredMethod(
-                "computeFragmentHosts");
-        method.setAccessible(true);
-        // 场景1：UNPARTITIONED
-        {
-            PlanFragment fragment = new PlanFragment(new PlanFragmentId(1),
-                    new OlapScanNode(new PlanNodeId(1), new TupleDescriptor(new TupleId(10)), "null scanNode"),
-                    DataPartition.UNPARTITIONED );
-            List<PlanFragment> privateFragments =
-                    (ArrayList<PlanFragment>) getField(coor, "fragments");
-            Map<PlanFragmentId, FragmentExecParams> privateFragmentExecParams =
-                    (HashMap<PlanFragmentId, FragmentExecParams>) getField(
-                            coor, "fragmentExecParams");
-            privateFragments.clear();
-            privateFragments.add(fragment);
-            privateFragmentExecParams.put(new PlanFragmentId(1), new FragmentExecParams(fragment));
-
-            // 调用函数
-            method.invoke(coor);
-            // 判断返回值
+import java.util.concurrent.ConcurrentMap;
+
+@RunWith(PowerMockRunner.class)
+@PowerMockIgnore({"org.apache.log4j.*", "javax.management.*"})
+@PrepareForTest(Catalog.class)
+public class CoordinatorTest extends Coordinator {
+    static Planner planner = new Planner();
+    static ConnectContext context = new ConnectContext(null);
+    static Catalog catalog;
+    static EditLog editLog;
+    static Analyzer analyzer = new Analyzer(catalog, null);
+    static Backend backendA;
+    static Backend backendB;
+    static Backend backendC;
+    static Backend backendD;
+
+    public CoordinatorTest() {
+        super(context, analyzer, planner);
+    }
+
+    private static Coordinator coor;
+
+    @BeforeClass
+    public static void beforeTest() throws IllegalAccessException, IllegalArgumentException,
+            InvocationTargetException, NoSuchFieldException,
+            SecurityException, NoSuchMethodException {
+        coor = new Coordinator(context, analyzer, planner);
+
+        editLog = EasyMock.createMock(EditLog.class);
+        editLog.logAddBackend(EasyMock.anyObject(Backend.class));
+        EasyMock.expectLastCall().anyTimes();
+        editLog.logDropBackend(EasyMock.anyObject(Backend.class));
+        EasyMock.expectLastCall().anyTimes();
+        editLog.logBackendStateChange(EasyMock.anyObject(Backend.class));
+        EasyMock.expectLastCall().anyTimes();
+        EasyMock.replay(editLog);
+
+        catalog = EasyMock.createMock(Catalog.class);
+        EasyMock.expect(catalog.getEditLog()).andReturn(editLog).anyTimes();
+        EasyMock.replay(catalog);
+
+        PowerMock.mockStatic(Catalog.class);
+        EasyMock.expect(Catalog.getInstance()).andReturn(catalog).anyTimes();
+        PowerMock.replay(Catalog.class);
+
+        FeConstants.heartbeat_interval_second = Integer.MAX_VALUE;
+        backendA = new Backend(0, "machineA", 0);
+        backendA.updateOnce(10000, 0, 0);
+        backendB = new Backend(1, "machineB", 0);
+        backendB.updateOnce(10000, 0, 0);
+        backendC = new Backend(2, "machineC", 0);
+        backendC.updateOnce(10000, 0, 0);
+        backendD = new Backend(3, "machineD", 0);
+        backendD.updateOnce(10000, 0, 0);
+
+        // private 方法赋值
+        Field field = coor.getClass().getDeclaredField("idToBackend");
+        field.setAccessible(true);
+        Map<Long, Backend> backendMap = new HashMap<Long, Backend>();
+        backendMap.put(Long.valueOf(0), backendA);
+        backendMap.put(Long.valueOf(1), backendB);
+        ImmutableMap<Long, Backend> idToBackendAB = ImmutableMap.copyOf(backendMap);
+        field.set(coor, idToBackendAB);
+    }
+
+    static void invokeFunction(String functionName) throws IllegalAccessException,
+            IllegalArgumentException, InvocationTargetException, NoSuchFieldException,
+            SecurityException, NoSuchMethodException {
+        Method method = coor.getClass().getDeclaredMethod(functionName);
+        method.setAccessible(true);
+        method.invoke(coor);
+    }
+
+    static Object getField(Object object, String fieldName) throws NoSuchFieldException,
+            SecurityException, IllegalArgumentException, IllegalAccessException {
+        Field field = object.getClass().getDeclaredField(fieldName);
+        field.setAccessible(true);
+        Object after = field.get(object);
+        return after;
+    }
+
+    /*
+     * 场景1：扫描2个scanRange，每个scanRange都分布在两台机器上（MachineA，machineB）
+     * 返回结果： 根据调度策略，machineA和machineB各扫描1个scanRange
+     *
+     * 场景2：扫描3个scanRange，每个scanRange都分布在两台机器上（MachineA，machineB）
+     * 返回结果： 根据调度策略，machineA扫描2个scanRange，machineB扫描1个scanRange
+     *
+     * 场景3：扫描3个scanRange，每个scanRange分布在不同的两台机器上（分别分布在（MachineA，machineB），（MachineA，machineC）
+     *      （MachineC，machineB）上。
+     * 返回结果：根据调度策略，machineA，machineB，machineC分布扫描1个scanRange
+     */
+    // TODO(lingbin): PALO-2051.
+    // Comment out these code temporatily.
+    // @Test
+    public void testComputeScanRangeAssignment() throws IllegalAccessException,
+            IllegalArgumentException, InvocationTargetException, NoSuchFieldException,
+            SecurityException, NoSuchMethodException {
+        Method method = coor.getClass().getDeclaredMethod(
+                "computeScanRangeAssignment",
+                PlanNodeId.class,
+                List.class,
+                Coordinator.FragmentScanRangeAssignment.class);
+        method.setAccessible(true);
+        int planNodeId = 2;
+        // 输出参数
+        FragmentScanRangeAssignment assignment = coor.new FragmentScanRangeAssignment();
+        // 输入参数
+        List<TScanRangeLocations> locations = new ArrayList<TScanRangeLocations>();
+
+        TScanRangeLocations scanRangeLocationsA = new TScanRangeLocations();
+        List<TScanRangeLocation> listLocationsA = new ArrayList<TScanRangeLocation>();
+        listLocationsA.add((new TScanRangeLocation())
+                .setServer(new TNetworkAddress("machineA", 10000)).setBackend_id(0));
+        listLocationsA.add((new TScanRangeLocation())
+                .setServer(new TNetworkAddress("machineB", 10000)).setBackend_id(1));
+        scanRangeLocationsA.setLocations(listLocationsA).setScan_range(new TScanRange());
+
+        TScanRangeLocations scanRangeLocationsB = new TScanRangeLocations();
+        List<TScanRangeLocation> listLocationsB = new ArrayList<TScanRangeLocation>();
+        listLocationsB.add((new TScanRangeLocation())
+                .setServer(new TNetworkAddress("machineB", 10000)).setBackend_id(1));
+        listLocationsB.add((new TScanRangeLocation())
+                .setServer(new TNetworkAddress("machineC", 10000)).setBackend_id(2));
+        scanRangeLocationsB.setLocations(listLocationsB).setScan_range(new TScanRange());
+
+        TScanRangeLocations scanRangeLocationsC = new TScanRangeLocations();
+        List<TScanRangeLocation> listLocationsC = new ArrayList<TScanRangeLocation>();
+        listLocationsC.add((new TScanRangeLocation())
+                .setServer(new TNetworkAddress("machineC", 10000)).setBackend_id(2));
+        listLocationsC.add((new TScanRangeLocation())
+                .setServer(new TNetworkAddress("machineA", 10000)).setBackend_id(0));
+        scanRangeLocationsC.setLocations(listLocationsC).setScan_range(new TScanRange());
+
+        // 场景1： 2个scanRange
+        {
+            assignment.clear();
+            locations.clear();
+            locations.add(scanRangeLocationsA);
+            locations.add(scanRangeLocationsA);
+            // 调用函数
+            method.invoke(
+                    coor,
+                    new PlanNodeId(planNodeId),
+                    locations,
+                    assignment);
+            // 判断返回值
+            Assert.assertEquals(assignment.get(new TNetworkAddress("machineA", 10000))
+                    .get(planNodeId).size(), 1);
+            Assert.assertEquals(assignment.get(new TNetworkAddress("machineB", 10000))
+                    .get(planNodeId).size(), 1);
+        }
+        // 场景2： 3个scanRange，每个scan_range都分布在两台机器上（A和B）
+        {
+            assignment.clear();
+            locations.clear();
+            locations.add(scanRangeLocationsA);
+            locations.add(scanRangeLocationsA);
+            locations.add(scanRangeLocationsA);
+
+            // 调用函数
+            method.invoke(
+                    coor,
+                    new PlanNodeId(planNodeId),
+                    locations,
+                    assignment);
+            // 判断返回值
+            Assert.assertEquals(assignment.get(new TNetworkAddress("machineA", 10000))
+                    .get(planNodeId).size(), 2);
+            Assert.assertEquals(assignment.get(new TNetworkAddress("machineB", 10000))
+                    .get(planNodeId).size(), 1);
+        }
+        // 场景3： 3个scanRange，scan_range分别分布在（A，B）（A，C）（C,B）上
+        {
+            Field field = coor.getClass().getDeclaredField("idToBackend");
+            field.setAccessible(true);
+            Map<Long, Backend> backendMap = new HashMap<Long, Backend>();
+            backendMap.put(Long.valueOf(0), backendA);
+            backendMap.put(Long.valueOf(1), backendB);
+            backendMap.put(Long.valueOf(2), backendC);
+            ImmutableMap<Long, Backend> idToBackendAB = ImmutableMap.copyOf(backendMap);
+            field.set(coor, idToBackendAB);
+
+            assignment.clear();
+            locations.clear();
+            locations.add(scanRangeLocationsA);
+            locations.add(scanRangeLocationsB);
+            locations.add(scanRangeLocationsC);
+            // 调用函数
+            method.invoke(
+                    coor,
+                    new PlanNodeId(planNodeId),
+                    locations,
+                    assignment);
+            // 判断返回值
+            Assert.assertEquals(assignment.get(new TNetworkAddress("machineA", 10000))
+                    .get(planNodeId).size(), 1);
+            Assert.assertEquals(assignment.get(new TNetworkAddress("machineB", 10000))
+                    .get(planNodeId).size(), 1);
+            Assert.assertEquals(assignment.get(new TNetworkAddress("machineC", 10000))
+                    .get(planNodeId).size(), 1);
+        }
+    }
+    /*
+     * 场景1：扫描UNPARTITIONED的fragment
+     * 返回结果： fragment执行参数的host列表为随机分配fragment
+     *
+     * 场景2：fragment的最左节点为ScanNode
+     * 返回结果：fragment执行参数的host列表为ScanNode的host列表
+     *
+     * 场景3：fragment的最左节点为非ScanNode
+     * 返回结果：fragment执行参数的host列表为来源fragment的执行参数的host列表
+     */
+    // TODO(lingbin): PALO-2051.
+    // Comment out these code temporatily.
+    // @Test
+    public void testcomputeFragmentHosts() throws NoSuchMethodException, SecurityException,
+            IllegalAccessException, IllegalArgumentException,
+            InvocationTargetException, NoSuchFieldException {
+        Method method = coor.getClass().getDeclaredMethod(
+                "computeFragmentHosts");
+        method.setAccessible(true);
+        // 场景1：UNPARTITIONED
+        {
+            PlanFragment fragment = new PlanFragment(new PlanFragmentId(1),
+                    new OlapScanNode(new PlanNodeId(1), new TupleDescriptor(new TupleId(10)), "null scanNode"),
+                    DataPartition.UNPARTITIONED );
+            List<PlanFragment> privateFragments =
+                    (ArrayList<PlanFragment>) getField(coor, "fragments");
+            Map<PlanFragmentId, FragmentExecParams> privateFragmentExecParams =
+                    (HashMap<PlanFragmentId, FragmentExecParams>) getField(
+                            coor, "fragmentExecParams");
+            privateFragments.clear();
+            privateFragments.add(fragment);
+            privateFragmentExecParams.put(new PlanFragmentId(1), new FragmentExecParams(fragment));
+
+            // 调用函数
+            method.invoke(coor);
+            // 判断返回值
             // Assert.assertEquals(privateFragmentExecParams.get(new PlanFragmentId(1))
             // .hosts.get(0).hostname, "machineA");
             // Assert.assertEquals(privateFragmentExecParams.get(new PlanFragmentId(1))
-            // .hosts.get(0).port, 10000);
-        }
-        // 场景2： ScanNode
-        {
-            PlanFragment fragment = new PlanFragment(new PlanFragmentId(1),
-                    new OlapScanNode(new PlanNodeId(1), new TupleDescriptor(new TupleId(10)), "null scanNode"),
-                    DataPartition.RANDOM );
-            List<PlanFragment> privateFragments =
-                    (ArrayList<PlanFragment>) getField(coor, "fragments");
-            Map<PlanFragmentId, FragmentExecParams> privateFragmentExecParams =
-                    (HashMap<PlanFragmentId, FragmentExecParams>) getField(
-                            coor, "fragmentExecParams");
-            Map<PlanFragmentId, FragmentScanRangeAssignment> privateScanRangeAssignment =
-                    (HashMap<PlanFragmentId, FragmentScanRangeAssignment>) getField(
-                            coor, "scanRangeAssignment");
-            FragmentScanRangeAssignment assignment = new FragmentScanRangeAssignment();
-            assignment.put(new TNetworkAddress("machineC", 10000), null);
-            assignment.put(new TNetworkAddress("machineD", 10000), null);
-
-            privateScanRangeAssignment.put(new PlanFragmentId(1), assignment);
-
-            privateFragments.clear();
-            privateFragments.add(fragment);
-            privateFragmentExecParams.put(new PlanFragmentId(1), new FragmentExecParams(fragment));
-
-            // 调用函数
-            method.invoke(coor);
-            // 判断返回值
+            // .hosts.get(0).port, 10000);
+        }
+        // 场景2： ScanNode
+        {
+            PlanFragment fragment = new PlanFragment(new PlanFragmentId(1),
+                    new OlapScanNode(new PlanNodeId(1), new TupleDescriptor(new TupleId(10)), "null scanNode"),
+                    DataPartition.RANDOM );
+            List<PlanFragment> privateFragments =
+                    (ArrayList<PlanFragment>) getField(coor, "fragments");
+            Map<PlanFragmentId, FragmentExecParams> privateFragmentExecParams =
+                    (HashMap<PlanFragmentId, FragmentExecParams>) getField(
+                            coor, "fragmentExecParams");
+            Map<PlanFragmentId, FragmentScanRangeAssignment> privateScanRangeAssignment =
+                    (HashMap<PlanFragmentId, FragmentScanRangeAssignment>) getField(
+                            coor, "scanRangeAssignment");
+            FragmentScanRangeAssignment assignment = new FragmentScanRangeAssignment();
+            assignment.put(new TNetworkAddress("machineC", 10000), null);
+            assignment.put(new TNetworkAddress("machineD", 10000), null);
+
+            privateScanRangeAssignment.put(new PlanFragmentId(1), assignment);
+
+            privateFragments.clear();
+            privateFragments.add(fragment);
+            privateFragmentExecParams.put(new PlanFragmentId(1), new FragmentExecParams(fragment));
+
+            // 调用函数
+            method.invoke(coor);
+            // 判断返回值
             // Assert.assertEquals(2, privateFragmentExecParams.get(new PlanFragmentId(1))
             // .hosts.size());
             // String hostname1 = privateFragmentExecParams.get(new PlanFragmentId(1))
             // .hosts.get(0).hostname;
             // String hostname2 = privateFragmentExecParams.get(new PlanFragmentId(1))
-            // .hosts.get(1).hostname;
+            // .hosts.get(1).hostname;
             // Assert.assertTrue(hostname1.equals("machineC") || hostname1.equals("machineD"));
             // Assert.assertTrue(hostname2.equals("machineC") || hostname1.equals("machineD"));
-            // Assert.assertFalse(hostname1.equals(hostname2));
-        }
-        // 场景3： 非ScanNode
-        {
-             /*     fragmentFather(UNPARITIONED) fragmentID=0
-              *     exchangeNode
-              *
-              *     fragmentSon(RANDOM) fragmentID=1
-              *     olapScannode
-              * */
-
-            Field field = coor.getClass().getDeclaredField("idToBackend");
-            field.setAccessible(true);
-            Map<Long, Backend> backendMap = new HashMap<Long, Backend>();
-            backendMap.put(Long.valueOf(0), backendA);
-            backendMap.put(Long.valueOf(1), backendB);
-            backendMap.put(Long.valueOf(2), backendC);
-            backendMap.put(Long.valueOf(3), backendD);
-            ImmutableMap<Long, Backend> idToBackendAB = ImmutableMap.copyOf(backendMap);
-            field.set(coor, idToBackendAB);
-
-            PlanNode olapNode = new OlapScanNode(new PlanNodeId(1), new TupleDescriptor(new TupleId(10)),
-                    "null scanNode");
-            PlanFragment fragmentFather = new PlanFragment(new PlanFragmentId(0),
-                    new ExchangeNode(new PlanNodeId(10), olapNode,  false),
-                    DataPartition.UNPARTITIONED);
-            PlanFragment fragmentSon = new PlanFragment(new PlanFragmentId(1),
-                    olapNode,
-                    DataPartition.RANDOM );
-            // fragmentSon.setDestination(fragmentFather, new PlanNodeId(10));
-
-            List<PlanFragment> privateFragments = (ArrayList<PlanFragment>) getField(
-                    coor, "fragments");
-            Map<PlanFragmentId, FragmentExecParams> privateFragmentExecParams =
-                    (HashMap<PlanFragmentId, FragmentExecParams>) getField(
-                            coor, "fragmentExecParams");
-            Map<PlanFragmentId, FragmentScanRangeAssignment> privateScanRangeAssignment =
-                    (HashMap<PlanFragmentId, FragmentScanRangeAssignment>) getField(
-                            coor, "scanRangeAssignment");
-
-            FragmentScanRangeAssignment assignment = new FragmentScanRangeAssignment();
-            assignment.put(new TNetworkAddress("machineC", 10000), null);
-            assignment.put(new TNetworkAddress("machineD", 10000), null);
-            privateScanRangeAssignment.put(new PlanFragmentId(1), assignment);
-
-            privateFragments.clear();
-            privateFragments.add(fragmentFather);
-            privateFragments.add(fragmentSon);
-
-            privateFragmentExecParams.put(new PlanFragmentId(1),
-                    new FragmentExecParams(fragmentSon));
-            privateFragmentExecParams.put(new PlanFragmentId(0),
-                    new FragmentExecParams(fragmentFather));
-
-            // 调用函数
-            method.invoke(coor);
-            // 判断返回值
+            // Assert.assertFalse(hostname1.equals(hostname2));
+        }
+        // 场景3： 非ScanNode
+        {
+             /*     fragmentFather(UNPARITIONED) fragmentID=0
+              *     exchangeNode
+              *
+              *     fragmentSon(RANDOM) fragmentID=1
+              *     olapScannode
+              * */
+
+            Field field = coor.getClass().getDeclaredField("idToBackend");
+            field.setAccessible(true);
+            Map<Long, Backend> backendMap = new HashMap<Long, Backend>();
+            backendMap.put(Long.valueOf(0), backendA);
+            backendMap.put(Long.valueOf(1), backendB);
+            backendMap.put(Long.valueOf(2), backendC);
+            backendMap.put(Long.valueOf(3), backendD);
+            ImmutableMap<Long, Backend> idToBackendAB = ImmutableMap.copyOf(backendMap);
+            field.set(coor, idToBackendAB);
+
+            PlanNode olapNode = new OlapScanNode(new PlanNodeId(1), new TupleDescriptor(new TupleId(10)),
+                    "null scanNode");
+            PlanFragment fragmentFather = new PlanFragment(new PlanFragmentId(0),
+                    new ExchangeNode(new PlanNodeId(10), olapNode,  false),
+                    DataPartition.UNPARTITIONED);
+            PlanFragment fragmentSon = new PlanFragment(new PlanFragmentId(1),
+                    olapNode,
+                    DataPartition.RANDOM );
+            // fragmentSon.setDestination(fragmentFather, new PlanNodeId(10));
+
+            List<PlanFragment> privateFragments = (ArrayList<PlanFragment>) getField(
+                    coor, "fragments");
+            Map<PlanFragmentId, FragmentExecParams> privateFragmentExecParams =
+                    (HashMap<PlanFragmentId, FragmentExecParams>) getField(
+                            coor, "fragmentExecParams");
+            Map<PlanFragmentId, FragmentScanRangeAssignment> privateScanRangeAssignment =
+                    (HashMap<PlanFragmentId, FragmentScanRangeAssignment>) getField(
+                            coor, "scanRangeAssignment");
+
+            FragmentScanRangeAssignment assignment = new FragmentScanRangeAssignment();
+            assignment.put(new TNetworkAddress("machineC", 10000), null);
+            assignment.put(new TNetworkAddress("machineD", 10000), null);
+            privateScanRangeAssignment.put(new PlanFragmentId(1), assignment);
+
+            privateFragments.clear();
+            privateFragments.add(fragmentFather);
+            privateFragments.add(fragmentSon);
+
+            privateFragmentExecParams.put(new PlanFragmentId(1),
+                    new FragmentExecParams(fragmentSon));
+            privateFragmentExecParams.put(new PlanFragmentId(0),
+                    new FragmentExecParams(fragmentFather));
+
+            // 调用函数
+            method.invoke(coor);
+            // 判断返回值
             // Assert.assertEquals(privateFragmentExecParams.get(new PlanFragmentId(0))
             // .hosts.get(0).hostname, "machineB");
             // Assert.assertEquals(privateFragmentExecParams.get(new PlanFragmentId(0))
@@ -410,44 +410,46 @@ public void testcomputeFragmentHosts() throws NoSuchMethodException, SecurityExc
             // .hosts.get(1).hostname;
             // Assert.assertTrue(hostname1.equals("machineC") || hostname1.equals("machineD"));
             // Assert.assertTrue(hostname2.equals("machineC") || hostname2.equals("machineD"));
-            // Assert.assertFalse(hostname1.equals(hostname2));
-        }
-    }
-
-    @Test
-    public void testNoUsedHosts() {
-    }
-
-    public void testNetworkException() throws TException, NoSuchFieldException,
-            SecurityException, IllegalArgumentException, IllegalAccessException,
-            NoSuchMethodException, InvocationTargetException {
-        Map<PlanFragmentId, FragmentExecParams> privateFragmentExecParams =
-                (HashMap<PlanFragmentId, FragmentExecParams>) getField(
-                        coor, "fragmentExecParams");
-        ConcurrentMap<TUniqueId, BackendExecState> privateBackendExecStateMap =
-                (ConcurrentMap<TUniqueId, BackendExecState>) getField(coor, "backendExecStateMap");
-        TQueryOptions privateQueryOptions = (TQueryOptions) getField(coor, "queryOptions");
-        // 设置超时时间为2s，尽快返回连接超时
-        privateQueryOptions.setQuery_timeout(2);
-        // Configure.qe_query_timeout_s  = 2;
-
-        privateFragmentExecParams.clear();
-        privateFragmentExecParams.put(new PlanFragmentId(23), new FragmentExecParams(null));
+            // Assert.assertFalse(hostname1.equals(hostname2));
+        }
+    }
+
+    @Test
+    public void testNoUsedHosts() {
+    }
+
+    /*
+    public void testNetworkException() throws TException, NoSuchFieldException,
+            SecurityException, IllegalArgumentException, IllegalAccessException,
+            NoSuchMethodException, InvocationTargetException {
+        Map<PlanFragmentId, FragmentExecParams> privateFragmentExecParams =
+                (HashMap<PlanFragmentId, FragmentExecParams>) getField(
+                        coor, "fragmentExecParams");
+        ConcurrentMap<TUniqueId, BackendExecState> privateBackendExecStateMap =
+                (ConcurrentMap<TUniqueId, BackendExecState>) getField(coor, "backendExecStateMap");
+        TQueryOptions privateQueryOptions = (TQueryOptions) getField(coor, "queryOptions");
+        // 设置超时时间为2s，尽快返回连接超时
+        privateQueryOptions.setQuery_timeout(2);
+        // Configure.qe_query_timeout_s  = 2;
+
+        privateFragmentExecParams.clear();
+        privateFragmentExecParams.put(new PlanFragmentId(23), new FragmentExecParams(null));
         // privateFragmentExecParams.get(new PlanFragmentId(23)).hosts.add(
-        // new TNetworkAddress("machine", 10000));
-        privateBackendExecStateMap.put(new TUniqueId(11, 12), coor.new BackendExecState(
-                new PlanFragmentId(23), 0, 0, new TExecPlanFragmentParams(),
-                new HashMap<TNetworkAddress, Long>()));
-        // 调用函数
-        boolean isException = false;
-        try {
-            privateBackendExecStateMap.get(new TUniqueId(11, 12)).execRemoteFragment();
-        } catch (org.apache.thrift.transport.TTransportException e) {
-            isException = true;
-        } catch (Exception e) {
-            isException = false;
-        }
-        Assert.assertTrue("need get the TTransportException", isException);
-    }
-}
-
+        // new TNetworkAddress("machine", 10000));
+        privateBackendExecStateMap.put(new TUniqueId(11, 12), coor.new BackendExecState(
+                new PlanFragmentId(23), 0, 0, new TExecPlanFragmentParams(),
+                new HashMap<TNetworkAddress, Long>()));
+        // 调用函数
+        boolean isException = false;
+        try {
+            privateBackendExecStateMap.get(new TUniqueId(11, 12)).execRemoteFragment();
+        } catch (org.apache.thrift.transport.TTransportException e) {
+            isException = true;
+        } catch (Exception e) {
+            isException = false;
+        }
+        Assert.assertTrue("need get the TTransportException", isException);
+    }
+    */
+}
+
diff --git a/fs_brokers/apache_hdfs_broker/src/com/baidu/palo/broker/hdfs/FileSystemManager.java b/fs_brokers/apache_hdfs_broker/src/com/baidu/palo/broker/hdfs/FileSystemManager.java
index 55ee4310c4d74d..089c417353c2a4 100644
--- a/fs_brokers/apache_hdfs_broker/src/com/baidu/palo/broker/hdfs/FileSystemManager.java
+++ b/fs_brokers/apache_hdfs_broker/src/com/baidu/palo/broker/hdfs/FileSystemManager.java
@@ -26,6 +26,7 @@
 import org.apache.hadoop.fs.FileSystem;
 import org.apache.hadoop.fs.Path;
 import org.apache.log4j.Logger;
+import com.google.common.base.Strings;
 
 import java.io.IOException;
 import java.net.URI;
@@ -48,6 +49,16 @@ public class FileSystemManager {
     private static final String HDFS_UGI_CONF = "hadoop.job.ugi";
     private static final String USER_NAME_KEY = "username";
     private static final String PASSWORD_KEY = "password";
+
+    // arguments for ha hdfs
+    private static final String DFS_NAMESERVICES_KEY = "dfs.nameservices";
+    private static final String DFS_HA_NAMENODES_PREFIX = "dfs.ha.namenodes.";
+    private static final String DFS_HA_NAMENODE_RPC_ADDRESS_PREFIX = "dfs.namenode.rpc-address.";
+    private static final String DFS_CLIENT_FAILOVER_PROXY_PROVIDER_PREFIX =
+            "dfs.client.failover.proxy.provider.";
+    private static final String DEFAULT_DFS_CLIENT_FAILOVER_PROXY_PROVIDER =
+            "org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider";
+    private static final String FS_DEFAULTFS_KEY = "fs.defaultFS";
     
     private ScheduledExecutorService handleManagementPool = Executors.newScheduledThreadPool(2);
     
@@ -85,8 +96,21 @@ public BrokerFileSystem getFileSystem(String path, Map<String, String> propertie
             throw new BrokerException(TBrokerOperationStatusCode.INVALID_INPUT_FILE_PATH, e);
         }
         String host = HDFS_SCHEME + pathUri.getAuthority();
+        if (Strings.isNullOrEmpty(pathUri.getAuthority())) {
+            if (properties.containsKey(FS_DEFAULTFS_KEY)) {
+                host = properties.get(FS_DEFAULTFS_KEY);
+                logger.info("no schema and authority in path. use fs.defaultFs");
+            } else {
+                logger.warn("invalid hdfs path. authority is null,path:" + path);
+                throw  new BrokerException(TBrokerOperationStatusCode.INVALID_ARGUMENT,
+                        "invalid hdfs path. authority is null");
+            }
+        }
         String username = properties.containsKey(USER_NAME_KEY) ? properties.get(USER_NAME_KEY) : "";
         String password = properties.containsKey(PASSWORD_KEY) ? properties.get(PASSWORD_KEY) : "";
+        String dfsNameServices =
+                properties.containsKey(DFS_NAMESERVICES_KEY) ? properties.get(DFS_NAMESERVICES_KEY) : "";
+
         String hdfsUgi = username + "," + password;
         FileSystemIdentity fileSystemIdentity = new FileSystemIdentity(host, hdfsUgi);
         BrokerFileSystem fileSystem = null;
@@ -110,6 +134,47 @@ public BrokerFileSystem getFileSystem(String path, Map<String, String> propertie
                 // TODO get this param from properties
                 // conf.set("dfs.replication", "2");
                 conf.set(HDFS_UGI_CONF, hdfsUgi);
+                if (!Strings.isNullOrEmpty(dfsNameServices)) {
+                    // ha hdfs arguments
+                    final String dfsHaNameNodesKey = DFS_HA_NAMENODES_PREFIX + dfsNameServices;
+                    if (!properties.containsKey(dfsHaNameNodesKey)) {
+                        throw  new BrokerException(TBrokerOperationStatusCode.INVALID_ARGUMENT,
+                                "load request missed necessary arguments for ha mode");
+                    }
+                    String dfsHaNameNodes =  properties.get(dfsHaNameNodesKey);
+                    conf.set(DFS_NAMESERVICES_KEY, dfsNameServices);
+                    conf.set(dfsHaNameNodesKey, dfsHaNameNodes);
+                    String[] nameNodes = dfsHaNameNodes.split(",");
+                    if (nameNodes == null) {
+                        throw  new BrokerException(TBrokerOperationStatusCode.INVALID_ARGUMENT,
+                                "invalid " + dfsHaNameNodesKey + " configuration");
+                    } else {
+                        for (String nameNode : nameNodes) {
+                            String nameNodeRpcAddress =
+                                    DFS_HA_NAMENODE_RPC_ADDRESS_PREFIX + dfsNameServices + "." + nameNode;
+                            if (!properties.containsKey(nameNodeRpcAddress)) {
+                                throw  new BrokerException(TBrokerOperationStatusCode.INVALID_ARGUMENT,
+                                        "missed " + nameNodeRpcAddress + " configuration");
+                            } else {
+                                conf.set(nameNodeRpcAddress, properties.get(nameNodeRpcAddress));
+                            }
+                        }
+                    }
+
+                    final String dfsClientFailoverProxyProviderKey =
+                            DFS_CLIENT_FAILOVER_PROXY_PROVIDER_PREFIX + dfsNameServices;
+                    if (properties.containsKey(dfsClientFailoverProxyProviderKey)) {
+                        conf.set(dfsClientFailoverProxyProviderKey,
+                                properties.get(dfsClientFailoverProxyProviderKey));
+                    } else {
+                        conf.set(dfsClientFailoverProxyProviderKey,
+                                DEFAULT_DFS_CLIENT_FAILOVER_PROXY_PROVIDER);
+                    }
+                    if (properties.containsKey(FS_DEFAULTFS_KEY)) {
+                        conf.set(FS_DEFAULTFS_KEY, properties.get(FS_DEFAULTFS_KEY));
+                    }
+                }
+
                 FileSystem dfsFileSystem = FileSystem.get(URI.create(host), conf);
                 fileSystem.setFileSystem(dfsFileSystem);
             }
diff --git a/fs_brokers/apache_hdfs_broker/test/com/baidu/palo/broker/hdfs/TestFileSystemManager.java b/fs_brokers/apache_hdfs_broker/test/com/baidu/palo/broker/hdfs/TestFileSystemManager.java
index 6be0dcdfea4538..c14e9fef1138c7 100644
--- a/fs_brokers/apache_hdfs_broker/test/com/baidu/palo/broker/hdfs/TestFileSystemManager.java
+++ b/fs_brokers/apache_hdfs_broker/test/com/baidu/palo/broker/hdfs/TestFileSystemManager.java
@@ -50,6 +50,76 @@ public void testGetFileSystemSuccess() throws IOException {
         fs.getDFSFileSystem().close();
     }
     
+    @Test
+    public void testGetFileSystemForhHA() throws IOException {
+        Map<String, String> properties = new HashMap<String, String>();
+        properties.put("username", "user");
+        properties.put("password", "passwd");
+        properties.put("fs.defaultFS", "hdfs://palo");
+        properties.put("dfs.nameservices", "palo");
+        properties.put("dfs.ha.namenodes.palo", "nn1,nn2");
+        properties.put("dfs.namenode.rpc-address.palo.nn1", "host1:port1");
+        properties.put("dfs.namenode.rpc-address.palo.nn2", "host2:port2");
+        properties.put("dfs.client.failover.proxy.provider.bdos",
+                "org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider");
+        BrokerFileSystem fs = fileSystemManager.getFileSystem(testHdfsHost + "/data/abc/logs", properties);
+        assertNotNull(fs);
+        fs.getDFSFileSystem().close();
+    }
+
+    @Test
+    public void testGetFileSystemForHAWithNoNames() throws IOException {
+        Map<String, String> properties = new HashMap<String, String>();
+        properties.put("username", "user");
+        properties.put("password", "passwd");
+        properties.put("fs.defaultFS", "hdfs://palo");
+        properties.put("dfs.nameservices", "palo");
+        properties.put("dfs.client.failover.proxy.provider.bdos",
+                "org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider");
+        boolean haveException = false;
+        try {
+            BrokerFileSystem fs = fileSystemManager.getFileSystem(testHdfsHost + "/data/abc/logs", properties);
+        } catch (BrokerException be) {
+            haveException = true;
+        }
+        assertEquals(true, haveException);
+    }
+
+    @Test
+    public void testGetFileSystemForHAWithNoRpcConfig() throws IOException {
+        Map<String, String> properties = new HashMap<String, String>();
+        properties.put("username", "user");
+        properties.put("password", "passwd");
+        properties.put("fs.defaultFS", "hdfs://palo");
+        properties.put("dfs.nameservices", "palo");
+        properties.put("dfs.ha.namenodes.palo", "nn1,nn2");
+        properties.put("dfs.namenode.rpc-address.palo.nn1", "host1:port1");
+        properties.put("dfs.client.failover.proxy.provider.bdos",
+                "org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider");
+        boolean haveException = false;
+        try {
+            BrokerFileSystem fs = fileSystemManager.getFileSystem(testHdfsHost + "/data/abc/logs", properties);
+        } catch (BrokerException be) {
+            haveException = true;
+        }
+        assertEquals(true, haveException);
+    }
+
+    @Test
+    public void testGetFileSystemForHAWithNoProviderArguments() throws IOException {
+        Map<String, String> properties = new HashMap<String, String>();
+        properties.put("username", "user");
+        properties.put("password", "passwd");
+        properties.put("fs.defaultFS", "hdfs://palo");
+        properties.put("dfs.nameservices", "palo");
+        properties.put("dfs.ha.namenodes.palo", "nn1,nn2");
+        properties.put("dfs.namenode.rpc-address.palo.nn1", "host1:port1");
+        properties.put("dfs.namenode.rpc-address.palo.nn2", "host2:port2");
+        BrokerFileSystem fs = fileSystemManager.getFileSystem(testHdfsHost + "/data/abc/logs", properties);
+        assertNotNull(fs);
+        fs.getDFSFileSystem().close();
+    }
+    
     @Test
     public void testGetFileSystemWithoutPassword() throws IOException {
         Map<String, String> properties = new HashMap<String, String>();
diff --git a/gensrc/proto/internal_service.proto b/gensrc/proto/internal_service.proto
index 68e481743cbf45..3698bb047cecdf 100644
--- a/gensrc/proto/internal_service.proto
+++ b/gensrc/proto/internal_service.proto
@@ -27,15 +27,15 @@ message PTransmitDataParams {
     // non-change member
     required PUniqueId finst_id = 1;
     required int32 node_id = 2;
+    // Id of this fragment in its role as a sender.
     required int32 sender_id = 3;
     required int32 be_number = 4;
 
-    // different per packet
-    required bool eos = 5;
-    optional PRowBatch row_batch = 6;
     // if set to true, indicates that no more row batches will be sent
     // for this dest_node_id
-    // Id of this fragment in its role as a sender.
+    required bool eos = 5;
+    optional PRowBatch row_batch = 6;
+    // different per packet
     required int64 packet_seq = 7;
 };
 
@@ -43,7 +43,36 @@ message PTransmitDataResult {
     optional PStatus status = 1;
 };
 
+message PExecPlanFragmentRequest {
+};
+
+message PExecPlanFragmentResult {
+    required PStatus status = 1;
+};
+
+message PCancelPlanFragmentRequest {
+    required PUniqueId finst_id = 1;
+};
+
+message PCancelPlanFragmentResult {
+    required PStatus status = 1;
+};
+
+message PFetchDataRequest {
+    required PUniqueId finst_id = 1;
+};
+
+message PFetchDataResult {
+    required PStatus status = 1;
+    // valid when status is ok
+    optional int64 packet_seq = 2;
+    optional bool eos = 3;
+};
+
 service PInternalService {
     rpc transmit_data(PTransmitDataParams) returns (PTransmitDataResult);
+    rpc exec_plan_fragment(PExecPlanFragmentRequest) returns (PExecPlanFragmentResult);
+    rpc cancel_plan_fragment(PCancelPlanFragmentRequest) returns (PCancelPlanFragmentResult);
+    rpc fetch_data(PFetchDataRequest) returns (PFetchDataResult);
 };
 
diff --git a/thirdparty/build-thirdparty.sh b/thirdparty/build-thirdparty.sh
index 5bb2f8dc8cee79..03846c0f9d6f48 100755
--- a/thirdparty/build-thirdparty.sh
+++ b/thirdparty/build-thirdparty.sh
@@ -36,6 +36,8 @@ if [ ! -f $curdir/vars.sh ]; then
 fi
 
 export PALO_HOME=$curdir/../
+export TP_DIR=$curdir
+
 source $curdir/vars.sh
 cd $TP_DIR
 
@@ -48,10 +50,15 @@ mkdir -p $TP_DIR/src
 mkdir -p $TP_DIR/installed
 export LD_LIBRARY_PATH=$TP_DIR/installed/lib:$LD_LIBRARY_PATH
 
+if [ -f $PALO_HOME/palo-toolchain/gcc730/bin/gcc ]; then
+    export GCC_HOME=$curdir/../palo-toolchain/gcc730
+fi
+export CC=${GCC_HOME}/bin/gcc
+export CPP=${GCC_HOME}/bin/cpp
+export CXX=${GCC_HOME}/bin/g++
+
 # Download thirdparties.
-# If you already run *download-thirdparty.sh*, this is a double check
-chmod +x download-thirdparty.sh
-./download-thirdparty.sh
+sh $TP_DIR/download-thirdparty.sh $@
 
 check_prerequest() {
     local CMD=$1
@@ -67,7 +74,7 @@ check_prerequest() {
 # check pre-request tools
 # sudo apt-get install ant
 # sudo yum install ant
-check_prerequest "ant -version" "ant"
+#check_prerequest "ant -version" "ant"
 
 # sudo apt-get install cmake
 # sudo yum install cmake
@@ -91,36 +98,20 @@ check_prerequest "libtoolize --version" "libtool"
 
 # sudo apt-get install binutils-dev
 # sudo yum install binutils-devel
-check_prerequest "locate libbfd.a" "binutils-dev"
+#check_prerequest "locate libbfd.a" "binutils-dev"
 
 # sudo apt-get install libiberty-dev
 # no need in centos 7.1
-check_prerequest "locate libiberty.a" "libiberty-dev"
+#check_prerequest "locate libiberty.a" "libiberty-dev"
 
 # sudo apt-get install bison
 # sudo yum install bison
-check_prerequest "bison --version" "bison"
-
-#########################
-# unpack java libraries
-#########################
-
-echo "Begin to unpack java libraries"
-if [ ! -f $TP_DIR/java-libraries.tar.gz ];then
-    echo "java-libraries.tar.gz is mising"
-    exit 1
-fi
-
-rm -rf $TP_JAR_DIR/*
-mkdir -p $TP_JAR_DIR/
-
-tar xzf $TP_DIR/java-libraries.tar.gz -C $TP_JAR_DIR/
-echo "Finish to unpack java libraries"
+#check_prerequest "bison --version" "bison"
 
 #########################
 # build all thirdparties
 #########################
-GCC_VERSION="$(gcc -dumpversion)"
+GCC_VERSION="$($CC -dumpversion)"
 
 CMAKE_CMD=`which cmake`
 
@@ -153,11 +144,13 @@ check_if_archieve_exist() {
 build_libevent() {
     check_if_source_exist $LIBEVENT_SOURCE
     cd $TP_SOURCE_DIR/$LIBEVENT_SOURCE
+    if [ ! -f configure ]; then
+        sh autogen.sh 
+    fi
 
-    CPPFLAGS="-I${TP_INCLUDE_DIR}" \
+    CFLAGS="-std=c99 -fPIC -D_BSD_SOURCE -fno-omit-frame-pointer -g -ggdb -O2 -I${TP_INCLUDE_DIR}" \
     LDFLAGS="-L${TP_LIB_DIR}" \
-    CFLAGS="-fPIC" \
-    ./configure --prefix=$TP_INSTALL_DIR
+    ./configure --prefix=$TP_INSTALL_DIR --enable-shared=no --disable-samples
     make -j2 && make install
 }
 
@@ -173,7 +166,6 @@ build_python() {
     make -j2 && make install
 }
 
-# openssl
 build_openssl() {
     check_if_source_exist $OPENSSL_SOURCE
     cd $TP_SOURCE_DIR/$OPENSSL_SOURCE
@@ -223,10 +215,11 @@ build_llvm() {
         exit 1
     fi
 
-    cd $TP_SOURCE_DIR/$LLVM_SOURCE
-    mkdir build -p && cd build
+    cd $TP_SOURCE_DIR
+    mkdir llvm-build -p && cd llvm-build
     rm -rf CMakeCache.txt CMakeFiles/
-    $CMAKE_CMD -DLLVM_REQUIRES_RTTI:Bool=True -DLLVM_TARGETS_TO_BUILD="X86" -DLLVM_ENABLE_PIC=true -DCMAKE_INSTALL_PREFIX=$TP_INSTALL_DIR ../
+    LDFLAGS="-L${TP_LIB_DIR} -static-libstdc++ -static-libgcc" \
+    $CMAKE_CMD -DLLVM_REQUIRES_RTTI:Bool=True -DLLVM_TARGETS_TO_BUILD="X86" -DLLVM_ENABLE_TERMINFO=OFF LLVM_BUILD_LLVM_DYLIB:BOOL=OFF -DLLVM_ENABLE_PIC=true -DBUILD_SHARED_LIBS=OFF -DCMAKE_BUILD_TYPE="RELEASE" -DCMAKE_INSTALL_PREFIX=$TP_INSTALL_DIR/llvm ../$LLVM_SOURCE
     make -j$PARALLEL REQUIRES_RTTI=1 && make install
 }
 
@@ -234,12 +227,17 @@ build_llvm() {
 build_protobuf() {
     check_if_source_exist $PROTOBUF_SOURCE
     cd $TP_SOURCE_DIR/$PROTOBUF_SOURCE
-
-    CPPFLAGS="-I${TP_INCLUDE_DIR}" \
-    LDFLAGS="-L${TP_LIB_DIR}" \
-    CFLAGS="-fPIC" \
-    ./configure --prefix=$TP_INSTALL_DIR
-    make -j2 && make install
+    rm -fr gmock
+    mkdir gmock && cd gmock && tar xf ${TP_SOURCE_DIR}/googletest-release-1.8.0.tar.gz \
+    && mv googletest-release-1.8.0 gtest && cd $TP_SOURCE_DIR/$PROTOBUF_SOURCE && sh autogen.sh
+    CXXFLAGS="-fPIC -O2" \
+    LDFLAGS="-L${TP_LIB_DIR} -static-libstdc++ -static-libgcc" \
+    ./configure --prefix=${TP_INSTALL_DIR} --disable-shared --enable-static
+    cd src
+    sed -i 's/^AM_LDFLAGS\(.*\)$/AM_LDFLAGS\1 -all-static/' Makefile
+    make -j$PARALLEL
+    cd -
+    make -j$PARALLEL && make install
 }
 
 # gflags
@@ -263,10 +261,10 @@ build_glog() {
     check_if_source_exist $GLOG_SOURCE
     cd $TP_SOURCE_DIR/$GLOG_SOURCE
 
-    CPPFLAGS="-I${TP_INCLUDE_DIR}" \
+    CPPFLAGS="-I${TP_INCLUDE_DIR} -fpermissive -fPIC" \
     LDFLAGS="-L${TP_LIB_DIR}" \
     CFLAGS="-fPIC" \
-    ./configure --prefix=$TP_INSTALL_DIR --enable-frame-pointers
+    ./configure --prefix=$TP_INSTALL_DIR --enable-frame-pointers --disable-shared --enable-static
     make -j$PARALLEL && make install
 }
 
@@ -302,7 +300,7 @@ build_snappy() {
     CPPFLAGS="-I${TP_INCLUDE_DIR}" \
     LDFLAGS="-L${TP_LIB_DIR}" \
     CFLAGS="-fPIC" \
-    ./configure --prefix=$TP_INSTALL_DIR \
+    ./configure --prefix=$TP_INSTALL_DIR --disable-shared --enable-static \
     --includedir=$TP_INCLUDE_DIR/snappy
     make -j$PARALLEL && make install
 }
@@ -311,12 +309,15 @@ build_snappy() {
 build_gperftools() {
     check_if_source_exist $GPERFTOOLS_SOURCE
     cd $TP_SOURCE_DIR/$GPERFTOOLS_SOURCE
+    if [ ! -f configure ]; then
+        sh autogen.sh 
+    fi
 
     CPPFLAGS="-I${TP_INCLUDE_DIR}" \
     LDFLAGS="-L${TP_LIB_DIR}" \
     LD_LIBRARY_PATH="${TP_LIB_DIR}" \
     CFLAGS="-fPIC" \
-    ./configure --prefix=$TP_INSTALL_DIR --disable-libunwind --with-pic --enable-frame-pointers
+    ./configure --prefix=$TP_INSTALL_DIR/gperftools --disable-shared --enable-static --disable-libunwind --with-pic --enable-frame-pointers
     make -j$PARALLEL && make install
 }
 
@@ -328,7 +329,7 @@ build_zlib() {
     CPPFLAGS="-I${TP_INCLUDE_DIR}" \
     LDFLAGS="-L${TP_LIB_DIR}" \
     CFLAGS="-fPIC" \
-    ./configure --prefix=$TP_INSTALL_DIR
+    ./configure --prefix=$TP_INSTALL_DIR --static
     make -j$PARALLEL && make install
 }
 
@@ -354,10 +355,10 @@ build_lzo2() {
     check_if_source_exist $LZO2_SOURCE
     cd $TP_SOURCE_DIR/$LZO2_SOURCE
     
-    CPPFLAGS="-I${TP_INCLUDE_DIR}" \
+    CPPFLAGS="-I${TP_INCLUDE_DIR} -fPIC" \
     LDFLAGS="-L${TP_LIB_DIR}" \
     CFLAGS="-fPIC" \
-    ./configure --prefix=$TP_INSTALL_DIR
+    ./configure --prefix=$TP_INSTALL_DIR --disable-shared --enable-static
     make -j$PARALLEL && make install
 }
 
@@ -381,7 +382,7 @@ build_curl() {
     CPPFLAGS="-I${TP_INCLUDE_DIR}" \
     LDFLAGS="-L${TP_LIB_DIR}" \
     CFLAGS="-fPIC" \
-    ./configure --prefix=$TP_INSTALL_DIR \
+    ./configure --prefix=$TP_INSTALL_DIR --disable-shared --enable-static \
     --without-ssl --without-libidn2 --disable-ldap
     make -j$PARALLEL && make install
 }
@@ -390,8 +391,9 @@ build_curl() {
 build_re2() {
     check_if_source_exist $RE2_SOURCE
     cd $TP_SOURCE_DIR/$RE2_SOURCE
-
-    make -j$PARALLEL install DESTDIR=$TP_INSTALL_DIR
+    
+    $CMAKE_CMD -DBUILD_SHARED_LIBS=0 -DCMAKE_INSTALL_PREFIX=$TP_INSTALL_DIR
+    make -j$PARALLEL install
 }
 
 # boost
@@ -399,8 +401,9 @@ build_boost() {
     check_if_source_exist $BOOST_SOURCE
     cd $TP_SOURCE_DIR/$BOOST_SOURCE
 
-    sh bootstrap.sh --prefix=$TP_INSTALL_DIR
-    ./b2 -d0 -j$PARALLEL --without-mpi --without-graph --without-graph_parallel --without-python cxxflags="-std=c++11 -fPIC -I$TP_INCLUDE_DIR -L$TP_LIB_DIR" install
+    echo "using gcc : $GCC_VERSION : $CXX ; " > tools/build/src/user-config.jam
+    sh bootstrap.sh --prefix=$TP_INSTALL_DIR 
+    ./b2 link=static -d0 -j$PARALLEL --without-mpi --without-graph --without-graph_parallel --without-python cxxflags="-std=c++11 -fPIC -I$TP_INCLUDE_DIR -L$TP_LIB_DIR" install
 }
 
 # mysql
@@ -420,7 +423,11 @@ build_mysql() {
         cp $TP_SOURCE_DIR/$BOOST_FOR_MYSQL_SOURCE ./ -rf
     fi
 
-    $CMAKE_CMD ../ -DWITH_BOOST=`pwd`/$BOOST_FOR_MYSQL_SOURCE -DCMAKE_INSTALL_PREFIX=$TP_INSTALL_DIR/mysql/ -DNCURSES_LIBRARY=$TP_LIB_DIR/libncurses.a -DNCURSES_INCLUDE_PATH=$TP_INCLUDE_DIR/ncurses/ -DCMAKE_INCLUDE_PATH=$TP_INCLUDE_DIR -DCMAKE_LIBRARY_PATH=$TP_LIB_DIR
+    $CMAKE_CMD ../ -DWITH_BOOST=`pwd`/$BOOST_FOR_MYSQL_SOURCE -DCMAKE_INSTALL_PREFIX=$TP_INSTALL_DIR/mysql/ \
+    -DNCURSES_LIBRARY=$TP_LIB_DIR/libncurses.a -DNCURSES_INCLUDE_PATH=$TP_INCLUDE_DIR/ncurses/ \
+    -DCMAKE_INCLUDE_PATH=$TP_INCLUDE_DIR -DCMAKE_LIBRARY_PATH=$TP_LIB_DIR -DWITHOUT_SERVER=1 \
+    -DCMAKE_CXX_FLAGS_RELWITHDEBINFO="-O3 -g -fabi-version=2 -fno-omit-frame-pointer -fno-strict-aliasing -std=gnu++11" \
+    -DDISABLE_SHARED=1 -DBUILD_SHARED_LIBS=0
     make -j$PARALLEL mysqlclient
 
     # copy headers manually
@@ -457,10 +464,39 @@ build_brpc() {
     cd $TP_SOURCE_DIR/$BRPC_SOURCE
     mkdir build -p && cd build
     rm -rf CMakeCache.txt CMakeFiles/
-    $CMAKE_CMD -v -DCMAKE_INSTALL_PREFIX=$TP_INSTALL_DIR -DBRPC_WITH_GLOG=ON -DCMAKE_INCLUDE_PATH="$TP_INSTALL_DIR/include" -DCMAKE_LIBRARY_PATH="$TP_INSTALL_DIR/lib;$TP_INSTALL_DIR/lib64" ..
+    $CMAKE_CMD -v -DBUILD_SHARED_LIBS=0 -DCMAKE_INSTALL_PREFIX=$TP_INSTALL_DIR \
+    -DBRPC_WITH_GLOG=ON -DCMAKE_INCLUDE_PATH="$TP_INSTALL_DIR/include" \
+    -DCMAKE_LIBRARY_PATH="$TP_INSTALL_DIR/lib;$TP_INSTALL_DIR/lib64" ..
     make -j$PARALLEL && make install
 }
 
+# java
+build_jdk() {
+    check_if_source_exist $JDK_SOURCE
+
+    if [ -d $TP_INSTALL_DIR/$JDK_SOURCE ];then
+        echo "$JDK_SOURCE already installed"
+    else
+        cp -rf $TP_SOURCE_DIR/$JDK_SOURCE $TP_INSTALL_DIR/
+    fi
+
+    export JAVA_HOME=$TP_INSTALL_DIR/$JDK_SOURCE
+}
+
+# ant
+build_ant() {
+    check_if_source_exist $ANT_SOURCE
+
+    if [ -d $TP_INSTALL_DIR/$ANT_SOURCE ];then
+        echo "$ANT_SOURCE already installed"
+    else
+        cp -rf $TP_SOURCE_DIR/$ANT_SOURCE $TP_INSTALL_DIR/ant
+    fi
+
+    export ANT_HOME=$TP_INSTALL_DIR/ant
+}
+
+build_llvm 
 build_libevent
 build_openssl
 build_zlib
@@ -483,5 +519,7 @@ build_mysql
 build_thrift
 build_leveldb
 build_brpc
+build_jdk
+build_ant
 
 echo "Finihsed to build all thirdparties"
diff --git a/thirdparty/download-thirdparty.sh b/thirdparty/download-thirdparty.sh
index 803e40780a2898..0dd6455f1aa71e 100755
--- a/thirdparty/download-thirdparty.sh
+++ b/thirdparty/download-thirdparty.sh
@@ -14,7 +14,6 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-
 set -e
 
 ################################################################
@@ -26,13 +25,13 @@ set -e
 
 curdir=`dirname "$0"`
 curdir=`cd "$curdir"; pwd`
+REPOSITORY_URL=$1
 
 export PALO_HOME=$curdir/../
 source $curdir/vars.sh
 
 mkdir -p $TP_DIR/src
 mkdir -p $TP_DIR/installed
-mkdir -p $TP_DIR/installed/jar/
 
 download() {
     local FILENAME=$1
@@ -82,9 +81,14 @@ download() {
 echo "===== Downloading thirdparty archives..."
 for TP_ARCH in ${TP_ARCHIVES[*]}
 do
-    URL=$TP_ARCH"_DOWNLOAD"
     NAME=$TP_ARCH"_NAME"
-    download ${!NAME} ${!URL} $TP_SOURCE_DIR
+    if test "x$REPOSITORY_URL" = x; then
+        URL=$TP_ARCH"_DOWNLOAD"
+        download ${!NAME} ${!URL} $TP_SOURCE_DIR
+    else
+        URL="${REPOSITORY_URL}/${!NAME}"
+        download ${!NAME} ${URL} $TP_SOURCE_DIR
+    fi
 done
 echo "===== Downloading thirdparty archives...done"
 
@@ -104,6 +108,9 @@ echo "===== Checking all thirdpart archives...done"
 echo "===== Unpacking all thirdparty archives..."
 TAR_CMD="tar"
 UNZIP_CMD="unzip"
+SUFFIX_TGZ="\.(tar\.gz|tgz)$"
+SUFFIX_XZ="\.tar\.xz$"
+SUFFIX_ZIP="\.zip$"
 for TP_ARCH in ${TP_ARCHIVES[*]}
 do
     NAME=$TP_ARCH"_NAME"
@@ -114,14 +121,21 @@ do
     fi
 
     if [ ! -d $TP_SOURCE_DIR/${!SOURCE} ]; then
-        if [[ "${!NAME}" =~ \.(tar\.gz|tgz)$  ]]; then
+        if [[ "${!NAME}" =~ $SUFFIX_TGZ  ]]; then
             echo "$TP_SOURCE_DIR/${!NAME}"
             echo "$TP_SOURCE_DIR/${!SOURCE}"
             if ! $TAR_CMD xzf "$TP_SOURCE_DIR/${!NAME}" -C "$TP_SOURCE_DIR/"; then
                 echo "Failed to untar ${!NAME}"
                 exit 1
             fi
-        elif [[ "${!NAME}" =~ \.zip$ ]]; then
+        elif [[ "${!NAME}" =~ $SUFFIX_XZ ]]; then
+            echo "$TP_SOURCE_DIR/${!NAME}"
+            echo "$TP_SOURCE_DIR/${!SOURCE}"
+            if ! $TAR_CMD xJf "$TP_SOURCE_DIR/${!NAME}" -C "$TP_SOURCE_DIR/"; then
+                echo "Failed to untar ${!NAME}"
+                exit 1
+            fi
+        elif [[ "${!NAME}" =~ $SUFFIX_ZIP ]]; then
             if ! $UNZIP_CMD "$TP_SOURCE_DIR/${!NAME}" -d "$TP_SOURCE_DIR/"; then
                 echo "Failed to unzip ${!NAME}"
                 exit 1
@@ -153,15 +167,6 @@ fi
 cd -
 echo "Finished patching $GLOG_SOURCE"
 
-# ncurses patch
-cd $TP_SOURCE_DIR/$NCURSES_SOURCE
-if [ ! -f $PATCHED_MARK ]; then
-    patch -p0 < $TP_PATCH_DIR/ncurses-6.0.patch 
-    touch $PATCHED_MARK
-fi
-cd -
-echo "Finished patching $NCURSES_SOURCE"
-
 # re2 patch
 cd $TP_SOURCE_DIR/$RE2_SOURCE
 if [ ! -f $PATCHED_MARK ]; then
@@ -180,36 +185,61 @@ fi
 cd -
 echo "Finished patching $MYSQL_SOURCE"
 
-##########################
-# Download java libraries
-##########################
-
-# create download dir first
-mkdir -p $TP_JAR_DIR
+# libevent patch
+cd $TP_SOURCE_DIR/$LIBEVENT_SOURCE
+if [ ! -f $PATCHED_MARK ]; then
+    patch -p1 < $TP_PATCH_DIR/libevent_on_free_cb.patch
+    touch $PATCHED_MARK
+fi
+cd -
+echo "Finished patching $LIBEVENT_SOURCE"
 
-echo "===== Downloading java libraries..."
-for TP_JAR in ${TP_JARS[*]}
-do
-    URL=$TP_JAR"_DOWNLOAD"
-    NAME=$TP_JAR"_NAME"
-    download ${!NAME} ${!URL} $TP_JAR_DIR
+# thrift patch
+cd $TP_SOURCE_DIR/$THRIFT_SOURCE
+if [ ! -f $PATCHED_MARK ]; then
+    patch -p0 < $TP_PATCH_DIR/thrift-0.9.3-aclocal.patch
+    touch $PATCHED_MARK
+fi
+cd -
+echo "Finished patching $THRIFT_SOURCE"
 
-    if [ "$TP_JAR"x == "KUDU"x ];then
-        # unzip kudu
-        tar xzf $TP_JAR_DIR/$KUDU_NAME -C $TP_JAR_DIR/
+if test "x$REPOSITORY_URL" != x; then
+    cd $TP_SOURCE_DIR/$COMPILER_RT_SOURCE
+    if [ ! -f $PATCHED_MARK ]; then
+        patch -p0 < $TP_PATCH_DIR/compiler-rt.patch
+        touch $PATCHED_MARK
     fi
-done
-echo "===== Downloading java libraries...done"
+    cd -
+    echo "Finished patching $COMPILER_RT_SOURCE"
+fi
+
+# lz4 patch to disable shared library
+cd $TP_SOURCE_DIR/$LZ4_SOURCE
+if [ ! -f $PATCHED_MARK ]; then
+    patch -p0 < $TP_PATCH_DIR/lz4-1.7.5.patch
+    touch $PATCHED_MARK
+fi
+cd -
+echo "Finished patching $LZ4_SOURCE"
+
+# brpc patch to disable shared library
+cd $TP_SOURCE_DIR/$BRPC_SOURCE
+if [ ! -f $PATCHED_MARK ]; then
+    patch -p0 < $TP_PATCH_DIR/brpc-0.9.0.patch
+    touch $PATCHED_MARK
+fi
+cd -
+echo "Finished patching $LZ4_SOURCE"
+
+#####################################
+# Copy java libraries
+#####################################
+
+echo "Begin to copy java libraries"
+
+rm -rf $TP_JAR_DIR/*
+mkdir -p $TP_JAR_DIR/
+cp -R $TP_DIR/java-libraries/* $TP_JAR_DIR/
+
+echo "Finish to copy java libraries"
 
-# check if all java libraries exist
-echo "===== Checking all java libraries..."
-for TP_JAR in ${TP_JARS[*]}
-do
-    NAME=$TP_JAR"_NAME"
-    if [ ! -r $TP_JAR_DIR/${!NAME} ]; then
-        echo "Failed to fetch ${!NAME}"
-        exit 1
-    fi
-done
-echo "===== Checking all java libraries...done"
-echo "===== Finish downloading all thirdparties"
diff --git a/thirdparty/java-libraries.tar.gz b/thirdparty/java-libraries.tar.gz
deleted file mode 100644
index 99eb6d566693ba..00000000000000
Binary files a/thirdparty/java-libraries.tar.gz and /dev/null differ
diff --git a/thirdparty/java-libraries/cglib-nodep-2.2.2.jar b/thirdparty/java-libraries/cglib-nodep-2.2.2.jar
new file mode 100644
index 00000000000000..02d81e88040019
Binary files /dev/null and b/thirdparty/java-libraries/cglib-nodep-2.2.2.jar differ
diff --git a/thirdparty/java-libraries/commons-cli-2.0-SNAPSHOT.jar b/thirdparty/java-libraries/commons-cli-2.0-SNAPSHOT.jar
new file mode 100644
index 00000000000000..0b1d51072a714c
Binary files /dev/null and b/thirdparty/java-libraries/commons-cli-2.0-SNAPSHOT.jar differ
diff --git a/thirdparty/java-libraries/commons-codec-1.9.jar b/thirdparty/java-libraries/commons-codec-1.9.jar
new file mode 100644
index 00000000000000..ef35f1c50d7c41
Binary files /dev/null and b/thirdparty/java-libraries/commons-codec-1.9.jar differ
diff --git a/thirdparty/java-libraries/commons-lang-2.4.jar b/thirdparty/java-libraries/commons-lang-2.4.jar
new file mode 100644
index 00000000000000..532939ecab6b77
Binary files /dev/null and b/thirdparty/java-libraries/commons-lang-2.4.jar differ
diff --git a/thirdparty/java-libraries/commons-pool2-2.2.jar b/thirdparty/java-libraries/commons-pool2-2.2.jar
new file mode 100644
index 00000000000000..6a3eb38acb83a1
Binary files /dev/null and b/thirdparty/java-libraries/commons-pool2-2.2.jar differ
diff --git a/thirdparty/java-libraries/commons-validator-1.4.1.jar b/thirdparty/java-libraries/commons-validator-1.4.1.jar
new file mode 100644
index 00000000000000..95c951e0504f07
Binary files /dev/null and b/thirdparty/java-libraries/commons-validator-1.4.1.jar differ
diff --git a/thirdparty/java-libraries/easymock-3.2.jar b/thirdparty/java-libraries/easymock-3.2.jar
new file mode 100644
index 00000000000000..7c439f82c181b1
Binary files /dev/null and b/thirdparty/java-libraries/easymock-3.2.jar differ
diff --git a/thirdparty/java-libraries/gson-2.2.4.jar b/thirdparty/java-libraries/gson-2.2.4.jar
new file mode 100644
index 00000000000000..75fe27c54714ca
Binary files /dev/null and b/thirdparty/java-libraries/gson-2.2.4.jar differ
diff --git a/thirdparty/java-libraries/guava-15.0.jar b/thirdparty/java-libraries/guava-15.0.jar
new file mode 100644
index 00000000000000..eb9ef8ad5ffffc
Binary files /dev/null and b/thirdparty/java-libraries/guava-15.0.jar differ
diff --git a/thirdparty/java-libraries/hamcrest-core-1.1.jar b/thirdparty/java-libraries/hamcrest-core-1.1.jar
new file mode 100644
index 00000000000000..e5149be76e7b4f
Binary files /dev/null and b/thirdparty/java-libraries/hamcrest-core-1.1.jar differ
diff --git a/thirdparty/java-libraries/jackson-core-asl-1.8.1.jar b/thirdparty/java-libraries/jackson-core-asl-1.8.1.jar
new file mode 100644
index 00000000000000..13574a4ed9efa7
Binary files /dev/null and b/thirdparty/java-libraries/jackson-core-asl-1.8.1.jar differ
diff --git a/thirdparty/java-libraries/jackson-mapper-asl-1.8.1.jar b/thirdparty/java-libraries/jackson-mapper-asl-1.8.1.jar
new file mode 100644
index 00000000000000..83b684038b6727
Binary files /dev/null and b/thirdparty/java-libraries/jackson-mapper-asl-1.8.1.jar differ
diff --git a/thirdparty/java-libraries/java-cup-0.11a.jar b/thirdparty/java-libraries/java-cup-0.11a.jar
new file mode 100644
index 00000000000000..1d84620d228a63
Binary files /dev/null and b/thirdparty/java-libraries/java-cup-0.11a.jar differ
diff --git a/thirdparty/java-libraries/javassist-3.18.2-GA.jar b/thirdparty/java-libraries/javassist-3.18.2-GA.jar
new file mode 100644
index 00000000000000..c8761c8efe0821
Binary files /dev/null and b/thirdparty/java-libraries/javassist-3.18.2-GA.jar differ
diff --git a/thirdparty/java-libraries/javax.servlet-api-3.0.1.jar b/thirdparty/java-libraries/javax.servlet-api-3.0.1.jar
new file mode 100644
index 00000000000000..4e2edcc9df6974
Binary files /dev/null and b/thirdparty/java-libraries/javax.servlet-api-3.0.1.jar differ
diff --git a/thirdparty/java-libraries/je-7.3.7.jar b/thirdparty/java-libraries/je-7.3.7.jar
new file mode 100644
index 00000000000000..dc74e5bc9f7245
Binary files /dev/null and b/thirdparty/java-libraries/je-7.3.7.jar differ
diff --git a/thirdparty/java-libraries/jetty-6.1.14.jar b/thirdparty/java-libraries/jetty-6.1.14.jar
new file mode 100644
index 00000000000000..8c503bea21164b
Binary files /dev/null and b/thirdparty/java-libraries/jetty-6.1.14.jar differ
diff --git a/thirdparty/java-libraries/jetty-util-6.1.14.jar b/thirdparty/java-libraries/jetty-util-6.1.14.jar
new file mode 100644
index 00000000000000..8f924bb1478c4a
Binary files /dev/null and b/thirdparty/java-libraries/jetty-util-6.1.14.jar differ
diff --git a/thirdparty/java-libraries/jflex-1.4.3.jar b/thirdparty/java-libraries/jflex-1.4.3.jar
new file mode 100644
index 00000000000000..8e952a3573fcfa
Binary files /dev/null and b/thirdparty/java-libraries/jflex-1.4.3.jar differ
diff --git a/thirdparty/java-libraries/jmockit-1.38.jar b/thirdparty/java-libraries/jmockit-1.38.jar
new file mode 100644
index 00000000000000..fe1f81685cef17
Binary files /dev/null and b/thirdparty/java-libraries/jmockit-1.38.jar differ
diff --git a/thirdparty/java-libraries/jprotobuf-1.11.0.jar b/thirdparty/java-libraries/jprotobuf-1.11.0.jar
new file mode 100644
index 00000000000000..76ffbd4214f5c5
Binary files /dev/null and b/thirdparty/java-libraries/jprotobuf-1.11.0.jar differ
diff --git a/thirdparty/java-libraries/jprotobuf-rpc-common-1.8.jar b/thirdparty/java-libraries/jprotobuf-rpc-common-1.8.jar
new file mode 100644
index 00000000000000..da258c8597dd40
Binary files /dev/null and b/thirdparty/java-libraries/jprotobuf-rpc-common-1.8.jar differ
diff --git a/thirdparty/java-libraries/jprotobuf-rpc-core-3.5.14.jar b/thirdparty/java-libraries/jprotobuf-rpc-core-3.5.14.jar
new file mode 100644
index 00000000000000..10398ed136be1b
Binary files /dev/null and b/thirdparty/java-libraries/jprotobuf-rpc-core-3.5.14.jar differ
diff --git a/thirdparty/java-libraries/json-20171018.jar b/thirdparty/java-libraries/json-20171018.jar
new file mode 100644
index 00000000000000..cad06581d98bb1
Binary files /dev/null and b/thirdparty/java-libraries/json-20171018.jar differ
diff --git a/thirdparty/java-libraries/junit-4.12.jar b/thirdparty/java-libraries/junit-4.12.jar
new file mode 100644
index 00000000000000..3a7fc266c3e322
Binary files /dev/null and b/thirdparty/java-libraries/junit-4.12.jar differ
diff --git a/thirdparty/java-libraries/k8s-client/automaton-1.11-8.jar b/thirdparty/java-libraries/k8s-client/automaton-1.11-8.jar
new file mode 100644
index 00000000000000..60f6ce01e14fca
Binary files /dev/null and b/thirdparty/java-libraries/k8s-client/automaton-1.11-8.jar differ
diff --git a/thirdparty/java-libraries/k8s-client/generex-1.0.1.jar b/thirdparty/java-libraries/k8s-client/generex-1.0.1.jar
new file mode 100644
index 00000000000000..982bd1e2d07cb4
Binary files /dev/null and b/thirdparty/java-libraries/k8s-client/generex-1.0.1.jar differ
diff --git a/thirdparty/java-libraries/k8s-client/jackson-annotations-2.7.0.jar b/thirdparty/java-libraries/k8s-client/jackson-annotations-2.7.0.jar
new file mode 100644
index 00000000000000..96fb17cf4f29d9
Binary files /dev/null and b/thirdparty/java-libraries/k8s-client/jackson-annotations-2.7.0.jar differ
diff --git a/thirdparty/java-libraries/k8s-client/jackson-core-2.7.5.jar b/thirdparty/java-libraries/k8s-client/jackson-core-2.7.5.jar
new file mode 100644
index 00000000000000..307df1eabf7784
Binary files /dev/null and b/thirdparty/java-libraries/k8s-client/jackson-core-2.7.5.jar differ
diff --git a/thirdparty/java-libraries/k8s-client/jackson-databind-2.7.5.jar b/thirdparty/java-libraries/k8s-client/jackson-databind-2.7.5.jar
new file mode 100644
index 00000000000000..d337ea543710e1
Binary files /dev/null and b/thirdparty/java-libraries/k8s-client/jackson-databind-2.7.5.jar differ
diff --git a/thirdparty/java-libraries/k8s-client/jackson-dataformat-yaml-2.7.5.jar b/thirdparty/java-libraries/k8s-client/jackson-dataformat-yaml-2.7.5.jar
new file mode 100644
index 00000000000000..e9c5d9e4fa5403
Binary files /dev/null and b/thirdparty/java-libraries/k8s-client/jackson-dataformat-yaml-2.7.5.jar differ
diff --git a/thirdparty/java-libraries/k8s-client/jackson-module-jaxb-annotations-2.7.5.jar b/thirdparty/java-libraries/k8s-client/jackson-module-jaxb-annotations-2.7.5.jar
new file mode 100644
index 00000000000000..136ddf33877dcc
Binary files /dev/null and b/thirdparty/java-libraries/k8s-client/jackson-module-jaxb-annotations-2.7.5.jar differ
diff --git a/thirdparty/java-libraries/k8s-client/kubernetes-client-1.4.27.jar b/thirdparty/java-libraries/k8s-client/kubernetes-client-1.4.27.jar
new file mode 100644
index 00000000000000..5af36e06a08ced
Binary files /dev/null and b/thirdparty/java-libraries/k8s-client/kubernetes-client-1.4.27.jar differ
diff --git a/thirdparty/java-libraries/k8s-client/kubernetes-model-1.0.64.jar b/thirdparty/java-libraries/k8s-client/kubernetes-model-1.0.64.jar
new file mode 100644
index 00000000000000..75d3bab68703e0
Binary files /dev/null and b/thirdparty/java-libraries/k8s-client/kubernetes-model-1.0.64.jar differ
diff --git a/thirdparty/java-libraries/k8s-client/logging-interceptor-3.4.1.jar b/thirdparty/java-libraries/k8s-client/logging-interceptor-3.4.1.jar
new file mode 100644
index 00000000000000..4bea8311b64a05
Binary files /dev/null and b/thirdparty/java-libraries/k8s-client/logging-interceptor-3.4.1.jar differ
diff --git a/thirdparty/java-libraries/k8s-client/okhttp-3.4.1.jar b/thirdparty/java-libraries/k8s-client/okhttp-3.4.1.jar
new file mode 100644
index 00000000000000..e31f248628faa0
Binary files /dev/null and b/thirdparty/java-libraries/k8s-client/okhttp-3.4.1.jar differ
diff --git a/thirdparty/java-libraries/k8s-client/okhttp-ws-3.4.1.jar b/thirdparty/java-libraries/k8s-client/okhttp-ws-3.4.1.jar
new file mode 100644
index 00000000000000..60a863f29e88bb
Binary files /dev/null and b/thirdparty/java-libraries/k8s-client/okhttp-ws-3.4.1.jar differ
diff --git a/thirdparty/java-libraries/k8s-client/okio-1.9.0.jar b/thirdparty/java-libraries/k8s-client/okio-1.9.0.jar
new file mode 100644
index 00000000000000..3c42b934b58d6c
Binary files /dev/null and b/thirdparty/java-libraries/k8s-client/okio-1.9.0.jar differ
diff --git a/thirdparty/java-libraries/k8s-client/snakeyaml-1.15.jar b/thirdparty/java-libraries/k8s-client/snakeyaml-1.15.jar
new file mode 100644
index 00000000000000..34084e33257e0d
Binary files /dev/null and b/thirdparty/java-libraries/k8s-client/snakeyaml-1.15.jar differ
diff --git a/thirdparty/java-libraries/k8s-client/validation-api-1.1.0.Final.jar b/thirdparty/java-libraries/k8s-client/validation-api-1.1.0.Final.jar
new file mode 100644
index 00000000000000..de85403868d90e
Binary files /dev/null and b/thirdparty/java-libraries/k8s-client/validation-api-1.1.0.Final.jar differ
diff --git a/thirdparty/java-libraries/k8s-client/zjsonpatch-0.2.3.jar b/thirdparty/java-libraries/k8s-client/zjsonpatch-0.2.3.jar
new file mode 100644
index 00000000000000..3467511c0389f5
Binary files /dev/null and b/thirdparty/java-libraries/k8s-client/zjsonpatch-0.2.3.jar differ
diff --git a/thirdparty/java-libraries/kudu-client/async-1.1.0.jar b/thirdparty/java-libraries/kudu-client/async-1.1.0.jar
new file mode 100755
index 00000000000000..ac7a4cd92856eb
Binary files /dev/null and b/thirdparty/java-libraries/kudu-client/async-1.1.0.jar differ
diff --git a/thirdparty/java-libraries/kudu-client/interface-annotations-1.2.0-cdh5.10.0.jar b/thirdparty/java-libraries/kudu-client/interface-annotations-1.2.0-cdh5.10.0.jar
new file mode 100755
index 00000000000000..07ece4af66f2cf
Binary files /dev/null and b/thirdparty/java-libraries/kudu-client/interface-annotations-1.2.0-cdh5.10.0.jar differ
diff --git a/thirdparty/java-libraries/kudu-client/kudu-client-1.2.0-cdh5.10.0.jar b/thirdparty/java-libraries/kudu-client/kudu-client-1.2.0-cdh5.10.0.jar
new file mode 100644
index 00000000000000..c7844f6bb96a80
Binary files /dev/null and b/thirdparty/java-libraries/kudu-client/kudu-client-1.2.0-cdh5.10.0.jar differ
diff --git a/thirdparty/java-libraries/kudu-client/log4j-1.2.17.jar b/thirdparty/java-libraries/kudu-client/log4j-1.2.17.jar
new file mode 100644
index 00000000000000..1d425cf7d7e25f
Binary files /dev/null and b/thirdparty/java-libraries/kudu-client/log4j-1.2.17.jar differ
diff --git a/thirdparty/java-libraries/kudu-client/slf4j-api-1.7.5.jar b/thirdparty/java-libraries/kudu-client/slf4j-api-1.7.5.jar
new file mode 100755
index 00000000000000..8f004d3906fc90
Binary files /dev/null and b/thirdparty/java-libraries/kudu-client/slf4j-api-1.7.5.jar differ
diff --git a/thirdparty/java-libraries/libfb303-0.9.3.jar b/thirdparty/java-libraries/libfb303-0.9.3.jar
new file mode 100644
index 00000000000000..07c711b738e229
Binary files /dev/null and b/thirdparty/java-libraries/libfb303-0.9.3.jar differ
diff --git a/thirdparty/java-libraries/libthrift-0.9.3.jar b/thirdparty/java-libraries/libthrift-0.9.3.jar
new file mode 100644
index 00000000000000..f9221a9f958f2a
Binary files /dev/null and b/thirdparty/java-libraries/libthrift-0.9.3.jar differ
diff --git a/thirdparty/java-libraries/log4j-api-2.2.jar b/thirdparty/java-libraries/log4j-api-2.2.jar
new file mode 100644
index 00000000000000..21bbcad489253d
Binary files /dev/null and b/thirdparty/java-libraries/log4j-api-2.2.jar differ
diff --git a/thirdparty/java-libraries/log4j-core-2.2.jar b/thirdparty/java-libraries/log4j-core-2.2.jar
new file mode 100644
index 00000000000000..a8279f78366e0a
Binary files /dev/null and b/thirdparty/java-libraries/log4j-core-2.2.jar differ
diff --git a/thirdparty/java-libraries/log4j-slf4j-impl-2.2.jar b/thirdparty/java-libraries/log4j-slf4j-impl-2.2.jar
new file mode 100644
index 00000000000000..658e53045e5431
Binary files /dev/null and b/thirdparty/java-libraries/log4j-slf4j-impl-2.2.jar differ
diff --git a/thirdparty/java-libraries/metrics-core-4.0.2.jar b/thirdparty/java-libraries/metrics-core-4.0.2.jar
new file mode 100644
index 00000000000000..2001fe9f2bc400
Binary files /dev/null and b/thirdparty/java-libraries/metrics-core-4.0.2.jar differ
diff --git a/thirdparty/java-libraries/mysql-connector-java-5.1.41.jar b/thirdparty/java-libraries/mysql-connector-java-5.1.41.jar
new file mode 100644
index 00000000000000..cdf74884d81edc
Binary files /dev/null and b/thirdparty/java-libraries/mysql-connector-java-5.1.41.jar differ
diff --git a/thirdparty/java-libraries/netty-all-4.1.0.Beta3.jar b/thirdparty/java-libraries/netty-all-4.1.0.Beta3.jar
new file mode 100644
index 00000000000000..fd2f6ba0e6c551
Binary files /dev/null and b/thirdparty/java-libraries/netty-all-4.1.0.Beta3.jar differ
diff --git a/thirdparty/java-libraries/objenesis-2.1.jar b/thirdparty/java-libraries/objenesis-2.1.jar
new file mode 100644
index 00000000000000..7c1e983798fb3d
Binary files /dev/null and b/thirdparty/java-libraries/objenesis-2.1.jar differ
diff --git a/thirdparty/java-libraries/powermock-easymock-1.6.1-full.jar b/thirdparty/java-libraries/powermock-easymock-1.6.1-full.jar
new file mode 100644
index 00000000000000..e5c7424c6647ac
Binary files /dev/null and b/thirdparty/java-libraries/powermock-easymock-1.6.1-full.jar differ
diff --git a/thirdparty/java-libraries/protobuf-java-2.5.0.jar b/thirdparty/java-libraries/protobuf-java-2.5.0.jar
new file mode 100644
index 00000000000000..4c4e686a497c4d
Binary files /dev/null and b/thirdparty/java-libraries/protobuf-java-2.5.0.jar differ
diff --git a/thirdparty/java-libraries/protoparser-3.1.5.jar b/thirdparty/java-libraries/protoparser-3.1.5.jar
new file mode 100644
index 00000000000000..b5bdc2b9ea72f1
Binary files /dev/null and b/thirdparty/java-libraries/protoparser-3.1.5.jar differ
diff --git a/thirdparty/java-libraries/servlet-api.jar b/thirdparty/java-libraries/servlet-api.jar
new file mode 100644
index 00000000000000..c9dab30f94889e
Binary files /dev/null and b/thirdparty/java-libraries/servlet-api.jar differ
diff --git a/thirdparty/java-libraries/slf4j-api-1.6.1.jar b/thirdparty/java-libraries/slf4j-api-1.6.1.jar
new file mode 100644
index 00000000000000..f1f4fdd214940c
Binary files /dev/null and b/thirdparty/java-libraries/slf4j-api-1.6.1.jar differ
diff --git a/thirdparty/java-libraries/snappy-java-1.1.7.2.jar b/thirdparty/java-libraries/snappy-java-1.1.7.2.jar
new file mode 100644
index 00000000000000..da8dd434abb6d9
Binary files /dev/null and b/thirdparty/java-libraries/snappy-java-1.1.7.2.jar differ
diff --git a/thirdparty/patches/brpc-0.9.0.patch b/thirdparty/patches/brpc-0.9.0.patch
new file mode 100644
index 00000000000000..5f2035a5b04274
--- /dev/null
+++ b/thirdparty/patches/brpc-0.9.0.patch
@@ -0,0 +1,16 @@
+--- src/CMakeLists.txt
++++ src/CMakeLists.txt
+@@ -46,11 +46,13 @@ endif()
+ 
+ #install directory
+ # cmake -DCMAKE_INSTALL_PREFIX=/usr
++if(BUILD_SHARED_LIBS)
+ install(TARGETS brpc-shared
+         RUNTIME DESTINATION bin
+         LIBRARY DESTINATION lib${LIBSUFFIX}
+         ARCHIVE DESTINATION lib${LIBSUFFIX}
+         )
++endif()
+ 
+ install(TARGETS brpc-static
+         RUNTIME DESTINATION bin
diff --git a/thirdparty/patches/compiler-rt.patch b/thirdparty/patches/compiler-rt.patch
new file mode 100644
index 00000000000000..3549e7bed1d4a7
--- /dev/null
+++ b/thirdparty/patches/compiler-rt.patch
@@ -0,0 +1,11 @@
+--- lib/sanitizer_common/sanitizer_platform_limits_posix.h
++++ lib/sanitizer_common/sanitizer_platform_limits_posix.h
+@@ -507,7 +507,7 @@ namespace __sanitizer {
+ 
+   typedef long long __sanitizer___kernel_loff_t;
+   typedef struct {
+-    unsigned long fds_bits[1024 / (8 * sizeof(long))];
++    unsigned long fds_bits[51200 / (8 * sizeof(long))];
+   } __sanitizer___kernel_fd_set;
+ #endif
+ 
diff --git a/thirdparty/patches/libevent_on_free_cb.patch b/thirdparty/patches/libevent_on_free_cb.patch
new file mode 100644
index 00000000000000..7e5cffa41fc730
--- /dev/null
+++ b/thirdparty/patches/libevent_on_free_cb.patch
@@ -0,0 +1,71 @@
+diff --git a/http.c b/http.c
+index b04af9a..5183a11 100644
+--- a/http.c
++++ b/http.c
+@@ -3995,6 +3995,9 @@ evhttp_request_free(struct evhttp_request *req)
+ 		return;
+ 	}
+ 
++	if (req->on_free_cb)
++		(*req->on_free_cb)(req, req->on_free_cb_arg);
++
+ 	if (req->remote_host != NULL)
+ 		mm_free(req->remote_host);
+ 	if (req->uri != NULL)
+@@ -4074,6 +4077,14 @@ evhttp_request_set_on_complete_cb(struct evhttp_request *req,
+ 	req->on_complete_cb_arg = cb_arg;
+ }
+ 
++void
++evhttp_request_set_on_free_cb(struct evhttp_request *req,
++    void (*cb)(struct evhttp_request *, void *), void *cb_arg)
++{
++	req->on_free_cb = cb;
++	req->on_free_cb_arg = cb_arg;
++}
++
+ /*
+  * Allows for inspection of the request URI
+  */
+diff --git a/include/event2/http.h b/include/event2/http.h
+index ed9acf4..3a73c6c 100644
+--- a/include/event2/http.h
++++ b/include/event2/http.h
+@@ -642,6 +642,20 @@ EVENT2_EXPORT_SYMBOL
+ void evhttp_request_set_on_complete_cb(struct evhttp_request *req,
+     void (*cb)(struct evhttp_request *, void *), void *cb_arg);
+ 
++/**
++ * Set a callback to be called on request free.
++ *
++ * The callback function will be called just before the evhttp_request object
++ * is destroyed.
++ *
++ * @param req a request object
++ * @param cb callback function that will be called before request free
++ * @param cb_arg an additional context argument for the callback
++ */
++EVENT2_EXPORT_SYMBOL
++void evhttp_request_set_on_free_cb(struct evhttp_request *req,
++    void (*cb)(struct evhttp_request *, void *), void *cb_arg);
++
+ /** Frees the request object and removes associated events. */
+ EVENT2_EXPORT_SYMBOL
+ void evhttp_request_free(struct evhttp_request *req);
+diff --git a/include/event2/http_struct.h b/include/event2/http_struct.h
+index 4bf5b1f..0762cab 100644
+--- a/include/event2/http_struct.h
++++ b/include/event2/http_struct.h
+@@ -142,6 +142,12 @@ struct {
+ 	 */
+ 	void (*on_complete_cb)(struct evhttp_request *, void *);
+ 	void *on_complete_cb_arg;
++
++	/*
++	 * Free callback - called just before the request is freed.
++	 */
++	void (*on_free_cb)(struct evhttp_request *, void *);
++	void *on_free_cb_arg;
+ };
+ 
+ #ifdef __cplusplus
diff --git a/thirdparty/patches/lz4-1.7.5.patch b/thirdparty/patches/lz4-1.7.5.patch
new file mode 100644
index 00000000000000..5598797a25cf9b
--- /dev/null
+++ b/thirdparty/patches/lz4-1.7.5.patch
@@ -0,0 +1,15 @@
+--- lib/Makefile
++++ lib/Makefile
+@@ -147,9 +147,9 @@ install: lib liblz4.pc
+ ifeq ($(BUILD_STATIC),yes)
+ 	@$(INSTALL_LIB) liblz4.a $(DESTDIR)$(LIBDIR)/liblz4.a
+ endif
+-	@$(INSTALL_LIB) liblz4.$(SHARED_EXT_VER) $(DESTDIR)$(LIBDIR)
+-	@ln -sf liblz4.$(SHARED_EXT_VER) $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT_MAJOR)
+-	@ln -sf liblz4.$(SHARED_EXT_VER) $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT)
++#	@$(INSTALL_LIB) liblz4.$(SHARED_EXT_VER) $(DESTDIR)$(LIBDIR)
++#	@ln -sf liblz4.$(SHARED_EXT_VER) $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT_MAJOR)
++#	@ln -sf liblz4.$(SHARED_EXT_VER) $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT)
+ 	@echo Installing includes
+ 	@$(INSTALL_DATA) lz4.h $(DESTDIR)$(INCLUDEDIR)/lz4.h
+ 	@$(INSTALL_DATA) lz4hc.h $(DESTDIR)$(INCLUDEDIR)/lz4hc.h
diff --git a/thirdparty/patches/ncurses-6.0.patch b/thirdparty/patches/ncurses-6.0.patch
deleted file mode 100644
index ac2283dedb7ca6..00000000000000
--- a/thirdparty/patches/ncurses-6.0.patch
+++ /dev/null
@@ -1,12 +0,0 @@
---- ncurses/base/MKlib_gen.sh.orig	2017-05-24 18:17:10.808025407 -0700
-+++ ncurses/base/MKlib_gen.sh	2017-05-24 18:19:59.296032796 -0700
-@@ -72,7 +72,8 @@
- # appears in gcc 5.0 and (with modification) in 5.1, making it necessary to
- # determine if we are using gcc, and if so, what version because the proposed
- # solution uses a nonstandard option.
--PRG=`echo "$1" | $AWK '{ sub(/^[[:space:]]*/,""); sub(/[[:space:]].*$/, ""); print; }' || exit 0`
-+#PRG=`echo "$1" | $AWK '{ sub(/^[[:space:]]*/,""); sub(/[[:space:]].*$/, ""); print; }' || exit 0`
-+PRG=gcc
- FSF=`"$PRG" --version 2>/dev/null || exit 0 | fgrep "Free Software Foundation" | head -n 1`
- ALL=`"$PRG" -dumpversion 2>/dev/null || exit 0`
- ONE=`echo "$ALL" | sed -e 's/\..*$//'`
diff --git a/thirdparty/patches/thrift-0.9.3-aclocal.patch b/thirdparty/patches/thrift-0.9.3-aclocal.patch
new file mode 100644
index 00000000000000..f35663c0470592
--- /dev/null
+++ b/thirdparty/patches/thrift-0.9.3-aclocal.patch
@@ -0,0 +1,11 @@
+--- bootstrap.sh
++++ bootstrap.sh
+@@ -48,7 +48,7 @@ fi
+ 
+ autoscan
+ $LIBTOOLIZE --copy --automake
+-aclocal -I ./aclocal
++aclocal -I ./aclocal -I /usr/share/aclocal
+ autoheader
+ autoconf
+ automake --copy --add-missing --foreign
diff --git a/thirdparty/vars.sh b/thirdparty/vars.sh
index 1a5de32ab677dc..2469a40e751ad0 100644
--- a/thirdparty/vars.sh
+++ b/thirdparty/vars.sh
@@ -28,9 +28,6 @@ PARALLEL=4
 # what you are doing.
 ###################################################
 
-# thirdparty root dir. default is where this script is.
-export TP_DIR=$PALO_HOME/thirdparty
-
 # thirdparties will be downloaded and unpacked here
 export TP_SOURCE_DIR=$TP_DIR/src
 
@@ -55,9 +52,11 @@ export TP_JAR_DIR=$TP_INSTALL_DIR/lib/jar
 #####################################################
 
 # libevent
-LIBEVENT_DOWNLOAD="https://github.com/libevent/libevent/releases/download/release-2.1.8-stable/libevent-2.1.8-stable.tar.gz"
-LIBEVENT_NAME=libevent-2.1.8-stable.tar.gz 
-LIBEVENT_SOURCE=libevent-2.1.8-stable
+# the last release version of libevent is 2.1.8, which was released on 26 Jan 2017, that is too old.
+# so we use the master version of libevent, which is downloaded on 22 Jun 2018, with commit 24236aed01798303745470e6c498bf606e88724a
+LIBEVENT_DOWNLOAD="http://palo-opensource.gz.bcebos.com/libevent-20180622-24236aed01798303745470e6c498bf606e88724a.zip?authorization=bce-auth-v1%2F069fc2786e464e63a5f1183824ddb522%2F2018-06-22T02%3A37%3A48Z%2F-1%2Fhost%2F031b0cc42ab83ca4e0ec3608cba963e95c1ddc46fc70a14457323e2d7960e6ef"
+LIBEVENT_NAME=libevent-20180622-24236aed01798303745470e6c498bf606e88724a.zip
+LIBEVENT_SOURCE=libevent-master
 
 # openssl
 OPENSSL_DOWNLOAD="https://www.openssl.org/source/openssl-1.0.2k.tar.gz"
@@ -85,9 +84,9 @@ COMPILER_RT_NAME=compiler-rt-3.4.src.tar.gz
 COMPILER_RT_SOURCE=compiler-rt-3.4
 
 # protobuf
-PROTOBUF_DOWNLOAD="https://github.com/google/protobuf/releases/download/v2.6.1/protobuf-2.6.1.tar.gz"
-PROTOBUF_NAME=protobuf-2.6.1.tar.gz
-PROTOBUF_SOURCE=protobuf-2.6.1
+PROTOBUF_DOWNLOAD="https://github.com/google/protobuf/archive/v3.5.1.tar.gz"
+PROTOBUF_NAME=protobuf-3.5.1.tar.gz
+PROTOBUF_SOURCE=protobuf-3.5.1
 
 # gflags
 GFLAGS_DOWNLOAD="https://github.com/gflags/gflags/archive/v2.2.0.tar.gz"
@@ -110,9 +109,9 @@ SNAPPY_NAME=snappy-1.1.4.tar.gz
 SNAPPY_SOURCE=snappy-1.1.4
 
 # gperftools
-GPERFTOOLS_DOWNLOAD="https://github.com/gperftools/gperftools/releases/download/gperftools-2.5.93/gperftools-2.5.93.tar.gz"
-GPERFTOOLS_NAME=gperftools-2.5.93.tar.gz
-GPERFTOOLS_SOURCE=gperftools-2.5.93
+GPERFTOOLS_DOWNLOAD="https://github.com/gperftools/gperftools/archive/gperftools-2.7.tar.gz"
+GPERFTOOLS_NAME=gperftools-2.7.tar.gz
+GPERFTOOLS_SOURCE=gperftools-gperftools-2.7
 
 # zlib
 ZLIB_DOWNLOAD="https://sourceforge.net/projects/libpng/files/zlib/1.2.11/zlib-1.2.11.tar.gz"
@@ -179,5 +178,15 @@ BRPC_DOWNLOAD="https://github.com/brpc/brpc/archive/v0.9.0.tar.gz"
 BRPC_NAME=brpc-0.9.0.tar.gz
 BRPC_SOURCE=brpc-0.9.0
 
+# JDK
+JDK_DOWNLOAD="http://mirror.cnop.net/jdk/linux/jdk-8u131-linux-x64.tar.gz"
+JDK_NAME=jdk-8u131-linux-x64.tar.gz
+JDK_SOURCE=jdk1.8.0_131
+
+# ant
+ANT_DOWNLOAD="https://archive.apache.org/dist/ant/binaries/apache-ant-1.7.0-bin.tar.gz"
+ANT_NAME=apache-ant-1.7.0-bin.tar.gz
+ANT_SOURCE=apache-ant-1.7.0
+
 # all thirdparties which need to be downloaded is set in array TP_ARCHIVES
-export TP_ARCHIVES=(LIBEVENT OPENSSL THRIFT LLVM CLANG COMPILER_RT PROTOBUF GFLAGS GLOG GTEST RAPIDJSON SNAPPY GPERFTOOLS ZLIB LZ4 BZIP LZO2 NCURSES CURL RE2 BOOST MYSQL BOOST_FOR_MYSQL LEVELDB BRPC)
+export TP_ARCHIVES="LIBEVENT OPENSSL THRIFT LLVM CLANG COMPILER_RT PROTOBUF GFLAGS GLOG GTEST RAPIDJSON SNAPPY GPERFTOOLS ZLIB LZ4 BZIP LZO2 NCURSES CURL RE2 BOOST MYSQL BOOST_FOR_MYSQL LEVELDB BRPC JDK ANT"