path: root/netfs/fuse/fuseApp.cpp

#include "fuseApp.h"
#include "cache.impl.h"
#include "fuseDirs.h"
#include "fuseFiles.h"
#include "fuseMappersImpl.h"
#include "lockHelpers.h"
#include <Glacier2/Router.h>
#include <boost/lexical_cast.hpp>
#include <compileTimeFormatter.h>
#include <cstring>
#include <defaultMapper.h>
#include <entCache.h>
#include <safeMapFind.h>
#include <slicer/slicer.h>
#include <uriParse.h>

namespace AdHoc {
	template class Cache<struct stat, std::string>;
	template class CallCacheable<struct stat, std::string>;
}

NetFS::FuseApp::FuseApp(Ice::StringSeq && a) : iceArgs(std::move(a)), sessionOpened(false), openHandleId(0) { }

NetFS::FuseApp::~FuseApp()
{
	for (const OpenDirs::value_type & of : openDirs) {
		// LCOV_EXCL_START
		try {
			of.second->remote->close();
		}
		catch (...) {
			// Can't do anything useful here
		}
		// LCOV_EXCL_STOP
	}
	for (const OpenFiles::value_type & of : openFiles) {
		// LCOV_EXCL_START
		try {
			of.second->remote->close();
		}
		catch (...) {
			// Can't do anything useful here
		}
		// LCOV_EXCL_STOP
	}
	if (volume) {
		try {
			volume->disconnect();
		}
		catch (...) {
			// Can't do anything useful here
		}
	}
	if (session) {
		try {
			session->destroy();
		}
		catch (...) {
			// Can't do anything useful here
		}
	}
	if (ic) {
		ic->destroy();
	}
}

void *
NetFS::FuseApp::init(struct fuse_conn_info *, struct fuse_config *)
{
	BOOST_ASSERT(!ic);
	ic = Ice::initialize(iceArgs);
	BOOST_ASSERT(ic);
	if (!iceArgs.empty()) {
		const auto & arg = iceArgs.front();
		if (arg.find("://") != std::string::npos) {
			fcr = configureFromUri(arg);
		}
		else if (auto colon = arg.find(':'); colon != std::string::npos) {
			fcr = configureFromFile(arg.substr(0, colon), arg.substr(colon + 1));
		}
	}
	if (!fcr->Mapper) {
		fcr->Mapper = std::make_shared<Mapping::DefaultMapper>();
	}
	BOOST_ASSERT(fcr);
	converter.mapper = fcr->Mapper;
	return this;
}

NetFS::Client::ResourcePtr
NetFS::FuseApp::configureFromFile(const std::filesystem::path & path, const std::string & resourceName)
{
	auto s = Slicer::FileDeserializerFactory::createNew(path.extension().string(), path);
	auto c = Slicer::DeserializeAnyWith<NetFS::Client::ConfigurationPtr>(s);
	return AdHoc::safeMapLookup<Client::ResourceNotFound>(c->Resources, resourceName);
}

AdHocFormatter(IceEndpointFmt, "%? -h %? -p %?");
NetFS::Client::ResourcePtr
NetFS::FuseApp::configureFromUri(const std::string & uriString)
{
	const AdHoc::Uri uri(uriString);

	auto r = std::make_shared<NetFS::Client::Resource>();
	r->ExportName = uri.path->string();
	r->Endpoints.emplace_back(IceEndpointFmt::get(uri.scheme, uri.host, uri.port ? *uri.port : 4000));
	if (uri.password) {
		r->AuthToken = *uri.password;
	}
	auto set = [&uri](const auto & param, auto & setting) {
		if (auto p = uri.query.find(param); p != uri.query.end()) {
			setting = boost::lexical_cast<std::remove_reference_t<decltype(setting)>>(p->second);
		}
	};
	auto setWith = [&uri](const auto & param, auto & setting, auto && f) {
		if (auto p = uri.query.find(param); p != uri.query.end()) {
			setting = f(p->second);
		}
	};
	set("async", r->Async);
	setWith("mapper", r->Mapper, [&set, &setWith](auto && m) -> NetFS::Mapping::MapperPtr {
		if (m == "hide") {
			return std::make_shared<NetFS::Client::HideUnknownMapperImpl>();
		}
		else if (m == "mask") {
			auto mi = std::make_shared<NetFS::Client::MaskUnknownMapperImpl>();
			set("mapper.unknownuser", mi->UnknownUser);
			set("mapper.unknowngroup", mi->UnknownGroup);
			setWith("mapper.usermask", mi->UserMask, Client::from_octal);
			setWith("mapper.groupmask", mi->GroupMask, Client::from_octal);
			return mi;
		}
		return {};
	});
	return r;
}

int
NetFS::FuseApp::opt_parse(void * data, const char * arg, int, struct fuse_args *)
{
	auto & iceArgs = *static_cast<Ice::StringSeq *>(data);
	if (strncmp(arg, "--Ice.", 6) == 0) {
		iceArgs.emplace_back(arg);
		return 0;
	}
	else if (strncmp(arg, "_netdev", 7) == 0) {
		return 0;
	}
	else if (arg[0] == '-') {
		return 1;
	}
	else if (iceArgs.empty() || strncmp(iceArgs.front().c_str(), "--Ice.", 6) == 0) {
		iceArgs.emplace(iceArgs.begin(), arg);
		return 0;
	}
	return 1;
}

void
NetFS::FuseApp::connectSession()
{
	if (!sessionOpened && ic->getDefaultRouter()) {
		Lock(_lock);
		auto router = Ice::checkedCast<Glacier2::RouterPrx>(ic->getDefaultRouter());
		session = router->createSession("", "");
		if (int acmTimeout = router->getACMTimeout() > 0) {
			Ice::ConnectionPtr conn = router->ice_getCachedConnection();
			conn->setACM(acmTimeout, IceUtil::None, Ice::ACMHeartbeat::HeartbeatAlways);
		}
		sessionOpened = true;
	}
}

void
NetFS::FuseApp::connectToService()
{
	if (!service) {
		Lock(_lock);
		auto proxyAddr = fcr->ServiceIdentity;
		for (const auto & ep : fcr->Endpoints) {
			proxyAddr += ":" + ep;
		}
		service = Ice::checkedCast<NetFS::ServicePrx>(ic->stringToProxy(proxyAddr));
		if (!service) {
			throw std::runtime_error("Invalid service proxy: " + proxyAddr);
		}
	}
}

void
NetFS::FuseApp::connectToVolume()
{
	if (!volume) {
		Lock(_lock);
		volume = service->connect(fcr->ExportName, fcr->AuthToken);
		if (!volume) {
			throw std::runtime_error("Invalid filesystem proxy");
		}
	}
}

void
NetFS::FuseApp::connectHandles()
{
	for (const OpenFiles::value_type & of : openFiles) {
		try {
			of.second->remote->ice_ping();
		}
		catch (const Ice::ObjectNotExistException &) {
			of.second->remote = volume->open(reqEnv(), of.second->path, of.second->flags & !O_CREAT);
		}
	}
	for (const OpenDirs::value_type & of : openDirs) {
		try {
			of.second->remote->ice_ping();
		}
		catch (const Ice::ObjectNotExistException &) {
			of.second->remote = volume->opendir(reqEnv(), of.second->path);
		}
	}
}

void
NetFS::FuseApp::verifyConnection()
{
	Lock(_lock);
	if (session) {
		try {
			session->ice_ping();
		}
		catch (const Ice::Exception &) {
			session = nullptr;
			sessionOpened = false;
		}
	}
	if (service) {
		try {
			service->ice_ping();
		}
		catch (const Ice::Exception &) {
			service = nullptr;
		}
	}
	if (volume) {
		try {
			volume->ice_ping();
		}
		catch (const Ice::Exception &) {
			volume = nullptr;
		}
	}
}

int
NetFS::FuseApp::onError(const std::exception & e) noexcept
{
	if (dynamic_cast<const Ice::SocketException *>(&e) || dynamic_cast<const Ice::TimeoutException *>(&e)) {
		log(LOG_ERR, e.what());
		try {
			verifyConnection();
			connectSession();
			connectToService();
			connectToVolume();
			connectHandles();
			return 0;
		}
		catch (...) {
			return -EIO;
		}
	}
	if (dynamic_cast<const Ice::RequestFailedException *>(&e)) {
		try {
			volume = nullptr;
			connectToVolume();
			connectHandles();
			return 0;
		}
		catch (...) {
			return -EIO;
		}
	}
	if (dynamic_cast<const NetFS::AuthError *>(&e)) {
		return -EPERM;
	}
	return FuseAppBase::onError(e);
}

void
NetFS::FuseApp::beforeOperation()
{
	connectSession();
	connectToService();
	connectToVolume();
}

NetFS::ReqEnv
NetFS::FuseApp::reqEnv()
{
	struct fuse_context * c = fuse_get_context();
	const auto t = converter.mapper->mapFileSystem(c->uid, c->gid);
	return {t.username, t.groupname};
}