fix long shutdown delay after Ctrl-C (bdbf09a) - permissioner · BlinkenArea

fix long shutdown delay after Ctrl-C

Stefan Schuermans commited on 2020-09-19 13:55:21
Showing 10 changed files, with 139 additions and 49 deletions.

libpermissioner/CMakeLists.txt 60e453d..9461227
libpermissioner/include/permissioner/Callback.h 0000000..3359a59
libpermissioner/include/permissioner/Config.h c13d8e3..9037276
libpermissioner/include/permissioner/Tree.h 1e799e6..89948f0
libpermissioner/src/Callback.cpp 0000000..c2a5853
libpermissioner/src/Config.cpp 650302f..f5a74f2
libpermissioner/src/Tree.cpp 84728d3..2b625ed
permissionerc/src/permissionerc.cpp 2c17a08..33f41ad
permissionerd/src/permissionerd.cpp 247b186..14ef349
tests/trees/testTrees.cpp e76a329..43c3052

@@ -1,6 +1,7 @@
 add_library(
   permissioner
   STATIC
+  include/permissioner/Callback.h
   include/permissioner/Config.h
   include/permissioner/Group.h
   include/permissioner/Nice.h
@@ -8,6 +9,7 @@ add_library(
   include/permissioner/StringUtils.h
   include/permissioner/Tree.h
   include/permissioner/User.h
+  src/Callback.cpp
   src/Config.cpp
   src/Group.cpp
   src/Nice.cpp

libpermissioner/include/permissioner/Callback.h

View file @ bdbf09a

...	...	@@ -0,0 +1,24 @@
	1	+/**
	2	+ * Permissioner: set file ownerships and permissions
	3	+ * Copyright 2020: Stefan Schuermans, Aachen, Germany <stefan@schuermans.info>
	4	+ * Copyleft: GNU GENERAL PUBLIC LICENSE version 3 (see LICENSE)
	5	+ */
	6	+
	7	+#ifndef CALLBACK_H
	8	+#define CALLBACK_H
	9	+
	10	+/// callback interface, called after each file
	11	+class Callback {
	12	+public:
	13	+ virtual ~Callback();
	14	+
	15	+ /**
	16	+ * @brief callback, called after each file
	17	+ * @return whether to continue (false means abort)
	18	+ *
	19	+ * This default implementation does nothing and returns true
	20	+ */
	21	+ virtual bool callback();
	22	+};
	23	+
	24	+#endif // #ifndef CALLBACK_H

libpermissioner/include/permissioner/Config.h

View file @ bdbf09a

@@ -7,6 +7,7 @@
 #ifndef CONFIG_H
 #define CONFIG_H
 
+#include <permissioner/Callback.h>
 #include <permissioner/Nice.h>
 #include <permissioner/Tree.h>
 
@@ -32,8 +33,10 @@ public:
 
   /**
    * @brief set owners and permissions of files in trees
+   * @param[in] callback callback object to call after each processed file
+   * @return whether traversal was completed (false means aborted)
    */
-  void setPermissions() const;
+  bool setPermissions(Callback &callback) const;
 
 protected:
   Nice nice;

libpermissioner/include/permissioner/Tree.h

View file @ bdbf09a

@@ -7,6 +7,7 @@
 #ifndef TREE_H
 #define TREE_H
 
+#include <permissioner/Callback.h>
 #include <permissioner/Group.h>
 #include <permissioner/Permissions.h>
 #include <permissioner/User.h>
@@ -43,23 +44,31 @@ public:
   /**
    * @brief set owners and permissions of files in tree
    * @param[in] exclude map of other trees that shall be excluded
+   * @param[in] callback callback object to call after each processed file
+   * @return whether traversal was completed (false means aborted)
    */
-  void setPermissions(TreeMap const &exclude) const;
+  bool setPermissions(TreeMap const &exclude, Callback &callback) const;
 
 protected:
   /**
    * @brief set owners and permissions of files in path and subtrees
    * @param[in] path path to top of directory tree for which to set owner/perms
    * @param[in] exclude map of other trees that shall be excluded
+   * @param[in] callback callback object to call after each processed file
+   * @return whether to continue (false means abort traversal)
    */
-  void setPermissionsInternal(boost::filesystem::path const &path,
-                              TreeMap const &exclude) const;
+  bool setPermissionsInternal(boost::filesystem::path const &path,
+                              TreeMap const &exclude,
+                              Callback &callback) const;
 
   /**
    * @brief set owners and permissions of one file or directory
    * @param[in] path path to file or directory
+   * @param[in] callback callback object to call after each processed file
+   * @return whether to continue (false means abort traversal)
    */
-  void setPermissionsOne(boost::filesystem::path const &path) const;
+  bool setPermissionsOne(boost::filesystem::path const &path,
+                         Callback &callback) const;
 
 protected:
   User user;

libpermissioner/src/Callback.cpp

View file @ bdbf09a

...	...	@@ -0,0 +1,11 @@
	1	+/**
	2	+ * Permissioner: set file ownerships and permissions
	3	+ * Copyright 2020: Stefan Schuermans, Aachen, Germany <stefan@schuermans.info>
	4	+ * Copyleft: GNU GENERAL PUBLIC LICENSE version 3 (see LICENSE)
	5	+ */
	6	+
	7	+#include <permissioner/Callback.h>
	8	+
	9	+Callback::~Callback() {}
	10	+
	11	+bool Callback::callback() { return true; }

libpermissioner/src/Config.cpp

View file @ bdbf09a

@@ -5,8 +5,9 @@
  */
 
 #include <permissioner/Config.h>
-#include <permissioner/StringUtils.h>
 
+#include <permissioner/Callback.h>
+#include <permissioner/StringUtils.h>
 #include <permissioner/Tree.h>
 
 #include <boost/filesystem.hpp>
@@ -61,9 +62,12 @@ TreeMap const & Config::getTrees() const {
   return trees;
 }
 
-void Config::setPermissions() const {
+bool Config::setPermissions(Callback &callback) const {
   for (auto const & path_tree : trees) {
     Tree const & tree = path_tree.second;
-    tree.setPermissions(trees); // exclude all other trees
+    if (! tree.setPermissions(trees, callback)) { // exclude all other trees
+      return false;
+    }
   }
+  return true;
 }

libpermissioner/src/Tree.cpp

View file @ bdbf09a

@@ -6,10 +6,11 @@
 
 #include <permissioner/Tree.h>
 
+#include <permissioner/Callback.h>
 #include <permissioner/Group.h>
 #include <permissioner/Permissions.h>
-#include <permissioner/User.h>
 #include <permissioner/StringUtils.h>
+#include <permissioner/User.h>
 
 #include <boost/filesystem.hpp>
 #include <sstream>
@@ -38,8 +39,8 @@ void Tree::parseParams(std::string const &paramStr) {
     user.parseUserName(userStr);
   } catch (std::exception const &e) {
     std::stringstream msg;
-    msg << "invalid <user> field \"" << userStr << "\" in \""
-        << paramStr << "\": " << e.what();
+    msg << "invalid <user> field \"" << userStr << "\" in \"" << paramStr
+        << "\": " << e.what();
     throw std::runtime_error(msg.str());
   }
 
@@ -47,8 +48,8 @@ void Tree::parseParams(std::string const &paramStr) {
     group.parseGroupName(groupStr);
   } catch (std::exception const &e) {
     std::stringstream msg;
-    msg << "invalid <group> field \"" << groupStr << "\" in \""
-        << paramStr << "\": " << e.what();
+    msg << "invalid <group> field \"" << groupStr << "\" in \"" << paramStr
+        << "\": " << e.what();
     throw std::runtime_error(msg.str());
   }
 
@@ -65,54 +66,57 @@ void Tree::parseParams(std::string const &paramStr) {
     root = boost::filesystem::canonical(rootStr);
   } catch (std::exception const &e) {
     std::stringstream msg;
-    msg << "invalid <root> field \"" << rootStr << "\" in \""
-        << paramStr << "\": " << e.what();
+    msg << "invalid <root> field \"" << rootStr << "\" in \"" << paramStr
+        << "\": " << e.what();
     throw std::runtime_error(msg.str());
   }
 }
 
-User const & Tree::getUser() const {
-  return user;
-}
+User const &Tree::getUser() const { return user; }
 
-Group const & Tree::getGroup() const {
-  return group;
-}
+Group const &Tree::getGroup() const { return group; }
 
-Permissions const & Tree::getPermissions() const {
-  return permissions;
-}
+Permissions const &Tree::getPermissions() const { return permissions; }
 
-boost::filesystem::path const & Tree::getRoot() const {
-  return root;
-}
+boost::filesystem::path const &Tree::getRoot() const { return root; }
 
-void Tree::setPermissions(TreeMap const &exclude) const {
-  setPermissionsInternal(root, exclude);
+bool Tree::setPermissions(TreeMap const &exclude,
+                          Callback &callback) const {
+  return setPermissionsInternal(root, exclude, callback);
 }
 
-void Tree::setPermissionsInternal(boost::filesystem::path const &path,
-                                  TreeMap const &exclude) const {
+bool Tree::setPermissionsInternal(boost::filesystem::path const &path,
+                                  TreeMap const &exclude,
+                                  Callback &callback) const {
   try {
     if (boost::filesystem::is_regular_file(path)) {
-      setPermissionsOne(path);
+      if (!setPermissionsOne(path, callback)) {
+        return false;
+      };
     } else if (boost::filesystem::is_directory(path)) {
-      setPermissionsOne(path);
+      if (!setPermissionsOne(path, callback)) {
+        return false;
+      };
       for (boost::filesystem::directory_entry entry :
            boost::filesystem::directory_iterator(path)) {
         if (exclude.find(entry) != exclude.end()) {
           continue; // other tree -> skip here
         }
-        setPermissionsInternal(entry, exclude); // recurse
+        // recurse
+        if (!setPermissionsInternal(entry, exclude, callback)) {
+          return false;
+        }
       }
     }
   } catch (boost::filesystem::filesystem_error const &e) {
     // ignore filesystem errors for now, as this runs in a daemon in background
     (void)e;
   }
+  return true;
 }
 
-void Tree::setPermissionsOne(boost::filesystem::path const &path) const {
+bool Tree::setPermissionsOne(boost::filesystem::path const &path,
+                             Callback &callback) const {
   // change permissions
   try {
     permissions.apply(path);
@@ -125,4 +129,7 @@ void Tree::setPermissionsOne(boost::filesystem::path const &path) const {
   int ret = lchown(path.string().c_str(), user.getUid(), group.getGid());
   // ignore error for now, as this runs in a daemon in background
   (void)ret;
+
+  // call callback and return whether to continue
+  return callback.callback();
 }

permissionerc/src/permissionerc.cpp

View file @ bdbf09a

@@ -4,6 +4,7 @@
  * Copyleft: GNU GENERAL PUBLIC LICENSE version 3 (see LICENSE)
  */
 
+#include <permissioner/Callback.h>
 #include <permissioner/Config.h>
 
 #include <cstdlib>
@@ -21,7 +22,8 @@ int main(int argc, char const **argv) {
   try {
     Config config;
     config.parseFile(configFileName);
-    config.setPermissions();
+    Callback callback;
+    config.setPermissions(callback);
   } catch (std::exception const &e) {
     std::cerr << "error: " << e.what() << std::endl;
     return EXIT_FAILURE;

permissionerd/src/permissionerd.cpp

View file @ bdbf09a

@@ -4,6 +4,7 @@
  * Copyleft: GNU GENERAL PUBLIC LICENSE version 3 (see LICENSE)
  */
 
+#include <permissioner/Callback.h>
 #include <permissioner/Config.h>
 
 #include <chrono>
@@ -14,10 +15,32 @@
 #include <string>
 #include <thread>
 
-static int go_on = 1;
+class DaemonCallback : public Callback {
+public:
+  DaemonCallback() : go_on(true) {}
+  bool callback() { return go_on; }
+  bool go_on;
+};
 
-void sighandler(int) {
-  go_on = 0;
+DaemonCallback daemonCallback;
+
+void sighandler(int) { daemonCallback.go_on = false; }
+
+// 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) {
+    if (duration >= step) {
+      std::this_thread::sleep_for(step);
+      duration -= step;
+    } else {
+      std::this_thread::sleep_for(duration);
+      duration = zero;
+    }
+  }
+  return duration <= zero;
 }
 
 int main(int argc, char const **argv) {
@@ -42,22 +65,23 @@ int main(int argc, char const **argv) {
   signal(SIGQUIT, sighandler);
   signal(SIGTERM, sighandler);
 
-  std::cout << "permissionerd (" << configFileName << ") starting"
-            << std::endl;
+  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) {
+  while (daemonCallback.go_on) {
 
-    // set owneship and permissions, measure time it takes
+    // set ownership and permissions, measure time it takes
     std::cout << "permissionerd (" << configFileName
               << "): setting ownership and permissions" << std::endl;
     auto begin = std::chrono::steady_clock::now();
     try {
-      config.setPermissions();
+      if (! config.setPermissions(daemonCallback)) {
+        break;
+      }
     } catch (std::exception const &e) {
       std::cerr << "error: " << e.what() << std::endl;
       ret = EXIT_FAILURE;
@@ -69,11 +93,13 @@ int main(int argc, char const **argv) {
               << 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);
-    std::this_thread::sleep_for(sleep_time);
+    auto sleep_time =
+        10 * duration + std::chrono::duration<int, std::ratio<1>>(1);
+    if (! iterativeSleep(sleep_time, daemonCallback)) {
+      break;
+    }
 
-  } // while (go_on)
+  } // while (daemonCallback.go_on)
 
   std::cout << "permissionerd (" << configFileName << ") shutting down"
             << std::endl;

tests/trees/testTrees.cpp

View file @ bdbf09a

@@ -4,6 +4,7 @@
  * Copyleft: GNU GENERAL PUBLIC LICENSE version 3 (see LICENSE)
  */
 
+#include <permissioner/Callback.h>
 #include <permissioner/Config.h>
 
 #include <boost/filesystem.hpp>
@@ -109,7 +110,8 @@ int main(int argc, char const **argv) {
   (void)argc;
   Config config;
   config.parseFile(argv[1]);
-  config.setPermissions();
+  Callback callback;
+  config.setPermissions(callback);
 
   int ret = EXIT_SUCCESS;
 


...	...	@@ -1,6 +1,7 @@
1	1	add_library(
2	2	permissioner
3	3	STATIC
	4	+ include/permissioner/Callback.h
4	5	include/permissioner/Config.h
5	6	include/permissioner/Group.h
6	7	include/permissioner/Nice.h
...	...	@@ -8,6 +9,7 @@ add_library(
8	9	include/permissioner/StringUtils.h
9	10	include/permissioner/Tree.h
10	11	include/permissioner/User.h
	12	+ src/Callback.cpp
11	13	src/Config.cpp
12	14	src/Group.cpp
13	15	src/Nice.cpp

...	...	@@ -7,6 +7,7 @@
7	7	#ifndef CONFIG_H
8	8	#define CONFIG_H
9	9
	10	+#include <permissioner/Callback.h>
10	11	#include <permissioner/Nice.h>
11	12	#include <permissioner/Tree.h>
12	13
...	...	@@ -32,8 +33,10 @@ public:
32	33
33	34	/**
34	35	* @brief set owners and permissions of files in trees
	36	+ * @param[in] callback callback object to call after each processed file
	37	+ * @return whether traversal was completed (false means aborted)
35	38	*/
36		- void setPermissions() const;
	39	+ bool setPermissions(Callback &callback) const;
37	40
38	41	protected:
39	42	Nice nice;

...	...	@@ -7,6 +7,7 @@
7	7	#ifndef TREE_H
8	8	#define TREE_H
9	9
	10	+#include <permissioner/Callback.h>
10	11	#include <permissioner/Group.h>
11	12	#include <permissioner/Permissions.h>
12	13	#include <permissioner/User.h>
...	...	@@ -43,23 +44,31 @@ public:
43	44	/**
44	45	* @brief set owners and permissions of files in tree
45	46	* @param[in] exclude map of other trees that shall be excluded
	47	+ * @param[in] callback callback object to call after each processed file
	48	+ * @return whether traversal was completed (false means aborted)
46	49	*/
47		- void setPermissions(TreeMap const &exclude) const;
	50	+ bool setPermissions(TreeMap const &exclude, Callback &callback) const;
48	51
49	52	protected:
50	53	/**
51	54	* @brief set owners and permissions of files in path and subtrees
52	55	* @param[in] path path to top of directory tree for which to set owner/perms
53	56	* @param[in] exclude map of other trees that shall be excluded
	57	+ * @param[in] callback callback object to call after each processed file
	58	+ * @return whether to continue (false means abort traversal)
54	59	*/
55		- void setPermissionsInternal(boost::filesystem::path const &path,
56		- TreeMap const &exclude) const;
	60	+ bool setPermissionsInternal(boost::filesystem::path const &path,
	61	+ TreeMap const &exclude,
	62	+ Callback &callback) const;
57	63
58	64	/**
59	65	* @brief set owners and permissions of one file or directory
60	66	* @param[in] path path to file or directory
	67	+ * @param[in] callback callback object to call after each processed file
	68	+ * @return whether to continue (false means abort traversal)
61	69	*/
62		- void setPermissionsOne(boost::filesystem::path const &path) const;
	70	+ bool setPermissionsOne(boost::filesystem::path const &path,
	71	+ Callback &callback) const;
63	72
64	73	protected:
65	74	User user;

...	...	@@ -5,8 +5,9 @@
5	5	*/
6	6
7	7	#include <permissioner/Config.h>
8		-#include <permissioner/StringUtils.h>
9	8
	9	+#include <permissioner/Callback.h>
	10	+#include <permissioner/StringUtils.h>
10	11	#include <permissioner/Tree.h>
11	12
12	13	#include <boost/filesystem.hpp>
...	...	@@ -61,9 +62,12 @@ TreeMap const & Config::getTrees() const {
61	62	return trees;
62	63	}
63	64
64		-void Config::setPermissions() const {
	65	+bool Config::setPermissions(Callback &callback) const {
65	66	for (auto const & path_tree : trees) {
66	67	Tree const & tree = path_tree.second;
67		- tree.setPermissions(trees); // exclude all other trees
	68	+ if (! tree.setPermissions(trees, callback)) { // exclude all other trees
	69	+ return false;
	70	+ }
68	71	}
	72	+ return true;
69	73	}

...	...	@@ -6,10 +6,11 @@
6	6
7	7	#include <permissioner/Tree.h>
8	8
	9	+#include <permissioner/Callback.h>
9	10	#include <permissioner/Group.h>
10	11	#include <permissioner/Permissions.h>
11		-#include <permissioner/User.h>
12	12	#include <permissioner/StringUtils.h>
	13	+#include <permissioner/User.h>
13	14
14	15	#include <boost/filesystem.hpp>
15	16	#include <sstream>
...	...	@@ -38,8 +39,8 @@ void Tree::parseParams(std::string const &paramStr) {
38	39	user.parseUserName(userStr);
39	40	} catch (std::exception const &e) {
40	41	std::stringstream msg;
41		- msg << "invalid <user> field \"" << userStr << "\" in \""
42		- << paramStr << "\": " << e.what();
	42	+ msg << "invalid <user> field \"" << userStr << "\" in \"" << paramStr
	43	+ << "\": " << e.what();
43	44	throw std::runtime_error(msg.str());
44	45	}
45	46
...	...	@@ -47,8 +48,8 @@ void Tree::parseParams(std::string const &paramStr) {
47	48	group.parseGroupName(groupStr);
48	49	} catch (std::exception const &e) {
49	50	std::stringstream msg;
50		- msg << "invalid <group> field \"" << groupStr << "\" in \""
51		- << paramStr << "\": " << e.what();
	51	+ msg << "invalid <group> field \"" << groupStr << "\" in \"" << paramStr
	52	+ << "\": " << e.what();
52	53	throw std::runtime_error(msg.str());
53	54	}
54	55
...	...	@@ -65,54 +66,57 @@ void Tree::parseParams(std::string const &paramStr) {
65	66	root = boost::filesystem::canonical(rootStr);
66	67	} catch (std::exception const &e) {
67	68	std::stringstream msg;
68		- msg << "invalid <root> field \"" << rootStr << "\" in \""
69		- << paramStr << "\": " << e.what();
	69	+ msg << "invalid <root> field \"" << rootStr << "\" in \"" << paramStr
	70	+ << "\": " << e.what();
70	71	throw std::runtime_error(msg.str());
71	72	}
72	73	}
73	74
74		-User const & Tree::getUser() const {
75		- return user;
76		-}
	75	+User const &Tree::getUser() const { return user; }
77	76
78		-Group const & Tree::getGroup() const {
79		- return group;
80		-}
	77	+Group const &Tree::getGroup() const { return group; }
81	78
82		-Permissions const & Tree::getPermissions() const {
83		- return permissions;
84		-}
	79	+Permissions const &Tree::getPermissions() const { return permissions; }
85	80
86		-boost::filesystem::path const & Tree::getRoot() const {
87		- return root;
88		-}
	81	+boost::filesystem::path const &Tree::getRoot() const { return root; }
89	82
90		-void Tree::setPermissions(TreeMap const &exclude) const {
91		- setPermissionsInternal(root, exclude);
	83	+bool Tree::setPermissions(TreeMap const &exclude,
	84	+ Callback &callback) const {
	85	+ return setPermissionsInternal(root, exclude, callback);
92	86	}
93	87
94		-void Tree::setPermissionsInternal(boost::filesystem::path const &path,
95		- TreeMap const &exclude) const {
	88	+bool Tree::setPermissionsInternal(boost::filesystem::path const &path,
	89	+ TreeMap const &exclude,
	90	+ Callback &callback) const {
96	91	try {
97	92	if (boost::filesystem::is_regular_file(path)) {
98		- setPermissionsOne(path);
	93	+ if (!setPermissionsOne(path, callback)) {
	94	+ return false;
	95	+ };
99	96	} else if (boost::filesystem::is_directory(path)) {
100		- setPermissionsOne(path);
	97	+ if (!setPermissionsOne(path, callback)) {
	98	+ return false;
	99	+ };
101	100	for (boost::filesystem::directory_entry entry :
102	101	boost::filesystem::directory_iterator(path)) {
103	102	if (exclude.find(entry) != exclude.end()) {
104	103	continue; // other tree -> skip here
105	104	}
106		- setPermissionsInternal(entry, exclude); // recurse
	105	+ // recurse
	106	+ if (!setPermissionsInternal(entry, exclude, callback)) {
	107	+ return false;
	108	+ }
107	109	}
108	110	}
109	111	} catch (boost::filesystem::filesystem_error const &e) {
110	112	// ignore filesystem errors for now, as this runs in a daemon in background
111	113	(void)e;
112	114	}
	115	+ return true;
113	116	}
114	117
115		-void Tree::setPermissionsOne(boost::filesystem::path const &path) const {
	118	+bool Tree::setPermissionsOne(boost::filesystem::path const &path,
	119	+ Callback &callback) const {
116	120	// change permissions
117	121	try {
118	122	permissions.apply(path);
...	...	@@ -125,4 +129,7 @@ void Tree::setPermissionsOne(boost::filesystem::path const &path) const {
125	129	int ret = lchown(path.string().c_str(), user.getUid(), group.getGid());
126	130	// ignore error for now, as this runs in a daemon in background
127	131	(void)ret;
	132	+
	133	+ // call callback and return whether to continue
	134	+ return callback.callback();
128	135	}

...	...	@@ -4,6 +4,7 @@
4	4	* Copyleft: GNU GENERAL PUBLIC LICENSE version 3 (see LICENSE)
5	5	*/
6	6
	7	+#include <permissioner/Callback.h>
7	8	#include <permissioner/Config.h>
8	9
9	10	#include <cstdlib>
...	...	@@ -21,7 +22,8 @@ int main(int argc, char const **argv) {
21	22	try {
22	23	Config config;
23	24	config.parseFile(configFileName);
24		- config.setPermissions();
	25	+ Callback callback;
	26	+ config.setPermissions(callback);
25	27	} catch (std::exception const &e) {
26	28	std::cerr << "error: " << e.what() << std::endl;
27	29	return EXIT_FAILURE;