Import subrepo ./:execute at 2233b2acfab721cf9412305b0c65f7b27c86cac0

Import subrepo ./:cleanup at 30129de755f5f7a5b9647b792ca1373b94e15dcb

Author: d-e-s-o

cleanup/README.md

@@ -27,6 +27,40 @@ This example also illustrates another important fact: execution of the various
 cleanup routines happens in reverse order of their registration. This property
 is important in most scenarios where resources of interest have dependencies.
 
+Sometimes cleanup is only necessary in case an error occurs. That is, if
+all operations (resource acquisitions etc.) succeed, we do not want to
+roll back and undo a part of them. To that end, a defer context can be
+"released" in which case no cleanup happens after block exit. Revisiting
+the example above:
+
+```python
+client = Client()
+with defer() as d:
+ obj = Object()
+ d.defer(obj.destroy)
+ obj.register(client)
+ d.defer(lambda: obj.unregister(client))
+
+ # Do some action that potentially raises an error.
+
+ # If we got here we want to keep the object created and registered
+ # with the client.
+ d.release()
+```
+
+This mechanism not only works on the level of a context but also for
+individually deferred functions:
+```python
+client = Client()
+with defer() as d:
+ obj = Object()
+ f = d.defer(obj.destroy)
+
+ # Do some action that potentially raises an error.
+
+ f.release()
+```
+
 
 Installation
 ------------

cleanup/src/deso/cleanup/defer.py

@@ -49,6 +49,10 @@ def __call__(self):
  # Mark function as executed.
  self._function = None
 
+ def release(self):
+ """Release the function from the defer operation without invoking it."""
+ self._function = None
+
  class _Defer:
  """Objects of this class act as a context with which to register deferred functions."""
  def __init__(self):
@@ -69,6 +73,10 @@ def defer(self, function):
  self._functions += [result]
  return result
 
+ def release(self):
+ """Release all deferred functions without executing them."""
+ self._functions = []
+
  def destroy(self):
  """Destroy the object, invoke all deferred functions."""
  # Always invoke in reverse order of registration.

cleanup/src/deso/cleanup/test/testDefer.py

@@ -120,5 +120,29 @@ def testDeferRunEarlyRunOnce(self):
  self.assertEqual(self._counter.count(), 1)
 
 
+ def testDeferFunctionRelease(self):
+ """Test the release functionality of deferred functions."""
+ with defer() as d:
+ f = d.defer(self._counter.increment)
+ _ = d.defer(self._counter.increment)
+
+ f.release()
+
+ # Only one increment should have been executed.
+ self.assertEqual(self._counter.count(), 1)
+
+
+ def testDeferReleaseAll(self):
+ """Test the release functionality of defer objects."""
+ with defer() as d:
+ d.defer(self._counter.increment)
+ d.defer(self._counter.increment)
+
+ d.release()
+
+ # No function should have been executed.
+ self.assertEqual(self._counter.count(), 0)
+
+
 if __name__ == "__main__":
  main()

execute/src/deso/execute/execute_.py

@@ -236,6 +236,25 @@ def pipeRead(argument, data):
  self._stdout = {}
  self._stderr = {}
 
+ # We want to redirect all file descriptors that we do not want
+ # anything from to /dev/null. But we only want to open the latter
+ # in case someone really requires it, i.e., if not all three
+ # channels are connected to pipes or user-defined file descriptors
+ # anyway.
+ if stdin is None or stdout is None or stderr is None:
+ null = open_(devnull, O_RDWR | O_CLOEXEC)
+ here.defer(lambda: close_(null))
+
+ if stdin is None:
+ stdin = null
+ if stdout is None:
+ stdout = null
+ if stderr is None:
+ stderr = null
+
+ # At this point stdin, stdout, and stderr are all either a valid
+ # file descriptor (i.e., of type int) or some data.
+
  # Now, depending on whether we got passed in a file descriptor (an
  # object of type int), remember it or create a pipe to read or write
  # data.
@@ -334,8 +353,7 @@ def pollRead(data):
  error = error.format(s=string, e=event)
  raise ConnectionError(error)
 
- return self._stdout["data"] if self._stdout else b"",\
- self._stderr["data"] if self._stderr else b""
+ return self.data()
 
 
  def stdin(self):
@@ -353,6 +371,12 @@ def stderr(self):
  return self._stderr["out"] if self._stderr else self._file_err
 
 
+ def data(self):
+ """Retrieve the data polled so far as a (stdout, stderr) tuple."""
+ return self._stdout["data"] if self._stdout else b"",\
+ self._stderr["data"] if self._stderr else b""
+
+
 def pipeline(commands, stdin=None, stdout=None, stderr=b""):
  """Execute a pipeline, supplying the given data to stdin and reading from stdout & stderr.
 
@@ -368,25 +392,6 @@ def pipeline(commands, stdin=None, stdout=None, stderr=b""):
  """
  with defer() as later:
  with defer() as here:
- # We want to redirect all file descriptors that we do not want
- # anything from to /dev/null. But we only want to open the latter
- # in case someone really requires it, i.e., if not all three
- # channels are connected to pipes or user-defined file descriptors
- # anyway.
- if stdin is None or stdout is None or stderr is None:
- null = open_(devnull, O_RDWR | O_CLOEXEC)
- here.defer(lambda: close_(null))
-
- if stdin is None:
- stdin = null
- if stdout is None:
- stdout = null
- if stderr is None:
- stderr = null
-
- # At this point stdin, stdout, and stderr are all either a valid
- # file descriptor (i.e., of type int) or some data.
-
  # Set up the file descriptors to pass to our execution pipeline.
  fds = _PipelineFileDescriptors(later, here, stdin, stdout, stderr)