|
|
|
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
|
|
|
// This source code is licensed under both the GPLv2 (found in the
|
|
|
|
// COPYING file in the root directory) and Apache 2.0 License
|
|
|
|
// (found in the LICENSE.Apache file in the root directory).
|
|
|
|
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
|
|
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
|
|
// found in the LICENSE file. See the AUTHORS file for names of contributors.
|
|
|
|
//
|
|
|
|
// A Status encapsulates the result of an operation. It may indicate success,
|
|
|
|
// or it may indicate an error with an associated error message.
|
|
|
|
//
|
|
|
|
// Multiple threads can invoke const methods on a Status without
|
|
|
|
// external synchronization, but if any of the threads may call a
|
|
|
|
// non-const method, all threads accessing the same Status must use
|
|
|
|
// external synchronization.
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <memory>
|
|
|
|
#include <string>
|
|
|
|
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
#include "port/stack_trace.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include "rocksdb/slice.h"
|
|
|
|
|
|
|
|
namespace ROCKSDB_NAMESPACE {
|
|
|
|
|
|
|
|
class Status {
|
|
|
|
public:
|
|
|
|
// Create a success status.
|
|
|
|
Status()
|
|
|
|
: code_(kOk),
|
|
|
|
subcode_(kNone),
|
|
|
|
sev_(kNoError),
|
|
|
|
retryable_(false),
|
|
|
|
data_loss_(false),
|
|
|
|
scope_(0),
|
|
|
|
state_(nullptr) {}
|
|
|
|
~Status() {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
if (!checked_) {
|
|
|
|
fprintf(stderr, "Failed to check Status %p\n", this);
|
|
|
|
port::PrintStack();
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
}
|
|
|
|
|
|
|
|
// Copy the specified status.
|
|
|
|
Status(const Status& s);
|
|
|
|
Status& operator=(const Status& s);
|
|
|
|
Status(Status&& s)
|
|
|
|
#if !(defined _MSC_VER) || ((defined _MSC_VER) && (_MSC_VER >= 1900))
|
|
|
|
noexcept
|
|
|
|
#endif
|
|
|
|
;
|
|
|
|
Status& operator=(Status&& s)
|
|
|
|
#if !(defined _MSC_VER) || ((defined _MSC_VER) && (_MSC_VER >= 1900))
|
|
|
|
noexcept
|
|
|
|
#endif
|
|
|
|
;
|
|
|
|
bool operator==(const Status& rhs) const;
|
|
|
|
bool operator!=(const Status& rhs) const;
|
|
|
|
|
|
|
|
// In case of intentionally swallowing an error, user must explicitly call
|
|
|
|
// this function. That way we are easily able to search the code to find where
|
|
|
|
// error swallowing occurs.
|
|
|
|
inline void PermitUncheckedError() const { MarkChecked(); }
|
|
|
|
|
|
|
|
inline void MustCheck() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = false;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
}
|
|
|
|
|
|
|
|
enum Code : unsigned char {
|
|
|
|
kOk = 0,
|
|
|
|
kNotFound = 1,
|
|
|
|
kCorruption = 2,
|
|
|
|
kNotSupported = 3,
|
|
|
|
kInvalidArgument = 4,
|
|
|
|
kIOError = 5,
|
|
|
|
kMergeInProgress = 6,
|
|
|
|
kIncomplete = 7,
|
|
|
|
kShutdownInProgress = 8,
|
|
|
|
kTimedOut = 9,
|
|
|
|
kAborted = 10,
|
|
|
|
kBusy = 11,
|
|
|
|
kExpired = 12,
|
|
|
|
kTryAgain = 13,
|
|
|
|
kCompactionTooLarge = 14,
|
|
|
|
kColumnFamilyDropped = 15,
|
|
|
|
kMaxCode
|
|
|
|
};
|
|
|
|
|
|
|
|
Code code() const {
|
|
|
|
MarkChecked();
|
|
|
|
return code_;
|
|
|
|
}
|
|
|
|
|
|
|
|
enum SubCode : unsigned char {
|
|
|
|
kNone = 0,
|
|
|
|
kMutexTimeout = 1,
|
|
|
|
kLockTimeout = 2,
|
|
|
|
kLockLimit = 3,
|
|
|
|
kNoSpace = 4,
|
|
|
|
kDeadlock = 5,
|
|
|
|
kStaleFile = 6,
|
|
|
|
kMemoryLimit = 7,
|
|
|
|
kSpaceLimit = 8,
|
|
|
|
kPathNotFound = 9,
|
New API to get all merge operands for a Key (#5604)
Summary:
This is a new API added to db.h to allow for fetching all merge operands associated with a Key. The main motivation for this API is to support use cases where doing a full online merge is not necessary as it is performance sensitive. Example use-cases:
1. Update subset of columns and read subset of columns -
Imagine a SQL Table, a row is encoded as a K/V pair (as it is done in MyRocks). If there are many columns and users only updated one of them, we can use merge operator to reduce write amplification. While users only read one or two columns in the read query, this feature can avoid a full merging of the whole row, and save some CPU.
2. Updating very few attributes in a value which is a JSON-like document -
Updating one attribute can be done efficiently using merge operator, while reading back one attribute can be done more efficiently if we don't need to do a full merge.
----------------------------------------------------------------------------------------------------
API :
Status GetMergeOperands(
const ReadOptions& options, ColumnFamilyHandle* column_family,
const Slice& key, PinnableSlice* merge_operands,
GetMergeOperandsOptions* get_merge_operands_options,
int* number_of_operands)
Example usage :
int size = 100;
int number_of_operands = 0;
std::vector<PinnableSlice> values(size);
GetMergeOperandsOptions merge_operands_info;
db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k1", values.data(), merge_operands_info, &number_of_operands);
Description :
Returns all the merge operands corresponding to the key. If the number of merge operands in DB is greater than merge_operands_options.expected_max_number_of_operands no merge operands are returned and status is Incomplete. Merge operands returned are in the order of insertion.
merge_operands-> Points to an array of at-least merge_operands_options.expected_max_number_of_operands and the caller is responsible for allocating it. If the status returned is Incomplete then number_of_operands will contain the total number of merge operands found in DB for key.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/5604
Test Plan:
Added unit test and perf test in db_bench that can be run using the command:
./db_bench -benchmarks=getmergeoperands --merge_operator=sortlist
Differential Revision: D16657366
Pulled By: vjnadimpalli
fbshipit-source-id: 0faadd752351745224ee12d4ae9ef3cb529951bf
5 years ago
|
|
|
KMergeOperandsInsufficientCapacity = 10,
|
|
|
|
kManualCompactionPaused = 11,
|
|
|
|
kOverwritten = 12,
|
|
|
|
kTxnNotPrepared = 13,
|
|
|
|
kIOFenced = 14,
|
|
|
|
kMaxSubCode
|
|
|
|
};
|
|
|
|
|
|
|
|
SubCode subcode() const {
|
|
|
|
MarkChecked();
|
|
|
|
return subcode_;
|
|
|
|
}
|
|
|
|
|
|
|
|
enum Severity : unsigned char {
|
|
|
|
kNoError = 0,
|
|
|
|
kSoftError = 1,
|
|
|
|
kHardError = 2,
|
|
|
|
kFatalError = 3,
|
|
|
|
kUnrecoverableError = 4,
|
|
|
|
kMaxSeverity
|
|
|
|
};
|
|
|
|
|
|
|
|
Status(const Status& s, Severity sev);
|
|
|
|
|
|
|
|
Status(Code _code, SubCode _subcode, Severity _sev, const Slice& msg)
|
|
|
|
: Status(_code, _subcode, msg, "", _sev) {}
|
|
|
|
|
|
|
|
Severity severity() const {
|
|
|
|
MarkChecked();
|
|
|
|
return sev_;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns a C style string indicating the message of the Status
|
|
|
|
const char* getState() const {
|
|
|
|
MarkChecked();
|
|
|
|
return state_.get();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return a success status.
|
|
|
|
static Status OK() { return Status(); }
|
|
|
|
|
|
|
|
// Successful, though an existing something was overwritten
|
|
|
|
// Note: using variants of OK status for program logic is discouraged,
|
|
|
|
// but it can be useful for communicating statistical information without
|
|
|
|
// changing public APIs.
|
|
|
|
static Status OkOverwritten() { return Status(kOk, kOverwritten); }
|
|
|
|
|
|
|
|
// Return error status of an appropriate type.
|
|
|
|
static Status NotFound(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kNotFound, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Fast path for not found without malloc;
|
|
|
|
static Status NotFound(SubCode msg = kNone) { return Status(kNotFound, msg); }
|
|
|
|
|
|
|
|
static Status NotFound(SubCode sc, const Slice& msg,
|
|
|
|
const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kNotFound, sc, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status Corruption(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kCorruption, msg, msg2);
|
|
|
|
}
|
|
|
|
static Status Corruption(SubCode msg = kNone) {
|
|
|
|
return Status(kCorruption, msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status NotSupported(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kNotSupported, msg, msg2);
|
|
|
|
}
|
|
|
|
static Status NotSupported(SubCode msg = kNone) {
|
|
|
|
return Status(kNotSupported, msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status InvalidArgument(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kInvalidArgument, msg, msg2);
|
|
|
|
}
|
|
|
|
static Status InvalidArgument(SubCode msg = kNone) {
|
|
|
|
return Status(kInvalidArgument, msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status IOError(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kIOError, msg, msg2);
|
|
|
|
}
|
|
|
|
static Status IOError(SubCode msg = kNone) { return Status(kIOError, msg); }
|
|
|
|
|
|
|
|
static Status MergeInProgress(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kMergeInProgress, msg, msg2);
|
|
|
|
}
|
|
|
|
static Status MergeInProgress(SubCode msg = kNone) {
|
|
|
|
return Status(kMergeInProgress, msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status Incomplete(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kIncomplete, msg, msg2);
|
|
|
|
}
|
|
|
|
static Status Incomplete(SubCode msg = kNone) {
|
|
|
|
return Status(kIncomplete, msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status ShutdownInProgress(SubCode msg = kNone) {
|
|
|
|
return Status(kShutdownInProgress, msg);
|
CompactFiles, EventListener and GetDatabaseMetaData
Summary:
This diff adds three sets of APIs to RocksDB.
= GetColumnFamilyMetaData =
* This APIs allow users to obtain the current state of a RocksDB instance on one column family.
* See GetColumnFamilyMetaData in include/rocksdb/db.h
= EventListener =
* A virtual class that allows users to implement a set of
call-back functions which will be called when specific
events of a RocksDB instance happens.
* To register EventListener, simply insert an EventListener to ColumnFamilyOptions::listeners
= CompactFiles =
* CompactFiles API inputs a set of file numbers and an output level, and RocksDB
will try to compact those files into the specified level.
= Example =
* Example code can be found in example/compact_files_example.cc, which implements
a simple external compactor using EventListener, GetColumnFamilyMetaData, and
CompactFiles API.
Test Plan:
listener_test
compactor_test
example/compact_files_example
export ROCKSDB_TESTS=CompactFiles
db_test
export ROCKSDB_TESTS=MetaData
db_test
Reviewers: ljin, igor, rven, sdong
Reviewed By: sdong
Subscribers: MarkCallaghan, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D24705
10 years ago
|
|
|
}
|
|
|
|
static Status ShutdownInProgress(const Slice& msg,
|
|
|
|
const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kShutdownInProgress, msg, msg2);
|
|
|
|
}
|
|
|
|
static Status Aborted(SubCode msg = kNone) { return Status(kAborted, msg); }
|
CompactFiles, EventListener and GetDatabaseMetaData
Summary:
This diff adds three sets of APIs to RocksDB.
= GetColumnFamilyMetaData =
* This APIs allow users to obtain the current state of a RocksDB instance on one column family.
* See GetColumnFamilyMetaData in include/rocksdb/db.h
= EventListener =
* A virtual class that allows users to implement a set of
call-back functions which will be called when specific
events of a RocksDB instance happens.
* To register EventListener, simply insert an EventListener to ColumnFamilyOptions::listeners
= CompactFiles =
* CompactFiles API inputs a set of file numbers and an output level, and RocksDB
will try to compact those files into the specified level.
= Example =
* Example code can be found in example/compact_files_example.cc, which implements
a simple external compactor using EventListener, GetColumnFamilyMetaData, and
CompactFiles API.
Test Plan:
listener_test
compactor_test
example/compact_files_example
export ROCKSDB_TESTS=CompactFiles
db_test
export ROCKSDB_TESTS=MetaData
db_test
Reviewers: ljin, igor, rven, sdong
Reviewed By: sdong
Subscribers: MarkCallaghan, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D24705
10 years ago
|
|
|
static Status Aborted(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kAborted, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status Busy(SubCode msg = kNone) { return Status(kBusy, msg); }
|
|
|
|
static Status Busy(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kBusy, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status TimedOut(SubCode msg = kNone) { return Status(kTimedOut, msg); }
|
Pessimistic Transactions
Summary:
Initial implementation of Pessimistic Transactions. This diff contains the api changes discussed in D38913. This diff is pretty large, so let me know if people would prefer to meet up to discuss it.
MyRocks folks: please take a look at the API in include/rocksdb/utilities/transaction[_db].h and let me know if you have any issues.
Also, you'll notice a couple of TODOs in the implementation of RollbackToSavePoint(). After chatting with Siying, I'm going to send out a separate diff for an alternate implementation of this feature that implements the rollback inside of WriteBatch/WriteBatchWithIndex. We can then decide which route is preferable.
Next, I'm planning on doing some perf testing and then integrating this diff into MongoRocks for further testing.
Test Plan: Unit tests, db_bench parallel testing.
Reviewers: igor, rven, sdong, yhchiang, yoshinorim
Reviewed By: sdong
Subscribers: hermanlee4, maykov, spetrunia, leveldb, dhruba
Differential Revision: https://reviews.facebook.net/D40869
10 years ago
|
|
|
static Status TimedOut(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kTimedOut, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status Expired(SubCode msg = kNone) { return Status(kExpired, msg); }
|
|
|
|
static Status Expired(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kExpired, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status TryAgain(SubCode msg = kNone) { return Status(kTryAgain, msg); }
|
|
|
|
static Status TryAgain(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kTryAgain, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status CompactionTooLarge(SubCode msg = kNone) {
|
|
|
|
return Status(kCompactionTooLarge, msg);
|
|
|
|
}
|
|
|
|
static Status CompactionTooLarge(const Slice& msg,
|
|
|
|
const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kCompactionTooLarge, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status ColumnFamilyDropped(SubCode msg = kNone) {
|
|
|
|
return Status(kColumnFamilyDropped, msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status ColumnFamilyDropped(const Slice& msg,
|
|
|
|
const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kColumnFamilyDropped, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status NoSpace() { return Status(kIOError, kNoSpace); }
|
|
|
|
static Status NoSpace(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kIOError, kNoSpace, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status MemoryLimit() { return Status(kAborted, kMemoryLimit); }
|
|
|
|
static Status MemoryLimit(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kAborted, kMemoryLimit, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status SpaceLimit() { return Status(kIOError, kSpaceLimit); }
|
|
|
|
static Status SpaceLimit(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kIOError, kSpaceLimit, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status PathNotFound() { return Status(kIOError, kPathNotFound); }
|
|
|
|
static Status PathNotFound(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kIOError, kPathNotFound, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status TxnNotPrepared() {
|
|
|
|
return Status(kInvalidArgument, kTxnNotPrepared);
|
|
|
|
}
|
|
|
|
static Status TxnNotPrepared(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kInvalidArgument, kTxnNotPrepared, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates success.
|
|
|
|
bool ok() const {
|
|
|
|
MarkChecked();
|
|
|
|
return code() == kOk;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates success *with* something
|
|
|
|
// overwritten
|
|
|
|
bool IsOkOverwritten() const {
|
|
|
|
MarkChecked();
|
|
|
|
return code() == kOk && subcode() == kOverwritten;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates a NotFound error.
|
|
|
|
bool IsNotFound() const {
|
|
|
|
MarkChecked();
|
|
|
|
return code() == kNotFound;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates a Corruption error.
|
|
|
|
bool IsCorruption() const {
|
|
|
|
MarkChecked();
|
|
|
|
return code() == kCorruption;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates a NotSupported error.
|
|
|
|
bool IsNotSupported() const {
|
|
|
|
MarkChecked();
|
|
|
|
return code() == kNotSupported;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates an InvalidArgument error.
|
|
|
|
bool IsInvalidArgument() const {
|
|
|
|
MarkChecked();
|
|
|
|
return code() == kInvalidArgument;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates an IOError.
|
|
|
|
bool IsIOError() const {
|
|
|
|
MarkChecked();
|
|
|
|
return code() == kIOError;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates an MergeInProgress.
|
|
|
|
bool IsMergeInProgress() const {
|
|
|
|
MarkChecked();
|
|
|
|
return code() == kMergeInProgress;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates Incomplete
|
|
|
|
bool IsIncomplete() const {
|
|
|
|
MarkChecked();
|
|
|
|
return code() == kIncomplete;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates Shutdown In progress
|
|
|
|
bool IsShutdownInProgress() const {
|
|
|
|
MarkChecked();
|
|
|
|
return code() == kShutdownInProgress;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IsTimedOut() const {
|
|
|
|
MarkChecked();
|
|
|
|
return code() == kTimedOut;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IsAborted() const {
|
|
|
|
MarkChecked();
|
|
|
|
return code() == kAborted;
|
|
|
|
}
|
CompactFiles, EventListener and GetDatabaseMetaData
Summary:
This diff adds three sets of APIs to RocksDB.
= GetColumnFamilyMetaData =
* This APIs allow users to obtain the current state of a RocksDB instance on one column family.
* See GetColumnFamilyMetaData in include/rocksdb/db.h
= EventListener =
* A virtual class that allows users to implement a set of
call-back functions which will be called when specific
events of a RocksDB instance happens.
* To register EventListener, simply insert an EventListener to ColumnFamilyOptions::listeners
= CompactFiles =
* CompactFiles API inputs a set of file numbers and an output level, and RocksDB
will try to compact those files into the specified level.
= Example =
* Example code can be found in example/compact_files_example.cc, which implements
a simple external compactor using EventListener, GetColumnFamilyMetaData, and
CompactFiles API.
Test Plan:
listener_test
compactor_test
example/compact_files_example
export ROCKSDB_TESTS=CompactFiles
db_test
export ROCKSDB_TESTS=MetaData
db_test
Reviewers: ljin, igor, rven, sdong
Reviewed By: sdong
Subscribers: MarkCallaghan, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D24705
10 years ago
|
|
|
|
|
|
|
bool IsLockLimit() const {
|
|
|
|
MarkChecked();
|
|
|
|
return code() == kAborted && subcode() == kLockLimit;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates that a resource is Busy and
|
|
|
|
// temporarily could not be acquired.
|
|
|
|
bool IsBusy() const {
|
|
|
|
MarkChecked();
|
|
|
|
return code() == kBusy;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IsDeadlock() const {
|
|
|
|
MarkChecked();
|
|
|
|
return code() == kBusy && subcode() == kDeadlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicated that the operation has Expired.
|
|
|
|
bool IsExpired() const {
|
|
|
|
MarkChecked();
|
|
|
|
return code() == kExpired;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates a TryAgain error.
|
|
|
|
// This usually means that the operation failed, but may succeed if
|
|
|
|
// re-attempted.
|
|
|
|
bool IsTryAgain() const {
|
|
|
|
MarkChecked();
|
|
|
|
return code() == kTryAgain;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates the proposed compaction is too large
|
|
|
|
bool IsCompactionTooLarge() const {
|
|
|
|
MarkChecked();
|
|
|
|
return code() == kCompactionTooLarge;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates Column Family Dropped
|
|
|
|
bool IsColumnFamilyDropped() const {
|
|
|
|
MarkChecked();
|
|
|
|
return code() == kColumnFamilyDropped;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates a NoSpace error
|
|
|
|
// This is caused by an I/O error returning the specific "out of space"
|
|
|
|
// error condition. Stricto sensu, an NoSpace error is an I/O error
|
|
|
|
// with a specific subcode, enabling users to take the appropriate action
|
|
|
|
// if needed
|
|
|
|
bool IsNoSpace() const {
|
|
|
|
MarkChecked();
|
|
|
|
return (code() == kIOError) && (subcode() == kNoSpace);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates a memory limit error. There may be
|
|
|
|
// cases where we limit the memory used in certain operations (eg. the size
|
|
|
|
// of a write batch) in order to avoid out of memory exceptions.
|
|
|
|
bool IsMemoryLimit() const {
|
|
|
|
MarkChecked();
|
|
|
|
return (code() == kAborted) && (subcode() == kMemoryLimit);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates a PathNotFound error
|
|
|
|
// This is caused by an I/O error returning the specific "no such file or
|
|
|
|
// directory" error condition. A PathNotFound error is an I/O error with
|
|
|
|
// a specific subcode, enabling users to take appropriate action if necessary
|
|
|
|
bool IsPathNotFound() const {
|
|
|
|
MarkChecked();
|
|
|
|
return (code() == kIOError || code() == kNotFound) &&
|
|
|
|
(subcode() == kPathNotFound);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates manual compaction paused. This
|
|
|
|
// is caused by a call to PauseManualCompaction
|
|
|
|
bool IsManualCompactionPaused() const {
|
|
|
|
MarkChecked();
|
|
|
|
return (code() == kIncomplete) && (subcode() == kManualCompactionPaused);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates a TxnNotPrepared error.
|
|
|
|
bool IsTxnNotPrepared() const {
|
|
|
|
MarkChecked();
|
|
|
|
return (code() == kInvalidArgument) && (subcode() == kTxnNotPrepared);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates a IOFenced error.
|
|
|
|
bool IsIOFenced() const {
|
|
|
|
MarkChecked();
|
|
|
|
return (code() == kIOError) && (subcode() == kIOFenced);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return a string representation of this status suitable for printing.
|
|
|
|
// Returns the string "OK" for success.
|
|
|
|
std::string ToString() const;
|
|
|
|
|
Introduce a new storage specific Env API (#5761)
Summary:
The current Env API encompasses both storage/file operations, as well as OS related operations. Most of the APIs return a Status, which does not have enough metadata about an error, such as whether its retry-able or not, scope (i.e fault domain) of the error etc., that may be required in order to properly handle a storage error. The file APIs also do not provide enough control over the IO SLA, such as timeout, prioritization, hinting about placement and redundancy etc.
This PR separates out the file/storage APIs from Env into a new FileSystem class. The APIs are updated to return an IOStatus with metadata about the error, as well as to take an IOOptions structure as input in order to allow more control over the IO.
The user can set both ```options.env``` and ```options.file_system``` to specify that RocksDB should use the former for OS related operations and the latter for storage operations. Internally, a ```CompositeEnvWrapper``` has been introduced that inherits from ```Env``` and redirects individual methods to either an ```Env``` implementation or the ```FileSystem``` as appropriate. When options are sanitized during ```DB::Open```, ```options.env``` is replaced with a newly allocated ```CompositeEnvWrapper``` instance if both env and file_system have been specified. This way, the rest of the RocksDB code can continue to function as before.
This PR also ports PosixEnv to the new API by splitting it into two - PosixEnv and PosixFileSystem. PosixEnv is defined as a sub-class of CompositeEnvWrapper, and threading/time functions are overridden with Posix specific implementations in order to avoid an extra level of indirection.
The ```CompositeEnvWrapper``` translates ```IOStatus``` return code to ```Status```, and sets the severity to ```kSoftError``` if the io_status is retryable. The error handling code in RocksDB can then recover the DB automatically.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/5761
Differential Revision: D18868376
Pulled By: anand1976
fbshipit-source-id: 39efe18a162ea746fabac6360ff529baba48486f
5 years ago
|
|
|
protected:
|
|
|
|
Code code_;
|
|
|
|
SubCode subcode_;
|
|
|
|
Severity sev_;
|
|
|
|
bool retryable_;
|
|
|
|
bool data_loss_;
|
|
|
|
unsigned char scope_;
|
|
|
|
// A nullptr state_ (which is at least the case for OK) means the extra
|
|
|
|
// message is empty.
|
|
|
|
std::unique_ptr<const char[]> state_;
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
mutable bool checked_ = false;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
|
|
|
|
explicit Status(Code _code, SubCode _subcode = kNone)
|
|
|
|
: code_(_code),
|
|
|
|
subcode_(_subcode),
|
|
|
|
sev_(kNoError),
|
|
|
|
retryable_(false),
|
|
|
|
data_loss_(false),
|
|
|
|
scope_(0) {}
|
|
|
|
|
|
|
|
explicit Status(Code _code, SubCode _subcode, bool retryable, bool data_loss,
|
|
|
|
unsigned char scope)
|
|
|
|
: code_(_code),
|
|
|
|
subcode_(_subcode),
|
|
|
|
sev_(kNoError),
|
|
|
|
retryable_(retryable),
|
|
|
|
data_loss_(data_loss),
|
|
|
|
scope_(scope) {}
|
|
|
|
|
|
|
|
Status(Code _code, SubCode _subcode, const Slice& msg, const Slice& msg2,
|
|
|
|
Severity sev = kNoError);
|
|
|
|
Status(Code _code, const Slice& msg, const Slice& msg2)
|
|
|
|
: Status(_code, kNone, msg, msg2) {}
|
|
|
|
|
|
|
|
static std::unique_ptr<const char[]> CopyState(const char* s);
|
|
|
|
|
|
|
|
inline void MarkChecked() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
inline Status::Status(const Status& s)
|
|
|
|
: code_(s.code_),
|
|
|
|
subcode_(s.subcode_),
|
|
|
|
sev_(s.sev_),
|
|
|
|
retryable_(s.retryable_),
|
|
|
|
data_loss_(s.data_loss_),
|
|
|
|
scope_(s.scope_) {
|
|
|
|
s.MarkChecked();
|
|
|
|
state_ = (s.state_ == nullptr) ? nullptr : CopyState(s.state_.get());
|
|
|
|
}
|
|
|
|
inline Status::Status(const Status& s, Severity sev)
|
|
|
|
: code_(s.code_),
|
|
|
|
subcode_(s.subcode_),
|
|
|
|
sev_(sev),
|
|
|
|
retryable_(s.retryable_),
|
|
|
|
data_loss_(s.data_loss_),
|
|
|
|
scope_(s.scope_) {
|
|
|
|
s.MarkChecked();
|
|
|
|
state_ = (s.state_ == nullptr) ? nullptr : CopyState(s.state_.get());
|
|
|
|
}
|
|
|
|
inline Status& Status::operator=(const Status& s) {
|
|
|
|
if (this != &s) {
|
|
|
|
s.MarkChecked();
|
|
|
|
MustCheck();
|
|
|
|
code_ = s.code_;
|
|
|
|
subcode_ = s.subcode_;
|
|
|
|
sev_ = s.sev_;
|
|
|
|
retryable_ = s.retryable_;
|
|
|
|
data_loss_ = s.data_loss_;
|
|
|
|
scope_ = s.scope_;
|
|
|
|
state_ = (s.state_ == nullptr) ? nullptr : CopyState(s.state_.get());
|
|
|
|
}
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline Status::Status(Status&& s)
|
|
|
|
#if !(defined _MSC_VER) || ((defined _MSC_VER) && (_MSC_VER >= 1900))
|
|
|
|
noexcept
|
|
|
|
#endif
|
|
|
|
: Status() {
|
|
|
|
s.MarkChecked();
|
|
|
|
*this = std::move(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline Status& Status::operator=(Status&& s)
|
|
|
|
#if !(defined _MSC_VER) || ((defined _MSC_VER) && (_MSC_VER >= 1900))
|
|
|
|
noexcept
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
if (this != &s) {
|
|
|
|
s.MarkChecked();
|
|
|
|
MustCheck();
|
|
|
|
code_ = std::move(s.code_);
|
|
|
|
s.code_ = kOk;
|
|
|
|
subcode_ = std::move(s.subcode_);
|
|
|
|
s.subcode_ = kNone;
|
|
|
|
sev_ = std::move(s.sev_);
|
|
|
|
s.sev_ = kNoError;
|
|
|
|
retryable_ = std::move(s.retryable_);
|
|
|
|
s.retryable_ = false;
|
|
|
|
data_loss_ = std::move(s.data_loss_);
|
|
|
|
s.data_loss_ = false;
|
|
|
|
scope_ = std::move(s.scope_);
|
|
|
|
s.scope_ = 0;
|
|
|
|
state_ = std::move(s.state_);
|
|
|
|
}
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool Status::operator==(const Status& rhs) const {
|
|
|
|
MarkChecked();
|
|
|
|
rhs.MarkChecked();
|
|
|
|
return (code_ == rhs.code_);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool Status::operator!=(const Status& rhs) const {
|
|
|
|
MarkChecked();
|
|
|
|
rhs.MarkChecked();
|
|
|
|
return !(*this == rhs);
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace ROCKSDB_NAMESPACE
|