Beispiel #1
0
    def run_booth(self, config_text=None, config_file=None, lock_file=True, args=[],
                  expected_exitcode=0, debug=False):
        '''
        Runs boothd.

        Returns a (pid, return_code, stdout, stderr, runner) tuple,
        where return_code/stdout/stderr are None iff pid is still running.
        '''
        self.init_log()

        runner = BoothRunner(self.boothd_path, self.mode, args)
        runner.show_args()
        (pid, return_code, stdout, stderr) = runner.run()
        self.check_return_code(pid, return_code, expected_exitcode)

        return (pid, return_code, stdout, stderr, runner)
Beispiel #2
0
    def run_booth(self, config_text=None, config_file=None, lock_file=True, args=[],
                  expected_exitcode=0, debug=False):
        '''
        Runs boothd.

        Returns a (pid, return_code, stdout, stderr, runner) tuple,
        where return_code/stdout/stderr are None iff pid is still running.
        '''
        self.init_log()

        runner = BoothRunner(self.boothd_path, self.mode, args)
        runner.show_args()
        (pid, return_code, stdout, stderr) = runner.run()
        self.check_return_code(pid, return_code, expected_exitcode)

        return (pid, return_code, stdout, stderr, runner)
Beispiel #3
0
    def run_booth(self, config_text=None, config_file=None, lock_file=True, args=[],
                  expected_exitcode=0, debug=False):
        '''
        Runs boothd.  Defaults to using a temporary lock file and
        the standard config file path.

        Returns a (pid, return_code, stdout, stderr, runner) tuple,
        where return_code/stdout/stderr are None iff pid is still running.
        '''
        self.init_log()

        runner = BoothRunner(self.boothd_path, self.mode, args)

        if config_text:
            config_file = self.write_config_file(config_text)
        if config_file:
            runner.set_config_file(config_file)

        if lock_file is True:
            lock_file = os.path.join(self.test_path, 'boothd-lock.pid')
        if lock_file:
            runner.set_lock_file(lock_file)

        if debug:
            runner.set_debug()

        runner.show_args()
        (pid, return_code, stdout, stderr) = runner.run()
        self.check_return_code(pid, return_code, expected_exitcode)

        expected_daemon = expected_exitcode == 0 or expected_exitcode is None
        got_daemon      = return_code       == 0 or return_code       is None

        if got_daemon:
            self.check_daemon_handling(runner, expected_daemon)

        return (pid, return_code, stdout, stderr, runner)
Beispiel #4
0
    def run_booth(self, expected_exitcode, expected_daemon,
                  config_text=None, config_file=None, lock_file=True,
                  args=(), debug=False, foreground=False):
        '''
        Runs boothd.  Defaults to using a temporary lock file and the
        standard config file path.  There are four possible types of
        outcome:

            - boothd exits non-zero without launching a daemon (setup phase failed,
              e.g. due to invalid configuration file)
            - boothd exits zero after launching a daemon (successful operation)
            - boothd does not exit (running in foreground mode)
            - boothd does not exit (setup phase hangs, e.g. while attempting
              to connect to peer during ticket_catchup())

        Arguments:
            config_text
                a string containing the contents of a configuration file to use
            config_file
                path to a configuration file to use
            lock_file
                False: don't pass a lockfile parameter to booth via -l
                True: pass a temporary lockfile parameter to booth via -l
                string: pass the given lockfile path to booth via -l
            args
                iterable of extra args to pass to booth
            expected_exitcode
                an integer, or False if booth is not expected to terminate
                within the timeout
            expected_daemon
                True iff a daemon is expected to be launched (this means
                running the server in foreground mode via -S;
                even though in this case the server's not technically not a daemon,
                we still want to treat it like one by checking the lockfile
                before and after we kill it)
            debug
                True means pass the -D parameter
            foreground
                True means pass the -S parameter

        Returns a (pid, return_code, stdout, stderr, runner) tuple,
        where return_code/stdout/stderr are None iff pid is still running.
        '''
        if expected_daemon and expected_exitcode is not None and expected_exitcode != 0:
            raise RuntimeError("Shouldn't ever expect daemon to start and then failure")

        if not expected_daemon and expected_exitcode == 0:
            raise RuntimeError("Shouldn't ever expect success without starting daemon")

        self.init_log()

        runner = BoothRunner(self.boothd_path, self.mode, args)

        if config_text:
            config_file = self.write_config_file(config_text)
        if config_file:
            runner.set_config_file(config_file)

        if lock_file is True:
            lock_file = os.path.join(self.test_path, 'boothd-lock.pid')
        if lock_file:
            runner.set_lock_file(lock_file)

        if debug:
            runner.set_debug()

        if foreground:
            runner.set_foreground()

        runner.show_args()
        (pid, return_code, stdout, stderr) = runner.run()
        self.check_return_code(pid, return_code, expected_exitcode)

        if expected_daemon:
            self.check_daemon_handling(runner, expected_daemon)
        elif return_code is None:
            # This isn't strictly necessary because we ensure no
            # daemon is running from within test setUp(), but it's
            # probably a good idea to tidy up after ourselves anyway.
            self.kill_pid(pid)

        return (pid, return_code, stdout, stderr, runner)
Beispiel #5
0
    def run_booth(self,
                  expected_exitcode,
                  expected_daemon,
                  config_text=None,
                  config_file=None,
                  lock_file=True,
                  args=(),
                  debug=False,
                  foreground=False):
        '''
        Runs boothd.  Defaults to using a temporary lock file and the
        standard config file path.  There are four possible types of
        outcome:

            - boothd exits non-zero without launching a daemon (setup phase failed,
              e.g. due to invalid configuration file)
            - boothd exits zero after launching a daemon (successful operation)
            - boothd does not exit (running in foreground mode)
            - boothd does not exit (setup phase hangs, e.g. while attempting
              to connect to peer during ticket_catchup())

        Arguments:
            config_text
                a string containing the contents of a configuration file to use
            config_file
                path to a configuration file to use
            lock_file
                False: don't pass a lockfile parameter to booth via -l
                True: pass a temporary lockfile parameter to booth via -l
                string: pass the given lockfile path to booth via -l
            args
                iterable of extra args to pass to booth
            expected_exitcode
                an integer, or False if booth is not expected to terminate
                within the timeout
            expected_daemon
                True iff a daemon is expected to be launched (this means
                running the server in foreground mode via -S;
                even though in this case the server's not technically not a daemon,
                we still want to treat it like one by checking the lockfile
                before and after we kill it)
            debug
                True means pass the -D parameter
            foreground
                True means pass the -S parameter

        Returns a (pid, return_code, stdout, stderr, runner) tuple,
        where return_code/stdout/stderr are None iff pid is still running.
        '''
        if expected_daemon and expected_exitcode is not None and expected_exitcode != 0:
            raise RuntimeError(
                "Shouldn't ever expect daemon to start and then failure")

        if not expected_daemon and expected_exitcode == 0:
            raise RuntimeError(
                "Shouldn't ever expect success without starting daemon")

        self.init_log()

        runner = BoothRunner(self.boothd_path, self.mode, args)

        if config_text:
            config_file = self.write_config_file(config_text)
        if config_file:
            runner.set_config_file(config_file)

        if lock_file is True:
            lock_file = os.path.join(self.test_path, 'boothd-lock.pid')
        if lock_file:
            runner.set_lock_file(lock_file)

        if debug:
            runner.set_debug()

        if foreground:
            runner.set_foreground()

        runner.show_args()
        (pid, return_code, stdout, stderr) = runner.run()
        self.check_return_code(pid, return_code, expected_exitcode)

        if expected_daemon:
            self.check_daemon_handling(runner, expected_daemon)
        elif return_code is None:
            # This isn't strictly necessary because we ensure no
            # daemon is running from within test setUp(), but it's
            # probably a good idea to tidy up after ourselves anyway.
            self.kill_pid(pid)

        return (pid, return_code, stdout, stderr, runner)