Index and PackFiles do not obtain a lock anymore before reading the files in question - this won't work on read-only alternate repositories anyway, and shouldn't be necessary considering a pack is immutable

Author: Byron

db/loose.py

@@ -23,6 +23,7 @@
 						)
 
 from gitdb.util import (
+		file_contents_ro_filepath,
 		ENOENT,
 		to_hex_sha,
 		hex_to_bin,
@@ -100,12 +101,12 @@ def _map_loose_object(self, sha):
 		:raise BadObject: if object could not be located"""
 		db_path = self.db_path(self.object_path(to_hex_sha(sha)))
 		try:
-			fd = os.open(db_path, os.O_RDONLY|self._fd_open_flags)
+			return file_contents_ro_filepath(db_path, flags=self._fd_open_flags)
 		except OSError,e:
 			if e.errno != ENOENT:
 				# try again without noatime
 				try:
-					fd = os.open(db_path, os.O_RDONLY)
+					return file_contents_ro_filepath(db_path)
 				except OSError:
 					raise BadObject(to_hex_sha(sha))
 				# didn't work because of our flag, don't try it again

pack.py

@@ -5,10 +5,9 @@
 						)
 from util import (
 					zlib,
-					LockedFD,
 					LazyMixin,
 					unpack_from,
-					file_contents_ro,
+					file_contents_ro_filepath,
 					)
 
 from fun import (
@@ -140,10 +139,10 @@ def _set_cache_(self, attr):
 		elif attr == "_packfile_checksum":
 			self._packfile_checksum = self._data[-20:]
 		elif attr == "_data":
-			lfd = LockedFD(self._indexpath)
-			fd = lfd.open()
-			self._data = file_contents_ro(fd)
-			lfd.rollback()
+			# Note: We don't lock the file when reading as we cannot be sure
+			# that we can actually write to the location - it could be a read-only
+			# alternate for instance
+			self._data = file_contents_ro_filepath(self._indexpath)
 		else:
 			# now its time to initialize everything - if we are here, someone wants
 			# to access the fanout table or related properties
@@ -337,10 +336,7 @@ def __init__(self, packpath):
 
 	def _set_cache_(self, attr):
 		if attr == '_data':
-			ldb = LockedFD(self._packpath)
-			fd = ldb.open()
-			self._data = file_contents_ro(fd)
-			ldb.rollback()
+			self._data = file_contents_ro_filepath(self._packpath)
 
 			# read the header information
 			type_id, self._version, self._size = unpack_from(">4sLL", self._data, 0)

util.py

@@ -114,7 +114,24 @@ def file_contents_ro(fd, stream=False, allow_mmap=True):
 	if stream:
 		return cStringIO.StringIO(contents)
 	return contents
-		
+	
+def file_contents_ro_filepath(filepath, stream=False, allow_mmap=True, flags=0):
+	"""Get the file contents at filepath as fast as possible
+	:return: random access compatible memory of the given filepath
+	:param stream: see ``file_contents_ro``
+	:param allow_mmap: see ``file_contents_ro``
+	:param flags: additional flags to pass to os.open
+	:raise OSError: If the file could not be opened
+	:note: for now we don't try to use O_NOATIME directly as the right value needs to be 
+		shared per database in fact. It only makes a real difference for loose object 
+		databases anyway, and they use it with the help of the ``flags`` parameter"""
+	fd = os.open(filepath, os.O_RDONLY|flags)
+	try:
+		return file_contents_ro(fd, stream, allow_mmap)
+	finally:
+		close(fd)
+	# END assure file is closed
+	
 def to_hex_sha(sha):
 	""":return: hexified version  of sha"""
 	if len(sha) == 40: