status.h

Go to the documentation of this file.

// Copyright 2012 Cloudera Inc.
//
// 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 IMPALA_COMMON_STATUS_H
#define IMPALA_COMMON_STATUS_H

#include <string>
#include <vector>

#include <boost/lexical_cast.hpp>

#include "common/logging.h"
#include "common/compiler-util.h"
#include "gen-cpp/Status_types.h"  // for TStatus
#include "gen-cpp/ErrorCodes_types.h"  // for TErrorCode
#include "gen-cpp/TCLIService_types.h" // for HS2 TStatus
#include "util/error-util.h" // for ErrorMessage

#define STATUS_API_VERSION 2

namespace impala {

//
//
//
//
//
//
//
//
//
class Status {
 public:
  typedef strings::internal::SubstituteArg ArgType;

  Status(): msg_(NULL) {}

  static const Status OK;
  static const Status CANCELLED;
  static const Status MEM_LIMIT_EXCEEDED;
  static const Status DEPRECATED_RPC;

  Status(const Status& status)
    : msg_(status.msg_ != NULL ? new ErrorMsg(*status.msg_) : NULL) { }

  Status(TErrorCode::type code);

  Status(TErrorCode::type error, const ArgType& arg0);
  Status(TErrorCode::type error, const ArgType& arg0, const ArgType& arg1);
  Status(TErrorCode::type error, const ArgType& arg0, const ArgType& arg1,
      const ArgType& arg2);
  Status(TErrorCode::type error, const ArgType& arg0, const ArgType& arg1,
      const ArgType& arg2, const ArgType& arg3);
  Status(TErrorCode::type error, const ArgType& arg0, const ArgType& arg1,
      const ArgType& arg2, const ArgType& arg3, const ArgType& arg4);
  Status(TErrorCode::type error, const ArgType& arg0, const ArgType& arg1,
      const ArgType& arg2, const ArgType& arg3, const ArgType& arg4,
      const ArgType& arg5);
  Status(TErrorCode::type error, const ArgType& arg0, const ArgType& arg1,
      const ArgType& arg2, const ArgType& arg3, const ArgType& arg4,
      const ArgType& arg5, const ArgType& arg6);
  Status(TErrorCode::type error, const ArgType& arg0, const ArgType& arg1,
      const ArgType& arg2, const ArgType& arg3, const ArgType& arg4,
      const ArgType& arg5, const ArgType& arg6, const ArgType& arg7);
  Status(TErrorCode::type error, const ArgType& arg0, const ArgType& arg1,
      const ArgType& arg2, const ArgType& arg3, const ArgType& arg4,
      const ArgType& arg5, const ArgType& arg6, const ArgType& arg7,
      const ArgType& arg8);
  Status(TErrorCode::type error, const ArgType& arg0, const ArgType& arg1,
      const ArgType& arg2, const ArgType& arg3, const ArgType& arg4,
      const ArgType& arg5, const ArgType& arg6, const ArgType& arg7,
      const ArgType& arg8, const ArgType& arg9);

  Status(const ErrorMsg& e);

  Status(const std::string& error_msg);

  static Status Expected(const std::string& error_msg);

  ~Status() {
    if (msg_ != NULL) delete msg_;
  }

  Status& operator=(const Status& status) {
    delete msg_;
    if (LIKELY(status.msg_ == NULL)) {
      msg_ = NULL;
    } else {
      msg_ = new ErrorMsg(*status.msg_);
    }
    return *this;
  }

  Status(const TStatus& status);

  Status& operator=(const TStatus& status);

  Status(const apache::hive::service::cli::thrift::TStatus& hs2_status);

  Status& operator=(const apache::hive::service::cli::thrift::TStatus& hs2_status);

  bool ok() const { return msg_ == NULL; }

  bool IsCancelled() const {
    return msg_ != NULL && msg_->error() == TErrorCode::CANCELLED;
  }

  bool IsMemLimitExceeded() const {
    return msg_ != NULL
        && msg_->error() == TErrorCode::MEM_LIMIT_EXCEEDED;
  }

  bool IsRecoverableError() const {
    return msg_ != NULL
        && msg_->error() == TErrorCode::RECOVERABLE_ERROR;
  }

  const ErrorMsg& msg() const {
    DCHECK_NOTNULL(msg_);
    return *msg_;
  }

  void SetErrorMsg(const ErrorMsg& m) {
    DCHECK_NOTNULL(msg_);
    delete msg_;
    msg_ = new ErrorMsg(m);
  }

  void AddDetail(const std::string& msg);

  void MergeStatus(const Status& status);

  template <typename T> void SetTStatus(T* status_container) const {
    ToThrift(&status_container->status);
    status_container->__isset.status = true;
  }

  void ToThrift(TStatus* status) const;

  const std::string GetDetail() const;

  TErrorCode::type code() const {
    return msg_ == NULL ? TErrorCode::OK : msg_->error();
  }

 private:

  Status(const std::string& error_msg, bool silent);

  ErrorMsg* msg_;
};

#define RETURN_IF_ERROR(stmt) \
  do { \
    Status __status__ = (stmt); \
    if (UNLIKELY(!__status__.ok())) return __status__; \
  } while (false)

#define EXIT_IF_ERROR(stmt) \
  do { \
    Status __status__ = (stmt); \
    if (UNLIKELY(!__status__.ok())) { \
      EXIT_WITH_ERROR(__status__.GetDetail()); \
    } \
  } while (false)

#define EXIT_WITH_ERROR(msg) \
  do { \
    LOG(ERROR) << msg; \
    exit(1); \
  } while (false)

}

#endif