void MountCommand::buildBackend (Cmdline const & cl)
{
MountBackendBuilder backend;
Key mpk (mp, KEY_CASCADING_NAME, KEY_END);
if (!mpk.isValid ())
{
throw invalid_argument (mp + " is not a valid mountpoint");
}
backend.setMountpoint (mpk, mountConf);
backend.setBackendConfig (cl.getPluginsConfig ("system/"));
PluginSpec resolver (cl.resolver);
if (cl.debug)
{
cout << "Trying to load the resolver plugin " << resolver.getName () << endl;
}
backend.addPlugin (PluginSpec (resolver));
if (cl.interactive)
{
cout << endl;
cout << "Enter a path to a file in the filesystem." << endl;
cout << "The path must either not exist or be a file." << endl;
cout << "For user or cascading mountpoints it must be a relative path." << endl;
cout << "Then, the path will be resolved dynamically." << endl;
cout << "Path: ";
cin >> path;
}
void SpecMountCommand::buildBackend (Cmdline const & cl)
{
SpecReader sr;
kdb::KeySet specToRead;
kdb.get (specToRead, "spec" + mp);
specToRead = specToRead.cut (Key ("spec" + mp, KEY_END));
sr.readSpecification (specToRead);
SpecReader::Backends const & backends = sr.getBackends ();
for (auto & p : backends)
{
auto backend = p.second;
if (cl.verbose)
{
std::cout << "Got mountpoint from " << p.first.getName () << " with " << backend.nodes
<< " nodes, configfile: " << backend.getConfigFile () << " and mountpoint: " << backend.getMountpoint ()
<< std::endl;
}
backend.setBackendConfig (cl.getPluginsConfig ("system/"));
backend.needPlugin (cl.resolver);
backend.needPlugin ("storage");
backend.addPlugins (parseArguments (cl.plugins));
const int alreadyRead = 1; // we already read mountpoint
if (cl.arguments.size () <= alreadyRead)
{
backend.addPlugins (parseArguments (cl.arguments.begin () + alreadyRead, cl.arguments.end ()));
}
// Call it a day
outputMissingRecommends (backend.resolveNeeds (cl.withRecommends));
Backends::umount (backend.getMountpoint (), mountConf);
backend.serialize (mountConf);
}
if (!cl.quiet && backends.empty ())
{
std::cout << "No metadata \"mountpoint\" found below spec" << mp << std::endl;
}
}
int ExportCommand::execute (Cmdline const & cl)
{
size_t argc = cl.arguments.size ();
if (argc != 1 && argc != 2 && argc != 3)
{
throw invalid_argument ("need 1 to 3 arguments");
}
Key root = cl.createKey (0);
kdb.get (ks, root);
printWarnings (cerr, root);
KeySet part (ks.cut (root));
if (cl.withoutElektra)
{
Key systemElektra ("system/elektra", KEY_END);
part.cut (systemElektra);
}
string format = cl.format;
if (argc > 1) format = cl.arguments[1];
#ifdef _WIN32
string file = "CON";
#else
string file = "/dev/stdout";
#endif
if (argc > 2 && cl.arguments[2] != "-") file = cl.arguments[2];
Modules modules;
PluginPtr plugin = modules.load (format, cl.getPluginsConfig ());
Key errorKey (root);
errorKey.setString (file);
plugin->set (part, errorKey);
printWarnings (cerr, errorKey);
printError (cerr, errorKey);
return 0;
}
int ImportCommand::execute (Cmdline const & cl)
{
size_t argc = cl.arguments.size ();
if (argc != 1 && argc != 2 && argc != 3)
{
throw invalid_argument ("need 1 to 3 arguments");
}
Key root = cl.createKey (0);
if (!root.isValid ())
{
throw invalid_argument ("root key \"" + cl.arguments[0] + "\" is not a valid key name");
}
KeySet originalKeys;
kdb.get (originalKeys, root);
KeySet base = originalKeys.cut (root);
printWarnings (cerr, root);
string format = cl.format;
if (argc > 1) format = cl.arguments[1];
string file = "/dev/stdin";
if (argc > 2 && cl.arguments[2] != "-") file = cl.arguments[2];
Modules modules;
PluginPtr plugin = modules.load (format, cl.getPluginsConfig ());
Key errorKey (root);
errorKey.setString (file);
KeySet importedKeys;
plugin->get (importedKeys, errorKey);
importedKeys = importedKeys.cut (root);
printWarnings (cerr, errorKey);
printError (cerr, errorKey);
ThreeWayMerge merger;
MergeHelper helper;
helper.configureMerger (cl, merger);
MergeResult result = merger.mergeKeySet (
MergeTask (BaseMergeKeys (base, root), OurMergeKeys (base, root), TheirMergeKeys (importedKeys, root), root));
helper.reportResult (cl, result, cout, cerr);
int ret = -1;
if (!result.hasConflicts ())
{
if (cl.verbose)
{
cout << "The merged keyset with strategy " << cl.strategy << " is:" << endl;
cout << result.getMergedKeys ();
}
KeySet resultKeys = result.getMergedKeys ();
originalKeys.append (resultKeys);
kdb.set (originalKeys, root);
ret = 0;
}
return ret;
}
int InfoCommand::execute (Cmdline const & cl)
{
std::string subkey;
if (cl.arguments.size () == 1)
{
}
else if (cl.arguments.size () == 2)
{
subkey = cl.arguments[1];
}
else
{
throw invalid_argument ("Need at 1 or 2 argument(s)");
}
std::string name = cl.arguments[0];
KeySet conf;
Key parentKey (std::string ("system/elektra/modules/") + name, KEY_END);
if (!cl.load)
{
kdb.get (conf, parentKey);
}
if (!conf.lookup (parentKey))
{
if (!cl.load)
{
cerr << "Module does not seem to be loaded." << endl;
cerr << "Now in fallback code. Will directly load config from plugin." << endl;
}
Modules modules;
KeySet ks = cl.getPluginsConfig ();
PluginPtr plugin;
if (ks.size () == 0)
{
plugin = modules.load (name);
}
else
{
plugin = modules.load (name, ks);
}
conf.append (plugin->getInfo ());
}
Key root (std::string ("system/elektra/modules/") + name + "/exports", KEY_END);
if (!subkey.empty ())
{
root.setName (std::string ("system/elektra/modules/") + name + "/infos/" + subkey);
Key k = conf.lookup (root);
if (k)
{
cout << k.getString () << std::endl;
return 0;
}
else
{
cerr << "clause not found" << std::endl;
return 1;
}
}
root.setName (std::string ("system/elektra/modules/") + name + "/exports");
Key k = conf.lookup (root);
if (k)
{
cout << "Exported symbols: ";
while ((k = conf.next ()) && k.isBelow (root))
{
cout << k.getBaseName () << " ";
}
cout << endl;
}
else
cout << "no exported symbols found" << endl;
root.setName (std::string ("system/elektra/modules/") + name + "/infos");
k = conf.lookup (root);
if (k)
{
while ((k = conf.next ()) && k.isBelow (root))
{
cout << k.getBaseName () << ": " << k.getString () << endl;
}
}
else
cout << "no information found" << endl;
return 0;
}