ceph/src/rocksdb/java/rocksjni/backupenginejni.cc

   1 // Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
   2 //  This source code is licensed under both the GPLv2 (found in the
   3 //  COPYING file in the root directory) and Apache 2.0 License
   4 //  (found in the LICENSE.Apache file in the root directory).
   5 //
   6 // This file implements the "bridge" between Java and C++ and enables
   7 // calling C++ ROCKSDB_NAMESPACE::BackupEngine methods from the Java side.
   8
   9 #include <jni.h>
  10
  11 #include <vector>
  12
  13 #include "include/org_rocksdb_BackupEngine.h"
  14 #include "rocksdb/utilities/backup_engine.h"
  15 #include "rocksjni/cplusplus_to_java_convert.h"
  16 #include "rocksjni/portal.h"
  17
  18 /*
  19  * Class:     org_rocksdb_BackupEngine
  20  * Method:    open
  21  * Signature: (JJ)J
  22  */
  23 jlong Java_org_rocksdb_BackupEngine_open(JNIEnv* env, jclass /*jcls*/,
  24                                          jlong env_handle,
  25                                          jlong backup_engine_options_handle) {
  26   auto* rocks_env = reinterpret_cast<ROCKSDB_NAMESPACE::Env*>(env_handle);
  27   auto* backup_engine_options =
  28       reinterpret_cast<ROCKSDB_NAMESPACE::BackupEngineOptions*>(
  29           backup_engine_options_handle);
  30   ROCKSDB_NAMESPACE::BackupEngine* backup_engine;
  31   auto status = ROCKSDB_NAMESPACE::BackupEngine::Open(
  32       rocks_env, *backup_engine_options, &backup_engine);
  33
  34   if (status.ok()) {
  35     return GET_CPLUSPLUS_POINTER(backup_engine);
  36   } else {
  37     ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env, status);
  38     return 0;
  39   }
  40 }
  41
  42 /*
  43  * Class:     org_rocksdb_BackupEngine
  44  * Method:    createNewBackup
  45  * Signature: (JJZ)V
  46  */
  47 void Java_org_rocksdb_BackupEngine_createNewBackup(
  48     JNIEnv* env, jobject /*jbe*/, jlong jbe_handle, jlong db_handle,
  49     jboolean jflush_before_backup) {
  50   auto* db = reinterpret_cast<ROCKSDB_NAMESPACE::DB*>(db_handle);
  51   auto* backup_engine =
  52       reinterpret_cast<ROCKSDB_NAMESPACE::BackupEngine*>(jbe_handle);
  53   auto status = backup_engine->CreateNewBackup(
  54       db, static_cast<bool>(jflush_before_backup));
  55
  56   if (status.ok()) {
  57     return;
  58   }
  59
  60   ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env, status);
  61 }
  62
  63 /*
  64  * Class:     org_rocksdb_BackupEngine
  65  * Method:    createNewBackupWithMetadata
  66  * Signature: (JJLjava/lang/String;Z)V
  67  */
  68 void Java_org_rocksdb_BackupEngine_createNewBackupWithMetadata(
  69     JNIEnv* env, jobject /*jbe*/, jlong jbe_handle, jlong db_handle,
  70     jstring japp_metadata, jboolean jflush_before_backup) {
  71   auto* db = reinterpret_cast<ROCKSDB_NAMESPACE::DB*>(db_handle);
  72   auto* backup_engine =
  73       reinterpret_cast<ROCKSDB_NAMESPACE::BackupEngine*>(jbe_handle);
  74
  75   jboolean has_exception = JNI_FALSE;
  76   std::string app_metadata = ROCKSDB_NAMESPACE::JniUtil::copyStdString(
  77       env, japp_metadata, &has_exception);
  78   if (has_exception == JNI_TRUE) {
  79     ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(
  80         env, "Could not copy jstring to std::string");
  81     return;
  82   }
  83
  84   auto status = backup_engine->CreateNewBackupWithMetadata(
  85       db, app_metadata, static_cast<bool>(jflush_before_backup));
  86
  87   if (status.ok()) {
  88     return;
  89   }
  90
  91   ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env, status);
  92 }
  93
  94 /*
  95  * Class:     org_rocksdb_BackupEngine
  96  * Method:    getBackupInfo
  97  * Signature: (J)Ljava/util/List;
  98  */
  99 jobject Java_org_rocksdb_BackupEngine_getBackupInfo(JNIEnv* env,
 100                                                     jobject /*jbe*/,
 101                                                     jlong jbe_handle) {
 102   auto* backup_engine =
 103       reinterpret_cast<ROCKSDB_NAMESPACE::BackupEngine*>(jbe_handle);
 104   std::vector<ROCKSDB_NAMESPACE::BackupInfo> backup_infos;
 105   backup_engine->GetBackupInfo(&backup_infos);
 106   return ROCKSDB_NAMESPACE::BackupInfoListJni::getBackupInfo(env, backup_infos);
 107 }
 108
 109 /*
 110  * Class:     org_rocksdb_BackupEngine
 111  * Method:    getCorruptedBackups
 112  * Signature: (J)[I
 113  */
 114 jintArray Java_org_rocksdb_BackupEngine_getCorruptedBackups(JNIEnv* env,
 115                                                             jobject /*jbe*/,
 116                                                             jlong jbe_handle) {
 117   auto* backup_engine =
 118       reinterpret_cast<ROCKSDB_NAMESPACE::BackupEngine*>(jbe_handle);
 119   std::vector<ROCKSDB_NAMESPACE::BackupID> backup_ids;
 120   backup_engine->GetCorruptedBackups(&backup_ids);
 121   // store backupids in int array
 122   std::vector<jint> int_backup_ids(backup_ids.begin(), backup_ids.end());
 123
 124   // Store ints in java array
 125   // Its ok to loose precision here (64->32)
 126   jsize ret_backup_ids_size = static_cast<jsize>(backup_ids.size());
 127   jintArray ret_backup_ids = env->NewIntArray(ret_backup_ids_size);
 128   if (ret_backup_ids == nullptr) {
 129     // exception thrown: OutOfMemoryError
 130     return nullptr;
 131   }
 132   env->SetIntArrayRegion(ret_backup_ids, 0, ret_backup_ids_size,
 133                          int_backup_ids.data());
 134   return ret_backup_ids;
 135 }
 136
 137 /*
 138  * Class:     org_rocksdb_BackupEngine
 139  * Method:    garbageCollect
 140  * Signature: (J)V
 141  */
 142 void Java_org_rocksdb_BackupEngine_garbageCollect(JNIEnv* env, jobject /*jbe*/,
 143                                                   jlong jbe_handle) {
 144   auto* backup_engine =
 145       reinterpret_cast<ROCKSDB_NAMESPACE::BackupEngine*>(jbe_handle);
 146   auto status = backup_engine->GarbageCollect();
 147
 148   if (status.ok()) {
 149     return;
 150   }
 151
 152   ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env, status);
 153 }
 154
 155 /*
 156  * Class:     org_rocksdb_BackupEngine
 157  * Method:    purgeOldBackups
 158  * Signature: (JI)V
 159  */
 160 void Java_org_rocksdb_BackupEngine_purgeOldBackups(JNIEnv* env, jobject /*jbe*/,
 161                                                    jlong jbe_handle,
 162                                                    jint jnum_backups_to_keep) {
 163   auto* backup_engine =
 164       reinterpret_cast<ROCKSDB_NAMESPACE::BackupEngine*>(jbe_handle);
 165   auto status = backup_engine->PurgeOldBackups(
 166       static_cast<uint32_t>(jnum_backups_to_keep));
 167
 168   if (status.ok()) {
 169     return;
 170   }
 171
 172   ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env, status);
 173 }
 174
 175 /*
 176  * Class:     org_rocksdb_BackupEngine
 177  * Method:    deleteBackup
 178  * Signature: (JI)V
 179  */
 180 void Java_org_rocksdb_BackupEngine_deleteBackup(JNIEnv* env, jobject /*jbe*/,
 181                                                 jlong jbe_handle,
 182                                                 jint jbackup_id) {
 183   auto* backup_engine =
 184       reinterpret_cast<ROCKSDB_NAMESPACE::BackupEngine*>(jbe_handle);
 185   auto status = backup_engine->DeleteBackup(
 186       static_cast<ROCKSDB_NAMESPACE::BackupID>(jbackup_id));
 187
 188   if (status.ok()) {
 189     return;
 190   }
 191
 192   ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env, status);
 193 }
 194
 195 /*
 196  * Class:     org_rocksdb_BackupEngine
 197  * Method:    restoreDbFromBackup
 198  * Signature: (JILjava/lang/String;Ljava/lang/String;J)V
 199  */
 200 void Java_org_rocksdb_BackupEngine_restoreDbFromBackup(
 201     JNIEnv* env, jobject /*jbe*/, jlong jbe_handle, jint jbackup_id,
 202     jstring jdb_dir, jstring jwal_dir, jlong jrestore_options_handle) {
 203   auto* backup_engine =
 204       reinterpret_cast<ROCKSDB_NAMESPACE::BackupEngine*>(jbe_handle);
 205   const char* db_dir = env->GetStringUTFChars(jdb_dir, nullptr);
 206   if (db_dir == nullptr) {
 207     // exception thrown: OutOfMemoryError
 208     return;
 209   }
 210   const char* wal_dir = env->GetStringUTFChars(jwal_dir, nullptr);
 211   if (wal_dir == nullptr) {
 212     // exception thrown: OutOfMemoryError
 213     env->ReleaseStringUTFChars(jdb_dir, db_dir);
 214     return;
 215   }
 216   auto* restore_options = reinterpret_cast<ROCKSDB_NAMESPACE::RestoreOptions*>(
 217       jrestore_options_handle);
 218   auto status = backup_engine->RestoreDBFromBackup(
 219       static_cast<ROCKSDB_NAMESPACE::BackupID>(jbackup_id), db_dir, wal_dir,
 220       *restore_options);
 221
 222   env->ReleaseStringUTFChars(jwal_dir, wal_dir);
 223   env->ReleaseStringUTFChars(jdb_dir, db_dir);
 224
 225   if (status.ok()) {
 226     return;
 227   }
 228
 229   ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env, status);
 230 }
 231
 232 /*
 233  * Class:     org_rocksdb_BackupEngine
 234  * Method:    restoreDbFromLatestBackup
 235  * Signature: (JLjava/lang/String;Ljava/lang/String;J)V
 236  */
 237 void Java_org_rocksdb_BackupEngine_restoreDbFromLatestBackup(
 238     JNIEnv* env, jobject /*jbe*/, jlong jbe_handle, jstring jdb_dir,
 239     jstring jwal_dir, jlong jrestore_options_handle) {
 240   auto* backup_engine =
 241       reinterpret_cast<ROCKSDB_NAMESPACE::BackupEngine*>(jbe_handle);
 242   const char* db_dir = env->GetStringUTFChars(jdb_dir, nullptr);
 243   if (db_dir == nullptr) {
 244     // exception thrown: OutOfMemoryError
 245     return;
 246   }
 247   const char* wal_dir = env->GetStringUTFChars(jwal_dir, nullptr);
 248   if (wal_dir == nullptr) {
 249     // exception thrown: OutOfMemoryError
 250     env->ReleaseStringUTFChars(jdb_dir, db_dir);
 251     return;
 252   }
 253   auto* restore_options = reinterpret_cast<ROCKSDB_NAMESPACE::RestoreOptions*>(
 254       jrestore_options_handle);
 255   auto status = backup_engine->RestoreDBFromLatestBackup(db_dir, wal_dir,
 256                                                          *restore_options);
 257
 258   env->ReleaseStringUTFChars(jwal_dir, wal_dir);
 259   env->ReleaseStringUTFChars(jdb_dir, db_dir);
 260
 261   if (status.ok()) {
 262     return;
 263   }
 264
 265   ROCKSDB_NAMESPACE::RocksDBExceptionJni::ThrowNew(env, status);
 266 }
 267
 268 /*
 269  * Class:     org_rocksdb_BackupEngine
 270  * Method:    disposeInternal
 271  * Signature: (J)V
 272  */
 273 void Java_org_rocksdb_BackupEngine_disposeInternal(JNIEnv* /*env*/,
 274                                                    jobject /*jbe*/,
 275                                                    jlong jbe_handle) {
 276   auto* be = reinterpret_cast<ROCKSDB_NAMESPACE::BackupEngine*>(jbe_handle);
 277   assert(be != nullptr);
 278   delete be;
 279 }