permissioner

@@ -103,6 +103,14 @@ Syntax:

       * `<niceness value>`: Linux niceness value for daemon process,

                             `19` for nicest (lowest CPU priority)

       * `idle`: set I/O priority class to idle

+   * sleep time after each file: `sleepTime <seconds>`

+      * range 0 - 1 s, default 1e-6 s

+   * wait time factor: `waitFactor <floating-point factor>`

+      * how long to wait after each tree traversal relative to the duration of

+        the traversal

+      * range 0 - 1000, default 10

+   * additional wait time after each tree traversal: `waitTime <seconds>`

+      * range 0 - 3600 s, default 1 s

    * owership and permission configuration:

      `tree <user> <group> <permissions> <directory>`

       * `<user>`: User name to set as user/owner, `-` to not change the user/owner.

@@ -3,6 +3,7 @@ add_library(

   STATIC

   include/permissioner/Callback.h

   include/permissioner/Config.h

+  include/permissioner/Float.h

   include/permissioner/Group.h

   include/permissioner/Nice.h

   include/permissioner/Permissions.h

@@ -11,6 +12,7 @@ add_library(

   include/permissioner/User.h

   src/Callback.cpp

   src/Config.cpp

+  src/Float.cpp

   src/Group.cpp

   src/Nice.cpp

   src/Permissions.cpp

@@ -8,6 +8,7 @@

 #define CONFIG_H

 #include <permissioner/Callback.h>

+#include <permissioner/Float.h>

 #include <permissioner/Nice.h>

 #include <permissioner/Tree.h>

@@ -18,6 +19,8 @@

 /// configuration file

 class Config {

 public:

+  Config();

+

   /**

    * @brief parse configuration file

    * @param[in] configFileName name of configuation file

@@ -28,6 +31,15 @@ public:

   /// return nice settings

   Nice const & getNice() const;

+  /// return sleep time setting

+  Float const & getSleepTime() const;

+

+  /// return wait factor setting

+  Float const & getWaitFactor() const;

+

+  /// return wait time setting

+  Float const & getWaitTime() const;

+

   /// return trees

   TreeMap const & getTrees() const;

@@ -40,6 +52,9 @@ public:

 protected:

   Nice nice;

+  Float sleepTime;

+  Float waitFactor;

+  Float waitTime;

   TreeMap trees;

 };

@@ -0,0 +1,41 @@

+/**

+ * Permissioner: set file ownerships and permissions

+ * Copyright 2020: Stefan Schuermans, Aachen, Germany <stefan@schuermans.info>

+ * Copyleft: GNU GENERAL PUBLIC LICENSE version 3 (see LICENSE)

+ */

+

+#ifndef FLOAT_H

+#define FLOAT_H

+

+#include <string>

+

+/// a floating point number in the settings

+class Float {

+public:

+  /**

+   * @brief initialize floating-point setting

+   * @param[in] name name of value for error messages

+   * @param[in] defVal default value

+   * @param[in] minVal minimum value

+   * @param[in] maxVal maximum value

+   */

+  Float(std::string const &name, float minVal, float maxVal, float defVal);

+

+  /**

+   * @brief parse floating-point value parameter

+   * @param[in] parmStr parameter string

+   * @throws std::exception if something goes wrong

+   */

+  void parseParams(std::string const &paramStr);

+

+  /// return floating-point value

+  float get() const;

+

+protected:

+  std::string name; ///< name for error messages

+  float minVal;     ///< minimum value

+  float maxVal;     ///< maximum value

+  float val;        ///< configured value

+};

+

+#endif // #ifndef FLOAT_H

@@ -42,6 +42,27 @@ public:

    */

   static int str2intRange(std::string const &str, int minVal, int maxVal,

                           std::string const &name);

+

+  /**

+   * @brief convert a string to a floating-point value

+   * @param[in] str string on which to operate

+   * @param[in] name filed name for exception

+   * @return floating-point value

+   * @throws std::exception if something goes wrong

+   */

+  static float str2float(std::string const &str, std::string const &name);

+

+  /**

+   * @brief convert a string to a floating-point value and check range

+   * @param[in] str string on which to operate

+   * @param[in] minVal minium value

+   * @param[in] maxVal maxium value

+   * @param[in] name filed name for exception

+   * @return floating-point value

+   * @throws std::exception if something goes wrong

+   */

+  static float str2floatRange(std::string const &str, float minVal,

+                              float maxVal, std::string const &name);

 };

 #endif // #ifndef STRING_UTILS_H

@@ -7,6 +7,7 @@

 #include <permissioner/Config.h>

 #include <permissioner/Callback.h>

+#include <permissioner/Float.h>

 #include <permissioner/StringUtils.h>

 #include <permissioner/Tree.h>

@@ -17,6 +18,11 @@

 #include <stdexcept>

 #include <string>

+Config::Config()

+    : sleepTime("sleepTime", 0.0f, 1.0f, 1.0e-6f),

+      waitFactor("waitFactor", 0.0f, 1.0e3f, 10.0f),

+      waitTime("waitTime", 0.0f, 3.6e3f, 1.0f) {}

+

 void Config::parseFile(std::string const &configFileName) {

   std::ifstream configFile(configFileName, std::ios::in);

   if (!configFile.is_open()) {

@@ -41,6 +47,18 @@ void Config::parseFile(std::string const &configFileName) {

       nice.parseParams(line.substr(pos));

       continue;

     }

+    if (typeStr == "sleepTime") {

+      sleepTime.parseParams(line.substr(pos));

+      continue;

+    }

+    if (typeStr == "waitFactor") {

+      waitFactor.parseParams(line.substr(pos));

+      continue;

+    }

+    if (typeStr == "waitTime") {

+      waitTime.parseParams(line.substr(pos));

+      continue;

+    }

     if (typeStr == "tree") {

       Tree tree;

       tree.parseParams(line.substr(pos));

@@ -54,13 +72,15 @@ void Config::parseFile(std::string const &configFileName) {

   }

 }

-Nice const & Config::getNice() const {

-  return nice;

-}

+Nice const &Config::getNice() const { return nice; }

-TreeMap const & Config::getTrees() const {

-  return trees;

-}

+Float const &Config::getSleepTime() const { return sleepTime; }

+

+Float const &Config::getWaitFactor() const { return waitFactor; }

+

+Float const &Config::getWaitTime() const { return waitTime; }

+

+TreeMap const &Config::getTrees() const { return trees; }

 bool Config::setPermissions(Callback &callback) const {

   for (auto const &path_tree : trees) {

@@ -0,0 +1,31 @@

+/**

+ * Permissioner: set file ownerships and permissions

+ * Copyright 2020: Stefan Schuermans, Aachen, Germany <stefan@schuermans.info>

+ * Copyleft: GNU GENERAL PUBLIC LICENSE version 3 (see LICENSE)

+ */

+

+#include <permissioner/Float.h>

+

+#include <permissioner/StringUtils.h>

+

+#include <sstream>

+#include <stdexcept>

+#include <string>

+

+Float::Float(std::string const &name, float minVal, float maxVal, float defVal)

+    : name(name), minVal(minVal), maxVal(maxVal), val(defVal) {}

+

+void Float::parseParams(std::string const &paramStr) {

+  // format of paramStr is: <floating-point-value>

+  std::string valStr;

+  std::string::size_type pos = 0;

+  StringUtils::getNextField(paramStr, pos, valStr, name);

+  if (pos < paramStr.length()) {

+    std::stringstream msg;

+    msg << "too many fields for \"" << name << "\" in \"" << paramStr << "\"";

+    throw std::runtime_error(msg.str());

+  }

+  val = StringUtils::str2floatRange(valStr, minVal, maxVal, name);

+}

+

+float Float::get() const { return val; }

@@ -58,3 +58,28 @@ int StringUtils::str2intRange(std::string const &str, int minVal, int maxVal,

   }

   return val;

 }

+

+float StringUtils::str2float(std::string const &str, std::string const &name) {

+  char const *c_str = str.c_str();

+  char *end;

+  float val = strtof(c_str, &end);

+  if (end == c_str || *end != 0) {

+    std::stringstream msg;

+    msg << "invalid floating-point value \"" << str << "\" for <" << name

+        << "> field";

+    throw std::runtime_error(msg.str());

+  }

+  return val;

+}

+

+float StringUtils::str2floatRange(std::string const &str, float minVal,

+                                  float maxVal, std::string const &name) {

+  float val = str2float(str, name);

+  if (val < minVal || val > maxVal) {

+    std::stringstream msg;

+    msg << "value " << val << " of <" << name << "> field out of range "

+        << minVal << " - " << maxVal;

+    throw std::runtime_error(msg.str());

+  }

+  return val;

+}

@@ -18,20 +18,24 @@

 class DaemonCallback : public Callback {

 public:

   DaemonCallback() : go_on(true) {}

-  bool callback() { return go_on; }

+  bool callback();

+  std::chrono::duration<float, std::ratio<1>> sleepTime;

+  template <class Rep, class Period>

+  bool iterativeSleep(std::chrono::duration<Rep, Period> duration) const;

   bool go_on;

 };

-DaemonCallback daemonCallback;

-

-void sighandler(int) { daemonCallback.go_on = false; }

+bool DaemonCallback::callback() {

+  iterativeSleep(sleepTime);

+  return go_on;

+}

 // iterative sleep, watching go_on, returns whether sleep completed

 template <class Rep, class Period>

-bool iterativeSleep(std::chrono::duration<Rep, Period> duration,

-                    DaemonCallback &daemonCallback) {

-  std::chrono::duration<int, std::milli> zero(0), step(100);

-  while (duration > zero && daemonCallback.go_on) {

+bool DaemonCallback::iterativeSleep(

+    std::chrono::duration<Rep, Period> duration) const {

+  const std::chrono::duration<int, std::milli> zero(0), step(100);

+  while (duration > zero && go_on) {

     if (duration >= step) {

       std::this_thread::sleep_for(step);

       duration -= step;

@@ -43,6 +47,10 @@ bool iterativeSleep(std::chrono::duration<Rep, Period> duration,

   return duration <= zero;

 }

+DaemonCallback daemonCallback;

+

+void sighandler(int) { daemonCallback.go_on = false; }

+

 int main(int argc, char const **argv) {

   if (argc != 2) {

     std::cerr << "usage: " << argv[0] << " <config file>" << std::endl;

@@ -59,6 +67,13 @@ int main(int argc, char const **argv) {

     return EXIT_FAILURE;

   }

+  // get timing from config

+  std::chrono::duration<float, std::ratio<1>> sleepTime(

+      config.getSleepTime().get());

+  float waitFactor = config.getWaitFactor().get();

+  std::chrono::duration<float, std::ratio<1>> waitTime(

+      config.getWaitTime().get());

+

   // catch signals to exit properly on Ctrl-C and so on

   signal(SIGINT, sighandler);

   signal(SIGPIPE, sighandler);

@@ -70,6 +85,9 @@ int main(int argc, char const **argv) {

   // set nicecess of process

   config.getNice().apply();

+  // set sleep time after each file in daemon callback

+  daemonCallback.sleepTime = sleepTime;

+

   // continuously set ownership and permissions

   int ret = EXIT_SUCCESS;

   while (daemonCallback.go_on) {

@@ -92,10 +110,8 @@ int main(int argc, char const **argv) {

     std::cout << "permissionerd (" << configFileName << "): took "

               << duration.count() << " s" << std::endl;

-    // sleep 10 times as long as the work took plus one second

-    auto sleep_time =

-        10 * duration + std::chrono::duration<int, std::ratio<1>>(1);

-    if (! iterativeSleep(sleep_time, daemonCallback)) {

+    // wait after tree traversal

+    if (!daemonCallback.iterativeSleep(waitFactor * duration + waitTime)) {

       break;

     }

@@ -0,0 +1,3 @@

+sleepTime 42.42e-3

+waitFactor 5.5

+waitTime 23.23

@@ -34,6 +34,25 @@ int testEmpty() {

     ret = EXIT_FAILURE;

   }

+  float sleepTime = config.getSleepTime().get();

+  if (sleepTime != 1.0e-6f) {

+    std::cerr << "unexpected sleepTime " << sleepTime << ", expected "

+              << 1.0e-6f << std::endl;

+    ret = EXIT_FAILURE;

+  }

+  float waitFactor = config.getWaitFactor().get();

+  if (waitFactor != 10.0f) {

+    std::cerr << "unexpected waitFactor " << waitFactor << ", expected "

+              << 10.0f << std::endl;

+    ret = EXIT_FAILURE;

+  }

+  float waitTime = config.getWaitTime().get();

+  if (waitTime != 1.0f) {

+    std::cerr << "unexpected waitTime " << waitTime << ", expected " << 1.0f

+              << std::endl;

+    ret = EXIT_FAILURE;

+  }

+

   TreeMap const &treeMap = config.getTrees();

   if (treeMap.size() != 0) {

     std::cerr << "unexpected trees: " << treeMap.size() << std::endl;

@@ -103,6 +122,34 @@ int testNice() {

   return ret;

 }

+int testSleepWait() {

+  Config config;

+  config.parseFile("sleep_wait.cfg");

+

+  int ret = EXIT_SUCCESS;

+

+  float sleepTime = config.getSleepTime().get();

+  if (sleepTime != 42.42e-3f) {

+    std::cerr << "unexpected sleepTime " << sleepTime << ", expected "

+              << 42.42e-3f << std::endl;

+    ret = EXIT_FAILURE;

+  }

+  float waitFactor = config.getWaitFactor().get();

+  if (waitFactor != 5.5f) {

+    std::cerr << "unexpected waitFactor " << waitFactor << ", expected "

+              << 5.5f << std::endl;

+    ret = EXIT_FAILURE;

+  }

+  float waitTime = config.getWaitTime().get();

+  if (waitTime != 23.23f) {

+    std::cerr << "unexpected waitTime " << waitTime << ", expected " << 23.23f

+              << std::endl;

+    ret = EXIT_FAILURE;

+  }

+

+  return ret;

+}

+

 bool checkTrees(TreeMap const &treeMap, std::string const &rel_path,

                 boost::optional<std::string> user,

                 boost::optional<std::string> group, mode_t setMode,

@@ -195,6 +242,7 @@ int main() {

   int ret = EXIT_SUCCESS;

   merge_ret(ret, testEmpty());

   merge_ret(ret, testNice());

+  merge_ret(ret, testSleepWait());

   merge_ret(ret, testTrees());

   return ret;

 }