NextGraph
/
rocksdb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove orphaned Java classes

Browse Source 
Summary:
Remove orphaned Java classes that were missed from commit 9385fd7
Closes https://github.com/facebook/rocksdb/issues/2210
Closes https://github.com/facebook/rocksdb/pull/2212

Differential Revision: D4986199

Pulled By: maysamyabandeh

fbshipit-source-id: 74e866cd8661c172a4754c2c945e30d650f6fa05
main
Adam Retter 8 years ago committed by Facebook Github Bot
parent 5e2ebf2bdc
commit 498693cf3e
10 changed files with 13 additions and 341 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 2
      java/CMakeLists.txt
  2. 2
      java/rocksjni/backupablejni.cc
  3. 2
      java/rocksjni/env_options.cc
  4. 2
      java/rocksjni/external_sst_file_info.cc
  5. 2
      java/rocksjni/restorejni.cc
  6. 2
      java/rocksjni/sst_file_writerjni.cc
  7. 5
      java/src/main/java/org/rocksdb/BackupInfo.java
  8. 167
      java/src/main/java/org/rocksdb/BackupableDB.java
  9. 12
      java/src/main/java/org/rocksdb/BackupableDBOptions.java
  10. 158
      java/src/main/java/org/rocksdb/RestoreBackupableDB.java

2
java/CMakeLists.txt
Unescape View File

@ -48,7 +48,6 @@ set(NATIVE_JAVA_CLASSES
org.rocksdb.AbstractRocksIterator org.rocksdb.AbstractRocksIterator
org.rocksdb.AbstractSlice org.rocksdb.AbstractSlice
org.rocksdb.AbstractWriteBatch org.rocksdb.AbstractWriteBatch
org.rocksdb.BackupableDB
org.rocksdb.BackupableDBOptions org.rocksdb.BackupableDBOptions
org.rocksdb.BackupEngine org.rocksdb.BackupEngine
org.rocksdb.BackupEngineTest org.rocksdb.BackupEngineTest
@ -84,7 +83,6 @@ set(NATIVE_JAVA_CLASSES
org.rocksdb.RateLimiter org.rocksdb.RateLimiter
org.rocksdb.ReadOptions org.rocksdb.ReadOptions
org.rocksdb.RemoveEmptyValueCompactionFilter org.rocksdb.RemoveEmptyValueCompactionFilter
org.rocksdb.RestoreBackupableDB
org.rocksdb.RestoreOptions org.rocksdb.RestoreOptions
org.rocksdb.RocksDB org.rocksdb.RocksDB
org.rocksdb.RocksDBExceptionTest org.rocksdb.RocksDBExceptionTest

2
java/rocksjni/backupablejni.cc
Unescape View File

@ -4,7 +4,7 @@
// of patent rights can be found in the PATENTS file in the same directory. // 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 // This file implements the "bridge" between Java and C++ and enables
// calling c++ rocksdb::BackupableDB and rocksdb::BackupableDBOptions methods // calling c++ rocksdb::BackupEnginge and rocksdb::BackupableDBOptions methods
// from Java side. // from Java side.
#include <stdio.h> #include <stdio.h>

2
java/rocksjni/env_options.cc
Unescape View File

@ -4,7 +4,7 @@
// of patent rights can be found in the PATENTS file in the same directory. // 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 // This file implements the "bridge" between Java and C++ and enables
// calling c++ rocksdb::BackupableDB and rocksdb::BackupableDBOptions methods // calling C++ rocksdb::EnvOptions methods
// from Java side. // from Java side.
#include <jni.h> #include <jni.h>

2
java/rocksjni/external_sst_file_info.cc
Unescape View File

@ -4,7 +4,7 @@
// of patent rights can be found in the PATENTS file in the same directory. // 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 // This file implements the "bridge" between Java and C++ and enables
// calling c++ rocksdb::BackupableDB and rocksdb::BackupableDBOptions methods // calling C++ rocksdb::ExternalSstFileInfo methods
// from Java side. // from Java side.
#include <jni.h> #include <jni.h>

2
java/rocksjni/restorejni.cc
Unescape View File

@ -4,7 +4,7 @@
// of patent rights can be found in the PATENTS file in the same directory. // 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 // This file implements the "bridge" between Java and C++ and enables
// calling c++ rocksdb::RestoreBackupableDB and rocksdb::RestoreOptions methods // calling C++ rocksdb::RestoreOptions methods
// from Java side. // from Java side.
#include <stdio.h> #include <stdio.h>

2
java/rocksjni/sst_file_writerjni.cc
Unescape View File

@ -4,7 +4,7 @@
// of patent rights can be found in the PATENTS file in the same directory. // 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 // This file implements the "bridge" between Java and C++ and enables
// calling c++ rocksdb::BackupableDB and rocksdb::BackupableDBOptions methods // calling C++ rocksdb::SstFileWriter methods
// from Java side. // from Java side.
#include <jni.h> #include <jni.h>

5
java/src/main/java/org/rocksdb/BackupInfo.java
Unescape View File

@ -6,14 +6,13 @@ package org.rocksdb;
/** /**
* Instances of this class describe a Backup made by * Instances of this class describe a Backup made by
* {@link org.rocksdb.BackupableDB}. * {@link org.rocksdb.BackupEngine}.
*/ */
public class BackupInfo { public class BackupInfo {
/** /**
* Package private constructor used to create instances * Package private constructor used to create instances
* of BackupInfo by {@link org.rocksdb.BackupableDB} and * of BackupInfo by {@link org.rocksdb.BackupEngine}
* {@link org.rocksdb.RestoreBackupableDB}.
* *
* @param backupId id of backup * @param backupId id of backup
* @param timestamp timestamp of backup * @param timestamp timestamp of backup

167
java/src/main/java/org/rocksdb/BackupableDB.java
Unescape View File

@ -1,167 +0,0 @@
// Copyright (c) 2011-present, 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.
package org.rocksdb;
import java.util.List;
/**
* <p>A subclass of RocksDB which supports
* backup-related operations.</p>
*
* @see org.rocksdb.BackupableDBOptions
*/
public class BackupableDB extends RocksDB {
/**
* <p>Open a {@code BackupableDB} under the specified path.
* Note that the backup path should be set properly in the
* input BackupableDBOptions.</p>
*
* @param opt {@link org.rocksdb.Options} to set for the database.
* @param bopt {@link org.rocksdb.BackupableDBOptions} to use.
* @param db_path Path to store data to. The path for storing the backup
* should be specified in the {@link org.rocksdb.BackupableDBOptions}.
*
* @return {@link BackupableDB} reference to the opened database.
*
* @throws RocksDBException thrown if error happens in underlying
* native library.
*/
public static BackupableDB open(
final Options opt, final BackupableDBOptions bopt, final String db_path)
throws RocksDBException {
final RocksDB db = RocksDB.open(opt, db_path);
final BackupableDB bdb = new BackupableDB(open(db.nativeHandle_,
bopt.nativeHandle_));
// Prevent the RocksDB object from attempting to delete
// the underly C++ DB object.
db.disOwnNativeHandle();
return bdb;
}
/**
* <p>Captures the state of the database in the latest backup.
* Note that this function is not thread-safe.</p>
*
* @param flushBeforeBackup if true, then all data will be flushed
* before creating backup.
*
* @throws RocksDBException thrown if error happens in underlying
* native library.
*/
public void createNewBackup(final boolean flushBeforeBackup)
throws RocksDBException {
assert(isOwningHandle());
createNewBackup(nativeHandle_, flushBeforeBackup);
}
/**
* <p>Deletes old backups, keeping latest numBackupsToKeep alive.</p>
*
* @param numBackupsToKeep Number of latest backups to keep.
*
* @throws RocksDBException thrown if error happens in underlying
* native library.
*/
public void purgeOldBackups(final int numBackupsToKeep)
throws RocksDBException {
assert(isOwningHandle());
purgeOldBackups(nativeHandle_, numBackupsToKeep);
}
/**
* <p>Deletes a specific backup.</p>
*
* @param backupId of backup to delete.
*
* @throws RocksDBException thrown if error happens in underlying
* native library.
*/
public void deleteBackup(final int backupId) throws RocksDBException {
assert(isOwningHandle());
deleteBackup0(nativeHandle_, backupId);
}
/**
* <p>Returns a list of {@link BackupInfo} instances, which describe
* already made backups.</p>
*
* @return List of {@link BackupInfo} instances.
*/
public List<BackupInfo> getBackupInfos() {
assert(isOwningHandle());
return getBackupInfo(nativeHandle_);
}
/**
* <p>Returns a list of corrupted backup ids. If there
* is no corrupted backup the method will return an
* empty list.</p>
*
* @return array of backup ids as int ids.
*/
public int[] getCorruptedBackups() {
assert(isOwningHandle());
return getCorruptedBackups(nativeHandle_);
}
/**
* <p>Will delete all the files we don't need anymore. It will
* do the full scan of the files/ directory and delete all the
* files that are not referenced.</p>
*
* @throws RocksDBException thrown if error happens in underlying
* native library.
*/
public void garbageCollect() throws RocksDBException {
assert(isOwningHandle());
garbageCollect(nativeHandle_);
}
/**
* <p>Close the BackupableDB instance and release resource.</p>
*
* <p>Internally, {@link BackupableDB} owns the {@code rocksdb::DB}
* pointer to its associated {@link org.rocksdb.RocksDB}.
* The release of that RocksDB pointer is handled in the destructor
* of the c++ {@code rocksdb::BackupableDB} and should be transparent
* to Java developers.</p>
*/
@Override public void close() {
super.close();
}
/**
* <p>A protected construction that will be used in the static
* factory method {@link #open(Options, BackupableDBOptions, String)}.
* </p>
*
* @param nativeHandle The native handle of the C++ BackupableDB object
*/
protected BackupableDB(final long nativeHandle) {
super(nativeHandle);
}
@Override protected void finalize() throws Throwable {
close();
super.finalize();
}
protected native static long open(final long rocksDBHandle,
final long backupDBOptionsHandle);
protected native void createNewBackup(long handle, boolean flag)
throws RocksDBException;
protected native void purgeOldBackups(long handle, int numBackupsToKeep)
throws RocksDBException;
private native void deleteBackup0(long nativeHandle, int backupId)
throws RocksDBException;
protected native List<BackupInfo> getBackupInfo(long handle);
private native int[] getCorruptedBackups(long handle);
private native void garbageCollect(long handle)
throws RocksDBException;
}

12
java/src/main/java/org/rocksdb/BackupableDBOptions.java
Unescape View File

@ -9,12 +9,12 @@ import java.io.File;
/** /**
* <p>BackupableDBOptions to control the behavior of a backupable database. * <p>BackupableDBOptions to control the behavior of a backupable database.
* It will be used during the creation of a {@link org.rocksdb.BackupableDB}. * It will be used during the creation of a {@link org.rocksdb.BackupEngine}.
* </p> * </p>
* <p>Note that dispose() must be called before an Options instance * <p>Note that dispose() must be called before an Options instance
* become out-of-scope to release the allocated memory in c++.</p> * become out-of-scope to release the allocated memory in c++.</p>
* *
* @see org.rocksdb.BackupableDB * @see org.rocksdb.BackupEngine
*/ */
public class BackupableDBOptions extends RocksObject { public class BackupableDBOptions extends RocksObject {
@ -375,8 +375,8 @@ public class BackupableDBOptions extends RocksObject {
/** /**
* Up to this many background threads will copy files for * Up to this many background threads will copy files for
* {@link BackupableDB#createNewBackup(boolean)} and * {@link BackupEngine#createNewBackup(RocksDB, boolean)} and
* {@link RestoreBackupableDB#restoreDBFromBackup(long, String, String, RestoreOptions)} * {@link BackupEngine#restoreDbFromBackup(int, String, String, RestoreOptions)}
* *
* Default: 1 * Default: 1
* *
@ -392,8 +392,8 @@ public class BackupableDBOptions extends RocksObject {
/** /**
* Up to this many background threads will copy files for * Up to this many background threads will copy files for
* {@link BackupableDB#createNewBackup(boolean)} and * {@link BackupEngine#createNewBackup(RocksDB, boolean)} and
* {@link RestoreBackupableDB#restoreDBFromBackup(long, String, String, RestoreOptions)} * {@link BackupEngine#restoreDbFromBackup(int, String, String, RestoreOptions)}
* *
* Default: 1 * Default: 1
* *

158
java/src/main/java/org/rocksdb/RestoreBackupableDB.java
Unescape View File

@ -1,158 +0,0 @@
// Copyright (c) 2011-present, 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.
package org.rocksdb;
import java.util.List;
/**
* <p>This class is used to access information about backups and
* restore from them.</p>
*
* <p>Note: {@code dispose()} must be called before this instance
* become out-of-scope to release the allocated
* memory in c++.</p>
*
*/
public class RestoreBackupableDB extends RocksObject {
/**
* <p>Construct new estoreBackupableDB instance.</p>
*
* @param options {@link org.rocksdb.BackupableDBOptions} instance
*/
public RestoreBackupableDB(final BackupableDBOptions options) {
super(newRestoreBackupableDB(options.nativeHandle_));
}
/**
* <p>Restore from backup with backup_id.</p>
*
* <p><strong>Important</strong>: If options_.share_table_files == true
* and you restore DB from some backup that is not the latest, and you
* start creating new backups from the new DB, they will probably
* fail.</p>
*
* <p><strong>Example</strong>: Let's say you have backups 1, 2, 3, 4, 5
* and you restore 3. If you add new data to the DB and try creating a new
* backup now, the database will diverge from backups 4 and 5 and the new
* backup will fail. If you want to create new backup, you will first have
* to delete backups 4 and 5.</p>
*
* @param backupId id pointing to backup
* @param dbDir database directory to restore to
* @param walDir directory where wal files are located
* @param restoreOptions {@link org.rocksdb.RestoreOptions} instance.
*
* @throws RocksDBException thrown if error happens in underlying
* native library.
*/
public void restoreDBFromBackup(final long backupId, final String dbDir,
final String walDir, final RestoreOptions restoreOptions)
throws RocksDBException {
assert(isOwningHandle());
restoreDBFromBackup0(nativeHandle_, backupId, dbDir, walDir,
restoreOptions.nativeHandle_);
}
/**
* <p>Restore from the latest backup.</p>
*
* @param dbDir database directory to restore to
* @param walDir directory where wal files are located
* @param restoreOptions {@link org.rocksdb.RestoreOptions} instance
*
* @throws RocksDBException thrown if error happens in underlying
* native library.
*/
public void restoreDBFromLatestBackup(final String dbDir,
final String walDir, final RestoreOptions restoreOptions)
throws RocksDBException {
assert(isOwningHandle());
restoreDBFromLatestBackup0(nativeHandle_, dbDir, walDir,
restoreOptions.nativeHandle_);
}
/**
* <p>Deletes old backups, keeping latest numBackupsToKeep alive.</p>
*
* @param numBackupsToKeep of latest backups to keep
*
* @throws RocksDBException thrown if error happens in underlying
* native library.
*/
public void purgeOldBackups(final int numBackupsToKeep)
throws RocksDBException {
assert(isOwningHandle());
purgeOldBackups0(nativeHandle_, numBackupsToKeep);
}
/**
* <p>Deletes a specific backup.</p>
*
* @param backupId of backup to delete.
*
* @throws RocksDBException thrown if error happens in underlying
* native library.
*/
public void deleteBackup(final int backupId)
throws RocksDBException {
assert(isOwningHandle());
deleteBackup0(nativeHandle_, backupId);
}
/**
* <p>Returns a list of {@link BackupInfo} instances, which describe
* already made backups.</p>
*
* @return List of {@link BackupInfo} instances.
*/
public List<BackupInfo> getBackupInfos() {
assert(isOwningHandle());
return getBackupInfo(nativeHandle_);
}
/**
* <p>Returns a list of corrupted backup ids. If there
* is no corrupted backup the method will return an
* empty list.</p>
*
* @return array of backup ids as int ids.
*/
public int[] getCorruptedBackups() {
assert(isOwningHandle());
return getCorruptedBackups(nativeHandle_);
}
/**
* <p>Will delete all the files we don't need anymore. It will
* do the full scan of the files/ directory and delete all the
* files that are not referenced.</p>
*
* @throws RocksDBException thrown if error happens in underlying
* native library.
*/
public void garbageCollect() throws RocksDBException {
assert(isOwningHandle());
garbageCollect(nativeHandle_);
}
private native static long newRestoreBackupableDB(final long options);
private native void restoreDBFromBackup0(long nativeHandle, long backupId,
String dbDir, String walDir, long restoreOptions)
throws RocksDBException;
private native void restoreDBFromLatestBackup0(long nativeHandle,
String dbDir, String walDir, long restoreOptions)
throws RocksDBException;
private native void purgeOldBackups0(long nativeHandle, int numBackupsToKeep)
throws RocksDBException;
private native void deleteBackup0(long nativeHandle, int backupId)
throws RocksDBException;
private native List<BackupInfo> getBackupInfo(long handle);
private native int[] getCorruptedBackups(long handle);
private native void garbageCollect(long handle)
throws RocksDBException;
@Override protected final native void disposeInternal(
final long nativeHandle);
}
Write Preview
Loading…
Cancel
Save