jni-util.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_UTIL_JNI_UTIL_H
#define IMPALA_UTIL_JNI_UTIL_H

#include <jni.h>
#include <string>
#include <vector>

#include "common/status.h"
#include "gen-cpp/Frontend_types.h"

#define THROW_IF_ERROR_WITH_LOGGING(stmt, env, adaptor) \
  do { \
    Status status = (stmt); \
    if (!status.ok()) { \
      (adaptor)->WriteErrorLog(); \
      (adaptor)->WriteFileErrors(); \
      (env)->ThrowNew((adaptor)->impala_exc_cl(), status.GetDetail().c_str()); \
      return; \
    } \
  } while (false)

#define THROW_IF_ERROR(stmt, env, impala_exc_cl) \
  do { \
    Status status = (stmt); \
    if (!status.ok()) { \
      (env)->ThrowNew((impala_exc_cl), status.GetDetail().c_str()); \
      return; \
    } \
  } while (false)

#define THROW_IF_ERROR_RET(stmt, env, impala_exc_cl, ret) \
  do { \
    Status status = (stmt); \
    if (!status.ok()) { \
      (env)->ThrowNew((impala_exc_cl), status.GetDetail().c_str()); \
      return (ret); \
    } \
  } while (false)

#define THROW_IF_EXC(env, exc_class) \
  do { \
    jthrowable exc = (env)->ExceptionOccurred(); \
    if (exc != NULL) { \
      DCHECK((throwable_to_string_id_) != NULL); \
      jstring stack = (jstring) env->CallStaticObjectMethod(JniUtil::jni_util_class(), \
          (JniUtil::throwable_to_stack_trace_id()), exc); \
      jboolean is_copy; \
      const char* c_stack = \
          reinterpret_cast<const char*>((env)->GetStringUTFChars(stack, &is_copy)); \
      (env)->ExceptionClear(); \
      (env)->ThrowNew((exc_class), c_stack); \
      return; \
    } \
  } while (false)

#define RETURN_IF_EXC(env) \
  do { \
    jthrowable exc = (env)->ExceptionOccurred(); \
    if (exc != NULL) { \
      jstring stack = (jstring) env->CallStaticObjectMethod(JniUtil::jni_util_class(), \
          (JniUtil::throwable_to_stack_trace_id()), exc); \
      jboolean is_copy; \
      const char* c_stack = \
          reinterpret_cast<const char*>((env)->GetStringUTFChars(stack, &is_copy)); \
      VLOG(1) << string(c_stack); \
     return; \
    } \
  } while (false)

#define EXIT_IF_EXC(env) \
  do { \
    jthrowable exc = (env)->ExceptionOccurred(); \
    if (exc != NULL) { \
      jstring stack = (jstring) env->CallStaticObjectMethod(JniUtil::jni_util_class(), \
          (JniUtil::throwable_to_stack_trace_id()), exc); \
      jboolean is_copy; \
      const char* c_stack = \
          reinterpret_cast<const char*>((env)->GetStringUTFChars(stack, &is_copy)); \
      LOG(ERROR) << string(c_stack); \
     exit(1); \
    } \
  } while (false)

#define RETURN_ERROR_IF_EXC(env) \
  do { \
    jthrowable exc = (env)->ExceptionOccurred(); \
    if (exc != NULL) return JniUtil::GetJniExceptionMsg(env);\
  } while (false)

#define EXIT_IF_JNIERROR(stmt) \
  do { \
    if ((stmt) != JNI_OK) { \
      cerr << #stmt << " resulted in a jni error"; \
      exit(1); \
    } \
  } while (false)

#define RETURN_IF_JNIERROR(stmt) \
  do { \
    if ((stmt) != JNI_OK) { \
      stringstream out; \
      out << #stmt << " resulted in a jni error";      \
      return Status(out.str()); \
    } \
  } while (false)

extern  "C" { extern JNIEnv* getJNIEnv(void); }

namespace impala {

class Status;

class JniLocalFrame {
 public:
  JniLocalFrame(): env_(NULL) {}
  ~JniLocalFrame() { if (env_ != NULL) env_->PopLocalFrame(NULL); }

  Status push(JNIEnv* env, int max_local_ref=10);

 private:
  JNIEnv* env_;
};

struct JniMethodDescriptor {
  const std::string name;

  const std::string signature;

  jmethodID* method_id;
};

class JniUtil {
 public:
  static void InitLibhdfs();

  static Status Init();

  static bool ClassExists(JNIEnv* env, const char* class_str);

  static Status GetGlobalClassRef(JNIEnv* env, const char* class_str, jclass* class_ref);

  static Status LocalToGlobalRef(JNIEnv* env, jobject local_ref, jobject* global_ref);

  static jmethodID throwable_to_string_id() { return throwable_to_string_id_; }
  static jmethodID throwable_to_stack_trace_id() { return throwable_to_stack_trace_id_; }

  static jclass jni_util_class() { return jni_util_cl_; }

  static jclass internal_exc_class() { return internal_exc_cl_; }

  static Status Cleanup();

  static Status GetJniExceptionMsg(JNIEnv* env, bool log_stack = true,
      const std::string& prefix = "");

  static Status GetJvmMetrics(const TGetJvmMetricsRequest& request,
      TGetJvmMetricsResponse* result);

  static Status LoadJniMethod(JNIEnv* jni_env, const jclass& jni_class,
      JniMethodDescriptor* descriptor);

  template <typename T>
  static Status CallJniMethod(const jobject& obj, const jmethodID& method, const T& arg) {
    JNIEnv* jni_env = getJNIEnv();
    jbyteArray request_bytes;
    JniLocalFrame jni_frame;
    RETURN_IF_ERROR(jni_frame.push(jni_env));
    RETURN_IF_ERROR(SerializeThriftMsg(jni_env, &arg, &request_bytes));
    jni_env->CallObjectMethod(obj, method, request_bytes);
    RETURN_ERROR_IF_EXC(jni_env);
    return Status::OK;
  }

  template <typename R>
  static Status CallJniMethod(const jobject& obj, const jmethodID& method, R* response) {
    JNIEnv* jni_env = getJNIEnv();
    JniLocalFrame jni_frame;
    RETURN_IF_ERROR(jni_frame.push(jni_env));
    jbyteArray result_bytes = static_cast<jbyteArray>(
        jni_env->CallObjectMethod(obj, method));
    RETURN_ERROR_IF_EXC(jni_env);
    RETURN_IF_ERROR(DeserializeThriftMsg(jni_env, result_bytes, response));
    return Status::OK;
  }

  template <typename T, typename R>
  static Status CallJniMethod(const jobject& obj, const jmethodID& method,
      const T& arg, R* response) {
    JNIEnv* jni_env = getJNIEnv();
    jbyteArray request_bytes;
    JniLocalFrame jni_frame;
    RETURN_IF_ERROR(jni_frame.push(jni_env));
    RETURN_IF_ERROR(SerializeThriftMsg(jni_env, &arg, &request_bytes));
    jbyteArray result_bytes = static_cast<jbyteArray>(
        jni_env->CallObjectMethod(obj, method, request_bytes));
    RETURN_ERROR_IF_EXC(jni_env);
    RETURN_IF_ERROR(DeserializeThriftMsg(jni_env, result_bytes, response));
    return Status::OK;
  }

  template <typename T>
  static Status CallJniMethod(const jobject& obj, const jmethodID& method,
      const T& arg, std::string* response) {
    JNIEnv* jni_env = getJNIEnv();
    jbyteArray request_bytes;
    JniLocalFrame jni_frame;
    RETURN_IF_ERROR(jni_frame.push(jni_env));
    RETURN_IF_ERROR(SerializeThriftMsg(jni_env, &arg, &request_bytes));
    jstring java_response_string = static_cast<jstring>(
        jni_env->CallObjectMethod(obj, method, request_bytes));
    RETURN_ERROR_IF_EXC(jni_env);
    jboolean is_copy;
    const char *str = jni_env->GetStringUTFChars(java_response_string, &is_copy);
    RETURN_ERROR_IF_EXC(jni_env);
    *response = str;
    jni_env->ReleaseStringUTFChars(java_response_string, str);
    RETURN_ERROR_IF_EXC(jni_env);
    return Status::OK;
  }

 private:
  static jclass jni_util_cl_;
  static jclass internal_exc_cl_;
  static jmethodID throwable_to_string_id_;
  static jmethodID throwable_to_stack_trace_id_;
  static jmethodID get_jvm_metrics_id_;
  static std::vector<jobject> global_refs_;
};

}

#endif