def update_buildout_data(cls, buildout):
     import gitpy
     repository = cls.get_repository()
     branch = repository.getCurrentBranch()
     try:
         remote = branch.getRemoteBranch() if branch is not None else None
     except gitpy.exceptions.NonexistentRefException:
         remote = None
     head = repository.getHead()
     from zc.buildout.buildout import Options
     data = {}
     data['version'] = cls.extract_version_tag().lstrip('v')
     data['author'] = head.getAuthorName()
     data['author_email'] = head.getAuthorEmail()
     data['git_local_branch'] = repr(branch.name if branch is not None else '(Not currently on any branch)')
     data['git_remote_tracking_branch'] = repr(remote.getNormalizedName() if remote is not None else '(No remote tracking)')
     data['git_remote_url'] = repr(remote.remote.url if remote is not None else '(Not remote tracking)')
     data['head_subject'] = repr(cls.strip_mako_characters(head.getSubject()))
     data['head_message'] = repr(cls.strip_mako_characters(head.getMessageBody()))
     data['head_hash'] = repr(head.hash)
     data['git_commit_date'] = repr(datetime.datetime.fromtimestamp(head.getDate()).isoformat(' '))
     diff = execute_async("git diff --patch --no-color", shell=True)
     diff.wait()
     data['dirty_diff'] = repr(cls.strip_mako_characters(diff.get_stdout().decode("utf-8")))
     data['homepage'] = repr(cls.get_homepage())
     if buildout.get("project").get("homepage"):
         data['homepage'] = repr(buildout.get("project").get("homepage"))
     buildout._data.update({SECTION_NAME: Options(buildout, SECTION_NAME, data)})
Beispiel #2
0
 def test__async_execute_with_little_output(self):
     part_a = 'legen'
     part_b = 'wait for it'
     part_c = 'dary'
     command = ["-c", "from sys import stdout; from time import sleep; stdout.write('%s');stdout.flush(); sleep(2); stdout.write('%s');stdout.flush(); sleep(2); stdout.write('%s'); stdout.flush(); sleep(2)" % \
                     (part_a, part_b, part_c)]
     command.insert(0,sys.executable)
     num_secs = 6
     with self.assertTakesAlmost(num_secs, 1):
         with self.assertImmediate():
             result = execute_async(command)
         with self.assertTakesAlmost(1):
             self.assertRaises(CommandTimeout, result.wait, **{'timeout':1})
             self.assertIn(part_a, result.get_stdout())
             #self.assertNotIn(part_b, result.get_stdout())
         with self.assertTakesAlmost(2):
             self.assertRaises(CommandTimeout, result.wait, **{'timeout':2})
             self.assertIn(part_a, result.get_stdout())
             self.assertIn(part_b, result.get_stdout())
             self.assertNotIn(part_c, result.get_stdout())
         with self.assertTakesAlmost(2):
             self.assertRaises(CommandTimeout, result.wait, **{'timeout':2})
             self.assertIn(part_a, result.get_stdout())
             self.assertIn(part_b, result.get_stdout())
             self.assertIn(part_c, result.get_stdout())
         result.wait()
Beispiel #3
0
def log_execute(args, timeout_in_seconds=None):
    from infi.execute import execute_async, CommandTimeout
    pid = execute_async(args)
    try:
        pid.wait(timeout_in_seconds)
    except CommandTimeout:
        pid.kill(9)
    return pid.get_pid()
Beispiel #4
0
def log_execute(args, timeout_in_seconds=None):
    from infi.execute import execute_async, CommandTimeout
    pid = execute_async(args)
    try:
        pid.wait(timeout_in_seconds)
    except CommandTimeout:
        pid.kill(9)
    return pid.get_pid()
Beispiel #5
0
 def test__async_execute(self):
     num_secs = 3
     with self.assertTakesAlmost(num_secs, 1):
         with self.assertImmediate():
             result = execute_async("sleep {}".format(num_secs), shell=True)
         self.assertIsNone(result.get_returncode())
         self.assertFalse(result.is_finished())
         self.assertIsNone(result.poll())
         self.assertEquals(result.wait(), True)
     self.assertEquals(0, result.poll())
 def _execute(self):
     from infi.execute import execute_async, CommandTimeout
     from os import path
     executable = self.executable if path.exists(self.executable) else find_executable(self.executable)
     logger.info("Going to run {} {}".format(executable, self.commandline_arguments))
     cmd = execute_async([executable] + self.commandline_arguments)
     try:
         cmd.wait(self.wait_time_in_seconds)
     except OSError, error:
         logger.exception("Command did not run")
 def test_async_with_another_greenlet_running(self):
     import gevent
     event = gevent.event.Event()
     def func():
         event.set()
     result = execute_async("sleep 1", shell=True)
     greenlet = gevent.spawn(func)
     self.assertFalse(event.is_set())
     result.wait()
     self.assertTrue(event.is_set())
     greenlet.join()
Beispiel #8
0
 def test__async_execute(self):
     num_secs = 3
     with self.assertTakesAlmost(num_secs, 1):
         with self.assertImmediate():
             result = execute_async("sleep {0}".format(num_secs),
                                    shell=True)
         self.assertIsNone(result.get_returncode())
         self.assertFalse(result.is_finished())
         self.assertIsNone(result.poll())
         self.assertEquals(result.wait(), True)
     self.assertEquals(0, result.poll())
Beispiel #9
0
 def with_webserver_running(self, configfile=None):
     tempfile_context = self.with_new_devlopment_config_file()
     if configfile is None:
         configfile = tempfile_context.__enter__()
         self.addCleanup(tempfile_context.__exit__, None, None, None)
     pid = execute_async(["bin/app_repo", "-f", configfile, "webserver", "start"])
     sleep(2)
     try:
         # wait(lambda: 'Bus STARTED' in pid.get_stderr(), timeout_seconds=3)
         yield
     finally:
         pid.kill(9)
Beispiel #10
0
    def test_async_with_another_greenlet_running(self):
        import gevent
        event = gevent.event.Event()

        def func():
            event.set()

        result = execute_async("sleep 1", shell=True)
        greenlet = gevent.spawn(func)
        self.assertFalse(event.is_set())
        result.wait()
        self.assertTrue(event.is_set())
        greenlet.join()
Beispiel #11
0
 def test__async_wait_periods(self):
     num_secs = 3
     with self.assertTakesAlmost(num_secs):
         with self.assertImmediate():
             result = execute_async("sleep {}".format(num_secs), shell=True)
         self.assertFalse(result.is_finished())
         with self.assertTakesAlmost(1):
             self.assertRaises(CommandTimeout, result.wait, **{'timeout':1})
             self.assertFalse(result.is_finished())
         with self.assertTakesAlmost(1):
             self.assertRaises(CommandTimeout, result.wait, **{'timeout':1})
             self.assertFalse(result.is_finished())
         result.wait()
         self.assertTrue(result.is_finished())
Beispiel #12
0
 def _execute(self):
     from infi.execute import execute_async, CommandTimeout
     from os import path
     executable = self.executable if path.exists(
         self.executable) else find_executable(self.executable)
     logger.info("Going to run {} {}".format(executable,
                                             self.commandline_arguments))
     try:
         cmd = execute_async([executable] + self.commandline_arguments,
                             env=self.env)
     except OSError:
         logger.error("executable {} not found".format(executable))
         return FakeResult
     try:
         cmd.wait(self.wait_time_in_seconds)
     except OSError, error:
         logger.exception("Command did not run")
Beispiel #13
0
 def test__async_wait_periods(self):
     num_secs = 3
     with self.assertTakesAlmost(num_secs):
         with self.assertImmediate():
             result = execute_async("sleep {0}".format(num_secs),
                                    shell=True)
         self.assertFalse(result.is_finished())
         with self.assertTakesAlmost(1):
             self.assertRaises(CommandTimeout, result.wait,
                               **{'timeout': 1})
             self.assertFalse(result.is_finished())
         with self.assertTakesAlmost(1):
             self.assertRaises(CommandTimeout, result.wait,
                               **{'timeout': 1})
             self.assertFalse(result.is_finished())
         result.wait()
         self.assertTrue(result.is_finished())
Beispiel #14
0
    def start(self):
        from os import path
        from sys import executable, path as sys_path
        from infi.execute import execute_async

        script = path.join(self.tempdir, 'script.py')
        with open(script, 'w') as fd:
            kwargs = dict(path=sys_path,
                          server_port=self.server.get_port(),
                          gevent_friendly=self.gevent_friendly,
                          worker_id=self._id,
                          tempdir=self.tempdir,
                          logging_port=self.logging_port)
            fd.write(SCRIPT.format(**kwargs))
        logger.debug("starting worker {}: {} {}".format(
            self._id, executable, script))
        self._result = execute_async([executable, script])
Beispiel #15
0
    def test__async_execute_with_little_output(self):
        try:
            import gevent.subprocess
            raise test_utils.SkipTest()
        except ImportError:
            pass

        part_a = b'legen'
        part_b = b'wait for it'
        part_c = b'dary'
        if PY3:
            command = ["-c", "from sys import stdout; from time import sleep; stdout.buffer.write(b'%s');stdout.flush(); sleep(2); stdout.buffer.write(b'%s');stdout.flush(); sleep(2); stdout.buffer.write(b'%s'); stdout.flush(); sleep(2)" % \
                        (part_a.decode("ASCII"), part_b.decode("ASCII"), part_c.decode("ASCII"))]
        else:
            command = ["-c", "from sys import stdout; from time import sleep; stdout.write(b'%s');stdout.flush(); sleep(2); stdout.write(b'%s');stdout.flush(); sleep(2); stdout.write(b'%s'); stdout.flush(); sleep(2)" % \
                        (part_a, part_b, part_c)]
        command.insert(0, sys.executable)
        num_secs = 6
        with self.assertTakesAlmost(num_secs, 1):
            with self.assertImmediate():
                result = execute_async(command)
            with self.assertTakesAlmost(1):
                self.assertRaises(CommandTimeout, result.wait,
                                  **{'timeout': 1})
                self.assertIn(part_a, result.get_stdout())
                #self.assertNotIn(part_b, result.get_stdout())
            with self.assertTakesAlmost(2):
                self.assertRaises(CommandTimeout, result.wait,
                                  **{'timeout': 2})
                self.assertIn(part_a, result.get_stdout())
                self.assertIn(part_b, result.get_stdout())
                self.assertNotIn(part_c, result.get_stdout())
            with self.assertTakesAlmost(2):
                self.assertRaises(CommandTimeout, result.wait,
                                  **{'timeout': 2})
                self.assertIn(part_a, result.get_stdout())
                self.assertIn(part_b, result.get_stdout())
                self.assertIn(part_c, result.get_stdout())
            result.wait()
 def _execute(self):
     from infi.execute import execute_async, CommandTimeout
     from os import path
     executable = self.executable if path.exists(self.executable) else find_executable(self.executable)
     logger.info("Going to run {} {}".format(executable, self.commandline_arguments))
     try:
         cmd = execute_async([executable] + self.commandline_arguments, env=self.env)
     except OSError:
         logger.error("executable {} not found".format(executable))
         return FakeResult
     try:
         cmd.wait(self.wait_time_in_seconds)
     except OSError as error:
         logger.exception("Command did not run")
     except CommandTimeout as error:
         logger.exception("Command did not finish in {} seconds, killing it".format(self.wait_time_in_seconds))
         cmd.kill()
         if not cmd.is_finished():
             cmd.kill(9)
         if not cmd.is_finished():
             logger.info("{!r} is stuck".format(cmd))
         else:
             logger.info("{!r} was killed".format(cmd))
     return cmd
Beispiel #17
0
 def update_buildout_data(cls, buildout):
     import gitpy
     repository = cls.get_repository()
     branch = repository.getCurrentBranch()
     try:
         remote = branch.getRemoteBranch() if branch is not None else None
     except gitpy.exceptions.NonexistentRefException:
         remote = None
     head = repository.getHead()
     from zc.buildout.buildout import Options
     data = {}
     data['version'] = cls.extract_version_tag().lstrip('v')
     data['author'] = head.getAuthorName()
     data['author_email'] = head.getAuthorEmail()
     data['git_local_branch'] = repr(branch.name if branch is not None else
                                     '(Not currently on any branch)')
     data['git_remote_tracking_branch'] = repr(remote.getNormalizedName(
     ) if remote is not None else '(No remote tracking)')
     data['git_remote_url'] = repr(remote.remote.url if remote is not None
                                   else '(Not remote tracking)')
     data['head_subject'] = repr(
         cls.strip_mako_characters(head.getSubject()))
     data['head_message'] = repr(
         cls.strip_mako_characters(head.getMessageBody()))
     data['head_hash'] = repr(head.hash)
     data['git_commit_date'] = repr(
         datetime.datetime.fromtimestamp(head.getDate()).isoformat(' '))
     diff = execute_async("git diff --patch --no-color", shell=True)
     diff.wait()
     data['dirty_diff'] = repr(
         cls.strip_mako_characters(diff.get_stdout().decode("utf-8")))
     data['homepage'] = repr(cls.get_homepage())
     if buildout.get("project").get("homepage"):
         data['homepage'] = repr(buildout.get("project").get("homepage"))
     buildout._data.update(
         {SECTION_NAME: Options(buildout, SECTION_NAME, data)})
Beispiel #18
0
    def test__async_execute_with_little_output(self):
        try:
            import gevent.subprocess
            raise test_utils.SkipTest()
        except ImportError:
            pass

        part_a = b'legen'
        part_b = b'wait for it'
        part_c = b'dary'
        if PY3:
            command = ["-c", "from sys import stdout; from time import sleep; stdout.buffer.write(b'%s');stdout.flush(); sleep(2); stdout.buffer.write(b'%s');stdout.flush(); sleep(2); stdout.buffer.write(b'%s'); stdout.flush(); sleep(2)" % \
                        (part_a.decode("ASCII"), part_b.decode("ASCII"), part_c.decode("ASCII"))]
        else:
            command = ["-c", "from sys import stdout; from time import sleep; stdout.write(b'%s');stdout.flush(); sleep(2); stdout.write(b'%s');stdout.flush(); sleep(2); stdout.write(b'%s'); stdout.flush(); sleep(2)" % \
                        (part_a, part_b, part_c)]
        command.insert(0,sys.executable)
        num_secs = 6
        with self.assertTakesAlmost(num_secs, 1):
            with self.assertImmediate():
                result = execute_async(command)
            with self.assertTakesAlmost(1):
                self.assertRaises(CommandTimeout, result.wait, **{'timeout':1})
                self.assertIn(part_a, result.get_stdout())
                #self.assertNotIn(part_b, result.get_stdout())
            with self.assertTakesAlmost(2):
                self.assertRaises(CommandTimeout, result.wait, **{'timeout':2})
                self.assertIn(part_a, result.get_stdout())
                self.assertIn(part_b, result.get_stdout())
                self.assertNotIn(part_c, result.get_stdout())
            with self.assertTakesAlmost(2):
                self.assertRaises(CommandTimeout, result.wait, **{'timeout':2})
                self.assertIn(part_a, result.get_stdout())
                self.assertIn(part_b, result.get_stdout())
                self.assertIn(part_c, result.get_stdout())
            result.wait()
 def start_python(self):
     basename = 'python' + EXTENSION
     python = os.path.abspath(os.path.join(os.path.curdir, 'bin', basename))
     pid = execute_async([python, '-c', 'import time; time.sleep(60)'])
     return pid
Beispiel #20
0
 def test__timeout_async(self):
     result = execute_async("sleep 100", shell=True, timeout=1)
     with self.assertRaises(CommandTimeout) as caught:
         result.wait()
     self.assertFalse(caught.exception.result.is_finished())
     caught.exception.result.kill()
Beispiel #21
0
 def test__timeout_async(self):
     result = execute_async("sleep 100", shell=True, timeout=1)
     with self.assertRaises(CommandTimeout) as caught:
         result.wait()
     self.assertFalse(caught.exception.result.is_finished())
     caught.exception.result.kill()