예제 #1
0
/**
 * @brief give info about current mounted backends
 *
 * @param mountConf a keyset that contains everything below
 * Backends::mountpointsPath
 *
 * @return an vector of information about mounted backends
 */
Backends::BackendInfoVector Backends::getBackendInfo (KeySet mountConf)
{
	std::vector<BackendInfo> ret;
	Key rootKey (Backends::mountpointsPath, KEY_END);
	Key cur;

	mountConf.rewind ();
	while ((cur = mountConf.next ()))
	{
		if (cur.isDirectBelow (rootKey))
		{
			BackendInfo bi;

			Key path = mountConf.lookup (cur.getName () + "/config/path");
			if (path)
			{
				bi.path = path.getString ();
			}
			Key mp = mountConf.lookup (cur.getName () + "/mountpoint");
			if (mp)
			{
				bi.mountpoint = mp.getString ();
			}
			bi.name = cur.getBaseName ();

			ret.push_back (bi);
		}
	}
	return ret;
}
예제 #2
0
/**
 * @brief set mp (interactive or by commandline)
 *
 * @see getName()
 */
void MountBaseCommand::getMountpoint (Cmdline const & cl)
{
	Key cur;
	std::vector<std::string> mountpoints;
	mountpoints.push_back ("system/elektra");
	mountConf.rewind ();
	while ((cur = mountConf.next ()))
	{
		if (cur.getBaseName () == "mountpoint")
		{
			if (cur.getString ().at (0) == '/')
			{
				mountpoints.push_back (Key ("user" + cur.getString (), KEY_END).getName ());
				mountpoints.push_back (Key ("system" + cur.getString (), KEY_END).getName ());
			}
			else
			{
				mountpoints.push_back (cur.getString ());
			}
		};
	}

	if (cl.interactive)
	{
		cout << "Already used are: ";
		std::copy (mountpoints.begin (), mountpoints.end (), ostream_iterator<std::string> (cout, " "));
		cout << endl;
		cout << "Please start with / for a cascading backend" << endl;
		cout << "Enter the mountpoint: ";
		cin >> mp;
	}
예제 #3
0
	/**
	 * @brief (Recursively) add or update a key to nodes
	 *
	 * If the key exists, it will be updated
	 *
	 * If the key does not exist, node(s) will be created
	 *
	 * @param k the key to add
	 * @param depth current depth of recursion
	 */
	void add(Key k, unsigned long depth)
	{
		assert(k);
		assert(m_self ? m_self.isBelow(k) : true);
		depth++;

		if (m_self.isDirectBelow(k) || depth == name_depth(k))
		{
			for (KeyNodeIterator it = m_subnodes.begin();
					it != m_subnodes.end();
					++it)
			{
				if (it->first == k.getBaseName())
				{
					// found node, update it
					it->second.m_self = k;
					return;
				}
			}
			// will add new subnode (direct below+not found)
			m_subnodes.insert(std::make_pair(k.getBaseName(), KeyNode(depth, k)));
			return;
		}

		for (KeyNodeIterator it = m_subnodes.begin();
				it != m_subnodes.end();
				++it)
		{
			if (k.isBelow(it->second.m_self))
			{
				// found subnode, call recursively
				it->second.add(k, depth);
				return;
			}
		}

		// create a structure key (without key, only name)
		std::string name = nth_level_of_name(k, depth);
		std::pair<KeyNodeIterator, bool> p = m_subnodes.insert(
			std::make_pair(name, KeyNode(depth)));
			// structure keys get a null key
		KeyNodeIterator it = p.first;
		it->second.add(k, depth);
	}
예제 #4
0
/**
 * @brief Find a backend in the given name
 *
 * @param mountPath the given backend name to find
 *
 * For backwards compatibility old-style names containing _ instead of escaped /
 * are accepted if no modern-style mountpoint is found.
 *
 * @param mountConf the configuration to search (should contain keys
 * below mountpointsPath to find something)
 *
 * @return the found backend or an empty BackendInfo if nothing found
 *         (with empty strings)
 */
BackendInfo Backends::findBackend (std::string const & mountPath, KeySet mountConf, bool verbose)
{
	BackendInfo ret;
	if (mountPath.empty ()) return ret;

	Backends::BackendInfoVector mtab = Backends::getBackendInfo (mountConf);

	Key kmp (Backends::getBasePath (mountPath), KEY_END);

	// search for proper mountname:
	for (Backends::BackendInfoVector::const_iterator it = mtab.begin (); it != mtab.end (); ++it)
	{
		if (verbose) std::cout << "compare: " << it->mountpoint << " with " << kmp.getBaseName () << std::endl;
		if (it->mountpoint == kmp.getBaseName ())
		{
			return *it;
		}
	};

	// fall back to compatibility pre 0.8.11 mountnames
	// May umount wrong things, so its done as extra step so that
	// it will never happen if something desired is present.
	std::string soldMountpoint = mountPath;
	std::replace (soldMountpoint.begin (), soldMountpoint.end (), '_', '/');
	Key koldMountpoint ("user/" + soldMountpoint, KEY_END);
	std::string omp = koldMountpoint.getName ();
	std::string oldMountpoint (omp.begin () + 4, omp.end ());
	if (soldMountpoint.at (0) != '/') oldMountpoint.erase (0, 1); // fix non-cascading
	if (koldMountpoint.getName () == "user") oldMountpoint = "/"; // fix root
	for (Backends::BackendInfoVector::const_iterator it = mtab.begin (); it != mtab.end (); ++it)
	{
		if (verbose) std::cout << "fallback compare: " << it->mountpoint << " with " << oldMountpoint << std::endl;
		if (it->mountpoint == oldMountpoint)
		{
			return *it;
		}
	}
	return ret;
}
예제 #5
0
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;
}