foundationdb/fdbclient/ConfigKnobs.cpp

/*
 * ConfigKnobs.cpp
 *
 * This source file is part of the FoundationDB open source project
 *
 * Copyright 2013-2018 Apple Inc. and the FoundationDB project authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "fdbclient/ConfigKnobs.h"
#include "fdbclient/Tuple.h"
#include "flow/UnitTest.h"

ConfigKey ConfigKeyRef::decodeKey(KeyRef const& key) {
	Tuple tuple;
	try {
		tuple = Tuple::unpack(key);
	} catch (Error& e) {
		TraceEvent(SevWarnAlways, "FailedToUnpackConfigKey").error(e).detail("Key", printable(key));
		throw invalid_config_db_key();
	}
	if (tuple.size() != 2) {
		throw invalid_config_db_key();
	}
	if (tuple.getType(0) == Tuple::NULL_TYPE) {
		return ConfigKeyRef({}, tuple.getString(1));
	} else {
		if (tuple.getType(0) != Tuple::BYTES || tuple.getType(1) != Tuple::BYTES) {
			throw invalid_config_db_key();
		}
		return ConfigKeyRef(tuple.getString(0), tuple.getString(1));
	}
}

Value KnobValueRef::ToValueFunc::operator()(int v) const {
	return BinaryWriter::toValue(v, Unversioned());
}
Value KnobValueRef::ToValueFunc::operator()(int64_t v) const {
	return BinaryWriter::toValue(v, Unversioned());
}
Value KnobValueRef::ToValueFunc::operator()(bool v) const {
	return BinaryWriter::toValue(v, Unversioned());
}
Value KnobValueRef::ToValueFunc::operator()(ValueRef v) const {
	return v;
}
Value KnobValueRef::ToValueFunc::operator()(double v) const {
	return BinaryWriter::toValue(v, Unversioned());
}

KnobValue KnobValueRef::CreatorFunc::operator()(NoKnobFound) const {
	ASSERT(false);
	return {};
}
KnobValue KnobValueRef::CreatorFunc::operator()(int v) const {
	return KnobValueRef(v);
}
KnobValue KnobValueRef::CreatorFunc::operator()(double v) const {
	return KnobValueRef(v);
}
KnobValue KnobValueRef::CreatorFunc::operator()(int64_t v) const {
	return KnobValueRef(v);
}
KnobValue KnobValueRef::CreatorFunc::operator()(bool v) const {
	return KnobValueRef(v);
}
KnobValue KnobValueRef::CreatorFunc::operator()(std::string const& v) const {
	return KnobValueRef(ValueRef(reinterpret_cast<uint8_t const*>(v.c_str()), v.size()));
}

namespace {

class SetKnobFunc {
	Knobs* knobs;
	std::string const* knobName;

public:
	SetKnobFunc(Knobs& knobs, std::string const& knobName) : knobs(&knobs), knobName(&knobName) {}
	template <class T>
	bool operator()(T const& v) const {
		return knobs->setKnob(*knobName, v);
	}
	bool operator()(StringRef const& v) const { return knobs->setKnob(*knobName, v.toString()); }
};

struct ToStringFunc {
	std::string operator()(int v) const { return format("int:%d", v); }
	std::string operator()(int64_t v) const { return format("int64_t:%ld", v); }
	std::string operator()(bool v) const { return format("bool:%d", v); }
	std::string operator()(ValueRef v) const { return "string:" + v.toString(); }
	std::string operator()(double v) const { return format("double:%lf", v); }
};

} // namespace

KnobValue KnobValueRef::create(ParsedKnobValue const& v) {
	return std::visit(CreatorFunc{}, v);
}

bool KnobValueRef::visitSetKnob(std::string const& knobName, Knobs& knobs) const {
	return std::visit(SetKnobFunc{ knobs, knobName }, value);
}

std::string KnobValueRef::toString() const {
	return std::visit(ToStringFunc{}, value);
}

ConfigDBType configDBTypeFromString(std::string const& str) {
	if (str == "disabled") {
		return ConfigDBType::DISABLED;
	} else if (str == "simple") {
		return ConfigDBType::SIMPLE;
	} else if (str == "paxos") {
		return ConfigDBType::PAXOS;
	} else {
		TraceEvent(SevWarnAlways, "InvalidConfigDBString");
		return ConfigDBType::DISABLED;
	}
}

std::string configDBTypeToString(ConfigDBType configDBType) {
	switch (configDBType) {
	case ConfigDBType::DISABLED:
		return "disabled";
	case ConfigDBType::SIMPLE:
		return "simple";
	case ConfigDBType::PAXOS:
		return "paxos";
	default:
		ASSERT(false);
		return "";
	}
}

TEST_CASE("/fdbclient/ConfigDB/ConfigKey/EncodeDecode") {
	Tuple tuple;
	tuple << "class-A"_sr
	      << "test_long"_sr;
	auto packed = tuple.pack();
	auto unpacked = ConfigKeyRef::decodeKey(packed);
	ASSERT(unpacked.configClass.get() == "class-A"_sr);
	ASSERT(unpacked.knobName == "test_long"_sr);
	return Void();
}

namespace {

void decodeFailureTest(KeyRef key) {
	try {
		ConfigKeyRef::decodeKey(key);
	} catch (Error& e) {
		ASSERT_EQ(e.code(), error_code_invalid_config_db_key);
		return;
	}
	ASSERT(false);
}

} // namespace

TEST_CASE("/fdbclient/ConfigDB/ConfigKey/DecodeFailure") {
	{
		Tuple tuple;
		tuple << "s1"_sr
		      << "s2"_sr
		      << "s3"_sr;
		decodeFailureTest(tuple.pack());
	}
	{
		Tuple tuple;
		tuple << "s1"_sr << 5;
		decodeFailureTest(tuple.pack());
	}
	decodeFailureTest("non-tuple-key"_sr);
	return Void();
}