rename Commands to CommandSequence

Author: Vladimir Kotal

opengrok-tools/src/main/python/opengrok_tools/sync.py

@@ -39,7 +39,7 @@
 from multiprocessing import Pool
 from os import path
 
-from .utils.commands import Commands, CommandsBase
+from .utils.commandsequence import CommandSequence, CommandSequenceBase
 from .utils.filelock import Timeout, FileLock
 from .utils.opengrok import list_indexed_projects, get_config_value
 from .utils.readconfig import read_config
@@ -59,7 +59,7 @@ def worker(base):
     Process one project by calling set of commands.
     """
 
-    x = Commands(base)
+    x = CommandSequence(base)
     x.run()
     base.fill(x.retcodes, x.outputs, x.failed)
 
@@ -175,8 +175,8 @@ def main():
 
             cmds_base = []
             for d in dirs_to_process:
-                cmd_base = CommandsBase(d, commands,
-                                        config.get("cleanup"))
+                cmd_base = CommandSequenceBase(d, commands,
+                                               config.get("cleanup"))
                 cmds_base.append(cmd_base)
 
             # Map the commands into pool of workers so they can be processed.
@@ -189,7 +189,7 @@ def main():
                 for cmds_base in cmds_base_results:
                     logger.debug("Checking results of project {}".
                                  format(cmds_base))
-                    cmds = Commands(cmds_base)
+                    cmds = CommandSequence(cmds_base)
                     cmds.fill(cmds_base.retcodes, cmds_base.outputs,
                               cmds_base.failed)
                     cmds.check(ignore_errors)

opengrok-tools/src/main/python/opengrok_tools/utils/__init__.py

@@ -1,4 +1,4 @@
-from . import commands
+from . import commandsequence
 from . import command
 from . import opengrok
 from . import utils
@@ -12,7 +12,7 @@
     'opengrok',
     'utils',
     'command',
-    'commands',
+    'commandsequence',
     'filelock',
     'hook',
     'repofactory',

opengrok-tools/src/main/python/opengrok_tools/utils/commands.py renamed to opengrok-tools/src/main/python/opengrok_tools/utils/commandsequence.py

@@ -28,7 +28,7 @@
 import json
 
 
-class CommandsBase:
+class CommandSequenceBase:
     """
     Wrap the run of a set of Command instances.
 
@@ -61,7 +61,7 @@ def fill(self, retcodes, outputs, failed):
         self.failed = failed
 
 
-class Commands(CommandsBase):
+class CommandSequence(CommandSequenceBase):
     PROJECT_SUBST = '%PROJECT%'
 
     def __init__(self, base):

opengrok-tools/src/test/python/test_commands.py

@@ -32,47 +32,47 @@
                 os.path.join(os.path.dirname(__file__), '..', '..',
                 'main', 'python')))
 
-from opengrok_tools.utils.commands import Commands, CommandsBase
+from opengrok_tools.utils.commandsequence import CommandSequence, CommandSequenceBase
 
 
 class TestApp(unittest.TestCase):
     def test_str(self):
-        cmds = Commands(CommandsBase("opengrok-master",
-                        [{"command": ['foo']}, {"command": ["bar"]}]))
+        cmds = CommandSequence(CommandSequenceBase("opengrok-master",
+                                                   [{"command": ['foo']}, {"command": ["bar"]}]))
         self.assertEqual("opengrok-master", str(cmds))
 
     @unittest.skipUnless(os.path.exists('/bin/sh') and os.path.exists('/bin/echo'), "requires Unix")
     def test_run_retcodes(self):
-        cmds = Commands(CommandsBase("opengrok-master",
-                        [{"command": ["/bin/echo"]},
-                         {"command": ["/bin/sh", "-c", "echo " + Commands.PROJECT_SUBST + "; exit 0"]},
-                         {"command": ["/bin/sh", "-c", "echo " + Commands.PROJECT_SUBST + "; exit 1"]}]))
+        cmds = CommandSequence(CommandSequenceBase("opengrok-master",
+                                                   [{"command": ["/bin/echo"]},
+                                             {"command": ["/bin/sh", "-c", "echo " + CommandSequence.PROJECT_SUBST + "; exit 0"]},
+                                             {"command": ["/bin/sh", "-c", "echo " + CommandSequence.PROJECT_SUBST + "; exit 1"]}]))
         cmds.run()
         self.assertEqual({'/bin/echo opengrok-master': 0,
                           '/bin/sh -c echo opengrok-master; exit 0': 0,
                           '/bin/sh -c echo opengrok-master; exit 1': 1}, cmds.retcodes)
 
     @unittest.skipUnless(os.path.exists('/bin/sh') and os.path.exists('/bin/echo'), "requires Unix")
     def test_terminate_after_non_zero_code(self):
-        cmds = Commands(CommandsBase("opengrok-master",
-                                     [{"command": ["/bin/sh", "-c", "echo " + Commands.PROJECT_SUBST + "; exit 255"]},
+        cmds = CommandSequence(CommandSequenceBase("opengrok-master",
+                                                   [{"command": ["/bin/sh", "-c", "echo " + CommandSequence.PROJECT_SUBST + "; exit 255"]},
                                       {"command": ["/bin/echo"]}]))
         cmds.run()
         self.assertEqual({'/bin/sh -c echo opengrok-master; exit 255': 255}, cmds.retcodes)
 
     @unittest.skipUnless(os.path.exists('/bin/sh') and os.path.exists('/bin/echo'), "requires Unix")
     def test_exit_2_handling(self):
-        cmds = Commands(CommandsBase("opengrok-master",
-                                     [{"command": ["/bin/sh", "-c", "echo " + Commands.PROJECT_SUBST + "; exit 2"]},
+        cmds = CommandSequence(CommandSequenceBase("opengrok-master",
+                                                   [{"command": ["/bin/sh", "-c", "echo " + CommandSequence.PROJECT_SUBST + "; exit 2"]},
                                       {"command": ["/bin/echo"]}]))
         cmds.run()
         self.assertEqual({'/bin/sh -c echo opengrok-master; exit 2': 2}, cmds.retcodes)
         self.assertFalse(cmds.failed)
 
     @unittest.skipUnless(os.path.exists('/bin/echo'), "requires Unix")
     def test_project_subst(self):
-        cmds = Commands(CommandsBase("test-subst",
-                        [{"command": ["/bin/echo", Commands.PROJECT_SUBST]}]))
+        cmds = CommandSequence(CommandSequenceBase("test-subst",
+                                                   [{"command": ["/bin/echo", CommandSequence.PROJECT_SUBST]}]))
         cmds.run()
         self.assertEqual(['test-subst\n'],
                          cmds.outputs['/bin/echo test-subst'])