462 lines
12 KiB
C++
462 lines
12 KiB
C++
/*
|
|
* Copyright 2009, 2010 Free Software Foundation, Inc.
|
|
* Copyright 2010 Kestrel Signal Processing, Inc.
|
|
* Copyright 2011, 2012, 2014 Range Networks, Inc.
|
|
*
|
|
* This software is distributed under the terms of the GNU Affero Public License.
|
|
* See the COPYING file in the main directory for details.
|
|
*
|
|
* This use of this software may be subject to additional restrictions.
|
|
* See the LEGAL file in the main directory for details.
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Affero General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Affero General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Affero General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
#ifndef CONFIGURATION_H
|
|
#define CONFIGURATION_H
|
|
|
|
|
|
#include "sqlite3util.h"
|
|
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <netinet/in.h>
|
|
#include <arpa/inet.h>
|
|
#include <regex.h>
|
|
|
|
#include <map>
|
|
#include <vector>
|
|
#include <string>
|
|
#include <sstream>
|
|
#include <iostream>
|
|
|
|
#include <Threads.h>
|
|
#include <stdint.h>
|
|
|
|
|
|
/** A class for configuration file errors. */
|
|
class ConfigurationTableError {};
|
|
extern char gCmdName[]; // Gotta be global, gotta be char*, gotta love it.
|
|
|
|
/** An exception thrown when a given config key isn't found. */
|
|
class ConfigurationTableKeyNotFound : public ConfigurationTableError {
|
|
|
|
private:
|
|
|
|
std::string mKey;
|
|
|
|
public:
|
|
|
|
ConfigurationTableKeyNotFound(const std::string& wKey)
|
|
:mKey(wKey)
|
|
{ }
|
|
|
|
const std::string& key() const { return mKey; }
|
|
|
|
};
|
|
|
|
|
|
// (pat) 10-5-2013 Add the key to this record so we can print better error messages,
|
|
// and warn if number() of floatNumber() have non-numeric values.
|
|
class ConfigurationRecord {
|
|
|
|
private:
|
|
|
|
std::string mCRKey;
|
|
std::string mValue;
|
|
bool mDefined;
|
|
mutable bool mCRWarned;
|
|
|
|
public:
|
|
|
|
ConfigurationRecord() : mDefined(false), mCRWarned(false) {}
|
|
ConfigurationRecord(const std::string &key,bool wDefined):
|
|
mCRKey(key),
|
|
mDefined(wDefined),
|
|
mCRWarned(false)
|
|
{ }
|
|
|
|
ConfigurationRecord(const std::string&key, const std::string& wValue):
|
|
mCRKey(key),
|
|
mValue(wValue),
|
|
//mNumber(strtol(wValue.c_str(),&endptr,0)),
|
|
mDefined(true),
|
|
mCRWarned(false)
|
|
{ }
|
|
|
|
ConfigurationRecord(const std::string&key, const char* wValue):
|
|
mCRKey(key),
|
|
mValue(std::string(wValue)),
|
|
//mNumber(strtol(wValue.c_str(),&endptr,0)),
|
|
mDefined(true),
|
|
mCRWarned(false)
|
|
{ }
|
|
|
|
|
|
const std::string& value() const { return mValue; }
|
|
long number() const;
|
|
bool defined() const { return mDefined; }
|
|
|
|
float floatNumber() const;
|
|
|
|
};
|
|
|
|
|
|
/** A string class that uses a hash function for comparison. */
|
|
class HashString : public std::string {
|
|
|
|
|
|
protected:
|
|
|
|
uint64_t mHash;
|
|
|
|
void computeHash();
|
|
|
|
|
|
public:
|
|
|
|
HashString(const char* src)
|
|
:std::string(src)
|
|
{
|
|
computeHash();
|
|
}
|
|
|
|
HashString(const std::string& src)
|
|
:std::string(src)
|
|
{
|
|
computeHash();
|
|
}
|
|
|
|
HashString()
|
|
{
|
|
mHash=0;
|
|
}
|
|
|
|
HashString& operator=(std::string& src)
|
|
{
|
|
std::string::operator=(src);
|
|
computeHash();
|
|
return *this;
|
|
}
|
|
|
|
HashString& operator=(const char* src)
|
|
{
|
|
std::string::operator=(src);
|
|
computeHash();
|
|
return *this;
|
|
}
|
|
|
|
bool operator==(const HashString& other)
|
|
{
|
|
return mHash==other.mHash;
|
|
}
|
|
|
|
bool operator<(const HashString& other)
|
|
{
|
|
return mHash<other.mHash;
|
|
}
|
|
|
|
bool operator>(const HashString& other)
|
|
{
|
|
return mHash<other.mHash;
|
|
}
|
|
|
|
uint64_t hash() const { return mHash; }
|
|
|
|
};
|
|
|
|
|
|
typedef std::map<std::string, ConfigurationRecord> ConfigurationRecordMap;
|
|
typedef std::map<HashString, ConfigurationRecord> ConfigurationMap;
|
|
class ConfigurationKey;
|
|
typedef std::map<std::string, ConfigurationKey> ConfigurationKeyMap;
|
|
ConfigurationKeyMap getConfigurationKeys();
|
|
|
|
/**
|
|
A class for maintaining a configuration key-value table,
|
|
based on sqlite3 and a local map-based cache.
|
|
Thread-safe, too.
|
|
*/
|
|
class ConfigurationTable {
|
|
|
|
private:
|
|
|
|
sqlite3* mDB; ///< database connection
|
|
ConfigurationMap mCache; ///< cache of recently access configuration values
|
|
mutable Mutex mLock; ///< control for multithreaded access to the cache
|
|
std::vector<std::string> (*mCrossCheck)(const std::string&); ///< cross check callback pointer
|
|
|
|
public:
|
|
|
|
ConfigurationKeyMap mSchema;///< definition of configuration default values and validation logic
|
|
|
|
// (pat) filename is the sql file name, wCmdName is the name of the executable we are running, used for better error messages.
|
|
ConfigurationTable(const char* filename = ":memory:", const char *wCmdName = 0, ConfigurationKeyMap wSchema = ConfigurationKeyMap());
|
|
|
|
/** Generate an up-to-date example sql file for new installs. */
|
|
std::string getDefaultSQL(const std::string& program, const std::string& version);
|
|
|
|
/** Generate an up-to-date TeX snippet. */
|
|
std::string getTeX(const std::string& program, const std::string& version);
|
|
|
|
/** Return true if the key is used in the table. */
|
|
bool defines(const std::string& key);
|
|
|
|
/** Return true if the application's schema knows about this key. */
|
|
bool keyDefinedInSchema(const std::string& name);
|
|
|
|
/** Return true if the provided value validates correctly against the defined schema. */
|
|
bool isValidValue(const std::string& name, const std::string& val);
|
|
|
|
/** Return true if the provided value validates correctly against the defined schema. */
|
|
bool isValidValue(const std::string& name, const int val) { std::stringstream ss; ss << val; return isValidValue(name, ss.str()); }
|
|
|
|
/** Return a map of all similar keys in the defined schema. */
|
|
ConfigurationKeyMap getSimilarKeys(const std::string& snippet);
|
|
|
|
/** Return true if this key is identified as static. */
|
|
bool isStatic(const std::string& key);
|
|
|
|
/**
|
|
Get a string parameter from the table.
|
|
Throw ConfigurationTableKeyNotFound if not found.
|
|
*/
|
|
std::string getStr(const std::string& key);
|
|
|
|
|
|
/**
|
|
Get a boolean from the table.
|
|
Return false if NULL or 0, true otherwise.
|
|
*/
|
|
bool getBool(const std::string& key);
|
|
|
|
/**
|
|
Get a numeric parameter from the table.
|
|
Throw ConfigurationTableKeyNotFound if not found.
|
|
*/
|
|
long getNum(const std::string& key);
|
|
|
|
/**
|
|
Get a vector of strings from the table.
|
|
*/
|
|
std::vector<std::string> getVectorOfStrings(const std::string& key);
|
|
|
|
/**
|
|
Get a float from the table.
|
|
Throw ConfigurationTableKeyNotFound if not found.
|
|
*/
|
|
float getFloat(const std::string& key);
|
|
|
|
/**
|
|
Get a numeric vector from the table.
|
|
*/
|
|
std::vector<unsigned> getVector(const std::string& key);
|
|
|
|
/** Get length of a vector */
|
|
unsigned getVectorLength(const std::string &key)
|
|
{ return getVector(key).size(); }
|
|
|
|
/** Set or change a value in the table. */
|
|
bool set(const std::string& key, const std::string& value);
|
|
|
|
/** Set or change a value in the table. */
|
|
bool set(const std::string& key, long value);
|
|
|
|
/**
|
|
Remove an entry from the table.
|
|
Will not alter required values.
|
|
@param key The key of the item to be removed.
|
|
@return true if anything was actually removed.
|
|
*/
|
|
bool remove(const std::string& key);
|
|
|
|
/** Search the table, dumping to a stream. */
|
|
void find(const std::string& pattern, std::ostream&) const;
|
|
|
|
/** Return all key/value pairs stored in the ConfigurationTable */
|
|
ConfigurationRecordMap getAllPairs() const;
|
|
|
|
/** Define the callback to purge the cache whenever the database changes. */
|
|
void setUpdateHook(void(*)(void *,int ,char const *,char const *,sqlite3_int64));
|
|
|
|
/** Define the callback for cross checking. */
|
|
void setCrossCheckHook(std::vector<std::string> (*wCrossCheck)(const std::string&));
|
|
|
|
/** Execute the application specific value cross checking logic. */
|
|
std::vector<std::string> crossCheck(const std::string& key);
|
|
|
|
/** purege cache if it exceeds a certain age */
|
|
void checkCacheAge();
|
|
|
|
/** Delete all records from the cache. */
|
|
void purge();
|
|
|
|
|
|
private:
|
|
|
|
/**
|
|
Attempt to lookup a record, cache if needed.
|
|
Throw ConfigurationTableKeyNotFound if not found.
|
|
Caller should hold mLock because the returned reference points into the cache.
|
|
*/
|
|
const ConfigurationRecord& lookup(const std::string& key);
|
|
|
|
};
|
|
|
|
|
|
typedef std::map<HashString, std::string> HashStringMap;
|
|
|
|
class SimpleKeyValueException : public std::exception {
|
|
std::string mWhy;
|
|
public:
|
|
const char *what() const throw() { return mWhy.c_str(); }
|
|
SimpleKeyValueException(std::string wWhy) : mWhy(wWhy) {}
|
|
// This is dorky. We have to define the no-op destructor because the default destructor has the wrong throw() content,
|
|
// and even though the throw content is not used by the compiler. What a balls-up.
|
|
~SimpleKeyValueException() throw() {}
|
|
};
|
|
|
|
class SimpleKeyValue {
|
|
|
|
protected:
|
|
|
|
HashStringMap mMap;
|
|
|
|
public:
|
|
|
|
/** Take a C string "A=B" and set map["A"]="B". */
|
|
void addItem(const char*);
|
|
|
|
/** Take a C string "A=B C=D E=F ..." and add all of the pairs to the map. */
|
|
void addItems(const char*s);
|
|
|
|
/** Return a reference to the string at map["key"]. */
|
|
const char* get(const char*) const;
|
|
|
|
std::string getStrOrBust(const char *key) const;
|
|
long getNumOrBust(const char *key) const;
|
|
long getNum(const char *key, bool &valid) const;
|
|
};
|
|
|
|
|
|
class ConfigurationKey {
|
|
|
|
public:
|
|
|
|
enum VisibilityLevel
|
|
{
|
|
CUSTOMER,
|
|
CUSTOMERSITE,
|
|
CUSTOMERTUNE,
|
|
CUSTOMERWARN,
|
|
DEVELOPER,
|
|
FACTORY
|
|
};
|
|
|
|
enum Type
|
|
{
|
|
BOOLEAN,
|
|
CHOICE_OPT,
|
|
CHOICE,
|
|
CIDR_OPT, // (pat) IP Route, eg: "xxx.xxx.xxx.xxx/yy"
|
|
CIDR,
|
|
FILEPATH_OPT,
|
|
FILEPATH,
|
|
HOSTANDPORT_OPT,
|
|
HOSTANDPORT, // (pat) hostname is allowed.
|
|
IPADDRESS_OPT,
|
|
IPADDRESS, // (pat) IP Address but hostnames not allowed.
|
|
IPANDPORT,
|
|
MIPADDRESS_OPT,
|
|
MIPADDRESS, // (pat) List of IP addresses + optional ports, used only for the Neighbors config option.
|
|
PORT_OPT,
|
|
PORT, // (pat) An IP port.
|
|
REGEX_OPT,
|
|
REGEX,
|
|
STRING_OPT,
|
|
STRING,
|
|
VALRANGE // (pat) string format is: <min_value> ':' <max_value> [ '(' <step> ')' ]
|
|
// step is not currently enforced.
|
|
// To allow floating point add a decimal point to the range, eg: "0.0:10.0"
|
|
};
|
|
|
|
enum Scope
|
|
{
|
|
GLOBALLYUNIQUE = 1, // (pat) value must be unique on all nodes.
|
|
GLOBALLYSAME = 2, // (pat) value must be the same on all nodes.
|
|
NEIGHBORSUNIQUE = 4, // (pat) value must be unique on all neighbors
|
|
NEIGHBORSSAME = 8, // (pat) value must be the same on all neighbors
|
|
NODESPECIFIC = 16
|
|
};
|
|
|
|
private:
|
|
|
|
std::string mName;
|
|
std::string mDefaultValue;
|
|
std::string mUnits;
|
|
VisibilityLevel mVisibility;
|
|
Type mType;
|
|
std::string mValidValues;
|
|
bool mIsStatic;
|
|
std::string mDescription;
|
|
unsigned mScope;
|
|
|
|
|
|
public:
|
|
|
|
ConfigurationKey(const std::string& wName, const std::string& wDefaultValue, const std::string& wUnits, const VisibilityLevel wVisibility, const Type wType, const std::string& wValidValues, bool wIsStatic, const std::string& wDescription, unsigned wScope = 0):
|
|
mName(wName),
|
|
mDefaultValue(wDefaultValue),
|
|
mUnits(wUnits),
|
|
mVisibility(wVisibility),
|
|
mType(wType),
|
|
mValidValues(wValidValues),
|
|
mIsStatic(wIsStatic),
|
|
mDescription(wDescription),
|
|
mScope(wScope)
|
|
{ }
|
|
|
|
ConfigurationKey()
|
|
{ }
|
|
|
|
const std::string& getName() const { return mName; }
|
|
const std::string& getDefaultValue() const { return mDefaultValue; }
|
|
void updateDefaultValue(const std::string& newValue) { mDefaultValue = newValue; }
|
|
void updateDefaultValue(const int newValue) { std::stringstream ss; ss << newValue; updateDefaultValue(ss.str()); }
|
|
void updateValidValues(const std::string& newValue) { mValidValues = newValue; }
|
|
const std::string& getUnits() const { return mUnits; }
|
|
const VisibilityLevel& getVisibility() const { return mVisibility; }
|
|
const Type& getType() const { return mType; }
|
|
const std::string& getValidValues() const { return mValidValues; }
|
|
bool isStatic() const { return mIsStatic; }
|
|
const std::string& getDescription() const { return mDescription; }
|
|
unsigned getScope() const { return mScope; }
|
|
|
|
static bool isValidIP(const std::string& ip);
|
|
static void getMinMaxStepping(const ConfigurationKey &key, std::string &min, std::string &max, std::string &stepping);
|
|
template<class T> static bool isInValRange(const ConfigurationKey &key, const std::string& val, const bool isInteger);
|
|
static const std::string visibilityLevelToString(const VisibilityLevel& visibility);
|
|
static const std::string typeToString(const ConfigurationKey::Type& type);
|
|
static void printKey(const ConfigurationKey &key, const std::string& currentValue, std::ostream& os);
|
|
static void printDescription(const ConfigurationKey &key, std::ostream& os);
|
|
};
|
|
|
|
|
|
#endif
|
|
|
|
|
|
// vim: ts=4 sw=4
|