mfm_dup.cpp

Makefile

@@ -140,7 +140,7 @@ INSTALLMAN1DIR ?= $(DESTDIR)$(MAN1DIR)
 
 
 .PHONY: all
-all: libfuse $(BUILDDIR)/mergerfs $(BUILDDIR)/fsck.mergerfs $(BUILDDIR)/mergerfs.collect-info
+all: libfuse $(BUILDDIR)/mergerfs $(BUILDDIR)/fsck.mergerfs $(BUILDDIR)/mergerfs.collect-info $(BUILDDIR)/mfm
 
 .PHONY: help
 help:
@@ -162,6 +162,9 @@ $(BUILDDIR)/fsck.mergerfs:
 $(BUILDDIR)/mergerfs.collect-info:
 	$(LN) -sf "mergerfs" $@
 
+$(BUILDDIR)/mfm:
+	$(LN) -sf "mergerfs" $@
+
 $(BUILDDIR)/tests: $(BUILDDIR)/mergerfs $(TESTS_OBJS)
 	$(CXX) $(CXXFLAGS) $(TESTS_FLAGS) $(INC_FLAGS) $(MFS_FLAGS) $(CPPFLAGS) $(TESTS_OBJS) -o $@ $(LDFLAGS) $(LDLIBS)
 
@@ -223,6 +226,7 @@ install-base: all
 	$(INSTALL) -v -m 0755 "$(BUILDDIR)/mergerfs" "$(INSTALLBINDIR)/mergerfs"
 	$(LN) -fs "mergerfs" "${INSTALLBINDIR}/fsck.mergerfs"
 	$(LN) -fs "mergerfs" "${INSTALLBINDIR}/mergerfs.collect-info"
+	$(LN) -fs "mergerfs" "${INSTALLBINDIR}/mfm"
 
 .PHONY: install-mount-tools
 install-mount-tools: install-base

src/fs_clonepath.cpp

@@ -27,10 +27,11 @@
 #include "fs_xattr.hpp"
 #include "ugid.hpp"
 
+#include <filesystem>
 #include <string>
 
 using std::string;
-
+namespace stdfs = std::filesystem;
 
 static
 bool
@@ -65,13 +66,18 @@ fs::clonepath(const string &srcpath_,
   struct stat st;
   string      dstpath;
   string      srcpath;
-  string      dirname;
+  stdfs::path dirname;
+  stdfs::path relpath;
 
   if((relpath_ == NULL) || (relpath_[0] == '\0'))
     return 0;
 
-  dirname = fs::path::dirname(relpath_);
-  if(dirname != "/")
+  relpath = relpath_;
+  if(relpath_[0] != '/')
+    relpath = "/" / relpath;
+
+  dirname = relpath.parent_path();
+  if(dirname != dirname.root_path())
     {
       rv = fs::clonepath(srcpath_,dstpath_,dirname,return_metadata_errors_);
       if(rv < 0)

src/mergerfs.cpp

@@ -17,6 +17,7 @@
 #include "mergerfs.hpp"
 #include "mergerfs_fsck.hpp"
 #include "mergerfs_collect_info.hpp"
+#include "mfm.hpp"
 
 #include "fs_path.hpp"
 #include "fs_readahead.hpp"
@@ -373,6 +374,8 @@ _pick_app_and_run(int    argc_,
     return mergerfs::fsck::main(argc_,argv_);
   if(appname == "mergerfs.collect-info")
     return mergerfs::collect_info::main(argc_,argv_);
+  if(appname == "mfm")
+    return mfm::main(argc_,argv_);
 
   return l::main(argc_,argv_);
 }

src/mfm.cpp

@@ -0,0 +1,86 @@
+#include "mfm.hpp"
+
+#include "mfm_options.hpp"
+
+#include "CLI11.hpp"
+
+static
+void
+_setup_argparser_dup(CLI::App       &app_,
+                     mfm::Opts::Dup &opts_)
+{
+  CLI::App *subcmd;
+
+  subcmd = app_.add_subcommand("dup",
+                               "duplicate files");
+  subcmd->add_option("path",opts_.paths)
+    ->description("")
+    ->type_name("PATH")
+    ->check(CLI::ExistingPath)
+    ->required();
+
+  auto func = std::bind(mfm::dup,std::cref(opts_));
+
+  subcmd->callback(func);
+}
+
+static
+void
+_setup_argparser_watch(CLI::App         &app_,
+                       mfm::Opts::Watch &opts_)
+{
+
+}
+
+static
+void
+_setup_argparser_migrate(CLI::App           &app_,
+                         mfm::Opts::Migrate &opts_)
+{
+
+}
+
+static
+void
+_setup_argparser_rebalance(CLI::App             &app_,
+                           mfm::Opts::Rebalance &opts_)
+{
+
+}
+
+static
+void
+_setup_argparser(CLI::App  &app_,
+                 mfm::Opts &opts_)
+{
+  _setup_argparser_dup(app_,opts_.dup);
+  _setup_argparser_migrate(app_,opts_.migrate);
+  _setup_argparser_rebalance(app_,opts_.rebalance);
+  _setup_argparser_watch(app_,opts_.watch);
+}
+
+#include "fmt/core.h"
+
+int
+mfm::main(int    argc_,
+          char **argv_)
+{
+  CLI::App app;
+  mfm::Opts opts;
+
+  app.description("mfm: mergerfs filesystem manager");
+  app.name("USAGE:: mfm");
+
+  ::_setup_argparser(app,opts);
+
+  try
+    {
+      app.parse(argc_,argv_);
+    }
+  catch(const CLI::ParseError &e_)
+    {
+      return app.exit(e_);
+    }
+
+  return 0;
+}

src/mfm.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "mfm_options.hpp"
+
+namespace mfm
+{
+  int main(int    argc,
+           char **argv);
+
+  void dup(const Opts::Dup &dup);
+}

src/mfm_dup.cpp

@@ -0,0 +1,84 @@
+#include "mfm_options.hpp"
+
+#include "str.hpp"
+#include "fs_clonepath.hpp"
+#include "fs_copyfile.hpp"
+
+#include "fmt/core.h"
+
+#include <filesystem>
+
+
+namespace stdfs = std::filesystem;
+
+namespace mfm
+{
+  void dup(const Opts::Dup &opts);
+}
+
+void
+mfm::dup(const Opts::Dup &opts_)
+{
+  std::vector<std::filesystem::path> srcpaths;
+
+  // TODO: expand if mergerfs mount
+  srcpaths = opts_.paths;
+
+  for(const auto &srcpath : srcpaths)
+    {
+      if(stdfs::is_regular_file(srcpath))
+        {
+        }
+      else if(stdfs::is_directory(srcpath))
+        {
+          auto dir_opts = (stdfs::directory_options::follow_directory_symlink |
+                           stdfs::directory_options::skip_permission_denied);
+
+          for(const stdfs::directory_entry &de :
+                stdfs::recursive_directory_iterator(srcpath,dir_opts))
+            {
+              if(!str::startswith(de.path().filename().string(),".dup_"))
+                continue;
+
+              for(const auto &de :
+                    stdfs::recursive_directory_iterator(de.path().parent_path()))
+                {
+                  if(!de.is_regular_file())
+                    continue;
+
+                  auto relpath = "/" / stdfs::relative(de.path(),srcpath);
+
+                  for(const auto &dstpath : srcpaths)
+                    {
+                      if(dstpath == srcpath)
+                        continue;
+
+                      auto srcfullpath = srcpath / relpath.relative_path();
+                      auto dstfullpath = srcpath / relpath.relative_path();
+
+                      if(stdfs::exists(dstfullpath))
+                        continue;
+
+                      fmt::println("copy {} to {} : {} : {}",
+                                   srcpath.string(),
+                                   dstpath.string(),
+                                   relpath.parent_path().string(),
+                                   relpath.filename().string());
+
+                      fs::clonepath(srcpath,
+                                    dstpath,
+                                    relpath.parent_path());
+                      fs::copyfile(srcpath / relpath.relative_path(),
+                                   dstpath / relpath.relative_path(),
+                                   {.cleanup_failure=false});
+                    }
+                }
+            }
+        }
+      else
+        {
+          //throw std::runtime_error("invalid file type");
+          fmt::println("invalid file type: {}",srcpath.string());
+        }
+    }
+}

src/mfm_options.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "int_types.h"
+
+#include <filesystem>
+#include <string>
+#include <vector>
+
+namespace mfm
+{
+  struct Opts
+  {
+    struct Dup
+    {
+      std::vector<std::filesystem::path> paths;
+    } dup;
+
+    struct Watch
+    {
+      std::filesystem::path path;
+    } watch;
+
+    struct Migrate
+    {
+      std::vector<std::filesystem::path> src;
+      std::vector<std::filesystem::path> dst;
+    } migrate;
+
+    struct Rebalance
+    {
+      std::vector<std::filesystem::path> dirpaths;
+    } rebalance;
+  };
+};