Made improvements to assure test-cases don't leak file handles

At least leakage is considerably reduced.
Additionally, a test-case was added which triggers failure if auto-disposal
of resources wouldn't work.

Fixes gitpython-developers#60

Author: Byron

.travis.yml

@@ -25,6 +25,9 @@ install:
   - git config --global user.email "travis@ci.com"
   - git config --global user.name "Travis Runner"
 script: 
+  # Make sure we limit open handles to see if we are leaking them
+  - ulimit -n 64
+  - ulimit -n
   - nosetests -v --with-coverage
   - flake8
 after_success:

git/cmd.py

@@ -38,6 +38,9 @@
 
 __all__ = ('Git', )
 
+if sys.platform != 'win32':
+    WindowsError = OSError
+
 
 # ==============================================================================
 ## @name Utilities
@@ -203,11 +206,18 @@ def __init__(self, proc, args):
             self.args = args
 
         def __del__(self):
-            self.proc.stdout.close()
-            self.proc.stderr.close()
+            if self.proc is None:
+                return
+
+            proc = self.proc
+            self.proc = None
+            if proc.stdin:
+                proc.stdin.close()
+            proc.stdout.close()
+            proc.stderr.close()
 
             # did the process finish already so we have a return code ?
-            if self.proc.poll() is not None:
+            if proc.poll() is not None:
                 return
 
             # can be that nothing really exists anymore ...
@@ -216,16 +226,16 @@ def __del__(self):
 
             # try to kill it
             try:
-                os.kill(self.proc.pid, 2)   # interrupt signal
-                self.proc.wait()    # ensure process goes away
+                os.kill(proc.pid, 2)   # interrupt signal
+                proc.wait()    # ensure process goes away
             except (OSError, WindowsError):
                 pass  # ignore error when process already died
             except AttributeError:
                 # try windows
                 # for some reason, providing None for stdout/stderr still prints something. This is why
                 # we simply use the shell and redirect to nul. Its slower than CreateProcess, question
                 # is whether we really want to see all these messages. Its annoying no matter what.
-                call(("TASKKILL /F /T /PID %s 2>nul 1>nul" % str(self.proc.pid)), shell=True)
+                call(("TASKKILL /F /T /PID %s 2>nul 1>nul" % str(proc.pid)), shell=True)
             # END exception handling
 
         def __getattr__(self, attr):

git/refs/log.py

@@ -204,6 +204,7 @@ def iter_entries(cls, stream):
                 return
             yield new_entry(line.strip())
         # END endless loop
+        stream.close()
 
     @classmethod
     def entry_at(cls, filepath, index):

git/repo/base.py

@@ -168,6 +168,10 @@ def __init__(self, path=None, odbt=DefaultDBType):
             args.append(self.git)
         self.odb = odbt(*args)
 
+    def __del__(self):
+        if self.git:
+            self.git.clear_cache()
+
     def __eq__(self, rhs):
         if isinstance(rhs, Repo):
             return self.git_dir == rhs.git_dir

git/test/lib/helper.py

@@ -279,6 +279,11 @@ def setUpClass(cls):
         """
         cls.rorepo = Repo(GIT_REPO)
 
+    @classmethod
+    def tearDownClass(cls):
+        cls.rorepo.git.clear_cache()
+        cls.rorepo.git = None
+
     def _make_file(self, rela_path, data, repo=None):
         """
         Create a file at the given path relative to our repository, filled

git/test/performance/lib.py

@@ -59,6 +59,12 @@ def setUp(self):
         self.gitrorepo = Repo(repo_path, odbt=GitCmdObjectDB)
         self.puregitrorepo = Repo(repo_path, odbt=GitDB)
 
+    def tearDown(self):
+        self.gitrorepo.git.clear_cache()
+        self.gitrorepo = None
+        self.puregitrorepo.git.clear_cache()
+        self.puregitrorepo = None
+
 
 class TestBigRepoRW(TestBigRepoR):
 
@@ -78,7 +84,12 @@ def setUp(self):
         self.puregitrwrepo = Repo(dirname, odbt=GitDB)
 
     def tearDown(self):
+        super(TestBigRepoRW, self).tearDown()
         if self.gitrwrepo is not None:
             shutil.rmtree(self.gitrwrepo.working_dir)
+            self.gitrwrepo.git.clear_cache()
+        self.gitrwrepo = None
+        self.puregitrwrepo.git.clear_cache()
+        self.puregitrwrepo = None
 
 #} END base classes

git/test/test_repo.py

@@ -656,3 +656,20 @@ def test_git_file(self, rwrepo):
         open(git_file_path, 'wb').write(('gitdir: %s\n' % real_path_abs).encode('ascii'))
         git_file_repo = Repo(rwrepo.working_tree_dir)
         assert os.path.abspath(git_file_repo.git_dir) == real_path_abs
+
+    def test_file_handle_leaks(self):
+        def last_commit(repo, rev, path):
+            commit = next(repo.iter_commits(rev, path, max_count=1))
+            commit.tree[path]
+
+        # This is based on this comment
+        # https://github.com/gitpython-developers/GitPython/issues/60#issuecomment-23558741
+        # And we expect to set max handles to a low value, like 64
+        # You should set ulimit -n X, see .travis.yml
+        # The loops below would easily create 500 handles if these would leak (4 pipes + multiple mapped files)
+        for i in range(64):
+            for repo_type in (GitCmdObjectDB, GitDB):
+                repo = Repo(self.rorepo.working_tree_dir, odbt=repo_type)
+                last_commit(repo, 'master', 'git/test/test_base.py')
+            # end for each repository type
+        # end for each iteration