//! [ksDeepCopy]
kdb::KeySet ksDeepCopy (kdb::KeySet orig)
{
kdb::KeySet deepCopy;
orig.rewind ();
while (orig.next ())
{
deepCopy.append (orig.current ().dup ());
}
return deepCopy;
}
// TODO: replace with proper ContainerEq
void compareKeySet (kdb::KeySet ks1, kdb::KeySet ks2)
{
using namespace kdb;
KeySet::iterator i1 = ks1.begin ();
for (KeySet::iterator i2 = ks2.begin (); i2 != ks2.end (); ++i1, ++i2)
{
EXPECT_EQ (*i1, *i2);
}
EXPECT_EQ (i1, ks1.end ()) << "second iterator not at end";
}
static inline void doCheck(Checker *c, kdb::KeySet ks)
{
try {
c->check(ks);
}
catch (const char *)
{
/* Make sure that it will be released */
ks.release();
throw;
}
ks.release();
}
Factory(kdb::KeySet config) :
m_factory()
{
config.rewind();
kdb::Key root = config.next();
m_factory.insert(std::make_pair("list", new Cnstancer<ListChecker>()));
kdb::Key k;
while ((k = config.next()))
{
if (!k.isDirectBelow(root)) throw "Factory: key for configuration is not direct below";
kdb::KeySet cks(config.cut(k));
m_factory.insert(std::make_pair(k.getBaseName(), new StructInstancer(cks)));
}
}
int Plugin::error (kdb::KeySet & ks, kdb::Key & parentKey)
{
if (!plugin->kdbError)
{
throw MissingSymbol("kdbError");
}
return plugin->kdbError(plugin, ks.getKeySet(), parentKey.getKey());
}
int Plugin::set (kdb::KeySet & ks, kdb::Key & parentKey)
{
if (!plugin->kdbSet)
{
throw MissingSymbol("kdbSet");
}
return plugin->kdbSet(plugin, ks.getKeySet(), parentKey.getKey());
}
/**
* @brief Easily allows to generate regression tests for keysets.
*
* @param tocheck the keyset to check (name + string)
* @param name the name of the keyset
*/
void outputGTest(kdb::KeySet tocheck, std::string name)
{
std::cout << name << ".rewind();" << std::endl;
tocheck.rewind();
while(tocheck.next())
{
std::cout << name << ".next();" << std::endl;
std::cout << "EXPECT_TRUE(" << name
<< ".current().getName() == \""
<< tocheck.current().getName()
<< "\") << \"name of element in keyset wrong\";"
<< std::endl;
std::cout << "EXPECT_TRUE(" << name
<< ".current().getString() == \""
<< tocheck.current().getString()
<< "\") << \"string of element in keyset wrong\";"
<< std::endl;
}
}
void check(kdb::KeySet &ks) override
{
config.rewind();
kdb::Key confRoot = config.next();
if (!confRoot) throw "StructChecker: No confRoot found";
kdb::Key cur;
kdb::Key root = ks.next();
if (!root) throw "StructChecker: No root key found";
while ((cur = ks.next()))
{
kdb::Key searchKey = config.next();
if (!searchKey) throw "StructChecker: More keys found than structure should have";
if (!cur.isDirectBelow(root)) throw "StructChecker: key is not direct below";
if (searchKey.getBaseName() != cur.getBaseName())
throw "StructChecker: did not find expected subkey";
cur.copyAllMeta (searchKey);
}
if (config.next()) throw "StructChecker: There should be more elements in the structure";
}
void check (kdb::KeySet &ks) override
{
kdb::Key k;
kdb::KeySet ks2 (ks.dup());
ks2.rewind();
kdb::Key root = ks2.next();
if (!root) throw "ListChecker: no root key found";
while ((k = ks2.next()))
{
if (!root.isDirectBelow(k)) throw "ListChecker: key is not direct below";
kdb::KeySet cks(ks2.cut(k));
structure->check(cks);
}
}
/**This function avoid that every return path need to release the
* configuration. */
inline static int openHelper (ckdb::Plugin * handle, kdb::KeySet & config, ckdb::Key * errorKey, Builder builder)
{
if (config.lookup ("/module"))
{
// suppress warnings if it is just a module
// don't buildup the Delegated then
return 0;
}
try
{
elektraPluginSetData (handle, (*builder) (config));
}
catch (const char * msg)
{
#ifdef KDBERRORS_H
ELEKTRA_ADD_WARNING (69, errorKey, msg);
#endif
return -1;
}
return get (handle) != nullptr ? 1 : -1;
}
void GlobalPlugins::serialize (kdb::KeySet & ret)
{
// transform to suitable data structure
std::map<std::shared_ptr<Plugin>, Placements> pp;
for (auto const & placements : plugins)
{
for (auto const & plugin : placements.second)
{
std::istringstream ss (plugin->lookupInfo ("status"));
std::string status;
bool isglobal = false;
while (ss >> status)
{
if (status == "global") isglobal = true;
}
if (!isglobal)
{
throw NoGlobalPlugin (plugin->name ());
}
pp[plugin].addPlacement (placements.first);
}
}
ret.append (Key ("system/elektra/globalplugins", KEY_VALUE, "", KEY_END));
ret.append (Key ("system/elektra/globalplugins/postcommit", KEY_VALUE, "list", KEY_END));
ret.append (Key ("system/elektra/globalplugins/postcommit/user", KEY_VALUE, "list", KEY_END));
ret.append (Key ("system/elektra/globalplugins/postcommit/user/placements", KEY_VALUE, "", KEY_END));
ret.append (Key ("system/elektra/globalplugins/postcommit/user/placements/set", KEY_VALUE, "presetstorage precommit postcommit",
KEY_END));
ret.append (
Key ("system/elektra/globalplugins/postcommit/user/placements/get", KEY_VALUE, "pregetstorage postgetstorage", KEY_END));
ret.append (Key ("system/elektra/globalplugins/postcommit/user/placements/error", KEY_VALUE, "prerollback postrollback", KEY_END));
ret.append (Key ("system/elektra/globalplugins/postcommit/user/plugins", KEY_VALUE, "", KEY_END));
Key i ("system/elektra/globalplugins/postcommit/user/plugins/#0", KEY_END);
for (auto const & plugin : pp)
{
i.setString (plugin.first->name ());
ret.append (i.dup ());
Key placements (i.dup ());
placements.addBaseName ("placements");
ret.append (placements);
ret.append (g (placements, "get", plugin.second.get));
ret.append (g (placements, "set", plugin.second.set));
ret.append (g (placements, "error", plugin.second.error));
serializeConf (ret, Key (i.getName () + "/config", KEY_VALUE, "", KEY_END), plugin.first->getConfig ());
ckdb::elektraArrayIncName (*i);
}
ret.append (Key ("system/elektra/globalplugins/postrollback", KEY_VALUE, "list", KEY_END));
ret.append (Key ("system/elektra/globalplugins/precommit", KEY_VALUE, "list", KEY_END));
ret.append (Key ("system/elektra/globalplugins/pregetstorage", KEY_VALUE, "list", KEY_END));
ret.append (Key ("system/elektra/globalplugins/postgetstorage", KEY_VALUE, "list", KEY_END));
ret.append (Key ("system/elektra/globalplugins/presetstorage", KEY_VALUE, "list", KEY_END));
ret.append (Key ("system/elektra/globalplugins/prerollback", KEY_VALUE, "list", KEY_END));
}
/**
* @pre name and mountpoint set
* Add plugin serialization into keyset ret.
*
* Only can be done once!
* (see firstRef in Plugin)
* */
void Backend::serialize (kdb::KeySet & ret)
{
assert (!mp.empty ());
Key backendRootKey (Backends::mountpointsPath, KEY_END);
backendRootKey.addBaseName (mp);
backendRootKey.setString ("This is a configuration for a backend, see subkeys for more information");
ret.append (backendRootKey);
if (mp == "/")
{
ret.append (*Key (backendRootKey.getName () + "/mountpoint", KEY_VALUE, "/", KEY_COMMENT,
"The mountpoint says the location where the backend should be mounted.\n"
"This is the root mountpoint.\n",
KEY_END));
}
else if (mp.at (0) == '/')
{
Key k ("system" + mp, KEY_END);
Key restrictedPath ("system/elektra", KEY_END);
if (!k) throw MountpointInvalidException ();
if (restrictedPath.isBelow (k)) throw MountpointInvalidException ();
ret.append (*Key (backendRootKey.getName () + "/mountpoint", KEY_VALUE, mp.c_str (), KEY_COMMENT,
"The mountpoint says the location where the backend should be mounted.\n"
"This is a cascading mountpoint.\n"
"That means it is both mounted to dir, user and system.",
KEY_END));
}
else
{
Key k (mp, KEY_END);
Key restrictedPath ("system/elektra", KEY_END);
if (!k) throw MountpointInvalidException ();
if (restrictedPath.isBelow (k)) throw MountpointInvalidException ();
ret.append (*Key (backendRootKey.getName () + "/mountpoint", KEY_VALUE, mp.c_str (), KEY_COMMENT,
"The mountpoint says the location where the backend should be mounted.\n"
"This is a normal mountpoint.\n",
KEY_END));
}
const string configBasePath = Backends::getBasePath (mp) + "/config";
ret.append (Key (configBasePath, KEY_END));
config.rewind ();
Key common = config.next ();
Key oldParent ("system", KEY_END);
Key newParent (configBasePath, KEY_END);
for (KeySet::iterator i = config.begin (); i != config.end (); ++i)
{
Key k (i->dup ());
ret.append (kdb::tools::helper::rebaseKey (k, oldParent, newParent));
}
errorplugins.serialise (backendRootKey, ret);
getplugins.serialise (backendRootKey, ret);
setplugins.serialise (backendRootKey, ret);
ret.append (*Key (backendRootKey.getName () + "/config/path", KEY_VALUE, configFile.c_str (), KEY_COMMENT,
"The path for this backend. Note that plugins can override that with more specific configuration.", KEY_END));
}