2014-04-18 02:28:51 +02:00
|
|
|
// Copyright (c) 2014, Facebook, Inc. All rights reserved.
|
|
|
|
// This source code is licensed under the BSD-style license found in the
|
|
|
|
// LICENSE file in the root directory of this source tree. An additional grant
|
|
|
|
// of patent rights can be found in the PATENTS file in the same directory.
|
|
|
|
//
|
|
|
|
// This file implements the "bridge" between Java and C++ and enables
|
2014-05-14 07:22:21 +02:00
|
|
|
// calling c++ rocksdb::BackupableDB and rocksdb::BackupableDBOptions methods
|
|
|
|
// from Java side.
|
2014-04-18 02:28:51 +02:00
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <jni.h>
|
|
|
|
#include <string>
|
2014-10-26 23:23:06 +01:00
|
|
|
#include <vector>
|
2014-04-18 02:28:51 +02:00
|
|
|
|
|
|
|
#include "include/org_rocksdb_BackupableDB.h"
|
|
|
|
#include "include/org_rocksdb_BackupableDBOptions.h"
|
|
|
|
#include "rocksjni/portal.h"
|
2014-07-23 20:15:14 +02:00
|
|
|
#include "rocksdb/utilities/backupable_db.h"
|
2014-04-18 02:28:51 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Class: org_rocksdb_BackupableDB
|
|
|
|
* Method: open
|
|
|
|
* Signature: (JJ)V
|
|
|
|
*/
|
|
|
|
void Java_org_rocksdb_BackupableDB_open(
|
|
|
|
JNIEnv* env, jobject jbdb, jlong jdb_handle, jlong jopt_handle) {
|
|
|
|
auto db = reinterpret_cast<rocksdb::DB*>(jdb_handle);
|
|
|
|
auto opt = reinterpret_cast<rocksdb::BackupableDBOptions*>(jopt_handle);
|
|
|
|
auto bdb = new rocksdb::BackupableDB(db, *opt);
|
|
|
|
|
|
|
|
// as BackupableDB extends RocksDB on the java side, we can reuse
|
|
|
|
// the RocksDB portal here.
|
|
|
|
rocksdb::RocksDBJni::setHandle(env, jbdb, bdb);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Class: org_rocksdb_BackupableDB
|
|
|
|
* Method: createNewBackup
|
|
|
|
* Signature: (JZ)V
|
|
|
|
*/
|
|
|
|
void Java_org_rocksdb_BackupableDB_createNewBackup(
|
|
|
|
JNIEnv* env, jobject jbdb, jlong jhandle, jboolean jflag) {
|
2014-08-14 19:58:09 +02:00
|
|
|
rocksdb::Status s =
|
|
|
|
reinterpret_cast<rocksdb::BackupableDB*>(jhandle)->CreateNewBackup(jflag);
|
|
|
|
if (!s.ok()) {
|
|
|
|
rocksdb::RocksDBExceptionJni::ThrowNew(env, s);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Class: org_rocksdb_BackupableDB
|
|
|
|
* Method: purgeOldBackups
|
|
|
|
* Signature: (JI)V
|
|
|
|
*/
|
|
|
|
void Java_org_rocksdb_BackupableDB_purgeOldBackups(
|
2014-10-26 23:23:06 +01:00
|
|
|
JNIEnv* env, jobject jbdb, jlong jhandle, jint jnumBackupsToKeep) {
|
2014-08-14 19:58:09 +02:00
|
|
|
rocksdb::Status s =
|
|
|
|
reinterpret_cast<rocksdb::BackupableDB*>(jhandle)->
|
|
|
|
PurgeOldBackups(jnumBackupsToKeep);
|
|
|
|
if (!s.ok()) {
|
|
|
|
rocksdb::RocksDBExceptionJni::ThrowNew(env, s);
|
|
|
|
}
|
2014-04-18 02:28:51 +02:00
|
|
|
}
|
|
|
|
|
2014-10-26 23:23:06 +01:00
|
|
|
/*
|
|
|
|
* Class: org_rocksdb_BackupableDB
|
|
|
|
* Method: deleteBackup0
|
2014-10-28 18:42:30 +01:00
|
|
|
* Signature: (JI)V
|
2014-10-26 23:23:06 +01:00
|
|
|
*/
|
|
|
|
void Java_org_rocksdb_BackupableDB_deleteBackup0(JNIEnv* env,
|
2014-10-28 18:42:30 +01:00
|
|
|
jobject jobj, jlong jhandle, jint jbackup_id) {
|
2014-10-26 23:23:06 +01:00
|
|
|
auto rdb = reinterpret_cast<rocksdb::BackupableDB*>(jhandle);
|
|
|
|
rocksdb::Status s = rdb->DeleteBackup(jbackup_id);
|
|
|
|
|
|
|
|
if (!s.ok()) {
|
|
|
|
rocksdb::RocksDBExceptionJni::ThrowNew(env, s);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Class: org_rocksdb_BackupableDB
|
|
|
|
* Method: getBackupInfo
|
|
|
|
* Signature: (J)Ljava/util/List;
|
|
|
|
*/
|
|
|
|
jobject Java_org_rocksdb_BackupableDB_getBackupInfo(
|
|
|
|
JNIEnv* env, jobject jbdb, jlong jhandle) {
|
|
|
|
std::vector<rocksdb::BackupInfo> backup_infos;
|
|
|
|
reinterpret_cast<rocksdb::BackupableDB*>(jhandle)->
|
|
|
|
GetBackupInfo(&backup_infos);
|
|
|
|
return rocksdb::BackupInfoListJni::getBackupInfo(env,
|
|
|
|
backup_infos);
|
|
|
|
}
|
|
|
|
|
2014-11-15 23:42:03 +01:00
|
|
|
/*
|
|
|
|
* Class: org_rocksdb_BackupableDB
|
|
|
|
* Method: getCorruptedBackups
|
2014-11-20 22:47:48 +01:00
|
|
|
* Signature: (J)[I;
|
2014-11-15 23:42:03 +01:00
|
|
|
*/
|
2014-11-20 22:47:48 +01:00
|
|
|
jintArray Java_org_rocksdb_BackupableDB_getCorruptedBackups(
|
2014-11-15 23:42:03 +01:00
|
|
|
JNIEnv* env, jobject jbdb, jlong jhandle) {
|
|
|
|
std::vector<rocksdb::BackupID> backup_ids;
|
|
|
|
reinterpret_cast<rocksdb::BackupableDB*>(jhandle)->
|
|
|
|
GetCorruptedBackups(&backup_ids);
|
2014-11-20 22:47:48 +01:00
|
|
|
// store backupids in int array
|
|
|
|
const int kIdSize = backup_ids.size();
|
|
|
|
int int_backup_ids[kIdSize];
|
2014-11-15 23:42:03 +01:00
|
|
|
for (std::vector<rocksdb::BackupID>::size_type i = 0;
|
|
|
|
i != backup_ids.size(); i++) {
|
2014-11-20 22:47:48 +01:00
|
|
|
int_backup_ids[i] = backup_ids[i];
|
2014-11-15 23:42:03 +01:00
|
|
|
}
|
2014-11-20 22:47:48 +01:00
|
|
|
// Store ints in java array
|
|
|
|
jintArray ret_backup_ids;
|
|
|
|
ret_backup_ids = env->NewIntArray(kIdSize);
|
|
|
|
env->SetIntArrayRegion(ret_backup_ids, 0, kIdSize, int_backup_ids);
|
|
|
|
return ret_backup_ids;
|
2014-11-15 23:42:03 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Class: org_rocksdb_BackupableDB
|
|
|
|
* Method: garbageCollect
|
|
|
|
* Signature: (J)V
|
|
|
|
*/
|
|
|
|
void Java_org_rocksdb_BackupableDB_garbageCollect(JNIEnv* env,
|
|
|
|
jobject jobj, jlong jhandle) {
|
|
|
|
auto db = reinterpret_cast<rocksdb::BackupableDB*>(jhandle);
|
|
|
|
rocksdb::Status s = db->GarbageCollect();
|
|
|
|
|
|
|
|
if (!s.ok()) {
|
|
|
|
rocksdb::RocksDBExceptionJni::ThrowNew(env, s);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-18 02:28:51 +02:00
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
// BackupDBOptions
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Class: org_rocksdb_BackupableDBOptions
|
|
|
|
* Method: newBackupableDBOptions
|
|
|
|
* Signature: (Ljava/lang/String;)V
|
|
|
|
*/
|
|
|
|
void Java_org_rocksdb_BackupableDBOptions_newBackupableDBOptions(
|
2014-11-15 23:03:32 +01:00
|
|
|
JNIEnv* env, jobject jobj, jstring jpath) {
|
2014-04-18 02:28:51 +02:00
|
|
|
const char* cpath = env->GetStringUTFChars(jpath, 0);
|
2014-11-15 23:03:32 +01:00
|
|
|
auto bopt = new rocksdb::BackupableDBOptions(cpath);
|
2014-04-18 02:28:51 +02:00
|
|
|
env->ReleaseStringUTFChars(jpath, cpath);
|
|
|
|
rocksdb::BackupableDBOptionsJni::setHandle(env, jobj, bopt);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Class: org_rocksdb_BackupableDBOptions
|
|
|
|
* Method: backupDir
|
|
|
|
* Signature: (J)Ljava/lang/String;
|
|
|
|
*/
|
|
|
|
jstring Java_org_rocksdb_BackupableDBOptions_backupDir(
|
2014-11-07 14:38:21 +01:00
|
|
|
JNIEnv* env, jobject jopt, jlong jhandle) {
|
2014-04-18 02:28:51 +02:00
|
|
|
auto bopt = reinterpret_cast<rocksdb::BackupableDBOptions*>(jhandle);
|
|
|
|
return env->NewStringUTF(bopt->backup_dir.c_str());
|
|
|
|
}
|
|
|
|
|
2014-11-15 23:03:32 +01:00
|
|
|
/*
|
|
|
|
* Class: org_rocksdb_BackupableDBOptions
|
|
|
|
* Method: setShareTableFiles
|
|
|
|
* Signature: (JZ)V
|
|
|
|
*/
|
|
|
|
void Java_org_rocksdb_BackupableDBOptions_setShareTableFiles(
|
|
|
|
JNIEnv* env, jobject jobj, jlong jhandle, jboolean flag) {
|
|
|
|
auto bopt = reinterpret_cast<rocksdb::BackupableDBOptions*>(jhandle);
|
|
|
|
bopt->share_table_files = flag;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Class: org_rocksdb_BackupableDBOptions
|
|
|
|
* Method: shareTableFiles
|
|
|
|
* Signature: (J)Z
|
|
|
|
*/
|
|
|
|
jboolean Java_org_rocksdb_BackupableDBOptions_shareTableFiles(
|
|
|
|
JNIEnv* env, jobject jobj, jlong jhandle) {
|
|
|
|
auto bopt = reinterpret_cast<rocksdb::BackupableDBOptions*>(jhandle);
|
|
|
|
return bopt->share_table_files;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Class: org_rocksdb_BackupableDBOptions
|
|
|
|
* Method: setSync
|
|
|
|
* Signature: (JZ)V
|
|
|
|
*/
|
|
|
|
void Java_org_rocksdb_BackupableDBOptions_setSync(
|
|
|
|
JNIEnv* env, jobject jobj, jlong jhandle, jboolean flag) {
|
|
|
|
auto bopt = reinterpret_cast<rocksdb::BackupableDBOptions*>(jhandle);
|
|
|
|
bopt->sync = flag;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Class: org_rocksdb_BackupableDBOptions
|
|
|
|
* Method: sync
|
|
|
|
* Signature: (J)Z
|
|
|
|
*/
|
|
|
|
jboolean Java_org_rocksdb_BackupableDBOptions_sync(
|
|
|
|
JNIEnv* env, jobject jobj, jlong jhandle) {
|
|
|
|
auto bopt = reinterpret_cast<rocksdb::BackupableDBOptions*>(jhandle);
|
|
|
|
return bopt->sync;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2014-11-16 14:52:53 +01:00
|
|
|
* Class: org_rocksdb_BackupableDBOptions
|
|
|
|
* Method: setDestroyOldData
|
|
|
|
* Signature: (JZ)V
|
|
|
|
*/
|
|
|
|
void Java_org_rocksdb_BackupableDBOptions_setDestroyOldData(
|
|
|
|
JNIEnv* env, jobject jobj, jlong jhandle, jboolean flag) {
|
|
|
|
auto bopt = reinterpret_cast<rocksdb::BackupableDBOptions*>(jhandle);
|
|
|
|
bopt->destroy_old_data = flag;
|
|
|
|
}
|
2014-11-15 23:03:32 +01:00
|
|
|
|
2014-11-16 14:52:53 +01:00
|
|
|
/*
|
|
|
|
* Class: org_rocksdb_BackupableDBOptions
|
|
|
|
* Method: destroyOldData
|
|
|
|
* Signature: (J)Z
|
|
|
|
*/
|
|
|
|
jboolean Java_org_rocksdb_BackupableDBOptions_destroyOldData(
|
|
|
|
JNIEnv* env, jobject jobj, jlong jhandle) {
|
|
|
|
auto bopt = reinterpret_cast<rocksdb::BackupableDBOptions*>(jhandle);
|
|
|
|
return bopt->destroy_old_data;
|
|
|
|
}
|
2014-11-15 23:03:32 +01:00
|
|
|
|
2014-11-16 14:52:53 +01:00
|
|
|
/*
|
|
|
|
* Class: org_rocksdb_BackupableDBOptions
|
|
|
|
* Method: setBackupLogFiles
|
|
|
|
* Signature: (JZ)V
|
|
|
|
*/
|
|
|
|
void Java_org_rocksdb_BackupableDBOptions_setBackupLogFiles(
|
|
|
|
JNIEnv* env, jobject jobj, jlong jhandle, jboolean flag) {
|
|
|
|
auto bopt = reinterpret_cast<rocksdb::BackupableDBOptions*>(jhandle);
|
|
|
|
bopt->backup_log_files = flag;
|
|
|
|
}
|
2014-11-15 23:03:32 +01:00
|
|
|
|
2014-11-16 14:52:53 +01:00
|
|
|
/*
|
|
|
|
* Class: org_rocksdb_BackupableDBOptions
|
|
|
|
* Method: backupLogFiles
|
|
|
|
* Signature: (J)Z
|
|
|
|
*/
|
|
|
|
jboolean Java_org_rocksdb_BackupableDBOptions_backupLogFiles(
|
|
|
|
JNIEnv* env, jobject jobj, jlong jhandle) {
|
|
|
|
auto bopt = reinterpret_cast<rocksdb::BackupableDBOptions*>(jhandle);
|
|
|
|
return bopt->backup_log_files;
|
|
|
|
}
|
2014-11-15 23:03:32 +01:00
|
|
|
|
2014-11-16 14:52:53 +01:00
|
|
|
/*
|
|
|
|
* Class: org_rocksdb_BackupableDBOptions
|
|
|
|
* Method: setBackupRateLimit
|
|
|
|
* Signature: (JJ)V
|
|
|
|
*/
|
|
|
|
void Java_org_rocksdb_BackupableDBOptions_setBackupRateLimit(
|
|
|
|
JNIEnv* env, jobject jobj, jlong jhandle, jlong jbackup_rate_limit) {
|
|
|
|
auto bopt = reinterpret_cast<rocksdb::BackupableDBOptions*>(jhandle);
|
|
|
|
bopt->backup_rate_limit = jbackup_rate_limit;
|
|
|
|
}
|
2014-11-15 23:03:32 +01:00
|
|
|
|
2014-11-16 14:52:53 +01:00
|
|
|
/*
|
|
|
|
* Class: org_rocksdb_BackupableDBOptions
|
|
|
|
* Method: backupRateLimit
|
|
|
|
* Signature: (J)J
|
|
|
|
*/
|
|
|
|
jlong Java_org_rocksdb_BackupableDBOptions_backupRateLimit(
|
|
|
|
JNIEnv* env, jobject jobj, jlong jhandle) {
|
|
|
|
auto bopt = reinterpret_cast<rocksdb::BackupableDBOptions*>(jhandle);
|
|
|
|
return bopt->backup_rate_limit;
|
|
|
|
}
|
2014-11-15 23:03:32 +01:00
|
|
|
|
2014-11-16 14:52:53 +01:00
|
|
|
/*
|
|
|
|
* Class: org_rocksdb_BackupableDBOptions
|
|
|
|
* Method: setRestoreRateLimit
|
|
|
|
* Signature: (JJ)V
|
|
|
|
*/
|
|
|
|
void Java_org_rocksdb_BackupableDBOptions_setRestoreRateLimit(
|
|
|
|
JNIEnv* env, jobject jobj, jlong jhandle, jlong jrestore_rate_limit) {
|
|
|
|
auto bopt = reinterpret_cast<rocksdb::BackupableDBOptions*>(jhandle);
|
|
|
|
bopt->restore_rate_limit = jrestore_rate_limit;
|
|
|
|
}
|
2014-11-15 23:03:32 +01:00
|
|
|
|
2014-11-16 14:52:53 +01:00
|
|
|
/*
|
|
|
|
* Class: org_rocksdb_BackupableDBOptions
|
|
|
|
* Method: restoreRateLimit
|
|
|
|
* Signature: (J)J
|
|
|
|
*/
|
|
|
|
jlong Java_org_rocksdb_BackupableDBOptions_restoreRateLimit(
|
|
|
|
JNIEnv* env, jobject jobj, jlong jhandle) {
|
|
|
|
auto bopt = reinterpret_cast<rocksdb::BackupableDBOptions*>(jhandle);
|
|
|
|
return bopt->restore_rate_limit;
|
|
|
|
}
|
2014-11-15 23:03:32 +01:00
|
|
|
|
2014-11-16 14:52:53 +01:00
|
|
|
/*
|
|
|
|
* Class: org_rocksdb_BackupableDBOptions
|
|
|
|
* Method: setShareFilesWithChecksum
|
|
|
|
* Signature: (JZ)V
|
|
|
|
*/
|
|
|
|
void Java_org_rocksdb_BackupableDBOptions_setShareFilesWithChecksum(
|
|
|
|
JNIEnv* env, jobject jobj, jlong jhandle, jboolean flag) {
|
|
|
|
auto bopt = reinterpret_cast<rocksdb::BackupableDBOptions*>(jhandle);
|
|
|
|
bopt->share_files_with_checksum = flag;
|
|
|
|
}
|
2014-11-15 23:03:32 +01:00
|
|
|
|
2014-11-16 14:52:53 +01:00
|
|
|
/*
|
|
|
|
* Class: org_rocksdb_BackupableDBOptions
|
|
|
|
* Method: shareFilesWithChecksum
|
|
|
|
* Signature: (J)Z
|
|
|
|
*/
|
|
|
|
jboolean Java_org_rocksdb_BackupableDBOptions_shareFilesWithChecksum(
|
|
|
|
JNIEnv* env, jobject jobj, jlong jhandle) {
|
|
|
|
auto bopt = reinterpret_cast<rocksdb::BackupableDBOptions*>(jhandle);
|
|
|
|
return bopt->share_files_with_checksum;
|
|
|
|
}
|
2014-11-15 23:03:32 +01:00
|
|
|
|
2014-04-18 02:28:51 +02:00
|
|
|
/*
|
|
|
|
* Class: org_rocksdb_BackupableDBOptions
|
[Java] Generalize dis-own native handle and refine dispose framework.
Summary:
1. Move disOwnNativeHandle() function from RocksDB to RocksObject
to allow other RocksObject to use disOwnNativeHandle() when its
ownership of native handle has been transferred.
2. RocksObject now has an abstract implementation of dispose(),
which does the following two things. First, it checks whether
both isOwningNativeHandle() and isInitialized() return true.
If so, it will call the protected abstract function dispose0(),
which all the subclasses of RocksObject should implement. Second,
it sets nativeHandle_ = 0. This redesign ensure all subclasses
of RocksObject have the same dispose behavior.
3. All subclasses of RocksObject now should implement dispose0()
instead of dispose(), and dispose0() will be called only when
isInitialized() returns true.
Test Plan:
make rocksdbjava
make jtest
Reviewers: dhruba, sdong, ankgup87, rsumbaly, swapnilghike, zzbennett, haobo
Reviewed By: haobo
Subscribers: leveldb
Differential Revision: https://reviews.facebook.net/D18801
2014-05-29 03:16:29 +02:00
|
|
|
* Method: disposeInternal
|
2014-04-18 02:28:51 +02:00
|
|
|
* Signature: (J)V
|
|
|
|
*/
|
[Java] Generalize dis-own native handle and refine dispose framework.
Summary:
1. Move disOwnNativeHandle() function from RocksDB to RocksObject
to allow other RocksObject to use disOwnNativeHandle() when its
ownership of native handle has been transferred.
2. RocksObject now has an abstract implementation of dispose(),
which does the following two things. First, it checks whether
both isOwningNativeHandle() and isInitialized() return true.
If so, it will call the protected abstract function dispose0(),
which all the subclasses of RocksObject should implement. Second,
it sets nativeHandle_ = 0. This redesign ensure all subclasses
of RocksObject have the same dispose behavior.
3. All subclasses of RocksObject now should implement dispose0()
instead of dispose(), and dispose0() will be called only when
isInitialized() returns true.
Test Plan:
make rocksdbjava
make jtest
Reviewers: dhruba, sdong, ankgup87, rsumbaly, swapnilghike, zzbennett, haobo
Reviewed By: haobo
Subscribers: leveldb
Differential Revision: https://reviews.facebook.net/D18801
2014-05-29 03:16:29 +02:00
|
|
|
void Java_org_rocksdb_BackupableDBOptions_disposeInternal(
|
2014-04-18 02:28:51 +02:00
|
|
|
JNIEnv* env, jobject jopt, jlong jhandle) {
|
|
|
|
auto bopt = reinterpret_cast<rocksdb::BackupableDBOptions*>(jhandle);
|
|
|
|
assert(bopt);
|
|
|
|
delete bopt;
|
|
|
|
rocksdb::BackupableDBOptionsJni::setHandle(env, jopt, nullptr);
|
|
|
|
}
|