Bring the Configurable options together (#5753)
Summary: This PR merges the functionality of making the ColumnFamilyOptions, TableFactory, and DBOptions into Configurable into a single PR, resolving any merge conflicts Pull Request resolved: https://github.com/facebook/rocksdb/pull/5753 Reviewed By: ajkr Differential Revision: D23385030 Pulled By: zhichao-cao fbshipit-source-id: 8b977a7731556230b9b8c5a081b98e49ee4f160amain
mrambacher
4 years ago
committed by
Facebook GitHub Bot
parent
18a3227b12
commit
7d472accdc
@ -0,0 +1,364 @@ |
||||
// 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.
|
||||
|
||||
#pragma once |
||||
|
||||
#include <string> |
||||
#include <unordered_map> |
||||
#include <unordered_set> |
||||
#include <vector> |
||||
|
||||
#include "rocksdb/rocksdb_namespace.h" |
||||
#include "rocksdb/status.h" |
||||
|
||||
namespace ROCKSDB_NAMESPACE { |
||||
class Logger; |
||||
class ObjectRegistry; |
||||
class OptionTypeInfo; |
||||
struct ColumnFamilyOptions; |
||||
struct ConfigOptions; |
||||
struct DBOptions; |
||||
|
||||
// Configurable is a base class used by the rocksdb that describes a
|
||||
// standard way of configuring objects. A Configurable object can:
|
||||
// -> Populate itself given:
|
||||
// - One or more "name/value" pair strings
|
||||
// - A string repesenting the set of name=value properties
|
||||
// - A map of name/value properties.
|
||||
// -> Convert itself into its string representation
|
||||
// -> Dump itself to a Logger
|
||||
// -> Compare itself to another Configurable object to see if the two objects
|
||||
// have equivalent options settings
|
||||
//
|
||||
// If a derived class calls RegisterOptions to register (by name) how its
|
||||
// options objects are to be processed, this functionality can typically be
|
||||
// handled by this class without additional overrides. Otherwise, the derived
|
||||
// class will need to implement the methods for handling the corresponding
|
||||
// functionality.
|
||||
class Configurable { |
||||
protected: |
||||
friend class ConfigurableHelper; |
||||
struct RegisteredOptions { |
||||
// The name of the options being registered
|
||||
std::string name; |
||||
// Pointer to the object being registered
|
||||
void* opt_ptr; |
||||
#ifndef ROCKSDB_LITE |
||||
// The map of options being registered
|
||||
const std::unordered_map<std::string, OptionTypeInfo>* type_map; |
||||
#endif |
||||
}; |
||||
|
||||
public: |
||||
Configurable() : prepared_(false) {} |
||||
virtual ~Configurable() {} |
||||
|
||||
// Returns the raw pointer of the named options that is used by this
|
||||
// object, or nullptr if this function is not supported.
|
||||
// Since the return value is a raw pointer, the object owns the
|
||||
// pointer and the caller should not delete the pointer.
|
||||
//
|
||||
// Note that changing the underlying options while the object
|
||||
// is currently used by any open DB is undefined behavior.
|
||||
// Developers should use DB::SetOption() instead to dynamically change
|
||||
// options while the DB is open.
|
||||
template <typename T> |
||||
const T* GetOptions() const { |
||||
return GetOptions<T>(T::kName()); |
||||
} |
||||
template <typename T> |
||||
T* GetOptions() { |
||||
return GetOptions<T>(T::kName()); |
||||
} |
||||
template <typename T> |
||||
const T* GetOptions(const std::string& name) const { |
||||
return reinterpret_cast<const T*>(GetOptionsPtr(name)); |
||||
} |
||||
template <typename T> |
||||
T* GetOptions(const std::string& name) { |
||||
return reinterpret_cast<T*>(const_cast<void*>(GetOptionsPtr(name))); |
||||
} |
||||
|
||||
// Configures the options for this class based on the input parameters.
|
||||
// On successful completion, the object is updated with the settings from
|
||||
// the opt_map.
|
||||
// If this method fails, an attempt is made to revert the object to original
|
||||
// state. Note that the revert may not be the original state but may be an
|
||||
// equivalent. For example, if the object contains an option that is a
|
||||
// shared_ptr, the shared_ptr may not be the original one but a copy (e.g. not
|
||||
// the Cache object that was passed in, but a Cache object of the same size).
|
||||
//
|
||||
// The acceptable values of the name/value pairs are documented with the
|
||||
// specific class/instance.
|
||||
//
|
||||
// @param config_options Controls how the arguments are processed.
|
||||
// @param opt_map Name/value pairs of the options to update
|
||||
// @param unused If specified, this value will return the name/value
|
||||
// pairs from opt_map that were NotFound for this object.
|
||||
// @return OK If all values in the map were successfully updated
|
||||
// If invoke_prepare_options is true, OK also implies
|
||||
// PrepareOptions ran successfully.
|
||||
// @return NotFound If any of the names in the opt_map were not valid
|
||||
// for this object. If unused is specified, it will contain the
|
||||
// collection of NotFound names.
|
||||
// @return NotSupported If any of the names are valid but the object does
|
||||
// not know how to convert the value. This can happen if, for example,
|
||||
// there is some nested Configurable that cannot be created.
|
||||
// @return InvalidArgument If any of the values cannot be successfully
|
||||
// parsed. This can also be returned if PrepareOptions encounters an
|
||||
// error.
|
||||
// @see ConfigOptions for a description of the controls.
|
||||
Status ConfigureFromMap( |
||||
const ConfigOptions& config_options, |
||||
const std::unordered_map<std::string, std::string>& opt_map); |
||||
Status ConfigureFromMap( |
||||
const ConfigOptions& config_options, |
||||
const std::unordered_map<std::string, std::string>& opt_map, |
||||
std::unordered_map<std::string, std::string>* unused); |
||||
|
||||
#ifndef ROCKSDB_LITE |
||||
// Updates the named option to the input value, returning OK if successful.
|
||||
// Note that ConfigureOption does not cause PrepareOptions to be invoked.
|
||||
// @param config_options Controls how the name/value is processed.
|
||||
// @param name The name of the option to update
|
||||
// @param value The value to set for the named option
|
||||
// @return OK If the named field was successfully updated to value.
|
||||
// @return NotFound If the name is not valid for this object.
|
||||
// @return NotSupported If the name is valid but the object does
|
||||
// not know how to convert the value. This can happen if, for example,
|
||||
// there is some nested Configurable that cannot be created.
|
||||
// @return InvalidArgument If the value cannot be successfully parsed.
|
||||
Status ConfigureOption(const ConfigOptions& config_options, |
||||
const std::string& name, const std::string& value); |
||||
#endif // ROCKSDB_LITE
|
||||
|
||||
// Configures the options for this class based on the input parameters.
|
||||
// On successful completion, the object is updated with the settings from
|
||||
// the opt_map. If this method fails, an attempt is made to revert the
|
||||
// object to original state. Note that the revert may not be the original
|
||||
// state but may be an equivalent.
|
||||
// @see ConfigureFromMap for more details
|
||||
// @param config_options Controls how the arguments are processed.
|
||||
// @param opt_str string containing the values to update.
|
||||
// @param unused If specified, this value will return the name/value
|
||||
// pairs from opt_map that were NotFound for this object.
|
||||
// @return OK If all specified values were successfully updated
|
||||
// If invoke_prepare_options is true, OK also implies
|
||||
// PrepareOptions ran successfully.
|
||||
// @return NotFound If any of the names were not valid for this object.
|
||||
// If unused is specified, it will contain the collection of NotFound
|
||||
// names.
|
||||
// @return NotSupported If any of the names are valid but the object does
|
||||
// not know how to convert the value. This can happen if, for example,
|
||||
// there is some nested Configurable that cannot be created.
|
||||
// @return InvalidArgument If any of the values cannot be successfully
|
||||
// parsed. This can also be returned if PrepareOptions encounters an
|
||||
// error.
|
||||
Status ConfigureFromString(const ConfigOptions& config_options, |
||||
const std::string& opts); |
||||
|
||||
// Fills in result with the serialized options for this object.
|
||||
// This is the inverse of ConfigureFromString.
|
||||
// @param config_options Controls how serialization happens.
|
||||
// @param result The string representation of this object.
|
||||
// @return OK If the options for this object wer successfully serialized.
|
||||
// @return InvalidArgument If one or more of the options could not be
|
||||
// serialized.
|
||||
Status GetOptionString(const ConfigOptions& config_options, |
||||
std::string* result) const; |
||||
#ifndef ROCKSDB_LITE |
||||
// Returns the serialized options for this object.
|
||||
// This method is similar to GetOptionString with no errors.
|
||||
// @param config_options Controls how serialization happens.
|
||||
// @param prefix A string to prepend to every option.
|
||||
// @return The serialized representation of the options for this object
|
||||
std::string ToString(const ConfigOptions& config_options) const { |
||||
return ToString(config_options, ""); |
||||
} |
||||
std::string ToString(const ConfigOptions& config_options, |
||||
const std::string& prefix) const; |
||||
|
||||
// Returns the list of option names associated with this configurable
|
||||
// @param config_options Controls how the names are returned
|
||||
// @param result The set of option names for this object. Note that
|
||||
// options that are deprecated or aliases are not returned.
|
||||
// @return OK on success.
|
||||
Status GetOptionNames(const ConfigOptions& config_options, |
||||
std::unordered_set<std::string>* result) const; |
||||
|
||||
// Returns the value of the option associated with the input name
|
||||
// This method is the functional inverse of ConfigureOption
|
||||
// @param config_options Controls how the value is returned
|
||||
// @param name The name of the option to return a value for.
|
||||
// @param value The returned value associated with the named option.
|
||||
// @return OK If the named field was successfully updated to value.
|
||||
// @return NotFound If the name is not valid for this object.
|
||||
// @param InvalidArgument If the name is valid for this object but
|
||||
// its value cannot be serialized.
|
||||
virtual Status GetOption(const ConfigOptions& config_options, |
||||
const std::string& name, std::string* value) const; |
||||
#endif // ROCKSDB_LITE
|
||||
|
||||
// Checks to see if this Configurable is equivalent to other.
|
||||
// This method assumes that the two objects are of the same class.
|
||||
// @param config_options Controls how the options are compared.
|
||||
// @param other The other object to compare to.
|
||||
// @param mismatch If the objects do not match, this parameter contains
|
||||
// the name of the option that triggered the match failure.
|
||||
// @param True if the objects match, false otherwise.
|
||||
virtual bool AreEquivalent(const ConfigOptions& config_options, |
||||
const Configurable* other, |
||||
std::string* name) const; |
||||
|
||||
// Returns a pretty-printed, human-readable version of the options.
|
||||
// This method is typically used to dump the options to a log file.
|
||||
// Classes should override this method
|
||||
virtual std::string GetPrintableOptions() const { return ""; } |
||||
|
||||
// Validates that the settings are valid/consistent and performs any object
|
||||
// initialization required by this object. This method may be called as part
|
||||
// of Configure (if invoke_prepare_options is set), or may be invoked
|
||||
// separately.
|
||||
//
|
||||
// Once an object has been prepared, non-mutable options can no longer be
|
||||
// updated.
|
||||
//
|
||||
// Classes must override this method to provide any implementation-specific
|
||||
// initialization, such as opening log files or setting up cache parameters.
|
||||
// Implementations should be idempotent (e.g. don't re-open the log file or
|
||||
// reconfigure the cache), as there is the potential this method can be called
|
||||
// more than once.
|
||||
//
|
||||
// By default, this method will also prepare all nested (Inner and
|
||||
// OptionType::kConfigurable) objects.
|
||||
//
|
||||
// @param config_options Controls how the object is prepared. Also contains
|
||||
// a Logger and Env that can be used to initialize this object.
|
||||
// @return OK If the object was successfully initialized.
|
||||
// @return InvalidArgument If this object could not be successfull
|
||||
// initialized.
|
||||
virtual Status PrepareOptions(const ConfigOptions& config_options); |
||||
|
||||
// Checks to see if the settings are valid for this object.
|
||||
// This method checks to see if the input DBOptions and ColumnFamilyOptions
|
||||
// are valid for the settings of this object. For example, an Env might not
|
||||
// support certain mmap modes or a TableFactory might require certain
|
||||
// settings.
|
||||
//
|
||||
// By default, this method will also validate all nested (Inner and
|
||||
// OptionType::kConfigurable) objects.
|
||||
//
|
||||
// @param db_opts The DBOptions to validate
|
||||
// @param cf_opts The ColumnFamilyOptions to validate
|
||||
// @return OK if the options are valid
|
||||
// @return InvalidArgument If the arguments are not valid for the options
|
||||
// of the current object.
|
||||
virtual Status ValidateOptions(const DBOptions& db_opts, |
||||
const ColumnFamilyOptions& cf_opts) const; |
||||
|
||||
// Returns true if this object has been initialized via PrepareOptions, false
|
||||
// otherwise. Once an object has been prepared, only mutable options may be
|
||||
// changed.
|
||||
virtual bool IsPrepared() const { return prepared_; } |
||||
|
||||
protected: |
||||
// True once the object is prepared. Once the object is prepared, only
|
||||
// mutable options can be configured.
|
||||
bool prepared_; |
||||
// If this class is a wrapper (has-a), this method should be
|
||||
// over-written to return the inner configurable (like an EnvWrapper).
|
||||
// This method should NOT recurse, but should instead return the
|
||||
// direct Inner object.
|
||||
virtual Configurable* Inner() const { return nullptr; } |
||||
|
||||
// Returns the raw pointer for the associated named option.
|
||||
// The name is typically the name of an option registered via the
|
||||
// Classes may override this method to provide further specialization (such as
|
||||
// returning a sub-option)
|
||||
//
|
||||
// The default implemntation looks at the registered options. If the
|
||||
// input name matches that of a registered option, the pointer registered
|
||||
// with that name is returned.
|
||||
// e.g,, RegisterOptions("X", &my_ptr, ...); GetOptionsPtr("X") returns
|
||||
// "my_ptr"
|
||||
virtual const void* GetOptionsPtr(const std::string& name) const; |
||||
|
||||
// Method for allowing options to be configured outside of the normal
|
||||
// registered options framework. Classes may override this method if they
|
||||
// wish to support non-standard options implementations (such as configuring
|
||||
// themselves from constant or simple ":"-separated strings.
|
||||
//
|
||||
// The default implementation does nothing and returns OK
|
||||
virtual Status ParseStringOptions(const ConfigOptions& config_options, |
||||
const std::string& opts_str); |
||||
|
||||
// Internal method to configure an object from a map of name-value options.
|
||||
// This method uses the input config_options to drive the configuration of
|
||||
// the options in opt_map. Any option name that cannot be found from the
|
||||
// input set will be returned in "unused".
|
||||
//
|
||||
// Classes may override this method to extend the functionality if required.
|
||||
// @param config_options Controls how the options are configured and errors
|
||||
// handled.
|
||||
// @param opts_map The set of options to configure
|
||||
// @param unused Any options from opt_map that were not configured.
|
||||
// @returns a Status based on the rules outlined in ConfigureFromMap
|
||||
virtual Status ConfigureOptions( |
||||
const ConfigOptions& config_options, |
||||
const std::unordered_map<std::string, std::string>& opts_map, |
||||
std::unordered_map<std::string, std::string>* unused); |
||||
|
||||
#ifndef ROCKSDB_LITE |
||||
// Method that configures a the specific opt_name from opt_value.
|
||||
// By default, this method calls opt_info.ParseOption with the
|
||||
// input parameters.
|
||||
// Classes may override this method to extend the functionality, or
|
||||
// change the returned Status.
|
||||
virtual Status ParseOption(const ConfigOptions& config_options, |
||||
const OptionTypeInfo& opt_info, |
||||
const std::string& opt_name, |
||||
const std::string& opt_value, void* opt_ptr); |
||||
|
||||
// Internal method to see if the single option name/info matches for this and
|
||||
// that Classes may override this value to change its behavior.
|
||||
// @param config_options Controls how the options are being matched
|
||||
// @param opt_info The OptionTypeInfo registered for this option name
|
||||
// that controls what field is matched (offset) and how (type).
|
||||
// @param name The name associated with this opt_info.
|
||||
// @param this_ptr The base pointer to compare to. This is the object
|
||||
// registered for
|
||||
// for this OptionTypeInfo.
|
||||
// @param that_ptr The other pointer to compare to. This is the object
|
||||
// registered for
|
||||
// for this OptionTypeInfo.
|
||||
// @param bad_name If the match fails, the name of the option that failed to
|
||||
// match.
|
||||
virtual bool OptionsAreEqual(const ConfigOptions& config_options, |
||||
const OptionTypeInfo& opt_info, |
||||
const std::string& name, |
||||
const void* const this_ptr, |
||||
const void* const that_ptr, |
||||
std::string* bad_name) const; |
||||
#endif |
||||
#ifndef ROCKSDB_LITE |
||||
// Internal method to serialize options (ToString)
|
||||
// Classes may override this value to change its behavior.
|
||||
virtual std::string SerializeOptions(const ConfigOptions& config_options, |
||||
const std::string& header) const; |
||||
#endif // ROCKSDB_LITE
|
||||
|
||||
// Given a name (e.g. rocksdb.my.type.opt), returns the short name (opt)
|
||||
virtual std::string GetOptionName(const std::string& long_name) const; |
||||
|
||||
private: |
||||
// Contains the collection of options (name, opt_ptr, opt_map) associated with
|
||||
// this object. This collection is typically set in the constructor of the
|
||||
// Configurable option via
|
||||
std::vector<RegisteredOptions> options_; |
||||
}; |
||||
} // namespace ROCKSDB_NAMESPACE
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,610 @@ |
||||
// 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).
|
||||
|
||||
#include "rocksdb/configurable.h" |
||||
|
||||
#include "logging/logging.h" |
||||
#include "options/configurable_helper.h" |
||||
#include "options/options_helper.h" |
||||
#include "rocksdb/status.h" |
||||
#include "rocksdb/utilities/object_registry.h" |
||||
#include "rocksdb/utilities/options_type.h" |
||||
#include "util/coding.h" |
||||
#include "util/string_util.h" |
||||
|
||||
namespace ROCKSDB_NAMESPACE { |
||||
|
||||
void ConfigurableHelper::RegisterOptions( |
||||
Configurable& configurable, const std::string& name, void* opt_ptr, |
||||
const std::unordered_map<std::string, OptionTypeInfo>* type_map) { |
||||
Configurable::RegisteredOptions opts; |
||||
opts.name = name; |
||||
#ifndef ROCKSDB_LITE |
||||
opts.type_map = type_map; |
||||
#else |
||||
(void)type_map; |
||||
#endif // ROCKSDB_LITE
|
||||
opts.opt_ptr = opt_ptr; |
||||
configurable.options_.emplace_back(opts); |
||||
} |
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// Methods for Initializing and Validating Configurable Objects
|
||||
//
|
||||
//*************************************************************************
|
||||
|
||||
Status Configurable::PrepareOptions(const ConfigOptions& opts) { |
||||
Status status = Status::OK(); |
||||
#ifndef ROCKSDB_LITE |
||||
for (auto opt_iter : options_) { |
||||
for (auto map_iter : *(opt_iter.type_map)) { |
||||
auto& opt_info = map_iter.second; |
||||
if (!opt_info.IsDeprecated() && !opt_info.IsAlias() && |
||||
opt_info.IsConfigurable()) { |
||||
if (!opt_info.IsEnabled(OptionTypeFlags::kDontPrepare)) { |
||||
Configurable* config = |
||||
opt_info.AsRawPointer<Configurable>(opt_iter.opt_ptr); |
||||
if (config != nullptr) { |
||||
status = config->PrepareOptions(opts); |
||||
if (!status.ok()) { |
||||
return status; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} |
||||
#endif // ROCKSDB_LITE
|
||||
if (status.ok()) { |
||||
auto inner = Inner(); |
||||
if (inner != nullptr) { |
||||
status = inner->PrepareOptions(opts); |
||||
} |
||||
} |
||||
if (status.ok()) { |
||||
prepared_ = true; |
||||
} |
||||
return status; |
||||
} |
||||
|
||||
Status Configurable::ValidateOptions(const DBOptions& db_opts, |
||||
const ColumnFamilyOptions& cf_opts) const { |
||||
Status status; |
||||
#ifndef ROCKSDB_LITE |
||||
for (auto opt_iter : options_) { |
||||
for (auto map_iter : *(opt_iter.type_map)) { |
||||
auto& opt_info = map_iter.second; |
||||
if (!opt_info.IsDeprecated() && !opt_info.IsAlias()) { |
||||
if (opt_info.IsConfigurable()) { |
||||
const Configurable* config = |
||||
opt_info.AsRawPointer<Configurable>(opt_iter.opt_ptr); |
||||
if (config != nullptr) { |
||||
status = config->ValidateOptions(db_opts, cf_opts); |
||||
} else if (!opt_info.CanBeNull()) { |
||||
status = |
||||
Status::NotFound("Missing configurable object", map_iter.first); |
||||
} |
||||
if (!status.ok()) { |
||||
return status; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} |
||||
#endif // ROCKSDB_LITE
|
||||
if (status.ok()) { |
||||
const auto inner = Inner(); |
||||
if (inner != nullptr) { |
||||
status = inner->ValidateOptions(db_opts, cf_opts); |
||||
} |
||||
} |
||||
return status; |
||||
} |
||||
|
||||
/*********************************************************************************/ |
||||
/* */ |
||||
/* Methods for Retrieving Options from Configurables */ |
||||
/* */ |
||||
/*********************************************************************************/ |
||||
|
||||
const void* Configurable::GetOptionsPtr(const std::string& name) const { |
||||
for (auto o : options_) { |
||||
if (o.name == name) { |
||||
return o.opt_ptr; |
||||
} |
||||
} |
||||
auto inner = Inner(); |
||||
if (inner != nullptr) { |
||||
return inner->GetOptionsPtr(name); |
||||
} else { |
||||
return nullptr; |
||||
} |
||||
} |
||||
|
||||
std::string Configurable::GetOptionName(const std::string& opt_name) const { |
||||
return opt_name; |
||||
} |
||||
|
||||
#ifndef ROCKSDB_LITE |
||||
const OptionTypeInfo* ConfigurableHelper::FindOption( |
||||
const std::vector<Configurable::RegisteredOptions>& options, |
||||
const std::string& short_name, std::string* opt_name, void** opt_ptr) { |
||||
for (auto iter : options) { |
||||
const auto opt_info = |
||||
OptionTypeInfo::Find(short_name, *(iter.type_map), opt_name); |
||||
if (opt_info != nullptr) { |
||||
*opt_ptr = iter.opt_ptr; |
||||
return opt_info; |
||||
} |
||||
} |
||||
return nullptr; |
||||
} |
||||
#endif // ROCKSDB_LITE
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// Methods for Configuring Options from Strings/Name-Value Pairs/Maps
|
||||
//
|
||||
//*************************************************************************
|
||||
|
||||
Status Configurable::ConfigureFromMap( |
||||
const ConfigOptions& config_options, |
||||
const std::unordered_map<std::string, std::string>& opts_map) { |
||||
Status s = ConfigureFromMap(config_options, opts_map, nullptr); |
||||
return s; |
||||
} |
||||
|
||||
Status Configurable::ConfigureFromMap( |
||||
const ConfigOptions& config_options, |
||||
const std::unordered_map<std::string, std::string>& opts_map, |
||||
std::unordered_map<std::string, std::string>* unused) { |
||||
return ConfigureOptions(config_options, opts_map, unused); |
||||
} |
||||
|
||||
Status Configurable::ConfigureOptions( |
||||
const ConfigOptions& config_options, |
||||
const std::unordered_map<std::string, std::string>& opts_map, |
||||
std::unordered_map<std::string, std::string>* unused) { |
||||
std::string curr_opts; |
||||
#ifndef ROCKSDB_LITE |
||||
if (!config_options.ignore_unknown_options) { |
||||
// If we are not ignoring unused, get the defaults in case we need to reset
|
||||
GetOptionString(config_options, &curr_opts).PermitUncheckedError(); |
||||
} |
||||
#endif // ROCKSDB_LITE
|
||||
Status s = ConfigurableHelper::ConfigureOptions(config_options, *this, |
||||
opts_map, unused); |
||||
if (config_options.invoke_prepare_options && s.ok()) { |
||||
s = PrepareOptions(config_options); |
||||
} |
||||
#ifndef ROCKSDB_LITE |
||||
if (!s.ok() && !curr_opts.empty()) { |
||||
ConfigOptions reset = config_options; |
||||
reset.ignore_unknown_options = true; |
||||
reset.invoke_prepare_options = true; |
||||
// There are some options to reset from this current error
|
||||
ConfigureFromString(reset, curr_opts).PermitUncheckedError(); |
||||
} |
||||
#endif // ROCKSDB_LITE
|
||||
return s; |
||||
} |
||||
|
||||
Status Configurable::ParseStringOptions(const ConfigOptions& /*config_options*/, |
||||
const std::string& /*opts_str*/) { |
||||
return Status::OK(); |
||||
} |
||||
|
||||
Status Configurable::ConfigureFromString(const ConfigOptions& config_options, |
||||
const std::string& opts_str) { |
||||
Status s; |
||||
if (!opts_str.empty()) { |
||||
#ifndef ROCKSDB_LITE |
||||
if (opts_str.find(';') != std::string::npos || |
||||
opts_str.find('=') != std::string::npos) { |
||||
std::unordered_map<std::string, std::string> opt_map; |
||||
s = StringToMap(opts_str, &opt_map); |
||||
if (s.ok()) { |
||||
s = ConfigureFromMap(config_options, opt_map, nullptr); |
||||
} |
||||
} else { |
||||
#endif // ROCKSDB_LITE
|
||||
s = ParseStringOptions(config_options, opts_str); |
||||
if (s.ok() && config_options.invoke_prepare_options) { |
||||
s = PrepareOptions(config_options); |
||||
} |
||||
#ifndef ROCKSDB_LITE |
||||
} |
||||
#endif // ROCKSDB_LITE
|
||||
} else if (config_options.invoke_prepare_options) { |
||||
s = PrepareOptions(config_options); |
||||
} else { |
||||
s = Status::OK(); |
||||
} |
||||
return s; |
||||
} |
||||
|
||||
#ifndef ROCKSDB_LITE |
||||
/**
|
||||
* Sets the value of the named property to the input value, returning OK on |
||||
* succcess. |
||||
*/ |
||||
Status Configurable::ConfigureOption(const ConfigOptions& config_options, |
||||
const std::string& name, |
||||
const std::string& value) { |
||||
const std::string& opt_name = GetOptionName(name); |
||||
return ConfigurableHelper::ConfigureSingleOption(config_options, *this, |
||||
opt_name, value); |
||||
} |
||||
|
||||
/**
|
||||
* Looks for the named option amongst the options for this type and sets |
||||
* the value for it to be the input value. |
||||
* If the name was found, found_option will be set to true and the resulting |
||||
* status should be returned. |
||||
*/ |
||||
|
||||
Status Configurable::ParseOption(const ConfigOptions& config_options, |
||||
const OptionTypeInfo& opt_info, |
||||
const std::string& opt_name, |
||||
const std::string& opt_value, void* opt_ptr) { |
||||
if (opt_info.IsMutable() || opt_info.IsConfigurable()) { |
||||
return opt_info.Parse(config_options, opt_name, opt_value, opt_ptr); |
||||
} else if (prepared_) { |
||||
return Status::InvalidArgument("Option not changeable: " + opt_name); |
||||
} else { |
||||
return opt_info.Parse(config_options, opt_name, opt_value, opt_ptr); |
||||
} |
||||
} |
||||
|
||||
#endif // ROCKSDB_LITE
|
||||
|
||||
Status ConfigurableHelper::ConfigureOptions( |
||||
const ConfigOptions& config_options, Configurable& configurable, |
||||
const std::unordered_map<std::string, std::string>& opts_map, |
||||
std::unordered_map<std::string, std::string>* unused) { |
||||
std::unordered_map<std::string, std::string> remaining = opts_map; |
||||
Status s = Status::OK(); |
||||
if (!opts_map.empty()) { |
||||
#ifndef ROCKSDB_LITE |
||||
for (const auto& iter : configurable.options_) { |
||||
s = ConfigureSomeOptions(config_options, configurable, *(iter.type_map), |
||||
&remaining, iter.opt_ptr); |
||||
if (remaining.empty()) { // Are there more options left?
|
||||
break; |
||||
} else if (!s.ok()) { |
||||
break; |
||||
} |
||||
} |
||||
#else |
||||
(void)configurable; |
||||
if (!config_options.ignore_unknown_options) { |
||||
s = Status::NotSupported("ConfigureFromMap not supported in LITE mode"); |
||||
} |
||||
#endif // ROCKSDB_LITE
|
||||
} |
||||
if (unused != nullptr && !remaining.empty()) { |
||||
unused->insert(remaining.begin(), remaining.end()); |
||||
} |
||||
if (config_options.ignore_unknown_options) { |
||||
s = Status::OK(); |
||||
} else if (s.ok() && unused == nullptr && !remaining.empty()) { |
||||
s = Status::NotFound("Could not find option: ", remaining.begin()->first); |
||||
} |
||||
return s; |
||||
} |
||||
|
||||
#ifndef ROCKSDB_LITE |
||||
/**
|
||||
* Updates the object with the named-value property values, returning OK on |
||||
* succcess. Any properties that were found are removed from the options list; |
||||
* upon return only options that were not found in this opt_map remain. |
||||
|
||||
* Returns: |
||||
* - OK if ignore_unknown_options is set |
||||
* - InvalidArgument, if any option was invalid |
||||
* - NotSupported, if any option is unsupported and ignore_unsupported_options |
||||
is OFF |
||||
* - OK, if no option was invalid or not supported (or ignored) |
||||
*/ |
||||
Status ConfigurableHelper::ConfigureSomeOptions( |
||||
const ConfigOptions& config_options, Configurable& configurable, |
||||
const std::unordered_map<std::string, OptionTypeInfo>& type_map, |
||||
std::unordered_map<std::string, std::string>* options, void* opt_ptr) { |
||||
Status result = Status::OK(); // The last non-OK result (if any)
|
||||
Status notsup = Status::OK(); // The last NotSupported result (if any)
|
||||
std::string elem_name; |
||||
int found = 1; |
||||
std::unordered_set<std::string> unsupported; |
||||
// While there are unused properties and we processed at least one,
|
||||
// go through the remaining unused properties and attempt to configure them.
|
||||
while (found > 0 && !options->empty()) { |
||||
found = 0; |
||||
notsup = Status::OK(); |
||||
for (auto it = options->begin(); it != options->end();) { |
||||
const std::string& opt_name = configurable.GetOptionName(it->first); |
||||
const std::string& opt_value = it->second; |
||||
const auto opt_info = |
||||
OptionTypeInfo::Find(opt_name, type_map, &elem_name); |
||||
if (opt_info == nullptr) { // Did not find the option. Skip it
|
||||
++it; |
||||
} else { |
||||
Status s = ConfigureOption(config_options, configurable, *opt_info, |
||||
opt_name, elem_name, opt_value, opt_ptr); |
||||
if (s.IsNotFound()) { |
||||
++it; |
||||
} else if (s.IsNotSupported()) { |
||||
notsup = s; |
||||
unsupported.insert(it->first); |
||||
++it; // Skip it for now
|
||||
} else { |
||||
found++; |
||||
it = options->erase(it); |
||||
if (!s.ok()) { |
||||
result = s; |
||||
} |
||||
} |
||||
} |
||||
} // End for all remaining options
|
||||
} // End while found one or options remain
|
||||
|
||||
// Now that we have been through the list, remove any unsupported
|
||||
for (auto u : unsupported) { |
||||
auto it = options->find(u); |
||||
if (it != options->end()) { |
||||
options->erase(it); |
||||
} |
||||
} |
||||
if (config_options.ignore_unknown_options) { |
||||
if (!result.ok()) result.PermitUncheckedError(); |
||||
if (!notsup.ok()) notsup.PermitUncheckedError(); |
||||
return Status::OK(); |
||||
} else if (!result.ok()) { |
||||
if (!notsup.ok()) notsup.PermitUncheckedError(); |
||||
return result; |
||||
} else if (config_options.ignore_unsupported_options) { |
||||
if (!notsup.ok()) notsup.PermitUncheckedError(); |
||||
return Status::OK(); |
||||
} else { |
||||
return notsup; |
||||
} |
||||
} |
||||
|
||||
Status ConfigurableHelper::ConfigureSingleOption( |
||||
const ConfigOptions& config_options, Configurable& configurable, |
||||
const std::string& name, const std::string& value) { |
||||
std::string opt_name; |
||||
void* opt_ptr = nullptr; |
||||
const auto opt_info = |
||||
FindOption(configurable.options_, name, &opt_name, &opt_ptr); |
||||
if (opt_info == nullptr) { |
||||
return Status::NotFound("Could not find option: ", name); |
||||
} else { |
||||
return ConfigureOption(config_options, configurable, *opt_info, name, |
||||
opt_name, value, opt_ptr); |
||||
} |
||||
} |
||||
|
||||
Status ConfigurableHelper::ConfigureOption( |
||||
const ConfigOptions& config_options, Configurable& configurable, |
||||
const OptionTypeInfo& opt_info, const std::string& opt_name, |
||||
const std::string& name, const std::string& value, void* opt_ptr) { |
||||
if (opt_name == name) { |
||||
return configurable.ParseOption(config_options, opt_info, opt_name, value, |
||||
opt_ptr); |
||||
} else if (opt_info.IsStruct() || opt_info.IsConfigurable()) { |
||||
return configurable.ParseOption(config_options, opt_info, name, value, |
||||
opt_ptr); |
||||
} else { |
||||
return Status::NotFound("Could not find option: ", name); |
||||
} |
||||
} |
||||
#endif // ROCKSDB_LITE
|
||||
|
||||
//*******************************************************************************
|
||||
//
|
||||
// Methods for Converting Options into strings
|
||||
//
|
||||
//*******************************************************************************
|
||||
|
||||
Status Configurable::GetOptionString(const ConfigOptions& config_options, |
||||
std::string* result) const { |
||||
assert(result); |
||||
result->clear(); |
||||
#ifndef ROCKSDB_LITE |
||||
return ConfigurableHelper::SerializeOptions(config_options, *this, "", |
||||
result); |
||||
#else |
||||
(void)config_options; |
||||
return Status::NotSupported("GetOptionString not supported in LITE mode"); |
||||
#endif // ROCKSDB_LITE
|
||||
} |
||||
|
||||
#ifndef ROCKSDB_LITE |
||||
std::string Configurable::ToString(const ConfigOptions& config_options, |
||||
const std::string& prefix) const { |
||||
std::string result = SerializeOptions(config_options, prefix); |
||||
if (result.empty() || result.find('=') == std::string::npos) { |
||||
return result; |
||||
} else { |
||||
return "{" + result + "}"; |
||||
} |
||||
} |
||||
|
||||
std::string Configurable::SerializeOptions(const ConfigOptions& config_options, |
||||
const std::string& header) const { |
||||
std::string result; |
||||
Status s = ConfigurableHelper::SerializeOptions(config_options, *this, header, |
||||
&result); |
||||
assert(s.ok()); |
||||
return result; |
||||
} |
||||
|
||||
Status Configurable::GetOption(const ConfigOptions& config_options, |
||||
const std::string& name, |
||||
std::string* value) const { |
||||
return ConfigurableHelper::GetOption(config_options, *this, |
||||
GetOptionName(name), value); |
||||
} |
||||
|
||||
Status ConfigurableHelper::GetOption(const ConfigOptions& config_options, |
||||
const Configurable& configurable, |
||||
const std::string& short_name, |
||||
std::string* value) { |
||||
// Look for option directly
|
||||
assert(value); |
||||
value->clear(); |
||||
|
||||
std::string opt_name; |
||||
void* opt_ptr = nullptr; |
||||
const auto opt_info = |
||||
FindOption(configurable.options_, short_name, &opt_name, &opt_ptr); |
||||
if (opt_info != nullptr) { |
||||
ConfigOptions embedded = config_options; |
||||
embedded.delimiter = ";"; |
||||
if (short_name == opt_name) { |
||||
return opt_info->Serialize(embedded, opt_name, opt_ptr, value); |
||||
} else if (opt_info->IsStruct()) { |
||||
return opt_info->Serialize(embedded, opt_name, opt_ptr, value); |
||||
} else if (opt_info->IsConfigurable()) { |
||||
auto const* config = opt_info->AsRawPointer<Configurable>(opt_ptr); |
||||
if (config != nullptr) { |
||||
return config->GetOption(embedded, opt_name, value); |
||||
} |
||||
} |
||||
} |
||||
return Status::NotFound("Cannot find option: ", short_name); |
||||
} |
||||
|
||||
Status ConfigurableHelper::SerializeOptions(const ConfigOptions& config_options, |
||||
const Configurable& configurable, |
||||
const std::string& prefix, |
||||
std::string* result) { |
||||
assert(result); |
||||
for (auto const& opt_iter : configurable.options_) { |
||||
for (const auto& map_iter : *(opt_iter.type_map)) { |
||||
const auto& opt_name = map_iter.first; |
||||
const auto& opt_info = map_iter.second; |
||||
if (opt_info.ShouldSerialize()) { |
||||
std::string value; |
||||
Status s = opt_info.Serialize(config_options, prefix + opt_name, |
||||
opt_iter.opt_ptr, &value); |
||||
if (!s.ok()) { |
||||
return s; |
||||
} else if (!value.empty()) { |
||||
// <prefix><opt_name>=<value><delimiter>
|
||||
result->append(prefix + opt_name + "=" + value + |
||||
config_options.delimiter); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
return Status::OK(); |
||||
} |
||||
#endif // ROCKSDB_LITE
|
||||
|
||||
//********************************************************************************
|
||||
//
|
||||
// Methods for listing the options from Configurables
|
||||
//
|
||||
//********************************************************************************
|
||||
#ifndef ROCKSDB_LITE |
||||
Status Configurable::GetOptionNames( |
||||
const ConfigOptions& config_options, |
||||
std::unordered_set<std::string>* result) const { |
||||
assert(result); |
||||
return ConfigurableHelper::ListOptions(config_options, *this, "", result); |
||||
} |
||||
|
||||
Status ConfigurableHelper::ListOptions( |
||||
const ConfigOptions& /*config_options*/, const Configurable& configurable, |
||||
const std::string& prefix, std::unordered_set<std::string>* result) { |
||||
Status status; |
||||
for (auto const& opt_iter : configurable.options_) { |
||||
for (const auto& map_iter : *(opt_iter.type_map)) { |
||||
const auto& opt_name = map_iter.first; |
||||
const auto& opt_info = map_iter.second; |
||||
// If the option is no longer used in rocksdb and marked as deprecated,
|
||||
// we skip it in the serialization.
|
||||
if (!opt_info.IsDeprecated() && !opt_info.IsAlias()) { |
||||
result->emplace(prefix + opt_name); |
||||
} |
||||
} |
||||
} |
||||
return status; |
||||
} |
||||
#endif // ROCKSDB_LITE
|
||||
|
||||
//*******************************************************************************
|
||||
//
|
||||
// Methods for Comparing Configurables
|
||||
//
|
||||
//*******************************************************************************
|
||||
|
||||
bool Configurable::AreEquivalent(const ConfigOptions& config_options, |
||||
const Configurable* other, |
||||
std::string* name) const { |
||||
assert(name); |
||||
name->clear(); |
||||
if (this == other || config_options.IsCheckDisabled()) { |
||||
return true; |
||||
} else if (other != nullptr) { |
||||
#ifndef ROCKSDB_LITE |
||||
return ConfigurableHelper::AreEquivalent(config_options, *this, *other, |
||||
name); |
||||
#else |
||||
return true; |
||||
#endif // ROCKSDB_LITE
|
||||
} else { |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
#ifndef ROCKSDB_LITE |
||||
bool Configurable::OptionsAreEqual(const ConfigOptions& config_options, |
||||
const OptionTypeInfo& opt_info, |
||||
const std::string& opt_name, |
||||
const void* const this_ptr, |
||||
const void* const that_ptr, |
||||
std::string* mismatch) const { |
||||
if (opt_info.AreEqual(config_options, opt_name, this_ptr, that_ptr, |
||||
mismatch)) { |
||||
return true; |
||||
} else if (opt_info.AreEqualByName(config_options, opt_name, this_ptr, |
||||
that_ptr)) { |
||||
*mismatch = ""; |
||||
return true; |
||||
} else { |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
bool ConfigurableHelper::AreEquivalent(const ConfigOptions& config_options, |
||||
const Configurable& this_one, |
||||
const Configurable& that_one, |
||||
std::string* mismatch) { |
||||
assert(mismatch != nullptr); |
||||
for (auto const& o : this_one.options_) { |
||||
const auto this_offset = this_one.GetOptionsPtr(o.name); |
||||
const auto that_offset = that_one.GetOptionsPtr(o.name); |
||||
if (this_offset != that_offset) { |
||||
if (this_offset == nullptr || that_offset == nullptr) { |
||||
return false; |
||||
} else { |
||||
for (const auto& map_iter : *(o.type_map)) { |
||||
if (config_options.IsCheckEnabled(map_iter.second.GetSanityLevel()) && |
||||
!this_one.OptionsAreEqual(config_options, map_iter.second, |
||||
map_iter.first, this_offset, |
||||
that_offset, mismatch)) { |
||||
return false; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} |
||||
return true; |
||||
} |
||||
#endif // ROCKSDB_LITE
|
||||
} // namespace ROCKSDB_NAMESPACE
|
||||
@ -0,0 +1,211 @@ |
||||
// 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).
|
||||
|
||||
#pragma once |
||||
|
||||
#include <map> |
||||
#include <stdexcept> |
||||
#include <string> |
||||
#include <vector> |
||||
|
||||
#include "rocksdb/configurable.h" |
||||
#include "rocksdb/convenience.h" |
||||
|
||||
namespace ROCKSDB_NAMESPACE { |
||||
// Helper class defining static methods for supporting the Configurable
|
||||
// class. The purpose of this class is to keep the Configurable class
|
||||
// as tight as possible and provide methods for doing the actual work
|
||||
// of configuring the objects.
|
||||
class ConfigurableHelper { |
||||
public: |
||||
// Registers the input name with the options and associated map.
|
||||
// When classes register their options in this manner, most of the
|
||||
// functionality (excluding unknown options and validate/prepare) is
|
||||
// implemented by the base class.
|
||||
//
|
||||
// This method should be called in the class constructor to register the
|
||||
// option set for this object. For example, to register the options
|
||||
// associated with the BlockBasedTableFactory, the constructor calls this
|
||||
// method passing in:
|
||||
// - the name of the options ("BlockBasedTableOptions");
|
||||
// - the options object (the BlockBasedTableOptions object for this object;
|
||||
// - the options type map for the BlockBasedTableOptions.
|
||||
// This registration allows the Configurable class to process the option
|
||||
// values associated with the BlockBasedTableOptions without further code in
|
||||
// the derived class.
|
||||
//
|
||||
// @param name The name of this set of options (@see GetOptionsPtr)
|
||||
// @param opt_ptr Pointer to the options to associate with this name
|
||||
// @param opt_map Options map that controls how this option is configured.
|
||||
template <typename T> |
||||
static void RegisterOptions( |
||||
Configurable& configurable, T* opt_ptr, |
||||
const std::unordered_map<std::string, OptionTypeInfo>* opt_map) { |
||||
RegisterOptions(configurable, T::kName(), opt_ptr, opt_map); |
||||
} |
||||
static void RegisterOptions( |
||||
Configurable& configurable, const std::string& name, void* opt_ptr, |
||||
const std::unordered_map<std::string, OptionTypeInfo>* opt_map); |
||||
|
||||
// Configures the input Configurable object based on the parameters.
|
||||
// On successful completion, the Configurable is updated with the settings
|
||||
// from the opt_map.
|
||||
//
|
||||
// The acceptable values of the name/value pairs are documented with the
|
||||
// specific class/instance.
|
||||
//
|
||||
// @param config_options Controls how the arguments are processed.
|
||||
// @param opt_map Name/value pairs of the options to update
|
||||
// @param unused If specified, this value will return the name/value
|
||||
// pairs from opt_map that were NotFound for this object.
|
||||
// @return OK If all values in the map were successfully updated
|
||||
// @return NotFound If any of the names in the opt_map were not valid
|
||||
// for this object. If unused is specified, it will contain the
|
||||
// collection of NotFound entries
|
||||
// @return NotSupported If any of the names are valid but the object does
|
||||
// not know how to convert the value. This can happen if, for example,
|
||||
// there is some nested Configurable that cannot be created.
|
||||
// @return InvalidArgument If any of the values cannot be successfully
|
||||
// parsed. This can also be returned if PrepareOptions encounters an
|
||||
// error.
|
||||
static Status ConfigureOptions( |
||||
const ConfigOptions& config_options, Configurable& configurable, |
||||
const std::unordered_map<std::string, std::string>& options, |
||||
std::unordered_map<std::string, std::string>* unused); |
||||
|
||||
#ifndef ROCKSDB_LITE |
||||
// Internal method to configure a set of options for this object.
|
||||
// Classes may override this value to change its behavior.
|
||||
// @param config_options Controls how the options are being configured
|
||||
// @param type_name The name that was registered for this set of options
|
||||
// @param type_map The map of options for this name
|
||||
// @param opt_ptr Pointer to the object being configured for this option set.
|
||||
// @param options The option name/values being updated. On return, any
|
||||
// option that was found is removed from the list.
|
||||
// @return OK If all of the options were successfully updated.
|
||||
// @return InvalidArgument If an option was found but the value could not
|
||||
// be updated.
|
||||
// @return NotFound If an option name was not found in type_mape
|
||||
// @return NotSupported If the option was found but no rule for converting
|
||||
// the value could be found.
|
||||
static Status ConfigureSomeOptions( |
||||
const ConfigOptions& config_options, Configurable& configurable, |
||||
const std::unordered_map<std::string, OptionTypeInfo>& type_map, |
||||
std::unordered_map<std::string, std::string>* options, void* opt_ptr); |
||||
|
||||
// Configures a single option in the input Configurable.
|
||||
// This method will look through the set of option names for this
|
||||
// Configurable searching for one with the input name. If such an option
|
||||
// is found, it will be configured via the input value.
|
||||
//
|
||||
// @param config_options Controls how the option is being configured
|
||||
// @param configurable The object to configure
|
||||
// @param name For options with sub-options (like Structs or
|
||||
// Configurables),
|
||||
// this value may be the name of the sub-field of the option being
|
||||
// updated. For example, if the option is
|
||||
// "compaction_options_fifo.allow_compaction", then field name would be
|
||||
// "allow_compaction". For most options, field_name and opt_name will be
|
||||
// equivalent.
|
||||
// @param value The new value for this option.
|
||||
// @param See ConfigureOptions for the possible return values
|
||||
static Status ConfigureSingleOption(const ConfigOptions& config_options, |
||||
Configurable& configurable, |
||||
const std::string& name, |
||||
const std::string& value); |
||||
|
||||
// Configures the option referenced by opt_info for this configurable
|
||||
// This method configures the option based on opt_info for the input
|
||||
// configurable.
|
||||
// @param config_options Controls how the option is being configured
|
||||
// @param configurable The object to configure
|
||||
// @param opt_name The full option name
|
||||
// @param name For options with sub-options (like Structs or
|
||||
// Configurables),
|
||||
// this value may be the name of the sub-field of the option being
|
||||
// updated. For example, if the option is
|
||||
// "compaction_options_fifo.allow_compaction", then field name would be
|
||||
// "allow_compaction". For most options, field_name and opt_name will be
|
||||
// equivalent.
|
||||
// @param value The new value for this option.
|
||||
// @param See ConfigureOptions for the possible return values
|
||||
static Status ConfigureOption(const ConfigOptions& config_options, |
||||
Configurable& configurable, |
||||
const OptionTypeInfo& opt_info, |
||||
const std::string& opt_name, |
||||
const std::string& name, |
||||
const std::string& value, void* opt_ptr); |
||||
|
||||
// Returns the value of the option associated with the input name
|
||||
// This method is the functional inverse of ConfigureOption
|
||||
// @param config_options Controls how the value is returned
|
||||
// @param configurable The object from which to get the option.
|
||||
// @param name The name of the option to return a value for.
|
||||
// @param value The returned value associated with the named option.
|
||||
// Note that value will be only the serialized version
|
||||
// of the option and not "name=value"
|
||||
// @return OK If the named field was successfully updated to value.
|
||||
// @return NotFound If the name is not valid for this object.
|
||||
// @param InvalidArgument If the name is valid for this object but
|
||||
// its value cannot be serialized.
|
||||
static Status GetOption(const ConfigOptions& config_options, |
||||
const Configurable& configurable, |
||||
const std::string& name, std::string* value); |
||||
|
||||
// Serializes the input Configurable into the output result.
|
||||
// This is the inverse of ConfigureOptions
|
||||
// @param config_options Controls how serialization happens.
|
||||
// @param configurable The object to serialize
|
||||
// @param prefix A prefix to add to the each option as it is serialized.
|
||||
// @param result The string representation of the configurable.
|
||||
// @return OK If the options for this object wer successfully serialized.
|
||||
// @return InvalidArgument If one or more of the options could not be
|
||||
// serialized.
|
||||
static Status SerializeOptions(const ConfigOptions& config_options, |
||||
const Configurable& configurable, |
||||
const std::string& prefix, |
||||
std::string* result); |
||||
|
||||
// Internal method to list the option names for this object.
|
||||
// Classes may override this value to change its behavior.
|
||||
// @see ListOptions for more details
|
||||
static Status ListOptions(const ConfigOptions& config_options, |
||||
const Configurable& configurable, |
||||
const std::string& prefix, |
||||
std::unordered_set<std::string>* result); |
||||
|
||||
// Checks to see if the two configurables are equivalent to one other.
|
||||
// This method assumes that the two objects are of the same class.
|
||||
// @param config_options Controls how the options are compared.
|
||||
// @param this_one The object to compare to.
|
||||
// @param that_one The other object being compared.
|
||||
// @param mismatch If the objects do not match, this parameter contains
|
||||
// the name of the option that triggered the match failure.
|
||||
// @param True if the objects match, false otherwise.
|
||||
static bool AreEquivalent(const ConfigOptions& config_options, |
||||
const Configurable& this_one, |
||||
const Configurable& that_one, |
||||
std::string* mismatch); |
||||
|
||||
private: |
||||
// Looks for the option specified by name in the RegisteredOptions.
|
||||
// This method traverses the types in the input options vector. If an entry
|
||||
// matching name is found, that entry, opt_name, and pointer are returned.
|
||||
// @param options The vector of options to search through
|
||||
// @param name The name of the option to search for in the OptionType map
|
||||
// @param opt_name If the name was found, this value is set to the option name
|
||||
// associated with the input name/type.
|
||||
// @param opt_ptr If the name was found, this value is set to the option
|
||||
// pointer
|
||||
// in the RegisteredOptions vector associated with this entry
|
||||
// @return A pointer to the OptionTypeInfo from the options if found,
|
||||
// nullptr if the name was not found in the input options
|
||||
static const OptionTypeInfo* FindOption( |
||||
const std::vector<Configurable::RegisteredOptions>& options, |
||||
const std::string& name, std::string* opt_name, void** opt_ptr); |
||||
#endif // ROCKSDB_LITE
|
||||
}; |
||||
|
||||
} // namespace ROCKSDB_NAMESPACE
|
||||
@ -0,0 +1,791 @@ |
||||
// 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.
|
||||
|
||||
#include "options/configurable_test.h" |
||||
|
||||
#include <cctype> |
||||
#include <cinttypes> |
||||
#include <cstring> |
||||
#include <unordered_map> |
||||
|
||||
#include "options/configurable_helper.h" |
||||
#include "options/options_helper.h" |
||||
#include "options/options_parser.h" |
||||
#include "rocksdb/configurable.h" |
||||
#include "test_util/testharness.h" |
||||
#include "test_util/testutil.h" |
||||
|
||||
#ifndef GFLAGS |
||||
bool FLAGS_enable_print = false; |
||||
#else |
||||
#include "util/gflags_compat.h" |
||||
using GFLAGS_NAMESPACE::ParseCommandLineFlags; |
||||
DEFINE_bool(enable_print, false, "Print options generated to console."); |
||||
#endif // GFLAGS
|
||||
|
||||
namespace ROCKSDB_NAMESPACE { |
||||
namespace test { |
||||
class StringLogger : public Logger { |
||||
public: |
||||
using Logger::Logv; |
||||
void Logv(const char* format, va_list ap) override { |
||||
char buffer[1000]; |
||||
vsnprintf(buffer, sizeof(buffer), format, ap); |
||||
string_.append(buffer); |
||||
} |
||||
const std::string& str() const { return string_; } |
||||
void clear() { string_.clear(); } |
||||
|
||||
private: |
||||
std::string string_; |
||||
}; |
||||
|
||||
class SimpleConfigurable : public TestConfigurable<Configurable> { |
||||
public: |
||||
static SimpleConfigurable* Create( |
||||
const std::string& name = "simple", |
||||
int mode = TestConfigMode::kDefaultMode, |
||||
const std::unordered_map<std::string, OptionTypeInfo>* map = |
||||
&simple_option_info) { |
||||
return new SimpleConfigurable(name, mode, map); |
||||
} |
||||
|
||||
SimpleConfigurable(const std::string& name, int mode, |
||||
const std::unordered_map<std::string, OptionTypeInfo>* |
||||
map = &simple_option_info) |
||||
: TestConfigurable(name, mode, map) { |
||||
if ((mode & TestConfigMode::kUniqueMode) != 0) { |
||||
unique_.reset(SimpleConfigurable::Create("Unique" + name_)); |
||||
ConfigurableHelper::RegisterOptions(*this, name_ + "Unique", &unique_, |
||||
&unique_option_info); |
||||
} |
||||
if ((mode & TestConfigMode::kSharedMode) != 0) { |
||||
shared_.reset(SimpleConfigurable::Create("Shared" + name_)); |
||||
ConfigurableHelper::RegisterOptions(*this, name_ + "Shared", &shared_, |
||||
&shared_option_info); |
||||
} |
||||
if ((mode & TestConfigMode::kRawPtrMode) != 0) { |
||||
pointer_ = SimpleConfigurable::Create("Pointer" + name_); |
||||
ConfigurableHelper::RegisterOptions(*this, name_ + "Pointer", &pointer_, |
||||
&pointer_option_info); |
||||
} |
||||
} |
||||
|
||||
}; // End class SimpleConfigurable
|
||||
|
||||
static std::unordered_map<std::string, OptionTypeInfo> wrapped_option_info = { |
||||
#ifndef ROCKSDB_LITE |
||||
{"inner", |
||||
{0, OptionType::kConfigurable, OptionVerificationType::kNormal, |
||||
OptionTypeFlags::kShared}}, |
||||
#endif // ROCKSDB_LITE
|
||||
}; |
||||
class WrappedConfigurable : public SimpleConfigurable { |
||||
public: |
||||
WrappedConfigurable(const std::string& name, unsigned char mode, |
||||
const std::shared_ptr<Configurable>& t) |
||||
: SimpleConfigurable(name, mode, &simple_option_info), inner_(t) { |
||||
ConfigurableHelper::RegisterOptions(*this, "WrappedOptions", &inner_, |
||||
&wrapped_option_info); |
||||
} |
||||
|
||||
protected: |
||||
Configurable* Inner() const override { return inner_.get(); } |
||||
|
||||
private: |
||||
std::shared_ptr<Configurable> inner_; |
||||
}; |
||||
|
||||
using ConfigTestFactoryFunc = std::function<Configurable*()>; |
||||
|
||||
class ConfigurableTest : public testing::Test { |
||||
public: |
||||
ConfigurableTest() { config_options_.invoke_prepare_options = false; } |
||||
|
||||
ConfigOptions config_options_; |
||||
}; |
||||
|
||||
class ConfigurableParamTest |
||||
: public ConfigurableTest, |
||||
virtual public ::testing::WithParamInterface< |
||||
std::pair<std::string, ConfigTestFactoryFunc>> { |
||||
public: |
||||
ConfigurableParamTest() { |
||||
configuration_ = GetParam().first; |
||||
factory_ = GetParam().second; |
||||
object_.reset(factory_()); |
||||
} |
||||
void TestConfigureOptions(const ConfigOptions& opts); |
||||
ConfigTestFactoryFunc factory_; |
||||
std::string configuration_; |
||||
std::unique_ptr<Configurable> object_; |
||||
}; |
||||
|
||||
TEST_F(ConfigurableTest, GetOptionsPtrTest) { |
||||
std::string opt_str; |
||||
std::unique_ptr<Configurable> configurable(SimpleConfigurable::Create()); |
||||
ASSERT_NE(configurable->GetOptions<TestOptions>("simple"), nullptr); |
||||
ASSERT_EQ(configurable->GetOptions<TestOptions>("bad-opt"), nullptr); |
||||
} |
||||
|
||||
TEST_F(ConfigurableTest, ConfigureFromMapTest) { |
||||
std::unique_ptr<Configurable> configurable(SimpleConfigurable::Create()); |
||||
auto* opts = configurable->GetOptions<TestOptions>("simple"); |
||||
ASSERT_OK(configurable->ConfigureFromMap(config_options_, {})); |
||||
ASSERT_NE(opts, nullptr); |
||||
#ifndef ROCKSDB_LITE |
||||
std::unordered_map<std::string, std::string> options_map = { |
||||
{"int", "1"}, {"bool", "true"}, {"string", "string"}}; |
||||
ASSERT_OK(configurable->ConfigureFromMap(config_options_, options_map)); |
||||
ASSERT_EQ(opts->i, 1); |
||||
ASSERT_EQ(opts->b, true); |
||||
ASSERT_EQ(opts->s, "string"); |
||||
#endif |
||||
} |
||||
|
||||
TEST_F(ConfigurableTest, ConfigureFromStringTest) { |
||||
std::unique_ptr<Configurable> configurable(SimpleConfigurable::Create()); |
||||
auto* opts = configurable->GetOptions<TestOptions>("simple"); |
||||
ASSERT_OK(configurable->ConfigureFromString(config_options_, "")); |
||||
ASSERT_NE(opts, nullptr); |
||||
#ifndef ROCKSDB_LITE // GetOptionsFromMap is not supported in ROCKSDB_LITE
|
||||
ASSERT_OK(configurable->ConfigureFromString(config_options_, |
||||
"int=1;bool=true;string=s")); |
||||
ASSERT_EQ(opts->i, 1); |
||||
ASSERT_EQ(opts->b, true); |
||||
ASSERT_EQ(opts->s, "s"); |
||||
#endif |
||||
} |
||||
|
||||
#ifndef ROCKSDB_LITE // GetOptionsFromMap is not supported in ROCKSDB_LITE
|
||||
TEST_F(ConfigurableTest, ConfigureIgnoreTest) { |
||||
std::unique_ptr<Configurable> configurable(SimpleConfigurable::Create()); |
||||
std::unordered_map<std::string, std::string> options_map = {{"unused", "u"}}; |
||||
ConfigOptions ignore = config_options_; |
||||
ignore.ignore_unknown_options = true; |
||||
ASSERT_NOK(configurable->ConfigureFromMap(config_options_, options_map)); |
||||
ASSERT_OK(configurable->ConfigureFromMap(ignore, options_map)); |
||||
ASSERT_NOK(configurable->ConfigureFromString(config_options_, "unused=u")); |
||||
ASSERT_OK(configurable->ConfigureFromString(ignore, "unused=u")); |
||||
} |
||||
|
||||
TEST_F(ConfigurableTest, ConfigureNestedOptionsTest) { |
||||
std::unique_ptr<Configurable> base, copy; |
||||
std::string opt_str; |
||||
std::string mismatch; |
||||
|
||||
base.reset(SimpleConfigurable::Create("simple", TestConfigMode::kAllOptMode)); |
||||
copy.reset(SimpleConfigurable::Create("simple", TestConfigMode::kAllOptMode)); |
||||
ASSERT_OK(base->ConfigureFromString(config_options_, |
||||
"shared={int=10; string=10};" |
||||
"unique={int=20; string=20};" |
||||
"pointer={int=30; string=30};")); |
||||
ASSERT_OK(base->GetOptionString(config_options_, &opt_str)); |
||||
ASSERT_OK(copy->ConfigureFromString(config_options_, opt_str)); |
||||
ASSERT_TRUE(base->AreEquivalent(config_options_, copy.get(), &mismatch)); |
||||
} |
||||
|
||||
TEST_F(ConfigurableTest, GetOptionsTest) { |
||||
std::unique_ptr<Configurable> simple; |
||||
|
||||
simple.reset( |
||||
SimpleConfigurable::Create("simple", TestConfigMode::kAllOptMode)); |
||||
int i = 11; |
||||
for (auto opt : {"", "shared.", "unique.", "pointer."}) { |
||||
std::string value; |
||||
std::string expected = ToString(i); |
||||
std::string opt_name = opt; |
||||
ASSERT_OK( |
||||
simple->ConfigureOption(config_options_, opt_name + "int", expected)); |
||||
ASSERT_OK(simple->GetOption(config_options_, opt_name + "int", &value)); |
||||
ASSERT_EQ(expected, value); |
||||
ASSERT_OK(simple->ConfigureOption(config_options_, opt_name + "string", |
||||
expected)); |
||||
ASSERT_OK(simple->GetOption(config_options_, opt_name + "string", &value)); |
||||
ASSERT_EQ(expected, value); |
||||
|
||||
ASSERT_NOK( |
||||
simple->ConfigureOption(config_options_, opt_name + "bad", expected)); |
||||
ASSERT_NOK(simple->GetOption(config_options_, "bad option", &value)); |
||||
ASSERT_TRUE(value.empty()); |
||||
i += 11; |
||||
} |
||||
} |
||||
|
||||
TEST_F(ConfigurableTest, ConfigureBadOptionsTest) { |
||||
std::unique_ptr<Configurable> configurable(SimpleConfigurable::Create()); |
||||
auto* opts = configurable->GetOptions<TestOptions>("simple"); |
||||
ASSERT_NE(opts, nullptr); |
||||
ASSERT_OK(configurable->ConfigureOption(config_options_, "int", "42")); |
||||
ASSERT_EQ(opts->i, 42); |
||||
ASSERT_NOK(configurable->ConfigureOption(config_options_, "int", "fred")); |
||||
ASSERT_NOK(configurable->ConfigureOption(config_options_, "bool", "fred")); |
||||
ASSERT_NOK( |
||||
configurable->ConfigureFromString(config_options_, "int=33;unused=u")); |
||||
ASSERT_EQ(opts->i, 42); |
||||
} |
||||
|
||||
TEST_F(ConfigurableTest, InvalidOptionTest) { |
||||
std::unique_ptr<Configurable> configurable(SimpleConfigurable::Create()); |
||||
std::unordered_map<std::string, std::string> options_map = { |
||||
{"bad-option", "bad"}}; |
||||
ASSERT_NOK(configurable->ConfigureFromMap(config_options_, options_map)); |
||||
ASSERT_NOK( |
||||
configurable->ConfigureFromString(config_options_, "bad-option=bad")); |
||||
ASSERT_NOK( |
||||
configurable->ConfigureOption(config_options_, "bad-option", "bad")); |
||||
} |
||||
|
||||
static std::unordered_map<std::string, OptionTypeInfo> validated_option_info = { |
||||
#ifndef ROCKSDB_LITE |
||||
{"validated", |
||||
{0, OptionType::kBoolean, OptionVerificationType::kNormal, |
||||
OptionTypeFlags::kNone}}, |
||||
#endif // ROCKSDB_LITE
|
||||
}; |
||||
static std::unordered_map<std::string, OptionTypeInfo> prepared_option_info = { |
||||
#ifndef ROCKSDB_LITE |
||||
{"prepared", |
||||
{0, OptionType::kInt, OptionVerificationType::kNormal, |
||||
OptionTypeFlags::kMutable}}, |
||||
#endif // ROCKSDB_LITE
|
||||
}; |
||||
static std::unordered_map<std::string, OptionTypeInfo> |
||||
dont_prepare_option_info = { |
||||
#ifndef ROCKSDB_LITE |
||||
{"unique", |
||||
{0, OptionType::kConfigurable, OptionVerificationType::kNormal, |
||||
(OptionTypeFlags::kUnique | OptionTypeFlags::kDontPrepare)}}, |
||||
|
||||
#endif // ROCKSDB_LITE
|
||||
}; |
||||
|
||||
class ValidatedConfigurable : public SimpleConfigurable { |
||||
public: |
||||
ValidatedConfigurable(const std::string& name, unsigned char mode, |
||||
bool dont_prepare = false) |
||||
: SimpleConfigurable(name, TestConfigMode::kDefaultMode), |
||||
validated(false), |
||||
prepared(0) { |
||||
ConfigurableHelper::RegisterOptions(*this, "Validated", &validated, |
||||
&validated_option_info); |
||||
ConfigurableHelper::RegisterOptions(*this, "Prepared", &prepared, |
||||
&prepared_option_info); |
||||
if ((mode & TestConfigMode::kUniqueMode) != 0) { |
||||
unique_.reset(new ValidatedConfigurable( |
||||
"Unique" + name_, TestConfigMode::kDefaultMode, false)); |
||||
if (dont_prepare) { |
||||
ConfigurableHelper::RegisterOptions(*this, name_ + "Unique", &unique_, |
||||
&dont_prepare_option_info); |
||||
} else { |
||||
ConfigurableHelper::RegisterOptions(*this, name_ + "Unique", &unique_, |
||||
&unique_option_info); |
||||
} |
||||
} |
||||
} |
||||
|
||||
Status PrepareOptions(const ConfigOptions& config_options) override { |
||||
if (++prepared <= 0) { |
||||
return Status::InvalidArgument("Cannot prepare option"); |
||||
} else { |
||||
return SimpleConfigurable::PrepareOptions(config_options); |
||||
} |
||||
} |
||||
|
||||
Status ValidateOptions(const DBOptions& db_opts, |
||||
const ColumnFamilyOptions& cf_opts) const override { |
||||
if (!validated) { |
||||
return Status::InvalidArgument("Not Validated"); |
||||
} else { |
||||
return SimpleConfigurable::ValidateOptions(db_opts, cf_opts); |
||||
} |
||||
} |
||||
|
||||
private: |
||||
bool validated; |
||||
int prepared; |
||||
}; |
||||
|
||||
TEST_F(ConfigurableTest, ValidateOptionsTest) { |
||||
std::unique_ptr<Configurable> configurable( |
||||
new ValidatedConfigurable("validated", TestConfigMode::kDefaultMode)); |
||||
ColumnFamilyOptions cf_opts; |
||||
DBOptions db_opts; |
||||
ASSERT_OK( |
||||
configurable->ConfigureOption(config_options_, "validated", "false")); |
||||
ASSERT_NOK(configurable->ValidateOptions(db_opts, cf_opts)); |
||||
ASSERT_OK( |
||||
configurable->ConfigureOption(config_options_, "validated", "true")); |
||||
ASSERT_OK(configurable->ValidateOptions(db_opts, cf_opts)); |
||||
} |
||||
|
||||
TEST_F(ConfigurableTest, PrepareOptionsTest) { |
||||
std::unique_ptr<Configurable> c( |
||||
new ValidatedConfigurable("Simple", TestConfigMode::kUniqueMode, false)); |
||||
auto cp = c->GetOptions<int>("Prepared"); |
||||
auto u = c->GetOptions<std::unique_ptr<Configurable>>("SimpleUnique"); |
||||
auto up = u->get()->GetOptions<int>("Prepared"); |
||||
config_options_.invoke_prepare_options = false; |
||||
|
||||
ASSERT_NE(cp, nullptr); |
||||
ASSERT_NE(up, nullptr); |
||||
ASSERT_EQ(*cp, 0); |
||||
ASSERT_EQ(*up, 0); |
||||
ASSERT_OK(c->ConfigureFromMap(config_options_, {})); |
||||
ASSERT_EQ(*cp, 0); |
||||
ASSERT_EQ(*up, 0); |
||||
config_options_.invoke_prepare_options = true; |
||||
ASSERT_OK(c->ConfigureFromMap(config_options_, {})); |
||||
ASSERT_EQ(*cp, 1); |
||||
ASSERT_EQ(*up, 1); |
||||
ASSERT_OK(c->ConfigureFromString(config_options_, "prepared=0")); |
||||
ASSERT_EQ(*up, 2); |
||||
ASSERT_EQ(*cp, 1); |
||||
|
||||
ASSERT_NOK(c->ConfigureFromString(config_options_, "prepared=-2")); |
||||
|
||||
c.reset( |
||||
new ValidatedConfigurable("Simple", TestConfigMode::kUniqueMode, true)); |
||||
cp = c->GetOptions<int>("Prepared"); |
||||
u = c->GetOptions<std::unique_ptr<Configurable>>("SimpleUnique"); |
||||
up = u->get()->GetOptions<int>("Prepared"); |
||||
|
||||
ASSERT_OK(c->ConfigureFromString(config_options_, "prepared=0")); |
||||
ASSERT_EQ(*cp, 1); |
||||
ASSERT_EQ(*up, 0); |
||||
} |
||||
|
||||
TEST_F(ConfigurableTest, DeprecatedOptionsTest) { |
||||
static std::unordered_map<std::string, OptionTypeInfo> |
||||
deprecated_option_info = { |
||||
{"deprecated", |
||||
{offsetof(struct TestOptions, b), OptionType::kBoolean, |
||||
OptionVerificationType::kDeprecated, OptionTypeFlags::kNone}}}; |
||||
std::unique_ptr<Configurable> orig; |
||||
orig.reset(SimpleConfigurable::Create("simple", TestConfigMode::kDefaultMode, |
||||
&deprecated_option_info)); |
||||
auto* opts = orig->GetOptions<TestOptions>("simple"); |
||||
ASSERT_NE(opts, nullptr); |
||||
opts->d = true; |
||||
ASSERT_OK(orig->ConfigureOption(config_options_, "deprecated", "false")); |
||||
ASSERT_TRUE(opts->d); |
||||
ASSERT_OK(orig->ConfigureFromString(config_options_, "deprecated=false")); |
||||
ASSERT_TRUE(opts->d); |
||||
} |
||||
|
||||
TEST_F(ConfigurableTest, AliasOptionsTest) { |
||||
static std::unordered_map<std::string, OptionTypeInfo> alias_option_info = { |
||||
{"bool", |
||||
{offsetof(struct TestOptions, b), OptionType::kBoolean, |
||||
OptionVerificationType::kNormal, OptionTypeFlags::kNone}}, |
||||
{"alias", |
||||
{offsetof(struct TestOptions, b), OptionType::kBoolean, |
||||
OptionVerificationType::kAlias, OptionTypeFlags::kNone, 0}}}; |
||||
std::unique_ptr<Configurable> orig; |
||||
orig.reset(SimpleConfigurable::Create("simple", TestConfigMode::kDefaultMode, |
||||
&alias_option_info)); |
||||
auto* opts = orig->GetOptions<TestOptions>("simple"); |
||||
ASSERT_NE(opts, nullptr); |
||||
ASSERT_OK(orig->ConfigureOption(config_options_, "bool", "false")); |
||||
ASSERT_FALSE(opts->b); |
||||
ASSERT_OK(orig->ConfigureOption(config_options_, "alias", "true")); |
||||
ASSERT_TRUE(opts->b); |
||||
std::string opts_str; |
||||
ASSERT_OK(orig->GetOptionString(config_options_, &opts_str)); |
||||
ASSERT_EQ(opts_str.find("alias"), std::string::npos); |
||||
|
||||
ASSERT_OK(orig->ConfigureOption(config_options_, "bool", "false")); |
||||
ASSERT_FALSE(opts->b); |
||||
ASSERT_OK(orig->GetOption(config_options_, "alias", &opts_str)); |
||||
ASSERT_EQ(opts_str, "false"); |
||||
} |
||||
|
||||
TEST_F(ConfigurableTest, NestedUniqueConfigTest) { |
||||
std::unique_ptr<Configurable> simple; |
||||
simple.reset( |
||||
SimpleConfigurable::Create("Outer", TestConfigMode::kAllOptMode)); |
||||
const auto outer = simple->GetOptions<TestOptions>("Outer"); |
||||
const auto unique = |
||||
simple->GetOptions<std::unique_ptr<Configurable>>("OuterUnique"); |
||||
ASSERT_NE(outer, nullptr); |
||||
ASSERT_NE(unique, nullptr); |
||||
ASSERT_OK( |
||||
simple->ConfigureFromString(config_options_, "int=24;string=outer")); |
||||
ASSERT_OK(simple->ConfigureFromString(config_options_, |
||||
"unique={int=42;string=nested}")); |
||||
const auto inner = unique->get()->GetOptions<TestOptions>("UniqueOuter"); |
||||
ASSERT_NE(inner, nullptr); |
||||
ASSERT_EQ(outer->i, 24); |
||||
ASSERT_EQ(outer->s, "outer"); |
||||
ASSERT_EQ(inner->i, 42); |
||||
ASSERT_EQ(inner->s, "nested"); |
||||
} |
||||
|
||||
TEST_F(ConfigurableTest, NestedSharedConfigTest) { |
||||
std::unique_ptr<Configurable> simple; |
||||
simple.reset(SimpleConfigurable::Create( |
||||
"Outer", TestConfigMode::kDefaultMode | TestConfigMode::kSharedMode)); |
||||
ASSERT_OK( |
||||
simple->ConfigureFromString(config_options_, "int=24;string=outer")); |
||||
ASSERT_OK(simple->ConfigureFromString(config_options_, |
||||
"shared={int=42;string=nested}")); |
||||
const auto outer = simple->GetOptions<TestOptions>("Outer"); |
||||
const auto shared = |
||||
simple->GetOptions<std::shared_ptr<Configurable>>("OuterShared"); |
||||
ASSERT_NE(outer, nullptr); |
||||
ASSERT_NE(shared, nullptr); |
||||
const auto inner = shared->get()->GetOptions<TestOptions>("SharedOuter"); |
||||
ASSERT_NE(inner, nullptr); |
||||
ASSERT_EQ(outer->i, 24); |
||||
ASSERT_EQ(outer->s, "outer"); |
||||
ASSERT_EQ(inner->i, 42); |
||||
ASSERT_EQ(inner->s, "nested"); |
||||
} |
||||
|
||||
TEST_F(ConfigurableTest, NestedRawConfigTest) { |
||||
std::unique_ptr<Configurable> simple; |
||||
simple.reset(SimpleConfigurable::Create( |
||||
"Outer", TestConfigMode::kDefaultMode | TestConfigMode::kRawPtrMode)); |
||||
ASSERT_OK( |
||||
simple->ConfigureFromString(config_options_, "int=24;string=outer")); |
||||
ASSERT_OK(simple->ConfigureFromString(config_options_, |
||||
"pointer={int=42;string=nested}")); |
||||
const auto outer = simple->GetOptions<TestOptions>("Outer"); |
||||
const auto pointer = simple->GetOptions<Configurable*>("OuterPointer"); |
||||
ASSERT_NE(outer, nullptr); |
||||
ASSERT_NE(pointer, nullptr); |
||||
const auto inner = (*pointer)->GetOptions<TestOptions>("PointerOuter"); |
||||
ASSERT_NE(inner, nullptr); |
||||
ASSERT_EQ(outer->i, 24); |
||||
ASSERT_EQ(outer->s, "outer"); |
||||
ASSERT_EQ(inner->i, 42); |
||||
ASSERT_EQ(inner->s, "nested"); |
||||
} |
||||
|
||||
TEST_F(ConfigurableTest, MatchesTest) { |
||||
std::string mismatch; |
||||
std::unique_ptr<Configurable> base, copy; |
||||
base.reset(SimpleConfigurable::Create( |
||||
"simple", TestConfigMode::kDefaultMode | TestConfigMode::kNestedMode)); |
||||
copy.reset(SimpleConfigurable::Create( |
||||
"simple", TestConfigMode::kDefaultMode | TestConfigMode::kNestedMode)); |
||||
ASSERT_OK(base->ConfigureFromString( |
||||
config_options_, |
||||
"int=11;string=outer;unique={int=22;string=u};shared={int=33;string=s}")); |
||||
ASSERT_OK(copy->ConfigureFromString( |
||||
config_options_, |
||||
"int=11;string=outer;unique={int=22;string=u};shared={int=33;string=s}")); |
||||
ASSERT_TRUE(base->AreEquivalent(config_options_, copy.get(), &mismatch)); |
||||
ASSERT_OK(base->ConfigureOption(config_options_, "shared", "int=44")); |
||||
ASSERT_FALSE(base->AreEquivalent(config_options_, copy.get(), &mismatch)); |
||||
ASSERT_EQ(mismatch, "shared.int"); |
||||
std::string c1value, c2value; |
||||
ASSERT_OK(base->GetOption(config_options_, mismatch, &c1value)); |
||||
ASSERT_OK(copy->GetOption(config_options_, mismatch, &c2value)); |
||||
ASSERT_NE(c1value, c2value); |
||||
} |
||||
|
||||
static Configurable* SimpleStructFactory() { |
||||
static std::unordered_map<std::string, OptionTypeInfo> struct_option_info = { |
||||
#ifndef ROCKSDB_LITE |
||||
{"struct", OptionTypeInfo::Struct("struct", &simple_option_info, 0, |
||||
OptionVerificationType::kNormal, |
||||
OptionTypeFlags::kMutable)}, |
||||
#endif // ROCKSDB_LITE
|
||||
}; |
||||
return SimpleConfigurable::Create( |
||||
"simple-struct", TestConfigMode::kDefaultMode, &struct_option_info); |
||||
} |
||||
|
||||
TEST_F(ConfigurableTest, ConfigureStructTest) { |
||||
std::unique_ptr<Configurable> base(SimpleStructFactory()); |
||||
std::unique_ptr<Configurable> copy(SimpleStructFactory()); |
||||
std::string opt_str, value; |
||||
std::string mismatch; |
||||
std::unordered_set<std::string> names; |
||||
|
||||
ASSERT_OK( |
||||
base->ConfigureFromString(config_options_, "struct={int=10; string=10}")); |
||||
ASSERT_OK(base->GetOptionString(config_options_, &opt_str)); |
||||
ASSERT_OK(copy->ConfigureFromString(config_options_, opt_str)); |
||||
ASSERT_TRUE(base->AreEquivalent(config_options_, copy.get(), &mismatch)); |
||||
ASSERT_OK(base->GetOptionNames(config_options_, &names)); |
||||
ASSERT_EQ(names.size(), 1); |
||||
ASSERT_EQ(*(names.begin()), "struct"); |
||||
ASSERT_OK( |
||||
base->ConfigureFromString(config_options_, "struct={int=20; string=20}")); |
||||
ASSERT_OK(base->GetOption(config_options_, "struct", &value)); |
||||
ASSERT_OK(copy->ConfigureOption(config_options_, "struct", value)); |
||||
ASSERT_TRUE(base->AreEquivalent(config_options_, copy.get(), &mismatch)); |
||||
|
||||
ASSERT_NOK(base->ConfigureFromString(config_options_, |
||||
"struct={int=10; string=10; bad=11}")); |
||||
ASSERT_OK(base->ConfigureOption(config_options_, "struct.int", "42")); |
||||
ASSERT_NOK(base->ConfigureOption(config_options_, "struct.bad", "42")); |
||||
ASSERT_NOK(base->GetOption(config_options_, "struct.bad", &value)); |
||||
ASSERT_OK(base->GetOption(config_options_, "struct.int", &value)); |
||||
ASSERT_EQ(value, "42"); |
||||
} |
||||
|
||||
TEST_F(ConfigurableTest, ConfigurableEnumTest) { |
||||
std::unique_ptr<Configurable> base, copy; |
||||
base.reset(SimpleConfigurable::Create("e", TestConfigMode::kEnumMode)); |
||||
copy.reset(SimpleConfigurable::Create("e", TestConfigMode::kEnumMode)); |
||||
|
||||
std::string opts_str; |
||||
std::string mismatch; |
||||
|
||||
ASSERT_OK(base->ConfigureFromString(config_options_, "enum=B")); |
||||
ASSERT_FALSE(base->AreEquivalent(config_options_, copy.get(), &mismatch)); |
||||
ASSERT_OK(base->GetOptionString(config_options_, &opts_str)); |
||||
ASSERT_OK(copy->ConfigureFromString(config_options_, opts_str)); |
||||
ASSERT_TRUE(base->AreEquivalent(config_options_, copy.get(), &mismatch)); |
||||
ASSERT_NOK(base->ConfigureOption(config_options_, "enum", "bad")); |
||||
ASSERT_NOK(base->ConfigureOption(config_options_, "unknown", "bad")); |
||||
} |
||||
|
||||
#ifndef ROCKSDB_LITE |
||||
static std::unordered_map<std::string, OptionTypeInfo> noserialize_option_info = |
||||
{ |
||||
{"int", |
||||
{offsetof(struct TestOptions, i), OptionType::kInt, |
||||
OptionVerificationType::kNormal, OptionTypeFlags::kDontSerialize}}, |
||||
}; |
||||
|
||||
TEST_F(ConfigurableTest, TestNoSerialize) { |
||||
std::unique_ptr<Configurable> base; |
||||
base.reset(SimpleConfigurable::Create("c", TestConfigMode::kDefaultMode, |
||||
&noserialize_option_info)); |
||||
std::string opts_str, value; |
||||
ASSERT_OK(base->ConfigureFromString(config_options_, "int=10")); |
||||
ASSERT_OK(base->GetOptionString(config_options_, &opts_str)); |
||||
ASSERT_EQ(opts_str, ""); |
||||
ASSERT_NOK(base->GetOption(config_options_, "int", &value)); |
||||
} |
||||
|
||||
TEST_F(ConfigurableTest, TestNoCompare) { |
||||
std::unordered_map<std::string, OptionTypeInfo> nocomp_option_info = { |
||||
{"int", |
||||
{offsetof(struct TestOptions, i), OptionType::kInt, |
||||
OptionVerificationType::kNormal, OptionTypeFlags::kCompareNever}}, |
||||
}; |
||||
std::unordered_map<std::string, OptionTypeInfo> normal_option_info = { |
||||
{"int", |
||||
{offsetof(struct TestOptions, i), OptionType::kInt, |
||||
OptionVerificationType::kNormal, OptionTypeFlags::kNone}}, |
||||
}; |
||||
|
||||
std::unique_ptr<Configurable> base, copy; |
||||
base.reset(SimpleConfigurable::Create("c", TestConfigMode::kDefaultMode, |
||||
&nocomp_option_info)); |
||||
copy.reset(SimpleConfigurable::Create("c", TestConfigMode::kDefaultMode, |
||||
&normal_option_info)); |
||||
ASSERT_OK(base->ConfigureFromString(config_options_, "int=10")); |
||||
ASSERT_OK(copy->ConfigureFromString(config_options_, "int=20")); |
||||
std::string bvalue, cvalue, mismatch; |
||||
ASSERT_OK(base->GetOption(config_options_, "int", &bvalue)); |
||||
ASSERT_OK(copy->GetOption(config_options_, "int", &cvalue)); |
||||
ASSERT_EQ(bvalue, "10"); |
||||
ASSERT_EQ(cvalue, "20"); |
||||
ASSERT_TRUE(base->AreEquivalent(config_options_, copy.get(), &mismatch)); |
||||
ASSERT_FALSE(copy->AreEquivalent(config_options_, base.get(), &mismatch)); |
||||
} |
||||
#endif |
||||
|
||||
void ConfigurableParamTest::TestConfigureOptions( |
||||
const ConfigOptions& config_options) { |
||||
std::unique_ptr<Configurable> base, copy; |
||||
std::unordered_set<std::string> names; |
||||
std::string opt_str, mismatch; |
||||
|
||||
base.reset(factory_()); |
||||
copy.reset(factory_()); |
||||
|
||||
ASSERT_OK(base->ConfigureFromString(config_options, configuration_)); |
||||
ASSERT_OK(base->GetOptionString(config_options, &opt_str)); |
||||
ASSERT_OK(copy->ConfigureFromString(config_options, opt_str)); |
||||
ASSERT_OK(copy->GetOptionString(config_options, &opt_str)); |
||||
ASSERT_TRUE(base->AreEquivalent(config_options, copy.get(), &mismatch)); |
||||
|
||||
copy.reset(factory_()); |
||||
ASSERT_OK(base->GetOptionNames(config_options, &names)); |
||||
std::unordered_map<std::string, std::string> unused; |
||||
bool found_one = false; |
||||
for (auto name : names) { |
||||
std::string value; |
||||
Status s = base->GetOption(config_options, name, &value); |
||||
if (s.ok()) { |
||||
s = copy->ConfigureOption(config_options, name, value); |
||||
if (s.ok() || s.IsNotSupported()) { |
||||
found_one = true; |
||||
} else { |
||||
unused[name] = value; |
||||
} |
||||
} else { |
||||
ASSERT_TRUE(s.IsNotSupported()); |
||||
} |
||||
} |
||||
ASSERT_TRUE(found_one || names.empty()); |
||||
while (found_one && !unused.empty()) { |
||||
found_one = false; |
||||
for (auto iter = unused.begin(); iter != unused.end();) { |
||||
if (copy->ConfigureOption(config_options, iter->first, iter->second) |
||||
.ok()) { |
||||
found_one = true; |
||||
iter = unused.erase(iter); |
||||
} else { |
||||
++iter; |
||||
} |
||||
} |
||||
} |
||||
ASSERT_EQ(0, unused.size()); |
||||
ASSERT_TRUE(base->AreEquivalent(config_options, copy.get(), &mismatch)); |
||||
} |
||||
|
||||
TEST_P(ConfigurableParamTest, GetDefaultOptionsTest) { |
||||
TestConfigureOptions(config_options_); |
||||
} |
||||
|
||||
TEST_P(ConfigurableParamTest, ConfigureFromPropsTest) { |
||||
std::string opt_str, mismatch; |
||||
std::unordered_set<std::string> names; |
||||
std::unique_ptr<Configurable> copy(factory_()); |
||||
|
||||
ASSERT_OK(object_->ConfigureFromString(config_options_, configuration_)); |
||||
config_options_.delimiter = "\n"; |
||||
ASSERT_OK(object_->GetOptionString(config_options_, &opt_str)); |
||||
std::istringstream iss(opt_str); |
||||
std::unordered_map<std::string, std::string> copy_map; |
||||
std::string line; |
||||
for (int line_num = 0; std::getline(iss, line); line_num++) { |
||||
std::string name; |
||||
std::string value; |
||||
ASSERT_OK( |
||||
RocksDBOptionsParser::ParseStatement(&name, &value, line, line_num)); |
||||
copy_map[name] = value; |
||||
} |
||||
ASSERT_OK(copy->ConfigureFromMap(config_options_, copy_map)); |
||||
ASSERT_TRUE(object_->AreEquivalent(config_options_, copy.get(), &mismatch)); |
||||
} |
||||
|
||||
static Configurable* SimpleFactory() { |
||||
return SimpleConfigurable::Create("simple"); |
||||
} |
||||
|
||||
static Configurable* UniqueFactory() { |
||||
return SimpleConfigurable::Create( |
||||
"simple", TestConfigMode::kSimpleMode | TestConfigMode::kUniqueMode); |
||||
} |
||||
static Configurable* SharedFactory() { |
||||
return SimpleConfigurable::Create( |
||||
"simple", TestConfigMode::kSimpleMode | TestConfigMode::kSharedMode); |
||||
} |
||||
|
||||
static Configurable* NestedFactory() { |
||||
return SimpleConfigurable::Create( |
||||
"simple", TestConfigMode::kSimpleMode | TestConfigMode::kNestedMode); |
||||
} |
||||
|
||||
static Configurable* MutableFactory() { |
||||
return SimpleConfigurable::Create("simple", TestConfigMode::kMutableMode | |
||||
TestConfigMode::kSimpleMode | |
||||
TestConfigMode::kNestedMode); |
||||
} |
||||
|
||||
static Configurable* ThreeWrappedFactory() { |
||||
std::shared_ptr<Configurable> child; |
||||
child.reset( |
||||
SimpleConfigurable::Create("child", TestConfigMode::kDefaultMode)); |
||||
std::shared_ptr<Configurable> parent; |
||||
parent.reset( |
||||
new WrappedConfigurable("parent", TestConfigMode::kDefaultMode, child)); |
||||
return new WrappedConfigurable("master", TestConfigMode::kDefaultMode, |
||||
parent); |
||||
} |
||||
|
||||
static Configurable* ThreeDeepFactory() { |
||||
Configurable* simple = SimpleConfigurable::Create( |
||||
"Simple", TestConfigMode::kUniqueMode | TestConfigMode::kDefaultMode); |
||||
auto* unique = |
||||
simple->GetOptions<std::unique_ptr<Configurable>>("SimpleUnique"); |
||||
unique->reset(SimpleConfigurable::Create( |
||||
"Child", TestConfigMode::kUniqueMode | TestConfigMode::kDefaultMode)); |
||||
unique = |
||||
unique->get()->GetOptions<std::unique_ptr<Configurable>>("ChildUnique"); |
||||
unique->reset( |
||||
SimpleConfigurable::Create("Child", TestConfigMode::kDefaultMode)); |
||||
return simple; |
||||
} |
||||
|
||||
static Configurable* DBOptionsFactory() { |
||||
auto config = DBOptionsAsConfigurable(DBOptions()); |
||||
return config.release(); |
||||
} |
||||
|
||||
static Configurable* CFOptionsFactory() { |
||||
auto config = CFOptionsAsConfigurable(ColumnFamilyOptions()); |
||||
return config.release(); |
||||
} |
||||
|
||||
static Configurable* BlockBasedFactory() { return NewBlockBasedTableFactory(); } |
||||
|
||||
INSTANTIATE_TEST_CASE_P( |
||||
ParamTest, ConfigurableParamTest, |
||||
testing::Values( |
||||
std::pair<std::string, ConfigTestFactoryFunc>( |
||||
"int=42;bool=true;string=s", SimpleFactory), |
||||
std::pair<std::string, ConfigTestFactoryFunc>( |
||||
"int=42;unique={int=33;string=unique}", MutableFactory), |
||||
std::pair<std::string, ConfigTestFactoryFunc>( |
||||
"struct={int=33;bool=true;string=s;}", SimpleStructFactory), |
||||
std::pair<std::string, ConfigTestFactoryFunc>( |
||||
"int=33;bool=true;string=outer;" |
||||
"shared={int=42;string=shared}", |
||||
SharedFactory), |
||||
std::pair<std::string, ConfigTestFactoryFunc>( |
||||
"int=33;bool=true;string=outer;" |
||||
"unique={int=42;string=unique}", |
||||
UniqueFactory), |
||||
std::pair<std::string, ConfigTestFactoryFunc>( |
||||
"int=11;bool=true;string=outer;" |
||||
"pointer={int=22;string=pointer};" |
||||
"unique={int=33;string=unique};" |
||||
"shared={int=44;string=shared}", |
||||
NestedFactory), |
||||
std::pair<std::string, ConfigTestFactoryFunc>( |
||||
"int=11;bool=true;string=outer;" |
||||
"inner={int=22;string=parent;" |
||||
"inner={int=33;string=child}};", |
||||
ThreeWrappedFactory), |
||||
std::pair<std::string, ConfigTestFactoryFunc>( |
||||
"int=11;bool=true;string=outer;" |
||||
"unique={int=22;string=inner;" |
||||
"unique={int=33;string=unique}};", |
||||
ThreeDeepFactory), |
||||
std::pair<std::string, ConfigTestFactoryFunc>("max_background_jobs=100;" |
||||
"max_open_files=200;", |
||||
DBOptionsFactory), |
||||
std::pair<std::string, ConfigTestFactoryFunc>( |
||||
"table_factory=BlockBasedTable;" |
||||
"disable_auto_compactions=true;", |
||||
CFOptionsFactory), |
||||
std::pair<std::string, ConfigTestFactoryFunc>("block_size=1024;" |
||||
"no_block_cache=true;", |
||||
BlockBasedFactory))); |
||||
#endif // ROCKSDB_LITE
|
||||
|
||||
} // namespace test
|
||||
} // namespace ROCKSDB_NAMESPACE
|
||||
int main(int argc, char** argv) { |
||||
::testing::InitGoogleTest(&argc, argv); |
||||
#ifdef GFLAGS |
||||
ParseCommandLineFlags(&argc, &argv, true); |
||||
#endif // GFLAGS
|
||||
return RUN_ALL_TESTS(); |
||||
} |
||||
@ -0,0 +1,127 @@ |
||||
// 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.
|
||||
|
||||
#pragma once |
||||
#include <algorithm> |
||||
#include <memory> |
||||
#include <unordered_map> |
||||
|
||||
#include "options/configurable_helper.h" |
||||
#include "rocksdb/configurable.h" |
||||
#include "rocksdb/utilities/options_type.h" |
||||
|
||||
namespace ROCKSDB_NAMESPACE { |
||||
struct ColumnFamilyOptions; |
||||
struct DBOptions; |
||||
|
||||
namespace test { |
||||
enum TestEnum { kTestA, kTestB }; |
||||
|
||||
static const std::unordered_map<std::string, int> test_enum_map = { |
||||
{"A", TestEnum::kTestA}, |
||||
{"B", TestEnum::kTestB}, |
||||
}; |
||||
|
||||
struct TestOptions { |
||||
int i = 0; |
||||
bool b = false; |
||||
bool d = true; |
||||
TestEnum e = TestEnum::kTestA; |
||||
std::string s = ""; |
||||
std::string u = ""; |
||||
}; |
||||
|
||||
static std::unordered_map<std::string, OptionTypeInfo> simple_option_info = { |
||||
#ifndef ROCKSDB_LITE |
||||
{"int", |
||||
{offsetof(struct TestOptions, i), OptionType::kInt, |
||||
OptionVerificationType::kNormal, OptionTypeFlags::kMutable}}, |
||||
{"bool", |
||||
{offsetof(struct TestOptions, b), OptionType::kBoolean, |
||||
OptionVerificationType::kNormal, OptionTypeFlags::kNone}}, |
||||
{"string", |
||||
{offsetof(struct TestOptions, s), OptionType::kString, |
||||
OptionVerificationType::kNormal, OptionTypeFlags::kNone}}, |
||||
#endif // ROCKSDB_LITE
|
||||
}; |
||||
|
||||
static std::unordered_map<std::string, OptionTypeInfo> enum_option_info = { |
||||
#ifndef ROCKSDB_LITE |
||||
{"enum", |
||||
OptionTypeInfo::Enum(offsetof(struct TestOptions, e), &test_enum_map)} |
||||
#endif |
||||
}; |
||||
|
||||
static std::unordered_map<std::string, OptionTypeInfo> unique_option_info = { |
||||
#ifndef ROCKSDB_LITE |
||||
{"unique", |
||||
{0, OptionType::kConfigurable, OptionVerificationType::kNormal, |
||||
(OptionTypeFlags::kUnique | OptionTypeFlags::kMutable)}}, |
||||
#endif // ROCKSDB_LITE
|
||||
}; |
||||
|
||||
static std::unordered_map<std::string, OptionTypeInfo> shared_option_info = { |
||||
#ifndef ROCKSDB_LITE |
||||
{"shared", |
||||
{0, OptionType::kConfigurable, OptionVerificationType::kNormal, |
||||
(OptionTypeFlags::kShared)}}, |
||||
#endif // ROCKSDB_LITE
|
||||
}; |
||||
static std::unordered_map<std::string, OptionTypeInfo> pointer_option_info = { |
||||
#ifndef ROCKSDB_LITE |
||||
{"pointer", |
||||
{0, OptionType::kConfigurable, OptionVerificationType::kNormal, |
||||
OptionTypeFlags::kRawPointer}}, |
||||
#endif // ROCKSDB_LITE
|
||||
}; |
||||
|
||||
enum TestConfigMode { |
||||
kEmptyMode = 0x0, // Don't register anything
|
||||
kMutableMode = 0x01, // Configuration is mutable
|
||||
kSimpleMode = 0x02, // Use the simple options
|
||||
kEnumMode = 0x04, // Use the enum options
|
||||
kDefaultMode = kSimpleMode, // Use no inner nested configurations
|
||||
kSharedMode = 0x10, // Use shared configuration
|
||||
kUniqueMode = 0x20, // Use unique configuration
|
||||
kRawPtrMode = 0x40, // Use pointer configuration
|
||||
kNestedMode = (kSharedMode | kUniqueMode | kRawPtrMode), |
||||
kAllOptMode = (kNestedMode | kEnumMode | kSimpleMode), |
||||
}; |
||||
|
||||
template <typename T> |
||||
class TestConfigurable : public Configurable { |
||||
protected: |
||||
std::string name_; |
||||
std::string prefix_; |
||||
TestOptions options_; |
||||
|
||||
public: |
||||
std::unique_ptr<T> unique_; |
||||
std::shared_ptr<T> shared_; |
||||
T* pointer_; |
||||
|
||||
TestConfigurable(const std::string& name, int mode, |
||||
const std::unordered_map<std::string, OptionTypeInfo>* map = |
||||
&simple_option_info) |
||||
: name_(name), pointer_(nullptr) { |
||||
prefix_ = "test." + name + "."; |
||||
if ((mode & TestConfigMode::kSimpleMode) != 0) { |
||||
ConfigurableHelper::RegisterOptions(*this, name_, &options_, map); |
||||
} |
||||
if ((mode & TestConfigMode::kEnumMode) != 0) { |
||||
ConfigurableHelper::RegisterOptions(*this, name_ + "Enum", &options_, |
||||
&enum_option_info); |
||||
} |
||||
} |
||||
|
||||
~TestConfigurable() override { delete pointer_; } |
||||
}; |
||||
|
||||
} // namespace test
|
||||
} // namespace ROCKSDB_NAMESPACE
|
||||
@ -0,0 +1,49 @@ |
||||
// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
// 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.
|
||||
|
||||
#include "rocksdb/convenience.h" |
||||
#include "rocksdb/table.h" |
||||
#include "table/block_based/block_based_table_factory.h" |
||||
#include "table/cuckoo/cuckoo_table_factory.h" |
||||
#include "table/plain/plain_table_factory.h" |
||||
|
||||
namespace ROCKSDB_NAMESPACE { |
||||
|
||||
Status TableFactory::CreateFromString(const ConfigOptions& config_options_in, |
||||
const std::string& id, |
||||
std::shared_ptr<TableFactory>* factory) { |
||||
Status status; |
||||
std::string name = id; |
||||
|
||||
std::string existing_opts; |
||||
|
||||
ConfigOptions config_options = config_options_in; |
||||
if (factory->get() != nullptr && name == factory->get()->Name()) { |
||||
config_options.delimiter = ";"; |
||||
|
||||
status = factory->get()->GetOptionString(config_options, &existing_opts); |
||||
if (!status.ok()) { |
||||
return status; |
||||
} |
||||
} |
||||
if (name == TableFactory::kBlockBasedTableName()) { |
||||
factory->reset(new BlockBasedTableFactory()); |
||||
#ifndef ROCKSDB_LITE |
||||
} else if (name == TableFactory::kPlainTableName()) { |
||||
factory->reset(new PlainTableFactory()); |
||||
} else if (name == TableFactory::kCuckooTableName()) { |
||||
factory->reset(new CuckooTableFactory()); |
||||
#endif // ROCKSDB_LITE
|
||||
} else { |
||||
return Status::NotSupported("Could not load table factory: ", name); |
||||
} |
||||
if (!existing_opts.empty()) { |
||||
config_options.invoke_prepare_options = false; |
||||
status = factory->get()->ConfigureFromString(config_options, existing_opts); |
||||
} |
||||
return status; |
||||
} |
||||
|
||||
} // namespace ROCKSDB_NAMESPACE
|
||||
Loading…
Reference in new issue