Ejemplo n.º 1
0
    def test_path_search_which(self):
        " which() finds an executable in $PATH and returns its abspath. "
        fname = 'gcc'
        bin_dir = tempfile.mkdtemp()
        bin_path = os.path.join(bin_dir, fname)
        save_path = os.environ['PATH']
        try:
            # setup
            os.environ['PATH'] = bin_dir
            with open(bin_path, 'w') as fp:
                pass

            # given non-executable,
            os.chmod(bin_path, 0o400)

            # exercise absolute and relative,
            assert pexpect.which(bin_path) is None
            assert pexpect.which(fname) is None

            # given executable,
            os.chmod(bin_path, 0o700)

            # exercise absolute and relative,
            assert pexpect.which(bin_path) == bin_path
            assert pexpect.which(fname) == bin_path

        finally:
            # restore,
            os.environ['PATH'] = save_path

            # destroy scratch files and folders,
            if os.path.exists(bin_path):
                os.unlink(bin_path)
            if os.path.exists(bin_dir):
                os.rmdir(bin_dir)
Ejemplo n.º 2
0
    def test_absolute_which(self):
        # make up a path and insert first a non-executable,
        # then, make it executable, and assert we may which() find it.
        fname = 'gcc'
        bin_dir = tempfile.mkdtemp()
        bin_path = os.path.join(bin_dir, fname)
        save_path = os.environ['PATH']
        try:
            # setup
            os.environ['PATH'] = bin_dir
            with open(bin_path, 'w') as fp:
                fp.write('#!/bin/sh\necho hello, world\n')
            os.chmod(bin_path, 0o400)

            # it should not be found because it is not executable
            assert pexpect.which(fname) is None, fname

            # but now it should -- because it is executable
            os.chmod(bin_path, 0o700)
            assert pexpect.which(fname) == bin_path, (fname, bin_path)

        finally:
            # restore,
            os.environ['PATH'] = save_path
            # destroy scratch files and folders,
            if os.path.exists(bin_path):
                os.unlink(bin_path)
            if os.path.exists(bin_dir):
                os.rmdir(bin_dir)
Ejemplo n.º 3
0
    def test_which_should_match_other_group_user(self):
        " which() returns executables by other, group, and user ownership. "
        # create an executable and test that it is found using which() for
        # each of the 'other', 'group', and 'user' permission bits.
        fname = 'g77'
        bin_dir = tempfile.mkdtemp()
        bin_path = os.path.join(bin_dir, fname)
        save_path = os.environ['PATH']
        try:
            # setup
            os.environ['PATH'] = bin_dir
            with open(bin_path, 'w') as fp:
                fp.write('#!/bin/sh\necho hello, world\n')
            for should_match, mode in ((False, 0o000), (True, 0o005),
                                       (True, 0o050), (True, 0o500), (False,
                                                                      0o004),
                                       (False, 0o040), (False, 0o400)):
                os.chmod(bin_path, mode)

                if not should_match:
                    # should not be found because it is not executable
                    assert pexpect.which(fname) is None
                else:
                    # should match full path
                    assert pexpect.which(fname) == bin_path

        finally:
            # restore,
            os.environ['PATH'] = save_path
            # destroy scratch files and folders,
            if os.path.exists(bin_path):
                os.unlink(bin_path)
            if os.path.exists(bin_dir):
                os.rmdir(bin_dir)
Ejemplo n.º 4
0
    def test_which_follows_symlink(self):
        " which() follows symlinks and returns its path. "
        fname = 'original'
        symname = 'extra-crispy'
        bin_dir = tempfile.mkdtemp()
        bin_path = os.path.join(bin_dir, fname)
        sym_path = os.path.join(bin_dir, symname)
        save_path = os.environ['PATH']
        try:
            # setup
            os.environ['PATH'] = bin_dir
            with open(bin_path, 'w') as fp:
                pass
            os.chmod(bin_path, 0o400)
            os.symlink(bin_path, sym_path)

            # should not be found because symlink points to non-executable
            assert pexpect.which(symname) is None

            # but now it should -- because it is executable
            os.chmod(bin_path, 0o700)
            assert pexpect.which(symname) == sym_path

        finally:
            # restore,
            os.environ['PATH'] = save_path

            # destroy scratch files, symlinks, and folders,
            if os.path.exists(sym_path):
                os.unlink(sym_path)
            if os.path.exists(bin_path):
                os.unlink(bin_path)
            if os.path.exists(bin_dir):
                os.rmdir(bin_dir)
Ejemplo n.º 5
0
    def test_which_follows_symlink(self):
        " which() follows symlinks and returns its path. "
        fname = 'original'
        symname = 'extra-crispy'
        bin_dir = tempfile.mkdtemp()
        bin_path = os.path.join(bin_dir, fname)
        sym_path = os.path.join(bin_dir, symname)
        save_path = os.environ['PATH']
        try:
            # setup
            os.environ['PATH'] = bin_dir
            with open(bin_path, 'w') as fp:
                pass
            os.chmod(bin_path, 0o400)
            os.symlink(bin_path, sym_path)

            # should not be found because symlink points to non-executable
            assert pexpect.which(symname) is None

            # but now it should -- because it is executable
            os.chmod(bin_path, 0o700)
            assert pexpect.which(symname) == sym_path

        finally:
            # restore,
            os.environ['PATH'] = save_path

            # destroy scratch files, symlinks, and folders,
            if os.path.exists(sym_path):
                os.unlink(sym_path)
            if os.path.exists(bin_path):
                os.unlink(bin_path)
            if os.path.exists(bin_dir):
                os.rmdir(bin_dir)
Ejemplo n.º 6
0
    def test_path_search_which(self):
        " which() finds an executable in $PATH and returns its abspath. "
        fname = 'gcc'
        bin_dir = tempfile.mkdtemp()
        bin_path = os.path.join(bin_dir, fname)
        save_path = os.environ['PATH']
        try:
            # setup
            os.environ['PATH'] = bin_dir
            with open(bin_path, 'w') as fp:
                pass

            # given non-executable,
            os.chmod(bin_path, 0o400)

            # exercise absolute and relative,
            assert pexpect.which(bin_path) is None
            assert pexpect.which(fname) is None

            # given executable,
            os.chmod(bin_path, 0o700)

            # exercise absolute and relative,
            assert pexpect.which(bin_path) == bin_path
            assert pexpect.which(fname) == bin_path

        finally:
            # restore,
            os.environ['PATH'] = save_path

            # destroy scratch files and folders,
            if os.path.exists(bin_path):
                os.unlink(bin_path)
            if os.path.exists(bin_dir):
                os.rmdir(bin_dir)
Ejemplo n.º 7
0
def call_editor(filename):
    editor = os.getenv("EDITOR")
    if editor is None:
        editor = pexpect.which("vim")
    if editor is None:
        editor = pexpect.which("vi")
    if editor is None:
        raise StandardError("Can't find an editor")
    os.system("%s %s" % (editor, filename))
Ejemplo n.º 8
0
 def test_which (self):
     p = os.defpath
     ep = os.environ['PATH']
     os.defpath = ":/tmp"
     os.environ['PATH'] = ":/tmp"
     wp = pexpect.which ("ticker.py")
     assert wp == 'ticker.py', "Should return a string. Returned %s" % wp
     os.defpath = "/tmp"
     os.environ['PATH'] = "/tmp"
     wp = pexpect.which ("ticker.py")
     assert wp == None, "Executable should not be found. Returned %s" % wp
     os.defpath = p
     os.environ['PATH'] = ep
Ejemplo n.º 9
0
 def test_which(self):
     p = os.defpath
     ep = os.environ['PATH']
     os.defpath = ":/tmp"
     os.environ['PATH'] = ":/tmp"
     wp = pexpect.which("ticker.py")
     assert wp == 'ticker.py', "Should return a string. Returned %s" % wp
     os.defpath = "/tmp"
     os.environ['PATH'] = "/tmp"
     wp = pexpect.which("ticker.py")
     assert wp == None, "Executable should not be found. Returned %s" % wp
     os.defpath = p
     os.environ['PATH'] = ep
Ejemplo n.º 10
0
    def __init__(self,
                 gdb='riscv64-unknown-elf-gdb',
                 openocd='openocd',
                 openocd_config_filename='./testing/targets/ssith_gfe.cfg',
                 timeout=60):
        print_and_log("Starting GDB session...")
        if not which(gdb):
            raise GdbError('Executable {} not found'.format(gdb))
        if not which(openocd):
            raise GdbError('Executable {} not found'.format(openocd))
        xlen = 32  # Default
        try:
            run_and_log(print_and_log("Starting openocd"), run([openocd, '-f', openocd_config_filename], \
                        timeout=0.5, stdout=PIPE, stderr=PIPE))
        except TimeoutExpired as exc:
            log = str(exc.stderr, encoding='utf-8')
            match = re.search('XLEN=(32|64)', log)
            if match:
                xlen = int(match.group(1))
            else:
                raise GdbError('XLEN not found by OpenOCD')

        # Create temporary files for gdb and openocd.  The `NamedTemporaryFile`
        # objects are stored in `self` so the files stay around as long as this
        # `GdbSession` is in use.  We open both in text mode, instead of the
        # default 'w+b'.
        self.openocd_log = tempfile.NamedTemporaryFile(mode='w',
                                                       prefix='openocd.',
                                                       suffix='.log')
        self.gdb_log = tempfile.NamedTemporaryFile(mode='w',
                                                   prefix='gdb.',
                                                   suffix='.log')

        init_cmds = '\n'.join([
            'set confirm off', 'set pagination off'
            'set width 0', 'set height 0', 'set print entry-values no',
            'set remotetimeout {}'.format(timeout),
            'set arch riscv:rv{}'.format(xlen),
            'target remote | {} -c "gdb_port pipe; log_output {}" -f {}'.
            format(openocd, self.openocd_log.name, openocd_config_filename)
        ])

        self.pty = spawn(gdb,
                         encoding='utf-8',
                         logfile=self.gdb_log,
                         timeout=timeout)
        self.repl = REPLWrapper(self.pty,
                                '(gdb) ',
                                None,
                                extra_init_cmd=init_cmds)
Ejemplo n.º 11
0
    def test_os_defpath_which(self):
        " which() finds an executable in $PATH and returns its abspath. "

        bin_dir = tempfile.mkdtemp()
        if sys.getfilesystemencoding() in ("ascii", "ANSI_X3.4-1968"):
            prefix = "ascii-"
        else:
            prefix = u"ǝpoɔıun-"
        temp_obj = tempfile.NamedTemporaryFile(suffix=u".sh",
                                               prefix=prefix,
                                               dir=bin_dir,
                                               delete=False)
        bin_path = temp_obj.name
        fname = os.path.basename(temp_obj.name)
        save_path = os.environ["PATH"]
        save_defpath = os.defpath

        try:
            # setup
            os.environ["PATH"] = ""
            os.defpath = bin_dir
            with open(bin_path, "w") as fp:
                pass

            # given non-executable,
            os.chmod(bin_path, 0o400)

            # exercise absolute and relative,
            assert pexpect.which(bin_path) is None
            assert pexpect.which(fname) is None

            # given executable,
            os.chmod(bin_path, 0o700)

            # exercise absolute and relative,
            assert pexpect.which(bin_path) == bin_path
            assert pexpect.which(fname) == bin_path

        finally:
            # restore,
            os.environ["PATH"] = save_path
            os.defpath = save_defpath

            # destroy scratch files and folders,
            if os.path.exists(bin_path):
                os.unlink(bin_path)
            if os.path.exists(bin_dir):
                os.rmdir(bin_dir)
Ejemplo n.º 12
0
async def test_telnet_client_cmdline(bind_host, unused_tcp_port, event_loop):
    """Test executing telnetlib3/client.py as client"""
    # this code may be reduced when pexpect asyncio is bugfixed ..
    # we especially need pexpect to pass sys.stdin.isatty() test.
    prog = pexpect.which('telnetlib3-client')
    args = [prog, bind_host, str(unused_tcp_port), '--loglevel=info',
            '--connect-minwait=0.05', '--connect-maxwait=0.05']

    class HelloServer(asyncio.Protocol):
        def connection_made(self, transport):
            super().connection_made(transport)
            transport.write(b'hello, space cadet.\r\n')
            # hangup
            event_loop.call_soon(transport.close)

    # start vanilla tcp server
    await event_loop.create_server(HelloServer,
                                        bind_host, unused_tcp_port)

    proc = await asyncio.create_subprocess_exec(
        *args, loop=event_loop,
        stdin=asyncio.subprocess.PIPE,
        stdout=asyncio.subprocess.PIPE)

    line = await asyncio.wait_for(proc.stdout.readline(), 1.5)
    assert line.strip() == b"Escape character is '^]'."

    line = await asyncio.wait_for(proc.stdout.readline(), 1.5)
    assert line.strip() == b'hello, space cadet.'

    # message received, expect the client to gracefully quit.
    out, err = await asyncio.wait_for(proc.communicate(), 1)
    assert out == b'\x1b[m\nConnection closed by foreign host.\n'
Ejemplo n.º 13
0
    def req_check(self):
        # check pexpect

        # check BlueZ
        # gatttool path
        #self.gatttool_path = "/usr/local/bluez5/attrib/gatttool"
        self.gatttool_path = pexpect.which('gatttool')
        if not self.gatttool_path:
            return "Please install the BlueZ stack: 'apt-get install bluez'"

        # if there is no MAC set, try to search for a drone (requires root)
        if not self.mac:
            if os.geteuid() != 0:
                return "Drone MAC missing. Init with 'mac=' or run as root to scan."
            lescan = pexpect.spawn("hcitool lescan")
            index = lescan.expect(P_OUIS, timeout=5)
            if index != 0:
                return "Couldn't find any drones nearby."
            self.mac = lescan.after
            self.cb(0, "Drone found! MAC: " + self.mac)

        elif not re.match(P_MAC, self.mac):
            return "Drone MAC format incorrect, please check it. Format: XX:XX:XX:XX:XX:XX"

        self.cb(0, "Everything seems to be alright, time to fly!")
        return None
Ejemplo n.º 14
0
def test_newtool(tmpdir):
    """
    Run 'pytool newtool testtool' while testtool.py does not exist.
    Verify that testtool.py is created and has the right contents.
    """
    pytest.debug_func()
    toolname = toyfile(tmpdir, "testtool.py")
    toollink = toyfile(tmpdir, "testtool")
    with U.Chdir(tmpdir.strpath):
        cmd = pexpect.which("pytool")
        if cmd is None:
            pytest.skip("pytool not found")
        S = pexpect.spawn("{} newtool {} tt".format(cmd, toollink.strpath))
        which = S.expect([r'Are you sure\? >',
                          'Error:',
                          pexpect.EOF])
        if which == 0:
            S.sendline('no')
            S.expect(pexpect.EOF)
            pytest.fail('should not have asked about overwriting')
        elif which == 1:
            print S.before + S.after
            pytest.fail('unexpected exception')

        assert toolname.strpath == toollink.readlink()

        expected = expected_testtool_py()
        got = toolname.read().split("\n")
        assert got == expected
Ejemplo n.º 15
0
def test_newpy_overwriting_no(tmpdir):
    """
    Run 'pytool newpy xyzzy' when xyzzy already exists. Verify
    that confirmation is requested. Answer 'no' and verify that
    the existing file is not overwritten.
    """
    pytest.debug_func()
    xyzzy = toyfile(tmpdir, "xyzzy", content="original xyzzy\n")
    xyzzy_py = toyfile(tmpdir, "xyzzy.py", content="original xyzzy.py\n")
    with U.Chdir(tmpdir.strpath):
        cmd = pexpect.which("pytool")
        S = pexpect.spawn("{} newpy xyzzy".format(cmd))
        which = S.expect([r'you sure\? >',
                          'Error:',
                          pexpect.EOF])
        if which == 0:
            S.sendline('no')
            S.expect(pexpect.EOF)
        elif which == 1:
            print S.before + S.after
            pytest.fail('unexpected exception')
        else:
            pytest.fail('should have asked about overwriting xyzzy')

        expected = ['original xyzzy']
        got = U.contents(xyzzy.strpath)
        assert got == expected

        expected = ['original xyzzy.py']
        got = U.contents(xyzzy_py.strpath)
        assert got == expected
Ejemplo n.º 16
0
def test_newpy_overwriting_yes(tmpdir):
    """
    Run 'pytool newpy xyzzy' when xyzzy, xyzzy.py already exist.
    Verify that confirmation is requested. Answer 'yes' and verify
    that the existing file IS overwritten.
    """
    pytest.debug_func()
    xyzzy = toyfile(tmpdir, "xyzzy", content="original xyzzy")
    xyzzy_py = toyfile(tmpdir, "xyzzy.py", content="original xyzzy.py")
    with U.Chdir(tmpdir.strpath):
        cmd = pexpect.which('pytool')
        S = pexpect.spawn('%s newpy %s' % (cmd, xyzzy.strpath))
        which = S.expect([r'Are you sure\? >',
                          'Error:',
                          pexpect.EOF])
        if which == 0:
            S.sendline('yes')
            S.expect(pexpect.EOF)
        elif which == 1:
            print S.before + S.after
            pytest.fail('unexpected exception')
        else:
            pytest.fail('should have asked about overwriting xyzzy')

        exp = os.path.abspath(xyzzy_py.strpath)
        got = os.readlink(xyzzy.strpath)
        assert got == exp

        expected = expected_xyzzy_py()
        got = U.contents(xyzzy_py.strpath)
        assert got == expected
Ejemplo n.º 17
0
def check_missing_requirements ():
    """This list of missing requirements (mencoder, mplayer, lame, and mkvmerge).
    Returns None if all requirements are in the execution path.
    """
    missing = []
    if pexpect.which("mencoder") is None:
        missing.append("mencoder")
    if pexpect.which("mplayer") is None:
        missing.append("mplayer")
    #if pexpect.which("lame") is None:
    #    missing.append("lame")
    #if pexpect.which("mkvmerge") is None:
    #    missing.append("mkvmerge")
    if len(missing)==0:
        return None
    return missing
Ejemplo n.º 18
0
def test_newtool_overwriting_yes(tmpdir):
    """
    Run 'pytool newtool testtool tt' while testtool.py exists. Verify that
    we are prompted about overwriting. Answer 'yes' and verify that the
    original file is overwritten.
    """
    pytest.debug_func()
    tname = toyfile(tmpdir, "testtool.py", content=["original testtool.py"])
    tlink = toyfile(tmpdir, "testtool", content=["original testtool"])
    with U.Chdir(tmpdir.strpath):
        cmd = pexpect.which("pytool")
        if cmd is None:
            pytest.skip("pytool not found")
        S = pexpect.spawn("{} newtool {} tt".format(cmd, tlink))
        which = S.expect([r'Are you sure\? >',
                          'Error:',
                          pexpect.EOF])
        if which == 0:
            S.sendline('yes')
            S.expect(pexpect.EOF)
        elif which == 1:
            print S.before + S.after
            pytest.fail('unexpected exception')
        else:
            pytest.fail("should have asked about overwriting {}".format(tname))

        exp = tname.strpath
        actual = tlink.readlink()
        assert actual == exp

        expected = expected_testtool_py()
        got = tname.read().split("\n")
        assert got == expected
Ejemplo n.º 19
0
    def sh(self):
        if self._sh is None:
            self._sh = pexpect.which('sh')
            if self._sh is None:
                raise OSError('"sh" shell not found')

        return self._sh
Ejemplo n.º 20
0
async def test_telnet_client_cmdline(bind_host, unused_tcp_port):
    """Test executing asynctelnet/client.py as client"""
    # this code may be reduced when pexpect asyncio is bugfixed ..
    # we especially need pexpect to pass sys.stdin.isatty() test.
    prog = pexpect.which('asynctelnet-client')
    args = [
        prog, bind_host,
        str(unused_tcp_port), '--loglevel=info', '--connect-minwait=0.05',
        '--connect-maxwait=0.05'
    ]

    class HelloServer(asyncio.Protocol):
        def connection_made(self, transport):
            super().connection_made(transport)
            transport.write(b'hello, space cadet.\r\n')
            # hangup
            event_loop.call_soon(transport.close)

    # start vanilla tcp server
    await event_loop.create_server(HelloServer, bind_host, unused_tcp_port)

    proc = await asyncio.create_subprocess_exec(*args,
                                                stdin=asyncio.subprocess.PIPE,
                                                stdout=asyncio.subprocess.PIPE)

    line = await asyncio.wait_for(proc.stdout.readline(), 1.5)
    assert line.strip() == b"Escape character is '^]'."

    line = await asyncio.wait_for(proc.stdout.readline(), 1.5)
    assert line.strip() == b'hello, space cadet.'

    # message received, expect the client to gracefully quit.
    out, err = await asyncio.wait_for(proc.communicate(), 1)
    assert out == b'\x1b[m\nConnection closed by foreign host.\n'
Ejemplo n.º 21
0
 def sh(self):
     if self._sh is None:        
         self._sh = pexpect.which('sh')
         if self._sh is None:
             raise OSError('"sh" shell not found')
     
     return self._sh
Ejemplo n.º 22
0
    def test_which_should_not_match_folders(self):
        " Which does not match folders, even though they are executable. "
        # make up a path and insert a folder that is 'executable', a naive
        # implementation might match (previously pexpect versions 3.2 and
        # sh versions 1.0.8, reported by @lcm337.)
        fname = 'g++'
        bin_dir = tempfile.mkdtemp()
        bin_dir2 = os.path.join(bin_dir, fname)
        save_path = os.environ['PATH']
        try:
            os.environ['PATH'] = bin_dir
            os.mkdir(bin_dir2, 0o755)
            # should not be found because it is not executable *file*,
            # but rather, has the executable bit set, as a good folder
            # should -- it should not be returned because it fails isdir()
            exercise = pexpect.which(fname)
            assert exercise is None

        finally:
            # restore,
            os.environ['PATH'] = save_path
            # destroy scratch folders,
            for _dir in (
                    bin_dir2,
                    bin_dir,
            ):
                if os.path.exists(_dir):
                    os.rmdir(_dir)
Ejemplo n.º 23
0
    def test_which_should_not_match_folders(self):
        " Which does not match folders, even though they are executable. "
        # make up a path and insert a folder that is 'executable', a naive
        # implementation might match (previously pexpect versions 3.2 and
        # sh versions 1.0.8, reported by @lcm337.)
        fname = 'g++'
        bin_dir = tempfile.mkdtemp()
        bin_dir2 = os.path.join(bin_dir, fname)
        save_path = os.environ['PATH']
        try:
            os.environ['PATH'] = bin_dir
            os.mkdir(bin_dir2, 0o755)
            # should not be found because it is not executable *file*,
            # but rather, has the executable bit set, as a good folder
            # should -- it should not be returned because it fails isdir()
            exercise = pexpect.which(fname)
            assert exercise is None

        finally:
            # restore,
            os.environ['PATH'] = save_path
            # destroy scratch folders,
            for _dir in (bin_dir2, bin_dir,):
                if os.path.exists(_dir):
                    os.rmdir(_dir)
Ejemplo n.º 24
0
def test_newtool_overwriting_no(tmpdir):
    """
    Run 'pytool newtool testtool tt' while testtool.py does exist. Verify
    that we are prompted about overwriting. Answer 'no' and verify that the
    original file is not overwritten.
    """
    pytest.debug_func()
    tname = toyfile(tmpdir, "testtool.py", content=["original testtool.py"])
    tlink = toyfile(tmpdir, "testtool", content=["original testtool"])
    with U.Chdir(tmpdir.strpath):
        cmd = pexpect.which("pytool")
        if cmd is None:
            pytest.skip("pytool not found")
        S = pexpect.spawn("{} newtool {} tt".format(cmd, tlink))
        which = S.expect([r'Are you sure\? >',
                          'Error:',
                          pexpect.EOF])
        if which == 0:
            S.sendline('no')
            S.expect(pexpect.EOF)
        elif which == 1:
            print S.before + S.after
            pytest.fail('unexpected exception')
        else:
            pytest.fail("should have asked about overwriting {}".format(tname))

        for fname in [tlink, tname]:
            exp = "original %s" % fname.basename
            got = fname.read()
            assert got == exp
Ejemplo n.º 25
0
def test_telnet_client_cmdline_stdin_pipe(bind_host, unused_tcp_port,
                                          event_loop):
    """Test sending data through command-line client (by os PIPE)."""
    # this code may be reduced when pexpect asyncio is bugfixed ..
    # we especially need pexpect to pass sys.stdin.isatty() test.
    prog = pexpect.which('telnetlib3-client')
    fd, logfile = tempfile.mkstemp(prefix='telnetlib3', suffix='.log')
    os.close(fd)

    args = [
        prog, bind_host,
        str(unused_tcp_port), '--loglevel=info', '--connect-minwait=0.15',
        '--connect-maxwait=0.15', '--logfile={0}'.format(logfile)
    ]

    @asyncio.coroutine
    def shell(reader, writer):
        writer.write('Press Return to continue:')
        inp = yield from reader.readline()
        if inp:
            writer.echo(inp)
            writer.write('\ngoodbye.\n')
        yield from writer.drain()
        writer.close()

    # start server
    yield from telnetlib3.create_server(host=bind_host,
                                        port=unused_tcp_port,
                                        shell=shell,
                                        loop=event_loop,
                                        connect_maxwait=0.05)

    # start client by way of pipe
    proc = yield from asyncio.create_subprocess_exec(
        *args,
        loop=event_loop,
        stdin=asyncio.subprocess.PIPE,
        stdout=asyncio.subprocess.PIPE,
        stderr=asyncio.subprocess.PIPE)

    #line = yield from asyncio.wait_for(proc.stdout.readline(), 1.5)
    #assert line.strip() == b"Escape character is '^]'."

    # message received, expect the client to gracefully quit.
    stdout, stderr = yield from asyncio.wait_for(proc.communicate(b'\r'), 2)

    # And finally, analyze the contents of the logfile,
    # - 2016-03-18 20:19:25,227 INFO client_base.py:113 Connected to <Peer 127.0.0.1 51237>
    # - 2016-03-18 20:19:25,286 INFO client_base.py:67 Connection closed to <Peer 127.0.0.1 51237>
    logfile_output = open(logfile).read().splitlines()
    assert stdout == (b"Escape character is '^]'.\n"
                      b"Press Return to continue:\r\ngoodbye.\n"
                      b"\x1b[m\nConnection closed by foreign host.\n")

    # verify,
    assert len(logfile_output) == 2, logfile
    assert 'Connected to <Peer' in logfile_output[0], logfile
    assert 'Connection closed to <Peer' in logfile_output[1], logfile
    os.unlink(logfile)
Ejemplo n.º 26
0
 def test_bash_which(self):
     """
     Calling bash_which('emacs') should get back a string with a path to the
     emacs executable
     """
     self.dbgfunc()
     self.assertEq(pexpect.which("emacs"),
                   bscr.bash_which("emacs"))
Ejemplo n.º 27
0
    def cmdline():
        binpath = pexpect.which('gnuchess')
        if binpath is None:
            utils.log.error('cannot find gnuchess on this system')

        args = ['--xboard']

        return [binpath] + args
Ejemplo n.º 28
0
    def cmdline():
        binpath = pexpect.which('gnuchess')
        if binpath is None:
            utils.log.error('cannot find gnuchess on this system')

        args    = ['--xboard']

        return [binpath] + args
Ejemplo n.º 29
0
def test_ascii(fx_ascii):
    """
    Run ascii and see if its output matches what is expected.
    """
    pytest.debug_func()
    cmd = pexpect.which("ascii")
    result = pexpect.run(cmd)
    assert "\r\n".join(fx_ascii.exp) == result
Ejemplo n.º 30
0
 def script_which_command(self, cmdname):
     """
     ScriptBase: Make sure the tcc command exists and is executable
     """
     cmd = pexpect.which(cmdname)
     if cmd is None:
         cmd = "bin/" + cmdname
     self.assertTrue(os.access(cmd, os.X_OK))
Ejemplo n.º 31
0
    def sh(self):
        if self._sh is None:
            shell_name = os.environ.get("SHELL", "sh")
            self._sh = pexpect.which(shell_name)
            if self._sh is None:
                raise OSError('"{}" shell not found'.format(shell_name))

        return self._sh
Ejemplo n.º 32
0
def test_final_newline(fx_ascii):
    """
    Run ascii and verify output ends with a newline
    """
    pytest.debug_func()
    cmd = pexpect.which("ascii")
    result = pexpect.run(cmd)
    assert "\r\n".join(fx_ascii.exp) == result
Ejemplo n.º 33
0
def setup_commands():
    """
    Bootstrap the PATH to have /usr/local/bin, where the op command should be
    """
    os.environ["PATH"] += os.pathsep + '/usr/local/bin'
    basecmd = 'op'
    cmdpath = pexpect.which(basecmd)
    return cmdpath
Ejemplo n.º 34
0
 def script_which_command(self, cmdname):
     """
     ScriptBase: Make sure the tcc command exists and is executable
     """
     cmd = pexpect.which(cmdname)
     if cmd is None:
         cmd = "bin/" + cmdname
     self.assertTrue(os.access(cmd, os.X_OK))
Ejemplo n.º 35
0
def run(cmd, args, log):
    """
    Execute CMD with argument ARGS in a subshell with pty.
    
    CMD: The command.  

    ARGS: The command arguments.
    """
    # print(cmd, args, log)

    if not pexpect.which(cmd):
        raise click.UsageError(f"ERROR: Command '{cmd}' not found.")

    logfile = None
    if log:
        logfile = open(log, 'a')

    cols, rows = shutil.get_terminal_size(fallback=(400, 100))

    process = pexpect.spawn(f'{cmd} {" ".join(args)}', dimensions=(rows, cols))

    patterns = process.compile_pattern_list([
        '\r\n',
        '\r',
        pexpect.TIMEOUT,
        pexpect.EOF,
    ])

    while True:
        index = process.expect(patterns, timeout=60)

        # Newline
        if index == 0:
            text = process.before.decode('utf-8')
            print(text, flush=True)
            if log:
                print(text, file=logfile)

        # Carriage return
        elif index == 1:
            if not process.before:
                continue
            text = process.before.decode('utf-8')
            print(text, flush=True)
            if log:
                print(text, file=logfile)
        # Timeout
        elif index == 2:
            print('<pytee: 60 sec elapsed without new input>')
            continue
        else:
            break
    process.close()

    # print(process.exitstatus, process.signalstatus)
    #raise SystemExit(process.exitstatus)
    return process.exitstatus
Ejemplo n.º 36
0
 def _path_for(self, cmd):
     if cmd in self._bin_paths:
         return self._bin_paths[cmd]
     else:
         path = pexpect.which(cmd)
         if path is None:
             raise CommandNotFoundError("failed to find path of %r" % cmd)
         self._bin_paths[cmd] = path
         return path
Ejemplo n.º 37
0
def test_ascii_help():
    """
    Run 'ascii --help' and validate the output
    """
    pytest.debug_func()
    cmd = pexpect.which("ascii")
    result = pexpect.run("%s --help" % cmd)
    exp = "Display ASCII collating sequence"
    assert exp in result
Ejemplo n.º 38
0
 def _path_for(self, cmd):
     if cmd in self._bin_paths:
         return self._bin_paths[cmd]
     else:
         path = pexpect.which(cmd)
         if path is None:
             raise CommandNotFoundError('failed to find path of %r' % cmd)
         self._bin_paths[cmd] = path
         return path
Ejemplo n.º 39
0
def check_dependencies(commands=[]):
    """Check for the existence of required commands, and sudo access"""
    # Check for sudo
    if pexpect.which("sudo") is None:
        return False

    # Check for required commands
    for command in commands:
        if pexpect.which(command) is None:
            return False

    # Check for LANG requirements
    child = None
    try:
        child = env_spawn('sudo', ['-v'], 1)
        if child.expect([".*ssword.*", "Sorry",
                         pexpect.EOF,
                         pexpect.TIMEOUT]) == 3:
            global use_env
            use_env = True
        child.close()
    except OSError:
        if child is not None:
            child.close()
        return False

    # Check for sudo rights
    child = env_spawn('sudo', ['-v'], 1)
    try:
        index = child.expect([".*ssword.*", "Sorry",
                              pexpect.EOF, pexpect.TIMEOUT])
        child.close()
        if index == 0 or index == 2:
            # User in sudoers, or already admin
            return True
        elif index == 1 or index == 3:
            # User not in sudoers
            return False

    except:
        # Something else went wrong.
        child.close()

    return False
Ejemplo n.º 40
0
    def test_os_defpath_which(self):
        " which() finds an executable in $PATH and returns its abspath. "

        bin_dir = tempfile.mkdtemp()
        temp_obj = tempfile.NamedTemporaryFile(suffix=u'.sh',
                                               prefix=u'ǝpoɔıun-',
                                               dir=bin_dir,
                                               delete=False)
        bin_path = temp_obj.name
        fname = os.path.basename(temp_obj.name)
        save_path = os.environ['PATH']
        save_defpath = os.defpath

        try:
            # setup
            os.environ['PATH'] = ''
            os.defpath = bin_dir
            with open(bin_path, 'w') as fp:
                pass

            # given non-executable,
            os.chmod(bin_path, 0o400)

            # exercise absolute and relative,
            assert pexpect.which(bin_path) is None
            assert pexpect.which(fname) is None

            # given executable,
            os.chmod(bin_path, 0o700)

            # exercise absolute and relative,
            assert pexpect.which(bin_path) == bin_path
            assert pexpect.which(fname) == bin_path

        finally:
            # restore,
            os.environ['PATH'] = save_path
            os.defpath = save_defpath

            # destroy scratch files and folders,
            if os.path.exists(bin_path):
                os.unlink(bin_path)
            if os.path.exists(bin_dir):
                os.rmdir(bin_dir)
Ejemplo n.º 41
0
def CompleteReportAsRoot(run_as,tmp_configfile,gui=False):
	"""Run a new instance of inforevealer with root priviledge to complete tmp_configfile"""
    
	if gui: from gui import askPassword

	if run_as == "substitute":
		#find the substitute user command and run the script	

		if pexpect.which('su') != None:
			message=_("Please, enter the root password.")
			root_instance = str(pexpect.which('su')) + " - -c \'"+ os.path.abspath(sys.argv[0])+" --runfile "+ tmp_configfile+"\'" 
			
		elif pexpect.which('sudo') != None: #TODO checkme
			message=_("Please, enter your user password.")
			root_instance = str(pexpect.which('sudo')) + ' ' + os.path.abspath(sys.argv[0])+' --runfile '+ tmp_configfile
		else:
			sys.stderr.write(_("Error: No substitute user command available.\n"))
			return 1
		ret=""
		count=0
		while ret!=[' \r\n'] and count <3:
			#Get password
			count+=1
			if gui:
				password=askPassword(question=message)
			else:
				print(message)
				password=getpass.getpass()
			if password != False: #askPassword could return False
				#Run the command #TODO exceptions ?
				child = pexpect.spawn(root_instance)
				ret=child.expect([".*:",pexpect.EOF]) #Could we do more ?
				child.sendline(password)
				ret = child.readlines() 
				if ret ==[' \r\n']: return 0
		message=_("Wrong password.\nThe log will be generated without root priviledge.")
		if gui:
			import gtk
			md = gtk.MessageDialog(None, gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_INFO, gtk.BUTTONS_CLOSE, message)
			md.set_title(_("Error"))
			md.run()
			md.destroy()
		else:
			print(message)
Ejemplo n.º 42
0
    def test_os_defpath_which(self):
        " which() finds an executable in $PATH and returns its abspath. "

        bin_dir = tempfile.mkdtemp()
        temp_obj = tempfile.NamedTemporaryFile(
            suffix=u'.sh', prefix=u'ǝpoɔıun-',
            dir=bin_dir, delete=False)
        bin_path = temp_obj.name
        fname = os.path.basename(temp_obj.name)
        save_path = os.environ['PATH']
        save_defpath = os.defpath

        try:
            # setup
            os.environ['PATH'] = ''
            os.defpath = bin_dir
            with open(bin_path, 'w') as fp:
                pass

            # given non-executable,
            os.chmod(bin_path, 0o400)

            # exercise absolute and relative,
            assert pexpect.which(bin_path) is None
            assert pexpect.which(fname) is None

            # given executable,
            os.chmod(bin_path, 0o700)

            # exercise absolute and relative,
            assert pexpect.which(bin_path) == bin_path
            assert pexpect.which(fname) == bin_path

        finally:
            # restore,
            os.environ['PATH'] = save_path
            os.defpath = save_defpath

            # destroy scratch files and folders,
            if os.path.exists(bin_path):
                os.unlink(bin_path)
            if os.path.exists(bin_dir):
                os.rmdir(bin_dir)
Ejemplo n.º 43
0
 def __init__(self, execpath=pexpect.which('M2'), timeout=4, configpath=None):
     """"""
     self.conf = M2Config(execpath, configpath)
     self.proc = None
     self.proc_command = self.conf.args.execpath
     self.proc_kwargs = {
         'args': ['--silent', '--no-debug', '-e', 'load("init.m2")'],
         'cwd': os.path.dirname(__file__) + '/assets/m2-code/',
         'timeout': timeout
     }
Ejemplo n.º 44
0
async def test_telnet_client_cmdline_stdin_pipe(bind_host, unused_tcp_port,
                                          event_loop):
    """Test sending data through command-line client (by os PIPE)."""
    # this code may be reduced when pexpect asyncio is bugfixed ..
    # we especially need pexpect to pass sys.stdin.isatty() test.
    prog = pexpect.which('telnetlib3-client')
    fd, logfile = tempfile.mkstemp(prefix='telnetlib3', suffix='.log')
    os.close(fd)

    args = [prog, bind_host, str(unused_tcp_port), '--loglevel=info',
            '--connect-minwait=0.15', '--connect-maxwait=0.15',
            '--logfile={0}'.format(logfile)]

    @asyncio.coroutine
    def shell(reader, writer):
        writer.write('Press Return to continue:')
        inp = yield from reader.readline()
        if inp:
            writer.echo(inp)
            writer.write('\ngoodbye.\n')
        yield from writer.drain()
        writer.close()

    # start server
    await telnetlib3.create_server(
        host=bind_host, port=unused_tcp_port,
        shell=shell, loop=event_loop,
        connect_maxwait=0.05)

    # start client by way of pipe
    proc = await asyncio.create_subprocess_exec(
        *args, loop=event_loop,
        stdin=asyncio.subprocess.PIPE,
        stdout=asyncio.subprocess.PIPE,
        stderr=asyncio.subprocess.PIPE)

    #line = await asyncio.wait_for(proc.stdout.readline(), 1.5)
    #assert line.strip() == b"Escape character is '^]'."

    # message received, expect the client to gracefully quit.
    stdout, stderr = await asyncio.wait_for(proc.communicate(b'\r'), 2)

    # And finally, analyze the contents of the logfile,
    # - 2016-03-18 20:19:25,227 INFO client_base.py:113 Connected to <Peer 127.0.0.1 51237>
    # - 2016-03-18 20:19:25,286 INFO client_base.py:67 Connection closed to <Peer 127.0.0.1 51237>
    logfile_output = open(logfile).read().splitlines()
    assert stdout == (b"Escape character is '^]'.\n"
                      b"Press Return to continue:\r\ngoodbye.\n"
                      b"\x1b[m\nConnection closed by foreign host.\n")

    # verify,
    assert len(logfile_output) == 2, logfile
    assert 'Connected to <Peer' in logfile_output[0], logfile
    assert 'Connection closed to <Peer' in logfile_output[1], logfile
    os.unlink(logfile)
Ejemplo n.º 45
0
 def test_bscr_help_help(self):
     """
     Test 'bscr help help'
     """
     self.dbgfunc()
     cmd = pexpect.which('bscr')
     result = pexpect.run('%s help help' % cmd)
     self.assertFalse('Traceback' in result)
     self.assertTrue('help - show a list' in result)
     self.assertTrue('With no arguments' in result)
     self.assertTrue('With a command as argument' in result)
Ejemplo n.º 46
0
 def test_bscr_help(self):
     """
     Test 'bscr help'
     """
     self.dbgfunc()
     cmd = pexpect.which('bscr')
     result = pexpect.run('%s help' % cmd)
     self.assertFalse('Traceback' in result)
     for f in [x for x in dir(bscr.bscr) if x.startswith('bscr_')]:
         subc = f.replace('bscr_', '')
         self.assertTrue('%s - ' % subc in result)
Ejemplo n.º 47
0
def test_align_help():
    """
    Verify that 'align --help' does the right thing
    """
    pytest.debug_func()
    cmd = pexpect.which("align")
    result = pexpect.run("%s --help" % cmd)
    nexp = "Traceback"
    assert nexp not in result
    exp = "Align columns from input"
    assert exp in result
Ejemplo n.º 48
0
def test_calc_help():
    """
    Verify that 'calc --help' does the right thing
    """
    pytest.debug_func()
    cmd = pexpect.which("calc")
    result = pexpect.run("%s --help" % cmd)
    nexp = "Traceback"
    assert nexp not in result
    exp = "Usage: calc [options]"
    assert exp in result
Ejemplo n.º 49
0
 def test_fl_help_help(self):
     """
     'fl help help' should get help for the help command
     """
     cmd = pexpect.which('fl')
     result = pexpect.run('%s help help' % cmd)
     self.assertFalse('Traceback' in result)
     for f in ['help - show a list of available commands',
               'With no arguments, show a list of commands',
               'With a command as argument, show help for that command',
               ]:
         self.assertTrue(f in result)
Ejemplo n.º 50
0
def run(parent_dir=None, logfile=None, verbose=False):
    """Create TinyTim PSFs using standardized parameters

    This function will automatically generate ALL PSFs listed in the
    global filter dictionaries in the module in a tree with a directory for each
    detector.

    """
    psf_classes = {('ACS', 'WFC'): WFCPSF,
                   ('ACS', 'HRC'): HRCPSF,
                   ('ACS', 'SBC'): SBCPSF,
                   ('WFC3', 'UVIS'): UVISPSF,
                   ('WFC3', 'IR'): IRPSF}

    if pexpect.which('tiny1') is None:
        raise FileNotFoundError("TinyTim executables NOT found! Please install first..")

    if parent_dir is None:
        parent_dir = os.getcwd()

    try:
        for instr, detectors in FILTER_DICT.items():
            instr_path = os.path.join(parent_dir, instr.lower())
            if not os.path.exists(instr_path):
                os.makedirs(instr_path)
            # move into that directory
            os.chdir(instr_path)
            # Now, let's start looping over the detectors
            for det, filter_names in detectors.items():
                det_path = os.path.join(instr_path, det.lower())
                if not os.path.exists(det_path):
                    os.makedirs(det_path)
                # move into that directory
                os.chdir(det_path)
                # Now, start creating the PSFs listed in the filter_dict for this detector
                for filter_name in filter_names:
                    # Create class for this PSF
                    psfobj = psf_classes[(instr, det)](filter_name,
                                                       logfile=logfile,
                                                       verbose=verbose)
                    psfobj.tiny1()
                    psfobj.tiny2()
                    psfobj.tiny3()
                # We are finished with creating all the PSFs for this detector...
                # Return to parent instrument directory
                os.chdir(instr_path)

            # We are finished with all the PSFs for this instrument...
            # return to the parent directory
            os.chdir(parent_dir)
    finally:
        os.chdir(parent_dir)
Ejemplo n.º 51
0
def check_missing_requirements ():
    """This list of missing requirements (mencoder, mplayer, lame, and mkvmerge).
    Returns None if all requirements are in the execution path.
    """
    missing = []
    if pexpect.which("mencoder") is None:
        missing.append("mencoder")
    if pexpect.which("mplayer") is None:
        missing.append("mplayer")
    cmd = "mencoder -oac help"
    (command_output, exitstatus) = run(cmd)
    ar = re.findall("(mp3lame)", command_output)
    if len(ar)==0:
        missing.append("Mencoder was not compiled with mp3lame support.")
    
    #if pexpect.which("lame") is None:
    #    missing.append("lame")
    #if pexpect.which("mkvmerge") is None:
    #    missing.append("mkvmerge")
    if len(missing)==0:
        return None
    return missing
Ejemplo n.º 52
0
def check_dependencies(commands=[]):
    """Check for the existence of required commands, and sudo access"""
    # Check for required commands
    for command in commands:
        if pexpect.which(command) is None:
            return False

    # Check for sudo or pkexec
    if pexpect.which("pkexec") is not None:
        return True

    if pexpect.which("sudo") is None:
        return False

    # Check for LANG requirements
    child = env_spawn('sudo -v', 1)
    if child.expect([".*ssword.*", "Sorry",
                     pexpect.EOF,
                     pexpect.TIMEOUT]) == 3:
        global use_env
        use_env = True
    child.close()

    # Check for sudo rights
    child = env_spawn('sudo -v', 1)
    try:
        index = child.expect([".*ssword.*", "Sorry",
                              pexpect.EOF, pexpect.TIMEOUT])
        child.close()
        if index in [0, 2]:
            # User in sudoers, or already admin
            return True

    except Exception:
        # Something else went wrong.
        child.close()

    return False
Ejemplo n.º 53
0
    def which(filename: str, env: Optional[Mapping[str, str]] = None):
        '''This takes a given filename; tries to find it in the environment path;
        then checks if it is executable. This returns the full path to the filename
        if found and executable. Otherwise this returns None.

        If `env` is not specified, use `os.environ` instead.

        Example:

        | ${path} | `Which` | java | { 'PATH': '/usr/lib/jvm/java-1.14.0-openjdk-amd64/bin' } |
        | Log To Console | ${path} |

        '''
        return pexpect.which(filename, env)
Ejemplo n.º 54
0
 def script_help(self, cmdname, helplist):
     """
     ScriptBase: Make sure 'tcc help' generates something reasonable
     """
     cmd = pexpect.which(cmdname)
     if cmd is None:
         cmd = "bin/" + cmdname
     result = pexpect.run("%s help" % cmd)
     self.assertFalse(
         "Traceback" in result,
         "'Traceback' not expected in %s" % U.line_quote(result))
     for item in helplist:
         self.assertTrue(item in result,
                         "Expected '%s' in '%s'" % (item, result))
Ejemplo n.º 55
0
 def _start_gap(self):
     # Signal handlers are inherited by forked processes, and we can't easily
     # reset it from the subprocess. Since kernelapp ignores SIGINT except in
     # message handlers, we need to temporarily reset the SIGINT handler here
     # so that gap and its children are interruptible.
     sig = signal.signal(signal.SIGINT, signal.SIG_DFL)
     try:
         # setup.g contains functions needed for Jupyter interfacing
         setupg = path.dirname(path.abspath(__file__))
         if which('gap') != None:
             gap_run_command = which('gap')
         elif which('gap.sh') != None:
             gap_run_command = which('gap.sh')
         else:
             raise NameError('gap executable not found')
         self.gapwrapper = replwrap.REPLWrapper(
             gap_run_command + ' -n -b -T %s/gap/setup.g' % (setupg),
             u'gap|| ',
             None,
             None,
             continuation_prompt=u'|| ')
         self.gapwrapper.run_command("\n")
     finally:
         signal.signal(signal.SIGINT, sig)
Ejemplo n.º 56
0
 def test_path_from_env(self):
     " executable found from optional env argument "
     bin_name = 'pexpect-test-path-from-env'
     tempdir = tempfile.mkdtemp()
     try:
         bin_path = os.path.join(tempdir, bin_name)
         with open(bin_path, 'w') as f:
             f.write('# test file not to be run')
         try:
             os.chmod(bin_path, 0o700)
             found_path = pexpect.which(bin_name, env={'PATH': tempdir})
         finally:
             os.remove(bin_path)
         self.assertEqual(bin_path, found_path)
     finally:
         os.rmdir(tempdir)
Ejemplo n.º 57
0
async def test_telnet_server_cmdline(bind_host, unused_tcp_port, event_loop):
    """Test executing telnetlib3/server.py as server"""
    # this code may be reduced when pexpect asyncio is bugfixed ..
    prog = pexpect.which("telnetlib3-server")
    args = [
        prog,
        bind_host,
        str(unused_tcp_port),
        "--loglevel=info",
        "--connect-maxwait=0.05",
    ]
    proc = await asyncio.create_subprocess_exec(*args,
                                                loop=event_loop,
                                                stderr=asyncio.subprocess.PIPE)

    seen = b""
    while True:
        line = await asyncio.wait_for(proc.stderr.readline(), 1.5)
        if b"Server ready" in line:
            break
        seen += line
        assert line, seen.decode()  # EOF reached

    # client connects,
    reader, writer = await asyncio.open_connection(host=bind_host,
                                                   port=unused_tcp_port,
                                                   loop=event_loop)

    # and closes,
    await reader.readexactly(3)  # IAC DO TTYPE, we ignore it!
    writer.close()

    seen = b""
    while True:
        line = await asyncio.wait_for(proc.stderr.readline(), 1.5)
        if b"Connection closed" in line:
            break
        seen += line
        assert line, seen.decode()  # EOF reached

    # send SIGTERM
    proc.terminate()

    # we would expect the server to gracefully end.
    await proc.communicate()
    await proc.wait()
Ejemplo n.º 58
0
def get_netcat():
    """Return IPv6-capable nc(1), if any."""
    netcat_paths = ('nc', 'netcat', '/usr/bin/nc', '/usr/local/bin/nc',
                    '/bin/nc.openbsd')
    for nc_name in netcat_paths:
        prog = pexpect.which(nc_name)
        if prog is None:
            continue

        stdout, stderr = subprocess.Popen(
            [prog, '-h'], stdout=subprocess.PIPE,
            stderr=subprocess.PIPE).communicate()

        # only openbsd netcat supports IPv6.
        # So that's the only one we'll use!
        if b'-46' in stdout + stderr:
            return prog
    return None
Ejemplo n.º 59
0
    def start(self, process_name, *args):
        """Starts a process."""
        if Process.is_running(process_name):
            self._error("Process '{}' is already running".format(process_name))
            return False

        if len(args) < 2:
            self._error("'directory' and 'command' arguments not given but mandatory")
            return False

        directory_path = xtask.parse_path(args[0])

        if not directory_path.exists():
            self._error("Location {} does not exist".format(directory_path))
            return False

        command = args[1]
        args = list(args[2:])

        if command.startswith("."):
            command_path = directory_path / command
            if not command_path.exists():
                self._error("Cannot find command {}".format(command_path))
            else:
                command = str(command_path)
        elif pexpect.which(command) is None:
            self._error("Unknown command '{}'".format(command))
            return False

        try:
            self._info(
                "Starting process '{}' by calling '{} {}' in directory {}".format(
                    process_name, command, " ".join(args), directory_path
                )
            )
            process = pexpect.spawn(command, args, cwd=directory_path, timeout=5)
            Process._processes[process_name] = process
        except Exception:
            self._exception(
                "Something went wrong while starting process '{}'".format(process_name)
            )
            return False

        return True