コード例 #1
0
ファイル: changesettest.py プロジェクト: tensor5/conary
    def testChangeSetFromFileSetsFilename(self):
        repos = self.openRepository()
        self.addComponent('foo:run', '1')
        self.addCollection('foo', '1', [':run'])
        csname = os.path.join(self.workDir, "changeset-lazyFileCache.ccs")
        self.changeset(repos, 'foo', csname)

        self.assertTrue(os.path.exists(csname))
        lfc = util.LazyFileCache()
        cs = changeset.ChangeSetFromFile(lfc.open(csname))
        self.assertEqual(cs.fileName, csname)
コード例 #2
0
ファイル: utiltest.py プロジェクト: sweptr/conary
    def testLazyFileCacheKernelBug(self):
        # CNY-2571

        lfc = util.LazyFileCache(1000)
        self.assertTrue(lfc._getFdCount() > 0)

        def _dummyCountOpenFileDescriptors():
            raise OSError(util.errno.EINVAL, "Invalid argument")

        self.mock(util, 'countOpenFileDescriptors',
            _dummyCountOpenFileDescriptors)
        self.assertEqual(lfc._getFdCount(), 0)
コード例 #3
0
ファイル: utiltest.py プロジェクト: sweptr/conary
 def testLazyFileDoubleRelease(self):
     lfc = util.LazyFileCache(1000)
     f = lfc.open("/etc/passwd")
     f._release()
     f._release()
     self.assertEqual(f._realFd, None)
コード例 #4
0
ファイル: utiltest.py プロジェクト: sweptr/conary
    def testLazyFileCache(self):
        lfc = util.LazyFileCache(1000)
        procdir = "/proc/self/fd"

        # Opening file that doesn't exist fails
        self.assertRaises(IOError, lfc.open, "/dev/null/bar")

        def getOpenFiles():
            fdlist = os.listdir(procdir)
            fdlist = ((x, os.path.join(procdir, x)) for x in fdlist)
            fdlist = set((x[0], os.readlink(x[1])) for x in fdlist 
                        if os.path.exists(x[1]))
            return fdlist
        origFdCount = fdCount = len(getOpenFiles())

        fd, fn = tempfile.mkstemp()
        try:
            os.close(fd)
            f = open(fn, 'w')

            # create a sparse file
            f.seek(10000)
            f.write('\0')
            f.close()

            lf = lfc.open(fn)
            lf.read(10000)
            self.assertEqual(fdCount + 1, len(getOpenFiles()))
            self.assertEqual(fdCount + 1, lfc._getFdCount())
            self.assertEqual(lf.tell(), 10000)
            lf.close()
            self.assertEqual(fdCount, len(getOpenFiles()))
            self.assertEqual(fdCount, lfc._getFdCount())

            # Open a bunch of files
            fdlist = getOpenFiles()
            fdCount = len(fdlist)
            count = 5000
            arr = []
            for i in range(count):
                arr.append(lfc.open(fn))
            fdlist2 = getOpenFiles()
            self.assertTrue(len(set(fdlist2) - set(fdlist)) <= lfc.threshold)

            for i, fd in enumerate(arr):
                fd.read(i + 1)
                self.assertEqual(fd.tell(), i + 1)
            # Some should have been closed
            openedFds = len(getOpenFiles()) - origFdCount
            self.assertFalse(lfc.threshold < openedFds)

            for i, fd in enumerate(arr):
                self.assertEqual(fd.tell(), i + 1)
            lfc.close()
            del lfc

            self.assertFalse(origFdCount < len(getOpenFiles()))
            # All the files in the array should be closed
            for fd in arr:
                self.assertEqual(None, fd._realFd)
                self.assertEqual(None, fd._cache)
        finally:
            os.unlink(fn)