permissioner

@@ -93,12 +93,18 @@ The configuration file lists directory trees and the ownerships and permissions

 to set for them. If some of the specified trees are nested within each other,

 the nested tree(s) is/are excluded from the containing tree(s).

-The syntax of the config file is line-based. Each line defines a directory tree

-and the ownerships and permissions.

+The syntax of the config file is line-based. Each line defines a setting or a

+directory tree and the ownerships and permissions for it.

 Syntax:

-* Each line: `tree <user> <group> <permissions> <directory>`

+   * process nice-ness (only for `permissionerd`, ignored by `permissonerc`)

+     `nice [<niceness value>] [idle]

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

+                            `19` for nicest (lowest CPU priority)

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

+   * owership and permission configuration:

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

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

       * `<group>`: Group name to set as group, `-` to not change the group.

       * `<permissions>`: Comma-separated list of permission settings.

@@ -3,12 +3,14 @@ add_library(

   STATIC

   include/permissioner/Config.h

   include/permissioner/Group.h

+  include/permissioner/Nice.h

   include/permissioner/Permissions.h

   include/permissioner/StringUtils.h

   include/permissioner/Tree.h

   include/permissioner/User.h

   src/Config.cpp

   src/Group.cpp

+  src/Nice.cpp

   src/Permissions.cpp

   src/StringUtils.cpp

   src/Tree.cpp

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

 #ifndef CONFIG_H

 #define CONFIG_H

+#include <permissioner/Nice.h>

 #include <permissioner/Tree.h>

 #include <boost/filesystem.hpp>

@@ -23,6 +24,9 @@ public:

    */

   void parseFile(std::string const &configFileName);

+  /// return nice settings

+  Nice const & getNice() const;

+

   /// return trees

   TreeMap const & getTrees() const;

@@ -32,6 +36,7 @@ public:

   void setPermissions() const;

 protected:

+  Nice nice;

   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 NICE_H

+#define NICE_H

+

+#include <boost/optional.hpp>

+#include <string>

+

+/// nice (CPU and I/O) priority settings

+class Nice {

+public:

+  Nice();

+

+  /**

+   * @brief parse nice parameters

+   * @param[in] parmStr parameter string

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

+   */

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

+

+  /// return niceness level

+  boost::optional<int> getNice() const;

+

+  /// return whether using I/O idle class

+  bool getIoIdle() const;

+

+  /**

+   * @brief set CPU and I/O priority of process

+   */

+  void apply() const;

+

+protected:

+  boost::optional<int> nice;

+  bool ioIdle;

+};

+

+#endif // #ifndef NICE_H

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

    */

   static void getNextField(std::string const &str, std::string::size_type &pos,

                            std::string &field, std::string const &name);

+

+  /**

+   * @brief convert a string to a long integer

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

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

+   * @return integer value

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

+   */

+  static long str2long(std::string const &str, std::string const &name);

+

+  /**

+   * @brief convert a string to an integer 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 integer value

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

+   */

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

+                          std::string const &name);

 };

 #endif // #ifndef STRING_UTILS_H

@@ -36,6 +36,10 @@ void Config::parseFile(std::string const &configFileName) {

       continue; // comment line -> ignore

     }

     // actual configuration lines

+    if (typeStr == "nice") {

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

+      continue;

+    }

     if (typeStr == "tree") {

       Tree tree;

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

@@ -49,6 +53,10 @@ void Config::parseFile(std::string const &configFileName) {

   }

 }

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

+  return nice;

+}

+

 TreeMap const & Config::getTrees() const {

   return trees;

 }

@@ -0,0 +1,64 @@

+/**

+ * 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/Nice.h>

+

+#include <permissioner/StringUtils.h>

+

+#include <boost/optional.hpp>

+#include <string>

+#include <sys/time.h>

+#include <sys/resource.h>

+#include <sys/syscall.h>

+

+#define IOPRIO_CLASS_SHIFT (13)

+#define IOPRIO_PRIO_VALUE(class_, data) (((class_) << IOPRIO_CLASS_SHIFT) | data)

+enum {

+  IOPRIO_WHO_PROCESS = 1,

+  IOPRIO_WHO_PGRP,

+  IOPRIO_WHO_USER,

+};

+enum {

+  IOPRIO_CLASS_NONE,

+  IOPRIO_CLASS_RT,

+  IOPRIO_CLASS_BE,

+  IOPRIO_CLASS_IDLE,

+};

+

+Nice::Nice() : ioIdle(false) {}

+

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

+  // format of paramStr is: <nice prm 1> [" " <nice prm 2>]

+  // <nice prm> may be <nice value: int> or "idle"

+  std::string niceStr;

+

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

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

+    StringUtils::getNextField(paramStr, pos, niceStr, "nice prm");

+    if (niceStr == "idle") {

+      ioIdle = true;

+      continue;

+    }

+    nice = StringUtils::str2intRange(niceStr, -20, 19, "nice value");

+  }

+}

+

+boost::optional<int> Nice::getNice() const { return nice; }

+

+bool Nice::getIoIdle() const { return ioIdle; }

+

+void Nice::apply() const {

+  // set CPU priority

+  if (nice.is_initialized()) {

+    setpriority(PRIO_PROCESS, 0, nice.get());

+  }

+

+  // set idle I/O priority

+  if (ioIdle) {

+    syscall(SYS_ioprio_set, IOPRIO_WHO_PROCESS, 0,

+            IOPRIO_PRIO_VALUE(IOPRIO_CLASS_IDLE, 0));

+  }

+}

@@ -6,8 +6,9 @@

 #include <permissioner/StringUtils.h>

-#include <stdexcept>

+#include <cstdlib>

 #include <sstream>

+#include <stdexcept>

 #include <string>

 void StringUtils::getNextField(std::string const &str,

@@ -33,3 +34,27 @@ void StringUtils::getNextField(std::string const &str,

     pos = str.length();

   }

 }

+

+long StringUtils::str2long(std::string const &str, std::string const &name) {

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

+  char *end;

+  long val = strtol(c_str, &end, 0);

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

+    std::stringstream msg;

+    msg << "invalid integer value \"" << str << "\" for <" << name << "> field";

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

+  }

+  return val;

+}

+

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

+                              std::string const &name) {

+  long val = str2long(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;

+}

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

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

             << std::endl;

+  // set nicecess of process

+  config.getNice().apply();

+

   // continuously set ownership and permissions

   int ret = EXIT_SUCCESS;

   while (go_on) {

@@ -13,7 +13,7 @@ add_test(

   NAME

   testConfig

   COMMAND

-  ${CMAKE_CURRENT_BINARY_DIR}/testConfig test.cfg

+  ${CMAKE_CURRENT_BINARY_DIR}/testConfig

   WORKING_DIRECTORY

   ${CMAKE_CURRENT_SOURCE_DIR}

 )

@@ -0,0 +1 @@

+# comment

@@ -0,0 +1 @@

+nice idle

@@ -0,0 +1 @@

+nice 19

@@ -0,0 +1 @@

+nice 19 idle

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

 #include <permissioner/Config.h>

 #include <permissioner/Group.h>

 #include <permissioner/Permissions.h>

-#include <permissioner/User.h>

 #include <permissioner/Tree.h>

+#include <permissioner/User.h>

 #include <boost/filesystem.hpp>

 #include <boost/optional.hpp>

@@ -18,11 +18,95 @@

 #include <iostream>

 #include <string>

-bool check(TreeMap const &treeMap, std::string const &rel_path,

+int testEmpty() {

+  Config config;

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

+

+  int ret = EXIT_SUCCESS;

+

+  Nice const &nice = config.getNice();

+  if (nice.getNice().is_initialized()) {

+    std::cerr << "unexpected nice value: " << nice.getNice().get() << std::endl;

+    ret = EXIT_FAILURE;

+  }

+  if (nice.getIoIdle()) {

+    std::cerr << "unexpected I/O idle" << std::endl;

+    ret = EXIT_FAILURE;

+  }

+

+  TreeMap const &treeMap = config.getTrees();

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

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

+    ret = EXIT_FAILURE;

+  }

+

+  return ret;

+}

+

+int testNice() {

+  int ret = EXIT_SUCCESS;

+

+  {

+    Config config;

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

+

+    Nice const &nice = config.getNice();

+    if (!nice.getNice().is_initialized()) {

+      std::cerr << "expected nice value, but got none" << std::endl;

+      ret = EXIT_FAILURE;

+    } else {

+      if (nice.getNice().get() != 19) {

+        std::cerr << "unexpected nice value: " << nice.getNice().get()

+                  << ", expected 19" << std::endl;

+        ret = EXIT_FAILURE;

+      }

+    }

+    if (nice.getIoIdle()) {

+      std::cerr << "unexpected I/O idle" << std::endl;

+      ret = EXIT_FAILURE;

+    }

+  }

+

+  {

+    Config config;

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

+

+    Nice const &nice = config.getNice();

+    if (nice.getNice().is_initialized()) {

+      std::cerr << "unexpected nice value: " << nice.getNice().get()

+                << std::endl;

+      ret = EXIT_FAILURE;

+    }

+    if (!nice.getIoIdle()) {

+      std::cerr << "expected I/O idle, but did not get it" << std::endl;

+      ret = EXIT_FAILURE;

+    }

+  }

+

+  {

+    Config config;

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

+

+    Nice const &nice = config.getNice();

+    if (!nice.getNice().is_initialized()) {

+      std::cerr << "expected nice value, but got none" << std::endl;

+      ret = EXIT_FAILURE;

+    } else {

+      if (nice.getNice().get() != 19) {

+        std::cerr << "unexpected nice value: " << nice.getNice().get()

+                  << ", expected 19" << 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, mode_t setCondMode,

-           mode_t clearMode, mode_t clearCondMode) {

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

+                mode_t setCondMode, mode_t clearMode, mode_t clearCondMode) {

   std::string path = boost::filesystem::canonical(rel_path).string();

   TreeMap::const_iterator itTree = treeMap.find(path);

   if (itTree == treeMap.end()) {

@@ -50,41 +134,37 @@ bool check(TreeMap const &treeMap, std::string const &rel_path,

   }

   Permissions const &perms = tree.getPermissions();

   if (perms.getSet() != setMode) {

-    std::cerr << "tree map entry \"" << path

-              << "\": unexpected set mode "

-              << std::oct << perms.getSet() << " != " << setMode

-              << std::dec << std::endl;

+    std::cerr << "tree map entry \"" << path << "\": unexpected set mode "

+              << std::oct << perms.getSet() << " != " << setMode << std::dec

+              << std::endl;

     ret = false;

   }

   if (perms.getSetCond() != setCondMode) {

-    std::cerr << "tree map entry \"" << path

-              << "\": unexpected set cond mode "

+    std::cerr << "tree map entry \"" << path << "\": unexpected set cond mode "

               << std::oct << perms.getSetCond() << " != " << setCondMode

               << std::dec << std::endl;

     ret = false;

   }

   if (perms.getClear() != clearMode) {

-    std::cerr << "tree map entry \"" << path

-              << "\": unexpected clear mode "

-              << std::oct << perms.getClear() << " != " << clearMode

-              << std::dec << std::endl;

+    std::cerr << "tree map entry \"" << path << "\": unexpected clear mode "

+              << std::oct << perms.getClear() << " != " << clearMode << std::dec

+              << std::endl;

     ret = false;

   }

   if (perms.getClearCond() != clearCondMode) {

     std::cerr << "tree map entry \"" << path

-              << "\": unexpected clear cond mode "

-              << std::oct << perms.getClearCond() << " != " << clearCondMode

-              << std::dec << std::endl;

+              << "\": unexpected clear cond mode " << std::oct

+              << perms.getClearCond() << " != " << clearCondMode << std::dec

+              << std::endl;

     ret = false;

   }

   return ret;

 }

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

-  (void)argc;

+int testTrees() {

   Config config;

-  config.parseFile(argv[1]);

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

   int ret = EXIT_SUCCESS;

@@ -93,16 +173,28 @@ int main(int argc, char const **argv) {

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

     ret = EXIT_FAILURE;

   }

-  if (! check(treeMap, "some/dir", std::string("nobody"),

-                                   std::string("nogroup"),

-                                   0011, 0044, 0022, 000)) {

+  if (!checkTrees(treeMap, "some/dir", std::string("nobody"),

+                  std::string("nogroup"), 0011, 0044, 0022, 000)) {

     ret = EXIT_FAILURE;

   }

-  if (! check(treeMap, "some/other/dir", boost::none,

-                                         boost::none,

-                                         0777, 0000, 0000, 0000)) {

+  if (!checkTrees(treeMap, "some/other/dir", boost::none, boost::none, 0777,

+                  0000, 0000, 0000)) {

     ret = EXIT_FAILURE;

   }

   return ret;

 }

+

+void merge_ret(int &ret, int ret2) {

+  if (ret == EXIT_SUCCESS && ret2 != EXIT_SUCCESS) {

+    ret = ret2;

+  }

+}

+

+int main() {

+  int ret = EXIT_SUCCESS;

+  merge_ret(ret, testEmpty());

+  merge_ret(ret, testNice());

+  merge_ret(ret, testTrees());

+  return ret;

+}