diff options
42 files changed, 1274 insertions, 1315 deletions
diff --git a/netfs/daemon/daemon.cpp b/netfs/daemon/daemon.cpp index ddd67f2..e232aaa 100644 --- a/netfs/daemon/daemon.cpp +++ b/netfs/daemon/daemon.cpp @@ -1,11 +1,11 @@ -#include <Ice/Ice.h> #include "daemon.h" #include "daemonService.h" #include "daemonVolume.h" -#include <slicer/slicer.h> #include "modeCheck.h" -#include <sys/stat.h> +#include <Ice/Ice.h> #include <safeMapFind.h> +#include <slicer/slicer.h> +#include <sys/stat.h> NetFSDaemon::~NetFSDaemon() { @@ -32,7 +32,7 @@ NetFSDaemon::hostname() // name = NetFSDaemonAdapter void -NetFSDaemon::start(const std::string & name, const Ice::CommunicatorPtr & ic, const Ice::StringSeq&) +NetFSDaemon::start(const std::string & name, const Ice::CommunicatorPtr & ic, const Ice::StringSeq &) { this->ic = ic; Ice::PropertiesPtr props = ic->getProperties(); @@ -66,12 +66,11 @@ NetFSDaemon::stop() } extern "C" { - DLL_PUBLIC - IceBox::Service * - // NOLINTNEXTLINE(performance-unnecessary-value-param) - createNetFSDaemon(Ice::CommunicatorPtr) - { - return new NetFSDaemon(); - } +DLL_PUBLIC +IceBox::Service * + // NOLINTNEXTLINE(performance-unnecessary-value-param) + createNetFSDaemon(Ice::CommunicatorPtr) +{ + return new NetFSDaemon(); +} } - diff --git a/netfs/daemon/daemon.h b/netfs/daemon/daemon.h index cea9643..373c0cb 100644 --- a/netfs/daemon/daemon.h +++ b/netfs/daemon/daemon.h @@ -3,32 +3,31 @@ #include <Ice/Ice.h> #include <IceBox/IceBox.h> +#include <c++11Helpers.h> #include <daemonConfig.h> #include <filesystem> #include <visibility.h> -#include <c++11Helpers.h> class DLL_PUBLIC NetFSDaemon : public IceBox::Service { - public: - NetFSDaemon() = default; - SPECIAL_MEMBERS_MOVE_RO(NetFSDaemon); - ~NetFSDaemon() override; +public: + NetFSDaemon() = default; + SPECIAL_MEMBERS_MOVE_RO(NetFSDaemon); + ~NetFSDaemon() override; - void start(const std::string&, const Ice::CommunicatorPtr&, const Ice::StringSeq&) override; - void stop() override; + void start(const std::string &, const Ice::CommunicatorPtr &, const Ice::StringSeq &) override; + void stop() override; - protected: - [[nodiscard]] virtual NetFS::Daemon::ConfigurationPtr ReadConfiguration(const std::filesystem::path & path) const; +protected: + [[nodiscard]] virtual NetFS::Daemon::ConfigurationPtr ReadConfiguration(const std::filesystem::path & path) const; - private: - void LoadConfiguration(const std::filesystem::path & path); +private: + void LoadConfiguration(const std::filesystem::path & path); - Ice::CommunicatorPtr ic; - Ice::ObjectAdapterPtr adapter; - NetFS::Daemon::RuntimeConfigurationPtr dc; + Ice::CommunicatorPtr ic; + Ice::ObjectAdapterPtr adapter; + NetFS::Daemon::RuntimeConfigurationPtr dc; - std::string hostname(); + std::string hostname(); }; #endif - diff --git a/netfs/daemon/daemonConfigImpl.cpp b/netfs/daemon/daemonConfigImpl.cpp index 48b1d0e..e45cf97 100644 --- a/netfs/daemon/daemonConfigImpl.cpp +++ b/netfs/daemon/daemonConfigImpl.cpp @@ -1,5 +1,5 @@ -#include <daemonConfig.h> #include <compileTimeFormatter.h> +#include <daemonConfig.h> AdHocFormatter(HostNotConfiguredMsg, "This host [%?] is not defined in the configuration"); void @@ -7,4 +7,3 @@ NetFS::Daemon::HostNotConfigured::ice_print(std::ostream & s) const { HostNotConfiguredMsg::write(s, hostName); } - diff --git a/netfs/daemon/daemonDirectory.cpp b/netfs/daemon/daemonDirectory.cpp index 22c0e4f..cf56c72 100644 --- a/netfs/daemon/daemonDirectory.cpp +++ b/netfs/daemon/daemonDirectory.cpp @@ -1,17 +1,13 @@ +#include "daemonDirectory.h" #include <Ice/ObjectAdapter.h> -#include <dirent.h> #include <cerrno> +#include <dirent.h> +#include <fcntl.h> #include <map> #include <sys/stat.h> #include <sys/types.h> -#include <fcntl.h> -#include "daemonDirectory.h" -DirectoryServer::DirectoryServer(DIR * d, EntryTypeConverter & t) : - EntryTypeConverter(t), - od(d) -{ -} +DirectoryServer::DirectoryServer(DIR * d, EntryTypeConverter & t) : EntryTypeConverter(t), od(d) { } void DirectoryServer::close(const Ice::Current & ice) @@ -26,7 +22,7 @@ DirectoryServer::close(const Ice::Current & ice) } NetFS::NameList -DirectoryServer::readdir(const Ice::Current&) +DirectoryServer::readdir(const Ice::Current &) { errno = 0; NetFS::NameList list; @@ -42,7 +38,7 @@ DirectoryServer::readdir(const Ice::Current&) } NetFS::DirectoryContents -DirectoryServer::listdir(const Ice::Current&) +DirectoryServer::listdir(const Ice::Current &) { errno = 0; NetFS::DirectoryContents list; @@ -53,7 +49,8 @@ DirectoryServer::listdir(const Ice::Current&) throw NetFS::SystemError(errno); // LCOV_EXCL_STOP } - struct stat s {}; + struct stat s { + }; if (::fstatat(fd, d->d_name, &s, AT_SYMLINK_NOFOLLOW) != 0) { // LCOV_EXCL_START throw NetFS::SystemError(errno); @@ -63,4 +60,3 @@ DirectoryServer::listdir(const Ice::Current&) } return list; } - diff --git a/netfs/daemon/daemonDirectory.h b/netfs/daemon/daemonDirectory.h index e74f5dc..83a827a 100644 --- a/netfs/daemon/daemonDirectory.h +++ b/netfs/daemon/daemonDirectory.h @@ -6,18 +6,15 @@ #include <typeConverter.h> class DirectoryServer : public NetFS::Directory, EntryTypeConverter { - public: - DirectoryServer(DIR * od, EntryTypeConverter &); +public: + DirectoryServer(DIR * od, EntryTypeConverter &); - void close(const Ice::Current&) override; - NetFS::NameList readdir(const Ice::Current&) override; - NetFS::DirectoryContents listdir(const Ice::Current&) override; + void close(const Ice::Current &) override; + NetFS::NameList readdir(const Ice::Current &) override; + NetFS::DirectoryContents listdir(const Ice::Current &) override; - private: - DIR * od; +private: + DIR * od; }; #endif - - - diff --git a/netfs/daemon/daemonFile.cpp b/netfs/daemon/daemonFile.cpp index ec96bc3..56adcc5 100644 --- a/netfs/daemon/daemonFile.cpp +++ b/netfs/daemon/daemonFile.cpp @@ -1,21 +1,17 @@ +#include "daemonFile.h" #include <Ice/ObjectAdapter.h> #include <cerrno> -#include <map> +#include <entCache.h> #include <fcntl.h> -#include <typeConverter.h> +#include <map> #include <sys/stat.h> -#include "daemonFile.h" -#include <entCache.h> +#include <typeConverter.h> #include <unistd.h> -FileServer::FileServer(int f, EntryTypeConverter & t) : - EntryTypeConverter(t), - fd(f) -{ -} +FileServer::FileServer(int f, EntryTypeConverter & t) : EntryTypeConverter(t), fd(f) { } void -FileServer::ftruncate(const NetFS::ReqEnv re, Ice::Long size, const Ice::Current&) +FileServer::ftruncate(const NetFS::ReqEnv re, Ice::Long size, const Ice::Current &) { (void)re; errno = 0; @@ -28,7 +24,8 @@ NetFS::Attr FileServer::fgetattr(const NetFS::ReqEnv re, const Ice::Current &) { (void)re; - struct stat s {}; + struct stat s { + }; if (::fstat(fd, &s) != 0) { throw NetFS::SystemError(errno); } @@ -46,7 +43,7 @@ FileServer::close(const Ice::Current & ice) } NetFS::Buffer -FileServer::read(Ice::Long offset, Ice::Long size, const Ice::Current&) +FileServer::read(Ice::Long offset, Ice::Long size, const Ice::Current &) { NetFS::Buffer buf; buf.resize(size); @@ -62,7 +59,7 @@ FileServer::read(Ice::Long offset, Ice::Long size, const Ice::Current&) } void -FileServer::write(Ice::Long offset, Ice::Long size, const NetFS::Buffer data, const Ice::Current&) +FileServer::write(Ice::Long offset, Ice::Long size, const NetFS::Buffer data, const Ice::Current &) { errno = 0; if (pwrite(fd, &data.front(), size, offset) != size) { @@ -71,14 +68,13 @@ FileServer::write(Ice::Long offset, Ice::Long size, const NetFS::Buffer data, co } Ice::Long -FileServer::copyrange(NetFS::FilePrxPtr to, Ice::Long offsrc, Ice::Long offdst, Ice::Long size, Ice::Int flags, const Ice::Current& ice) +FileServer::copyrange(NetFS::FilePrxPtr to, Ice::Long offsrc, Ice::Long offdst, Ice::Long size, Ice::Int flags, + const Ice::Current & ice) { - if (auto obj = ice.adapter->findByProxy(to); - auto file = std::dynamic_pointer_cast<FileServer>(obj)) { + if (auto obj = ice.adapter->findByProxy(to); auto file = std::dynamic_pointer_cast<FileServer>(obj)) { errno = 0; off_t src = offsrc, dst = offdst; - if (auto rtn = copy_file_range(fd, &src, file->fd, &dst, size, flags); - rtn != -1) { + if (auto rtn = copy_file_range(fd, &src, file->fd, &dst, size, flags); rtn != -1) { return rtn; } throw NetFS::SystemError(errno); @@ -88,4 +84,3 @@ FileServer::copyrange(NetFS::FilePrxPtr to, Ice::Long offsrc, Ice::Long offdst, return size; } } - diff --git a/netfs/daemon/daemonFile.h b/netfs/daemon/daemonFile.h index 7c4c121..e5b7475 100644 --- a/netfs/daemon/daemonFile.h +++ b/netfs/daemon/daemonFile.h @@ -5,21 +5,19 @@ #include <typeConverter.h> class FileServer : public NetFS::File, EntryTypeConverter { - public: - FileServer(int fd, EntryTypeConverter &); +public: + FileServer(int fd, EntryTypeConverter &); - void close(const Ice::Current&) override; - void ftruncate(const NetFS::ReqEnv, Ice::Long size, const Ice::Current&) override; - NetFS::Attr fgetattr(const NetFS::ReqEnv, const Ice::Current&) override; + void close(const Ice::Current &) override; + void ftruncate(const NetFS::ReqEnv, Ice::Long size, const Ice::Current &) override; + NetFS::Attr fgetattr(const NetFS::ReqEnv, const Ice::Current &) override; - NetFS::Buffer read(Ice::Long offset, Ice::Long size, const Ice::Current&) override; - void write(Ice::Long offset, Ice::Long size, const NetFS::Buffer data, const Ice::Current&) override; - Ice::Long copyrange(NetFS::FilePrxPtr, Ice::Long, Ice::Long, Ice::Long, Ice::Int, const Ice::Current&) override; + NetFS::Buffer read(Ice::Long offset, Ice::Long size, const Ice::Current &) override; + void write(Ice::Long offset, Ice::Long size, const NetFS::Buffer data, const Ice::Current &) override; + Ice::Long copyrange(NetFS::FilePrxPtr, Ice::Long, Ice::Long, Ice::Long, Ice::Int, const Ice::Current &) override; - private: - const int fd; +private: + const int fd; }; #endif - - diff --git a/netfs/daemon/daemonService.cpp b/netfs/daemon/daemonService.cpp index fd5a0fd..18b050d 100644 --- a/netfs/daemon/daemonService.cpp +++ b/netfs/daemon/daemonService.cpp @@ -1,12 +1,9 @@ -#include "daemon.h" #include "daemonService.h" +#include "daemon.h" #include "daemonVolume.h" #include <safeMapFind.h> -ServiceServer::ServiceServer(NetFS::Daemon::ConfigurationPtr c) : - config(std::move(c)) -{ -} +ServiceServer::ServiceServer(NetFS::Daemon::ConfigurationPtr c) : config(std::move(c)) { } NetFS::VolumePrxPtr ServiceServer::connect(const std::string share, const std::string authtoken, const Ice::Current & ice) @@ -16,6 +13,5 @@ ServiceServer::connect(const std::string share, const std::string authtoken, con throw NetFS::AuthError(); } return Ice::uncheckedCast<NetFS::VolumePrx>(ice.adapter->addFacetWithUUID( - std::make_shared<VolumeServer>(ex->RootPath, userLookup, groupLookup), "v01")); + std::make_shared<VolumeServer>(ex->RootPath, userLookup, groupLookup), "v01")); } - diff --git a/netfs/daemon/daemonService.h b/netfs/daemon/daemonService.h index 64ae45c..e0f80ef 100644 --- a/netfs/daemon/daemonService.h +++ b/netfs/daemon/daemonService.h @@ -1,23 +1,21 @@ #ifndef DAEMONSERVICE_H #define DAEMONSERVICE_H -#include <service.h> -#include <entCache.h> #include <daemonConfig.h> #include <entCache.h> +#include <service.h> class ServiceServer : public NetFS::Service { - public: - explicit ServiceServer(NetFS::Daemon::ConfigurationPtr c); +public: + explicit ServiceServer(NetFS::Daemon::ConfigurationPtr c); - NetFS::VolumePrxPtr connect(const std::string share, const std::string auth, const Ice::Current&) override; + NetFS::VolumePrxPtr connect(const std::string share, const std::string auth, const Ice::Current &) override; - private: - EntCache<User> userLookup; - EntCache<Group> groupLookup; +private: + EntCache<User> userLookup; + EntCache<Group> groupLookup; - NetFS::Daemon::ConfigurationPtr config; + NetFS::Daemon::ConfigurationPtr config; }; #endif - diff --git a/netfs/daemon/daemonVolume.cpp b/netfs/daemon/daemonVolume.cpp index 096d748..3ae43da 100644 --- a/netfs/daemon/daemonVolume.cpp +++ b/netfs/daemon/daemonVolume.cpp @@ -1,25 +1,22 @@ -#include <Ice/ObjectAdapter.h> -#include <cerrno> -#include <map> -#include <unistd.h> -#include <sys/stat.h> -#include <climits> -#include <fcntl.h> #include "daemonVolume.h" -#include "daemonFile.h" +#include "daemon.h" #include "daemonDirectory.h" +#include "daemonFile.h" #include "modeCheck.h" +#include <Ice/ObjectAdapter.h> #include <boost/algorithm/string/predicate.hpp> +#include <cerrno> +#include <climits> #include <entCache.h> -#include "daemon.h" +#include <fcntl.h> +#include <map> +#include <sys/stat.h> +#include <unistd.h> extern std::map<Ice::Int, int> files; VolumeServer::VolumeServer(const std::filesystem::path & r, const EntCache<User> & u, const EntCache<Group> & g) : - root(std::filesystem::canonical(r)), - userLookup(u), - groupLookup(g), - converter(u, g) + root(std::filesystem::canonical(r)), userLookup(u), groupLookup(g), converter(u, g) { } @@ -33,7 +30,8 @@ Ice::Int VolumeServer::access(const NetFS::ReqEnv re, std::string path, Ice::Int mode, const Ice::Current &) { ModeCheck mc(re, root, userLookup, groupLookup); - struct stat s {}; + struct stat s { + }; std::filesystem::path p(resolvePath(std::move(path))); if (::stat(p.c_str(), &s) != 0) { return errno; @@ -59,7 +57,8 @@ NetFS::Attr VolumeServer::getattr(const NetFS::ReqEnv re, std::string path, const Ice::Current &) { ModeCheck mc(re, root, userLookup, groupLookup); - struct stat s {}; + struct stat s { + }; std::filesystem::path p(resolvePath(std::move(path))); mc.AssertReadParent(p); if (::lstat(p.c_str(), &s) != 0) { @@ -69,7 +68,7 @@ VolumeServer::getattr(const NetFS::ReqEnv re, std::string path, const Ice::Curre } void -VolumeServer::mknod(const NetFS::ReqEnv re, std::string path, Ice::Int mode, Ice::Int dev, const Ice::Current&) +VolumeServer::mknod(const NetFS::ReqEnv re, std::string path, Ice::Int mode, Ice::Int dev, const Ice::Current &) { ModeCheck mc(re, root, userLookup, groupLookup); errno = 0; @@ -113,7 +112,8 @@ VolumeServer::link(const NetFS::ReqEnv re, std::string path1, std::string path2, } void -VolumeServer::rename(const NetFS::ReqEnv re, std::string from, std::string to, const Ice::optional<Ice::Int> flags, const Ice::Current &) +VolumeServer::rename(const NetFS::ReqEnv re, std::string from, std::string to, const Ice::optional<Ice::Int> flags, + const Ice::Current &) { ModeCheck mc(re, root, userLookup, groupLookup); errno = 0; @@ -170,12 +170,12 @@ VolumeServer::chown(const NetFS::ReqEnv re, std::string path, Ice::Int uid, Ice: } void -VolumeServer::utimens(const NetFS::ReqEnv re, std::string path, - Ice::Long s0, Ice::Long ns0, Ice::Long s1, Ice::Long ns1, const Ice::Current&) +VolumeServer::utimens(const NetFS::ReqEnv re, std::string path, Ice::Long s0, Ice::Long ns0, Ice::Long s1, + Ice::Long ns1, const Ice::Current &) { ModeCheck mc(re, root, userLookup, groupLookup); errno = 0; - std::array<struct timespec, 2> times { { { s0, ns0 }, { s1, ns1 } } }; + std::array<struct timespec, 2> times {{{s0, ns0}, {s1, ns1}}}; std::filesystem::path p(resolvePath(std::move(path))); mc.AssertWrite(p); if (::utimensat(0, p.c_str(), times.data(), AT_SYMLINK_NOFOLLOW) != 0) { @@ -184,11 +184,12 @@ VolumeServer::utimens(const NetFS::ReqEnv re, std::string path, } NetFS::VFS -VolumeServer::statfs(const NetFS::ReqEnv re, std::string path, const Ice::Current&) +VolumeServer::statfs(const NetFS::ReqEnv re, std::string path, const Ice::Current &) { ModeCheck mc(re, root, userLookup, groupLookup); errno = 0; - struct statvfs s {}; + struct statvfs s { + }; std::filesystem::path p(resolvePath(std::move(path))); mc.AssertRead(p); if (::statvfs(p.c_str(), &s) != 0) { @@ -198,7 +199,7 @@ VolumeServer::statfs(const NetFS::ReqEnv re, std::string path, const Ice::Curren } void -VolumeServer::truncate(const NetFS::ReqEnv re, std::string path, Ice::Long size, const Ice::Current&) +VolumeServer::truncate(const NetFS::ReqEnv re, std::string path, Ice::Long size, const Ice::Current &) { ModeCheck mc(re, root, userLookup, groupLookup); errno = 0; @@ -210,7 +211,7 @@ VolumeServer::truncate(const NetFS::ReqEnv re, std::string path, Ice::Long size, } void -VolumeServer::unlink(const NetFS::ReqEnv re, std::string path, const Ice::Current&) +VolumeServer::unlink(const NetFS::ReqEnv re, std::string path, const Ice::Current &) { ModeCheck mc(re, root, userLookup, groupLookup); errno = 0; @@ -235,8 +236,8 @@ VolumeServer::open(const NetFS::ReqEnv re, std::string path, Ice::Int flags, con if (fd == -1) { throw NetFS::SystemError(errno); } - return Ice::uncheckedCast<NetFS::FilePrx>(ice.adapter->addFacetWithUUID( - std::make_shared<FileServer>(fd, converter), "v01")); + return Ice::uncheckedCast<NetFS::FilePrx>( + ice.adapter->addFacetWithUUID(std::make_shared<FileServer>(fd, converter), "v01")); } NetFS::FilePrxPtr @@ -255,8 +256,8 @@ VolumeServer::create(const NetFS::ReqEnv re, std::string path, Ice::Int flags, I ::unlink(p.c_str()); throw NetFS::SystemError(errno); } - return Ice::uncheckedCast<NetFS::FilePrx>(ice.adapter->addFacetWithUUID( - std::make_shared<FileServer>(fd, converter), "v01")); + return Ice::uncheckedCast<NetFS::FilePrx>( + ice.adapter->addFacetWithUUID(std::make_shared<FileServer>(fd, converter), "v01")); } NetFS::DirectoryPrxPtr @@ -270,12 +271,12 @@ VolumeServer::opendir(const NetFS::ReqEnv re, std::string path, const Ice::Curre if (!od) { throw NetFS::SystemError(errno); } - return Ice::uncheckedCast<NetFS::DirectoryPrx>(ice.adapter->addWithUUID( - std::make_shared<DirectoryServer>(od, converter))); + return Ice::uncheckedCast<NetFS::DirectoryPrx>( + ice.adapter->addWithUUID(std::make_shared<DirectoryServer>(od, converter))); } void -VolumeServer::mkdir(const NetFS::ReqEnv re, std::string path, Ice::Int mode, const Ice::Current&) +VolumeServer::mkdir(const NetFS::ReqEnv re, std::string path, Ice::Int mode, const Ice::Current &) { ModeCheck mc(re, root, userLookup, groupLookup); errno = 0; @@ -291,7 +292,7 @@ VolumeServer::mkdir(const NetFS::ReqEnv re, std::string path, Ice::Int mode, con } void -VolumeServer::rmdir(const NetFS::ReqEnv re, std::string path, const Ice::Current&) +VolumeServer::rmdir(const NetFS::ReqEnv re, std::string path, const Ice::Current &) { ModeCheck mc(re, root, userLookup, groupLookup); errno = 0; @@ -306,7 +307,7 @@ std::filesystem::path normalizedAppend(std::filesystem::path out, const std::filesystem::path && in) { unsigned int depth = 0; - for(const auto & e : in) { + for (const auto & e : in) { if (e.empty() || e == "." || e == "/") { continue; } @@ -330,4 +331,3 @@ VolumeServer::resolvePath(std::string && path) const { return normalizedAppend(root, std::move(path)); } - diff --git a/netfs/daemon/daemonVolume.h b/netfs/daemon/daemonVolume.h index 0f91f67..b75c5d6 100644 --- a/netfs/daemon/daemonVolume.h +++ b/netfs/daemon/daemonVolume.h @@ -1,53 +1,55 @@ #ifndef DAEMONVOLUME_H #define DAEMONVOLUME_H -#include <volume.h> -#include <shared_mutex> -#include <filesystem> #include <entCache.h> +#include <filesystem> +#include <shared_mutex> #include <typeConverter.h> +#include <volume.h> class VolumeServer : public NetFS::Volume { - public: - VolumeServer(const std::filesystem::path & root, const EntCache<User> &, const EntCache<Group> &); +public: + VolumeServer(const std::filesystem::path & root, const EntCache<User> &, const EntCache<Group> &); - NetFS::DirectoryPrxPtr opendir(const NetFS::ReqEnv, std::string path, const Ice::Current&) override; + NetFS::DirectoryPrxPtr opendir(const NetFS::ReqEnv, std::string path, const Ice::Current &) override; - void mkdir(const NetFS::ReqEnv, std::string path, Ice::Int id, const Ice::Current&) override; - void rmdir(const NetFS::ReqEnv, std::string path, const Ice::Current&) override; + void mkdir(const NetFS::ReqEnv, std::string path, Ice::Int id, const Ice::Current &) override; + void rmdir(const NetFS::ReqEnv, std::string path, const Ice::Current &) override; - void truncate(const NetFS::ReqEnv, std::string path, Ice::Long size, const Ice::Current&) override; + void truncate(const NetFS::ReqEnv, std::string path, Ice::Long size, const Ice::Current &) override; - void unlink(const NetFS::ReqEnv, std::string path, const Ice::Current&) override; + void unlink(const NetFS::ReqEnv, std::string path, const Ice::Current &) override; - NetFS::FilePrxPtr open(const NetFS::ReqEnv, std::string path, Ice::Int flags, const Ice::Current&) override; - NetFS::FilePrxPtr create(const NetFS::ReqEnv, std::string path, Ice::Int flags, Ice::Int mode, const Ice::Current&) override; + NetFS::FilePrxPtr open(const NetFS::ReqEnv, std::string path, Ice::Int flags, const Ice::Current &) override; + NetFS::FilePrxPtr create( + const NetFS::ReqEnv, std::string path, Ice::Int flags, Ice::Int mode, const Ice::Current &) override; - NetFS::VFS statfs(const NetFS::ReqEnv, std::string path, const Ice::Current&) override; + NetFS::VFS statfs(const NetFS::ReqEnv, std::string path, const Ice::Current &) override; - Ice::Int access(const NetFS::ReqEnv, std::string path, Ice::Int mode, const Ice::Current&) override; - NetFS::Attr getattr(const NetFS::ReqEnv, std::string path, const Ice::Current&) override; - void mknod(const NetFS::ReqEnv, std::string path, Ice::Int mode, Ice::Int dev, const Ice::Current&) override; - void symlink(const NetFS::ReqEnv, const std::string path1, const std::string path2, const Ice::Current&) override; - void link(const NetFS::ReqEnv, std::string path1, std::string path2, const Ice::Current&) override; - void rename(const NetFS::ReqEnv, std::string path1, const std::string path2, const Ice::optional<Ice::Int>, const Ice::Current&) override; - std::string readlink(const NetFS::ReqEnv, std::string path, const Ice::Current&) override; - void chmod(const NetFS::ReqEnv, std::string path, Ice::Int mode, const Ice::Current&) override; - void chown(const NetFS::ReqEnv, std::string path, Ice::Int uid, Ice::Int gid, const Ice::Current&) override; - void utimens(const NetFS::ReqEnv, std::string path, Ice::Long, Ice::Long, Ice::Long, Ice::Long, const Ice::Current&) override; + Ice::Int access(const NetFS::ReqEnv, std::string path, Ice::Int mode, const Ice::Current &) override; + NetFS::Attr getattr(const NetFS::ReqEnv, std::string path, const Ice::Current &) override; + void mknod(const NetFS::ReqEnv, std::string path, Ice::Int mode, Ice::Int dev, const Ice::Current &) override; + void symlink(const NetFS::ReqEnv, const std::string path1, const std::string path2, const Ice::Current &) override; + void link(const NetFS::ReqEnv, std::string path1, std::string path2, const Ice::Current &) override; + void rename(const NetFS::ReqEnv, std::string path1, const std::string path2, const Ice::optional<Ice::Int>, + const Ice::Current &) override; + std::string readlink(const NetFS::ReqEnv, std::string path, const Ice::Current &) override; + void chmod(const NetFS::ReqEnv, std::string path, Ice::Int mode, const Ice::Current &) override; + void chown(const NetFS::ReqEnv, std::string path, Ice::Int uid, Ice::Int gid, const Ice::Current &) override; + void utimens(const NetFS::ReqEnv, std::string path, Ice::Long, Ice::Long, Ice::Long, Ice::Long, + const Ice::Current &) override; - void disconnect(const Ice::Current&) override; + void disconnect(const Ice::Current &) override; - protected: - inline std::filesystem::path resolvePath(std::string && path) const; +protected: + inline std::filesystem::path resolvePath(std::string && path) const; - private: - const std::filesystem::path root; +private: + const std::filesystem::path root; - const EntCache<User> & userLookup; - const EntCache<Group> & groupLookup; - EntryTypeConverter converter; + const EntCache<User> & userLookup; + const EntCache<Group> & groupLookup; + EntryTypeConverter converter; }; #endif - diff --git a/netfs/daemon/modeCheck.cpp b/netfs/daemon/modeCheck.cpp index 58ade75..6e65888 100644 --- a/netfs/daemon/modeCheck.cpp +++ b/netfs/daemon/modeCheck.cpp @@ -2,12 +2,10 @@ #include <entCache.h> #include <exceptions.h> -ModeCheck::ModeCheck(const NetFS::ReqEnv & re, const std::filesystem::path & r, const EntCache<User> & u, const EntCache<Group> & g) : +ModeCheck::ModeCheck(const NetFS::ReqEnv & re, const std::filesystem::path & r, const EntCache<User> & u, + const EntCache<Group> & g) : myu(u.getEntry(re.user)->id), - myg(g.getEntry(re.grp)->id), - root(r), - userLookup(u), - groupLookup(g) + myg(g.getEntry(re.grp)->id), root(r), userLookup(u), groupLookup(g) { } @@ -64,10 +62,11 @@ ModeCheck::AssertWritePerms(const std::filesystem::path & p) const } } - struct stat +struct stat ModeCheck::lstat(const std::filesystem::path & p) { - struct stat s {}; + struct stat s { + }; if (::lstat(p.c_str(), &s) != 0) { throw NetFS::SystemError(errno); } @@ -86,11 +85,9 @@ ModeCheck::ReadableBy(const struct stat & s, uid_t u, gid_t g) const if (s.st_mode & S_IRUSR && s.st_uid == u) { return true; } - if (s.st_mode & S_IRGRP && - (s.st_gid == g - || userLookup.getEntry(u)->group == s.st_gid - || groupLookup.getEntry(s.st_gid)->hasMember(u))) - { + if (s.st_mode & S_IRGRP + && (s.st_gid == g || userLookup.getEntry(u)->group == s.st_gid + || groupLookup.getEntry(s.st_gid)->hasMember(u))) { return true; } return false; @@ -108,10 +105,9 @@ ModeCheck::WritableBy(const struct stat & s, uid_t u, gid_t g) const if (s.st_mode & S_IWUSR && s.st_uid == u) { return true; } - if (s.st_mode & S_IWGRP && - (s.st_gid == g - || userLookup.getEntry(u)->group == s.st_gid - || groupLookup.getEntry(s.st_gid)->hasMember(u))) { + if (s.st_mode & S_IWGRP + && (s.st_gid == g || userLookup.getEntry(u)->group == s.st_gid + || groupLookup.getEntry(s.st_gid)->hasMember(u))) { return true; } return false; @@ -129,12 +125,10 @@ ModeCheck::ExecutableBy(const struct stat & s, uid_t u, gid_t g) const if (s.st_mode & S_IXUSR && s.st_uid == u) { return true; } - if (s.st_mode & S_IXGRP && - (s.st_gid == g - || userLookup.getEntry(u)->group == s.st_gid - || groupLookup.getEntry(s.st_gid)->hasMember(u))) { + if (s.st_mode & S_IXGRP + && (s.st_gid == g || userLookup.getEntry(u)->group == s.st_gid + || groupLookup.getEntry(s.st_gid)->hasMember(u))) { return true; } return false; } - diff --git a/netfs/daemon/modeCheck.h b/netfs/daemon/modeCheck.h index 01e9ecb..693ad8d 100644 --- a/netfs/daemon/modeCheck.h +++ b/netfs/daemon/modeCheck.h @@ -1,35 +1,34 @@ #ifndef NETFS_DAEMON_IOHELPERS #define NETFS_DAEMON_IOHELPERS +#include <entCache.h> +#include <filesystem> #include <sys/stat.h> #include <types.h> -#include <filesystem> -#include <entCache.h> class ModeCheck { - public: - ModeCheck(const NetFS::ReqEnv & re, const std::filesystem::path &, const EntCache<User> &, const EntCache<Group> &); +public: + ModeCheck(const NetFS::ReqEnv & re, const std::filesystem::path &, const EntCache<User> &, const EntCache<Group> &); - void AssertReadParent(const std::filesystem::path &) const; - void AssertRead(const std::filesystem::path &) const; - void AssertWriteParent(const std::filesystem::path &) const; - void AssertWrite(const std::filesystem::path &) const; - void AssertWritePerms(const std::filesystem::path &) const; + void AssertReadParent(const std::filesystem::path &) const; + void AssertRead(const std::filesystem::path &) const; + void AssertWriteParent(const std::filesystem::path &) const; + void AssertWrite(const std::filesystem::path &) const; + void AssertWritePerms(const std::filesystem::path &) const; - const uid_t myu; - const gid_t myg; - const std::filesystem::path & root; + const uid_t myu; + const gid_t myg; + const std::filesystem::path & root; - [[nodiscard]] bool ReadableBy(const struct stat &, uid_t u, gid_t g) const; - [[nodiscard]] bool WritableBy(const struct stat &, uid_t u, gid_t g) const; - [[nodiscard]] bool ExecutableBy(const struct stat &, uid_t u, gid_t g) const; + [[nodiscard]] bool ReadableBy(const struct stat &, uid_t u, gid_t g) const; + [[nodiscard]] bool WritableBy(const struct stat &, uid_t u, gid_t g) const; + [[nodiscard]] bool ExecutableBy(const struct stat &, uid_t u, gid_t g) const; - private: - static struct stat lstat(const std::filesystem::path &); +private: + static struct stat lstat(const std::filesystem::path &); - const EntCache<User> & userLookup; - const EntCache<Group> & groupLookup; + const EntCache<User> & userLookup; + const EntCache<Group> & groupLookup; }; #endif - diff --git a/netfs/fuse/fuseApp.cpp b/netfs/fuse/fuseApp.cpp index 29820b8..78a3a03 100644 --- a/netfs/fuse/fuseApp.cpp +++ b/netfs/fuse/fuseApp.cpp @@ -1,16 +1,16 @@ -#include <Glacier2/Router.h> -#include <cstring> #include "fuseApp.h" -#include "lockHelpers.h" #include "cache.impl.h" -#include <entCache.h> -#include <slicer/slicer.h> -#include <uriParse.h> -#include <safeMapFind.h> -#include <compileTimeFormatter.h> #include "fuseDirs.h" #include "fuseFiles.h" +#include "lockHelpers.h" +#include <Glacier2/Router.h> #include <boost/lexical_cast.hpp> +#include <compileTimeFormatter.h> +#include <cstring> +#include <entCache.h> +#include <safeMapFind.h> +#include <slicer/slicer.h> +#include <uriParse.h> namespace AdHoc { template class Cache<struct stat, std::string>; @@ -18,10 +18,7 @@ namespace AdHoc { } NetFS::FuseApp::FuseApp(Ice::StringSeq && a) : - iceArgs(std::move(a)), - sessionOpened(false), - openHandleId(0), - converter(userLookup, groupLookup) + iceArgs(std::move(a)), sessionOpened(false), openHandleId(0), converter(userLookup, groupLookup) { } @@ -283,4 +280,3 @@ NetFS::FuseApp::reqEnv() groupLookup.getName(c->gid, &re.grp); return re; } - diff --git a/netfs/fuse/fuseApp.h b/netfs/fuse/fuseApp.h index 6869c01..d373e94 100644 --- a/netfs/fuse/fuseApp.h +++ b/netfs/fuse/fuseApp.h @@ -1,124 +1,122 @@ #ifndef NETFS_FUSE_H #define NETFS_FUSE_H -#include <shared_mutex> -#include <functional> -#include <filesystem> -#include <Ice/Ice.h> +#include "cache.h" +#include "fuseAppBase.h" +#include "fuseConfig.h" #include <Glacier2/Session.h> -#include <service.h> +#include <Ice/Ice.h> +#include <c++11Helpers.h> #include <entCache.h> +#include <filesystem> +#include <functional> +#include <service.h> +#include <shared_mutex> #include <typeConverter.h> -#include "fuseAppBase.h" -#include "fuseConfig.h" -#include "cache.h" #include <visibility.h> -#include <c++11Helpers.h> namespace NetFS { class DLL_PUBLIC FuseApp : public FuseAppBaseT<FuseApp> { - private: - class OpenDir; - using OpenDirPtr = std::shared_ptr<OpenDir>; - using OpenDirs = std::map<int, OpenDirPtr>; - - class OpenFile; - using OpenFilePtr = std::shared_ptr<OpenFile>; - using OpenFiles = std::map<int, OpenFilePtr>; - - public: - explicit FuseApp(Ice::StringSeq &&); - SPECIAL_MEMBERS_DELETE(FuseApp); - ~FuseApp() override; - - // lifecycle - void * init (struct fuse_conn_info * info, struct fuse_config * cfg) override; - static int opt_parse(void * data, const char * arg, int, struct fuse_args *); - - protected: - void connectSession(); - virtual void connectToService(); - void connectToVolume(); - void connectHandles(); - void verifyConnection(); - - public: - // misc - int access(const char * p, int a) override; - int getattr(const char *, struct stat *, struct fuse_file_info *) override; - int chmod(const char *, mode_t, struct fuse_file_info *) override; - int chown(const char *, uid_t, gid_t, struct fuse_file_info *) override; - int link(const char *, const char *) override; - int readlink(const char *, char *, size_t) override; - int rename(const char *, const char *, unsigned int) override; - int symlink(const char *, const char *) override; - int unlink(const char *) override; - // NOLINTNEXTLINE(hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - int utimens(const char *, const struct timespec tv[2], struct fuse_file_info *) override; - int mknod(const char *, mode_t, dev_t) override; - // dirs - int opendir(const char * p, struct fuse_file_info * fi) override; - int releasedir(const char *, struct fuse_file_info * fi) override; - int readdir(const char *, void * buf, fuse_fill_dir_t filler, off_t, struct fuse_file_info * fi, enum fuse_readdir_flags) override; - int mkdir(const char *, mode_t) override; - int rmdir(const char *) override; - // files - int open(const char * p, struct fuse_file_info * fi) override; - int create(const char *, mode_t, struct fuse_file_info *) override; - int flush(const char *, struct fuse_file_info * fi) override; - int release(const char *, struct fuse_file_info * fi) override; - int read(const char *, char * buf, size_t s, off_t o, struct fuse_file_info * fi) override; - int write(const char *, const char * buf, size_t s, off_t o, struct fuse_file_info * fi) override; - ssize_t copy_file_range(const char *, struct fuse_file_info *, off_t, const char *, struct fuse_file_info *, off_t, size_t, int) override; - int truncate(const char *, off_t, struct fuse_file_info *) override; - // fs - int statfs(const char *, struct statvfs *) override; - // stuff - int onError(const std::exception & err) noexcept override; - void beforeOperation() override; - - virtual struct fuse_context * fuse_get_context() = 0; - - static NetFS::Client::ResourcePtr configureFromFile(const std::filesystem::path &, const std::string &); - static NetFS::Client::ResourcePtr configureFromUri(const std::string &); - - protected: - template<typename Handle, typename ... Params> - void setProxy(uint64_t & fh, const Params & ...); - template<typename Handle> - Handle getProxy(uint64_t localID); - template<typename Handle> - void clearProxy(uint64_t localID); - template<typename Handle> - std::map<int, Handle> & getMap(); - - template<typename Rtn, typename F> static inline Rtn - waitOnWriteRangeAndThen(size_t s, off_t o, const OpenFilePtr & of, const F & f); - - ReqEnv reqEnv(); - - Ice::StringSeq iceArgs; - Ice::CommunicatorPtr ic; - Client::ResourcePtr fcr; - mutable std::shared_mutex _proxymaplock; - - NetFS::VolumePrxPtr volume; - NetFS::ServicePrxPtr service; - Glacier2::SessionPrxPtr session; - bool sessionOpened; - - std::string mountPoint; - - OpenDirs openDirs; - OpenFiles openFiles; - int openHandleId; - - EntCache<User> userLookup; - EntCache<Group> groupLookup; - EntryTypeConverter converter; - - using StatCache = AdHoc::Cache<struct stat, std::string>; - StatCache statCache; + private: + class OpenDir; + using OpenDirPtr = std::shared_ptr<OpenDir>; + using OpenDirs = std::map<int, OpenDirPtr>; + + class OpenFile; + using OpenFilePtr = std::shared_ptr<OpenFile>; + using OpenFiles = std::map<int, OpenFilePtr>; + + public: + explicit FuseApp(Ice::StringSeq &&); + SPECIAL_MEMBERS_DELETE(FuseApp); + ~FuseApp() override; + + // lifecycle + void * init(struct fuse_conn_info * info, struct fuse_config * cfg) override; + static int opt_parse(void * data, const char * arg, int, struct fuse_args *); + + protected: + void connectSession(); + virtual void connectToService(); + void connectToVolume(); + void connectHandles(); + void verifyConnection(); + + public: + // misc + int access(const char * p, int a) override; + int getattr(const char *, struct stat *, struct fuse_file_info *) override; + int chmod(const char *, mode_t, struct fuse_file_info *) override; + int chown(const char *, uid_t, gid_t, struct fuse_file_info *) override; + int link(const char *, const char *) override; + int readlink(const char *, char *, size_t) override; + int rename(const char *, const char *, unsigned int) override; + int symlink(const char *, const char *) override; + int unlink(const char *) override; + // NOLINTNEXTLINE(hicpp-avoid-c-arrays,modernize-avoid-c-arrays) + int utimens(const char *, const struct timespec tv[2], struct fuse_file_info *) override; + int mknod(const char *, mode_t, dev_t) override; + // dirs + int opendir(const char * p, struct fuse_file_info * fi) override; + int releasedir(const char *, struct fuse_file_info * fi) override; + int readdir(const char *, void * buf, fuse_fill_dir_t filler, off_t, struct fuse_file_info * fi, + enum fuse_readdir_flags) override; + int mkdir(const char *, mode_t) override; + int rmdir(const char *) override; + // files + int open(const char * p, struct fuse_file_info * fi) override; + int create(const char *, mode_t, struct fuse_file_info *) override; + int flush(const char *, struct fuse_file_info * fi) override; + int release(const char *, struct fuse_file_info * fi) override; + int read(const char *, char * buf, size_t s, off_t o, struct fuse_file_info * fi) override; + int write(const char *, const char * buf, size_t s, off_t o, struct fuse_file_info * fi) override; + ssize_t copy_file_range(const char *, struct fuse_file_info *, off_t, const char *, struct fuse_file_info *, + off_t, size_t, int) override; + int truncate(const char *, off_t, struct fuse_file_info *) override; + // fs + int statfs(const char *, struct statvfs *) override; + // stuff + int onError(const std::exception & err) noexcept override; + void beforeOperation() override; + + virtual struct fuse_context * fuse_get_context() = 0; + + static NetFS::Client::ResourcePtr configureFromFile(const std::filesystem::path &, const std::string &); + static NetFS::Client::ResourcePtr configureFromUri(const std::string &); + + protected: + template<typename Handle, typename... Params> void setProxy(uint64_t & fh, const Params &...); + template<typename Handle> Handle getProxy(uint64_t localID); + template<typename Handle> void clearProxy(uint64_t localID); + template<typename Handle> std::map<int, Handle> & getMap(); + + template<typename Rtn, typename F> + static inline Rtn waitOnWriteRangeAndThen(size_t s, off_t o, const OpenFilePtr & of, const F & f); + + ReqEnv reqEnv(); + + Ice::StringSeq iceArgs; + Ice::CommunicatorPtr ic; + Client::ResourcePtr fcr; + mutable std::shared_mutex _proxymaplock; + + NetFS::VolumePrxPtr volume; + NetFS::ServicePrxPtr service; + Glacier2::SessionPrxPtr session; + bool sessionOpened; + + std::string mountPoint; + + OpenDirs openDirs; + OpenFiles openFiles; + int openHandleId; + + EntCache<User> userLookup; + EntCache<Group> groupLookup; + EntryTypeConverter converter; + + using StatCache = AdHoc::Cache<struct stat, std::string>; + StatCache statCache; }; } diff --git a/netfs/fuse/fuseApp.impl.h b/netfs/fuse/fuseApp.impl.h index 8dd9f1e..e433ee7 100644 --- a/netfs/fuse/fuseApp.impl.h +++ b/netfs/fuse/fuseApp.impl.h @@ -6,13 +6,14 @@ #include <safeMapFind.h> namespace NetFS { - template<typename Handle, typename ... Params> + template<typename Handle, typename... Params> void - FuseApp::setProxy(uint64_t & fh, const Params & ... params) + FuseApp::setProxy(uint64_t & fh, const Params &... params) { auto & map = getMap<Handle>(); Lock(_proxymaplock); - while (map.find(fh = ++openHandleId) != map.end()) ; + while (map.find(fh = ++openHandleId) != map.end()) + ; map.emplace(fh, std::make_shared<typename Handle::element_type>(params...)); } @@ -40,4 +41,3 @@ namespace NetFS { } #endif - diff --git a/netfs/fuse/fuseAppBase.cpp b/netfs/fuse/fuseAppBase.cpp index 4d06b44..f2c1f30 100644 --- a/netfs/fuse/fuseAppBase.cpp +++ b/netfs/fuse/fuseAppBase.cpp @@ -1,11 +1,11 @@ #include "fuseAppBase.h" -#include <cerrno> +#include <boost/assert.hpp> #include <cassert> +#include <cerrno> #include <cstdio> -#include <unistd.h> #include <cstdlib> #include <typeinfo> -#include <boost/assert.hpp> +#include <unistd.h> FuseAppBase * FuseAppBase::fuseApp; @@ -27,177 +27,221 @@ FuseAppBase::~FuseAppBase() // to call them in a realistic manner. They exist only as the default // implementation of the function which is never passed to libfuse // unless it is overridden. -void * FuseAppBase::init(fuse_conn_info*, fuse_config *) +void * +FuseAppBase::init(fuse_conn_info *, fuse_config *) { return nullptr; } -int FuseAppBase::access(const char *, int) +int +FuseAppBase::access(const char *, int) { return -ENOSYS; } -int FuseAppBase::chmod(const char *, mode_t, struct fuse_file_info *) +int +FuseAppBase::chmod(const char *, mode_t, struct fuse_file_info *) { return -ENOSYS; } -int FuseAppBase::chown(const char *, uid_t, gid_t, struct fuse_file_info *) +int +FuseAppBase::chown(const char *, uid_t, gid_t, struct fuse_file_info *) { return -ENOSYS; } -int FuseAppBase::create(const char *, mode_t, struct fuse_file_info *) +int +FuseAppBase::create(const char *, mode_t, struct fuse_file_info *) { return -ENOSYS; } -int FuseAppBase::getattr(const char *, struct stat *, struct fuse_file_info *) +int +FuseAppBase::getattr(const char *, struct stat *, struct fuse_file_info *) { return -ENOSYS; } -int FuseAppBase::flush(const char *, struct fuse_file_info *) +int +FuseAppBase::flush(const char *, struct fuse_file_info *) { return -ENOSYS; } -int FuseAppBase::fsync(const char *, int, struct fuse_file_info *) +int +FuseAppBase::fsync(const char *, int, struct fuse_file_info *) { return -ENOSYS; } -int FuseAppBase::fsyncdir(const char *, int, struct fuse_file_info *) +int +FuseAppBase::fsyncdir(const char *, int, struct fuse_file_info *) { return -ENOSYS; } -int FuseAppBase::truncate(const char *, off_t, struct fuse_file_info *) +int +FuseAppBase::truncate(const char *, off_t, struct fuse_file_info *) { return -ENOSYS; } -int FuseAppBase::getxattr(const char *, const char *, char *, size_t) +int +FuseAppBase::getxattr(const char *, const char *, char *, size_t) { return -ENOSYS; } -int FuseAppBase::link(const char *, const char *) +int +FuseAppBase::link(const char *, const char *) { return -ENOSYS; } -int FuseAppBase::listxattr(const char *, char *, size_t) +int +FuseAppBase::listxattr(const char *, char *, size_t) { return -ENOSYS; } -int FuseAppBase::mkdir(const char *, mode_t) +int +FuseAppBase::mkdir(const char *, mode_t) { return -ENOSYS; } -int FuseAppBase::mknod(const char *, mode_t, dev_t) +int +FuseAppBase::mknod(const char *, mode_t, dev_t) { return -ENOSYS; } -int FuseAppBase::open(const char *, struct fuse_file_info *) +int +FuseAppBase::open(const char *, struct fuse_file_info *) { return -ENOSYS; } -int FuseAppBase::opendir(const char *, struct fuse_file_info *) +int +FuseAppBase::opendir(const char *, struct fuse_file_info *) { return -ENOSYS; } -int FuseAppBase::read(const char *, char *, size_t, off_t, struct fuse_file_info *) +int +FuseAppBase::read(const char *, char *, size_t, off_t, struct fuse_file_info *) { return -ENOSYS; } -int FuseAppBase::readdir(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *, enum fuse_readdir_flags) +int +FuseAppBase::readdir(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *, enum fuse_readdir_flags) { return -ENOSYS; } -int FuseAppBase::readlink(const char *, char *, size_t) +int +FuseAppBase::readlink(const char *, char *, size_t) { return -ENOSYS; } -int FuseAppBase::release(const char *, struct fuse_file_info *) +int +FuseAppBase::release(const char *, struct fuse_file_info *) { return -ENOSYS; } -int FuseAppBase::releasedir(const char *, struct fuse_file_info *) +int +FuseAppBase::releasedir(const char *, struct fuse_file_info *) { return -ENOSYS; } -int FuseAppBase::removexattr(const char *, const char *) +int +FuseAppBase::removexattr(const char *, const char *) { return -ENOSYS; } -int FuseAppBase::rename(const char *, const char *, unsigned int) +int +FuseAppBase::rename(const char *, const char *, unsigned int) { return -ENOSYS; } -int FuseAppBase::rmdir(const char *) +int +FuseAppBase::rmdir(const char *) { return -ENOSYS; } -int FuseAppBase::setxattr(const char *, const char *, const char *, size_t, int) +int +FuseAppBase::setxattr(const char *, const char *, const char *, size_t, int) { return -ENOSYS; } -int FuseAppBase::statfs(const char *, struct statvfs *) +int +FuseAppBase::statfs(const char *, struct statvfs *) { return -ENOSYS; } -int FuseAppBase::symlink(const char *, const char *) +int +FuseAppBase::symlink(const char *, const char *) { return -ENOSYS; } -int FuseAppBase::unlink(const char *) +int +FuseAppBase::unlink(const char *) { return -ENOSYS; } -int FuseAppBase::write(const char *, const char *, size_t, off_t, struct fuse_file_info *) +int +FuseAppBase::write(const char *, const char *, size_t, off_t, struct fuse_file_info *) { return -ENOSYS; } -int FuseAppBase::lock(const char *, struct fuse_file_info *, int, struct flock *) +int +FuseAppBase::lock(const char *, struct fuse_file_info *, int, struct flock *) { return -ENOSYS; } // NOLINTNEXTLINE(modernize-avoid-c-arrays, hicpp-avoid-c-arrays) -int FuseAppBase::utimens(const char *, const struct timespec[2], struct fuse_file_info *) +int +FuseAppBase::utimens(const char *, const struct timespec[2], struct fuse_file_info *) { return -ENOSYS; } -int FuseAppBase::bmap(const char *, size_t, uint64_t *) +int +FuseAppBase::bmap(const char *, size_t, uint64_t *) { return -ENOSYS; } -int FuseAppBase::ioctl(const char *, unsigned int, void *, struct fuse_file_info *, unsigned int, void *) +int +FuseAppBase::ioctl(const char *, unsigned int, void *, struct fuse_file_info *, unsigned int, void *) { return -ENOSYS; } -int FuseAppBase::poll(const char *, struct fuse_file_info *, struct fuse_pollhandle *, unsigned *) +int +FuseAppBase::poll(const char *, struct fuse_file_info *, struct fuse_pollhandle *, unsigned *) { return -ENOSYS; } -int FuseAppBase::write_buf(const char *, struct fuse_bufvec *, off_t, struct fuse_file_info *) +int +FuseAppBase::write_buf(const char *, struct fuse_bufvec *, off_t, struct fuse_file_info *) { return -ENOSYS; } -int FuseAppBase::read_buf(const char *, struct fuse_bufvec **, size_t, off_t, struct fuse_file_info *) +int +FuseAppBase::read_buf(const char *, struct fuse_bufvec **, size_t, off_t, struct fuse_file_info *) { return -ENOSYS; } -int FuseAppBase::flock(const char *, struct fuse_file_info *, int) +int +FuseAppBase::flock(const char *, struct fuse_file_info *, int) { return -ENOSYS; } -int FuseAppBase::fallocate(const char *, int, off_t, off_t, struct fuse_file_info *) +int +FuseAppBase::fallocate(const char *, int, off_t, off_t, struct fuse_file_info *) { return -ENOSYS; } -ssize_t FuseAppBase::copy_file_range(const char *, struct fuse_file_info *, off_t, const char *, struct fuse_file_info *, off_t, size_t, int) +ssize_t +FuseAppBase::copy_file_range( + const char *, struct fuse_file_info *, off_t, const char *, struct fuse_file_info *, off_t, size_t, int) { return -ENOSYS; } -off_t FuseAppBase::lseek(const char *, off_t, int, struct fuse_file_info *) +off_t +FuseAppBase::lseek(const char *, off_t, int, struct fuse_file_info *) { return -ENOSYS; } // LCOV_EXCL_STOP -void FuseAppBase::log(int level, const char * message) const noexcept +void +FuseAppBase::log(int level, const char * message) const noexcept { logf(level, "%s", message); } -void FuseAppBase::logf(int level, const char * fmt, ...) const noexcept +void +FuseAppBase::logf(int level, const char * fmt, ...) const noexcept { va_list args; va_start(args, fmt); @@ -205,13 +249,14 @@ void FuseAppBase::logf(int level, const char * fmt, ...) const noexcept va_end(args); } -int FuseAppBase::onError(const std::exception & e) noexcept +int +FuseAppBase::onError(const std::exception & e) noexcept { logf(LOG_ERR, "Unknown exception (what: %s)", e.what()); return -ENOSYS; } -void FuseAppBase::beforeOperation() +void +FuseAppBase::beforeOperation() { } - diff --git a/netfs/fuse/fuseAppBase.h b/netfs/fuse/fuseAppBase.h index 2709671..44f3c81 100644 --- a/netfs/fuse/fuseAppBase.h +++ b/netfs/fuse/fuseAppBase.h @@ -1,82 +1,89 @@ #ifndef FUSEAPP_H #define FUSEAPP_H -#include <fuse.h> -#include <typeinfo> -#include <exception> -#include <cstdio> +#include <c++11Helpers.h> #include <cerrno> +#include <cstdio> +#include <exception> +#include <fuse.h> +#include <lockHelpers.h> +#include <shared_mutex> #include <syslog.h> +#include <typeinfo> #include <visibility.h> -#include <c++11Helpers.h> -#include <shared_mutex> -#include <lockHelpers.h> class DLL_PUBLIC FuseAppBase { - public: - FuseAppBase(); - SPECIAL_MEMBERS_DELETE(FuseAppBase); - virtual ~FuseAppBase(); +public: + FuseAppBase(); + SPECIAL_MEMBERS_DELETE(FuseAppBase); + virtual ~FuseAppBase(); - virtual void * init (struct fuse_conn_info * info, struct fuse_config * cfg); - virtual int access(const char *, int); - virtual int chmod(const char *, mode_t, struct fuse_file_info *); - virtual int chown(const char *, uid_t, gid_t, struct fuse_file_info *); - virtual int create(const char *, mode_t, struct fuse_file_info *); - virtual int getattr(const char *, struct stat *, struct fuse_file_info *); - virtual int flush(const char *, struct fuse_file_info *); - virtual int fsync(const char *, int, struct fuse_file_info *); - virtual int fsyncdir(const char *, int, struct fuse_file_info *); - virtual int truncate(const char *, off_t, struct fuse_file_info *); - virtual int getxattr(const char *, const char *, char *, size_t); - virtual int link(const char *, const char *); - virtual int listxattr(const char *, char *, size_t); - virtual int mkdir(const char *, mode_t); - virtual int mknod(const char *, mode_t, dev_t); - virtual int open(const char *, struct fuse_file_info *); - virtual int opendir(const char *, struct fuse_file_info *); - virtual int read(const char *, char *, size_t, off_t, struct fuse_file_info *); - virtual int readdir(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *, enum fuse_readdir_flags); - virtual int readlink(const char *, char *, size_t); - virtual int release(const char *, struct fuse_file_info *); - virtual int releasedir(const char *, struct fuse_file_info *); - virtual int removexattr(const char *, const char *); - virtual int rename(const char *, const char *, unsigned int); - virtual int rmdir(const char *); - virtual int setxattr(const char *, const char *, const char *, size_t, int); - virtual int statfs(const char *, struct statvfs *); - virtual int symlink(const char *, const char *); - virtual int unlink(const char *); - virtual int write(const char *, const char *, size_t, off_t, struct fuse_file_info *); - virtual int lock(const char *, struct fuse_file_info *, int cmd, struct flock *); - // NOLINTNEXTLINE(hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - virtual int utimens(const char *, const struct timespec tv[2], struct fuse_file_info *); - virtual int bmap(const char *, size_t blocksize, uint64_t *idx); - virtual int ioctl(const char *, unsigned int cmd, void *arg, struct fuse_file_info *, unsigned int flags, void * data); - virtual int poll(const char *, struct fuse_file_info *, struct fuse_pollhandle *, unsigned *); - virtual int write_buf(const char *, struct fuse_bufvec *buf, off_t off, struct fuse_file_info *); - virtual int read_buf(const char *, struct fuse_bufvec **bufp, size_t size, off_t off, struct fuse_file_info *); - virtual int flock(const char *, struct fuse_file_info *, int op); - virtual int fallocate(const char *, int, off_t, off_t, struct fuse_file_info *); - virtual ssize_t copy_file_range(const char *, struct fuse_file_info *, off_t, const char *, struct fuse_file_info *, off_t, size_t, int); - virtual off_t lseek(const char *, off_t off, int whence, struct fuse_file_info *); - virtual int onError(const std::exception & err) noexcept; - virtual void beforeOperation(); - void log(int level, const char * message) const noexcept; - void logf(int level, const char * fmt, ...) const noexcept __attribute__ ((__format__ (__printf__, 3, 4))); - virtual void vlogf(int level, const char * fmt, va_list) const noexcept __attribute__ ((__format__ (__printf__, 3, 0))) = 0; + virtual void * init(struct fuse_conn_info * info, struct fuse_config * cfg); + virtual int access(const char *, int); + virtual int chmod(const char *, mode_t, struct fuse_file_info *); + virtual int chown(const char *, uid_t, gid_t, struct fuse_file_info *); + virtual int create(const char *, mode_t, struct fuse_file_info *); + virtual int getattr(const char *, struct stat *, struct fuse_file_info *); + virtual int flush(const char *, struct fuse_file_info *); + virtual int fsync(const char *, int, struct fuse_file_info *); + virtual int fsyncdir(const char *, int, struct fuse_file_info *); + virtual int truncate(const char *, off_t, struct fuse_file_info *); + virtual int getxattr(const char *, const char *, char *, size_t); + virtual int link(const char *, const char *); + virtual int listxattr(const char *, char *, size_t); + virtual int mkdir(const char *, mode_t); + virtual int mknod(const char *, mode_t, dev_t); + virtual int open(const char *, struct fuse_file_info *); + virtual int opendir(const char *, struct fuse_file_info *); + virtual int read(const char *, char *, size_t, off_t, struct fuse_file_info *); + virtual int readdir(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *, enum fuse_readdir_flags); + virtual int readlink(const char *, char *, size_t); + virtual int release(const char *, struct fuse_file_info *); + virtual int releasedir(const char *, struct fuse_file_info *); + virtual int removexattr(const char *, const char *); + virtual int rename(const char *, const char *, unsigned int); + virtual int rmdir(const char *); + virtual int setxattr(const char *, const char *, const char *, size_t, int); + virtual int statfs(const char *, struct statvfs *); + virtual int symlink(const char *, const char *); + virtual int unlink(const char *); + virtual int write(const char *, const char *, size_t, off_t, struct fuse_file_info *); + virtual int lock(const char *, struct fuse_file_info *, int cmd, struct flock *); + // NOLINTNEXTLINE(hicpp-avoid-c-arrays,modernize-avoid-c-arrays) + virtual int utimens(const char *, const struct timespec tv[2], struct fuse_file_info *); + virtual int bmap(const char *, size_t blocksize, uint64_t * idx); + virtual int ioctl( + const char *, unsigned int cmd, void * arg, struct fuse_file_info *, unsigned int flags, void * data); + virtual int poll(const char *, struct fuse_file_info *, struct fuse_pollhandle *, unsigned *); + virtual int write_buf(const char *, struct fuse_bufvec * buf, off_t off, struct fuse_file_info *); + virtual int read_buf(const char *, struct fuse_bufvec ** bufp, size_t size, off_t off, struct fuse_file_info *); + virtual int flock(const char *, struct fuse_file_info *, int op); + virtual int fallocate(const char *, int, off_t, off_t, struct fuse_file_info *); + virtual ssize_t copy_file_range( + const char *, struct fuse_file_info *, off_t, const char *, struct fuse_file_info *, off_t, size_t, int); + virtual off_t lseek(const char *, off_t off, int whence, struct fuse_file_info *); + virtual int onError(const std::exception & err) noexcept; + virtual void beforeOperation(); + void log(int level, const char * message) const noexcept; + void logf(int level, const char * fmt, ...) const noexcept __attribute__((__format__(__printf__, 3, 4))); + virtual void vlogf(int level, const char * fmt, va_list) const noexcept + __attribute__((__format__(__printf__, 3, 0))) + = 0; - mutable std::shared_mutex _lock; - protected: - static FuseAppBase * fuseApp; + mutable std::shared_mutex _lock; + +protected: + static FuseAppBase * fuseApp; }; -template <typename FuseApp> -class FuseAppBaseT : public FuseAppBase { - public: -#define GetIntHelper(func) getInternalHelper<decltype(&FuseAppBase::func), decltype(&FuseApp::func), &FuseAppBase::func>(&FuseAppBase::func) -#define GetHelper(func) getHelper<decltype(&FuseAppBase::func), decltype(&FuseApp::func), &FuseAppBase::func>(&FuseAppBase::func) - FuseAppBaseT() : operations({ +template<typename FuseApp> class FuseAppBaseT : public FuseAppBase { +public: +#define GetIntHelper(func) \ + getInternalHelper<decltype(&FuseAppBase::func), decltype(&FuseApp::func), &FuseAppBase::func>(&FuseAppBase::func) +#define GetHelper(func) \ + getHelper<decltype(&FuseAppBase::func), decltype(&FuseApp::func), &FuseAppBase::func>(&FuseAppBase::func) + FuseAppBaseT() : + operations({ GetHelper(getattr), GetHelper(readlink), GetHelper(mknod), @@ -105,7 +112,7 @@ class FuseAppBaseT : public FuseAppBase { GetHelper(releasedir), GetHelper(fsyncdir), GetIntHelper(init), - nullptr, //fuseDestroy + nullptr, // fuseDestroy GetHelper(access), GetHelper(create), GetHelper(lock), @@ -119,64 +126,65 @@ class FuseAppBaseT : public FuseAppBase { GetHelper(fallocate), GetHelper(copy_file_range), GetHelper(lseek), - }) - { - } + }) + { + } #undef GetHelper #undef GetIntHelper - const struct fuse_operations operations; + const struct fuse_operations operations; - private: - template <typename BFunc, typename IFunc, BFunc bfunc, typename Rtn, typename ... Args> - constexpr static auto getInternalHelper(Rtn(FuseAppBase::*)(Args...)) -> Rtn(*)(Args...) - { - if constexpr (!std::is_same<BFunc, IFunc>::value) { - return [](Args ... a) { - return (fuseApp->*bfunc)(a...); - }; - } - return nullptr; +private: + template<typename BFunc, typename IFunc, BFunc bfunc, typename Rtn, typename... Args> + constexpr static auto getInternalHelper(Rtn (FuseAppBase::*)(Args...)) -> Rtn (*)(Args...) + { + if constexpr (!std::is_same<BFunc, IFunc>::value) { + return [](Args... a) { + return (fuseApp->*bfunc)(a...); + }; } - template <typename BFunc, typename IFunc, BFunc bfunc, typename Rtn, typename ... Args> - constexpr static auto getHelper(Rtn(FuseAppBase::*)(Args...)) -> Rtn(*)(Args...) - { - if constexpr (!std::is_same<BFunc, IFunc>::value) { - return [](Args ... a) -> Rtn { - for (int t = 0; ; ++t) { - try { - fuseApp->beforeOperation(); - SharedLock(fuseApp->_lock); - return (fuseApp->*bfunc)(a...); - } - catch (const std::exception & ex) { - if (t < 10) { - if (int rtn = fuseApp->onError(ex)) { - return rtn; - } - } - else { - fuseApp->logf(LOG_ERR, "Retries expired with %s calling %s", ex.what(), typeid(bfunc).name()); - return -EIO; + return nullptr; + } + template<typename BFunc, typename IFunc, BFunc bfunc, typename Rtn, typename... Args> + constexpr static auto getHelper(Rtn (FuseAppBase::*)(Args...)) -> Rtn (*)(Args...) + { + if constexpr (!std::is_same<BFunc, IFunc>::value) { + return [](Args... a) -> Rtn { + for (int t = 0;; ++t) { + try { + fuseApp->beforeOperation(); + SharedLock(fuseApp->_lock); + return (fuseApp->*bfunc)(a...); + } + catch (const std::exception & ex) { + if (t < 10) { + if (int rtn = fuseApp->onError(ex)) { + return rtn; } } - catch (...) { - fuseApp->logf(LOG_ERR, "Unknown exception calling %s", typeid(bfunc).name()); + else { + fuseApp->logf( + LOG_ERR, "Retries expired with %s calling %s", ex.what(), typeid(bfunc).name()); return -EIO; } } - }; - } - return nullptr; + catch (...) { + fuseApp->logf(LOG_ERR, "Unknown exception calling %s", typeid(bfunc).name()); + return -EIO; + } + } + }; } + return nullptr; + } - protected: - template <typename Func, Func f, typename ... Args> - static int internalHelper(Args ... a) - { - return (fuseApp->*f)(a...); - } +protected: + template<typename Func, Func f, typename... Args> + static int + internalHelper(Args... a) + { + return (fuseApp->*f)(a...); + } }; #endif - diff --git a/netfs/fuse/fuseConfigImpl.cpp b/netfs/fuse/fuseConfigImpl.cpp index 9129bfc..fa542fe 100644 --- a/netfs/fuse/fuseConfigImpl.cpp +++ b/netfs/fuse/fuseConfigImpl.cpp @@ -1,5 +1,5 @@ -#include <fuseConfig.h> #include <compileTimeFormatter.h> +#include <fuseConfig.h> AdHocFormatter(ResourceNotFoundMsg, "No such resource: %?"); void @@ -7,4 +7,3 @@ NetFS::Client::ResourceNotFound::ice_print(std::ostream & s) const { ResourceNotFoundMsg::write(s, resourceName); } - diff --git a/netfs/fuse/fuseDirs.cpp b/netfs/fuse/fuseDirs.cpp index a1748d8..c1a91bd 100644 --- a/netfs/fuse/fuseDirs.cpp +++ b/netfs/fuse/fuseDirs.cpp @@ -1,98 +1,94 @@ #include "fuseDirs.h" -#include <lockHelpers.h> #include <entCache.h> +#include <lockHelpers.h> namespace NetFS { -FuseApp::OpenDir::OpenDir(DirectoryPrxPtr r, std::string p) : - remote(std::move(r)), - path(std::move(p)) -{ -} + FuseApp::OpenDir::OpenDir(DirectoryPrxPtr r, std::string p) : remote(std::move(r)), path(std::move(p)) { } -template<> -std::map<int, FuseApp::OpenDirPtr> & -FuseApp::getMap<FuseApp::OpenDirPtr>() -{ - return openDirs; -} - -int -FuseApp::opendir(const char * p, struct fuse_file_info * fi) -{ - try { - auto remote = volume->opendir(reqEnv(), p); - setProxy<OpenDirPtr>(fi->fh, remote, p); - return 0; - } - catch (SystemError & e) { - return -e.syserrno; + template<> + std::map<int, FuseApp::OpenDirPtr> & + FuseApp::getMap<FuseApp::OpenDirPtr>() + { + return openDirs; } -} -int -FuseApp::releasedir(const char *, struct fuse_file_info * fi) -{ - try { - auto remote = getProxy<OpenDirPtr>(fi->fh)->remote; - remote->close(); - clearProxy<OpenDirPtr>(fi->fh); - return 0; + int + FuseApp::opendir(const char * p, struct fuse_file_info * fi) + { + try { + auto remote = volume->opendir(reqEnv(), p); + setProxy<OpenDirPtr>(fi->fh, remote, p); + return 0; + } + catch (SystemError & e) { + return -e.syserrno; + } } - catch (SystemError & e) { - clearProxy<OpenDirPtr>(fi->fh); - return -e.syserrno; + + int + FuseApp::releasedir(const char *, struct fuse_file_info * fi) + { + try { + auto remote = getProxy<OpenDirPtr>(fi->fh)->remote; + remote->close(); + clearProxy<OpenDirPtr>(fi->fh); + return 0; + } + catch (SystemError & e) { + clearProxy<OpenDirPtr>(fi->fh); + return -e.syserrno; + } } -} -int -FuseApp::readdir(const char * p, void * buf, fuse_fill_dir_t filler, off_t, struct fuse_file_info * fi, enum fuse_readdir_flags flags) -{ - try { - auto od = getProxy<OpenDirPtr>(fi->fh); - std::string path(p); - auto expiry = time(nullptr) + 2; - if (flags == FUSE_READDIR_PLUS) { - for (const auto & e : od->remote->listdir()) { - filler(buf, e.first.c_str(), nullptr, 0, FUSE_FILL_DIR_PLUS); - std::string k(path + e.first); - statCache.remove(k); - statCache.add(k, converter.convert(e.second), expiry); + int + FuseApp::readdir(const char * p, void * buf, fuse_fill_dir_t filler, off_t, struct fuse_file_info * fi, + enum fuse_readdir_flags flags) + { + try { + auto od = getProxy<OpenDirPtr>(fi->fh); + std::string path(p); + auto expiry = time(nullptr) + 2; + if (flags == FUSE_READDIR_PLUS) { + for (const auto & e : od->remote->listdir()) { + filler(buf, e.first.c_str(), nullptr, 0, FUSE_FILL_DIR_PLUS); + std::string k(path + e.first); + statCache.remove(k); + statCache.add(k, converter.convert(e.second), expiry); + } } - } - else { - for (const auto & e : od->remote->readdir()) { - filler(buf, e.c_str(), nullptr, 0, (fuse_fill_dir_flags)0); + else { + for (const auto & e : od->remote->readdir()) { + filler(buf, e.c_str(), nullptr, 0, (fuse_fill_dir_flags)0); + } } + return 0; + } + catch (SystemError & e) { + return -e.syserrno; } - return 0; - } - catch (SystemError & e) { - return -e.syserrno; } -} -int -FuseApp::mkdir(const char * p, mode_t m) -{ - try { - volume->mkdir(reqEnv(), p, m); - return 0; - } - catch (SystemError & e) { - return -e.syserrno; + int + FuseApp::mkdir(const char * p, mode_t m) + { + try { + volume->mkdir(reqEnv(), p, m); + return 0; + } + catch (SystemError & e) { + return -e.syserrno; + } } -} -int -FuseApp::rmdir(const char * p) -{ - try { - volume->rmdir(reqEnv(), p); - return 0; - } - catch (SystemError & e) { - return -e.syserrno; + int + FuseApp::rmdir(const char * p) + { + try { + volume->rmdir(reqEnv(), p); + return 0; + } + catch (SystemError & e) { + return -e.syserrno; + } } } -} - diff --git a/netfs/fuse/fuseDirs.h b/netfs/fuse/fuseDirs.h index 55088dd..bb02e65 100644 --- a/netfs/fuse/fuseDirs.h +++ b/netfs/fuse/fuseDirs.h @@ -5,13 +5,12 @@ namespace NetFS { class FuseApp::OpenDir { - public: - OpenDir(DirectoryPrxPtr remote, std::string path); + public: + OpenDir(DirectoryPrxPtr remote, std::string path); - DirectoryPrxPtr remote; - const std::string path; + DirectoryPrxPtr remote; + const std::string path; }; } #endif - diff --git a/netfs/fuse/fuseFiles.cpp b/netfs/fuse/fuseFiles.cpp index 48b3f87..0a59252 100644 --- a/netfs/fuse/fuseFiles.cpp +++ b/netfs/fuse/fuseFiles.cpp @@ -1,282 +1,277 @@ -#include <cstring> -#include "fuseApp.impl.h" #include "fuseFiles.h" +#include "fuseApp.impl.h" #include "lockHelpers.h" +#include <cstring> #include <entCache.h> #include <mutex> namespace NetFS { -FuseApp::OpenFile::WriteState::WriteState() : - future(promise.get_future().share()) -{ -} - -FuseApp::OpenFile::OpenFile(FilePrxPtr r, std::string p, int f) : - remote(std::move(r)), - path(std::move(p)), - flags(f) -{ -} - -template<> -std::map<int, FuseApp::OpenFilePtr> & -FuseApp::getMap<FuseApp::OpenFilePtr>() -{ - return openFiles; -} + FuseApp::OpenFile::WriteState::WriteState() : future(promise.get_future().share()) { } -void -FuseApp::OpenFile::wait() const -{ - auto cbg = [this](){ - SharedLock(_lock); - return bg; - }(); - for (const auto & w : cbg) { - w.second->future.wait(); + FuseApp::OpenFile::OpenFile(FilePrxPtr r, std::string p, int f) : remote(std::move(r)), path(std::move(p)), flags(f) + { } -} -void -FuseApp::OpenFile::flush() -{ - auto first = [this]() { - SharedLock(_lock); - return bg.empty() ? nullptr : bg.begin()->second; - }; - while (auto w = first()) { - // background operations are void, so no need to actually get the return value - w->future.wait(); + template<> + std::map<int, FuseApp::OpenFilePtr> & + FuseApp::getMap<FuseApp::OpenFilePtr>() + { + return openFiles; } -} -FuseApp::OpenFile::BGs::interval_type -FuseApp::OpenFile::range(off_t o, size_t s) -{ - return OpenFile::BGs::interval_type::right_open(o, o + s); -} - -int -FuseApp::open(const char * p, struct fuse_file_info * fi) -{ - try { - auto remote = volume->open(reqEnv(), p, fi->flags); - setProxy<OpenFilePtr>(fi->fh, remote, p, fi->flags); - return 0; - } - catch (SystemError & e) { - return -e.syserrno; + void + FuseApp::OpenFile::wait() const + { + auto cbg = [this]() { + SharedLock(_lock); + return bg; + }(); + for (const auto & w : cbg) { + w.second->future.wait(); + } } -} -int -FuseApp::create(const char * p, mode_t m, struct fuse_file_info * fi) -{ - try { - auto remote = volume->create(reqEnv(), p, fi->flags, m); - setProxy<OpenFilePtr>(fi->fh, remote, p, fi->flags); - return 0; + void + FuseApp::OpenFile::flush() + { + auto first = [this]() { + SharedLock(_lock); + return bg.empty() ? nullptr : bg.begin()->second; + }; + while (auto w = first()) { + // background operations are void, so no need to actually get the return value + w->future.wait(); + } } - catch (SystemError & e) { - return -e.syserrno; + + FuseApp::OpenFile::BGs::interval_type + FuseApp::OpenFile::range(off_t o, size_t s) + { + return OpenFile::BGs::interval_type::right_open(o, o + s); } -} -int -FuseApp::release(const char *, struct fuse_file_info * fi) -{ - try { - auto of = getProxy<OpenFilePtr>(fi->fh); - auto remote = of->remote; + int + FuseApp::open(const char * p, struct fuse_file_info * fi) + { try { - of->flush(); + auto remote = volume->open(reqEnv(), p, fi->flags); + setProxy<OpenFilePtr>(fi->fh, remote, p, fi->flags); + return 0; } catch (SystemError & e) { + return -e.syserrno; } - remote->close(); - clearProxy<OpenFilePtr>(fi->fh); - return 0; - } - catch (SystemError & e) { - clearProxy<OpenFilePtr>(fi->fh); - return -e.syserrno; - } -} - -int -FuseApp::flush(const char *, struct fuse_file_info * fi) -{ - try { - getProxy<OpenFilePtr>(fi->fh)->flush(); - return 0; - } - catch (SystemError & e) { - return -e.syserrno; } -} -template<typename Rtn, typename F> -inline -Rtn -FuseApp::waitOnWriteRangeAndThen(size_t s, off_t o, const OpenFilePtr & of, const F & f) -{ - const auto key = OpenFile::range(o, s); - while (true) { - std::unique_lock<decltype(of->_lock)> _l(of->_lock); - // Acquire operations to wait for - auto R = of->bg.equal_range(key); - if (R.first == R.second) { - // Perform operation - return f(key); + int + FuseApp::create(const char * p, mode_t m, struct fuse_file_info * fi) + { + try { + auto remote = volume->create(reqEnv(), p, fi->flags, m); + setProxy<OpenFilePtr>(fi->fh, remote, p, fi->flags); + return 0; } - else { - std::vector<std::shared_ptr<OpenFile::WriteState>> overlap; - overlap.reserve(std::distance(R.first, R.second)); - for (auto i = R.first; i != R.second; i++) { - overlap.push_back(i->second); - } - // Wait for them whilst unlocked - _l.release()->unlock(); - for (const auto & r : overlap) { - r->future.wait(); - } - // Cause this thread to yield so the callback can acquire _lock - usleep(0); + catch (SystemError & e) { + return -e.syserrno; } } -} -int -FuseApp::read(const char *, char * buf, size_t s, off_t o, struct fuse_file_info * fi) -{ - try { - auto cpy = [buf](const auto && data) { - memcpy(buf, &data.front(), data.size()); - return data.size(); - }; - auto of = getProxy<OpenFilePtr>(fi->fh); - auto remote = of->remote; - if (fcr->Async) { - auto p = waitOnWriteRangeAndThen<std::future<Buffer>>(s, o, of, [o, s, &remote](const auto &){ - return remote->readAsync(o, s); - }); - return cpy(p.get()); + int + FuseApp::release(const char *, struct fuse_file_info * fi) + { + try { + auto of = getProxy<OpenFilePtr>(fi->fh); + auto remote = of->remote; + try { + of->flush(); + } + catch (SystemError & e) { + } + remote->close(); + clearProxy<OpenFilePtr>(fi->fh); + return 0; } - else { - return cpy(remote->read(o, s)); + catch (SystemError & e) { + clearProxy<OpenFilePtr>(fi->fh); + return -e.syserrno; } } - catch (SystemError & e) { - return -e.syserrno; - } -} -int -FuseApp::write(const char *, const char * buf, size_t s, off_t o, struct fuse_file_info * fi) -{ - try { - auto of = getProxy<OpenFilePtr>(fi->fh); - auto remote = of->remote; - if (fcr->Async) { - waitOnWriteRangeAndThen<void>(s, o, of, [o, s, buf, &of, remote](const auto & key){ - auto p = std::make_shared<OpenFile::WriteState>(); - remote->writeAsync(o, s, Buffer(buf, buf + s), [p,of,key]() { - p->promise.set_value(); - ScopeLock(of->_lock) { - of->bg.erase(key); - } - }, [p,of,key](auto e) { - p->promise.set_exception(e); - ScopeLock(of->_lock) { - of->bg.erase(key); - } - }); - of->bg.insert({key, p}); - }); + int + FuseApp::flush(const char *, struct fuse_file_info * fi) + { + try { + getProxy<OpenFilePtr>(fi->fh)->flush(); + return 0; } - else { - remote->write(o, s, Buffer(buf, buf + s)); + catch (SystemError & e) { + return -e.syserrno; } - return s; - } - catch (SystemError & e) { - return -e.syserrno; } -} -ssize_t -FuseApp::copy_file_range(const char *, struct fuse_file_info *fi_in, off_t offset_in, const char *, struct fuse_file_info *fi_out, off_t offset_out, size_t size, int flags) -{ - try { - auto of_in = getProxy<OpenFilePtr>(fi_in->fh); - auto of_out = getProxy<OpenFilePtr>(fi_out->fh); - auto remote_in = of_in->remote; - auto remote_out = of_out->remote; - of_in->wait(); - of_out->wait(); - return remote_in->copyrange(remote_out, offset_in, offset_out, size, flags); - } - catch (SystemError & e) { - return -e.syserrno; + template<typename Rtn, typename F> + inline Rtn + FuseApp::waitOnWriteRangeAndThen(size_t s, off_t o, const OpenFilePtr & of, const F & f) + { + const auto key = OpenFile::range(o, s); + while (true) { + std::unique_lock<decltype(of->_lock)> _l(of->_lock); + // Acquire operations to wait for + auto R = of->bg.equal_range(key); + if (R.first == R.second) { + // Perform operation + return f(key); + } + else { + std::vector<std::shared_ptr<OpenFile::WriteState>> overlap; + overlap.reserve(std::distance(R.first, R.second)); + for (auto i = R.first; i != R.second; i++) { + overlap.push_back(i->second); + } + // Wait for them whilst unlocked + _l.release()->unlock(); + for (const auto & r : overlap) { + r->future.wait(); + } + // Cause this thread to yield so the callback can acquire _lock + usleep(0); + } + } } -} -int -FuseApp::truncate(const char * p, off_t o, fuse_file_info * fi) -{ - try { - if (fi) { + int + FuseApp::read(const char *, char * buf, size_t s, off_t o, struct fuse_file_info * fi) + { + try { + auto cpy = [buf](const auto && data) { + memcpy(buf, &data.front(), data.size()); + return data.size(); + }; auto of = getProxy<OpenFilePtr>(fi->fh); - of->wait(); auto remote = of->remote; - remote->ftruncate(reqEnv(), o); + if (fcr->Async) { + auto p = waitOnWriteRangeAndThen<std::future<Buffer>>(s, o, of, [o, s, &remote](const auto &) { + return remote->readAsync(o, s); + }); + return cpy(p.get()); + } + else { + return cpy(remote->read(o, s)); + } } - else { - volume->truncate(reqEnv(), p, o); + catch (SystemError & e) { + return -e.syserrno; } - return 0; - } - catch (SystemError & e) { - return -e.syserrno; } -} -int -FuseApp::getattr(const char * p, struct stat * s, fuse_file_info * fi) -{ - try { - if (fi) { + int + FuseApp::write(const char *, const char * buf, size_t s, off_t o, struct fuse_file_info * fi) + { + try { auto of = getProxy<OpenFilePtr>(fi->fh); - of->wait(); auto remote = of->remote; - *s = converter.convert(remote->fgetattr(reqEnv())); - } - else { - if (auto cacehedStat = statCache.get(p)) { - *s = *cacehedStat; + if (fcr->Async) { + waitOnWriteRangeAndThen<void>(s, o, of, [o, s, buf, &of, remote](const auto & key) { + auto p = std::make_shared<OpenFile::WriteState>(); + remote->writeAsync( + o, s, Buffer(buf, buf + s), + [p, of, key]() { + p->promise.set_value(); + ScopeLock(of->_lock) { + of->bg.erase(key); + } + }, + [p, of, key](auto e) { + p->promise.set_exception(e); + ScopeLock(of->_lock) { + of->bg.erase(key); + } + }); + of->bg.insert({key, p}); + }); } else { - *s = converter.convert(volume->getattr(reqEnv(), p)); + remote->write(o, s, Buffer(buf, buf + s)); } + return s; + } + catch (SystemError & e) { + return -e.syserrno; + } + } + ssize_t + FuseApp::copy_file_range(const char *, struct fuse_file_info * fi_in, off_t offset_in, const char *, + struct fuse_file_info * fi_out, off_t offset_out, size_t size, int flags) + { + try { + auto of_in = getProxy<OpenFilePtr>(fi_in->fh); + auto of_out = getProxy<OpenFilePtr>(fi_out->fh); + auto remote_in = of_in->remote; + auto remote_out = of_out->remote; + of_in->wait(); + of_out->wait(); + return remote_in->copyrange(remote_out, offset_in, offset_out, size, flags); + } + catch (SystemError & e) { + return -e.syserrno; } - return 0; } - catch (SystemError & e) { - return -e.syserrno; + + int + FuseApp::truncate(const char * p, off_t o, fuse_file_info * fi) + { + try { + if (fi) { + auto of = getProxy<OpenFilePtr>(fi->fh); + of->wait(); + auto remote = of->remote; + remote->ftruncate(reqEnv(), o); + } + else { + volume->truncate(reqEnv(), p, o); + } + return 0; + } + catch (SystemError & e) { + return -e.syserrno; + } } -} -int -FuseApp::unlink(const char * p) -{ - try { - volume->unlink(reqEnv(), p); - return 0; + int + FuseApp::getattr(const char * p, struct stat * s, fuse_file_info * fi) + { + try { + if (fi) { + auto of = getProxy<OpenFilePtr>(fi->fh); + of->wait(); + auto remote = of->remote; + *s = converter.convert(remote->fgetattr(reqEnv())); + } + else { + if (auto cacehedStat = statCache.get(p)) { + *s = *cacehedStat; + } + else { + *s = converter.convert(volume->getattr(reqEnv(), p)); + } + } + return 0; + } + catch (SystemError & e) { + return -e.syserrno; + } } - catch (SystemError & e) { - return -e.syserrno; + + int + FuseApp::unlink(const char * p) + { + try { + volume->unlink(reqEnv(), p); + return 0; + } + catch (SystemError & e) { + return -e.syserrno; + } } } -} - diff --git a/netfs/fuse/fuseFiles.h b/netfs/fuse/fuseFiles.h index 4c9a31a..9143836 100644 --- a/netfs/fuse/fuseFiles.h +++ b/netfs/fuse/fuseFiles.h @@ -6,28 +6,27 @@ namespace NetFS { class FuseApp::OpenFile { - public: - OpenFile(FilePrxPtr remote, std::string path, int flags); + public: + OpenFile(FilePrxPtr remote, std::string path, int flags); - void flush(); - void wait() const; + void flush(); + void wait() const; - FilePrxPtr remote; - const std::string path; - const int flags; - class WriteState { - public: - WriteState(); + FilePrxPtr remote; + const std::string path; + const int flags; + class WriteState { + public: + WriteState(); - std::promise<void> promise; - std::shared_future<void> future; - }; - using BGs = boost::icl::interval_map<Ice::Long, std::shared_ptr<WriteState>>; - static BGs::interval_type range(off_t, size_t); - BGs bg; - mutable std::shared_mutex _lock; + std::promise<void> promise; + std::shared_future<void> future; + }; + using BGs = boost::icl::interval_map<Ice::Long, std::shared_ptr<WriteState>>; + static BGs::interval_type range(off_t, size_t); + BGs bg; + mutable std::shared_mutex _lock; }; } #endif - diff --git a/netfs/fuse/fuseMisc.cpp b/netfs/fuse/fuseMisc.cpp index c434333..36a695b 100644 --- a/netfs/fuse/fuseMisc.cpp +++ b/netfs/fuse/fuseMisc.cpp @@ -99,12 +99,10 @@ int NetFS::FuseApp::utimens(const char * path, const struct timespec times[2], fuse_file_info *) { try { - volume->utimens(reqEnv(), path, - times[0].tv_sec, times[0].tv_nsec, times[1].tv_sec, times[1].tv_nsec); + volume->utimens(reqEnv(), path, times[0].tv_sec, times[0].tv_nsec, times[1].tv_sec, times[1].tv_nsec); return 0; } catch (NetFS::SystemError & e) { return -e.syserrno; } } - diff --git a/netfs/fuse/fuseSystem.cpp b/netfs/fuse/fuseSystem.cpp index ac87d14..413bbda 100644 --- a/netfs/fuse/fuseSystem.cpp +++ b/netfs/fuse/fuseSystem.cpp @@ -11,4 +11,3 @@ NetFS::FuseApp::statfs(const char * p, struct statvfs * vfs) return -e.syserrno; } } - diff --git a/netfs/fuse/netfs.cpp b/netfs/fuse/netfs.cpp index 78a566b..9df3a75 100644 --- a/netfs/fuse/netfs.cpp +++ b/netfs/fuse/netfs.cpp @@ -2,49 +2,50 @@ #include <syslog.h> class FuseImpl : public fuse_args, public NetFS::FuseApp { - public: - FuseImpl(int c, char ** v) : - fuse_args(FUSE_ARGS_INIT(c, v)), - NetFS::FuseApp([this](){ - Ice::StringSeq iceArgs; - if (fuse_opt_parse(this, &iceArgs, nullptr, opt_parse) == -1) { - exit(-1); - } - return iceArgs; - }()) - { - openlog("netfs", LOG_CONS | LOG_PID | LOG_NDELAY, LOG_USER); - } - FuseImpl(const FuseImpl &) = delete; - FuseImpl(FuseImpl &&) = delete; - - ~FuseImpl() override - { - closelog(); - } - - void operator=(const FuseImpl &) = delete; - void operator=(FuseImpl &&) = delete; - - struct fuse_context * fuse_get_context() override - { - return ::fuse_get_context(); - } - - int run() - { - return ::fuse_main(argc, argv, &operations, this); - } - - void vlogf(int priority, const char * fmt, va_list args) const noexcept override - { - vsyslog(priority, fmt, args); - } +public: + FuseImpl(int c, char ** v) : + fuse_args(FUSE_ARGS_INIT(c, v)), NetFS::FuseApp([this]() { + Ice::StringSeq iceArgs; + if (fuse_opt_parse(this, &iceArgs, nullptr, opt_parse) == -1) { + exit(-1); + } + return iceArgs; + }()) + { + openlog("netfs", LOG_CONS | LOG_PID | LOG_NDELAY, LOG_USER); + } + FuseImpl(const FuseImpl &) = delete; + FuseImpl(FuseImpl &&) = delete; + + ~FuseImpl() override + { + closelog(); + } + + void operator=(const FuseImpl &) = delete; + void operator=(FuseImpl &&) = delete; + + struct fuse_context * + fuse_get_context() override + { + return ::fuse_get_context(); + } + + int + run() + { + return ::fuse_main(argc, argv, &operations, this); + } + + void + vlogf(int priority, const char * fmt, va_list args) const noexcept override + { + vsyslog(priority, fmt, args); + } }; int -main(int argc, char* argv[]) +main(int argc, char * argv[]) { return FuseImpl(argc, argv).run(); } - diff --git a/netfs/ice/entryResolver.h b/netfs/ice/entryResolver.h index 14f2d5d..973af4c 100644 --- a/netfs/ice/entryResolver.h +++ b/netfs/ice/entryResolver.h @@ -1,21 +1,20 @@ #ifndef NETFS_ENTRYRESOLVER_H #define NETFS_ENTRYRESOLVER_H -#include <cstddef> +#include <cstdint> +#include <unistd.h> enum class ResolvedAs : uint8_t { Real, Fallback, }; -template <typename id_t, typename name_t> -class EntryResolver { - public: - virtual ~EntryResolver() = default; +template<typename id_t, typename name_t> class EntryResolver { +public: + virtual ~EntryResolver() = default; - virtual ResolvedAs getID(const name_t &, id_t *) const = 0; - virtual ResolvedAs getName(const id_t &, name_t *) const = 0; + virtual ResolvedAs getID(const name_t &, id_t *) const = 0; + virtual ResolvedAs getName(const id_t &, name_t *) const = 0; }; #endif - diff --git a/netfs/ice/exceptionsImpl.cpp b/netfs/ice/exceptionsImpl.cpp index 93f5930..9588476 100644 --- a/netfs/ice/exceptionsImpl.cpp +++ b/netfs/ice/exceptionsImpl.cpp @@ -1,5 +1,5 @@ -#include <exceptions.h> #include <compileTimeFormatter.h> +#include <exceptions.h> AdHocFormatter(ExportNotFoundMsg, "Export [%?] not found on remote host"); void @@ -7,4 +7,3 @@ NetFS::ExportNotFound::ice_print(std::ostream & s) const { ExportNotFoundMsg::write(s, exportName); } - diff --git a/netfs/ice/typeConverter.cpp b/netfs/ice/typeConverter.cpp index 8e75326..e365c5d 100644 --- a/netfs/ice/typeConverter.cpp +++ b/netfs/ice/typeConverter.cpp @@ -1,17 +1,14 @@ #include "typeConverter.h" #include <boost/numeric/conversion/cast.hpp> -EntryTypeConverter::EntryTypeConverter(const UserLookup & u, const GroupLookup & g) : - userLookup(u), - groupLookup(g) -{ -} +EntryTypeConverter::EntryTypeConverter(const UserLookup & u, const GroupLookup & g) : userLookup(u), groupLookup(g) { } // Wrapper function to assure no unexpected corruption occurs // during narrowing assignments. // (bugprone-narrowing-conversions) template<typename T, typename S> -inline void safeAssign(T & t, const S & s) +inline void +safeAssign(T & t, const S & s) { t = boost::numeric_cast<T>(s); } @@ -19,7 +16,8 @@ inline void safeAssign(T & t, const S & s) struct stat EntryTypeConverter::convert(const NetFS::Attr & a) const { - struct stat s {}; + struct stat s { + }; s.st_dev = a.dev; s.st_ino = a.inode; s.st_mode = a.mode; @@ -45,7 +43,8 @@ EntryTypeConverter::convert(const NetFS::Attr & a) const struct statvfs TypeConverter::convert(const NetFS::VFS & v) const { - struct statvfs vfs {}; + struct statvfs vfs { + }; vfs.f_bsize = v.blockSize; vfs.f_frsize = v.fragmentSize; vfs.f_blocks = v.blocks; @@ -97,4 +96,3 @@ TypeConverter::convert(const struct statvfs & s) const safeAssign(t.maxNameLen, s.f_namemax); return t; } - diff --git a/netfs/ice/typeConverter.h b/netfs/ice/typeConverter.h index fedd204..3cd2941 100644 --- a/netfs/ice/typeConverter.h +++ b/netfs/ice/typeConverter.h @@ -1,33 +1,32 @@ #ifndef NETFS_TYPECONVERT_H #define NETFS_TYPECONVERT_H -#include <types.h> +#include "entryResolver.h" #include <sys/stat.h> #include <sys/statvfs.h> +#include <types.h> #include <visibility.h> -#include "entryResolver.h" class DLL_PUBLIC TypeConverter { - public: - // VFS - struct statvfs convert(const NetFS::VFS &) const; - NetFS::VFS convert(const struct statvfs &) const; +public: + // VFS + struct statvfs convert(const NetFS::VFS &) const; + NetFS::VFS convert(const struct statvfs &) const; }; class DLL_PUBLIC EntryTypeConverter : public TypeConverter { - public: - using UserLookup = EntryResolver<uid_t, std::string>; - using GroupLookup = EntryResolver<gid_t, std::string>; - EntryTypeConverter(const UserLookup &, const GroupLookup &); +public: + using UserLookup = EntryResolver<uid_t, std::string>; + using GroupLookup = EntryResolver<gid_t, std::string>; + EntryTypeConverter(const UserLookup &, const GroupLookup &); - // Attributes - struct stat convert(const NetFS::Attr &) const; - NetFS::Attr convert(const struct stat &) const; + // Attributes + struct stat convert(const NetFS::Attr &) const; + NetFS::Attr convert(const struct stat &) const; - protected: - const UserLookup & userLookup; - const GroupLookup & groupLookup; +protected: + const UserLookup & userLookup; + const GroupLookup & groupLookup; }; #endif - diff --git a/netfs/lib/entCache.cpp b/netfs/lib/entCache.cpp index a4436b9..d9f61df 100644 --- a/netfs/lib/entCache.cpp +++ b/netfs/lib/entCache.cpp @@ -7,4 +7,3 @@ static_assert(std::is_nothrow_move_assignable_v<Group>); template class EntCache<User>; template class EntCache<Group>; - diff --git a/netfs/lib/entCache.h b/netfs/lib/entCache.h index e0a06b5..e8c6461 100644 --- a/netfs/lib/entCache.h +++ b/netfs/lib/entCache.h @@ -1,71 +1,67 @@ #ifndef ENTCACHE_H #define ENTCACHE_H -#include <string> +#include <c++11Helpers.h> +#include <entryResolver.h> #include <set> #include <shared_mutex> -#include <entryResolver.h> -#include <c++11Helpers.h> +#include <string> class User { - public: - User(uid_t, std::string, gid_t); - uid_t id; - std::string name; - gid_t group; +public: + User(uid_t, std::string, gid_t); + uid_t id; + std::string name; + gid_t group; }; class Group { - public: - Group(gid_t, std::string); +public: + Group(gid_t, std::string); - bool hasMember(uid_t) const; + bool hasMember(uid_t) const; - gid_t id; - std::string name; - std::set<uid_t> members; + gid_t id; + std::string name; + std::set<uid_t> members; }; -template<class entry_t> -class EntCache : public EntryResolver<decltype(entry_t::id), decltype(entry_t::name)> { - public: - EntCache(); - EntCache(entry_t fb); - ~EntCache() override; +template<class entry_t> class EntCache : public EntryResolver<decltype(entry_t::id), decltype(entry_t::name)> { +public: + EntCache(); + EntCache(entry_t fb); + ~EntCache() override; - SPECIAL_MEMBERS_DEFAULT_MOVE_NO_COPY(EntCache); + SPECIAL_MEMBERS_DEFAULT_MOVE_NO_COPY(EntCache); - using id_t = decltype(entry_t::id); - using name_t = decltype(entry_t::name); - using entry_ptr = std::shared_ptr<entry_t>; + using id_t = decltype(entry_t::id); + using name_t = decltype(entry_t::name); + using entry_ptr = std::shared_ptr<entry_t>; - struct Resolution : public entry_ptr { - Resolution(entry_ptr, ResolvedAs = ResolvedAs::Real); - ResolvedAs resolution; - }; + struct Resolution : public entry_ptr { + Resolution(entry_ptr, ResolvedAs = ResolvedAs::Real); + ResolvedAs resolution; + }; - ResolvedAs getID(const name_t &, id_t *) const override; - ResolvedAs getName(const id_t &, name_t *) const override; - template<class key_t> - Resolution getEntry(const key_t &) const; + ResolvedAs getID(const name_t &, id_t *) const override; + ResolvedAs getName(const id_t &, name_t *) const override; + template<class key_t> Resolution getEntry(const key_t &) const; - void setFallback(entry_t fb); - void clearFallback(); + void setFallback(entry_t fb); + void clearFallback(); - protected: - void fillCache() const; - template<class key_t> - entry_ptr getEntryNoFill(const key_t &) const; +protected: + void fillCache() const; + template<class key_t> entry_ptr getEntryNoFill(const key_t &) const; - class Ids; - std::unique_ptr<Ids> idcache; - mutable std::shared_mutex lock; - mutable time_t fillTime {0}; - entry_ptr fallback; + class Ids; + std::unique_ptr<Ids> idcache; + mutable std::shared_mutex lock; + mutable time_t fillTime {0}; + entry_ptr fallback; }; using UserEntCache = EntCache<User>; using GroupEntCache = EntCache<Group>; #endif - diff --git a/netfs/lib/entCache.impl.h b/netfs/lib/entCache.impl.h index e0a8f85..0021f00 100644 --- a/netfs/lib/entCache.impl.h +++ b/netfs/lib/entCache.impl.h @@ -1,41 +1,33 @@ -#include "entCache.h" #ifndef ENTCACHE_IMPL_H #define ENTCACHE_IMPL_H +#include "entCache.h" +#include <boost/multi_index/member.hpp> +#include <boost/multi_index/ordered_index.hpp> +#include <boost/multi_index_container.hpp> #include <exceptions.h> +#include <grp.h> #include <lockHelpers.h> #include <pwd.h> -#include <grp.h> #include <type_traits> -#include <boost/multi_index_container.hpp> -#include <boost/multi_index/member.hpp> -#include <boost/multi_index/ordered_index.hpp> template<class entry_t> -class EntCache<entry_t>::Ids : public boost::multi_index::multi_index_container<std::shared_ptr<entry_t>, - boost::multi_index::indexed_by< - boost::multi_index::ordered_unique< - boost::multi_index::tag<id_t>, BOOST_MULTI_INDEX_MEMBER(entry_t, const id_t, id), std::less<>>, - boost::multi_index::ordered_unique< - boost::multi_index::tag<std::string>, BOOST_MULTI_INDEX_MEMBER(entry_t, const std::string, name), std::less<>> - > > { - }; +class EntCache<entry_t>::Ids : + public boost::multi_index::multi_index_container<std::shared_ptr<entry_t>, + boost::multi_index::indexed_by<boost::multi_index::ordered_unique<boost::multi_index::tag<id_t>, + BOOST_MULTI_INDEX_MEMBER(entry_t, const id_t, id), std::less<>>, + boost::multi_index::ordered_unique<boost::multi_index::tag<std::string>, + BOOST_MULTI_INDEX_MEMBER(entry_t, const std::string, name), std::less<>>>> { +}; -template<class entry_t> -EntCache<entry_t>::EntCache() : - idcache(std::make_unique<Ids>()) -{ -} +template<class entry_t> EntCache<entry_t>::EntCache() : idcache(std::make_unique<Ids>()) { } -template<class entry_t> -EntCache<entry_t>::EntCache(entry_t fb) : - idcache(std::make_unique<Ids>()) +template<class entry_t> EntCache<entry_t>::EntCache(entry_t fb) : idcache(std::make_unique<Ids>()) { setFallback(std::move(fb)); } -template<class entry_t> -EntCache<entry_t>::~EntCache() = default; +template<class entry_t> EntCache<entry_t>::~EntCache() = default; template<class entry_t> ResolvedAs @@ -56,9 +48,7 @@ EntCache<entry_t>::getName(const EntCache<entry_t>::id_t & u, EntCache<entry_t>: } template<class entry_t> -EntCache<entry_t>::Resolution::Resolution(entry_ptr e, ResolvedAs res) : - entry_ptr(std::move(e)), - resolution(res) +EntCache<entry_t>::Resolution::Resolution(entry_ptr e, ResolvedAs res) : entry_ptr(std::move(e)), resolution(res) { } @@ -77,7 +67,7 @@ EntCache<entry_t>::getEntry(const key_t & key) const return ent; } if (fallback) { - return { fallback, ResolvedAs::Fallback }; + return {fallback, ResolvedAs::Fallback}; } throw NetFS::SystemError(EPERM); } @@ -110,12 +100,7 @@ EntCache<entry_t>::clearFallback() fallback.reset(); } -User::User(uid_t u, std::string n, gid_t g) : - id(u), - name(std::move(n)), - group(g) -{ -} +User::User(uid_t u, std::string n, gid_t g) : id(u), name(std::move(n)), group(g) { } const int BUFLEN = 8196; @@ -127,7 +112,8 @@ EntCache<User>::fillCache() const setpwent(); idcache->clear(); std::array<char, BUFLEN> buf {}; - struct passwd pwbuf {}, * pwp; + struct passwd pwbuf { + }, *pwp; while (getpwent_r(&pwbuf, buf.data(), buf.size(), &pwp) == 0) { idcache->insert(std::make_shared<User>(pwp->pw_uid, pwp->pw_name, pwp->pw_gid)); } @@ -135,11 +121,7 @@ EntCache<User>::fillCache() const time(&fillTime); } -Group::Group(gid_t g, std::string n) : - id(g), - name(std::move(n)) -{ -} +Group::Group(gid_t g, std::string n) : id(g), name(std::move(n)) { } template<> void @@ -149,7 +131,8 @@ EntCache<Group>::fillCache() const setgrent(); std::array<char, BUFLEN> buf {}; idcache->clear(); - struct group grpbuf {}, * grp; + struct group grpbuf { + }, *grp; EntCache<User> instance; while (getgrent_r(&grpbuf, buf.data(), buf.size(), &grp) == 0) { auto g = std::make_shared<Group>(grp->gr_gid, grp->gr_name); @@ -173,4 +156,3 @@ Group::hasMember(uid_t u) const } #endif - diff --git a/netfs/unittests/mockDaemon.cpp b/netfs/unittests/mockDaemon.cpp index c2bfca2..0cb3172 100644 --- a/netfs/unittests/mockDaemon.cpp +++ b/netfs/unittests/mockDaemon.cpp @@ -1,31 +1,24 @@ #include "mockDaemon.h" -#include <definedDirs.h> #include <buffer.h> +#include <definedDirs.h> -const std::filesystem::path MockDaemonHost::TestExportRoot(binDir / - UniqueExport::get(getpid())); +const std::filesystem::path MockDaemonHost::TestExportRoot(binDir / UniqueExport::get(getpid())); -MockDaemon::MockDaemon(std::string ep) : - NetFSDaemon(), - testEndpoint(std::move(ep)) -{ -} +MockDaemon::MockDaemon(std::string ep) : NetFSDaemon(), testEndpoint(std::move(ep)) { } NetFS::Daemon::ConfigurationPtr MockDaemon::ReadConfiguration(const std::filesystem::path & path) const { auto c = NetFSDaemon::ReadConfiguration(path); - for(const auto & e : c->Exports) { + for (const auto & e : c->Exports) { e.second->RootPath = MockDaemonHost::TestExportRoot.string(); } - c->Hosts.insert({ "unittest", std::make_shared<NetFS::Daemon::Host>(testEndpoint) }); + c->Hosts.insert({"unittest", std::make_shared<NetFS::Daemon::Host>(testEndpoint)}); return c; } MockDaemonHost::MockDaemonHost(std::string ep, Ice::StringSeq ps) : - testEndpoint(std::move(ep)), - params(std::move(ps)), - daemon(nullptr) + testEndpoint(std::move(ep)), params(std::move(ps)), daemon(nullptr) { std::filesystem::remove_all(TestExportRoot); std::filesystem::create_directories(TestExportRoot); @@ -68,4 +61,3 @@ MockDaemonHost::restart() stop(); start(); } - diff --git a/netfs/unittests/mockDaemon.h b/netfs/unittests/mockDaemon.h index 659d23c..fb129c4 100644 --- a/netfs/unittests/mockDaemon.h +++ b/netfs/unittests/mockDaemon.h @@ -1,40 +1,39 @@ #ifndef MOCKDAEMON_H #define MOCKDAEMON_H +#include <compileTimeFormatter.h> #include <daemon.h> #include <visibility.h> -#include <compileTimeFormatter.h> AdHocFormatter(UniqueExport, "testExport-%?"); class DLL_PUBLIC MockDaemon : public NetFSDaemon { - public: - MockDaemon(std::string ep); +public: + MockDaemon(std::string ep); - const std::string testEndpoint; + const std::string testEndpoint; - protected: - NetFS::Daemon::ConfigurationPtr ReadConfiguration(const std::filesystem::path &) const override; +protected: + NetFS::Daemon::ConfigurationPtr ReadConfiguration(const std::filesystem::path &) const override; }; class DLL_PUBLIC MockDaemonHost { - public: - MockDaemonHost(std::string ep, Ice::StringSeq ps = {}); - ~MockDaemonHost(); +public: + MockDaemonHost(std::string ep, Ice::StringSeq ps = {}); + ~MockDaemonHost(); - void restart(); + void restart(); - Ice::CommunicatorPtr ic; - static const std::filesystem::path TestExportRoot; + Ice::CommunicatorPtr ic; + static const std::filesystem::path TestExportRoot; - private: - void start(); - void stop(); +private: + void start(); + void stop(); - const std::string testEndpoint; - Ice::StringSeq params; - NetFSDaemon * daemon; + const std::string testEndpoint; + Ice::StringSeq params; + NetFSDaemon * daemon; }; #endif - diff --git a/netfs/unittests/mockFuse.cpp b/netfs/unittests/mockFuse.cpp index 8a85267..554a62d 100644 --- a/netfs/unittests/mockFuse.cpp +++ b/netfs/unittests/mockFuse.cpp @@ -3,9 +3,7 @@ #include <buffer.h> FuseMock::FuseMock(std::string ep, Ice::StringSeq a) : - NetFS::FuseApp(std::move(a)), - testEndpoint(std::move(ep)), - context({}) + NetFS::FuseApp(std::move(a)), testEndpoint(std::move(ep)), context({}) { ::memset(&context, 0, sizeof(fuse_context)); context.pid = getpid(); @@ -43,11 +41,9 @@ FuseMock::vlogf(int, const char * fmt, va_list args) const noexcept } FuseMockHost::FuseMockHost(std::string ep, const Ice::StringSeq & a) : - app(std::make_unique<FuseMock>(std::move(ep), a)), - fuse(&app->operations) + app(std::make_unique<FuseMock>(std::move(ep), a)), fuse(&app->operations) { if (app->operations.init) { app->operations.init(nullptr, nullptr); } } - diff --git a/netfs/unittests/mockFuse.h b/netfs/unittests/mockFuse.h index 4461da6..c0e7828 100644 --- a/netfs/unittests/mockFuse.h +++ b/netfs/unittests/mockFuse.h @@ -5,29 +5,28 @@ #include <visibility.h> class DLL_PUBLIC FuseMock : public NetFS::FuseApp { - public: - FuseMock(std::string, Ice::StringSeq); +public: + FuseMock(std::string, Ice::StringSeq); - struct fuse_context * fuse_get_context() override; - void vlogf(int, const char *, va_list) const throw() override; + struct fuse_context * fuse_get_context() override; + void vlogf(int, const char *, va_list) const throw() override; - void connectToService() override; - private: - const std::string testEndpoint; - fuse_context context; + void connectToService() override; + +private: + const std::string testEndpoint; + fuse_context context; }; class DLL_PUBLIC FuseMockHost { - public: - FuseMockHost(std::string, const Ice::StringSeq &); +public: + FuseMockHost(std::string, const Ice::StringSeq &); - private: - std::unique_ptr<FuseMock> app; +private: + std::unique_ptr<FuseMock> app; - public: - const fuse_operations * fuse; +public: + const fuse_operations * fuse; }; - #endif - diff --git a/netfs/unittests/testCore.cpp b/netfs/unittests/testCore.cpp index ee079a8..cdbb958 100644 --- a/netfs/unittests/testCore.cpp +++ b/netfs/unittests/testCore.cpp @@ -3,12 +3,12 @@ #define private public #include "mockDaemon.h" #include "mockFuse.h" +#include <algorithm> +#include <climits> #include <definedDirs.h> #include <filesystem> -#include <ostream> -#include <algorithm> #include <fuseFiles.h> -#include <climits> +#include <ostream> const auto testExport = UniqueExport::get(getpid()); const std::string testEndpoint("tcp -h localhost -p 12012"); @@ -24,7 +24,8 @@ operator==(const struct stat & a, const struct stat & b) namespace std { template<size_t l> - bool operator==(const std::array<char, l> & a, const char * b) + bool + operator==(const std::array<char, l> & a, const char * b) { return strncmp(a.data(), b, l) == 0; } @@ -32,13 +33,15 @@ namespace std { AdHocFormatter(StatDebug, "dev: %? inode: %?"); // LCOV_EXCL_START template<typename T, size_t l> - ostream & operator<<(ostream & s, const std::array<T, l> & a) + ostream & + operator<<(ostream & s, const std::array<T, l> & a) { std::copy(a.begin(), a.end(), std::ostream_iterator<T>(s)); return s; } - ostream & operator<<(ostream & s, const struct stat & ss) + ostream & + operator<<(ostream & s, const struct stat & ss) { return StatDebug::write(s, ss.st_dev, ss.st_ino); } @@ -46,51 +49,42 @@ namespace std { } class Core { - public: - Core(const std::string & daemonConfig = "defaultDaemon.xml", const std::string & fuseConfig = "defaultFuse.xml") : - daemonHost(testEndpoint, { - "--Ice.ThreadPool.Client.Size=4", - "--Ice.ThreadPool.Client.SizeMax=20", - "--Ice.ThreadPool.Server.Size=5", - "--Ice.ThreadPool.Server.SizeMax=20", - "--NetFSD.ConfigPath=" + (rootDir / daemonConfig).string() - }), - fuseHost(testEndpoint, { - "--Ice.ThreadPool.Client.Size=6", - "--Ice.ThreadPool.Client.SizeMax=20", - (rootDir / fuseConfig).string() + ":testvol", - (binDir / "test").string() - }), - ic(daemonHost.ic), - fuse(fuseHost.fuse) - { - } - - static - int - nameListAdd(void *buf, const char *name, const struct stat *, off_t, fuse_fill_dir_flags) - { - static_cast<NetFS::NameList *>(buf)->push_back(name); - return 0; - } +public: + Core(const std::string & daemonConfig = "defaultDaemon.xml", const std::string & fuseConfig = "defaultFuse.xml") : + daemonHost(testEndpoint, + {"--Ice.ThreadPool.Client.Size=4", "--Ice.ThreadPool.Client.SizeMax=20", + "--Ice.ThreadPool.Server.Size=5", "--Ice.ThreadPool.Server.SizeMax=20", + "--NetFSD.ConfigPath=" + (rootDir / daemonConfig).string()}), + fuseHost(testEndpoint, + {"--Ice.ThreadPool.Client.Size=6", "--Ice.ThreadPool.Client.SizeMax=20", + (rootDir / fuseConfig).string() + ":testvol", (binDir / "test").string()}), + ic(daemonHost.ic), fuse(fuseHost.fuse) + { + } + static int + nameListAdd(void * buf, const char * name, const struct stat *, off_t, fuse_fill_dir_flags) + { + static_cast<NetFS::NameList *>(buf)->push_back(name); + return 0; + } - protected: - MockDaemonHost daemonHost; - FuseMockHost fuseHost; +protected: + MockDaemonHost daemonHost; + FuseMockHost fuseHost; - Ice::CommunicatorPtr ic; + Ice::CommunicatorPtr ic; - public: - const fuse_operations * fuse; +public: + const fuse_operations * fuse; }; class AltCore : public Core { - public: - AltCore() : Core("altDaemon.xml", "defaultFuse.xml") { } +public: + AltCore() : Core("altDaemon.xml", "defaultFuse.xml") { } }; -BOOST_FIXTURE_TEST_SUITE( NetfsCore, Core ); +BOOST_FIXTURE_TEST_SUITE(NetfsCore, Core); BOOST_AUTO_TEST_CASE(fuse_operations_correct) { @@ -102,7 +96,7 @@ BOOST_AUTO_TEST_CASE(fuse_operations_correct) BOOST_REQUIRE(!fuse->fsync); } -BOOST_AUTO_TEST_CASE ( daemonInitialised ) +BOOST_AUTO_TEST_CASE(daemonInitialised) { auto service = Ice::checkedCast<NetFS::ServicePrx>(ic->stringToProxy("Service")); BOOST_REQUIRE(service); @@ -113,18 +107,20 @@ BOOST_AUTO_TEST_CASE ( daemonInitialised ) volume->disconnect(); } -BOOST_AUTO_TEST_CASE ( clientInitialised ) +BOOST_AUTO_TEST_CASE(clientInitialised) { struct statvfs s; - BOOST_REQUIRE_EQUAL(0, fuse->statfs("/", &s)); + BOOST_REQUIRE_EQUAL(0, fuse->statfs("/", &s)); BOOST_REQUIRE_EQUAL(s.f_fsid, 0); - BOOST_REQUIRE_EQUAL(-ENOENT, fuse->statfs("/missing", &s)); + BOOST_REQUIRE_EQUAL(-ENOENT, fuse->statfs("/missing", &s)); } -BOOST_AUTO_TEST_CASE( testNavigation ) +BOOST_AUTO_TEST_CASE(testNavigation) { - struct stat attr {}, rootattr {}, insideattr {}; - struct fuse_file_info fi {}; + struct stat attr { + }, rootattr {}, insideattr {}; + struct fuse_file_info fi { + }; int fd = fuse->create("/inside", 0666, &fi); BOOST_REQUIRE(fd >= 0); fuse->release("/inside", &fi); @@ -153,13 +149,14 @@ BOOST_AUTO_TEST_CASE( testNavigation ) BOOST_REQUIRE_EQUAL(attr, insideattr); } -BOOST_AUTO_TEST_CASE( testSandboxing ) +BOOST_AUTO_TEST_CASE(testSandboxing) { // A previous (bad) run might create one or more of these: std::filesystem::remove(binDir / "outside"); std::filesystem::remove(binDir / "sub" / "outside"); std::filesystem::remove(binDir / "sub"); - struct fuse_file_info fi {}; + struct fuse_file_info fi { + }; BOOST_REQUIRE_EQUAL(fuse->create("../outside", 0666, &fi), -EPERM); BOOST_REQUIRE(!std::filesystem::exists(binDir / "outside")); BOOST_REQUIRE_EQUAL(fuse->create("/../outside", 0666, &fi), -EPERM); @@ -183,7 +180,8 @@ BOOST_AUTO_TEST_CASE( testSandboxing ) void enableWriteOnDir(const fuse_operations * fuse, const char * dir) { - struct stat st {}; + struct stat st { + }; BOOST_REQUIRE_EQUAL(fuse->chmod(dir, 0700, nullptr), 0); BOOST_REQUIRE_EQUAL(fuse->getattr(dir, &st, nullptr), 0); BOOST_REQUIRE_EQUAL(st.st_mode, 0700 | S_IFDIR); @@ -192,16 +190,19 @@ enableWriteOnDir(const fuse_operations * fuse, const char * dir) void disableWriteOnDir(const fuse_operations * fuse, const char * dir) { - struct stat st {}; + struct stat st { + }; BOOST_REQUIRE_EQUAL(fuse->chmod(dir, 0500, nullptr), 0); BOOST_REQUIRE_EQUAL(fuse->getattr(dir, &st, nullptr), 0); BOOST_REQUIRE_EQUAL(st.st_mode, 0500 | S_IFDIR); } -BOOST_AUTO_TEST_CASE( directories ) +BOOST_AUTO_TEST_CASE(directories) { - struct fuse_file_info fi {}; - struct stat st {}; + struct fuse_file_info fi { + }; + struct stat st { + }; BOOST_REQUIRE_EQUAL(fuse->mkdir("/test", 0700), 0); BOOST_REQUIRE(std::filesystem::is_directory(binDir / testExport / "test")); BOOST_REQUIRE_EQUAL(fuse->mkdir("/test", 0700), -EEXIST); @@ -242,10 +243,12 @@ BOOST_AUTO_TEST_CASE( directories ) BOOST_REQUIRE_EQUAL(fuse->opendir("/test", &fi), -ENOENT); } -BOOST_AUTO_TEST_CASE( files ) +BOOST_AUTO_TEST_CASE(files) { - struct fuse_file_info fi {}; - struct stat st {}, st2 {}; + struct fuse_file_info fi { + }; + struct stat st { + }, st2 {}; fi.flags = O_RDWR; BOOST_REQUIRE_EQUAL(fuse->open("/test", &fi), -ENOENT); BOOST_REQUIRE_EQUAL(fuse->create("/test", 0600, &fi), 0); @@ -297,9 +300,10 @@ BOOST_AUTO_TEST_CASE( files ) BOOST_REQUIRE_EQUAL(fuse->unlink("/test3"), -ENOENT); } -BOOST_AUTO_TEST_CASE( files_copy_range ) +BOOST_AUTO_TEST_CASE(files_copy_range) { - struct fuse_file_info fiin {}, fiout {}; + struct fuse_file_info fiin { + }, fiout {}; fiin.flags = O_RDWR; fiout.flags = O_RDWR; BOOST_REQUIRE_EQUAL(fuse->create("/src", 0600, &fiin), 0); @@ -313,10 +317,12 @@ BOOST_AUTO_TEST_CASE( files_copy_range ) BOOST_REQUIRE_EQUAL(fuse->release("/dst", &fiout), 0); } -BOOST_AUTO_TEST_CASE( bgwriteOverlapped, * boost::unit_test::timeout(2) ) +BOOST_AUTO_TEST_CASE(bgwriteOverlapped, *boost::unit_test::timeout(2)) { - struct fuse_file_info fi {}; - struct stat st {}; + struct fuse_file_info fi { + }; + struct stat st { + }; fi.flags = O_RDWR; constexpr auto s = sizeof(int32_t); auto N = 20; @@ -328,16 +334,18 @@ BOOST_AUTO_TEST_CASE( bgwriteOverlapped, * boost::unit_test::timeout(2) ) BOOST_REQUIRE_EQUAL(st.st_size, N + s - 1); std::array<char, s> buf; BOOST_REQUIRE_EQUAL(fuse->read("/test", buf.data(), s, (N - 1), &fi), s); - BOOST_REQUIRE_EQUAL(*(int*)buf.data(), N - 1); + BOOST_REQUIRE_EQUAL(*(int *)buf.data(), N - 1); BOOST_REQUIRE_EQUAL(fuse->release("/test", &fi), 0); BOOST_REQUIRE_EQUAL(fuse->getattr("/test", &st, nullptr), 0); BOOST_REQUIRE_EQUAL(st.st_size, N + s - 1); } -BOOST_AUTO_TEST_CASE( bgwriteDistinct, * boost::unit_test::timeout(2) ) +BOOST_AUTO_TEST_CASE(bgwriteDistinct, *boost::unit_test::timeout(2)) { - struct fuse_file_info fi {}; - struct stat st {}; + struct fuse_file_info fi { + }; + struct stat st { + }; fi.flags = O_RDWR; constexpr auto s = sizeof(int32_t); auto N = 20; @@ -349,13 +357,13 @@ BOOST_AUTO_TEST_CASE( bgwriteDistinct, * boost::unit_test::timeout(2) ) BOOST_REQUIRE_EQUAL(st.st_size, N * s); std::array<char, s> buf; BOOST_REQUIRE_EQUAL(fuse->read("/test", buf.data(), s, (N - 1) * s, &fi), s); - BOOST_REQUIRE_EQUAL(*(int*)buf.data(), N - 1); + BOOST_REQUIRE_EQUAL(*(int *)buf.data(), N - 1); BOOST_REQUIRE_EQUAL(fuse->release("/test", &fi), 0); BOOST_REQUIRE_EQUAL(fuse->getattr("/test", &st, nullptr), 0); BOOST_REQUIRE_EQUAL(st.st_size, N * s); } -BOOST_AUTO_TEST_CASE( symlinks ) +BOOST_AUTO_TEST_CASE(symlinks) { std::array<char, PATH_MAX> buf; BOOST_REQUIRE_EQUAL(fuse->mkdir("/dir", 0700), 0); @@ -371,9 +379,10 @@ BOOST_AUTO_TEST_CASE( symlinks ) enableWriteOnDir(fuse, "/"); } -BOOST_AUTO_TEST_CASE( access ) +BOOST_AUTO_TEST_CASE(access) { - struct stat st {}; + struct stat st { + }; BOOST_REQUIRE_EQUAL(fuse->access("/", F_OK), 0); BOOST_REQUIRE_EQUAL(fuse->access("/missing", F_OK), -ENOENT); // Basic assertions @@ -397,9 +406,10 @@ BOOST_AUTO_TEST_CASE( access ) BOOST_REQUIRE_EQUAL(fuse->getattr("/dir", &st, nullptr), -ENOENT); } -BOOST_AUTO_TEST_CASE( permissionsDirs ) +BOOST_AUTO_TEST_CASE(permissionsDirs) { - struct stat st {}; + struct stat st { + }; BOOST_REQUIRE_EQUAL(fuse->mkdir("/dir", 0700), 0); BOOST_REQUIRE_EQUAL(fuse->mkdir("/dir/yes", 0000), 0); BOOST_REQUIRE_EQUAL(fuse->getattr("/dir/yes", &st, nullptr), 0); @@ -413,10 +423,12 @@ BOOST_AUTO_TEST_CASE( permissionsDirs ) BOOST_REQUIRE_EQUAL(fuse->getattr("/dir/yes", &st, nullptr), -ENOENT); } -BOOST_AUTO_TEST_CASE( permissionsFiles ) +BOOST_AUTO_TEST_CASE(permissionsFiles) { - struct stat st {}; - struct fuse_file_info fi {}; + struct stat st { + }; + struct fuse_file_info fi { + }; fi.flags = O_RDWR; BOOST_REQUIRE_EQUAL(fuse->mkdir("/dir", 0700), 0); BOOST_REQUIRE_NE(fuse->create("/dir/yes", 0000, &fi), -1); @@ -432,11 +444,12 @@ BOOST_AUTO_TEST_CASE( permissionsFiles ) BOOST_REQUIRE_EQUAL(fuse->getattr("/dir/yes", &st, nullptr), -ENOENT); } -BOOST_AUTO_TEST_CASE( mknod ) +BOOST_AUTO_TEST_CASE(mknod) { BOOST_REQUIRE_EQUAL(fuse->mknod("/nod", 0600 | S_IFIFO, 0), 0); BOOST_REQUIRE_EQUAL(fuse->mknod("/nod", 0600 | S_IFIFO, 0), -EEXIST); - struct stat st {}; + struct stat st { + }; BOOST_REQUIRE_EQUAL(fuse->getattr("/nod", &st, nullptr), 0); BOOST_REQUIRE_EQUAL(st.st_mode, 0600 | S_IFIFO); BOOST_REQUIRE_EQUAL(fuse->unlink("/nod"), 0); @@ -446,9 +459,10 @@ BOOST_AUTO_TEST_CASE( mknod ) enableWriteOnDir(fuse, "/"); } -BOOST_AUTO_TEST_CASE( renameToDir ) +BOOST_AUTO_TEST_CASE(renameToDir) { - struct fuse_file_info fi {}; + struct fuse_file_info fi { + }; BOOST_REQUIRE_EQUAL(fuse->create("/file", 0600, &fi), 0); BOOST_REQUIRE_EQUAL(fuse->release("/file", &fi), 0); BOOST_REQUIRE_EQUAL(fuse->mkdir("/dir", 0700), 0); @@ -465,9 +479,10 @@ BOOST_AUTO_TEST_CASE( renameToDir ) BOOST_REQUIRE_EQUAL(fuse->rmdir("/dir"), 0); } -BOOST_AUTO_TEST_CASE( renameFlags ) +BOOST_AUTO_TEST_CASE(renameFlags) { - struct fuse_file_info fi {}; + struct fuse_file_info fi { + }; BOOST_REQUIRE_EQUAL(fuse->create("/file", 0600, &fi), 0); BOOST_REQUIRE_EQUAL(fuse->release("/file", &fi), 0); BOOST_REQUIRE_EQUAL(fuse->create("/file2", 0600, &fi), 0); @@ -482,11 +497,12 @@ BOOST_AUTO_TEST_CASE( renameFlags ) BOOST_REQUIRE_EQUAL(fuse->access("/file2", F_OK), 0); } -BOOST_AUTO_TEST_CASE( chown ) +BOOST_AUTO_TEST_CASE(chown) { BOOST_REQUIRE_EQUAL(fuse->mkdir("/dir", 0777), 0); BOOST_REQUIRE_EQUAL(fuse->chown("/dir", getuid(), getgid(), nullptr), 0); - struct stat st {}; + struct stat st { + }; BOOST_REQUIRE_EQUAL(fuse->getattr("/dir", &st, nullptr), 0); BOOST_REQUIRE_EQUAL(st.st_uid, getuid()); BOOST_REQUIRE_EQUAL(st.st_gid, getgid()); @@ -494,14 +510,15 @@ BOOST_AUTO_TEST_CASE( chown ) BOOST_REQUIRE_EQUAL(fuse->rmdir("/dir"), 0); } -BOOST_AUTO_TEST_CASE( utimens ) +BOOST_AUTO_TEST_CASE(utimens) { BOOST_REQUIRE_EQUAL(fuse->mknod("/file", 0600, 0), 0); - std::array<timespec, 2> times { { {1, 100}, { 2, 200 } } }; + std::array<timespec, 2> times {{{1, 100}, {2, 200}}}; BOOST_REQUIRE_EQUAL(fuse->utimens("/file", times.data(), nullptr), 0); times[1].tv_nsec = -200; BOOST_REQUIRE_EQUAL(fuse->utimens("/file", times.data(), nullptr), -EINVAL); - struct stat st {}; + struct stat st { + }; BOOST_REQUIRE_EQUAL(fuse->getattr("/file", &st, nullptr), 0); BOOST_REQUIRE_EQUAL(st.st_atime, 1); BOOST_REQUIRE_EQUAL(st.st_atim.tv_sec, 1); @@ -523,11 +540,12 @@ BOOST_AUTO_TEST_CASE( utimens ) BOOST_AUTO_TEST_SUITE_END(); -BOOST_FIXTURE_TEST_SUITE( NetfsAltCore, AltCore ); +BOOST_FIXTURE_TEST_SUITE(NetfsAltCore, AltCore); -BOOST_AUTO_TEST_CASE( noListDir ) +BOOST_AUTO_TEST_CASE(noListDir) { - struct fuse_file_info fi {}; + struct fuse_file_info fi { + }; BOOST_REQUIRE_EQUAL(fuse->mkdir("/test", 0700), 0); BOOST_REQUIRE(std::filesystem::is_directory(binDir / testExport / "test")); BOOST_REQUIRE_EQUAL(fuse->mkdir("/test", 0700), -EEXIST); @@ -564,10 +582,12 @@ BOOST_AUTO_TEST_CASE( noListDir ) BOOST_REQUIRE_EQUAL(fuse->opendir("/test", &fi), -ENOENT); } -BOOST_AUTO_TEST_CASE( testFGWrites ) +BOOST_AUTO_TEST_CASE(testFGWrites) { - struct fuse_file_info fi {}; - struct stat st {}; + struct fuse_file_info fi { + }; + struct stat st { + }; fi.flags = O_RDWR; BOOST_REQUIRE_EQUAL(fuse->create("/test", 0600, &fi), 0); BOOST_REQUIRE_EQUAL(fuse->write("/test", "some test buffer", 16, 0, &fi), 16); @@ -581,49 +601,48 @@ BOOST_AUTO_TEST_CASE( testFGWrites ) BOOST_AUTO_TEST_SUITE_END(); -BOOST_AUTO_TEST_CASE( testNoAuthNoPass ) +BOOST_AUTO_TEST_CASE(testNoAuthNoPass) { Core c("defaultDaemon.xml", "defaultFuse.xml"); struct statvfs s; - BOOST_REQUIRE_EQUAL(0, c.fuse->statfs("/", &s)); + BOOST_REQUIRE_EQUAL(0, c.fuse->statfs("/", &s)); } -BOOST_AUTO_TEST_CASE( testWithAuthNoPass ) +BOOST_AUTO_TEST_CASE(testWithAuthNoPass) { Core c("secureDaemon.xml", "defaultFuse.xml"); struct statvfs s; - BOOST_REQUIRE_EQUAL(-EPERM, c.fuse->statfs("/", &s)); + BOOST_REQUIRE_EQUAL(-EPERM, c.fuse->statfs("/", &s)); } -BOOST_AUTO_TEST_CASE( testWithAuthWithPass ) +BOOST_AUTO_TEST_CASE(testWithAuthWithPass) { Core c("secureDaemon.xml", "secureFuse.xml"); struct statvfs s; - BOOST_REQUIRE_EQUAL(0, c.fuse->statfs("/", &s)); + BOOST_REQUIRE_EQUAL(0, c.fuse->statfs("/", &s)); } -BOOST_AUTO_TEST_CASE( testNoAuthWithPass ) +BOOST_AUTO_TEST_CASE(testNoAuthWithPass) { Core c("defaultDaemon.xml", "secureFuse.xml"); struct statvfs s; - BOOST_REQUIRE_EQUAL(0, c.fuse->statfs("/", &s)); + BOOST_REQUIRE_EQUAL(0, c.fuse->statfs("/", &s)); } -BOOST_AUTO_TEST_CASE( uriConnect ) +BOOST_AUTO_TEST_CASE(uriConnect) { - MockDaemonHost daemon(testEndpoint, { - "--NetFSD.ConfigPath=" + (rootDir / "defaultDaemon.xml").string() - }); - FuseMockHost fuse(std::string(), { - testUri, - (binDir / "test").string(), + MockDaemonHost daemon(testEndpoint, {"--NetFSD.ConfigPath=" + (rootDir / "defaultDaemon.xml").string()}); + FuseMockHost fuse(std::string(), + { + testUri, + (binDir / "test").string(), }); struct statvfs s; - BOOST_REQUIRE_EQUAL(0, fuse.fuse->statfs("/", &s)); + BOOST_REQUIRE_EQUAL(0, fuse.fuse->statfs("/", &s)); } -BOOST_AUTO_TEST_CASE( interval_map_works_how_i_think ) +BOOST_AUTO_TEST_CASE(interval_map_works_how_i_think) { // Used as proof that setting and selecting ranges given an // attempt to write to [offset, offset + size) will find @@ -642,9 +661,9 @@ BOOST_AUTO_TEST_CASE( interval_map_works_how_i_think ) BOOST_REQUIRE(map.empty()); // Pretend we have 3 writes in progress - map.insert({r(5, 10), std::make_shared<NetFS::FuseApp::OpenFile::WriteState>() }); // [5, 15) - map.insert({r(15, 15), std::make_shared<NetFS::FuseApp::OpenFile::WriteState>() }); // [15, 30) - map.insert({r(35, 10), std::make_shared<NetFS::FuseApp::OpenFile::WriteState>() }); // [35, 45) + map.insert({r(5, 10), std::make_shared<NetFS::FuseApp::OpenFile::WriteState>()}); // [5, 15) + map.insert({r(15, 15), std::make_shared<NetFS::FuseApp::OpenFile::WriteState>()}); // [15, 30) + map.insert({r(35, 10), std::make_shared<NetFS::FuseApp::OpenFile::WriteState>()}); // [35, 45) // Then the following writes to [O, O+S) should wait on N pending writes check(0, 1, 0); // Clear before check(100, 10, 0); // Clear after @@ -666,4 +685,3 @@ BOOST_AUTO_TEST_CASE( interval_map_works_how_i_think ) map.erase(r(35, 10)); BOOST_REQUIRE(map.empty()); } - diff --git a/netfs/unittests/testEdgeCases.cpp b/netfs/unittests/testEdgeCases.cpp index b0d0098..01eb6b7 100644 --- a/netfs/unittests/testEdgeCases.cpp +++ b/netfs/unittests/testEdgeCases.cpp @@ -1,34 +1,32 @@ #define BOOST_TEST_MODULE TestNetFSEdgeCases -#include <boost/test/unit_test.hpp> #include "mockDaemon.h" #include "mockFuse.h" +#include <boost/test/unit_test.hpp> #include <definedDirs.h> const std::string testEndpoint("tcp -h localhost -p 12014"); -BOOST_AUTO_TEST_CASE ( createAndDaemonRestart ) +BOOST_AUTO_TEST_CASE(createAndDaemonRestart) { - MockDaemonHost daemon(testEndpoint, { - "--NetFSD.ConfigPath=" + (rootDir / "defaultDaemon.xml").string() - }); - FuseMockHost fuse(testEndpoint, { - (rootDir / "defaultFuse.xml:testvol").string(), - (rootDir / "test").string() - }); + MockDaemonHost daemon(testEndpoint, {"--NetFSD.ConfigPath=" + (rootDir / "defaultDaemon.xml").string()}); + FuseMockHost fuse(testEndpoint, {(rootDir / "defaultFuse.xml:testvol").string(), (rootDir / "test").string()}); - struct statvfs s {}; - BOOST_REQUIRE_EQUAL(0, fuse.fuse->statfs("/", &s)); + struct statvfs s { + }; + BOOST_REQUIRE_EQUAL(0, fuse.fuse->statfs("/", &s)); const char * fileName = "/createMe"; BOOST_TEST_CHECKPOINT("Create a new file"); - struct fuse_file_info fh {}; + struct fuse_file_info fh { + }; memset(&fh, 0, sizeof(fh)); fh.flags = O_WRONLY | O_CREAT | O_APPEND; BOOST_REQUIRE_EQUAL(0, fuse.fuse->create(fileName, 0100644, &fh)); BOOST_REQUIRE(fh.fh); BOOST_TEST_CHECKPOINT("Fetch file attributes"); - struct stat st {}; + struct stat st { + }; BOOST_REQUIRE_EQUAL(0, fuse.fuse->getattr(fileName, &st, &fh)); BOOST_REQUIRE_EQUAL(st.st_size, 0); BOOST_REQUIRE_EQUAL(st.st_uid, getuid()); @@ -55,56 +53,41 @@ BOOST_AUTO_TEST_CASE ( createAndDaemonRestart ) BOOST_REQUIRE_EQUAL(0, fuse.fuse->release(fileName, &fh)); } -BOOST_AUTO_TEST_CASE( noDaemonAtStartUp ) +BOOST_AUTO_TEST_CASE(noDaemonAtStartUp) { - FuseMockHost fuse(testEndpoint, { - (rootDir / "defaultFuse.xml:testvol").string(), - (rootDir / "test").string() - }); + FuseMockHost fuse(testEndpoint, {(rootDir / "defaultFuse.xml:testvol").string(), (rootDir / "test").string()}); - struct statvfs s {}; - BOOST_REQUIRE_EQUAL(-EIO, fuse.fuse->statfs("/", &s)); - MockDaemonHost daemon(testEndpoint, { - "--NetFSD.ConfigPath=" + (rootDir / "defaultDaemon.xml").string() - }); + struct statvfs s { + }; + BOOST_REQUIRE_EQUAL(-EIO, fuse.fuse->statfs("/", &s)); + MockDaemonHost daemon(testEndpoint, {"--NetFSD.ConfigPath=" + (rootDir / "defaultDaemon.xml").string()}); - BOOST_REQUIRE_EQUAL(0, fuse.fuse->statfs("/", &s)); + BOOST_REQUIRE_EQUAL(0, fuse.fuse->statfs("/", &s)); } -BOOST_AUTO_TEST_CASE ( daemonUnavailableAfterUse ) +BOOST_AUTO_TEST_CASE(daemonUnavailableAfterUse) { - FuseMockHost fuse(testEndpoint, { - (rootDir / "defaultFuse.xml:testvol").string(), - (rootDir / "test").string() - }); - struct statvfs s {}; + FuseMockHost fuse(testEndpoint, {(rootDir / "defaultFuse.xml:testvol").string(), (rootDir / "test").string()}); + struct statvfs s { + }; { - MockDaemonHost daemon(testEndpoint, { - "--NetFSD.ConfigPath=" + (rootDir / "defaultDaemon.xml").string() - }); + MockDaemonHost daemon(testEndpoint, {"--NetFSD.ConfigPath=" + (rootDir / "defaultDaemon.xml").string()}); - BOOST_REQUIRE_EQUAL(0, fuse.fuse->statfs("/", &s)); + BOOST_REQUIRE_EQUAL(0, fuse.fuse->statfs("/", &s)); } - BOOST_REQUIRE_EQUAL(-EIO, fuse.fuse->statfs("/", &s)); + BOOST_REQUIRE_EQUAL(-EIO, fuse.fuse->statfs("/", &s)); { - MockDaemonHost daemon(testEndpoint, { - "--NetFSD.ConfigPath=" + (rootDir / "defaultDaemon.xml").string() - }); + MockDaemonHost daemon(testEndpoint, {"--NetFSD.ConfigPath=" + (rootDir / "defaultDaemon.xml").string()}); - BOOST_REQUIRE_EQUAL(0, fuse.fuse->statfs("/", &s)); + BOOST_REQUIRE_EQUAL(0, fuse.fuse->statfs("/", &s)); } - BOOST_REQUIRE_EQUAL(-EIO, fuse.fuse->statfs("/", &s)); + BOOST_REQUIRE_EQUAL(-EIO, fuse.fuse->statfs("/", &s)); } -BOOST_AUTO_TEST_CASE( manyThreads ) +BOOST_AUTO_TEST_CASE(manyThreads) { - MockDaemonHost daemon(testEndpoint, { - "--NetFSD.ConfigPath=" + (rootDir / "defaultDaemon.xml").string() - }); - FuseMockHost fuse(testEndpoint, { - (rootDir / "defaultFuse.xml:testvol").string(), - (rootDir / "test").string() - }); + MockDaemonHost daemon(testEndpoint, {"--NetFSD.ConfigPath=" + (rootDir / "defaultDaemon.xml").string()}); + FuseMockHost fuse(testEndpoint, {(rootDir / "defaultFuse.xml:testvol").string(), (rootDir / "test").string()}); bool running = true; std::vector<std::thread> ths; @@ -112,8 +95,9 @@ BOOST_AUTO_TEST_CASE( manyThreads ) std::atomic_uint success = 0; for (int x = 0; x < 20; x++) { ths.emplace_back([&] { - struct statvfs s {}; - while(running && success < 1600) { + struct statvfs s { + }; + while (running && success < 1600) { if (fuse.fuse->statfs("/", &s) == 0) { success++; } @@ -126,11 +110,10 @@ BOOST_AUTO_TEST_CASE( manyThreads ) daemon.restart(); sleep(1); running = false; - + for (auto & th : ths) { th.join(); } BOOST_CHECK_GT(success, 800); } - diff --git a/netfs/unittests/testFuse.cpp b/netfs/unittests/testFuse.cpp index b856e15..ded7077 100644 --- a/netfs/unittests/testFuse.cpp +++ b/netfs/unittests/testFuse.cpp @@ -1,78 +1,79 @@ #define BOOST_TEST_MODULE TestNetFSFuse +#include "mockDaemon.h" #include <boost/test/unit_test.hpp> +#include <cache.impl.h> #include <definedDirs.h> #include <filesystem> -#include <ostream> -#include <thread> #include <fuse.h> #include <fuseApp.h> -#include <cache.impl.h> -#include "mockDaemon.h" +#include <ostream> +#include <thread> -static const std::filesystem::path mntpnt { binDir / "mnt" }; +static const std::filesystem::path mntpnt {binDir / "mnt"}; const std::string testEndpoint("tcp -h localhost -p 12015"); const std::string testUri("tcp://localhost:12015/testvol"); class FuseMountPoint : public MockDaemonHost, public NetFS::FuseApp { - public: - FuseMountPoint() : - MockDaemonHost(::testEndpoint, { - "--NetFSD.ConfigPath=" + (rootDir / "defaultDaemon.xml").string() - }), - NetFS::FuseApp({::testUri}) - { - std::filesystem::remove(mntpnt); - std::filesystem::create_directory(mntpnt); - struct fuse_args fargs { }; - ::fuse_opt_add_arg(&fargs, "-onoauto_cache"); - ::fuse_opt_add_arg(&fargs, "-oattr_timeout=0"); - ::fuse_opt_add_arg(&fargs, "-oac_attr_timeout=0"); - fs = ::fuse_new(&fargs, &operations, sizeof(fuse_operations), this); - BOOST_REQUIRE(fs); - BOOST_REQUIRE_EQUAL(0,::fuse_mount(fs, mntpnt.c_str())); - th = std::make_unique<std::thread>(::fuse_loop, fs); - } - - ~FuseMountPoint() override - { - ::fuse_unmount(fs); - if (th) { - th->join(); - } - std::filesystem::remove(mntpnt); +public: + FuseMountPoint() : + MockDaemonHost(::testEndpoint, {"--NetFSD.ConfigPath=" + (rootDir / "defaultDaemon.xml").string()}), + NetFS::FuseApp({::testUri}) + { + std::filesystem::remove(mntpnt); + std::filesystem::create_directory(mntpnt); + struct fuse_args fargs { + }; + ::fuse_opt_add_arg(&fargs, "-onoauto_cache"); + ::fuse_opt_add_arg(&fargs, "-oattr_timeout=0"); + ::fuse_opt_add_arg(&fargs, "-oac_attr_timeout=0"); + fs = ::fuse_new(&fargs, &operations, sizeof(fuse_operations), this); + BOOST_REQUIRE(fs); + BOOST_REQUIRE_EQUAL(0, ::fuse_mount(fs, mntpnt.c_str())); + th = std::make_unique<std::thread>(::fuse_loop, fs); + } + + ~FuseMountPoint() override + { + ::fuse_unmount(fs); + if (th) { + th->join(); } - - FuseMountPoint(const FuseMountPoint &) = delete; - FuseMountPoint(FuseMountPoint &&) = delete; - - FuseMountPoint & operator=(const FuseMountPoint &) = delete; - FuseMountPoint & operator=(FuseMountPoint &&) = delete; - - struct fuse_context * fuse_get_context() override - { - return ::fuse_get_context(); - } - - static inline char * vstrdupf(const char * fmt, va_list args) - { - char * out {}; - BOOST_REQUIRE_GE(vasprintf(&out, fmt, args), 0); - BOOST_REQUIRE(out); - return out; - } - - void vlogf(int, const char * fmt, va_list args) const noexcept override - { - std::unique_ptr<char, void(*)(void*)> msg(vstrdupf(fmt, args), std::free); - BOOST_TEST_MESSAGE(msg.get()); - } - - struct fuse * fs; - std::unique_ptr<std::thread> th; + std::filesystem::remove(mntpnt); + } + + FuseMountPoint(const FuseMountPoint &) = delete; + FuseMountPoint(FuseMountPoint &&) = delete; + + FuseMountPoint & operator=(const FuseMountPoint &) = delete; + FuseMountPoint & operator=(FuseMountPoint &&) = delete; + + struct fuse_context * + fuse_get_context() override + { + return ::fuse_get_context(); + } + + static inline char * + vstrdupf(const char * fmt, va_list args) + { + char * out {}; + BOOST_REQUIRE_GE(vasprintf(&out, fmt, args), 0); + BOOST_REQUIRE(out); + return out; + } + + void + vlogf(int, const char * fmt, va_list args) const noexcept override + { + std::unique_ptr<char, void (*)(void *)> msg(vstrdupf(fmt, args), std::free); + BOOST_TEST_MESSAGE(msg.get()); + } + + struct fuse * fs; + std::unique_ptr<std::thread> th; }; -#define BOOST_CHECK_EQUAL_FIELD(left, right, field) \ - BOOST_CHECK_EQUAL((left).field, (right).field); +#define BOOST_CHECK_EQUAL_FIELD(left, right, field) BOOST_CHECK_EQUAL((left).field, (right).field); #define BOOST_CHECK_EQUAL_STAT(left, right) \ BOOST_CHECK_NE(&(left), &(right)); \ @@ -86,13 +87,13 @@ class FuseMountPoint : public MockDaemonHost, public NetFS::FuseApp { BOOST_CHECK_EQUAL_FIELD(left, right, st_rdev); \ BOOST_CHECK_EQUAL_FIELD(left, right, st_size); \ BOOST_CHECK_EQUAL_FIELD(left, right, st_blksize); \ - BOOST_CHECK_EQUAL_FIELD(left, right, st_blocks); \ + BOOST_CHECK_EQUAL_FIELD(left, right, st_blocks); -static -auto +static auto get_lstat(const std::filesystem::path & p) { - struct stat st { }; + struct stat st { + }; BOOST_TEST_INFO(p); BOOST_REQUIRE_EQUAL(::lstat(p.c_str(), &st), 0); return st; @@ -100,12 +101,12 @@ get_lstat(const std::filesystem::path & p) BOOST_FIXTURE_TEST_SUITE(fmp, FuseMountPoint); -BOOST_AUTO_TEST_CASE(fuse, * boost::unit_test::timeout(5)) +BOOST_AUTO_TEST_CASE(fuse, *boost::unit_test::timeout(5)) { BOOST_REQUIRE(std::filesystem::is_directory(mntpnt)); } -BOOST_AUTO_TEST_CASE(fuse_ls, * boost::unit_test::timeout(5)) +BOOST_AUTO_TEST_CASE(fuse_ls, *boost::unit_test::timeout(5)) { BOOST_REQUIRE(std::filesystem::is_directory(mntpnt)); BOOST_REQUIRE(std::filesystem::is_empty(mntpnt)); @@ -151,4 +152,3 @@ BOOST_AUTO_TEST_CASE(url_params_2) auto fcs = NetFS::FuseApp::configureFromUri("tcp://localhost/foo?0&async=0"); BOOST_CHECK_EQUAL(fcs->Async, false); } - diff --git a/netfs/unittests/testGlacier.cpp b/netfs/unittests/testGlacier.cpp index f4474fb..47782c5 100644 --- a/netfs/unittests/testGlacier.cpp +++ b/netfs/unittests/testGlacier.cpp @@ -1,37 +1,36 @@ #define BOOST_TEST_MODULE TestNetFSGlacier -#include <boost/test/unit_test.hpp> #include "mockDaemon.h" #include "mockFuse.h" #include <boost/scope_exit.hpp> +#include <boost/test/unit_test.hpp> #include <definedDirs.h> const std::string testEndpoint("tcp -h localhost -p 12013"); #define PID "/tmp/glacier.pid" -BOOST_AUTO_TEST_CASE ( withRouter ) +BOOST_AUTO_TEST_CASE(withRouter) { std::filesystem::remove(PID); BOOST_REQUIRE_EQUAL(0, - system("/usr/bin/glacier2router --Glacier2.Client.Endpoints='tcp -p 14063' --Glacier2.PermissionsVerifier=Glacier2/NullPermissionsVerifier --daemon --pidfile " PID)); + system("/usr/bin/glacier2router --Glacier2.Client.Endpoints='tcp -p 14063' " + "--Glacier2.PermissionsVerifier=Glacier2/NullPermissionsVerifier --daemon --pidfile " PID)); sleep(1); - BOOST_SCOPE_EXIT(void) { + BOOST_SCOPE_EXIT(void) + { BOOST_REQUIRE_EQUAL(0, system("kill $(cat " PID ")")); std::filesystem::remove(PID); - } BOOST_SCOPE_EXIT_END; + } + BOOST_SCOPE_EXIT_END; { - MockDaemonHost daemon(testEndpoint, { - "--NetFSD.ConfigPath=" + (rootDir / "defaultDaemon.xml").string() - }); - FuseMockHost fuse(testEndpoint, { - (rootDir / "defaultFuse.xml:testvol").string(), - (rootDir / "test").string(), - "--Ice.Default.Router=Glacier2/router:tcp -h localhost -p 14063" - }); + MockDaemonHost daemon(testEndpoint, {"--NetFSD.ConfigPath=" + (rootDir / "defaultDaemon.xml").string()}); + FuseMockHost fuse(testEndpoint, + {(rootDir / "defaultFuse.xml:testvol").string(), (rootDir / "test").string(), + "--Ice.Default.Router=Glacier2/router:tcp -h localhost -p 14063"}); - struct statvfs s {}; - BOOST_REQUIRE_EQUAL(0, fuse.fuse->statfs("/", &s)); + struct statvfs s { + }; + BOOST_REQUIRE_EQUAL(0, fuse.fuse->statfs("/", &s)); } } - diff --git a/netfs/unittests/testLib.cpp b/netfs/unittests/testLib.cpp index 1e80590..b44ab37 100644 --- a/netfs/unittests/testLib.cpp +++ b/netfs/unittests/testLib.cpp @@ -1,11 +1,12 @@ #define BOOST_TEST_MODULE TestNetFSLib -#include <boost/test/unit_test.hpp> #include <boost/test/data/test_case.hpp> +#include <boost/test/unit_test.hpp> #include <entCache.impl.h> #include <lockHelpers.h> namespace std { - ostream & operator<<(ostream & strm, const ResolvedAs & r) + ostream & + operator<<(ostream & strm, const ResolvedAs & r) { strm << r; return strm; @@ -13,11 +14,7 @@ namespace std { } struct TestEntry { - TestEntry(int i, std::string n) : - id(i), - name(std::move(n)) - { - } + TestEntry(int i, std::string n) : id(i), name(std::move(n)) { } int id; std::string name; @@ -34,10 +31,10 @@ EntCache<TestEntry>::fillCache() const idcache->insert(std::make_shared<TestEntry>(3, "user3")); } -const auto GoodIds = boost::unit_test::data::make({ 1, 2, 3 }); -const auto BadIds = boost::unit_test::data::make({ 0, -1, 10 }); -const auto GoodNames = boost::unit_test::data::make({ "user1", "user2", "user3" }); -const auto BadNames = boost::unit_test::data::make({ "", "bad", "user4" }); +const auto GoodIds = boost::unit_test::data::make({1, 2, 3}); +const auto BadIds = boost::unit_test::data::make({0, -1, 10}); +const auto GoodNames = boost::unit_test::data::make({"user1", "user2", "user3"}); +const auto BadNames = boost::unit_test::data::make({"", "bad", "user4"}); BOOST_FIXTURE_TEST_SUITE(tec, TestEntCache); @@ -70,8 +67,8 @@ BOOST_DATA_TEST_CASE(foundname, GoodNames ^ GoodIds, name, id) BOOST_AUTO_TEST_SUITE_END(); class TestEntCacheWithFallback : public TestEntCache { - public: - TestEntCacheWithFallback() : TestEntCache({ 4, "fallback" }) { } +public: + TestEntCacheWithFallback() : TestEntCache({4, "fallback"}) { } }; BOOST_FIXTURE_TEST_SUITE(tecfb, TestEntCacheWithFallback); @@ -105,4 +102,3 @@ BOOST_DATA_TEST_CASE(foundname, GoodNames ^ GoodIds, name, id) } BOOST_AUTO_TEST_SUITE_END(); - |