Example #1
0
    def _writeInstalled(self, installed_db):
        if not self.__cygwinPlatform:
            raise PlatformException(
                "fail to create {0} only supported under Cygwin."
                "".format(installed_db))

        sys.stderr.write("creating {0} ... ".format(installed_db))

        db_contents = CygApt.INSTALLED_DB_MAGIC
        cygcheck_path = self.__pm.mapPath("/bin/cygcheck")

        if os.path.exists(cygcheck_path):
            cmd = [cygcheck_path, "-cd"]
            proc = Process(cmd)
            proc.mustRun()

            lines = proc.getOutput().splitlines(True)
            # remove first two lines
            pkgs = lines[2:]

            for pkg in pkgs:
                pkg = pkg.split()
                db_contents += "{0} {0}-{1}.tar.bz2 0\n".format(
                    pkg[0], pkg[1])

        f = open(installed_db, 'w')
        f.write(db_contents)
        f.close()

        sys.stderr.write("OK\n")
Example #2
0
    def testGpgImport(self):
        if not self._var_cygwin_p:
            self.skipTest("requires cygwin or linux");

        self.obj._gpgImport(self.obj.GPG_CYG_PUBLIC_RING_URI);

        cmd = " ".join([
            "gpg",
            "--no-secmem-warning",
            "--list-public-keys",
            "--fingerprint",
        ]);
        p = Process(cmd);
        p.mustRun();
        lines = p.getOutput().splitlines(True);
        findout = False;
        for line in lines:
            if isinstance(line, bytes):
                marker = self.obj.GPG_GOOD_FINGER.encode();
            else:
                marker = self.obj.GPG_GOOD_FINGER;
            if marker in line:
                findout = True;
                break;

        self.assertTrue(findout);
Example #3
0
    def testGpgImport(self):
        if not self._var_cygwin_p:
            self.skipTest("requires cygwin or linux")

        self.obj._gpgImport(self.obj.GPG_CYG_PUBLIC_RING_URI)

        cmd = " ".join([
            "gpg",
            "--no-secmem-warning",
            "--list-public-keys",
            "--fingerprint",
        ])
        p = Process(cmd)
        p.mustRun()
        lines = p.getOutput().splitlines(True)
        findout = False
        for line in lines:
            if isinstance(line, bytes):
                marker = self.obj.GPG_GOOD_FINGER.encode()
            else:
                marker = self.obj.GPG_GOOD_FINGER
            if marker in line:
                findout = True
                break

        self.assertTrue(findout)
Example #4
0
    def _writeInstalled(self, installed_db):
        if not self.__cygwinPlatform:
            raise PlatformException(
                "fail to create {0} only supported under Cygwin."
                "".format(installed_db)
            );

        sys.stderr.write("creating {0} ... ".format(installed_db));

        db_contents = CygApt.INSTALLED_DB_MAGIC;
        cygcheck_path = self.__pm.mapPath("/bin/cygcheck");

        if os.path.exists(cygcheck_path):
            cmd = [cygcheck_path, "-cd"];
            proc = Process(cmd);
            proc.mustRun();

            lines = proc.getOutput().splitlines(True);
            # remove first two lines
            pkgs = lines[2:];

            for pkg in pkgs:
                pkg = pkg.split();
                db_contents += "{0} {0}-{1}.tar.bz2 0\n".format(pkg[0], pkg[1]);

        f = open(installed_db, 'w');
        f.write(db_contents);
        f.close();

        sys.stderr.write("OK\n");
Example #5
0
    def testRunReturnAlwaysExitCodeEvenOnCommandFailed(self):
        proc = Process(
            'nonexistingcommandIhopeneversomeonewouldnameacommandlikethis')
        actual = proc.run()

        self.assertTrue(
            0 < actual,
            "Failed asserting that {0} is greater than 0".format(actual))
Example #6
0
    def testExitCodeCommandFailed(self):
        process = Process(
            'nonexistingcommandIhopeneversomeonewouldnameacommandlikethis')
        process.run()

        actual = process.getExitCode()
        self.assertTrue(
            0 < actual,
            "Failed asserting that {0} is greater than 0".format(actual))
Example #7
0
    def __init__(self, root, cygwin_p):
        self.__root = root
        self.__mountRoot = "/"
        self.__cygwinPlatform = cygwin_p
        self.__map = {}

        p = Process([self.__root + "/bin/mount"])
        p.run()
        mountout = p.getOutput().splitlines(True)
        self._addMapping(mountout)
Example #8
0
    def __init__(self, root, cygwin_p):
        self.__root = root;
        self.__mountRoot = "/";
        self.__cygwinPlatform = cygwin_p;
        self.__map = {};

        p = Process([self.__root + "/bin/mount"]);
        p.run();
        mountout = p.getOutput().splitlines(True);
        self._addMapping(mountout);
Example #9
0
 def _checkForSetupExe(self):
     # It's far from bulletproof, but it's surprisingly hard to detect
     # setup.exe running since it doesn't lock any files.
     p = Process([self.__pm.mapPath("/bin/ps"), "-W"]);
     p.run();
     psout = p.getOutput().splitlines(True);
     setup_re = re.compile(r"(?<![a-z0-9_ -])setup(|-1\.7|-x86|-x86_64)\.exe", re.IGNORECASE);
     for l in psout:
         m = setup_re.search(l);
         if m:
             raise AppConflictException(
                 "Please close {0} while "
                 "running {1}".format(m.group(0), self.__appName)
             );
Example #10
0
 def _checkForSetupExe(self):
     # It's far from bulletproof, but it's surprisingly hard to detect
     # setup.exe running since it doesn't lock any files.
     p = Process([self.__pm.mapPath("/bin/ps"), "-W"])
     p.run()
     psout = p.getOutput().splitlines(True)
     setup_re = re.compile(
         r"(?<![a-z0-9_ -])setup(|-1\.7|-x86|-x86_64)\.exe", re.IGNORECASE)
     for l in psout:
         m = setup_re.search(l)
         if m:
             raise AppConflictException("Please close {0} while "
                                        "running {1}".format(
                                            m.group(0), self.__appName))
Example #11
0
 def _doInstallExternal(self, ball):
     # Currently we use a temporary directory and extractall() then copy:
     # this is very slow. The Python documentation warns more sophisticated
     # approaches have pitfalls without specifying what they are.
     tf = cautils.open_tarfile(ball, self.__dosXz)
     members = tf.getmembers()
     tempdir = tempfile.mkdtemp()
     try:
         tf.extractall(tempdir)
         for m in members:
             if m.isdir():
                 path = self.__pm.mapPath("/" + m.name)
                 if not os.path.exists(path):
                     os.makedirs(path, m.mode)
         for m in members:
             if m.isdir():
                 path = self.__pm.mapPath("/" + m.name)
                 if not os.path.exists(path):
                     os.makedirs(path, m.mode)
             else:
                 path = self.__pm.mapPath("/" + m.name)
                 dirname = os.path.dirname(path)
                 if not os.path.exists(dirname):
                     os.makedirs(dirname)
                 if os.path.exists(path):
                     os.chmod(path, 0o777)
                     os.remove(path)
                 # Windows extract() is robust but can't form Cygwin links
                 # (It produces copies instead: bulky and bugbait.)
                 # Convert to links if possible -- depends on coreutils being installed
                 if m.issym() and self.__lnExists:
                     link_target = m.linkname
                     Process([self.__dosLn, "-s", link_target,
                              path]).run(True)
                 elif m.islnk() and self.__lnExists:
                     # Hard link -- expect these to be very rare
                     link_target = m.linkname
                     mapped_target = self.__pm.mapPath("/" + m.linkname)
                     # Must ensure target exists before forming hard link
                     if not os.path.exists(mapped_target):
                         shutil.move(os.path.join(tempdir, link_target),
                                     mapped_target)
                     Process([self.__dosLn, mapped_target, path]).run(True)
                 else:
                     shutil.move(os.path.join(tempdir, m.name), path)
     finally:
         tf.close()
         cautils.rmtree(tempdir)
Example #12
0
    def _runScript(self, file_name, optional=True):
        mapped_file = self.__pm.mapPath(file_name)
        mapped_file_done = mapped_file + ".done"
        if os.path.isfile(mapped_file):
            sys.stderr.write("running: {0}\n".format(file_name))
            cmd = ["bash"] + self.SH_OPTIONS + [mapped_file]
            if not self.__cygwinPlatform:
                cmd[0] = self.__dosBash

            cwd = None
            extension = os.path.splitext(mapped_file)[1]

            if ".dash" == extension:
                cmd = ["dash"] + self.DASH_OPTIONS + [mapped_file]
                if not self.__cygwinPlatform:
                    cmd[0] = self.__dosDash

            if extension in [".bat", ".cmd"]:
                cmd = ["cmd"
                       ] + self.CMD_OPTIONS + [os.path.basename(mapped_file)]
                cwd = os.path.dirname(mapped_file)

            retval = Process(cmd, cwd).run(True)

            if os.path.exists(mapped_file_done):
                os.remove(mapped_file_done)
            if retval == 0 and os.path.basename(file_name)[:3] not in [
                    '0p_', 'zp_'
            ]:
                shutil.move(mapped_file, mapped_file_done)
        else:
            if not optional:
                sys.stderr.write("{0}: WARNING couldn't find {1}.\n".format(
                    self.__appName, mapped_file))
Example #13
0
def open_tarfile(ball, xzPath='xz'):
    """Opens a tar file like `tarfile.open`.

    Supports also LZMA compressed tarballs.

    @param ball:   str A tar file, it can be compressed
    @param xzPath: str A path to the lzma program

    @return: TarFile An appropriate TarFile instance
    """
    assert isinstance(xzPath, str)

    ball_orig = ball
    if ball.lower().endswith('.tar.xz'):
        ball_orig = ball
        ball = ball[:-3]
        # remove .xz extension
        remove_if_exists(ball)
        Process([xzPath, '-k', '-d', ball_orig]).mustRun()
    tf = tarfile.open(ball)
    if ball_orig != ball:
        tf_close_orig = tf.close

        def tf_close():
            retValue = tf_close_orig()
            remove_if_exists(ball)
            return retValue

        tf.close = tf_close
    return tf
Example #14
0
    def _integrityControl(self, checklist=None):
        if None is checklist:
            checklist = list()

        options = ["-c"]
        if self.__verbose:
            options.append("-v")

        if len(checklist) == 0:
            checklist.append(self.__pkgName)

        command = ["/bin/cygcheck"] + options + checklist
        if not self.__cygwinPlatform:
            command = subprocess.list2cmdline(command)
            command = [self.__dosBash] + self.SH_OPTIONS + ["-c"] + [command]

        p = Process(command)
        p.run()
        outputlines = p.getOutput().splitlines(True)

        unformat = ""
        start = False
        incomplete = []
        for res in outputlines:
            try:
                res_split = res.split()
                package, version, status = res_split
            except ValueError:
                if len(res_split) > 0:
                    unformat += res
                continue

            if package == 'Package' \
               and version == 'Version' \
               and status == 'Status':
                start = True
                unformat = ''
            elif not start:
                continue

            if start and status == 'Incomplete':
                print(res[:-2])
                print(unformat)
                unformat = ""
                incomplete.append(package)

        return incomplete
Example #15
0
    def _integrityControl(self, checklist=None):
        if None is checklist :
            checklist = list();

        options = ["-c"];
        if self.__verbose:
            options.append("-v");

        if len(checklist) == 0:
            checklist.append(self.__pkgName);

        command = ["/bin/cygcheck"] + options + checklist;
        if not self.__cygwinPlatform:
            command = subprocess.list2cmdline(command);
            command = [self.__dosBash] + self.SH_OPTIONS + ["-c"] + [command];

        p = Process(command);
        p.run();
        outputlines = p.getOutput().splitlines(True);

        unformat = "";
        start = False;
        incomplete = [];
        for res in outputlines:
            try:
                res_split = res.split();
                package, version, status = res_split;
            except ValueError:
                if len(res_split) > 0:
                    unformat += res;
                continue;

            if package == 'Package' \
               and version == 'Version' \
               and status == 'Status':
                start = True;
                unformat = '';
            elif not start:
                continue;

            if start and status == 'Incomplete':
                print(res[:-2]);
                print(unformat);
                unformat = "";
                incomplete.append(package);

        return incomplete;
Example #16
0
    def testResponsesCommandFailed(self, expected, method):
        process = Process(
            'python -c \'import sys; sys.stdout.write("foo"); sys.stderr.write("bar");\''
        )
        process.run()
        process.setCommandLine(
            'nonexistingcommandIhopeneversomeonewouldnameacommandlikethis')
        process.run()

        self.assertEqual(getattr(process, method)(), expected)
Example #17
0
    def testResponsesCommandFailed(self, expected, method):
        process = Process('python -c \'import sys; sys.stdout.write("foo"); sys.stderr.write("bar");\'')
        process.run()
        process.setCommandLine("nonexistingcommandIhopeneversomeonewouldnameacommandlikethis")
        process.run()

        self.assertEqual(getattr(process, method)(), expected)
Example #18
0
    def testRunWorkingDirectoryIsUsed(self, startMethod):
        popen = subprocess.Popen
        directory = os.path.dirname(__file__)

        def mock(*args, **kargs):
            self.assertEqual(kargs["cwd"], directory)

            return popen(*args, **kargs)

        subprocess.Popen = mock

        try:
            proc = Process("python --version")
            proc.setWorkingDirectory(directory)

            getattr(proc, startMethod)()
        finally:
            subprocess.Popen = popen
Example #19
0
    def testRunWorkingDirectoryIsUsed(self, startMethod):
        popen = subprocess.Popen
        directory = os.path.dirname(__file__)

        def mock(*args, **kargs):
            self.assertEqual(kargs['cwd'], directory)

            return popen(*args, **kargs)

        subprocess.Popen = mock

        try:
            proc = Process('python --version')
            proc.setWorkingDirectory(directory)

            getattr(proc, startMethod)()
        finally:
            subprocess.Popen = popen
Example #20
0
    def _gpgImport(self, uri):
        if not self.__cygwinPlatform:
            return

        cautils.uri_get(self.__tmpDir, uri, verbose=self.__verbose)
        tmpfile = os.path.join(self.__tmpDir, os.path.basename(uri))
        cmd = ["gpg"]
        cmd.append("--no-secmem-warning")
        cmd += ["--import", tmpfile]
        Process(cmd).mustRun()
Example #21
0
    def testProcessPipes(self, size, getter, code):
        expected = '*' * 1024 * size + '!'
        expectedLength = 1024 * size + 1

        proc = Process("python -c '{0}'".format(code))
        proc.setInput(expected)
        proc.run()

        self.assertEqual(len(getattr(proc, getter)()), expectedLength)
        self.assertEqual(proc.getExitCode(), 0)
Example #22
0
 def _compressFollowingTargetExtension(self, srcPath, targetPath):
     compression = targetPath.split(".")[-1]
     if "bz2" == compression:
         f = open(srcPath, 'rb')
         contents = f.read()
         compressed = bz2.compress(contents)
         f.close()
         f = open(targetPath, 'wb')
         f.write(compressed)
         f.close()
         os.remove(srcPath)
     elif "xz" == compression:
         Process(['xz', '-f', srcPath]).mustRun()
Example #23
0
    def testProcessPipes(self, size, getter, code):
        expected = "*" * 1024 * size + "!"
        expectedLength = 1024 * size + 1

        proc = Process("python -c '{0}'".format(code))
        proc.setInput(expected)
        proc.run()

        self.assertEqual(len(getattr(proc, getter)()), expectedLength)
        self.assertEqual(proc.getExitCode(), 0)
Example #24
0
    def testRunInheritOutput(self, startMethod):
        popen = subprocess.Popen

        def mock(*args, **kargs):
            self.assertTrue(None is kargs['stdout'])
            self.assertTrue(None is kargs['stderr'])

            return popen(*args, **kargs)

        subprocess.Popen = mock

        try:
            proc = Process("python -c ''")

            getattr(proc, startMethod)(True)
        finally:
            subprocess.Popen = popen
Example #25
0
    def testSetStreamAsInput(self, size, getter, code):
        expected = '*' * 1024 * size + '!'
        expectedLength = 1024 * size + 1

        stream = TemporaryFile()
        stream.write(expected)
        stream.seek(0)

        proc = Process("python -c '{0}'".format(code))
        proc.setInput(stream)
        proc.run()

        stream.close()

        self.assertEqual(len(getattr(proc, getter)()), expectedLength)
        self.assertEqual(proc.getExitCode(), 0)
Example #26
0
    def testDefaultGetterSetter(self, fn, value):
        proc = Process('python')

        setter = 'set' + fn
        getter = 'get' + fn

        self.assertTrue(
            None is getattr(proc, setter)(value),
            "Failed asserting that setter method return None",
        )

        self.assertEqual(getattr(proc, getter)(), value)

        if not isinstance(value, str):
            self.assertFalse(
                value is getattr(proc, getter)(),
                "Failed asserting that getter method return a cloned value",
            )
Example #27
0
    def testSetStreamAsInput(self, size, getter, code):
        expected = "*" * 1024 * size + "!"
        expectedLength = 1024 * size + 1

        stream = TemporaryFile()
        stream.write(expected)
        stream.seek(0)

        proc = Process("python -c '{0}'".format(code))
        proc.setInput(stream)
        proc.run()

        stream.close()

        self.assertEqual(len(getattr(proc, getter)()), expectedLength)
        self.assertEqual(proc.getExitCode(), 0)
Example #28
0
def cygpath(path):
    p = Process(["cygpath", path]);
    p.run();
    dospath = p.getOutput().strip();
    return dospath;
Example #29
0
 def testGetErrorOutputProcessNotStarted(self):
     proc = Process("python --version")
     proc.getErrorOutput()
Example #30
0
    def testConstructorSetTheCwd(self):
        proc = Process('foo', 'bar')

        self.assertEqual(proc.getWorkingDirectory(), 'bar')
Example #31
0
    def testConstructor(self):
        proc = Process('foo')

        self.assertEqual(proc.getCommandLine(), 'foo')
        self.assertEqual(proc.getWorkingDirectory(), None)
        self.assertEqual(proc.getInput(), None)
Example #32
0
    def testProcessResponses(self, expected, getter, code):
        proc = Process("python -c '{0}'".format(code))
        proc.run()

        self.assertEqual(getattr(proc, getter)(), expected)
Example #33
0
    def update(self, cyg_apt_rc, verify, main_mirror=None):
        """fetch current package database from mirror"""
        sig_name = None
        self.__rc = cautils.parse_rc(cyg_apt_rc)

        if (not self.__cygwinPlatform):
            self.__pm = PathMapper(self.__rc.ROOT[:-1], False)

        if (main_mirror):
            mirror = main_mirror
        else:
            mirror = self.__rc.mirror

        if not mirror:
            raise UnexpectedValueException(
                "A mirror must be specified on the configuration file \"{0}\" "
                "or with the command line option \"--mirror\". "
                "See cygwin.com/mirrors.html for the list of mirrors."
                "".format(cyg_apt_rc))

        if not mirror[-1] == "/":
            sep = "/"
        else:
            sep = ""

        setup_ini_names = [
            "setup.bz2",
            "setup.ini",
        ]

        bag = zip(setup_ini_names, list(range(len(setup_ini_names))))
        platform_dir = self.__arch + "/"

        for (setup_ini_name, index) in bag:
            setup_ini_url = '{0}{1}{2}{3}'.format(mirror, sep, platform_dir,
                                                  setup_ini_name)
            try:
                cautils.uri_get(self.__tmpDir,
                                setup_ini_url,
                                verbose=self.__verbose)
            except ApplicationException as e:
                # Failed to find a possible .ini
                if index == len(setup_ini_names) - 1:
                    raise e
                else:
                    continue
                    # Not an error to fail to find the first one
            # Take the first one we find
            break

        if setup_ini_name[-4:] == ".bz2":
            bz_file = os.path.join(self.__tmpDir, setup_ini_name)
            f = open(bz_file, "rb")
            compressed = f.read()
            f.close()

            decomp = bz2.decompress(compressed)
            os.remove(bz_file)
            setup_ini_name = "setup.ini"

            f = open(os.path.join(self.__tmpDir, setup_ini_name), "wb")
            f.write(decomp)
            f.close()

        if not self.__cygwinPlatform:
            sys.stderr.write(
                "WARNING can't verify setup.ini outside Cygwin.\n")
            verify = False

        if verify:
            sig_name = "{0}.sig".format(setup_ini_name)
            sig_url = "{0}{1}{2}{3}".format(mirror, sep, platform_dir,
                                            sig_name)
            try:
                cautils.uri_get(self.__tmpDir, sig_url, verbose=self.__verbose)
            except RequestException as e:
                msg = ("Failed to download signature {0} Use -X to ignore "
                       "signatures.".format(sig_url))
                raise RequestException(msg, previous=e)

            if self.__cygwinPlatform:
                gpg_path = "gpg"
            else:
                if self._cygwinVersion() < 1.7:
                    gpg_path = "/usr/bin/gpg"
                else:
                    gpg_path = "/usr/local/bin/gpg"
            cmd = [gpg_path, "--verify", "--no-secmem-warning"]
            cmd.append("{0}/{1}".format(self.__tmpDir, sig_name))
            cmd.append("{0}/{1}".format(self.__tmpDir, setup_ini_name))
            p = Process(cmd)
            p.run()
            verify = p.getErrorOutput()
            if isinstance(verify, bytes):
                marker = self.GPG_GOOD_FINGER.encode()
            else:
                marker = self.GPG_GOOD_FINGER
            if not marker in verify:
                msg = ("{0} not signed by Cygwin's public key. "
                       "Use -X to ignore signatures.".format(setup_ini_url))
                raise SignatureException(msg)

        downloads = os.path.join(
            self.__pm.mapPath(self.__rc.cache),
            urllib.quote(mirror + ('' if mirror.endswith('/') else '/'),
                         '').lower(),
            platform_dir,
        )

        if not os.path.exists(downloads):
            os.makedirs(downloads)

        shutil.copy(os.path.join(self.__tmpDir, setup_ini_name),
                    os.path.join(downloads, setup_ini_name))

        # BC layer for `setup_ini` configuration field
        if self.__rc.setup_ini:
            setup_ini = self.__pm.mapPath(self.__rc.setup_ini)
            if os.path.exists(setup_ini):
                shutil.copy(setup_ini, "{0}.bak".format(setup_ini))
            shutil.copy(os.path.join(downloads, setup_ini_name), setup_ini)

        if os.path.exists(os.path.join(self.__tmpDir, setup_ini_name)):
            os.remove(os.path.join(self.__tmpDir, setup_ini_name))
        if sig_name:
            if os.path.exists(os.path.join(self.__tmpDir, sig_name)):
                os.remove(os.path.join(self.__tmpDir, sig_name))
Example #34
0
    def testRunReturnAlwaysExitCode(self, expected, getter, code):
        proc = Process("python -c '{0}'".format(code))
        actual = proc.run()

        self.assertEqual(actual, proc.getExitCode())
Example #35
0
    def testConstructor(self):
        proc = Process("foo")

        self.assertEqual(proc.getCommandLine(), "foo")
        self.assertEqual(proc.getWorkingDirectory(), None)
        self.assertEqual(proc.getInput(), None)
Example #36
0
    def testExitCodeTextIsNoneWhenExitCodeIsNone(self):
        process = Process('')

        self.assertEqual(process.getExitCodeText(), None)
Example #37
0
 def testInvalidInput(self, value):
     process = Process("python --version")
     process.setInput(value)
Example #38
0
    def testExitCodeTextIsNoneWhenExitCodeIsNone(self):
        process = Process("")

        self.assertEqual(process.getExitCodeText(), None)
Example #39
0
    def _generateDistFiles(self, distname='curr'):
        dirname = os.path.join(self._tmpdir,
                               self.name + self.version.__dict__[distname])
        os.makedirs(dirname)
        usr_d = os.path.join(dirname, "usr")
        etc_d = os.path.join(dirname, "etc")
        var_d = os.path.join(dirname, "var")
        bin_d = os.path.join(dirname, "usr", "bin")
        share_d = os.path.join(dirname, "usr", "share", self.name)
        version_d = os.path.join(share_d, self.version.__dict__[distname])
        postinstall_d = os.path.join(dirname, "etc", "postinstall")
        postremove_d = os.path.join(dirname, "etc", "postremove")
        preremove_d = os.path.join(dirname, "etc", "preremove")
        marker_d = os.path.join(dirname, "var", self.name)
        os.makedirs(bin_d)
        os.makedirs(postinstall_d)
        os.makedirs(postremove_d)
        os.makedirs(preremove_d)
        os.makedirs(marker_d)
        os.makedirs(share_d)
        os.makedirs(version_d)
        bin_f = os.path.join(bin_d, self.name)
        link_bin_f = os.path.join(bin_d, self.name + "-link")
        link_version_d = os.path.join(share_d, "current")
        hardlink_bin_f = os.path.join(bin_d, self.name + "-hardlink")
        postinstall_f = os.path.join(postinstall_d,
                                     self.name + self._scriptsExt)
        postremove_f = os.path.join(postremove_d, self.name + self._scriptsExt)
        preremove_f = os.path.join(preremove_d, self.name + self._scriptsExt)
        marker_f = os.path.join(marker_d, "version")

        # create exec "#!/usr/bin/sh\necho running;" <pkg> > root/usr/bin
        #    link
        #    hard link
        f = open(bin_f, 'w')
        f.write('#!/bin/sh\necho "running";')
        f.close()
        Process(['ln', '-s', self.name, link_bin_f]).mustRun()
        Process(['ln', bin_f, hardlink_bin_f]).mustRun()
        Process([
            'ln',
            '-s',
            os.path.relpath(version_d, os.path.dirname(link_version_d)),
            link_version_d,
        ]).mustRun()

        self._writeScript(postinstall_f, 0)
        self._writeScript(preremove_f, 0)
        self._writeScript(postremove_f, 0)

        # create version marker > root/var/<pkg>/<version>
        f = open(marker_f, 'w')
        f.write(self.version.__dict__[distname])
        f.close()
        # build install tar
        tar_name = os.path.join(self._localMirror,
                                self.install.__dict__[distname].url)
        tarInstallPath = ".".join(tar_name.split(".")[:-1])
        tar = tarfile.open(tarInstallPath, mode='w')
        for name in [usr_d, etc_d, var_d]:
            tar.add(name, os.path.basename(name))
        members = tar.getmembers()
        tar.close()
        self._compressFollowingTargetExtension(tarInstallPath, tar_name)
        del tarInstallPath

        # Force slash to the end of each directories
        lst = []
        for m in members:
            if m.isdir() and not m.name.endswith("/"):
                lst.append(m.name + "/")
            else:
                lst.append(m.name)
        f = open("{0}.lst".format(tar_name), 'w')
        f.write("\n".join(lst))
        f.close()

        # build source tar
        tar_src_name = os.path.join(self._localMirror,
                                    self.source.__dict__[distname].url)
        tarSrcPath = ".".join(tar_src_name.split(".")[:-1])
        tar = tarfile.open(tarSrcPath, mode='w')
        tar.add(dirname, "{0}-{1}".format(self.name,
                                          self.version.__dict__[distname]))
        tar.close()
        self._compressFollowingTargetExtension(tarSrcPath, tar_src_name)
        del tarSrcPath

        md5sum = self._md5Sum(tar_name)
        md5sum_src = self._md5Sum(tar_src_name)

        md5_sum_f = os.path.join(os.path.dirname(tar_name), "md5.sum")

        f = open(md5_sum_f, 'a')
        f.write("{0}  {1}{LF}"
                "{2}  {3}{LF}"
                "".format(md5sum,
                          os.path.basename(
                              self.install.__dict__[distname].url),
                          md5sum_src,
                          os.path.basename(self.source.__dict__[distname].url),
                          LF="\n"))
        f.close()
Example #40
0
    def testConstructorSetTheCwd(self):
        proc = Process("foo", "bar")

        self.assertEqual(proc.getWorkingDirectory(), "bar")
Example #41
0
    def testValidInput(self, expected, value):
        process = Process("python --version")
        process.setInput(value)

        self.assertEqual(process.getInput(), expected)
Example #42
0
    def testProcessResponses(self, expected, getter, code):
        proc = Process("python -c '{0}'".format(code))
        proc.run()

        self.assertEqual(getattr(proc, getter)(), expected)
Example #43
0
 def testMustRunThrowsException(self):
     process = Process('python -c \'import sys; sys.stdout.write("foo"); sys.stderr.write("bar"); exit(1);\'')
     process.mustRun()
Example #44
0
def cygpath(path):
    p = Process(["cygpath", path])
    p.run()
    dospath = p.getOutput().strip()
    return dospath
Example #45
0
    def testRunReturnAlwaysExitCode(self, expected, getter, code):
        proc = Process("python -c '{0}'".format(code))
        actual = proc.run()

        self.assertEqual(actual, proc.getExitCode())
Example #46
0
    def testMustRun(self):
        process = Process('python -c \'import sys; sys.stdout.write("foo");\'')
        process.mustRun()

        self.assertEqual(process.getOutput(), 'foo')
        self.assertEqual(process.getExitCode(), 0)
Example #47
0
    def update(self, cyg_apt_rc, verify, main_mirror=None):
        """fetch current package database from mirror"""
        sig_name = None;
        self.__rc = cautils.parse_rc(cyg_apt_rc);

        if(not self.__cygwinPlatform):
            self.__pm = PathMapper(self.__rc.ROOT[:-1], False);

        if (main_mirror):
            mirror = main_mirror;
        else:
            mirror = self.__rc.mirror;

        if not mirror :
            raise UnexpectedValueException(
                "A mirror must be specified on the configuration file \"{0}\" "
                "or with the command line option \"--mirror\". "
                "See cygwin.com/mirrors.html for the list of mirrors."
                "".format(cyg_apt_rc)
            );

        if not mirror[-1] == "/":
            sep = "/";
        else:
            sep = "";

        setup_ini_names = [
            "setup.bz2",
            "setup.ini",
        ];

        bag = zip(setup_ini_names, list(range(len(setup_ini_names))));
        platform_dir = self.__arch+"/";

        for (setup_ini_name, index) in bag:
            setup_ini_url = '{0}{1}{2}{3}'.format(mirror, sep, platform_dir, setup_ini_name);
            try:
                cautils.uri_get(
                    self.__tmpDir,
                    setup_ini_url,
                    verbose=self.__verbose
                );
            except ApplicationException as e:
                # Failed to find a possible .ini
                if index == len(setup_ini_names) - 1:
                    raise e;
                else:
                    continue;
                    # Not an error to fail to find the first one
            # Take the first one we find
            break;

        if setup_ini_name[-4:] == ".bz2":
            bz_file = os.path.join(self.__tmpDir, setup_ini_name);
            f = open(bz_file, "rb");
            compressed = f.read();
            f.close();

            decomp = bz2.decompress(compressed);
            os.remove(bz_file);
            setup_ini_name = "setup.ini";

            f = open(os.path.join(self.__tmpDir, setup_ini_name), "wb");
            f.write(decomp);
            f.close();

        if not self.__cygwinPlatform:
            sys.stderr.write("WARNING can't verify setup.ini outside Cygwin.\n");
            verify = False;

        if verify:
            sig_name = "{0}.sig".format(setup_ini_name);
            sig_url = "{0}{1}{2}{3}".format(mirror, sep, platform_dir, sig_name);
            try:
                cautils.uri_get(self.__tmpDir, sig_url, verbose=self.__verbose);
            except RequestException as e:
                msg = (
                    "Failed to download signature {0} Use -X to ignore "
                    "signatures.".format(sig_url)
                );
                raise RequestException(msg, previous=e);

            if self.__cygwinPlatform:
                gpg_path = "gpg";
            else:
                if self._cygwinVersion() < 1.7:
                    gpg_path = "/usr/bin/gpg";
                else:
                    gpg_path = "/usr/local/bin/gpg";
            cmd = [gpg_path, "--verify", "--no-secmem-warning"];
            cmd.append("{0}/{1}".format(self.__tmpDir, sig_name));
            cmd.append("{0}/{1}".format(self.__tmpDir, setup_ini_name));
            p = Process(cmd);
            p.run();
            verify = p.getErrorOutput();
            if isinstance(verify, bytes):
                marker = self.GPG_GOOD_FINGER.encode();
            else:
                marker = self.GPG_GOOD_FINGER;
            if not marker in verify:
                msg = (
                    "{0} not signed by Cygwin's public key. "
                    "Use -X to ignore signatures.".format(setup_ini_url)
                );
                raise SignatureException(msg);

        downloads = os.path.join(
            self.__pm.mapPath(self.__rc.cache),
            urllib.quote(mirror+('' if mirror.endswith('/') else '/'), '').lower(),
            platform_dir,
        );

        if not os.path.exists(downloads):
            os.makedirs(downloads);

        shutil.copy(
            os.path.join(self.__tmpDir, setup_ini_name),
            os.path.join(downloads, setup_ini_name)
        );

        # BC layer for `setup_ini` configuration field
        if self.__rc.setup_ini :
            setup_ini = self.__pm.mapPath(self.__rc.setup_ini);
            if os.path.exists(setup_ini):
                shutil.copy(setup_ini, "{0}.bak".format(setup_ini));
            shutil.copy(
                os.path.join(downloads, setup_ini_name),
                setup_ini
            );

        if os.path.exists(os.path.join(self.__tmpDir, setup_ini_name)):
            os.remove(os.path.join(self.__tmpDir, setup_ini_name));
        if sig_name:
            if os.path.exists(os.path.join(self.__tmpDir, sig_name)):
                os.remove(os.path.join(self.__tmpDir, sig_name));
Example #48
0
    def testMustRun(self):
        process = Process("python -c 'import sys; sys.stdout.write(\"foo\");'")
        process.mustRun()

        self.assertEqual(process.getOutput(), "foo")
        self.assertEqual(process.getExitCode(), 0)
Example #49
0
 def testMustRunThrowsException(self):
     process = Process(
         'python -c \'import sys; sys.stdout.write("foo"); sys.stderr.write("bar"); exit(1);\''
     )
     process.mustRun()
Example #50
0
 def testGetErrorOutputProcessNotStarted(self):
     proc = Process('python --version')
     proc.getErrorOutput()
Example #51
0
    def testRunReturnAlwaysExitCodeEvenOnCommandFailed(self):
        proc = Process("nonexistingcommandIhopeneversomeonewouldnameacommandlikethis")
        actual = proc.run()

        self.assertTrue(0 < actual, "Failed asserting that {0} is greater than 0".format(actual))
Example #52
0
    def testValidInput(self, expected, value):
        process = Process('python --version')
        process.setInput(value)

        self.assertEqual(process.getInput(), expected)
Example #53
0
    def testExitCodeCommandFailed(self):
        process = Process("nonexistingcommandIhopeneversomeonewouldnameacommandlikethis")
        process.run()

        actual = process.getExitCode()
        self.assertTrue(0 < actual, "Failed asserting that {0} is greater than 0".format(actual))