// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you 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 IMPALA_RPC_THRIFT_THREAD_H
#define IMPALA_RPC_THRIFT_THREAD_H

#include <thrift/concurrency/Thread.h>

#include "common/logging.h"
#include "util/thread.h"
#include "util/promise.h"

/// This file adds an implementation of Thrift's ThreadFactory and Thread that uses
/// Impala's Thread wrapper class, so that all threads are accounted for by Impala's
/// ThreadManager.
namespace impala {

/// The ThriftThreadFactory is responsible for creating new ThriftThreads to run server
/// tasks on.
class ThriftThreadFactory : public apache::thrift::concurrency::ThreadFactory {
 public:
  /// Group is the thread group for new threads to be assigned to, and prefix is the
  /// per-thread prefix (threads are named "prefix-<count_>-<tid>").
  ThriftThreadFactory(const std::string& group, const std::string& prefix)
      : group_(group), prefix_(prefix), count_(0) { }

  /// (From ThreadFactory) - creates a new ThriftThread to run the supplied Runnable.
  virtual boost::shared_ptr<apache::thrift::concurrency::Thread> newThread(
      boost::shared_ptr<apache::thrift::concurrency::Runnable> runnable) const;

  /// (From ThreadFactory) - returns the *current* thread ID, i.e. the ID of the executing
  /// thread (which may not have been created by this factory).
  virtual apache::thrift::concurrency::Thread::id_t getCurrentThreadId() const;

 private:
  /// Group name for the Impala ThreadManager
  std::string group_;

  /// Thread name prefix for the Impala ThreadManager
  std::string prefix_;

  /// Marked mutable because we want to increment it inside newThread, which for some
  /// reason is const.
  mutable int64_t count_;
};

/// A ThriftThread is a Thrift-compatible wrapper for Impala's Thread class, so that all
/// server threads are registered with the global ThreadManager.
class ThriftThread : public apache::thrift::concurrency::Thread {
 public:
  ThriftThread(const std::string& group, const std::string& name,
      boost::shared_ptr<apache::thrift::concurrency::Runnable> runnable);

  /// (From Thread) - starts execution of the runnable in a separate thread, returning once
  /// execution has begun.
  virtual void start();

  /// Joins the separate thread
  virtual void join();

  /// Returns the Thrift thread ID of the execution thread
  virtual id_t getId();

  virtual ~ThriftThread() { }

 private:
  /// Method executed on impala_thread_. Runs the Runnable once promise has been set to the
  /// current thread ID. The runnable parameter is a shared_ptr so that is always valid
  /// even after the ThriftThread may have been terminated.
  void RunRunnable(boost::shared_ptr<apache::thrift::concurrency::Runnable> runnable,
      Promise<apache::thrift::concurrency::Thread::id_t>* promise);

  /// Impala thread that runs the runnable and registers itself with the global
  /// ThreadManager.
  std::unique_ptr<impala::Thread> impala_thread_;

  /// Thrift thread ID, set by RunRunnable.
  apache::thrift::concurrency::Thread::id_t tid_;

  /// Group name for the Impala ThreadManager
  std::string group_;

  /// Individual thread name for the Impala ThreadManager
  std::string name_;
};

}

#endif