back to Reference (Gold) summary
Reference (Gold): dulwich
Pytest Summary for test tests
| status | count |
|---|---|
| passed | 1522 |
| skipped | 55 |
| error | 9 |
| xfailed | 1 |
| total | 1587 |
| collected | 1587 |
Failed pytests:
test_swift_smoke.py::SwiftRepoSmokeTest::test_clone_bare
test_swift_smoke.py::SwiftRepoSmokeTest::test_clone_bare
path = None, file = None
def load_conf(path=None, file=None):
"""Load configuration in global var CONF.
Args:
path: The path to the configuration file
file: If provided read instead the file like object
"""
conf = ConfigParser()
if file:
try:
conf.read_file(file, path)
except AttributeError:
# read_file only exists in Python3
conf.readfp(file)
return conf
confpath = None
if not path:
try:
> confpath = os.environ["DULWICH_SWIFT_CFG"]
dulwich/contrib/swift.py:135:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
self = environ({'MODAL_IMAGE_ID': 'im-IZz1uDYqoSR6GHA3U0a9t5', 'MODAL_FUNCTION_RUNTIME': 'gvisor', 'PYTHONHASHSEED': '0', 'MO...ON': '8.3.3', 'PYTEST_CURRENT_TEST': 'tests/contrib/test_swift_smoke.py::SwiftRepoSmokeTest::test_clone_bare (setup)'})
key = 'DULWICH_SWIFT_CFG'
def __getitem__(self, key):
try:
value = self._data[self.encodekey(key)]
except KeyError:
# raise KeyError with the original key value
> raise KeyError(key) from None
E KeyError: 'DULWICH_SWIFT_CFG'
/usr/lib/python3.10/os.py:680: KeyError
The above exception was the direct cause of the following exception:
cls =
@classmethod
def setUpClass(cls):
cls.backend = SwiftSystemBackend()
cls.port = 9148
cls.server_address = "localhost"
cls.fakerepo = "fakerepo"
cls.th_server = DulwichServer(cls.backend, cls.port)
cls.th_server.run()
> cls.conf = swift.load_conf()
tests/contrib/test_swift_smoke.py:80:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
path = None, file = None
def load_conf(path=None, file=None):
"""Load configuration in global var CONF.
Args:
path: The path to the configuration file
file: If provided read instead the file like object
"""
conf = ConfigParser()
if file:
try:
conf.read_file(file, path)
except AttributeError:
# read_file only exists in Python3
conf.readfp(file)
return conf
confpath = None
if not path:
try:
confpath = os.environ["DULWICH_SWIFT_CFG"]
except KeyError as exc:
> raise Exception("You need to specify a configuration file") from exc
E Exception: You need to specify a configuration file
dulwich/contrib/swift.py:137: Exception
test_swift_smoke.py::SwiftRepoSmokeTest::test_clone_then_push_data
test_swift_smoke.py::SwiftRepoSmokeTest::test_clone_then_push_data
path = None, file = None
def load_conf(path=None, file=None):
"""Load configuration in global var CONF.
Args:
path: The path to the configuration file
file: If provided read instead the file like object
"""
conf = ConfigParser()
if file:
try:
conf.read_file(file, path)
except AttributeError:
# read_file only exists in Python3
conf.readfp(file)
return conf
confpath = None
if not path:
try:
> confpath = os.environ["DULWICH_SWIFT_CFG"]
dulwich/contrib/swift.py:135:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
self = environ({'MODAL_IMAGE_ID': 'im-IZz1uDYqoSR6GHA3U0a9t5', 'MODAL_FUNCTION_RUNTIME': 'gvisor', 'PYTHONHASHSEED': '0', 'MO...3', 'PYTEST_CURRENT_TEST': 'tests/contrib/test_swift_smoke.py::SwiftRepoSmokeTest::test_clone_then_push_data (setup)'})
key = 'DULWICH_SWIFT_CFG'
def __getitem__(self, key):
try:
value = self._data[self.encodekey(key)]
except KeyError:
# raise KeyError with the original key value
> raise KeyError(key) from None
E KeyError: 'DULWICH_SWIFT_CFG'
/usr/lib/python3.10/os.py:680: KeyError
The above exception was the direct cause of the following exception:
cls =
@classmethod
def setUpClass(cls):
cls.backend = SwiftSystemBackend()
cls.port = 9148
cls.server_address = "localhost"
cls.fakerepo = "fakerepo"
cls.th_server = DulwichServer(cls.backend, cls.port)
cls.th_server.run()
> cls.conf = swift.load_conf()
tests/contrib/test_swift_smoke.py:80:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
path = None, file = None
def load_conf(path=None, file=None):
"""Load configuration in global var CONF.
Args:
path: The path to the configuration file
file: If provided read instead the file like object
"""
conf = ConfigParser()
if file:
try:
conf.read_file(file, path)
except AttributeError:
# read_file only exists in Python3
conf.readfp(file)
return conf
confpath = None
if not path:
try:
confpath = os.environ["DULWICH_SWIFT_CFG"]
except KeyError as exc:
> raise Exception("You need to specify a configuration file") from exc
E Exception: You need to specify a configuration file
dulwich/contrib/swift.py:137: Exception
test_swift_smoke.py::SwiftRepoSmokeTest::test_init_bare
test_swift_smoke.py::SwiftRepoSmokeTest::test_init_bare
path = None, file = None
def load_conf(path=None, file=None):
"""Load configuration in global var CONF.
Args:
path: The path to the configuration file
file: If provided read instead the file like object
"""
conf = ConfigParser()
if file:
try:
conf.read_file(file, path)
except AttributeError:
# read_file only exists in Python3
conf.readfp(file)
return conf
confpath = None
if not path:
try:
> confpath = os.environ["DULWICH_SWIFT_CFG"]
dulwich/contrib/swift.py:135:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
self = environ({'MODAL_IMAGE_ID': 'im-IZz1uDYqoSR6GHA3U0a9t5', 'MODAL_FUNCTION_RUNTIME': 'gvisor', 'PYTHONHASHSEED': '0', 'MO...ION': '8.3.3', 'PYTEST_CURRENT_TEST': 'tests/contrib/test_swift_smoke.py::SwiftRepoSmokeTest::test_init_bare (setup)'})
key = 'DULWICH_SWIFT_CFG'
def __getitem__(self, key):
try:
value = self._data[self.encodekey(key)]
except KeyError:
# raise KeyError with the original key value
> raise KeyError(key) from None
E KeyError: 'DULWICH_SWIFT_CFG'
/usr/lib/python3.10/os.py:680: KeyError
The above exception was the direct cause of the following exception:
cls =
@classmethod
def setUpClass(cls):
cls.backend = SwiftSystemBackend()
cls.port = 9148
cls.server_address = "localhost"
cls.fakerepo = "fakerepo"
cls.th_server = DulwichServer(cls.backend, cls.port)
cls.th_server.run()
> cls.conf = swift.load_conf()
tests/contrib/test_swift_smoke.py:80:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
path = None, file = None
def load_conf(path=None, file=None):
"""Load configuration in global var CONF.
Args:
path: The path to the configuration file
file: If provided read instead the file like object
"""
conf = ConfigParser()
if file:
try:
conf.read_file(file, path)
except AttributeError:
# read_file only exists in Python3
conf.readfp(file)
return conf
confpath = None
if not path:
try:
confpath = os.environ["DULWICH_SWIFT_CFG"]
except KeyError as exc:
> raise Exception("You need to specify a configuration file") from exc
E Exception: You need to specify a configuration file
dulwich/contrib/swift.py:137: Exception
test_swift_smoke.py::SwiftRepoSmokeTest::test_push_annotated_tag
test_swift_smoke.py::SwiftRepoSmokeTest::test_push_annotated_tag
path = None, file = None
def load_conf(path=None, file=None):
"""Load configuration in global var CONF.
Args:
path: The path to the configuration file
file: If provided read instead the file like object
"""
conf = ConfigParser()
if file:
try:
conf.read_file(file, path)
except AttributeError:
# read_file only exists in Python3
conf.readfp(file)
return conf
confpath = None
if not path:
try:
> confpath = os.environ["DULWICH_SWIFT_CFG"]
dulwich/contrib/swift.py:135:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
self = environ({'MODAL_IMAGE_ID': 'im-IZz1uDYqoSR6GHA3U0a9t5', 'MODAL_FUNCTION_RUNTIME': 'gvisor', 'PYTHONHASHSEED': '0', 'MO...3.3', 'PYTEST_CURRENT_TEST': 'tests/contrib/test_swift_smoke.py::SwiftRepoSmokeTest::test_push_annotated_tag (setup)'})
key = 'DULWICH_SWIFT_CFG'
def __getitem__(self, key):
try:
value = self._data[self.encodekey(key)]
except KeyError:
# raise KeyError with the original key value
> raise KeyError(key) from None
E KeyError: 'DULWICH_SWIFT_CFG'
/usr/lib/python3.10/os.py:680: KeyError
The above exception was the direct cause of the following exception:
cls =
@classmethod
def setUpClass(cls):
cls.backend = SwiftSystemBackend()
cls.port = 9148
cls.server_address = "localhost"
cls.fakerepo = "fakerepo"
cls.th_server = DulwichServer(cls.backend, cls.port)
cls.th_server.run()
> cls.conf = swift.load_conf()
tests/contrib/test_swift_smoke.py:80:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
path = None, file = None
def load_conf(path=None, file=None):
"""Load configuration in global var CONF.
Args:
path: The path to the configuration file
file: If provided read instead the file like object
"""
conf = ConfigParser()
if file:
try:
conf.read_file(file, path)
except AttributeError:
# read_file only exists in Python3
conf.readfp(file)
return conf
confpath = None
if not path:
try:
confpath = os.environ["DULWICH_SWIFT_CFG"]
except KeyError as exc:
> raise Exception("You need to specify a configuration file") from exc
E Exception: You need to specify a configuration file
dulwich/contrib/swift.py:137: Exception
test_swift_smoke.py::SwiftRepoSmokeTest::test_push_branch
test_swift_smoke.py::SwiftRepoSmokeTest::test_push_branch
path = None, file = None
def load_conf(path=None, file=None):
"""Load configuration in global var CONF.
Args:
path: The path to the configuration file
file: If provided read instead the file like object
"""
conf = ConfigParser()
if file:
try:
conf.read_file(file, path)
except AttributeError:
# read_file only exists in Python3
conf.readfp(file)
return conf
confpath = None
if not path:
try:
> confpath = os.environ["DULWICH_SWIFT_CFG"]
dulwich/contrib/swift.py:135:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
self = environ({'MODAL_IMAGE_ID': 'im-IZz1uDYqoSR6GHA3U0a9t5', 'MODAL_FUNCTION_RUNTIME': 'gvisor', 'PYTHONHASHSEED': '0', 'MO...N': '8.3.3', 'PYTEST_CURRENT_TEST': 'tests/contrib/test_swift_smoke.py::SwiftRepoSmokeTest::test_push_branch (setup)'})
key = 'DULWICH_SWIFT_CFG'
def __getitem__(self, key):
try:
value = self._data[self.encodekey(key)]
except KeyError:
# raise KeyError with the original key value
> raise KeyError(key) from None
E KeyError: 'DULWICH_SWIFT_CFG'
/usr/lib/python3.10/os.py:680: KeyError
The above exception was the direct cause of the following exception:
cls =
@classmethod
def setUpClass(cls):
cls.backend = SwiftSystemBackend()
cls.port = 9148
cls.server_address = "localhost"
cls.fakerepo = "fakerepo"
cls.th_server = DulwichServer(cls.backend, cls.port)
cls.th_server.run()
> cls.conf = swift.load_conf()
tests/contrib/test_swift_smoke.py:80:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
path = None, file = None
def load_conf(path=None, file=None):
"""Load configuration in global var CONF.
Args:
path: The path to the configuration file
file: If provided read instead the file like object
"""
conf = ConfigParser()
if file:
try:
conf.read_file(file, path)
except AttributeError:
# read_file only exists in Python3
conf.readfp(file)
return conf
confpath = None
if not path:
try:
confpath = os.environ["DULWICH_SWIFT_CFG"]
except KeyError as exc:
> raise Exception("You need to specify a configuration file") from exc
E Exception: You need to specify a configuration file
dulwich/contrib/swift.py:137: Exception
test_swift_smoke.py::SwiftRepoSmokeTest::test_push_commit
test_swift_smoke.py::SwiftRepoSmokeTest::test_push_commit
path = None, file = None
def load_conf(path=None, file=None):
"""Load configuration in global var CONF.
Args:
path: The path to the configuration file
file: If provided read instead the file like object
"""
conf = ConfigParser()
if file:
try:
conf.read_file(file, path)
except AttributeError:
# read_file only exists in Python3
conf.readfp(file)
return conf
confpath = None
if not path:
try:
> confpath = os.environ["DULWICH_SWIFT_CFG"]
dulwich/contrib/swift.py:135:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
self = environ({'MODAL_IMAGE_ID': 'im-IZz1uDYqoSR6GHA3U0a9t5', 'MODAL_FUNCTION_RUNTIME': 'gvisor', 'PYTHONHASHSEED': '0', 'MO...N': '8.3.3', 'PYTEST_CURRENT_TEST': 'tests/contrib/test_swift_smoke.py::SwiftRepoSmokeTest::test_push_commit (setup)'})
key = 'DULWICH_SWIFT_CFG'
def __getitem__(self, key):
try:
value = self._data[self.encodekey(key)]
except KeyError:
# raise KeyError with the original key value
> raise KeyError(key) from None
E KeyError: 'DULWICH_SWIFT_CFG'
/usr/lib/python3.10/os.py:680: KeyError
The above exception was the direct cause of the following exception:
cls =
@classmethod
def setUpClass(cls):
cls.backend = SwiftSystemBackend()
cls.port = 9148
cls.server_address = "localhost"
cls.fakerepo = "fakerepo"
cls.th_server = DulwichServer(cls.backend, cls.port)
cls.th_server.run()
> cls.conf = swift.load_conf()
tests/contrib/test_swift_smoke.py:80:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
path = None, file = None
def load_conf(path=None, file=None):
"""Load configuration in global var CONF.
Args:
path: The path to the configuration file
file: If provided read instead the file like object
"""
conf = ConfigParser()
if file:
try:
conf.read_file(file, path)
except AttributeError:
# read_file only exists in Python3
conf.readfp(file)
return conf
confpath = None
if not path:
try:
confpath = os.environ["DULWICH_SWIFT_CFG"]
except KeyError as exc:
> raise Exception("You need to specify a configuration file") from exc
E Exception: You need to specify a configuration file
dulwich/contrib/swift.py:137: Exception
test_swift_smoke.py::SwiftRepoSmokeTest::test_push_data_branch
test_swift_smoke.py::SwiftRepoSmokeTest::test_push_data_branch
path = None, file = None
def load_conf(path=None, file=None):
"""Load configuration in global var CONF.
Args:
path: The path to the configuration file
file: If provided read instead the file like object
"""
conf = ConfigParser()
if file:
try:
conf.read_file(file, path)
except AttributeError:
# read_file only exists in Python3
conf.readfp(file)
return conf
confpath = None
if not path:
try:
> confpath = os.environ["DULWICH_SWIFT_CFG"]
dulwich/contrib/swift.py:135:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
self = environ({'MODAL_IMAGE_ID': 'im-IZz1uDYqoSR6GHA3U0a9t5', 'MODAL_FUNCTION_RUNTIME': 'gvisor', 'PYTHONHASHSEED': '0', 'MO...8.3.3', 'PYTEST_CURRENT_TEST': 'tests/contrib/test_swift_smoke.py::SwiftRepoSmokeTest::test_push_data_branch (setup)'})
key = 'DULWICH_SWIFT_CFG'
def __getitem__(self, key):
try:
value = self._data[self.encodekey(key)]
except KeyError:
# raise KeyError with the original key value
> raise KeyError(key) from None
E KeyError: 'DULWICH_SWIFT_CFG'
/usr/lib/python3.10/os.py:680: KeyError
The above exception was the direct cause of the following exception:
cls =
@classmethod
def setUpClass(cls):
cls.backend = SwiftSystemBackend()
cls.port = 9148
cls.server_address = "localhost"
cls.fakerepo = "fakerepo"
cls.th_server = DulwichServer(cls.backend, cls.port)
cls.th_server.run()
> cls.conf = swift.load_conf()
tests/contrib/test_swift_smoke.py:80:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
path = None, file = None
def load_conf(path=None, file=None):
"""Load configuration in global var CONF.
Args:
path: The path to the configuration file
file: If provided read instead the file like object
"""
conf = ConfigParser()
if file:
try:
conf.read_file(file, path)
except AttributeError:
# read_file only exists in Python3
conf.readfp(file)
return conf
confpath = None
if not path:
try:
confpath = os.environ["DULWICH_SWIFT_CFG"]
except KeyError as exc:
> raise Exception("You need to specify a configuration file") from exc
E Exception: You need to specify a configuration file
dulwich/contrib/swift.py:137: Exception
test_swift_smoke.py::SwiftRepoSmokeTest::test_push_multiple_branch
test_swift_smoke.py::SwiftRepoSmokeTest::test_push_multiple_branch
path = None, file = None
def load_conf(path=None, file=None):
"""Load configuration in global var CONF.
Args:
path: The path to the configuration file
file: If provided read instead the file like object
"""
conf = ConfigParser()
if file:
try:
conf.read_file(file, path)
except AttributeError:
# read_file only exists in Python3
conf.readfp(file)
return conf
confpath = None
if not path:
try:
> confpath = os.environ["DULWICH_SWIFT_CFG"]
dulwich/contrib/swift.py:135:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
self = environ({'MODAL_IMAGE_ID': 'im-IZz1uDYqoSR6GHA3U0a9t5', 'MODAL_FUNCTION_RUNTIME': 'gvisor', 'PYTHONHASHSEED': '0', 'MO...3', 'PYTEST_CURRENT_TEST': 'tests/contrib/test_swift_smoke.py::SwiftRepoSmokeTest::test_push_multiple_branch (setup)'})
key = 'DULWICH_SWIFT_CFG'
def __getitem__(self, key):
try:
value = self._data[self.encodekey(key)]
except KeyError:
# raise KeyError with the original key value
> raise KeyError(key) from None
E KeyError: 'DULWICH_SWIFT_CFG'
/usr/lib/python3.10/os.py:680: KeyError
The above exception was the direct cause of the following exception:
cls =
@classmethod
def setUpClass(cls):
cls.backend = SwiftSystemBackend()
cls.port = 9148
cls.server_address = "localhost"
cls.fakerepo = "fakerepo"
cls.th_server = DulwichServer(cls.backend, cls.port)
cls.th_server.run()
> cls.conf = swift.load_conf()
tests/contrib/test_swift_smoke.py:80:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
path = None, file = None
def load_conf(path=None, file=None):
"""Load configuration in global var CONF.
Args:
path: The path to the configuration file
file: If provided read instead the file like object
"""
conf = ConfigParser()
if file:
try:
conf.read_file(file, path)
except AttributeError:
# read_file only exists in Python3
conf.readfp(file)
return conf
confpath = None
if not path:
try:
confpath = os.environ["DULWICH_SWIFT_CFG"]
except KeyError as exc:
> raise Exception("You need to specify a configuration file") from exc
E Exception: You need to specify a configuration file
dulwich/contrib/swift.py:137: Exception
test_swift_smoke.py::SwiftRepoSmokeTest::test_push_remove_branch
test_swift_smoke.py::SwiftRepoSmokeTest::test_push_remove_branch
path = None, file = None
def load_conf(path=None, file=None):
"""Load configuration in global var CONF.
Args:
path: The path to the configuration file
file: If provided read instead the file like object
"""
conf = ConfigParser()
if file:
try:
conf.read_file(file, path)
except AttributeError:
# read_file only exists in Python3
conf.readfp(file)
return conf
confpath = None
if not path:
try:
> confpath = os.environ["DULWICH_SWIFT_CFG"]
dulwich/contrib/swift.py:135:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
self = environ({'MODAL_IMAGE_ID': 'im-IZz1uDYqoSR6GHA3U0a9t5', 'MODAL_FUNCTION_RUNTIME': 'gvisor', 'PYTHONHASHSEED': '0', 'MO...3.3', 'PYTEST_CURRENT_TEST': 'tests/contrib/test_swift_smoke.py::SwiftRepoSmokeTest::test_push_remove_branch (setup)'})
key = 'DULWICH_SWIFT_CFG'
def __getitem__(self, key):
try:
value = self._data[self.encodekey(key)]
except KeyError:
# raise KeyError with the original key value
> raise KeyError(key) from None
E KeyError: 'DULWICH_SWIFT_CFG'
/usr/lib/python3.10/os.py:680: KeyError
The above exception was the direct cause of the following exception:
cls =
@classmethod
def setUpClass(cls):
cls.backend = SwiftSystemBackend()
cls.port = 9148
cls.server_address = "localhost"
cls.fakerepo = "fakerepo"
cls.th_server = DulwichServer(cls.backend, cls.port)
cls.th_server.run()
> cls.conf = swift.load_conf()
tests/contrib/test_swift_smoke.py:80:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
path = None, file = None
def load_conf(path=None, file=None):
"""Load configuration in global var CONF.
Args:
path: The path to the configuration file
file: If provided read instead the file like object
"""
conf = ConfigParser()
if file:
try:
conf.read_file(file, path)
except AttributeError:
# read_file only exists in Python3
conf.readfp(file)
return conf
confpath = None
if not path:
try:
confpath = os.environ["DULWICH_SWIFT_CFG"]
except KeyError as exc:
> raise Exception("You need to specify a configuration file") from exc
E Exception: You need to specify a configuration file
dulwich/contrib/swift.py:137: Exception
test_walk.py::WalkerTest::test_merge_of_old_branch
test_walk.py::WalkerTest::test_merge_of_old_branch
self =testcase = rawexcinfo = ( , AssertionError("Lists differ: [ ] !...? ^^\n"), ) reason = '' def addExpectedFailure( self, testcase: unittest.TestCase, rawexcinfo: _SysExcInfoType, reason: str = "", ) -> None: try: > xfail(str(reason)) E _pytest.outcomes.XFailed .venv/lib/python3.10/site-packages/_pytest/unittest.py:295: XFailed
Patch diff
diff --git a/dulwich/archive.py b/dulwich/archive.py
index db584c66..03dcad2f 100644
--- a/dulwich/archive.py
+++ b/dulwich/archive.py
@@ -1,4 +1,26 @@
+# archive.py -- Creating an archive from a tarball
+# Copyright (C) 2015 Jonas Haag <jonas@lophus.org>
+# Copyright (C) 2015 Jelmer Vernooij <jelmer@jelmer.uk>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Generates tarballs for Git trees."""
+
import posixpath
import stat
import struct
@@ -19,12 +41,33 @@ class ChunkedBytesIO:
list_of_bytestrings)
"""
- def __init__(self, contents) ->None:
+ def __init__(self, contents) -> None:
self.contents = contents
- self.pos = 0, 0
+ self.pos = (0, 0)
+
+ def read(self, maxbytes=None):
+ if maxbytes < 0:
+ maxbytes = float("inf")
+
+ buf = []
+ chunk, cursor = self.pos
+ while chunk < len(self.contents):
+ if maxbytes < len(self.contents[chunk]) - cursor:
+ buf.append(self.contents[chunk][cursor : cursor + maxbytes])
+ cursor += maxbytes
+ self.pos = (chunk, cursor)
+ break
+ else:
+ buf.append(self.contents[chunk][cursor:])
+ maxbytes -= len(self.contents[chunk]) - cursor
+ chunk += 1
+ cursor = 0
+ self.pos = (chunk, cursor)
+ return b"".join(buf)
-def tar_stream(store, tree, mtime, prefix=b'', format=''):
+
+def tar_stream(store, tree, mtime, prefix=b"", format=""):
"""Generate a tar stream for the contents of a Git tree.
Returns a generator that lazily assembles a .tar.gz archive, yielding it in
@@ -40,11 +83,50 @@ def tar_stream(store, tree, mtime, prefix=b'', format=''):
Returns:
Bytestrings
"""
- pass
+ buf = BytesIO()
+ with closing(tarfile.open(None, f"w:{format}", buf)) as tar:
+ if format == "gz":
+ # Manually correct the gzip header file modification time so that
+ # archives created from the same Git tree are always identical.
+ # The gzip header file modification time is not currently
+ # accessible from the tarfile API, see:
+ # https://bugs.python.org/issue31526
+ buf.seek(0)
+ assert buf.read(2) == b"\x1f\x8b", "Invalid gzip header"
+ buf.seek(4)
+ buf.write(struct.pack("<L", mtime))
+ buf.seek(0, SEEK_END)
+
+ for entry_abspath, entry in _walk_tree(store, tree, prefix):
+ try:
+ blob = store[entry.sha]
+ except KeyError:
+ # Entry probably refers to a submodule, which we don't yet
+ # support.
+ continue
+ data = ChunkedBytesIO(blob.chunked)
+
+ info = tarfile.TarInfo()
+ # tarfile only works with ascii.
+ info.name = entry_abspath.decode("utf-8", "surrogateescape")
+ info.size = blob.raw_length()
+ info.mode = entry.mode
+ info.mtime = mtime
+
+ tar.addfile(info, data)
+ yield buf.getvalue()
+ buf.truncate(0)
+ buf.seek(0)
+ yield buf.getvalue()
-def _walk_tree(store, tree, root=b''):
+def _walk_tree(store, tree, root=b""):
"""Recursively walk a dulwich Tree, yielding tuples of
(absolute path, TreeEntry) along the way.
"""
- pass
+ for entry in tree.iteritems():
+ entry_abspath = posixpath.join(root, entry.path)
+ if stat.S_ISDIR(entry.mode):
+ yield from _walk_tree(store, store[entry.sha], entry_abspath)
+ else:
+ yield (entry_abspath, entry)
diff --git a/dulwich/bundle.py b/dulwich/bundle.py
index 1e9c8d04..3b08f337 100644
--- a/dulwich/bundle.py
+++ b/dulwich/bundle.py
@@ -1,19 +1,45 @@
+# bundle.py -- Bundle format support
+# Copyright (C) 2020 Jelmer Vernooij <jelmer@jelmer.uk>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Bundle format support."""
+
from typing import Dict, List, Optional, Sequence, Tuple, Union
+
from .pack import PackData, write_pack_data
class Bundle:
version: Optional[int]
+
capabilities: Dict[str, str]
prerequisites: List[Tuple[bytes, str]]
references: Dict[str, bytes]
pack_data: Union[PackData, Sequence[bytes]]
- def __repr__(self) ->str:
+ def __repr__(self) -> str:
return (
- f'<{type(self).__name__}(version={self.version}, capabilities={self.capabilities}, prerequisites={self.prerequisites}, references={self.references})>'
- )
+ f"<{type(self).__name__}(version={self.version}, "
+ f"capabilities={self.capabilities}, "
+ f"prerequisites={self.prerequisites}, "
+ f"references={self.references})>"
+ )
def __eq__(self, other):
if not isinstance(other, type(self)):
@@ -31,6 +57,77 @@ class Bundle:
return True
+def _read_bundle(f, version):
+ capabilities = {}
+ prerequisites = []
+ references = {}
+ line = f.readline()
+ if version >= 3:
+ while line.startswith(b"@"):
+ line = line[1:].rstrip(b"\n")
+ try:
+ key, value = line.split(b"=", 1)
+ except ValueError:
+ key = line
+ value = None
+ else:
+ value = value.decode("utf-8")
+ capabilities[key.decode("utf-8")] = value
+ line = f.readline()
+ while line.startswith(b"-"):
+ (obj_id, comment) = line[1:].rstrip(b"\n").split(b" ", 1)
+ prerequisites.append((obj_id, comment.decode("utf-8")))
+ line = f.readline()
+ while line != b"\n":
+ (obj_id, ref) = line.rstrip(b"\n").split(b" ", 1)
+ references[ref] = obj_id
+ line = f.readline()
+ pack_data = PackData.from_file(f)
+ ret = Bundle()
+ ret.references = references
+ ret.capabilities = capabilities
+ ret.prerequisites = prerequisites
+ ret.pack_data = pack_data
+ ret.version = version
+ return ret
+
+
def read_bundle(f):
"""Read a bundle file."""
- pass
+ firstline = f.readline()
+ if firstline == b"# v2 git bundle\n":
+ return _read_bundle(f, 2)
+ if firstline == b"# v3 git bundle\n":
+ return _read_bundle(f, 3)
+ raise AssertionError(f"unsupported bundle format header: {firstline!r}")
+
+
+def write_bundle(f, bundle):
+ version = bundle.version
+ if version is None:
+ if bundle.capabilities:
+ version = 3
+ else:
+ version = 2
+ if version == 2:
+ f.write(b"# v2 git bundle\n")
+ elif version == 3:
+ f.write(b"# v3 git bundle\n")
+ else:
+ raise AssertionError("unknown version %d" % version)
+ if version == 3:
+ for key, value in bundle.capabilities.items():
+ f.write(b"@" + key.encode("utf-8"))
+ if value is not None:
+ f.write(b"=" + value.encode("utf-8"))
+ f.write(b"\n")
+ for obj_id, comment in bundle.prerequisites:
+ f.write(b"-%s %s\n" % (obj_id, comment.encode("utf-8")))
+ for ref, obj_id in bundle.references.items():
+ f.write(b"%s %s\n" % (obj_id, ref))
+ f.write(b"\n")
+ write_pack_data(
+ f.write,
+ num_records=len(bundle.pack_data),
+ records=bundle.pack_data.iter_unpacked(),
+ )
diff --git a/dulwich/cli.py b/dulwich/cli.py
index 0c09585d..2c619994 100755
--- a/dulwich/cli.py
+++ b/dulwich/cli.py
@@ -1,9 +1,32 @@
+#
+# dulwich - Simple command-line interface to Dulwich
+# Copyright (C) 2008-2011 Jelmer Vernooij <jelmer@jelmer.uk>
+# vim: expandtab
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Simple command-line interface to Dulwich>.
This is a very simple command-line wrapper for Dulwich. It is by
no means intended to be a full-blown Git command-line interface but just
a way to test Dulwich.
"""
+
import argparse
import optparse
import os
@@ -11,7 +34,9 @@ import signal
import sys
from getopt import getopt
from typing import ClassVar, Dict, Optional, Type
+
from dulwich import porcelain
+
from .client import GitProtocolError, get_transport_and_path
from .errors import ApplyDeltaError
from .index import Index
@@ -20,234 +45,818 @@ from .pack import Pack, sha_to_hex
from .repo import Repo
+def signal_int(signal, frame):
+ sys.exit(1)
+
+
+def signal_quit(signal, frame):
+ import pdb
+
+ pdb.set_trace()
+
+
class Command:
"""A Dulwich subcommand."""
def run(self, args):
"""Run the command."""
- pass
+ raise NotImplementedError(self.run)
class cmd_archive(Command):
- pass
+ def run(self, args):
+ parser = argparse.ArgumentParser()
+ parser.add_argument(
+ "--remote",
+ type=str,
+ help="Retrieve archive from specified remote repo",
+ )
+ parser.add_argument("committish", type=str, nargs="?")
+ args = parser.parse_args(args)
+ if args.remote:
+ client, path = get_transport_and_path(args.remote)
+ client.archive(
+ path,
+ args.committish,
+ sys.stdout.write,
+ write_error=sys.stderr.write,
+ )
+ else:
+ porcelain.archive(
+ ".", args.committish, outstream=sys.stdout.buffer, errstream=sys.stderr
+ )
class cmd_add(Command):
- pass
+ def run(self, argv):
+ parser = argparse.ArgumentParser()
+ args = parser.parse_args(argv)
+
+ porcelain.add(".", paths=args)
class cmd_rm(Command):
- pass
+ def run(self, argv):
+ parser = argparse.ArgumentParser()
+ args = parser.parse_args(argv)
+
+ porcelain.rm(".", paths=args)
class cmd_fetch_pack(Command):
- pass
+ def run(self, argv):
+ parser = argparse.ArgumentParser()
+ parser.add_argument("--all", action="store_true")
+ parser.add_argument("location", nargs="?", type=str)
+ args = parser.parse_args(argv)
+ client, path = get_transport_and_path(args.location)
+ r = Repo(".")
+ if args.all:
+ determine_wants = r.object_store.determine_wants_all
+ else:
+
+ def determine_wants(x, **kwargs):
+ return [y for y in args if y not in r.object_store]
+
+ client.fetch(path, r, determine_wants)
class cmd_fetch(Command):
- pass
+ def run(self, args):
+ opts, args = getopt(args, "", [])
+ opts = dict(opts)
+ client, path = get_transport_and_path(args.pop(0))
+ r = Repo(".")
+ refs = client.fetch(path, r, progress=sys.stdout.write)
+ print("Remote refs:")
+ for item in refs.items():
+ print("{} -> {}".format(*item))
class cmd_for_each_ref(Command):
- pass
+ def run(self, args):
+ parser = argparse.ArgumentParser()
+ parser.add_argument("pattern", type=str, nargs="?")
+ args = parser.parse_args(args)
+ for sha, object_type, ref in porcelain.for_each_ref(".", args.pattern):
+ print(f"{sha.decode()} {object_type.decode()}\t{ref.decode()}")
class cmd_fsck(Command):
- pass
+ def run(self, args):
+ opts, args = getopt(args, "", [])
+ opts = dict(opts)
+ for obj, msg in porcelain.fsck("."):
+ print(f"{obj}: {msg}")
class cmd_log(Command):
- pass
+ def run(self, args):
+ parser = optparse.OptionParser()
+ parser.add_option(
+ "--reverse",
+ dest="reverse",
+ action="store_true",
+ help="Reverse order in which entries are printed",
+ )
+ parser.add_option(
+ "--name-status",
+ dest="name_status",
+ action="store_true",
+ help="Print name/status for each changed file",
+ )
+ options, args = parser.parse_args(args)
+
+ porcelain.log(
+ ".",
+ paths=args,
+ reverse=options.reverse,
+ name_status=options.name_status,
+ outstream=sys.stdout,
+ )
class cmd_diff(Command):
- pass
+ def run(self, args):
+ opts, args = getopt(args, "", [])
+
+ r = Repo(".")
+ if args == []:
+ commit_id = b"HEAD"
+ else:
+ commit_id = args[0]
+ commit = parse_commit(r, commit_id)
+ parent_commit = r[commit.parents[0]]
+ porcelain.diff_tree(
+ r, parent_commit.tree, commit.tree, outstream=sys.stdout.buffer
+ )
class cmd_dump_pack(Command):
- pass
+ def run(self, args):
+ opts, args = getopt(args, "", [])
+
+ if args == []:
+ print("Usage: dulwich dump-pack FILENAME")
+ sys.exit(1)
+
+ basename, _ = os.path.splitext(args[0])
+ x = Pack(basename)
+ print(f"Object names checksum: {x.name()}")
+ print(f"Checksum: {sha_to_hex(x.get_stored_checksum())}")
+ if not x.check():
+ print("CHECKSUM DOES NOT MATCH")
+ print("Length: %d" % len(x))
+ for name in x:
+ try:
+ print(f"\t{x[name]}")
+ except KeyError as k:
+ print(f"\t{name}: Unable to resolve base {k}")
+ except ApplyDeltaError as e:
+ print(f"\t{name}: Unable to apply delta: {e!r}")
class cmd_dump_index(Command):
- pass
+ def run(self, args):
+ opts, args = getopt(args, "", [])
+
+ if args == []:
+ print("Usage: dulwich dump-index FILENAME")
+ sys.exit(1)
+
+ filename = args[0]
+ idx = Index(filename)
+
+ for o in idx:
+ print(o, idx[o])
class cmd_init(Command):
- pass
+ def run(self, args):
+ opts, args = getopt(args, "", ["bare"])
+ opts = dict(opts)
+
+ if args == []:
+ path = os.getcwd()
+ else:
+ path = args[0]
+
+ porcelain.init(path, bare=("--bare" in opts))
class cmd_clone(Command):
- pass
+ def run(self, args):
+ parser = optparse.OptionParser()
+ parser.add_option(
+ "--bare",
+ dest="bare",
+ help="Whether to create a bare repository.",
+ action="store_true",
+ )
+ parser.add_option(
+ "--depth", dest="depth", type=int, help="Depth at which to fetch"
+ )
+ parser.add_option(
+ "-b",
+ "--branch",
+ dest="branch",
+ type=str,
+ help=("Check out branch instead of branch pointed to by remote " "HEAD"),
+ )
+ parser.add_option(
+ "--refspec",
+ dest="refspec",
+ type=str,
+ help="References to fetch",
+ action="append",
+ )
+ parser.add_option(
+ "--filter",
+ dest="filter_spec",
+ type=str,
+ help="git-rev-list-style object filter",
+ )
+ parser.add_option(
+ "--protocol", dest="protocol", type=int, help="Git protocol version to use"
+ )
+ options, args = parser.parse_args(args)
+
+ if args == []:
+ print("usage: dulwich clone host:path [PATH]")
+ sys.exit(1)
+
+ source = args.pop(0)
+ if len(args) > 0:
+ target = args.pop(0)
+ else:
+ target = None
+
+ try:
+ porcelain.clone(
+ source,
+ target,
+ bare=options.bare,
+ depth=options.depth,
+ branch=options.branch,
+ refspec=options.refspec,
+ filter_spec=options.filter_spec,
+ protocol_version=options.protocol,
+ )
+ except GitProtocolError as e:
+ print(f"{e}")
class cmd_commit(Command):
- pass
+ def run(self, args):
+ opts, args = getopt(args, "", ["message"])
+ opts = dict(opts)
+ porcelain.commit(".", message=opts["--message"])
class cmd_commit_tree(Command):
- pass
+ def run(self, args):
+ opts, args = getopt(args, "", ["message"])
+ if args == []:
+ print("usage: dulwich commit-tree tree")
+ sys.exit(1)
+ opts = dict(opts)
+ porcelain.commit_tree(".", tree=args[0], message=opts["--message"])
class cmd_update_server_info(Command):
- pass
+ def run(self, args):
+ porcelain.update_server_info(".")
class cmd_symbolic_ref(Command):
- pass
+ def run(self, args):
+ opts, args = getopt(args, "", ["ref-name", "force"])
+ if not args:
+ print("Usage: dulwich symbolic-ref REF_NAME [--force]")
+ sys.exit(1)
+
+ ref_name = args.pop(0)
+ porcelain.symbolic_ref(".", ref_name=ref_name, force="--force" in args)
class cmd_pack_refs(Command):
- pass
+ def run(self, argv):
+ parser = argparse.ArgumentParser()
+ parser.add_argument("--all", action="store_true")
+ # ignored, we never prune
+ parser.add_argument("--no-prune", action="store_true")
+
+ args = parser.parse_args(argv)
+
+ porcelain.pack_refs(".", all=args.all)
class cmd_show(Command):
- pass
+ def run(self, argv):
+ parser = argparse.ArgumentParser()
+ parser.add_argument("objectish", type=str, nargs="*")
+ args = parser.parse_args(argv)
+ porcelain.show(".", args.objectish or None)
class cmd_diff_tree(Command):
- pass
+ def run(self, args):
+ opts, args = getopt(args, "", [])
+ if len(args) < 2:
+ print("Usage: dulwich diff-tree OLD-TREE NEW-TREE")
+ sys.exit(1)
+ porcelain.diff_tree(".", args[0], args[1])
class cmd_rev_list(Command):
- pass
+ def run(self, args):
+ opts, args = getopt(args, "", [])
+ if len(args) < 1:
+ print("Usage: dulwich rev-list COMMITID...")
+ sys.exit(1)
+ porcelain.rev_list(".", args)
class cmd_tag(Command):
- pass
+ def run(self, args):
+ parser = optparse.OptionParser()
+ parser.add_option(
+ "-a",
+ "--annotated",
+ help="Create an annotated tag.",
+ action="store_true",
+ )
+ parser.add_option(
+ "-s", "--sign", help="Sign the annotated tag.", action="store_true"
+ )
+ options, args = parser.parse_args(args)
+ porcelain.tag_create(
+ ".", args[0], annotated=options.annotated, sign=options.sign
+ )
class cmd_repack(Command):
- pass
+ def run(self, args):
+ opts, args = getopt(args, "", [])
+ opts = dict(opts)
+ porcelain.repack(".")
class cmd_reset(Command):
- pass
+ def run(self, args):
+ opts, args = getopt(args, "", ["hard", "soft", "mixed"])
+ opts = dict(opts)
+ mode = ""
+ if "--hard" in opts:
+ mode = "hard"
+ elif "--soft" in opts:
+ mode = "soft"
+ elif "--mixed" in opts:
+ mode = "mixed"
+ porcelain.reset(".", mode=mode, *args)
class cmd_daemon(Command):
- pass
+ def run(self, args):
+ from dulwich import log_utils
+
+ from .protocol import TCP_GIT_PORT
+
+ parser = optparse.OptionParser()
+ parser.add_option(
+ "-l",
+ "--listen_address",
+ dest="listen_address",
+ default="localhost",
+ help="Binding IP address.",
+ )
+ parser.add_option(
+ "-p",
+ "--port",
+ dest="port",
+ type=int,
+ default=TCP_GIT_PORT,
+ help="Binding TCP port.",
+ )
+ options, args = parser.parse_args(args)
+
+ log_utils.default_logging_config()
+ if len(args) >= 1:
+ gitdir = args[0]
+ else:
+ gitdir = "."
+
+ porcelain.daemon(gitdir, address=options.listen_address, port=options.port)
class cmd_web_daemon(Command):
- pass
+ def run(self, args):
+ from dulwich import log_utils
+
+ parser = optparse.OptionParser()
+ parser.add_option(
+ "-l",
+ "--listen_address",
+ dest="listen_address",
+ default="",
+ help="Binding IP address.",
+ )
+ parser.add_option(
+ "-p",
+ "--port",
+ dest="port",
+ type=int,
+ default=8000,
+ help="Binding TCP port.",
+ )
+ options, args = parser.parse_args(args)
+
+ log_utils.default_logging_config()
+ if len(args) >= 1:
+ gitdir = args[0]
+ else:
+ gitdir = "."
+
+ porcelain.web_daemon(gitdir, address=options.listen_address, port=options.port)
class cmd_write_tree(Command):
- pass
+ def run(self, args):
+ parser = optparse.OptionParser()
+ options, args = parser.parse_args(args)
+ sys.stdout.write("{}\n".format(porcelain.write_tree(".")))
class cmd_receive_pack(Command):
- pass
+ def run(self, args):
+ parser = optparse.OptionParser()
+ options, args = parser.parse_args(args)
+ if len(args) >= 1:
+ gitdir = args[0]
+ else:
+ gitdir = "."
+ porcelain.receive_pack(gitdir)
class cmd_upload_pack(Command):
- pass
+ def run(self, args):
+ parser = optparse.OptionParser()
+ options, args = parser.parse_args(args)
+ if len(args) >= 1:
+ gitdir = args[0]
+ else:
+ gitdir = "."
+ porcelain.upload_pack(gitdir)
class cmd_status(Command):
- pass
+ def run(self, args):
+ parser = optparse.OptionParser()
+ options, args = parser.parse_args(args)
+ if len(args) >= 1:
+ gitdir = args[0]
+ else:
+ gitdir = "."
+ status = porcelain.status(gitdir)
+ if any(names for (kind, names) in status.staged.items()):
+ sys.stdout.write("Changes to be committed:\n\n")
+ for kind, names in status.staged.items():
+ for name in names:
+ sys.stdout.write(
+ f"\t{kind}: {name.decode(sys.getfilesystemencoding())}\n"
+ )
+ sys.stdout.write("\n")
+ if status.unstaged:
+ sys.stdout.write("Changes not staged for commit:\n\n")
+ for name in status.unstaged:
+ sys.stdout.write(f"\t{name.decode(sys.getfilesystemencoding())}\n")
+ sys.stdout.write("\n")
+ if status.untracked:
+ sys.stdout.write("Untracked files:\n\n")
+ for name in status.untracked:
+ sys.stdout.write(f"\t{name}\n")
+ sys.stdout.write("\n")
class cmd_ls_remote(Command):
- pass
+ def run(self, args):
+ opts, args = getopt(args, "", [])
+ if len(args) < 1:
+ print("Usage: dulwich ls-remote URL")
+ sys.exit(1)
+ refs = porcelain.ls_remote(args[0])
+ for ref in sorted(refs):
+ sys.stdout.write(f"{ref}\t{refs[ref]}\n")
class cmd_ls_tree(Command):
- pass
+ def run(self, args):
+ parser = optparse.OptionParser()
+ parser.add_option(
+ "-r",
+ "--recursive",
+ action="store_true",
+ help="Recursively list tree contents.",
+ )
+ parser.add_option("--name-only", action="store_true", help="Only display name.")
+ options, args = parser.parse_args(args)
+ try:
+ treeish = args.pop(0)
+ except IndexError:
+ treeish = None
+ porcelain.ls_tree(
+ ".",
+ treeish,
+ outstream=sys.stdout,
+ recursive=options.recursive,
+ name_only=options.name_only,
+ )
class cmd_pack_objects(Command):
- pass
+ def run(self, args):
+ deltify = False
+ reuse_deltas = True
+ opts, args = getopt(args, "", ["stdout", "deltify", "no-reuse-deltas"])
+ opts = dict(opts)
+ if len(args) < 1 and "--stdout" not in opts.keys():
+ print("Usage: dulwich pack-objects basename")
+ sys.exit(1)
+ object_ids = [line.strip() for line in sys.stdin.readlines()]
+ if "--deltify" in opts.keys():
+ deltify = True
+ if "--no-reuse-deltas" in opts.keys():
+ reuse_deltas = False
+ if "--stdout" in opts.keys():
+ packf = getattr(sys.stdout, "buffer", sys.stdout)
+ idxf = None
+ close = []
+ else:
+ basename = args[0]
+ packf = open(basename + ".pack", "wb")
+ idxf = open(basename + ".idx", "wb")
+ close = [packf, idxf]
+ porcelain.pack_objects(
+ ".", object_ids, packf, idxf, deltify=deltify, reuse_deltas=reuse_deltas
+ )
+ for f in close:
+ f.close()
class cmd_pull(Command):
- pass
+ def run(self, args):
+ parser = argparse.ArgumentParser()
+ parser.add_argument("from_location", type=str)
+ parser.add_argument("refspec", type=str, nargs="*")
+ parser.add_argument("--filter", type=str, nargs=1)
+ parser.add_argument("--protocol", type=int, nargs=1)
+ args = parser.parse_args(args)
+ porcelain.pull(
+ ".",
+ args.from_location or None,
+ args.refspec or None,
+ filter_spec=args.filter,
+ protocol_version=args.protocol_version or None,
+ )
class cmd_push(Command):
- pass
+ def run(self, argv):
+ parser = argparse.ArgumentParser()
+ parser.add_argument("-f", "--force", action="store_true", help="Force")
+ parser.add_argument("to_location", type=str)
+ parser.add_argument("refspec", type=str, nargs="*")
+ args = parser.parse_args(argv)
+ try:
+ porcelain.push(
+ ".", args.to_location, args.refspec or None, force=args.force
+ )
+ except porcelain.DivergedBranches:
+ sys.stderr.write("Diverged branches; specify --force to override")
+ return 1
class cmd_remote_add(Command):
- pass
+ def run(self, args):
+ parser = optparse.OptionParser()
+ options, args = parser.parse_args(args)
+ porcelain.remote_add(".", args[0], args[1])
class SuperCommand(Command):
subcommands: ClassVar[Dict[str, Type[Command]]] = {}
default_command: ClassVar[Optional[Type[Command]]] = None
+ def run(self, args):
+ if not args and not self.default_command:
+ print(
+ "Supported subcommands: {}".format(", ".join(self.subcommands.keys()))
+ )
+ return False
+ cmd = args[0]
+ try:
+ cmd_kls = self.subcommands[cmd]
+ except KeyError:
+ print(f"No such subcommand: {args[0]}")
+ return False
+ return cmd_kls().run(args[1:])
+
class cmd_remote(SuperCommand):
- subcommands: ClassVar[Dict[str, Type[Command]]] = {'add': cmd_remote_add}
+ subcommands: ClassVar[Dict[str, Type[Command]]] = {
+ "add": cmd_remote_add,
+ }
class cmd_submodule_list(Command):
- pass
+ def run(self, argv):
+ parser = argparse.ArgumentParser()
+ parser.parse_args(argv)
+ for path, sha in porcelain.submodule_list("."):
+ sys.stdout.write(f" {sha} {path}\n")
class cmd_submodule_init(Command):
- pass
+ def run(self, argv):
+ parser = argparse.ArgumentParser()
+ parser.parse_args(argv)
+ porcelain.submodule_init(".")
class cmd_submodule(SuperCommand):
- subcommands: ClassVar[Dict[str, Type[Command]]] = {'init':
- cmd_submodule_init}
+ subcommands: ClassVar[Dict[str, Type[Command]]] = {
+ "init": cmd_submodule_init,
+ }
+
default_command = cmd_submodule_init
class cmd_check_ignore(Command):
- pass
+ def run(self, args):
+ parser = optparse.OptionParser()
+ options, args = parser.parse_args(args)
+ ret = 1
+ for path in porcelain.check_ignore(".", args):
+ print(path)
+ ret = 0
+ return ret
class cmd_check_mailmap(Command):
- pass
+ def run(self, args):
+ parser = optparse.OptionParser()
+ options, args = parser.parse_args(args)
+ for arg in args:
+ canonical_identity = porcelain.check_mailmap(".", arg)
+ print(canonical_identity)
class cmd_stash_list(Command):
- pass
+ def run(self, args):
+ parser = optparse.OptionParser()
+ options, args = parser.parse_args(args)
+ for i, entry in porcelain.stash_list("."):
+ print("stash@{%d}: %s" % (i, entry.message.rstrip("\n")))
class cmd_stash_push(Command):
- pass
+ def run(self, args):
+ parser = optparse.OptionParser()
+ options, args = parser.parse_args(args)
+ porcelain.stash_push(".")
+ print("Saved working directory and index state")
class cmd_stash_pop(Command):
- pass
+ def run(self, args):
+ parser = optparse.OptionParser()
+ options, args = parser.parse_args(args)
+ porcelain.stash_pop(".")
+ print("Restrored working directory and index state")
class cmd_stash(SuperCommand):
- subcommands: ClassVar[Dict[str, Type[Command]]] = {'list':
- cmd_stash_list, 'pop': cmd_stash_pop, 'push': cmd_stash_push}
+ subcommands: ClassVar[Dict[str, Type[Command]]] = {
+ "list": cmd_stash_list,
+ "pop": cmd_stash_pop,
+ "push": cmd_stash_push,
+ }
class cmd_ls_files(Command):
- pass
+ def run(self, args):
+ parser = optparse.OptionParser()
+ options, args = parser.parse_args(args)
+ for name in porcelain.ls_files("."):
+ print(name)
class cmd_describe(Command):
- pass
+ def run(self, args):
+ parser = optparse.OptionParser()
+ options, args = parser.parse_args(args)
+ print(porcelain.describe("."))
class cmd_help(Command):
- pass
-
-
-commands = {'add': cmd_add, 'archive': cmd_archive, 'check-ignore':
- cmd_check_ignore, 'check-mailmap': cmd_check_mailmap, 'clone':
- cmd_clone, 'commit': cmd_commit, 'commit-tree': cmd_commit_tree,
- 'describe': cmd_describe, 'daemon': cmd_daemon, 'diff': cmd_diff,
- 'diff-tree': cmd_diff_tree, 'dump-pack': cmd_dump_pack, 'dump-index':
- cmd_dump_index, 'fetch-pack': cmd_fetch_pack, 'fetch': cmd_fetch,
- 'for-each-ref': cmd_for_each_ref, 'fsck': cmd_fsck, 'help': cmd_help,
- 'init': cmd_init, 'log': cmd_log, 'ls-files': cmd_ls_files, 'ls-remote':
- cmd_ls_remote, 'ls-tree': cmd_ls_tree, 'pack-objects': cmd_pack_objects,
- 'pack-refs': cmd_pack_refs, 'pull': cmd_pull, 'push': cmd_push,
- 'receive-pack': cmd_receive_pack, 'remote': cmd_remote, 'repack':
- cmd_repack, 'reset': cmd_reset, 'rev-list': cmd_rev_list, 'rm': cmd_rm,
- 'show': cmd_show, 'stash': cmd_stash, 'status': cmd_status,
- 'symbolic-ref': cmd_symbolic_ref, 'submodule': cmd_submodule, 'tag':
- cmd_tag, 'update-server-info': cmd_update_server_info, 'upload-pack':
- cmd_upload_pack, 'web-daemon': cmd_web_daemon, 'write-tree': cmd_write_tree
- }
-if __name__ == '__main__':
+ def run(self, args):
+ parser = optparse.OptionParser()
+ parser.add_option(
+ "-a",
+ "--all",
+ dest="all",
+ action="store_true",
+ help="List all commands.",
+ )
+ options, args = parser.parse_args(args)
+
+ if options.all:
+ print("Available commands:")
+ for cmd in sorted(commands):
+ print(f" {cmd}")
+ else:
+ print(
+ """\
+The dulwich command line tool is currently a very basic frontend for the
+Dulwich python module. For full functionality, please see the API reference.
+
+For a list of supported commands, see 'dulwich help -a'.
+"""
+ )
+
+
+commands = {
+ "add": cmd_add,
+ "archive": cmd_archive,
+ "check-ignore": cmd_check_ignore,
+ "check-mailmap": cmd_check_mailmap,
+ "clone": cmd_clone,
+ "commit": cmd_commit,
+ "commit-tree": cmd_commit_tree,
+ "describe": cmd_describe,
+ "daemon": cmd_daemon,
+ "diff": cmd_diff,
+ "diff-tree": cmd_diff_tree,
+ "dump-pack": cmd_dump_pack,
+ "dump-index": cmd_dump_index,
+ "fetch-pack": cmd_fetch_pack,
+ "fetch": cmd_fetch,
+ "for-each-ref": cmd_for_each_ref,
+ "fsck": cmd_fsck,
+ "help": cmd_help,
+ "init": cmd_init,
+ "log": cmd_log,
+ "ls-files": cmd_ls_files,
+ "ls-remote": cmd_ls_remote,
+ "ls-tree": cmd_ls_tree,
+ "pack-objects": cmd_pack_objects,
+ "pack-refs": cmd_pack_refs,
+ "pull": cmd_pull,
+ "push": cmd_push,
+ "receive-pack": cmd_receive_pack,
+ "remote": cmd_remote,
+ "repack": cmd_repack,
+ "reset": cmd_reset,
+ "rev-list": cmd_rev_list,
+ "rm": cmd_rm,
+ "show": cmd_show,
+ "stash": cmd_stash,
+ "status": cmd_status,
+ "symbolic-ref": cmd_symbolic_ref,
+ "submodule": cmd_submodule,
+ "tag": cmd_tag,
+ "update-server-info": cmd_update_server_info,
+ "upload-pack": cmd_upload_pack,
+ "web-daemon": cmd_web_daemon,
+ "write-tree": cmd_write_tree,
+}
+
+
+def main(argv=None):
+ if argv is None:
+ argv = sys.argv[1:]
+
+ if len(argv) < 1:
+ print("Usage: dulwich <{}> [OPTIONS...]".format("|".join(commands.keys())))
+ return 1
+
+ cmd = argv[0]
+ try:
+ cmd_kls = commands[cmd]
+ except KeyError:
+ print(f"No such subcommand: {cmd}")
+ return 1
+ # TODO(jelmer): Return non-0 on errors
+ return cmd_kls().run(argv[1:])
+
+
+def _main():
+ if "DULWICH_PDB" in os.environ and getattr(signal, "SIGQUIT", None):
+ signal.signal(signal.SIGQUIT, signal_quit) # type: ignore
+ signal.signal(signal.SIGINT, signal_int)
+
+ sys.exit(main())
+
+
+if __name__ == "__main__":
_main()
diff --git a/dulwich/client.py b/dulwich/client.py
index e21ee5ae..58b3cade 100644
--- a/dulwich/client.py
+++ b/dulwich/client.py
@@ -1,3 +1,23 @@
+# client.py -- Implementation of the client side git protocols
+# Copyright (C) 2008-2013 Jelmer Vernooij <jelmer@jelmer.uk>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Client side support for the Git protocol.
The Dulwich client supports the following capabilities:
@@ -17,6 +37,7 @@ Known capabilities that are not supported:
* no-progress
* include-tag
"""
+
import copy
import logging
import os
@@ -26,36 +47,104 @@ import subprocess
import sys
from contextlib import closing
from io import BufferedReader, BytesIO
-from typing import IO, TYPE_CHECKING, Callable, ClassVar, Dict, Iterable, Iterator, List, Optional, Set, Tuple, Union
+from typing import (
+ IO,
+ TYPE_CHECKING,
+ Callable,
+ ClassVar,
+ Dict,
+ Iterable,
+ Iterator,
+ List,
+ Optional,
+ Set,
+ Tuple,
+ Union,
+)
from urllib.parse import quote as urlquote
from urllib.parse import unquote as urlunquote
from urllib.parse import urljoin, urlparse, urlunparse, urlunsplit
+
if TYPE_CHECKING:
import urllib3
+
import dulwich
+
from .config import Config, apply_instead_of, get_xdg_config_home_path
from .errors import GitProtocolError, NotGitRepository, SendPackError
-from .pack import PACK_SPOOL_FILE_MAX_SIZE, PackChunkGenerator, UnpackedObject, write_pack_from_container
-from .protocol import _RBUFSIZE, CAPABILITIES_REF, CAPABILITY_AGENT, CAPABILITY_DELETE_REFS, CAPABILITY_FETCH, CAPABILITY_FILTER, CAPABILITY_INCLUDE_TAG, CAPABILITY_MULTI_ACK, CAPABILITY_MULTI_ACK_DETAILED, CAPABILITY_OFS_DELTA, CAPABILITY_QUIET, CAPABILITY_REPORT_STATUS, CAPABILITY_SHALLOW, CAPABILITY_SIDE_BAND_64K, CAPABILITY_SYMREF, CAPABILITY_THIN_PACK, COMMAND_DEEPEN, COMMAND_DONE, COMMAND_HAVE, COMMAND_SHALLOW, COMMAND_UNSHALLOW, COMMAND_WANT, DEFAULT_GIT_PROTOCOL_VERSION_FETCH, DEFAULT_GIT_PROTOCOL_VERSION_SEND, GIT_PROTOCOL_VERSIONS, KNOWN_RECEIVE_CAPABILITIES, KNOWN_UPLOAD_CAPABILITIES, SIDE_BAND_CHANNEL_DATA, SIDE_BAND_CHANNEL_FATAL, SIDE_BAND_CHANNEL_PROGRESS, TCP_GIT_PORT, ZERO_SHA, HangupException, PktLineParser, Protocol, agent_string, capability_agent, extract_capabilities, extract_capability_names, parse_capability, pkt_line
+from .pack import (
+ PACK_SPOOL_FILE_MAX_SIZE,
+ PackChunkGenerator,
+ UnpackedObject,
+ write_pack_from_container,
+)
+from .protocol import (
+ _RBUFSIZE,
+ CAPABILITIES_REF,
+ CAPABILITY_AGENT,
+ CAPABILITY_DELETE_REFS,
+ CAPABILITY_FETCH,
+ CAPABILITY_FILTER,
+ CAPABILITY_INCLUDE_TAG,
+ CAPABILITY_MULTI_ACK,
+ CAPABILITY_MULTI_ACK_DETAILED,
+ CAPABILITY_OFS_DELTA,
+ CAPABILITY_QUIET,
+ CAPABILITY_REPORT_STATUS,
+ CAPABILITY_SHALLOW,
+ CAPABILITY_SIDE_BAND_64K,
+ CAPABILITY_SYMREF,
+ CAPABILITY_THIN_PACK,
+ COMMAND_DEEPEN,
+ COMMAND_DONE,
+ COMMAND_HAVE,
+ COMMAND_SHALLOW,
+ COMMAND_UNSHALLOW,
+ COMMAND_WANT,
+ DEFAULT_GIT_PROTOCOL_VERSION_FETCH,
+ DEFAULT_GIT_PROTOCOL_VERSION_SEND,
+ GIT_PROTOCOL_VERSIONS,
+ KNOWN_RECEIVE_CAPABILITIES,
+ KNOWN_UPLOAD_CAPABILITIES,
+ SIDE_BAND_CHANNEL_DATA,
+ SIDE_BAND_CHANNEL_FATAL,
+ SIDE_BAND_CHANNEL_PROGRESS,
+ TCP_GIT_PORT,
+ ZERO_SHA,
+ HangupException,
+ PktLineParser,
+ Protocol,
+ agent_string,
+ capability_agent,
+ extract_capabilities,
+ extract_capability_names,
+ parse_capability,
+ pkt_line,
+)
from .refs import PEELED_TAG_SUFFIX, _import_remote_refs, read_info_refs
from .repo import Repo
+
+# url2pathname is lazily imported
url2pathname = None
+
+
logger = logging.getLogger(__name__)
class InvalidWants(Exception):
"""Invalid wants."""
- def __init__(self, wants) ->None:
- Exception.__init__(self,
- f'requested wants not in server provided refs: {wants!r}')
+ def __init__(self, wants) -> None:
+ Exception.__init__(
+ self, f"requested wants not in server provided refs: {wants!r}"
+ )
class HTTPUnauthorized(Exception):
"""Raised when authentication fails."""
- def __init__(self, www_authenticate, url) ->None:
- Exception.__init__(self, 'No valid credentials provided')
+ def __init__(self, www_authenticate, url) -> None:
+ Exception.__init__(self, "No valid credentials provided")
self.www_authenticate = www_authenticate
self.url = url
@@ -63,33 +152,50 @@ class HTTPUnauthorized(Exception):
class HTTPProxyUnauthorized(Exception):
"""Raised when proxy authentication fails."""
- def __init__(self, proxy_authenticate, url) ->None:
- Exception.__init__(self, 'No valid proxy credentials provided')
+ def __init__(self, proxy_authenticate, url) -> None:
+ Exception.__init__(self, "No valid proxy credentials provided")
self.proxy_authenticate = proxy_authenticate
self.url = url
def _fileno_can_read(fileno):
"""Check if a file descriptor is readable."""
- pass
+ return len(select.select([fileno], [], [], 0)[0]) > 0
def _win32_peek_avail(handle):
"""Wrapper around PeekNamedPipe to check how many bytes are available."""
- pass
+ from ctypes import byref, windll, wintypes
+
+ c_avail = wintypes.DWORD()
+ c_message = wintypes.DWORD()
+ success = windll.kernel32.PeekNamedPipe(
+ handle, None, 0, None, byref(c_avail), byref(c_message)
+ )
+ if not success:
+ raise OSError(wintypes.GetLastError())
+ return c_avail.value
COMMON_CAPABILITIES = [CAPABILITY_OFS_DELTA, CAPABILITY_SIDE_BAND_64K]
-UPLOAD_CAPABILITIES = [CAPABILITY_THIN_PACK, CAPABILITY_MULTI_ACK,
- CAPABILITY_MULTI_ACK_DETAILED, CAPABILITY_SHALLOW, *COMMON_CAPABILITIES]
-RECEIVE_CAPABILITIES = [CAPABILITY_REPORT_STATUS, CAPABILITY_DELETE_REFS, *
- COMMON_CAPABILITIES]
+UPLOAD_CAPABILITIES = [
+ CAPABILITY_THIN_PACK,
+ CAPABILITY_MULTI_ACK,
+ CAPABILITY_MULTI_ACK_DETAILED,
+ CAPABILITY_SHALLOW,
+ *COMMON_CAPABILITIES,
+]
+RECEIVE_CAPABILITIES = [
+ CAPABILITY_REPORT_STATUS,
+ CAPABILITY_DELETE_REFS,
+ *COMMON_CAPABILITIES,
+]
class ReportStatusParser:
"""Handle status as reported by servers with 'report-status' capability."""
- def __init__(self) ->None:
+ def __init__(self) -> None:
self._done = False
self._pack_status = None
self._ref_statuses: List[bytes] = []
@@ -102,7 +208,21 @@ class ReportStatusParser:
Returns:
iterator over refs
"""
- pass
+ if self._pack_status not in (b"unpack ok", None):
+ raise SendPackError(self._pack_status)
+ for status in self._ref_statuses:
+ try:
+ status, rest = status.split(b" ", 1)
+ except ValueError:
+ # malformed response, move on to the next one
+ continue
+ if status == b"ng":
+ ref, error = rest.split(b" ", 1)
+ yield ref, error.decode("utf-8")
+ elif status == b"ok":
+ yield rest, None
+ else:
+ raise GitProtocolError(f"invalid ref status {status!r}")
def handle_packet(self, pkt):
"""Handle a packet.
@@ -111,7 +231,61 @@ class ReportStatusParser:
GitProtocolError: Raised when packets are received after a flush
packet.
"""
- pass
+ if self._done:
+ raise GitProtocolError("received more data after status report")
+ if pkt is None:
+ self._done = True
+ return
+ if self._pack_status is None:
+ self._pack_status = pkt.strip()
+ else:
+ ref_status = pkt.strip()
+ self._ref_statuses.append(ref_status)
+
+
+def negotiate_protocol_version(proto):
+ pkt = proto.read_pkt_line()
+ if pkt == b"version 2\n":
+ return 2
+ proto.unread_pkt_line(pkt)
+ return 0
+
+
+def read_server_capabilities(pkt_seq):
+ server_capabilities = []
+ for pkt in pkt_seq:
+ server_capabilities.append(pkt)
+ return set(server_capabilities)
+
+
+def read_pkt_refs(pkt_seq, server_capabilities=None):
+ refs = {}
+ # Receive refs from server
+ for pkt in pkt_seq:
+ (sha, ref) = pkt.rstrip(b"\n").split(None, 1)
+ if sha == b"ERR":
+ raise GitProtocolError(ref.decode("utf-8", "replace"))
+ if server_capabilities is None:
+ (ref, server_capabilities) = extract_capabilities(ref)
+ else: # Git protocol-v2:
+ try:
+ symref, target = ref.split(b" ", 1)
+ except ValueError:
+ pass
+ else:
+ if symref and target and target[:14] == b"symref-target:":
+ server_capabilities.add(
+ b"%s=%s:%s"
+ % (CAPABILITY_SYMREF, symref, target.split(b":", 1)[1])
+ )
+ ref = symref
+ refs[ref] = sha
+
+ if len(refs) == 0:
+ return {}, set()
+ if refs == {CAPABILITIES_REF: ZERO_SHA}:
+ refs = {}
+ return refs, set(server_capabilities)
class FetchPackResult:
@@ -122,26 +296,53 @@ class FetchPackResult:
symrefs: Dictionary with remote symrefs
agent: User agent string
"""
- _FORWARDED_ATTRS: ClassVar[Set[str]] = {'clear', 'copy', 'fromkeys',
- 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update',
- 'values', 'viewitems', 'viewkeys', 'viewvalues'}
- def __init__(self, refs, symrefs, agent, new_shallow=None,
- new_unshallow=None) ->None:
+ _FORWARDED_ATTRS: ClassVar[Set[str]] = {
+ "clear",
+ "copy",
+ "fromkeys",
+ "get",
+ "items",
+ "keys",
+ "pop",
+ "popitem",
+ "setdefault",
+ "update",
+ "values",
+ "viewitems",
+ "viewkeys",
+ "viewvalues",
+ }
+
+ def __init__(
+ self, refs, symrefs, agent, new_shallow=None, new_unshallow=None
+ ) -> None:
self.refs = refs
self.symrefs = symrefs
self.agent = agent
self.new_shallow = new_shallow
self.new_unshallow = new_unshallow
+ def _warn_deprecated(self):
+ import warnings
+
+ warnings.warn(
+ "Use FetchPackResult.refs instead.",
+ DeprecationWarning,
+ stacklevel=3,
+ )
+
def __eq__(self, other):
if isinstance(other, dict):
self._warn_deprecated()
return self.refs == other
- return (self.refs == other.refs and self.symrefs == other.symrefs and
- self.agent == other.agent)
+ return (
+ self.refs == other.refs
+ and self.symrefs == other.symrefs
+ and self.agent == other.agent
+ )
- def __contains__(self, name) ->bool:
+ def __contains__(self, name) -> bool:
self._warn_deprecated()
return name in self.refs
@@ -149,7 +350,7 @@ class FetchPackResult:
self._warn_deprecated()
return self.refs[name]
- def __len__(self) ->int:
+ def __len__(self) -> int:
self._warn_deprecated()
return len(self.refs)
@@ -163,10 +364,8 @@ class FetchPackResult:
return getattr(self.refs, name)
return super().__getattribute__(name)
- def __repr__(self) ->str:
- return (
- f'{self.__class__.__name__}({self.refs!r}, {self.symrefs!r}, {self.agent!r})'
- )
+ def __repr__(self) -> str:
+ return f"{self.__class__.__name__}({self.refs!r}, {self.symrefs!r}, {self.agent!r})"
class SendPackResult:
@@ -178,22 +377,45 @@ class SendPackResult:
ref_status: Optional dictionary mapping ref name to error message (if it
failed to update), or None if it was updated successfully
"""
- _FORWARDED_ATTRS: ClassVar[Set[str]] = {'clear', 'copy', 'fromkeys',
- 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update',
- 'values', 'viewitems', 'viewkeys', 'viewvalues'}
- def __init__(self, refs, agent=None, ref_status=None) ->None:
+ _FORWARDED_ATTRS: ClassVar[Set[str]] = {
+ "clear",
+ "copy",
+ "fromkeys",
+ "get",
+ "items",
+ "keys",
+ "pop",
+ "popitem",
+ "setdefault",
+ "update",
+ "values",
+ "viewitems",
+ "viewkeys",
+ "viewvalues",
+ }
+
+ def __init__(self, refs, agent=None, ref_status=None) -> None:
self.refs = refs
self.agent = agent
self.ref_status = ref_status
+ def _warn_deprecated(self):
+ import warnings
+
+ warnings.warn(
+ "Use SendPackResult.refs instead.",
+ DeprecationWarning,
+ stacklevel=3,
+ )
+
def __eq__(self, other):
if isinstance(other, dict):
self._warn_deprecated()
return self.refs == other
return self.refs == other.refs and self.agent == other.agent
- def __contains__(self, name) ->bool:
+ def __contains__(self, name) -> bool:
self._warn_deprecated()
return name in self.refs
@@ -201,7 +423,7 @@ class SendPackResult:
self._warn_deprecated()
return self.refs[name]
- def __len__(self) ->int:
+ def __len__(self) -> int:
self._warn_deprecated()
return len(self.refs)
@@ -215,17 +437,34 @@ class SendPackResult:
return getattr(self.refs, name)
return super().__getattribute__(name)
- def __repr__(self) ->str:
- return f'{self.__class__.__name__}({self.refs!r}, {self.agent!r})'
+ def __repr__(self) -> str:
+ return f"{self.__class__.__name__}({self.refs!r}, {self.agent!r})"
+
+
+def _read_shallow_updates(pkt_seq):
+ new_shallow = set()
+ new_unshallow = set()
+ for pkt in pkt_seq:
+ if pkt == b"shallow-info\n": # Git-protocol v2
+ continue
+ try:
+ cmd, sha = pkt.split(b" ", 1)
+ except ValueError:
+ raise GitProtocolError(f"unknown command {pkt}")
+ if cmd == COMMAND_SHALLOW:
+ new_shallow.add(sha.strip())
+ elif cmd == COMMAND_UNSHALLOW:
+ new_unshallow.add(sha.strip())
+ else:
+ raise GitProtocolError(f"unknown command {pkt}")
+ return (new_shallow, new_unshallow)
class _v1ReceivePackHeader:
-
- def __init__(self, capabilities, old_refs, new_refs) ->None:
+ def __init__(self, capabilities, old_refs, new_refs) -> None:
self.want: List[bytes] = []
self.have: List[bytes] = []
- self._it = self._handle_receive_pack_head(capabilities, old_refs,
- new_refs)
+ self._it = self._handle_receive_pack_head(capabilities, old_refs, new_refs)
self.sent_capabilities = False
def __iter__(self):
@@ -242,11 +481,45 @@ class _v1ReceivePackHeader:
Returns:
(have, want) tuple
"""
- pass
-
-
-def _read_side_band64k_data(pkt_seq: Iterable[bytes]) ->Iterator[Tuple[int,
- bytes]]:
+ self.have = [x for x in old_refs.values() if not x == ZERO_SHA]
+
+ for refname in new_refs:
+ if not isinstance(refname, bytes):
+ raise TypeError(f"refname is not a bytestring: {refname!r}")
+ old_sha1 = old_refs.get(refname, ZERO_SHA)
+ if not isinstance(old_sha1, bytes):
+ raise TypeError(
+ f"old sha1 for {refname!r} is not a bytestring: {old_sha1!r}"
+ )
+ new_sha1 = new_refs.get(refname, ZERO_SHA)
+ if not isinstance(new_sha1, bytes):
+ raise TypeError(
+ f"old sha1 for {refname!r} is not a bytestring {new_sha1!r}"
+ )
+
+ if old_sha1 != new_sha1:
+ logger.debug(
+ "Sending updated ref %r: %r -> %r", refname, old_sha1, new_sha1
+ )
+ if self.sent_capabilities:
+ yield old_sha1 + b" " + new_sha1 + b" " + refname
+ else:
+ yield (
+ old_sha1
+ + b" "
+ + new_sha1
+ + b" "
+ + refname
+ + b"\0"
+ + b" ".join(sorted(capabilities))
+ )
+ self.sent_capabilities = True
+ if new_sha1 not in self.have and new_sha1 != ZERO_SHA:
+ self.want.append(new_sha1)
+ yield None
+
+
+def _read_side_band64k_data(pkt_seq: Iterable[bytes]) -> Iterator[Tuple[int, bytes]]:
"""Read per-channel data.
This requires the side-band-64k capability.
@@ -254,11 +527,30 @@ def _read_side_band64k_data(pkt_seq: Iterable[bytes]) ->Iterator[Tuple[int,
Args:
pkt_seq: Sequence of packets to read
"""
- pass
-
-
-def _handle_upload_pack_head(proto, capabilities, graph_walker, wants,
- can_read, depth, protocol_version):
+ for pkt in pkt_seq:
+ channel = ord(pkt[:1])
+ yield channel, pkt[1:]
+
+
+def find_capability(capabilities, key, value):
+ for capability in capabilities:
+ k, v = parse_capability(capability)
+ if k != key:
+ continue
+ if value and value not in v.split(b" "):
+ continue
+ return capability
+
+
+def _handle_upload_pack_head(
+ proto,
+ capabilities,
+ graph_walker,
+ wants,
+ can_read,
+ depth,
+ protocol_version,
+):
"""Handle the head of a 'git-upload-pack' request.
Args:
@@ -271,12 +563,77 @@ def _handle_upload_pack_head(proto, capabilities, graph_walker, wants,
depth: Depth for request
protocol_version: Neogiated Git protocol version.
"""
- pass
-
-
-def _handle_upload_pack_tail(proto, capabilities: Set[bytes], graph_walker,
- pack_data: Callable[[bytes], None], progress: Optional[Callable[[bytes],
- None]]=None, rbufsize=_RBUFSIZE, protocol_version=0):
+ assert isinstance(wants, list) and isinstance(wants[0], bytes)
+ wantcmd = COMMAND_WANT + b" " + wants[0]
+ if protocol_version is None:
+ protocol_version = DEFAULT_GIT_PROTOCOL_VERSION_SEND
+ if protocol_version != 2:
+ wantcmd += b" " + b" ".join(sorted(capabilities))
+ wantcmd += b"\n"
+ proto.write_pkt_line(wantcmd)
+ for want in wants[1:]:
+ proto.write_pkt_line(COMMAND_WANT + b" " + want + b"\n")
+ if depth not in (0, None) or getattr(graph_walker, "shallow", None):
+ if protocol_version == 2:
+ if not find_capability(capabilities, CAPABILITY_FETCH, CAPABILITY_SHALLOW):
+ raise GitProtocolError(
+ "server does not support shallow capability required for " "depth"
+ )
+ elif CAPABILITY_SHALLOW not in capabilities:
+ raise GitProtocolError(
+ "server does not support shallow capability required for " "depth"
+ )
+ for sha in graph_walker.shallow:
+ proto.write_pkt_line(COMMAND_SHALLOW + b" " + sha + b"\n")
+ if depth is not None:
+ proto.write_pkt_line(
+ COMMAND_DEEPEN + b" " + str(depth).encode("ascii") + b"\n"
+ )
+ if protocol_version == 2:
+ proto.write_pkt_line(None)
+ if protocol_version != 2:
+ proto.write_pkt_line(None)
+
+ if depth not in (0, None):
+ if can_read is not None:
+ (new_shallow, new_unshallow) = _read_shallow_updates(proto.read_pkt_seq())
+ else:
+ new_shallow = new_unshallow = None
+ else:
+ new_shallow = new_unshallow = set()
+
+ have = next(graph_walker)
+ while have:
+ proto.write_pkt_line(COMMAND_HAVE + b" " + have + b"\n")
+ if can_read is not None and can_read():
+ pkt = proto.read_pkt_line()
+ parts = pkt.rstrip(b"\n").split(b" ")
+ if parts[0] == b"ACK":
+ graph_walker.ack(parts[1])
+ if parts[2] in (b"continue", b"common"):
+ pass
+ elif parts[2] == b"ready":
+ break
+ else:
+ raise AssertionError(
+ f"{parts[2]} not in ('continue', 'ready', 'common)"
+ )
+ have = next(graph_walker)
+ proto.write_pkt_line(COMMAND_DONE + b"\n")
+ if protocol_version == 2:
+ proto.write_pkt_line(None)
+ return (new_shallow, new_unshallow)
+
+
+def _handle_upload_pack_tail(
+ proto,
+ capabilities: Set[bytes],
+ graph_walker,
+ pack_data: Callable[[bytes], None],
+ progress: Optional[Callable[[bytes], None]] = None,
+ rbufsize=_RBUFSIZE,
+ protocol_version=0,
+):
"""Handle the tail of a 'git-upload-pack' request.
Args:
@@ -288,14 +645,59 @@ def _handle_upload_pack_tail(proto, capabilities: Set[bytes], graph_walker,
rbufsize: Read buffer size
protocol_version: Neogiated Git protocol version.
"""
- pass
-
-
+ pkt = proto.read_pkt_line()
+ while pkt:
+ parts = pkt.rstrip(b"\n").split(b" ")
+ if protocol_version == 2 and parts[0] != "packfile":
+ break
+ else:
+ if parts[0] == b"ACK":
+ graph_walker.ack(parts[1])
+ if parts[0] == b"NAK":
+ graph_walker.nak()
+ if len(parts) < 3 or parts[2] not in (
+ b"ready",
+ b"continue",
+ b"common",
+ ):
+ break
+ pkt = proto.read_pkt_line()
+ if CAPABILITY_SIDE_BAND_64K in capabilities or protocol_version == 2:
+ if progress is None:
+ # Just ignore progress data
+
+ def progress(x):
+ pass
+
+ for chan, data in _read_side_band64k_data(proto.read_pkt_seq()):
+ if chan == SIDE_BAND_CHANNEL_DATA:
+ pack_data(data)
+ elif chan == SIDE_BAND_CHANNEL_PROGRESS:
+ progress(data)
+ else:
+ raise AssertionError("Invalid sideband channel %d" % chan)
+ else:
+ while True:
+ data = proto.read(rbufsize)
+ if data == b"":
+ break
+ pack_data(data)
+
+
+# TODO(durin42): this doesn't correctly degrade if the server doesn't
+# support some capabilities. This should work properly with servers
+# that don't support multi_ack.
class GitClient:
"""Git smart server client."""
- def __init__(self, thin_packs=True, report_activity=None, quiet=False,
- include_tags=False, **kwargs) ->None:
+ def __init__(
+ self,
+ thin_packs=True,
+ report_activity=None,
+ quiet=False,
+ include_tags=False,
+ **kwargs,
+ ) -> None:
"""Create a new GitClient instance.
Args:
@@ -317,7 +719,7 @@ class GitClient:
self._fetch_capabilities.remove(CAPABILITY_THIN_PACK)
if include_tags:
self._fetch_capabilities.add(CAPABILITY_INCLUDE_TAG)
- self.protocol_version = 0
+ self.protocol_version = 0 # will be overridden later
def get_url(self, path):
"""Retrieves full url to given path.
@@ -329,7 +731,7 @@ class GitClient:
Url to path (as string)
"""
- pass
+ raise NotImplementedError(self.get_url)
@classmethod
def from_parsedurl(cls, parsedurl, **kwargs):
@@ -341,11 +743,17 @@ class GitClient:
Returns:
A `GitClient` object
"""
- pass
-
- def send_pack(self, path, update_refs, generate_pack_data: Callable[[
- Set[bytes], Set[bytes], bool], Tuple[int, Iterator[UnpackedObject]]
- ], progress=None):
+ raise NotImplementedError(cls.from_parsedurl)
+
+ def send_pack(
+ self,
+ path,
+ update_refs,
+ generate_pack_data: Callable[
+ [Set[bytes], Set[bytes], bool], Tuple[int, Iterator[UnpackedObject]]
+ ],
+ progress=None,
+ ):
"""Upload a pack to a remote repository.
Args:
@@ -364,21 +772,121 @@ class GitClient:
SendPackError: if server rejects the pack data
"""
- pass
-
- def clone(self, path, target_path, mkdir: bool=True, bare: bool=False,
- origin: Optional[str]='origin', checkout=None, branch=None,
- progress=None, depth=None, ref_prefix=[], filter_spec=None,
- protocol_version: Optional[int]=None) ->Repo:
+ raise NotImplementedError(self.send_pack)
+
+ def clone(
+ self,
+ path,
+ target_path,
+ mkdir: bool = True,
+ bare: bool = False,
+ origin: Optional[str] = "origin",
+ checkout=None,
+ branch=None,
+ progress=None,
+ depth=None,
+ ref_prefix=[],
+ filter_spec=None,
+ protocol_version: Optional[int] = None,
+ ) -> Repo:
"""Clone a repository."""
- pass
-
- def fetch(self, path: str, target: Repo, determine_wants: Optional[
- Callable[[Dict[bytes, bytes], Optional[int]], List[bytes]]]=None,
- progress: Optional[Callable[[bytes], None]]=None, depth: Optional[
- int]=None, ref_prefix: Optional[List[bytes]]=[], filter_spec:
- Optional[bytes]=None, protocol_version: Optional[int]=None
- ) ->FetchPackResult:
+ from .refs import _set_default_branch, _set_head, _set_origin_head
+
+ if mkdir:
+ os.mkdir(target_path)
+
+ try:
+ target = None
+ if not bare:
+ target = Repo.init(target_path)
+ if checkout is None:
+ checkout = True
+ else:
+ if checkout:
+ raise ValueError("checkout and bare are incompatible")
+ target = Repo.init_bare(target_path)
+
+ # TODO(jelmer): abstract method for get_location?
+ if isinstance(self, (LocalGitClient, SubprocessGitClient)):
+ encoded_path = path.encode("utf-8")
+ else:
+ encoded_path = self.get_url(path).encode("utf-8")
+
+ assert target is not None
+ if origin is not None:
+ target_config = target.get_config()
+ target_config.set(
+ (b"remote", origin.encode("utf-8")), b"url", encoded_path
+ )
+ target_config.set(
+ (b"remote", origin.encode("utf-8")),
+ b"fetch",
+ b"+refs/heads/*:refs/remotes/" + origin.encode("utf-8") + b"/*",
+ )
+ target_config.write_to_path()
+
+ ref_message = b"clone: from " + encoded_path
+ result = self.fetch(
+ path,
+ target,
+ progress=progress,
+ depth=depth,
+ ref_prefix=ref_prefix,
+ filter_spec=filter_spec,
+ protocol_version=protocol_version,
+ )
+ if origin is not None:
+ _import_remote_refs(
+ target.refs, origin, result.refs, message=ref_message
+ )
+
+ origin_head = result.symrefs.get(b"HEAD")
+ origin_sha = result.refs.get(b"HEAD")
+ if origin is None or (origin_sha and not origin_head):
+ # set detached HEAD
+ target.refs[b"HEAD"] = origin_sha
+ head = origin_sha
+ else:
+ _set_origin_head(target.refs, origin.encode("utf-8"), origin_head)
+ head_ref = _set_default_branch(
+ target.refs,
+ origin.encode("utf-8"),
+ origin_head,
+ branch,
+ ref_message,
+ )
+
+ # Update target head
+ if head_ref:
+ head = _set_head(target.refs, head_ref, ref_message)
+ else:
+ head = None
+
+ if checkout and head is not None:
+ target.reset_index()
+ except BaseException:
+ if target is not None:
+ target.close()
+ if mkdir:
+ import shutil
+
+ shutil.rmtree(target_path)
+ raise
+ return target
+
+ def fetch(
+ self,
+ path: str,
+ target: Repo,
+ determine_wants: Optional[
+ Callable[[Dict[bytes, bytes], Optional[int]], List[bytes]]
+ ] = None,
+ progress: Optional[Callable[[bytes], None]] = None,
+ depth: Optional[int] = None,
+ ref_prefix: Optional[List[bytes]] = [],
+ filter_spec: Optional[bytes] = None,
+ protocol_version: Optional[int] = None,
+ ) -> FetchPackResult:
"""Fetch into a target repository.
Args:
@@ -405,12 +913,61 @@ class GitClient:
Dictionary with all remote refs (not just those fetched)
"""
- pass
+ if determine_wants is None:
+ determine_wants = target.object_store.determine_wants_all
+ if CAPABILITY_THIN_PACK in self._fetch_capabilities:
+ from tempfile import SpooledTemporaryFile
+
+ f: IO[bytes] = SpooledTemporaryFile(
+ max_size=PACK_SPOOL_FILE_MAX_SIZE,
+ prefix="incoming-",
+ dir=getattr(target.object_store, "path", None),
+ )
+
+ def commit():
+ if f.tell():
+ f.seek(0)
+ target.object_store.add_thin_pack(f.read, None, progress=progress)
+ f.close()
- def fetch_pack(self, path: str, determine_wants, graph_walker,
- pack_data, *, progress: Optional[Callable[[bytes], None]]=None,
- depth: Optional[int]=None, ref_prefix=[], filter_spec=None,
- protocol_version: Optional[int]=None):
+ def abort():
+ f.close()
+
+ else:
+ f, commit, abort = target.object_store.add_pack()
+ try:
+ result = self.fetch_pack(
+ path,
+ determine_wants,
+ target.get_graph_walker(),
+ f.write,
+ progress=progress,
+ depth=depth,
+ ref_prefix=ref_prefix,
+ filter_spec=filter_spec,
+ protocol_version=protocol_version,
+ )
+ except BaseException:
+ abort()
+ raise
+ else:
+ commit()
+ target.update_shallow(result.new_shallow, result.new_unshallow)
+ return result
+
+ def fetch_pack(
+ self,
+ path: str,
+ determine_wants,
+ graph_walker,
+ pack_data,
+ *,
+ progress: Optional[Callable[[bytes], None]] = None,
+ depth: Optional[int] = None,
+ ref_prefix=[],
+ filter_spec=None,
+ protocol_version: Optional[int] = None,
+ ):
"""Retrieve a pack from a git smart server.
Args:
@@ -438,7 +995,7 @@ class GitClient:
FetchPackResult object
"""
- pass
+ raise NotImplementedError(self.fetch_pack)
def get_refs(self, path):
"""Retrieve the current refs from a git smart server.
@@ -446,11 +1003,30 @@ class GitClient:
Args:
path: Path to the repo to fetch from. (as bytestring)
"""
- pass
-
- def _handle_receive_pack_tail(self, proto: Protocol, capabilities: Set[
- bytes], progress: Optional[Callable[[bytes], None]]=None) ->Optional[
- Dict[bytes, Optional[str]]]:
+ raise NotImplementedError(self.get_refs)
+
+ @staticmethod
+ def _should_send_pack(new_refs):
+ # The packfile MUST NOT be sent if the only command used is delete.
+ return any(sha != ZERO_SHA for sha in new_refs.values())
+
+ def _negotiate_receive_pack_capabilities(self, server_capabilities):
+ negotiated_capabilities = self._send_capabilities & server_capabilities
+ agent = None
+ for capability in server_capabilities:
+ k, v = parse_capability(capability)
+ if k == CAPABILITY_AGENT:
+ agent = v
+ (extract_capability_names(server_capabilities) - KNOWN_RECEIVE_CAPABILITIES)
+ # TODO(jelmer): warn about unknown capabilities
+ return negotiated_capabilities, agent
+
+ def _handle_receive_pack_tail(
+ self,
+ proto: Protocol,
+ capabilities: Set[bytes],
+ progress: Optional[Callable[[bytes], None]] = None,
+ ) -> Optional[Dict[bytes, Optional[str]]]:
"""Handle the tail of a 'git-receive-pack' request.
Args:
@@ -463,12 +1039,88 @@ class GitClient:
error message if the ref failed to update
None if it was updated successfully
"""
- pass
-
- def archive(self, path, committish, write_data, progress=None,
- write_error=None, format=None, subdirs=None, prefix=None):
+ if CAPABILITY_SIDE_BAND_64K in capabilities or self.protocol_version == 2:
+ if progress is None:
+
+ def progress(x):
+ pass
+
+ if CAPABILITY_REPORT_STATUS in capabilities:
+ assert self._report_status_parser is not None
+ pktline_parser = PktLineParser(self._report_status_parser.handle_packet)
+ for chan, data in _read_side_band64k_data(proto.read_pkt_seq()):
+ if chan == SIDE_BAND_CHANNEL_DATA:
+ if CAPABILITY_REPORT_STATUS in capabilities:
+ pktline_parser.parse(data)
+ elif chan == SIDE_BAND_CHANNEL_PROGRESS:
+ progress(data)
+ else:
+ raise AssertionError("Invalid sideband channel %d" % chan)
+ else:
+ if CAPABILITY_REPORT_STATUS in capabilities:
+ assert self._report_status_parser
+ for pkt in proto.read_pkt_seq():
+ self._report_status_parser.handle_packet(pkt)
+ if self._report_status_parser is not None:
+ return dict(self._report_status_parser.check())
+
+ return None
+
+ def _negotiate_upload_pack_capabilities(self, server_capabilities):
+ (extract_capability_names(server_capabilities) - KNOWN_UPLOAD_CAPABILITIES)
+ # TODO(jelmer): warn about unknown capabilities
+ symrefs = {}
+ agent = None
+ fetch_capa = None
+ for capability in server_capabilities:
+ k, v = parse_capability(capability)
+ if k == CAPABILITY_SYMREF:
+ (src, dst) = v.split(b":", 1)
+ symrefs[src] = dst
+ if k == CAPABILITY_AGENT:
+ agent = v
+ if self.protocol_version == 2 and k == CAPABILITY_FETCH:
+ fetch_capa = CAPABILITY_FETCH
+ fetch_features = []
+ v = v.strip()
+ if b"shallow" in v.split(b" "):
+ fetch_features.append(CAPABILITY_SHALLOW)
+ if b"filter" in v.split(b" "):
+ fetch_features.append(CAPABILITY_FILTER)
+ for i in range(len(fetch_features)):
+ if i == 0:
+ fetch_capa += b"="
+ else:
+ fetch_capa += b" "
+ fetch_capa += fetch_features[i]
+
+ negotiated_capabilities = self._fetch_capabilities & server_capabilities
+ if fetch_capa:
+ negotiated_capabilities.add(fetch_capa)
+ return (negotiated_capabilities, symrefs, agent)
+
+ def archive(
+ self,
+ path,
+ committish,
+ write_data,
+ progress=None,
+ write_error=None,
+ format=None,
+ subdirs=None,
+ prefix=None,
+ ):
"""Retrieve an archive of the specified tree."""
- pass
+ raise NotImplementedError(self.archive)
+
+ @staticmethod
+ def _warn_filter_objects():
+ import warnings
+
+ warnings.warn(
+ "object filtering not recognized by server, ignoring",
+ UserWarning,
+ )
def check_wants(wants, refs):
@@ -478,14 +1130,29 @@ def check_wants(wants, refs):
wants: Set of object SHAs to fetch
refs: Refs dictionary to check against
"""
- pass
+ missing = set(wants) - {
+ v for (k, v) in refs.items() if not k.endswith(PEELED_TAG_SUFFIX)
+ }
+ if missing:
+ raise InvalidWants(missing)
+
+
+def _remote_error_from_stderr(stderr):
+ if stderr is None:
+ return HangupException()
+ lines = [line.rstrip(b"\n") for line in stderr.readlines()]
+ for line in lines:
+ if line.startswith(b"ERROR: "):
+ return GitProtocolError(line[len(b"ERROR: ") :].decode("utf-8", "replace"))
+ return HangupException(lines)
class TraditionalGitClient(GitClient):
"""Traditional Git client."""
- DEFAULT_ENCODING = 'utf-8'
- def __init__(self, path_encoding=DEFAULT_ENCODING, **kwargs) ->None:
+ DEFAULT_ENCODING = "utf-8"
+
+ def __init__(self, path_encoding=DEFAULT_ENCODING, **kwargs) -> None:
self._remote_path_encoding = path_encoding
super().__init__(**kwargs)
@@ -504,7 +1171,7 @@ class TraditionalGitClient(GitClient):
protocol_version: Desired Git protocol version. By default the highest
mutually supported protocol version will be used.
"""
- pass
+ raise NotImplementedError
def send_pack(self, path, update_refs, generate_pack_data, progress=None):
"""Upload a pack to a remote repository.
@@ -525,11 +1192,93 @@ class TraditionalGitClient(GitClient):
SendPackError: if server rejects the pack data
"""
- pass
+ self.protocol_version = DEFAULT_GIT_PROTOCOL_VERSION_SEND
+ proto, unused_can_read, stderr = self._connect(b"receive-pack", path)
+ with proto:
+ try:
+ old_refs, server_capabilities = read_pkt_refs(proto.read_pkt_seq())
+ except HangupException as exc:
+ raise _remote_error_from_stderr(stderr) from exc
+ (
+ negotiated_capabilities,
+ agent,
+ ) = self._negotiate_receive_pack_capabilities(server_capabilities)
+ if CAPABILITY_REPORT_STATUS in negotiated_capabilities:
+ self._report_status_parser = ReportStatusParser()
+ report_status_parser = self._report_status_parser
+
+ try:
+ new_refs = orig_new_refs = update_refs(dict(old_refs))
+ except BaseException:
+ proto.write_pkt_line(None)
+ raise
+
+ if set(new_refs.items()).issubset(set(old_refs.items())):
+ proto.write_pkt_line(None)
+ return SendPackResult(new_refs, agent=agent, ref_status={})
+
+ if CAPABILITY_DELETE_REFS not in server_capabilities:
+ # Server does not support deletions. Fail later.
+ new_refs = dict(orig_new_refs)
+ for ref, sha in orig_new_refs.items():
+ if sha == ZERO_SHA:
+ if CAPABILITY_REPORT_STATUS in negotiated_capabilities:
+ report_status_parser._ref_statuses.append(
+ b"ng " + ref + b" remote does not support deleting refs"
+ )
+ report_status_parser._ref_status_ok = False
+ del new_refs[ref]
+
+ if new_refs is None:
+ proto.write_pkt_line(None)
+ return SendPackResult(old_refs, agent=agent, ref_status={})
+
+ if len(new_refs) == 0 and orig_new_refs:
+ # NOOP - Original new refs filtered out by policy
+ proto.write_pkt_line(None)
+ if report_status_parser is not None:
+ ref_status = dict(report_status_parser.check())
+ else:
+ ref_status = None
+ return SendPackResult(old_refs, agent=agent, ref_status=ref_status)
+
+ header_handler = _v1ReceivePackHeader(
+ negotiated_capabilities, old_refs, new_refs
+ )
+
+ for pkt in header_handler:
+ proto.write_pkt_line(pkt)
- def fetch_pack(self, path, determine_wants, graph_walker, pack_data,
- progress=None, depth=None, ref_prefix=[], filter_spec=None,
- protocol_version: Optional[int]=None):
+ pack_data_count, pack_data = generate_pack_data(
+ header_handler.have,
+ header_handler.want,
+ ofs_delta=(CAPABILITY_OFS_DELTA in negotiated_capabilities),
+ progress=progress,
+ )
+
+ if self._should_send_pack(new_refs):
+ for chunk in PackChunkGenerator(
+ pack_data_count, pack_data, progress=progress
+ ):
+ proto.write(chunk)
+
+ ref_status = self._handle_receive_pack_tail(
+ proto, negotiated_capabilities, progress
+ )
+ return SendPackResult(new_refs, agent=agent, ref_status=ref_status)
+
+ def fetch_pack(
+ self,
+ path,
+ determine_wants,
+ graph_walker,
+ pack_data,
+ progress=None,
+ depth=None,
+ ref_prefix=[],
+ filter_spec=None,
+ protocol_version: Optional[int] = None,
+ ):
"""Retrieve a pack from a git smart server.
Args:
@@ -557,48 +1306,362 @@ class TraditionalGitClient(GitClient):
FetchPackResult object
"""
- pass
+ if (
+ protocol_version is not None
+ and protocol_version not in GIT_PROTOCOL_VERSIONS
+ ):
+ raise ValueError("unknown Git protocol version %d" % protocol_version)
+ proto, can_read, stderr = self._connect(b"upload-pack", path, protocol_version)
+ server_protocol_version = negotiate_protocol_version(proto)
+ if server_protocol_version not in GIT_PROTOCOL_VERSIONS:
+ raise ValueError(
+ "unknown Git protocol version %d used by server"
+ % server_protocol_version
+ )
+ if protocol_version and server_protocol_version > protocol_version:
+ raise ValueError(
+ "bad Git protocol version %d used by server" % server_protocol_version
+ )
+ self.protocol_version = server_protocol_version
+ with proto:
+ try:
+ if self.protocol_version == 2:
+ server_capabilities = read_server_capabilities(proto.read_pkt_seq())
+ refs = None
+ else:
+ refs, server_capabilities = read_pkt_refs(proto.read_pkt_seq())
+ except HangupException as exc:
+ raise _remote_error_from_stderr(stderr) from exc
+ (
+ negotiated_capabilities,
+ symrefs,
+ agent,
+ ) = self._negotiate_upload_pack_capabilities(server_capabilities)
+
+ if self.protocol_version == 2:
+ proto.write_pkt_line(b"command=ls-refs\n")
+ proto.write(b"0001") # delim-pkt
+ proto.write_pkt_line(b"symrefs")
+ for prefix in ref_prefix:
+ proto.write_pkt_line(b"ref-prefix " + prefix)
+ proto.write_pkt_line(None)
+ refs, server_capabilities = read_pkt_refs(
+ proto.read_pkt_seq(), server_capabilities
+ )
+
+ if refs is None:
+ proto.write_pkt_line(None)
+ return FetchPackResult(refs, symrefs, agent)
+
+ try:
+ if depth is not None:
+ wants = determine_wants(refs, depth=depth)
+ else:
+ wants = determine_wants(refs)
+ except BaseException:
+ proto.write_pkt_line(None)
+ raise
+ if wants is not None:
+ wants = [cid for cid in wants if cid != ZERO_SHA]
+ if not wants:
+ proto.write_pkt_line(None)
+ return FetchPackResult(refs, symrefs, agent)
+ if self.protocol_version == 2:
+ proto.write_pkt_line(b"command=fetch\n")
+ proto.write(b"0001") # delim-pkt
+ if (
+ find_capability(
+ negotiated_capabilities, CAPABILITY_FETCH, CAPABILITY_FILTER
+ )
+ and filter_spec
+ ):
+ proto.write(pkt_line(b"filter %s\n" % filter_spec))
+ elif filter_spec:
+ self._warn_filter_objects()
+ elif filter_spec:
+ self._warn_filter_objects()
+ (new_shallow, new_unshallow) = _handle_upload_pack_head(
+ proto,
+ negotiated_capabilities,
+ graph_walker,
+ wants,
+ can_read,
+ depth=depth,
+ protocol_version=self.protocol_version,
+ )
+ _handle_upload_pack_tail(
+ proto,
+ negotiated_capabilities,
+ graph_walker,
+ pack_data,
+ progress,
+ protocol_version=self.protocol_version,
+ )
+ return FetchPackResult(refs, symrefs, agent, new_shallow, new_unshallow)
def get_refs(self, path, protocol_version=None):
"""Retrieve the current refs from a git smart server."""
- pass
+ # stock `git ls-remote` uses upload-pack
+ if (
+ protocol_version is not None
+ and protocol_version not in GIT_PROTOCOL_VERSIONS
+ ):
+ raise ValueError("unknown Git protocol version %d" % protocol_version)
+ proto, _, stderr = self._connect(b"upload-pack", path, protocol_version)
+ server_protocol_version = negotiate_protocol_version(proto)
+ if server_protocol_version not in GIT_PROTOCOL_VERSIONS:
+ raise ValueError(
+ "unknown Git protocol version %d used by server"
+ % server_protocol_version
+ )
+ if protocol_version and server_protocol_version > protocol_version:
+ raise ValueError(
+ "bad Git protocol version %d used by server" % server_protocol_version
+ )
+ self.protocol_version = server_protocol_version
+ if self.protocol_version == 2:
+ server_capabilities = read_server_capabilities(proto.read_pkt_seq())
+ proto.write_pkt_line(b"command=ls-refs\n")
+ proto.write(b"0001") # delim-pkt
+ proto.write_pkt_line(b"symrefs")
+ proto.write_pkt_line(None)
+ else:
+ server_capabilities = None # read_pkt_refs will find them
+ with proto:
+ try:
+ refs, server_capabilities = read_pkt_refs(
+ proto.read_pkt_seq(), server_capabilities
+ )
+ except HangupException as exc:
+ raise _remote_error_from_stderr(stderr) from exc
+ proto.write_pkt_line(None)
+ return refs
+
+ def archive(
+ self,
+ path,
+ committish,
+ write_data,
+ progress=None,
+ write_error=None,
+ format=None,
+ subdirs=None,
+ prefix=None,
+ ):
+ proto, can_read, stderr = self._connect(b"upload-archive", path)
+ with proto:
+ if format is not None:
+ proto.write_pkt_line(b"argument --format=" + format)
+ proto.write_pkt_line(b"argument " + committish)
+ if subdirs is not None:
+ for subdir in subdirs:
+ proto.write_pkt_line(b"argument " + subdir)
+ if prefix is not None:
+ proto.write_pkt_line(b"argument --prefix=" + prefix)
+ proto.write_pkt_line(None)
+ try:
+ pkt = proto.read_pkt_line()
+ except HangupException as exc:
+ raise _remote_error_from_stderr(stderr) from exc
+ if pkt == b"NACK\n" or pkt == b"NACK":
+ return
+ elif pkt == b"ACK\n" or pkt == b"ACK":
+ pass
+ elif pkt.startswith(b"ERR "):
+ raise GitProtocolError(pkt[4:].rstrip(b"\n").decode("utf-8", "replace"))
+ else:
+ raise AssertionError(f"invalid response {pkt!r}")
+ ret = proto.read_pkt_line()
+ if ret is not None:
+ raise AssertionError("expected pkt tail")
+ for chan, data in _read_side_band64k_data(proto.read_pkt_seq()):
+ if chan == SIDE_BAND_CHANNEL_DATA:
+ write_data(data)
+ elif chan == SIDE_BAND_CHANNEL_PROGRESS:
+ progress(data)
+ elif chan == SIDE_BAND_CHANNEL_FATAL:
+ write_error(data)
+ else:
+ raise AssertionError("Invalid sideband channel %d" % chan)
class TCPGitClient(TraditionalGitClient):
"""A Git Client that works over TCP directly (i.e. git://)."""
- def __init__(self, host, port=None, **kwargs) ->None:
+ def __init__(self, host, port=None, **kwargs) -> None:
if port is None:
port = TCP_GIT_PORT
self._host = host
self._port = port
super().__init__(**kwargs)
+ @classmethod
+ def from_parsedurl(cls, parsedurl, **kwargs):
+ return cls(parsedurl.hostname, port=parsedurl.port, **kwargs)
+
+ def get_url(self, path):
+ netloc = self._host
+ if self._port is not None and self._port != TCP_GIT_PORT:
+ netloc += ":%d" % self._port
+ return urlunsplit(("git", netloc, path, "", ""))
+
+ def _connect(self, cmd, path, protocol_version=None):
+ if not isinstance(cmd, bytes):
+ raise TypeError(cmd)
+ if not isinstance(path, bytes):
+ path = path.encode(self._remote_path_encoding)
+ sockaddrs = socket.getaddrinfo(
+ self._host, self._port, socket.AF_UNSPEC, socket.SOCK_STREAM
+ )
+ s = None
+ err = OSError(f"no address found for {self._host}")
+ for family, socktype, proto, canonname, sockaddr in sockaddrs:
+ s = socket.socket(family, socktype, proto)
+ s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+ try:
+ s.connect(sockaddr)
+ break
+ except OSError as e:
+ err = e
+ if s is not None:
+ s.close()
+ s = None
+ if s is None:
+ raise err
+ # -1 means system default buffering
+ rfile = s.makefile("rb", -1)
+ # 0 means unbuffered
+ wfile = s.makefile("wb", 0)
+
+ def close():
+ rfile.close()
+ wfile.close()
+ s.close()
+
+ proto = Protocol(
+ rfile.read,
+ wfile.write,
+ close,
+ report_activity=self._report_activity,
+ )
+ if path.startswith(b"/~"):
+ path = path[1:]
+ if cmd == b"upload-pack":
+ if protocol_version is None:
+ self.protocol_version = DEFAULT_GIT_PROTOCOL_VERSION_FETCH
+ else:
+ self.protocol_version = protocol_version
+ else:
+ self.protocol_version = DEFAULT_GIT_PROTOCOL_VERSION_SEND
+
+ if cmd == b"upload-pack" and self.protocol_version == 2:
+ # Git protocol version advertisement is hidden behind two NUL bytes
+ # for compatibility with older Git server implementations, which
+ # would crash if something other than a "host=" header was found
+ # after the first NUL byte.
+ version_str = b"\0\0version=%d\0" % self.protocol_version
+ else:
+ version_str = b""
+ # TODO(jelmer): Alternative to ascii?
+ proto.send_cmd(
+ b"git-" + cmd, path, b"host=" + self._host.encode("ascii") + version_str
+ )
+ return proto, lambda: _fileno_can_read(s), None
+
class SubprocessWrapper:
"""A socket-like object that talks to a subprocess via pipes."""
- def __init__(self, proc) ->None:
+ def __init__(self, proc) -> None:
self.proc = proc
self.read = BufferedReader(proc.stdout).read
self.write = proc.stdin.write
+ @property
+ def stderr(self):
+ return self.proc.stderr
+
+ def can_read(self):
+ if sys.platform == "win32":
+ from msvcrt import get_osfhandle
+
+ handle = get_osfhandle(self.proc.stdout.fileno())
+ return _win32_peek_avail(handle) != 0
+ else:
+ return _fileno_can_read(self.proc.stdout.fileno())
+
+ def close(self):
+ self.proc.stdin.close()
+ self.proc.stdout.close()
+ if self.proc.stderr:
+ self.proc.stderr.close()
+ self.proc.wait()
-def find_git_command() ->List[str]:
+
+def find_git_command() -> List[str]:
"""Find command to run for system Git (usually C Git)."""
- pass
+ if sys.platform == "win32": # support .exe, .bat and .cmd
+ try: # to avoid overhead
+ import pywintypes
+ import win32api
+ except ImportError: # run through cmd.exe with some overhead
+ return ["cmd", "/c", "git"]
+ else:
+ try:
+ status, git = win32api.FindExecutable("git")
+ return [git]
+ except pywintypes.error:
+ return ["cmd", "/c", "git"]
+ else:
+ return ["git"]
class SubprocessGitClient(TraditionalGitClient):
"""Git client that talks to a server using a subprocess."""
+
+ @classmethod
+ def from_parsedurl(cls, parsedurl, **kwargs):
+ return cls(**kwargs)
+
git_command = None
+ def _connect(self, service, path, protocol_version=None):
+ if not isinstance(service, bytes):
+ raise TypeError(service)
+ if isinstance(path, bytes):
+ path = path.decode(self._remote_path_encoding)
+ if self.git_command is None:
+ git_command = find_git_command()
+ argv = [*git_command, service.decode("ascii"), path]
+ p = subprocess.Popen(
+ argv,
+ bufsize=0,
+ stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ )
+ pw = SubprocessWrapper(p)
+ return (
+ Protocol(
+ pw.read,
+ pw.write,
+ pw.close,
+ report_activity=self._report_activity,
+ ),
+ pw.can_read,
+ p.stderr,
+ )
+
class LocalGitClient(GitClient):
"""Git Client that just uses a local on-disk repository."""
- def __init__(self, thin_packs: bool=True, report_activity=None, config:
- Optional[Config]=None) ->None:
+ def __init__(
+ self,
+ thin_packs: bool = True,
+ report_activity=None,
+ config: Optional[Config] = None,
+ ) -> None:
"""Create a new LocalGitClient instance.
Args:
@@ -607,6 +1670,20 @@ class LocalGitClient(GitClient):
activity.
"""
self._report_activity = report_activity
+ # Ignore the thin_packs argument
+
+ def get_url(self, path):
+ return urlunsplit(("file", "", path, "", ""))
+
+ @classmethod
+ def from_parsedurl(cls, parsedurl, **kwargs):
+ return cls(**kwargs)
+
+ @classmethod
+ def _open_repo(cls, path):
+ if not isinstance(path, str):
+ path = os.fsdecode(path)
+ return closing(Repo(path))
def send_pack(self, path, update_refs, generate_pack_data, progress=None):
"""Upload a pack to a local on-disk repository.
@@ -626,10 +1703,59 @@ class LocalGitClient(GitClient):
SendPackError: if server rejects the pack data
"""
- pass
+ if not progress:
+
+ def progress(x):
+ pass
+
+ with self._open_repo(path) as target:
+ old_refs = target.get_refs()
+ new_refs = update_refs(dict(old_refs))
+
+ have = [sha1 for sha1 in old_refs.values() if sha1 != ZERO_SHA]
+ want = []
+ for refname, new_sha1 in new_refs.items():
+ if (
+ new_sha1 not in have
+ and new_sha1 not in want
+ and new_sha1 != ZERO_SHA
+ ):
+ want.append(new_sha1)
+
+ if not want and set(new_refs.items()).issubset(set(old_refs.items())):
+ return SendPackResult(new_refs, ref_status={})
+
+ target.object_store.add_pack_data(
+ *generate_pack_data(have, want, ofs_delta=True)
+ )
- def fetch(self, path, target, determine_wants=None, progress=None,
- depth=None, ref_prefix=[], filter_spec=None, **kwargs):
+ ref_status = {}
+
+ for refname, new_sha1 in new_refs.items():
+ old_sha1 = old_refs.get(refname, ZERO_SHA)
+ if new_sha1 != ZERO_SHA:
+ if not target.refs.set_if_equals(refname, old_sha1, new_sha1):
+ msg = f"unable to set {refname} to {new_sha1}"
+ progress(msg)
+ ref_status[refname] = msg
+ else:
+ if not target.refs.remove_if_equals(refname, old_sha1):
+ progress(f"unable to remove {refname}")
+ ref_status[refname] = "unable to remove"
+
+ return SendPackResult(new_refs, ref_status=ref_status)
+
+ def fetch(
+ self,
+ path,
+ target,
+ determine_wants=None,
+ progress=None,
+ depth=None,
+ ref_prefix=[],
+ filter_spec=None,
+ **kwargs,
+ ):
"""Fetch into a target repository.
Args:
@@ -654,12 +1780,27 @@ class LocalGitClient(GitClient):
FetchPackResult object
"""
- pass
-
- def fetch_pack(self, path, determine_wants, graph_walker, pack_data,
- progress=None, depth=None, ref_prefix: Optional[List[bytes]]=[],
- filter_spec: Optional[bytes]=None, protocol_version: Optional[int]=None
- ) ->FetchPackResult:
+ with self._open_repo(path) as r:
+ refs = r.fetch(
+ target,
+ determine_wants=determine_wants,
+ progress=progress,
+ depth=depth,
+ )
+ return FetchPackResult(refs, r.refs.get_symrefs(), agent_string())
+
+ def fetch_pack(
+ self,
+ path,
+ determine_wants,
+ graph_walker,
+ pack_data,
+ progress=None,
+ depth=None,
+ ref_prefix: Optional[List[bytes]] = [],
+ filter_spec: Optional[bytes] = None,
+ protocol_version: Optional[int] = None,
+ ) -> FetchPackResult:
"""Retrieve a pack from a local on-disk repository.
Args:
@@ -685,22 +1826,48 @@ class LocalGitClient(GitClient):
FetchPackResult object
"""
- pass
+ with self._open_repo(path) as r:
+ missing_objects = r.find_missing_objects(
+ determine_wants, graph_walker, progress=progress, depth=depth
+ )
+ other_haves = missing_objects.get_remote_has()
+ object_ids = list(missing_objects)
+ symrefs = r.refs.get_symrefs()
+ agent = agent_string()
+
+ # Did the process short-circuit (e.g. in a stateless RPC call)?
+ # Note that the client still expects a 0-object pack in most cases.
+ if object_ids is None:
+ return FetchPackResult(None, symrefs, agent)
+ write_pack_from_container(
+ pack_data, r.object_store, object_ids, other_haves=other_haves
+ )
+ return FetchPackResult(r.get_refs(), symrefs, agent)
def get_refs(self, path):
"""Retrieve the current refs from a local on-disk repository."""
- pass
+ with self._open_repo(path) as target:
+ return target.get_refs()
+# What Git client to use for local access
default_local_git_client_cls = LocalGitClient
class SSHVendor:
"""A client side SSH implementation."""
- def run_command(self, host, command, username=None, port=None, password
- =None, key_filename=None, ssh_command=None, protocol_version:
- Optional[int]=None):
+ def run_command(
+ self,
+ host,
+ command,
+ username=None,
+ port=None,
+ password=None,
+ key_filename=None,
+ ssh_command=None,
+ protocol_version: Optional[int] = None,
+ ):
"""Connect to an SSH server.
Run a command remotely and return a file-like object for interaction
@@ -717,39 +1884,172 @@ class SSHVendor:
protocol_version: Desired Git protocol version. By default the highest
mutually supported protocol version will be used.
"""
- pass
+ raise NotImplementedError(self.run_command)
class StrangeHostname(Exception):
"""Refusing to connect to strange SSH hostname."""
- def __init__(self, hostname) ->None:
+ def __init__(self, hostname) -> None:
super().__init__(hostname)
class SubprocessSSHVendor(SSHVendor):
"""SSH vendor that shells out to the local 'ssh' command."""
+ def run_command(
+ self,
+ host,
+ command,
+ username=None,
+ port=None,
+ password=None,
+ key_filename=None,
+ ssh_command=None,
+ protocol_version=None,
+ ):
+ if password is not None:
+ raise NotImplementedError(
+ "Setting password not supported by SubprocessSSHVendor."
+ )
+
+ if ssh_command:
+ import shlex
+
+ args = [*shlex.split(ssh_command, posix=sys.platform != "win32"), "-x"]
+ else:
+ args = ["ssh", "-x"]
+
+ if port:
+ args.extend(["-p", str(port)])
+
+ if key_filename:
+ args.extend(["-i", str(key_filename)])
+
+ if protocol_version is None:
+ protocol_version = DEFAULT_GIT_PROTOCOL_VERSION_FETCH
+ if protocol_version > 0:
+ args.extend(["-o", f"SetEnv GIT_PROTOCOL=version={protocol_version}"])
+
+ if username:
+ host = f"{username}@{host}"
+ if host.startswith("-"):
+ raise StrangeHostname(hostname=host)
+ args.append(host)
+
+ proc = subprocess.Popen(
+ [*args, command],
+ bufsize=0,
+ stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ )
+ return SubprocessWrapper(proc)
+
class PLinkSSHVendor(SSHVendor):
"""SSH vendor that shells out to the local 'plink' command."""
+ def run_command(
+ self,
+ host,
+ command,
+ username=None,
+ port=None,
+ password=None,
+ key_filename=None,
+ ssh_command=None,
+ protocol_version: Optional[int] = None,
+ ):
+ if ssh_command:
+ import shlex
+
+ args = [*shlex.split(ssh_command, posix=sys.platform != "win32"), "-ssh"]
+ elif sys.platform == "win32":
+ args = ["plink.exe", "-ssh"]
+ else:
+ args = ["plink", "-ssh"]
+
+ if password is not None:
+ import warnings
+ warnings.warn(
+ "Invoking PLink with a password exposes the password in the "
+ "process list."
+ )
+ args.extend(["-pw", str(password)])
+
+ if port:
+ args.extend(["-P", str(port)])
+
+ if key_filename:
+ args.extend(["-i", str(key_filename)])
+
+ if username:
+ host = f"{username}@{host}"
+ if host.startswith("-"):
+ raise StrangeHostname(hostname=host)
+ args.append(host)
+
+ # plink.exe does not provide a way to pass environment variables
+ # via the command line. The best we can do is set an environment
+ # variable and hope that plink will pass it to the server. If this
+ # does not work then the server should behave as if we had requested
+ # protocol version 0.
+ env = copy.deepcopy(os.environ)
+ if protocol_version is None:
+ protocol_version = DEFAULT_GIT_PROTOCOL_VERSION_FETCH
+ if protocol_version > 0:
+ env["GIT_PROTOCOL"] = f"version={protocol_version}"
+
+ proc = subprocess.Popen(
+ [*args, command],
+ bufsize=0,
+ stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ env=env,
+ )
+ return SubprocessWrapper(proc)
+
+
+def ParamikoSSHVendor(**kwargs):
+ import warnings
+
+ warnings.warn(
+ "ParamikoSSHVendor has been moved to dulwich.contrib.paramiko_vendor.",
+ DeprecationWarning,
+ )
+ from .contrib.paramiko_vendor import ParamikoSSHVendor
+
+ return ParamikoSSHVendor(**kwargs)
+
+
+# Can be overridden by users
get_ssh_vendor = SubprocessSSHVendor
class SSHGitClient(TraditionalGitClient):
-
- def __init__(self, host, port=None, username=None, vendor=None, config=
- None, password=None, key_filename=None, ssh_command=None, **kwargs
- ) ->None:
+ def __init__(
+ self,
+ host,
+ port=None,
+ username=None,
+ vendor=None,
+ config=None,
+ password=None,
+ key_filename=None,
+ ssh_command=None,
+ **kwargs,
+ ) -> None:
self.host = host
self.port = port
self.username = username
self.password = password
self.key_filename = key_filename
- self.ssh_command = ssh_command or os.environ.get('GIT_SSH_COMMAND',
- os.environ.get('GIT_SSH'))
+ self.ssh_command = ssh_command or os.environ.get(
+ "GIT_SSH_COMMAND", os.environ.get("GIT_SSH")
+ )
super().__init__(**kwargs)
self.alternative_paths: Dict[bytes, bytes] = {}
if vendor is not None:
@@ -757,10 +2057,84 @@ class SSHGitClient(TraditionalGitClient):
else:
self.ssh_vendor = get_ssh_vendor()
+ def get_url(self, path):
+ netloc = self.host
+ if self.port is not None:
+ netloc += ":%d" % self.port
+
+ if self.username is not None:
+ netloc = urlquote(self.username, "@/:") + "@" + netloc
-def default_urllib3_manager(config, pool_manager_cls=None,
- proxy_manager_cls=None, base_url=None, **override_kwargs) ->Union[
- 'urllib3.ProxyManager', 'urllib3.PoolManager']:
+ return urlunsplit(("ssh", netloc, path, "", ""))
+
+ @classmethod
+ def from_parsedurl(cls, parsedurl, **kwargs):
+ return cls(
+ host=parsedurl.hostname,
+ port=parsedurl.port,
+ username=parsedurl.username,
+ **kwargs,
+ )
+
+ def _get_cmd_path(self, cmd):
+ cmd = self.alternative_paths.get(cmd, b"git-" + cmd)
+ assert isinstance(cmd, bytes)
+ return cmd
+
+ def _connect(self, cmd, path, protocol_version=None):
+ if not isinstance(cmd, bytes):
+ raise TypeError(cmd)
+ if isinstance(path, bytes):
+ path = path.decode(self._remote_path_encoding)
+ if path.startswith("/~"):
+ path = path[1:]
+ argv = (
+ self._get_cmd_path(cmd).decode(self._remote_path_encoding)
+ + " '"
+ + path
+ + "'"
+ )
+ kwargs = {}
+ if self.password is not None:
+ kwargs["password"] = self.password
+ if self.key_filename is not None:
+ kwargs["key_filename"] = self.key_filename
+ # GIT_SSH_COMMAND takes precedence over GIT_SSH
+ if self.ssh_command is not None:
+ kwargs["ssh_command"] = self.ssh_command
+ con = self.ssh_vendor.run_command(
+ self.host,
+ argv,
+ port=self.port,
+ username=self.username,
+ protocol_version=protocol_version,
+ **kwargs,
+ )
+ return (
+ Protocol(
+ con.read,
+ con.write,
+ con.close,
+ report_activity=self._report_activity,
+ ),
+ con.can_read,
+ getattr(con, "stderr", None),
+ )
+
+
+def default_user_agent_string():
+ # Start user agent with "git/", because GitHub requires this. :-( See
+ # https://github.com/jelmer/dulwich/issues/562 for details.
+ return "git/dulwich/{}".format(".".join([str(x) for x in dulwich.__version__]))
+
+
+def default_urllib3_manager(
+ config,
+ pool_manager_cls=None,
+ proxy_manager_cls=None,
+ base_url=None,
+ **override_kwargs,
+) -> Union["urllib3.ProxyManager", "urllib3.PoolManager"]:
"""Return urllib3 connection pool manager.
Honour detected proxy configurations.
@@ -775,7 +2149,136 @@ def default_urllib3_manager(config, pool_manager_cls=None,
(defaults to `urllib3.PoolManager`) instance otherwise
"""
- pass
+ proxy_server = user_agent = None
+ ca_certs = ssl_verify = None
+
+ if proxy_server is None:
+ for proxyname in ("https_proxy", "http_proxy", "all_proxy"):
+ proxy_server = os.environ.get(proxyname)
+ if proxy_server:
+ break
+
+ if proxy_server:
+ if check_for_proxy_bypass(base_url):
+ proxy_server = None
+
+ if config is not None:
+ if proxy_server is None:
+ try:
+ proxy_server = config.get(b"http", b"proxy")
+ except KeyError:
+ pass
+ try:
+ user_agent = config.get(b"http", b"useragent")
+ except KeyError:
+ pass
+
+ # TODO(jelmer): Support per-host settings
+ try:
+ ssl_verify = config.get_boolean(b"http", b"sslVerify")
+ except KeyError:
+ ssl_verify = True
+
+ try:
+ ca_certs = config.get(b"http", b"sslCAInfo")
+ except KeyError:
+ ca_certs = None
+
+ if user_agent is None:
+ user_agent = default_user_agent_string()
+
+ headers = {"User-agent": user_agent}
+
+ kwargs = {
+ "ca_certs": ca_certs,
+ }
+ if ssl_verify is True:
+ kwargs["cert_reqs"] = "CERT_REQUIRED"
+ elif ssl_verify is False:
+ kwargs["cert_reqs"] = "CERT_NONE"
+ else:
+ # Default to SSL verification
+ kwargs["cert_reqs"] = "CERT_REQUIRED"
+
+ kwargs.update(override_kwargs)
+
+ import urllib3
+
+ if proxy_server is not None:
+ if proxy_manager_cls is None:
+ proxy_manager_cls = urllib3.ProxyManager
+ if not isinstance(proxy_server, str):
+ proxy_server = proxy_server.decode()
+ proxy_server_url = urlparse(proxy_server)
+ if proxy_server_url.username is not None:
+ proxy_headers = urllib3.make_headers(
+ proxy_basic_auth=f"{proxy_server_url.username}:{proxy_server_url.password or ''}" # type: ignore
+ )
+ else:
+ proxy_headers = {}
+ manager = proxy_manager_cls(
+ proxy_server, proxy_headers=proxy_headers, headers=headers, **kwargs
+ )
+ else:
+ if pool_manager_cls is None:
+ pool_manager_cls = urllib3.PoolManager
+ manager = pool_manager_cls(headers=headers, **kwargs)
+
+ return manager
+
+
+def check_for_proxy_bypass(base_url):
+ # Check if a proxy bypass is defined with the no_proxy environment variable
+ if base_url: # only check if base_url is provided
+ no_proxy_str = os.environ.get("no_proxy")
+ if no_proxy_str:
+ # implementation based on curl behavior: https://curl.se/libcurl/c/CURLOPT_NOPROXY.html
+ # get hostname of provided parsed url
+ parsed_url = urlparse(base_url)
+ hostname = parsed_url.hostname
+
+ if hostname:
+ import ipaddress
+
+ # check if hostname is an ip address
+ try:
+ hostname_ip = ipaddress.ip_address(hostname)
+ except ValueError:
+ hostname_ip = None
+
+ no_proxy_values = no_proxy_str.split(",")
+ for no_proxy_value in no_proxy_values:
+ no_proxy_value = no_proxy_value.strip()
+ if no_proxy_value:
+ no_proxy_value = no_proxy_value.lower()
+ no_proxy_value = no_proxy_value.lstrip(
+ "."
+ ) # ignore leading dots
+
+ if hostname_ip:
+ # check if no_proxy_value is a ip network
+ try:
+ no_proxy_value_network = ipaddress.ip_network(
+ no_proxy_value, strict=False
+ )
+ except ValueError:
+ no_proxy_value_network = None
+ if no_proxy_value_network:
+ # if hostname is a ip address and no_proxy_value is a ip network -> check if ip address is part of network
+ if hostname_ip in no_proxy_value_network:
+ return True
+
+ if no_proxy_value == "*":
+ # '*' is special case for always bypass proxy
+ return True
+ if hostname == no_proxy_value:
+ return True
+ no_proxy_value = (
+ "." + no_proxy_value
+ ) # add a dot to only match complete domains
+ if hostname.endswith(no_proxy_value):
+ return True
+ return False
class AbstractHttpGitClient(GitClient):
@@ -787,8 +2290,8 @@ class AbstractHttpGitClient(GitClient):
_http_request method.
"""
- def __init__(self, base_url, dumb=False, **kwargs) ->None:
- self._base_url = base_url.rstrip('/') + '/'
+ def __init__(self, base_url, dumb=False, **kwargs) -> None:
+ self._base_url = base_url.rstrip("/") + "/"
self.dumb = dumb
GitClient.__init__(self, **kwargs)
@@ -809,7 +2312,118 @@ class AbstractHttpGitClient(GitClient):
Raises:
GitProtocolError
"""
- pass
+ raise NotImplementedError(self._http_request)
+
+ def _discover_references(self, service, base_url, protocol_version=None):
+ if (
+ protocol_version is not None
+ and protocol_version not in GIT_PROTOCOL_VERSIONS
+ ):
+ raise ValueError("unknown Git protocol version %d" % protocol_version)
+ assert base_url[-1] == "/"
+ tail = "info/refs"
+ headers = {"Accept": "*/*"}
+ if self.dumb is not True:
+ tail += "?service={}".format(service.decode("ascii"))
+ # Enable protocol v2 only when fetching, not when pushing.
+ # Git does not yet implement push over protocol v2, and as of
+ # git version 2.37.3 git-http-backend's behaviour is erratic if
+ # we try: It responds with a Git-protocol-v1-style ref listing
+ # which lacks the "001f# service=git-receive-pack" marker.
+ if service == b"git-upload-pack":
+ if protocol_version is None:
+ self.protocol_version = DEFAULT_GIT_PROTOCOL_VERSION_FETCH
+ else:
+ self.protocol_version = protocol_version
+ if self.protocol_version == 2:
+ headers["Git-Protocol"] = "version=2"
+ else:
+ self.protocol_version = DEFAULT_GIT_PROTOCOL_VERSION_SEND
+ url = urljoin(base_url, tail)
+ resp, read = self._http_request(url, headers)
+
+ if resp.redirect_location:
+ # Something changed (redirect!), so let's update the base URL
+ if not resp.redirect_location.endswith(tail):
+ raise GitProtocolError(
+ f"Redirected from URL {url} to URL {resp.redirect_location} without {tail}"
+ )
+ base_url = urljoin(url, resp.redirect_location[: -len(tail)])
+
+ try:
+ self.dumb = resp.content_type is None or not resp.content_type.startswith(
+ "application/x-git-"
+ )
+ if not self.dumb:
+
+ def begin_protocol_v2(proto):
+ server_capabilities = read_server_capabilities(proto.read_pkt_seq())
+ resp, read = self._smart_request(
+ service.decode("ascii"),
+ base_url,
+ pkt_line(b"command=ls-refs\n")
+ + b"0001"
+ + pkt_line(b"symrefs")
+ + b"0000",
+ )
+ proto = Protocol(read, None)
+ return server_capabilities, resp, read, proto
+
+ proto = Protocol(read, None)
+ server_protocol_version = negotiate_protocol_version(proto)
+ if server_protocol_version not in GIT_PROTOCOL_VERSIONS:
+ raise ValueError(
+ "unknown Git protocol version %d used by server"
+ % server_protocol_version
+ )
+ if protocol_version and server_protocol_version > protocol_version:
+ raise ValueError(
+ "bad Git protocol version %d used by server"
+ % server_protocol_version
+ )
+ self.protocol_version = server_protocol_version
+ if self.protocol_version == 2:
+ server_capabilities, resp, read, proto = begin_protocol_v2(proto)
+ else:
+ server_capabilities = None # read_pkt_refs will find them
+ try:
+ [pkt] = list(proto.read_pkt_seq())
+ except ValueError as exc:
+ raise GitProtocolError(
+ "unexpected number of packets received"
+ ) from exc
+ if pkt.rstrip(b"\n") != (b"# service=" + service):
+ raise GitProtocolError(
+ f"unexpected first line {pkt!r} from smart server"
+ )
+ # Github sends "version 2" after sending the service name.
+ # Try to negotiate protocol version 2 again.
+ server_protocol_version = negotiate_protocol_version(proto)
+ if server_protocol_version not in GIT_PROTOCOL_VERSIONS:
+ raise ValueError(
+ "unknown Git protocol version %d used by server"
+ % server_protocol_version
+ )
+ if protocol_version and server_protocol_version > protocol_version:
+ raise ValueError(
+ "bad Git protocol version %d used by server"
+ % server_protocol_version
+ )
+ self.protocol_version = server_protocol_version
+ if self.protocol_version == 2:
+ server_capabilities, resp, read, proto = begin_protocol_v2(
+ proto
+ )
+ (
+ refs,
+ server_capabilities,
+ ) = read_pkt_refs(proto.read_pkt_seq(), server_capabilities)
+ return refs, server_capabilities, base_url
+ else:
+ self.protocol_version = 0 # dumb servers only support protocol v0
+ return read_info_refs(resp), set(), base_url
+ finally:
+ resp.close()
def _smart_request(self, service, url, data):
"""Send a 'smart' HTTP request.
@@ -817,7 +2431,23 @@ class AbstractHttpGitClient(GitClient):
This is a simple wrapper around _http_request that sets
a couple of extra headers.
"""
- pass
+ assert url[-1] == "/"
+ url = urljoin(url, service)
+ result_content_type = f"application/x-{service}-result"
+ headers = {
+ "Content-Type": f"application/x-{service}-request",
+ "Accept": result_content_type,
+ }
+ if self.protocol_version == 2:
+ headers["Git-Protocol"] = "version=2"
+ if isinstance(data, bytes):
+ headers["Content-Length"] = str(len(data))
+ resp, read = self._http_request(url, headers, data)
+ if resp.content_type.split(";")[0] != result_content_type:
+ raise GitProtocolError(
+ f"Invalid content-type from server: {resp.content_type}"
+ )
+ return resp, read
def send_pack(self, path, update_refs, generate_pack_data, progress=None):
"""Upload a pack to a remote repository.
@@ -838,11 +2468,64 @@ class AbstractHttpGitClient(GitClient):
SendPackError: if server rejects the pack data
"""
- pass
-
- def fetch_pack(self, path, determine_wants, graph_walker, pack_data,
- progress=None, depth=None, ref_prefix=[], filter_spec=None,
- protocol_version: Optional[int]=None):
+ url = self._get_url(path)
+ old_refs, server_capabilities, url = self._discover_references(
+ b"git-receive-pack", url
+ )
+ (
+ negotiated_capabilities,
+ agent,
+ ) = self._negotiate_receive_pack_capabilities(server_capabilities)
+ negotiated_capabilities.add(capability_agent())
+
+ if CAPABILITY_REPORT_STATUS in negotiated_capabilities:
+ self._report_status_parser = ReportStatusParser()
+
+ new_refs = update_refs(dict(old_refs))
+ if new_refs is None:
+ # Determine wants function is aborting the push.
+ return SendPackResult(old_refs, agent=agent, ref_status={})
+ if set(new_refs.items()).issubset(set(old_refs.items())):
+ return SendPackResult(new_refs, agent=agent, ref_status={})
+ if self.dumb:
+ raise NotImplementedError(self.fetch_pack)
+
+ def body_generator():
+ header_handler = _v1ReceivePackHeader(
+ negotiated_capabilities, old_refs, new_refs
+ )
+ for pkt in header_handler:
+ yield pkt_line(pkt)
+ pack_data_count, pack_data = generate_pack_data(
+ header_handler.have,
+ header_handler.want,
+ ofs_delta=(CAPABILITY_OFS_DELTA in negotiated_capabilities),
+ )
+ if self._should_send_pack(new_refs):
+ yield from PackChunkGenerator(pack_data_count, pack_data)
+
+ resp, read = self._smart_request("git-receive-pack", url, data=body_generator())
+ try:
+ resp_proto = Protocol(read, None)
+ ref_status = self._handle_receive_pack_tail(
+ resp_proto, negotiated_capabilities, progress
+ )
+ return SendPackResult(new_refs, agent=agent, ref_status=ref_status)
+ finally:
+ resp.close()
+
+ def fetch_pack(
+ self,
+ path,
+ determine_wants,
+ graph_walker,
+ pack_data,
+ progress=None,
+ depth=None,
+ ref_prefix=[],
+ filter_spec=None,
+ protocol_version: Optional[int] = None,
+ ):
"""Retrieve a pack from a git smart server.
Args:
@@ -868,49 +2551,226 @@ class AbstractHttpGitClient(GitClient):
FetchPackResult object
"""
- pass
+ url = self._get_url(path)
+ refs, server_capabilities, url = self._discover_references(
+ b"git-upload-pack", url, protocol_version
+ )
+ (
+ negotiated_capabilities,
+ symrefs,
+ agent,
+ ) = self._negotiate_upload_pack_capabilities(server_capabilities)
+ if depth is not None:
+ wants = determine_wants(refs, depth=depth)
+ else:
+ wants = determine_wants(refs)
+ if wants is not None:
+ wants = [cid for cid in wants if cid != ZERO_SHA]
+ if not wants:
+ return FetchPackResult(refs, symrefs, agent)
+ if self.dumb:
+ raise NotImplementedError(self.fetch_pack)
+ req_data = BytesIO()
+ req_proto = Protocol(None, req_data.write)
+ (new_shallow, new_unshallow) = _handle_upload_pack_head(
+ req_proto,
+ negotiated_capabilities,
+ graph_walker,
+ wants,
+ can_read=None,
+ depth=depth,
+ protocol_version=self.protocol_version,
+ )
+ if self.protocol_version == 2:
+ data = pkt_line(b"command=fetch\n") + b"0001"
+ if (
+ find_capability(
+ negotiated_capabilities, CAPABILITY_FETCH, CAPABILITY_FILTER
+ )
+ and filter_spec
+ ):
+ data += pkt_line(b"filter %s\n" % filter_spec)
+ elif filter_spec:
+ self._warn_filter_objects()
+ data += req_data.getvalue()
+ else:
+ if filter_spec:
+ self._warn_filter_objects()
+ data = req_data.getvalue()
+ resp, read = self._smart_request("git-upload-pack", url, data)
+ try:
+ resp_proto = Protocol(read, None)
+ if new_shallow is None and new_unshallow is None:
+ (new_shallow, new_unshallow) = _read_shallow_updates(
+ resp_proto.read_pkt_seq()
+ )
+ _handle_upload_pack_tail(
+ resp_proto,
+ negotiated_capabilities,
+ graph_walker,
+ pack_data,
+ progress,
+ protocol_version=self.protocol_version,
+ )
+ return FetchPackResult(refs, symrefs, agent, new_shallow, new_unshallow)
+ finally:
+ resp.close()
def get_refs(self, path):
"""Retrieve the current refs from a git smart server."""
- pass
+ url = self._get_url(path)
+ refs, _, _ = self._discover_references(b"git-upload-pack", url)
+ return refs
- def __repr__(self) ->str:
- return f'{type(self).__name__}({self._base_url!r}, dumb={self.dumb!r})'
+ def get_url(self, path):
+ return self._get_url(path).rstrip("/")
+ def _get_url(self, path):
+ return urljoin(self._base_url, path).rstrip("/") + "/"
+
+ @classmethod
+ def from_parsedurl(cls, parsedurl, **kwargs):
+ password = parsedurl.password
+ if password is not None:
+ kwargs["password"] = urlunquote(password)
+ username = parsedurl.username
+ if username is not None:
+ kwargs["username"] = urlunquote(username)
+ return cls(urlunparse(parsedurl), **kwargs)
+
+ def __repr__(self) -> str:
+ return f"{type(self).__name__}({self._base_url!r}, dumb={self.dumb!r})"
+
+
+def _wrap_urllib3_exceptions(func):
+ from urllib3.exceptions import ProtocolError
+
+ def wrapper(*args, **kwargs):
+ try:
+ return func(*args, **kwargs)
+ except ProtocolError as error:
+ raise GitProtocolError(str(error)) from error
+
+ return wrapper
-class Urllib3HttpGitClient(AbstractHttpGitClient):
- def __init__(self, base_url, dumb=None, pool_manager=None, config=None,
- username=None, password=None, **kwargs) ->None:
+class Urllib3HttpGitClient(AbstractHttpGitClient):
+ def __init__(
+ self,
+ base_url,
+ dumb=None,
+ pool_manager=None,
+ config=None,
+ username=None,
+ password=None,
+ **kwargs,
+ ) -> None:
self._username = username
self._password = password
+
if pool_manager is None:
- self.pool_manager = default_urllib3_manager(config, base_url=
- base_url)
+ self.pool_manager = default_urllib3_manager(config, base_url=base_url)
else:
self.pool_manager = pool_manager
+
if username is not None:
+ # No escaping needed: ":" is not allowed in username:
+ # https://tools.ietf.org/html/rfc2617#section-2
credentials = f"{username}:{password or ''}"
import urllib3.util
+
basic_auth = urllib3.util.make_headers(basic_auth=credentials)
- self.pool_manager.headers.update(basic_auth)
+ self.pool_manager.headers.update(basic_auth) # type: ignore
+
self.config = config
+
super().__init__(base_url=base_url, dumb=dumb, **kwargs)
+ def _get_url(self, path):
+ if not isinstance(path, str):
+ # urllib3.util.url._encode_invalid_chars() converts the path back
+ # to bytes using the utf-8 codec.
+ path = path.decode("utf-8")
+ return urljoin(self._base_url, path).rstrip("/") + "/"
+
+ def _http_request(self, url, headers=None, data=None):
+ import urllib3.exceptions
+
+ req_headers = self.pool_manager.headers.copy()
+ if headers is not None:
+ req_headers.update(headers)
+ req_headers["Pragma"] = "no-cache"
+
+ try:
+ if data is None:
+ resp = self.pool_manager.request(
+ "GET", url, headers=req_headers, preload_content=False
+ )
+ else:
+ resp = self.pool_manager.request(
+ "POST", url, headers=req_headers, body=data, preload_content=False
+ )
+ except urllib3.exceptions.HTTPError as e:
+ raise GitProtocolError(str(e)) from e
+
+ if resp.status == 404:
+ raise NotGitRepository
+ if resp.status == 401:
+ raise HTTPUnauthorized(resp.headers.get("WWW-Authenticate"), url)
+ if resp.status == 407:
+ raise HTTPProxyUnauthorized(resp.headers.get("Proxy-Authenticate"), url)
+ if resp.status != 200:
+ raise GitProtocolError(
+ "unexpected http resp %d for %s" % (resp.status, url)
+ )
+
+ resp.content_type = resp.headers.get("Content-Type")
+ # Check if geturl() is available (urllib3 version >= 1.23)
+ try:
+ resp_url = resp.geturl()
+ except AttributeError:
+ # get_redirect_location() is available for urllib3 >= 1.1
+ resp.redirect_location = resp.get_redirect_location()
+ else:
+ resp.redirect_location = resp_url if resp_url != url else ""
+ return resp, _wrap_urllib3_exceptions(resp.read)
+
HttpGitClient = Urllib3HttpGitClient
-def _win32_url_to_path(parsed) ->str:
+def _win32_url_to_path(parsed) -> str:
"""Convert a file: URL to a path.
https://datatracker.ietf.org/doc/html/rfc8089
"""
- pass
-
-
-def get_transport_and_path_from_url(url: str, config: Optional[Config]=None,
- operation: Optional[str]=None, **kwargs) ->Tuple[GitClient, str]:
+ assert sys.platform == "win32" or os.name == "nt"
+ assert parsed.scheme == "file"
+
+ _, netloc, path, _, _, _ = parsed
+
+ if netloc == "localhost" or not netloc:
+ netloc = ""
+ elif (
+ netloc
+ and len(netloc) >= 2
+ and netloc[0].isalpha()
+ and netloc[1:2] in (":", ":/")
+ ):
+ # file://C:/foo.bar/baz or file://C://foo.bar//baz
+ netloc = netloc[:2]
+ else:
+ raise NotImplementedError("Non-local file URLs are not supported")
+
+ global url2pathname
+ if url2pathname is None:
+ from urllib.request import url2pathname # type: ignore
+ return url2pathname(netloc + path) # type: ignore
+
+
+def get_transport_and_path_from_url(
+ url: str, config: Optional[Config] = None, operation: Optional[str] = None, **kwargs
+) -> Tuple[GitClient, str]:
"""Obtain a git client from a URL.
Args:
@@ -925,16 +2785,61 @@ def get_transport_and_path_from_url(url: str, config: Optional[Config]=None,
Tuple with client instance and relative path.
"""
- pass
+ if config is not None:
+ url = apply_instead_of(config, url, push=(operation == "push"))
+ return _get_transport_and_path_from_url(
+ url, config=config, operation=operation, **kwargs
+ )
-def parse_rsync_url(location: str) ->Tuple[Optional[str], str, str]:
- """Parse a rsync-style URL."""
- pass
+def _get_transport_and_path_from_url(url, config, operation, **kwargs):
+ parsed = urlparse(url)
+ if parsed.scheme == "git":
+ return (TCPGitClient.from_parsedurl(parsed, **kwargs), parsed.path)
+ elif parsed.scheme in ("git+ssh", "ssh"):
+ return SSHGitClient.from_parsedurl(parsed, **kwargs), parsed.path
+ elif parsed.scheme in ("http", "https"):
+ return (
+ HttpGitClient.from_parsedurl(parsed, config=config, **kwargs),
+ parsed.path,
+ )
+ elif parsed.scheme == "file":
+ if sys.platform == "win32" or os.name == "nt":
+ return default_local_git_client_cls(**kwargs), _win32_url_to_path(parsed)
+ return (
+ default_local_git_client_cls.from_parsedurl(parsed, **kwargs),
+ parsed.path,
+ )
+
+ raise ValueError(f"unknown scheme '{parsed.scheme}'")
-def get_transport_and_path(location: str, config: Optional[Config]=None,
- operation: Optional[str]=None, **kwargs) ->Tuple[GitClient, str]:
+
+def parse_rsync_url(location: str) -> Tuple[Optional[str], str, str]:
+ """Parse a rsync-style URL."""
+ if ":" in location and "@" not in location:
+ # SSH with no user@, zero or one leading slash.
+ (host, path) = location.split(":", 1)
+ user = None
+ elif ":" in location:
+ # SSH with user@host:foo.
+ user_host, path = location.split(":", 1)
+ if "@" in user_host:
+ user, host = user_host.rsplit("@", 1)
+ else:
+ user = None
+ host = user_host
+ else:
+ raise ValueError("not a valid rsync-style URL")
+ return (user, host, path)
+
+
+def get_transport_and_path(
+ location: str,
+ config: Optional[Config] = None,
+ operation: Optional[str] = None,
+ **kwargs,
+) -> Tuple[GitClient, str]:
"""Obtain a git client from a URL.
Args:
@@ -949,8 +2854,50 @@ def get_transport_and_path(location: str, config: Optional[Config]=None,
Tuple with client instance and relative path.
"""
- pass
-
+ if config is not None:
+ location = apply_instead_of(config, location, push=(operation == "push"))
+
+ # First, try to parse it as a URL
+ try:
+ return _get_transport_and_path_from_url(
+ location, config=config, operation=operation, **kwargs
+ )
+ except ValueError:
+ pass
-DEFAULT_GIT_CREDENTIALS_PATHS = [os.path.expanduser('~/.git-credentials'),
- get_xdg_config_home_path('git', 'credentials')]
+ if sys.platform == "win32" and location[0].isalpha() and location[1:3] == ":\\":
+ # Windows local path
+ return default_local_git_client_cls(**kwargs), location
+
+ try:
+ (username, hostname, path) = parse_rsync_url(location)
+ except ValueError:
+ # Otherwise, assume it's a local path.
+ return default_local_git_client_cls(**kwargs), location
+ else:
+ return SSHGitClient(hostname, username=username, **kwargs), path
+
+
+DEFAULT_GIT_CREDENTIALS_PATHS = [
+ os.path.expanduser("~/.git-credentials"),
+ get_xdg_config_home_path("git", "credentials"),
+]
+
+
+def get_credentials_from_store(
+ scheme, hostname, username=None, fnames=DEFAULT_GIT_CREDENTIALS_PATHS
+):
+ for fname in fnames:
+ try:
+ with open(fname, "rb") as f:
+ for line in f:
+ parsed_line = urlparse(line.strip())
+ if (
+ parsed_line.scheme == scheme
+ and parsed_line.hostname == hostname
+ and (username is None or parsed_line.username == username)
+ ):
+ return parsed_line.username, parsed_line.password
+ except FileNotFoundError:
+ # If the file doesn't exist, try the next one.
+ continue
diff --git a/dulwich/cloud/gcs.py b/dulwich/cloud/gcs.py
index 329f6ef2..b9dd9b4c 100644
--- a/dulwich/cloud/gcs.py
+++ b/dulwich/cloud/gcs.py
@@ -1,18 +1,79 @@
+# object_store.py -- Object store for git objects
+# Copyright (C) 2021 Jelmer Vernooij <jelmer@jelmer.uk>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
+
"""Storage of repositories on GCS."""
+
import posixpath
import tempfile
+
from ..object_store import BucketBasedObjectStore
from ..pack import PACK_SPOOL_FILE_MAX_SIZE, Pack, PackData, load_pack_index_file
+# TODO(jelmer): For performance, read ranges?
-class GcsObjectStore(BucketBasedObjectStore):
- def __init__(self, bucket, subpath='') ->None:
+class GcsObjectStore(BucketBasedObjectStore):
+ def __init__(self, bucket, subpath="") -> None:
super().__init__()
self.bucket = bucket
self.subpath = subpath
- def __repr__(self) ->str:
- return (
- f'{type(self).__name__}({self.bucket!r}, subpath={self.subpath!r})'
- )
+ def __repr__(self) -> str:
+ return f"{type(self).__name__}({self.bucket!r}, subpath={self.subpath!r})"
+
+ def _remove_pack(self, name):
+ self.bucket.delete_blobs(
+ [posixpath.join(self.subpath, name) + "." + ext for ext in ["pack", "idx"]]
+ )
+
+ def _iter_pack_names(self):
+ packs = {}
+ for blob in self.bucket.list_blobs(prefix=self.subpath):
+ name, ext = posixpath.splitext(posixpath.basename(blob.name))
+ packs.setdefault(name, set()).add(ext)
+ for name, exts in packs.items():
+ if exts == {".pack", ".idx"}:
+ yield name
+
+ def _load_pack_data(self, name):
+ b = self.bucket.blob(posixpath.join(self.subpath, name + ".pack"))
+ f = tempfile.SpooledTemporaryFile(max_size=PACK_SPOOL_FILE_MAX_SIZE)
+ b.download_to_file(f)
+ f.seek(0)
+ return PackData(name + ".pack", f)
+
+ def _load_pack_index(self, name):
+ b = self.bucket.blob(posixpath.join(self.subpath, name + ".idx"))
+ f = tempfile.SpooledTemporaryFile(max_size=PACK_SPOOL_FILE_MAX_SIZE)
+ b.download_to_file(f)
+ f.seek(0)
+ return load_pack_index_file(name + ".idx", f)
+
+ def _get_pack(self, name):
+ return Pack.from_lazy_objects(
+ lambda: self._load_pack_data(name), lambda: self._load_pack_index(name)
+ )
+
+ def _upload_pack(self, basename, pack_file, index_file):
+ idxblob = self.bucket.blob(posixpath.join(self.subpath, basename + ".idx"))
+ datablob = self.bucket.blob(posixpath.join(self.subpath, basename + ".pack"))
+ idxblob.upload_from_file(index_file)
+ datablob.upload_from_file(pack_file)
diff --git a/dulwich/config.py b/dulwich/config.py
index 663659a6..c0a3de11 100644
--- a/dulwich/config.py
+++ b/dulwich/config.py
@@ -1,3 +1,23 @@
+# config.py - Reading and writing Git config files
+# Copyright (C) 2011-2013 Jelmer Vernooij <jelmer@jelmer.uk>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Reading and writing Git configuration files.
Todo:
@@ -5,31 +25,83 @@ Todo:
* treat subsection names as case-insensitive for [branch.foo] style
subsections
"""
+
import os
import sys
from contextlib import suppress
-from typing import Any, BinaryIO, Dict, Iterable, Iterator, KeysView, List, MutableMapping, Optional, Tuple, Union, overload
+from typing import (
+ Any,
+ BinaryIO,
+ Dict,
+ Iterable,
+ Iterator,
+ KeysView,
+ List,
+ MutableMapping,
+ Optional,
+ Tuple,
+ Union,
+ overload,
+)
+
from .file import GitFile
+
SENTINEL = object()
-class CaseInsensitiveOrderedMultiDict(MutableMapping):
+def lower_key(key):
+ if isinstance(key, (bytes, str)):
+ return key.lower()
+
+ if isinstance(key, Iterable):
+ return type(key)(map(lower_key, key)) # type: ignore
- def __init__(self) ->None:
+ return key
+
+
+class CaseInsensitiveOrderedMultiDict(MutableMapping):
+ def __init__(self) -> None:
self._real: List[Any] = []
self._keyed: Dict[Any, Any] = {}
- def __len__(self) ->int:
+ @classmethod
+ def make(cls, dict_in=None):
+ if isinstance(dict_in, cls):
+ return dict_in
+
+ out = cls()
+
+ if dict_in is None:
+ return out
+
+ if not isinstance(dict_in, MutableMapping):
+ raise TypeError
+
+ for key, value in dict_in.items():
+ out[key] = value
+
+ return out
+
+ def __len__(self) -> int:
return len(self._keyed)
+ def keys(self) -> KeysView[Tuple[bytes, ...]]:
+ return self._keyed.keys()
+
+ def items(self):
+ return iter(self._real)
+
def __iter__(self):
return self._keyed.__iter__()
- def __setitem__(self, key, value) ->None:
+ def values(self):
+ return self._keyed.values()
+
+ def __setitem__(self, key, value) -> None:
self._real.append((key, value))
self._keyed[lower_key(key)] = value
- def __delitem__(self, key) ->None:
+ def __delitem__(self, key) -> None:
key = lower_key(key)
del self._keyed[key]
for i, (actual, unused_value) in reversed(list(enumerate(self._real))):
@@ -39,6 +111,31 @@ class CaseInsensitiveOrderedMultiDict(MutableMapping):
def __getitem__(self, item):
return self._keyed[lower_key(item)]
+ def get(self, key, default=SENTINEL):
+ try:
+ return self[key]
+ except KeyError:
+ pass
+
+ if default is SENTINEL:
+ return type(self)()
+
+ return default
+
+ def get_all(self, key):
+ key = lower_key(key)
+ for actual, value in self._real:
+ if lower_key(actual) == key:
+ yield value
+
+ def setdefault(self, key, default=SENTINEL):
+ try:
+ return self[key]
+ except KeyError:
+ self[key] = self.get(key, default)
+
+ return self[key]
+
Name = bytes
NameLike = Union[bytes, str]
@@ -51,7 +148,7 @@ ValueLike = Union[bytes, str]
class Config:
"""A Git configuration."""
- def get(self, section: SectionLike, name: NameLike) ->Value:
+ def get(self, section: SectionLike, name: NameLike) -> Value:
"""Retrieve the contents of a configuration setting.
Args:
@@ -62,10 +159,9 @@ class Config:
Raises:
KeyError: if the value is not set
"""
- pass
+ raise NotImplementedError(self.get)
- def get_multivar(self, section: SectionLike, name: NameLike) ->Iterator[
- Value]:
+ def get_multivar(self, section: SectionLike, name: NameLike) -> Iterator[Value]:
"""Retrieve the contents of a multivar configuration setting.
Args:
@@ -76,10 +172,19 @@ class Config:
Raises:
KeyError: if the value is not set
"""
- pass
+ raise NotImplementedError(self.get_multivar)
- def get_boolean(self, section: SectionLike, name: NameLike, default:
- Optional[bool]=None) ->Optional[bool]:
+ @overload
+ def get_boolean(
+ self, section: SectionLike, name: NameLike, default: bool
+ ) -> bool: ...
+
+ @overload
+ def get_boolean(self, section: SectionLike, name: NameLike) -> Optional[bool]: ...
+
+ def get_boolean(
+ self, section: SectionLike, name: NameLike, default: Optional[bool] = None
+ ) -> Optional[bool]:
"""Retrieve a configuration setting as boolean.
Args:
@@ -90,10 +195,19 @@ class Config:
Returns:
Contents of the setting
"""
- pass
-
- def set(self, section: SectionLike, name: NameLike, value: Union[
- ValueLike, bool]) ->None:
+ try:
+ value = self.get(section, name)
+ except KeyError:
+ return default
+ if value.lower() == b"true":
+ return True
+ elif value.lower() == b"false":
+ return False
+ raise ValueError(f"not a valid boolean string: {value!r}")
+
+ def set(
+ self, section: SectionLike, name: NameLike, value: Union[ValueLike, bool]
+ ) -> None:
"""Set a configuration value.
Args:
@@ -102,9 +216,9 @@ class Config:
and optional subsection
value: value of the setting
"""
- pass
+ raise NotImplementedError(self.set)
- def items(self, section: SectionLike) ->Iterator[Tuple[Name, Value]]:
+ def items(self, section: SectionLike) -> Iterator[Tuple[Name, Value]]:
"""Iterate over the configuration pairs for a specific section.
Args:
@@ -112,16 +226,16 @@ class Config:
Returns:
Iterator over (name, value) pairs
"""
- pass
+ raise NotImplementedError(self.items)
- def sections(self) ->Iterator[Section]:
+ def sections(self) -> Iterator[Section]:
"""Iterate over the sections.
Returns: Iterator over section tuples
"""
- pass
+ raise NotImplementedError(self.sections)
- def has_section(self, name: Section) ->bool:
+ def has_section(self, name: Section) -> bool:
"""Check if a specified section exists.
Args:
@@ -129,109 +243,508 @@ class Config:
Returns:
boolean indicating whether the section exists
"""
- pass
+ return name in self.sections()
class ConfigDict(Config, MutableMapping[Section, MutableMapping[Name, Value]]):
"""Git configuration stored in a dictionary."""
- def __init__(self, values: Union[MutableMapping[Section, MutableMapping
- [Name, Value]], None]=None, encoding: Union[str, None]=None) ->None:
+ def __init__(
+ self,
+ values: Union[
+ MutableMapping[Section, MutableMapping[Name, Value]], None
+ ] = None,
+ encoding: Union[str, None] = None,
+ ) -> None:
"""Create a new ConfigDict."""
if encoding is None:
encoding = sys.getdefaultencoding()
self.encoding = encoding
self._values = CaseInsensitiveOrderedMultiDict.make(values)
- def __repr__(self) ->str:
- return f'{self.__class__.__name__}({self._values!r})'
+ def __repr__(self) -> str:
+ return f"{self.__class__.__name__}({self._values!r})"
- def __eq__(self, other: object) ->bool:
- return isinstance(other, self.__class__
- ) and other._values == self._values
+ def __eq__(self, other: object) -> bool:
+ return isinstance(other, self.__class__) and other._values == self._values
- def __getitem__(self, key: Section) ->MutableMapping[Name, Value]:
+ def __getitem__(self, key: Section) -> MutableMapping[Name, Value]:
return self._values.__getitem__(key)
- def __setitem__(self, key: Section, value: MutableMapping[Name, Value]
- ) ->None:
+ def __setitem__(self, key: Section, value: MutableMapping[Name, Value]) -> None:
return self._values.__setitem__(key, value)
- def __delitem__(self, key: Section) ->None:
+ def __delitem__(self, key: Section) -> None:
return self._values.__delitem__(key)
- def __iter__(self) ->Iterator[Section]:
+ def __iter__(self) -> Iterator[Section]:
return self._values.__iter__()
- def __len__(self) ->int:
+ def __len__(self) -> int:
return self._values.__len__()
-
-_ESCAPE_TABLE = {ord(b'\\'): ord(b'\\'), ord(b'"'): ord(b'"'), ord(b'n'):
- ord(b'\n'), ord(b't'): ord(b'\t'), ord(b'b'): ord(b'\x08')}
-_COMMENT_CHARS = [ord(b'#'), ord(b';')]
-_WHITESPACE_CHARS = [ord(b'\t'), ord(b' ')]
-
-
-def _escape_value(value: bytes) ->bytes:
+ @classmethod
+ def _parse_setting(cls, name: str):
+ parts = name.split(".")
+ if len(parts) == 3:
+ return (parts[0], parts[1], parts[2])
+ else:
+ return (parts[0], None, parts[1])
+
+ def _check_section_and_name(
+ self, section: SectionLike, name: NameLike
+ ) -> Tuple[Section, Name]:
+ if not isinstance(section, tuple):
+ section = (section,)
+
+ checked_section = tuple(
+ [
+ subsection.encode(self.encoding)
+ if not isinstance(subsection, bytes)
+ else subsection
+ for subsection in section
+ ]
+ )
+
+ if not isinstance(name, bytes):
+ name = name.encode(self.encoding)
+
+ return checked_section, name
+
+ def get_multivar(self, section: SectionLike, name: NameLike) -> Iterator[Value]:
+ section, name = self._check_section_and_name(section, name)
+
+ if len(section) > 1:
+ try:
+ return self._values[section].get_all(name)
+ except KeyError:
+ pass
+
+ return self._values[(section[0],)].get_all(name)
+
+ def get( # type: ignore[override]
+ self,
+ section: SectionLike,
+ name: NameLike,
+ ) -> Value:
+ section, name = self._check_section_and_name(section, name)
+
+ if len(section) > 1:
+ try:
+ return self._values[section][name]
+ except KeyError:
+ pass
+
+ return self._values[(section[0],)][name]
+
+ def set(
+ self,
+ section: SectionLike,
+ name: NameLike,
+ value: Union[ValueLike, bool],
+ ) -> None:
+ section, name = self._check_section_and_name(section, name)
+
+ if isinstance(value, bool):
+ value = b"true" if value else b"false"
+
+ if not isinstance(value, bytes):
+ value = value.encode(self.encoding)
+
+ self._values.setdefault(section)[name] = value
+
+ def items( # type: ignore[override]
+ self, section: Section
+ ) -> Iterator[Tuple[Name, Value]]:
+ return self._values.get(section).items()
+
+ def sections(self) -> Iterator[Section]:
+ return self._values.keys()
+
+
+def _format_string(value: bytes) -> bytes:
+ if (
+ value.startswith((b" ", b"\t"))
+ or value.endswith((b" ", b"\t"))
+ or b"#" in value
+ ):
+ return b'"' + _escape_value(value) + b'"'
+ else:
+ return _escape_value(value)
+
+
+_ESCAPE_TABLE = {
+ ord(b"\\"): ord(b"\\"),
+ ord(b'"'): ord(b'"'),
+ ord(b"n"): ord(b"\n"),
+ ord(b"t"): ord(b"\t"),
+ ord(b"b"): ord(b"\b"),
+}
+_COMMENT_CHARS = [ord(b"#"), ord(b";")]
+_WHITESPACE_CHARS = [ord(b"\t"), ord(b" ")]
+
+
+def _parse_string(value: bytes) -> bytes:
+ value = bytearray(value.strip())
+ ret = bytearray()
+ whitespace = bytearray()
+ in_quotes = False
+ i = 0
+ while i < len(value):
+ c = value[i]
+ if c == ord(b"\\"):
+ i += 1
+ try:
+ v = _ESCAPE_TABLE[value[i]]
+ except IndexError as exc:
+ raise ValueError(
+ "escape character in %r at %d before end of string" % (value, i)
+ ) from exc
+ except KeyError as exc:
+ raise ValueError(
+ "escape character followed by unknown character "
+ "%s at %d in %r" % (value[i], i, value)
+ ) from exc
+ if whitespace:
+ ret.extend(whitespace)
+ whitespace = bytearray()
+ ret.append(v)
+ elif c == ord(b'"'):
+ in_quotes = not in_quotes
+ elif c in _COMMENT_CHARS and not in_quotes:
+ # the rest of the line is a comment
+ break
+ elif c in _WHITESPACE_CHARS:
+ whitespace.append(c)
+ else:
+ if whitespace:
+ ret.extend(whitespace)
+ whitespace = bytearray()
+ ret.append(c)
+ i += 1
+
+ if in_quotes:
+ raise ValueError("missing end quote")
+
+ return bytes(ret)
+
+
+def _escape_value(value: bytes) -> bytes:
"""Escape a value."""
- pass
+ value = value.replace(b"\\", b"\\\\")
+ value = value.replace(b"\r", b"\\r")
+ value = value.replace(b"\n", b"\\n")
+ value = value.replace(b"\t", b"\\t")
+ value = value.replace(b'"', b'\\"')
+ return value
+
+
+def _check_variable_name(name: bytes) -> bool:
+ for i in range(len(name)):
+ c = name[i : i + 1]
+ if not c.isalnum() and c != b"-":
+ return False
+ return True
+
+
+def _check_section_name(name: bytes) -> bool:
+ for i in range(len(name)):
+ c = name[i : i + 1]
+ if not c.isalnum() and c not in (b"-", b"."):
+ return False
+ return True
+
+
+def _strip_comments(line: bytes) -> bytes:
+ comment_bytes = {ord(b"#"), ord(b";")}
+ quote = ord(b'"')
+ string_open = False
+ # Normalize line to bytearray for simple 2/3 compatibility
+ for i, character in enumerate(bytearray(line)):
+ # Comment characters outside balanced quotes denote comment start
+ if character == quote:
+ string_open = not string_open
+ elif not string_open and character in comment_bytes:
+ return line[:i]
+ return line
+
+
+def _parse_section_header_line(line: bytes) -> Tuple[Section, bytes]:
+ # Parse section header ("[bla]")
+ line = _strip_comments(line).rstrip()
+ in_quotes = False
+ escaped = False
+ for i, c in enumerate(line):
+ if escaped:
+ escaped = False
+ continue
+ if c == ord(b'"'):
+ in_quotes = not in_quotes
+ if c == ord(b"\\"):
+ escaped = True
+ if c == ord(b"]") and not in_quotes:
+ last = i
+ break
+ else:
+ raise ValueError("expected trailing ]")
+ pts = line[1:last].split(b" ", 1)
+ line = line[last + 1 :]
+ section: Section
+ if len(pts) == 2:
+ if pts[1][:1] != b'"' or pts[1][-1:] != b'"':
+ raise ValueError(f"Invalid subsection {pts[1]!r}")
+ else:
+ pts[1] = pts[1][1:-1]
+ if not _check_section_name(pts[0]):
+ raise ValueError(f"invalid section name {pts[0]!r}")
+ section = (pts[0], pts[1])
+ else:
+ if not _check_section_name(pts[0]):
+ raise ValueError(f"invalid section name {pts[0]!r}")
+ pts = pts[0].split(b".", 1)
+ if len(pts) == 2:
+ section = (pts[0], pts[1])
+ else:
+ section = (pts[0],)
+ return section, line
class ConfigFile(ConfigDict):
"""A Git configuration file, like .git/config or ~/.gitconfig."""
- def __init__(self, values: Union[MutableMapping[Section, MutableMapping
- [Name, Value]], None]=None, encoding: Union[str, None]=None) ->None:
+ def __init__(
+ self,
+ values: Union[
+ MutableMapping[Section, MutableMapping[Name, Value]], None
+ ] = None,
+ encoding: Union[str, None] = None,
+ ) -> None:
super().__init__(values=values, encoding=encoding)
self.path: Optional[str] = None
@classmethod
- def from_file(cls, f: BinaryIO) ->'ConfigFile':
+ def from_file(cls, f: BinaryIO) -> "ConfigFile":
"""Read configuration from a file-like object."""
- pass
+ ret = cls()
+ section: Optional[Section] = None
+ setting = None
+ continuation = None
+ for lineno, line in enumerate(f.readlines()):
+ if lineno == 0 and line.startswith(b"\xef\xbb\xbf"):
+ line = line[3:]
+ line = line.lstrip()
+ if setting is None:
+ if len(line) > 0 and line[:1] == b"[":
+ section, line = _parse_section_header_line(line)
+ ret._values.setdefault(section)
+ if _strip_comments(line).strip() == b"":
+ continue
+ if section is None:
+ raise ValueError(f"setting {line!r} without section")
+ try:
+ setting, value = line.split(b"=", 1)
+ except ValueError:
+ setting = line
+ value = b"true"
+ setting = setting.strip()
+ if not _check_variable_name(setting):
+ raise ValueError(f"invalid variable name {setting!r}")
+ if value.endswith(b"\\\n"):
+ continuation = value[:-2]
+ elif value.endswith(b"\\\r\n"):
+ continuation = value[:-3]
+ else:
+ continuation = None
+ value = _parse_string(value)
+ ret._values[section][setting] = value
+ setting = None
+ else: # continuation line
+ if line.endswith(b"\\\n"):
+ continuation += line[:-2]
+ elif line.endswith(b"\\\r\n"):
+ continuation += line[:-3]
+ else:
+ continuation += line
+ value = _parse_string(continuation)
+ ret._values[section][setting] = value
+ continuation = None
+ setting = None
+ return ret
@classmethod
- def from_path(cls, path: str) ->'ConfigFile':
+ def from_path(cls, path: str) -> "ConfigFile":
"""Read configuration from a file on disk."""
- pass
+ with GitFile(path, "rb") as f:
+ ret = cls.from_file(f)
+ ret.path = path
+ return ret
- def write_to_path(self, path: Optional[str]=None) ->None:
+ def write_to_path(self, path: Optional[str] = None) -> None:
"""Write configuration to a file on disk."""
- pass
+ if path is None:
+ path = self.path
+ with GitFile(path, "wb") as f:
+ self.write_to_file(f)
- def write_to_file(self, f: BinaryIO) ->None:
+ def write_to_file(self, f: BinaryIO) -> None:
"""Write configuration to a file-like object."""
- pass
+ for section, values in self._values.items():
+ try:
+ section_name, subsection_name = section
+ except ValueError:
+ (section_name,) = section
+ subsection_name = None
+ if subsection_name is None:
+ f.write(b"[" + section_name + b"]\n")
+ else:
+ f.write(b"[" + section_name + b' "' + subsection_name + b'"]\n')
+ for key, value in values.items():
+ value = _format_string(value)
+ f.write(b"\t" + key + b" = " + value + b"\n")
+
+
+def get_xdg_config_home_path(*path_segments):
+ xdg_config_home = os.environ.get(
+ "XDG_CONFIG_HOME",
+ os.path.expanduser("~/.config/"),
+ )
+ return os.path.join(xdg_config_home, *path_segments)
+
+
+def _find_git_in_win_path():
+ for exe in ("git.exe", "git.cmd"):
+ for path in os.environ.get("PATH", "").split(";"):
+ if os.path.exists(os.path.join(path, exe)):
+ # in windows native shells (powershell/cmd) exe path is
+ # .../Git/bin/git.exe or .../Git/cmd/git.exe
+ #
+ # in git-bash exe path is .../Git/mingw64/bin/git.exe
+ git_dir, _bin_dir = os.path.split(path)
+ yield git_dir
+ parent_dir, basename = os.path.split(git_dir)
+ if basename == "mingw32" or basename == "mingw64":
+ yield parent_dir
+ break
+
+
+def _find_git_in_win_reg():
+ import platform
+ import winreg
+
+ if platform.machine() == "AMD64":
+ subkey = (
+ "SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\"
+ "CurrentVersion\\Uninstall\\Git_is1"
+ )
+ else:
+ subkey = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\" "Uninstall\\Git_is1"
+
+ for key in (winreg.HKEY_CURRENT_USER, winreg.HKEY_LOCAL_MACHINE): # type: ignore
+ with suppress(OSError):
+ with winreg.OpenKey(key, subkey) as k: # type: ignore
+ val, typ = winreg.QueryValueEx(k, "InstallLocation") # type: ignore
+ if typ == winreg.REG_SZ: # type: ignore
+ yield val
+
+
+# There is no set standard for system config dirs on windows. We try the
+# following:
+# - %PROGRAMDATA%/Git/config - (deprecated) Windows config dir per CGit docs
+# - %PROGRAMFILES%/Git/etc/gitconfig - Git for Windows (msysgit) config dir
+# Used if CGit installation (Git/bin/git.exe) is found in PATH in the
+# system registry
+def get_win_system_paths():
+ if "PROGRAMDATA" in os.environ:
+ yield os.path.join(os.environ["PROGRAMDATA"], "Git", "config")
+
+ for git_dir in _find_git_in_win_path():
+ yield os.path.join(git_dir, "etc", "gitconfig")
+ for git_dir in _find_git_in_win_reg():
+ yield os.path.join(git_dir, "etc", "gitconfig")
class StackedConfig(Config):
"""Configuration which reads from multiple config files.."""
- def __init__(self, backends: List[ConfigFile], writable: Optional[
- ConfigFile]=None) ->None:
+ def __init__(
+ self, backends: List[ConfigFile], writable: Optional[ConfigFile] = None
+ ) -> None:
self.backends = backends
self.writable = writable
- def __repr__(self) ->str:
- return f'<{self.__class__.__name__} for {self.backends!r}>'
+ def __repr__(self) -> str:
+ return f"<{self.__class__.__name__} for {self.backends!r}>"
@classmethod
- def default_backends(cls) ->List[ConfigFile]:
+ def default(cls) -> "StackedConfig":
+ return cls(cls.default_backends())
+
+ @classmethod
+ def default_backends(cls) -> List[ConfigFile]:
"""Retrieve the default configuration.
See git-config(1) for details on the files searched.
"""
- pass
-
-
-def read_submodules(path: str) ->Iterator[Tuple[bytes, bytes, bytes]]:
+ paths = []
+ paths.append(os.path.expanduser("~/.gitconfig"))
+ paths.append(get_xdg_config_home_path("git", "config"))
+
+ if "GIT_CONFIG_NOSYSTEM" not in os.environ:
+ paths.append("/etc/gitconfig")
+ if sys.platform == "win32":
+ paths.extend(get_win_system_paths())
+
+ backends = []
+ for path in paths:
+ try:
+ cf = ConfigFile.from_path(path)
+ except FileNotFoundError:
+ continue
+ backends.append(cf)
+ return backends
+
+ def get(self, section: SectionLike, name: NameLike) -> Value:
+ if not isinstance(section, tuple):
+ section = (section,)
+ for backend in self.backends:
+ try:
+ return backend.get(section, name)
+ except KeyError:
+ pass
+ raise KeyError(name)
+
+ def get_multivar(self, section: SectionLike, name: NameLike) -> Iterator[Value]:
+ if not isinstance(section, tuple):
+ section = (section,)
+ for backend in self.backends:
+ try:
+ yield from backend.get_multivar(section, name)
+ except KeyError:
+ pass
+
+ def set(
+ self, section: SectionLike, name: NameLike, value: Union[ValueLike, bool]
+ ) -> None:
+ if self.writable is None:
+ raise NotImplementedError(self.set)
+ return self.writable.set(section, name, value)
+
+ def sections(self) -> Iterator[Section]:
+ seen = set()
+ for backend in self.backends:
+ for section in backend.sections():
+ if section not in seen:
+ seen.add(section)
+ yield section
+
+
+def read_submodules(path: str) -> Iterator[Tuple[bytes, bytes, bytes]]:
"""Read a .gitmodules file."""
- pass
+ cfg = ConfigFile.from_path(path)
+ return parse_submodules(cfg)
-def parse_submodules(config: ConfigFile) ->Iterator[Tuple[bytes, bytes, bytes]
- ]:
+def parse_submodules(config: ConfigFile) -> Iterator[Tuple[bytes, bytes, bytes]]:
"""Parse a gitmodules GitConfig file, returning submodules.
Args:
@@ -240,15 +753,48 @@ def parse_submodules(config: ConfigFile) ->Iterator[Tuple[bytes, bytes, bytes]
list of tuples (submodule path, url, name),
where name is quoted part of the section's name.
"""
- pass
-
-
-def iter_instead_of(config: Config, push: bool=False) ->Iterable[Tuple[str,
- str]]:
+ for section in config.keys():
+ section_kind, section_name = section
+ if section_kind == b"submodule":
+ try:
+ sm_path = config.get(section, b"path")
+ sm_url = config.get(section, b"url")
+ yield (sm_path, sm_url, section_name)
+ except KeyError:
+ # If either path or url is missing, just ignore this
+ # submodule entry and move on to the next one. This is
+ # how git itself handles malformed .gitmodule entries.
+ pass
+
+
+def iter_instead_of(config: Config, push: bool = False) -> Iterable[Tuple[str, str]]:
"""Iterate over insteadOf / pushInsteadOf values."""
- pass
-
-
-def apply_instead_of(config: Config, orig_url: str, push: bool=False) ->str:
+ for section in config.sections():
+ if section[0] != b"url":
+ continue
+ replacement = section[1]
+ try:
+ needles = list(config.get_multivar(section, "insteadOf"))
+ except KeyError:
+ needles = []
+ if push:
+ try:
+ needles += list(config.get_multivar(section, "pushInsteadOf"))
+ except KeyError:
+ pass
+ for needle in needles:
+ assert isinstance(needle, bytes)
+ yield needle.decode("utf-8"), replacement.decode("utf-8")
+
+
+def apply_instead_of(config: Config, orig_url: str, push: bool = False) -> str:
"""Apply insteadOf / pushInsteadOf to a URL."""
- pass
+ longest_needle = ""
+ updated_url = orig_url
+ for needle, replacement in iter_instead_of(config, push):
+ if not orig_url.startswith(needle):
+ continue
+ if len(longest_needle) < len(needle):
+ longest_needle = needle
+ updated_url = replacement + orig_url[len(needle) :]
+ return updated_url
diff --git a/dulwich/contrib/diffstat.py b/dulwich/contrib/diffstat.py
index 1fbadd25..803c009e 100755
--- a/dulwich/contrib/diffstat.py
+++ b/dulwich/contrib/diffstat.py
@@ -1,28 +1,115 @@
+#!/usr/bin/env python
+# vim:ts=4:sw=4:softtabstop=4:smarttab:expandtab
+
+# Copyright (c) 2020 Kevin B. Hendricks, Stratford Ontario Canada
+# All rights reserved.
+#
+# This diffstat code was extracted and heavily modified from:
+#
+# https://github.com/techtonik/python-patch
+# Under the following license:
+#
+# Patch utility to apply unified diffs
+# Brute-force line-by-line non-recursive parsing
+#
+# Copyright (c) 2008-2016 anatoly techtonik
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
import re
import sys
from typing import List, Optional, Tuple
-_git_header_name = re.compile(b'diff --git a/(.*) b/(.*)')
-_GIT_HEADER_START = b'diff --git a/'
-_GIT_BINARY_START = b'Binary file'
-_GIT_RENAMEFROM_START = b'rename from'
-_GIT_RENAMETO_START = b'rename to'
-_GIT_CHUNK_START = b'@@'
-_GIT_ADDED_START = b'+'
-_GIT_DELETED_START = b'-'
-_GIT_UNCHANGED_START = b' '
-
-
-def _parse_patch(lines: List[bytes]) ->Tuple[List[bytes], List[bool], List[
- Tuple[int, int]]]:
+
+# only needs to detect git style diffs as this is for
+# use with dulwich
+
+_git_header_name = re.compile(rb"diff --git a/(.*) b/(.*)")
+
+_GIT_HEADER_START = b"diff --git a/"
+_GIT_BINARY_START = b"Binary file"
+_GIT_RENAMEFROM_START = b"rename from"
+_GIT_RENAMETO_START = b"rename to"
+_GIT_CHUNK_START = b"@@"
+_GIT_ADDED_START = b"+"
+_GIT_DELETED_START = b"-"
+_GIT_UNCHANGED_START = b" "
+
+# emulate original full Patch class by just extracting
+# filename and minimal chunk added/deleted information to
+# properly interface with diffstat routine
+
+
+def _parse_patch(
+ lines: List[bytes],
+) -> Tuple[List[bytes], List[bool], List[Tuple[int, int]]]:
"""Parse a git style diff or patch to generate diff stats.
Args:
lines: list of byte string lines from the diff to be parsed
Returns: A tuple (names, is_binary, counts) of three lists
"""
- pass
+ names = []
+ nametypes = []
+ counts = []
+ in_patch_chunk = in_git_header = binaryfile = False
+ currentfile: Optional[bytes] = None
+ added = deleted = 0
+ for line in lines:
+ if line.startswith(_GIT_HEADER_START):
+ if currentfile is not None:
+ names.append(currentfile)
+ nametypes.append(binaryfile)
+ counts.append((added, deleted))
+ m = _git_header_name.search(line)
+ assert m
+ currentfile = m.group(2)
+ binaryfile = False
+ added = deleted = 0
+ in_git_header = True
+ in_patch_chunk = False
+ elif line.startswith(_GIT_BINARY_START) and in_git_header:
+ binaryfile = True
+ in_git_header = False
+ elif line.startswith(_GIT_RENAMEFROM_START) and in_git_header:
+ currentfile = line[12:]
+ elif line.startswith(_GIT_RENAMETO_START) and in_git_header:
+ assert currentfile
+ currentfile += b" => %s" % line[10:]
+ elif line.startswith(_GIT_CHUNK_START) and (in_patch_chunk or in_git_header):
+ in_patch_chunk = True
+ in_git_header = False
+ elif line.startswith(_GIT_ADDED_START) and in_patch_chunk:
+ added += 1
+ elif line.startswith(_GIT_DELETED_START) and in_patch_chunk:
+ deleted += 1
+ elif not line.startswith(_GIT_UNCHANGED_START) and in_patch_chunk:
+ in_patch_chunk = False
+ # handle end of input
+ if currentfile is not None:
+ names.append(currentfile)
+ nametypes.append(binaryfile)
+ counts.append((added, deleted))
+ return names, nametypes, counts
+# note must all done using bytes not string because on linux filenames
+# may not be encodable even to utf-8
def diffstat(lines, max_width=80):
"""Generate summary statistics from a git style diff ala
(git diff tag1 tag2 --stat).
@@ -34,8 +121,231 @@ def diffstat(lines, max_width=80):
Returns: A byte string that lists the changed files with change
counts and histogram.
"""
- pass
+ names, nametypes, counts = _parse_patch(lines)
+ insert = []
+ delete = []
+ namelen = 0
+ maxdiff = 0 # max changes for any file used for histogram width calc
+ for i, filename in enumerate(names):
+ i, d = counts[i]
+ insert.append(i)
+ delete.append(d)
+ namelen = max(namelen, len(filename))
+ maxdiff = max(maxdiff, i + d)
+ output = b""
+ statlen = len(str(maxdiff)) # stats column width
+ for i, n in enumerate(names):
+ binaryfile = nametypes[i]
+ # %-19s | %-4d %s
+ # note b'%d' % namelen is not supported until Python 3.5
+ # To convert an int to a format width specifier for byte
+ # strings use str(namelen).encode('ascii')
+ format = (
+ b" %-"
+ + str(namelen).encode("ascii")
+ + b"s | %"
+ + str(statlen).encode("ascii")
+ + b"s %s\n"
+ )
+ binformat = b" %-" + str(namelen).encode("ascii") + b"s | %s\n"
+ if not binaryfile:
+ hist = b""
+ # -- calculating histogram --
+ width = len(format % (b"", b"", b""))
+ histwidth = max(2, max_width - width)
+ if maxdiff < histwidth:
+ hist = b"+" * insert[i] + b"-" * delete[i]
+ else:
+ iratio = (float(insert[i]) / maxdiff) * histwidth
+ dratio = (float(delete[i]) / maxdiff) * histwidth
+ iwidth = dwidth = 0
+ # make sure every entry that had actual insertions gets
+ # at least one +
+ if insert[i] > 0:
+ iwidth = int(iratio)
+ if iwidth == 0 and 0 < iratio < 1:
+ iwidth = 1
+ # make sure every entry that had actual deletions gets
+ # at least one -
+ if delete[i] > 0:
+ dwidth = int(dratio)
+ if dwidth == 0 and 0 < dratio < 1:
+ dwidth = 1
+ hist = b"+" * int(iwidth) + b"-" * int(dwidth)
+ output += format % (
+ bytes(names[i]),
+ str(insert[i] + delete[i]).encode("ascii"),
+ hist,
+ )
+ else:
+ output += binformat % (bytes(names[i]), b"Bin")
+
+ output += b" %d files changed, %d insertions(+), %d deletions(-)" % (
+ len(names),
+ sum(insert),
+ sum(delete),
+ )
+ return output
+
+
+def main():
+ argv = sys.argv
+ # allow diffstat.py to also be used from the command line
+ if len(sys.argv) > 1:
+ diffpath = argv[1]
+ data = b""
+ with open(diffpath, "rb") as f:
+ data = f.read()
+ lines = data.split(b"\n")
+ result = diffstat(lines)
+ print(result.decode("utf-8"))
+ return 0
+
+ # if no path argument to a diff file is passed in, run
+ # a self test. The test case includes tricky things like
+ # a diff of diff, binary files, renames with further changes
+ # added files and removed files.
+ # All extracted from Sigil-Ebook/Sigil's github repo with
+ # full permission to use under this license.
+ selftest = b"""
+diff --git a/docs/qt512.7_remove_bad_workaround.patch b/docs/qt512.7_remove_bad_workaround.patch
+new file mode 100644
+index 00000000..64e34192
+--- /dev/null
++++ b/docs/qt512.7_remove_bad_workaround.patch
+@@ -0,0 +1,15 @@
++--- qtbase/src/gui/kernel/qwindow.cpp.orig 2019-12-12 09:15:59.000000000 -0500
+++++ qtbase/src/gui/kernel/qwindow.cpp 2020-01-10 10:36:53.000000000 -0500
++@@ -218,12 +218,6 @@
++ QGuiApplicationPrivate::window_list.removeAll(this);
++ if (!QGuiApplicationPrivate::is_app_closing)
++ QGuiApplicationPrivate::instance()->modalWindowList.removeOne(this);
++-
++- // focus_window is normally cleared in destroy(), but the window may in
++- // some cases end up becoming the focus window again. Clear it again
++- // here as a workaround. See QTBUG-75326.
++- if (QGuiApplicationPrivate::focus_window == this)
++- QGuiApplicationPrivate::focus_window = 0;
++ }
++
++ void QWindowPrivate::init(QScreen *targetScreen)
+diff --git a/docs/testplugin_v017.zip b/docs/testplugin_v017.zip
+new file mode 100644
+index 00000000..a4cf4c4c
+Binary files /dev/null and b/docs/testplugin_v017.zip differ
+diff --git a/ci_scripts/macgddeploy.py b/ci_scripts/gddeploy.py
+similarity index 73%
+rename from ci_scripts/macgddeploy.py
+rename to ci_scripts/gddeploy.py
+index a512d075..f9dacd33 100644
+--- a/ci_scripts/macgddeploy.py
++++ b/ci_scripts/gddeploy.py
+@@ -1,19 +1,32 @@
+ #!/usr/bin/env python3
+
+ import os
++import sys
+ import subprocess
+ import datetime
+ import shutil
++import glob
+
+ gparent = os.path.expandvars('$GDRIVE_DIR')
+ grefresh_token = os.path.expandvars('$GDRIVE_REFRESH_TOKEN')
+
+-travis_branch = os.path.expandvars('$TRAVIS_BRANCH')
+-travis_commit = os.path.expandvars('$TRAVIS_COMMIT')
+-travis_build_number = os.path.expandvars('$TRAVIS_BUILD_NUMBER')
++if sys.platform.lower().startswith('darwin'):
++ travis_branch = os.path.expandvars('$TRAVIS_BRANCH')
++ travis_commit = os.path.expandvars('$TRAVIS_COMMIT')
++ travis_build_number = os.path.expandvars('$TRAVIS_BUILD_NUMBER')
++
++ origfilename = './bin/Sigil.tar.xz'
++ newfilename = './bin/Sigil-{}-{}-build_num-{}.tar.xz'.format(travis_branch, travis_commit[:7],travis_build_numbe\
+r)
++else:
++ appveyor_branch = os.path.expandvars('$APPVEYOR_REPO_BRANCH')
++ appveyor_commit = os.path.expandvars('$APPVEYOR_REPO_COMMIT')
++ appveyor_build_number = os.path.expandvars('$APPVEYOR_BUILD_NUMBER')
++ names = glob.glob('.\\installer\\Sigil-*-Setup.exe')
++ if not names:
++ exit(1)
++ origfilename = names[0]
++ newfilename = '.\\installer\\Sigil-{}-{}-build_num-{}-Setup.exe'.format(appveyor_branch, appveyor_commit[:7], ap\
+pveyor_build_number)
+
+-origfilename = './bin/Sigil.tar.xz'
+-newfilename = './bin/Sigil-{}-{}-build_num-{}.tar.xz'.format(travis_branch, travis_commit[:7],travis_build_number)
+ shutil.copy2(origfilename, newfilename)
+
+ folder_name = datetime.date.today()
+diff --git a/docs/qt512.6_backport_009abcd_fix.patch b/docs/qt512.6_backport_009abcd_fix.patch
+deleted file mode 100644
+index f4724347..00000000
+--- a/docs/qt512.6_backport_009abcd_fix.patch
++++ /dev/null
+@@ -1,26 +0,0 @@
+---- qtbase/src/widgets/kernel/qwidget.cpp.orig 2019-11-08 10:57:07.000000000 -0500
+-+++ qtbase/src/widgets/kernel/qwidget.cpp 2019-12-11 12:32:24.000000000 -0500
+-@@ -8934,6 +8934,23 @@
+- }
+- }
+- switch (event->type()) {
+-+ case QEvent::PlatformSurface: {
+-+ // Sync up QWidget's view of whether or not the widget has been created
+-+ switch (static_cast<QPlatformSurfaceEvent*>(event)->surfaceEventType()) {
+-+ case QPlatformSurfaceEvent::SurfaceCreated:
+-+ if (!testAttribute(Qt::WA_WState_Created))
+-+ create();
+-+ break;
+-+ case QPlatformSurfaceEvent::SurfaceAboutToBeDestroyed:
+-+ if (testAttribute(Qt::WA_WState_Created)) {
+-+ // Child windows have already been destroyed by QWindow,
+-+ // so we skip them here.
+-+ destroy(false, false);
+-+ }
+-+ break;
+-+ }
+-+ break;
+-+ }
+- case QEvent::MouseMove:
+- mouseMoveEvent((QMouseEvent*)event);
+- break;
+diff --git a/docs/Building_Sigil_On_MacOSX.txt b/docs/Building_Sigil_On_MacOSX.txt
+index 3b41fd80..64914c78 100644
+--- a/docs/Building_Sigil_On_MacOSX.txt
++++ b/docs/Building_Sigil_On_MacOSX.txt
+@@ -113,7 +113,7 @@ install_name_tool -add_rpath @loader_path/../../Frameworks ./bin/Sigil.app/Content
+
+ # To test if the newly bundled python 3 version of Sigil is working properly ypou can do the following:
+
+-1. download testplugin_v014.zip from https://github.com/Sigil-Ebook/Sigil/tree/master/docs
++1. download testplugin_v017.zip from https://github.com/Sigil-Ebook/Sigil/tree/master/docs
+ 2. open Sigil.app to the normal nearly blank template epub it generates when opened
+ 3. use Plugins->Manage Plugins menu and make sure the "Use Bundled Python" checkbox is checked
+ 4. use the "Add Plugin" button to navigate to and add testplugin.zip and then hit "Okay" to exit the Manage Plugins Dialog
+"""
+
+ testoutput = b""" docs/qt512.7_remove_bad_workaround.patch | 15 ++++++++++++
+ docs/testplugin_v017.zip | Bin
+ ci_scripts/macgddeploy.py => ci_scripts/gddeploy.py | 0
+ docs/qt512.6_backport_009abcd_fix.patch | 26 ---------------------
+ docs/Building_Sigil_On_MacOSX.txt | 2 +-
+ 5 files changed, 16 insertions(+), 27 deletions(-)"""
+
+ # return 0 on success otherwise return -1
+ result = diffstat(selftest.split(b"\n"))
+ if result == testoutput:
+ print("self test passed")
+ return 0
+ print("self test failed")
+ print("Received:")
+ print(result.decode("utf-8"))
+ print("Expected:")
+ print(testoutput.decode("utf-8"))
+ return -1
-if __name__ == '__main__':
+if __name__ == "__main__":
sys.exit(main())
diff --git a/dulwich/contrib/paramiko_vendor.py b/dulwich/contrib/paramiko_vendor.py
index 435df841..4d6da7f4 100644
--- a/dulwich/contrib/paramiko_vendor.py
+++ b/dulwich/contrib/paramiko_vendor.py
@@ -1,3 +1,23 @@
+# paramiko_vendor.py -- paramiko implementation of the SSHVendor interface
+# Copyright (C) 2013 Aaron O'Mullan <aaron.omullan@friendco.de>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Paramiko SSH support for Dulwich.
To use this implementation as the SSH implementation in Dulwich, override
@@ -9,19 +29,92 @@ the dulwich.client.get_ssh_vendor attribute:
This implementation is experimental and does not have any tests.
"""
+
import paramiko
import paramiko.client
class _ParamikoWrapper:
-
- def __init__(self, client, channel) ->None:
+ def __init__(self, client, channel) -> None:
self.client = client
self.channel = channel
+
+ # Channel must block
self.channel.setblocking(True)
+ @property
+ def stderr(self):
+ return self.channel.makefile_stderr("rb")
+
+ def can_read(self):
+ return self.channel.recv_ready()
+
+ def write(self, data):
+ return self.channel.sendall(data)
+
+ def read(self, n=None):
+ data = self.channel.recv(n)
+ data_len = len(data)
+
+ # Closed socket
+ if not data:
+ return b""
+
+ # Read more if needed
+ if n and data_len < n:
+ diff_len = n - data_len
+ return data + self.read(diff_len)
+ return data
+
+ def close(self):
+ self.channel.close()
+
class ParamikoSSHVendor:
+ # http://docs.paramiko.org/en/2.4/api/client.html
- def __init__(self, **kwargs) ->None:
+ def __init__(self, **kwargs) -> None:
self.kwargs = kwargs
+
+ def run_command(
+ self,
+ host,
+ command,
+ username=None,
+ port=None,
+ password=None,
+ pkey=None,
+ key_filename=None,
+ protocol_version=None,
+ **kwargs,
+ ):
+ client = paramiko.SSHClient()
+
+ connection_kwargs = {"hostname": host}
+ connection_kwargs.update(self.kwargs)
+ if username:
+ connection_kwargs["username"] = username
+ if port:
+ connection_kwargs["port"] = port
+ if password:
+ connection_kwargs["password"] = password
+ if pkey:
+ connection_kwargs["pkey"] = pkey
+ if key_filename:
+ connection_kwargs["key_filename"] = key_filename
+ connection_kwargs.update(kwargs)
+
+ policy = paramiko.client.MissingHostKeyPolicy()
+ client.set_missing_host_key_policy(policy)
+ client.connect(**connection_kwargs)
+
+ # Open SSH session
+ channel = client.get_transport().open_session()
+
+ if protocol_version is None or protocol_version == 2:
+ channel.set_environment_variable(name="GIT_PROTOCOL", value="version=2")
+
+ # Run commands
+ channel.exec_command(command)
+
+ return _ParamikoWrapper(client, channel)
diff --git a/dulwich/contrib/release_robot.py b/dulwich/contrib/release_robot.py
index 3b1d8a46..fc3eefdc 100644
--- a/dulwich/contrib/release_robot.py
+++ b/dulwich/contrib/release_robot.py
@@ -1,3 +1,22 @@
+# release_robot.py
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Determine last version string from tags.
Alternate to `Versioneer <https://pypi.python.org/pypi/versioneer/>`_ using
@@ -24,13 +43,17 @@ EG::
"""
+
import datetime
import re
import sys
import time
+
from ..repo import Repo
-PROJDIR = '.'
-PATTERN = '[ a-zA-Z_\\-]*([\\d\\.]+[\\-\\w\\.]*)'
+
+# CONSTANTS
+PROJDIR = "."
+PATTERN = r"[ a-zA-Z_\-]*([\d\.]+[\-\w\.]*)"
def get_recent_tags(projdir=PROJDIR):
@@ -46,7 +69,45 @@ def get_recent_tags(projdir=PROJDIR):
Otherwise the tag meta is a tuple containing the tag time, tag id and tag
name. Time is in UTC.
"""
- pass
+ with Repo(projdir) as project: # dulwich repository object
+ refs = project.get_refs() # dictionary of refs and their SHA-1 values
+ tags = {} # empty dictionary to hold tags, commits and datetimes
+ # iterate over refs in repository
+ for key, value in refs.items():
+ key = key.decode("utf-8") # compatible with Python-3
+ obj = project.get_object(value) # dulwich object from SHA-1
+ # don't just check if object is "tag" b/c it could be a "commit"
+ # instead check if "tags" is in the ref-name
+ if "tags" not in key:
+ # skip ref if not a tag
+ continue
+ # strip the leading text from refs to get "tag name"
+ _, tag = key.rsplit("/", 1)
+ # check if tag object is "commit" or "tag" pointing to a "commit"
+ try:
+ commit = obj.object # a tuple (commit class, commit id)
+ except AttributeError:
+ commit = obj
+ tag_meta = None
+ else:
+ tag_meta = (
+ datetime.datetime(*time.gmtime(obj.tag_time)[:6]),
+ obj.id.decode("utf-8"),
+ obj.name.decode("utf-8"),
+ ) # compatible with Python-3
+ commit = project.get_object(commit[1]) # commit object
+ # get tag commit datetime, but dulwich returns seconds since
+ # beginning of epoch, so use Python time module to convert it to
+ # timetuple then convert to datetime
+ tags[tag] = [
+ datetime.datetime(*time.gmtime(commit.commit_time)[:6]),
+ commit.id.decode("utf-8"),
+ commit.author.decode("utf-8"),
+ tag_meta,
+ ] # compatible with Python-3
+
+ # return list of tags sorted by their datetimes from newest to oldest
+ return sorted(tags.items(), key=lambda tag: tag[1][0], reverse=True)
def get_current_version(projdir=PROJDIR, pattern=PATTERN, logger=None):
@@ -63,10 +124,22 @@ def get_current_version(projdir=PROJDIR, pattern=PATTERN, logger=None):
Returns:
tag matching first group in regular expression pattern
"""
- pass
-
-
-if __name__ == '__main__':
+ tags = get_recent_tags(projdir)
+ try:
+ tag = tags[0][0]
+ except IndexError:
+ return
+ matches = re.match(pattern, tag)
+ try:
+ current_version = matches.group(1)
+ except (IndexError, AttributeError) as err:
+ if logger:
+ logger.exception(err)
+ return tag
+ return current_version
+
+
+if __name__ == "__main__":
if len(sys.argv) > 1:
_PROJDIR = sys.argv[1]
else:
diff --git a/dulwich/contrib/requests_vendor.py b/dulwich/contrib/requests_vendor.py
index fd2439dc..b556f314 100644
--- a/dulwich/contrib/requests_vendor.py
+++ b/dulwich/contrib/requests_vendor.py
@@ -1,3 +1,23 @@
+# requests_vendor.py -- requests implementation of the AbstractHttpGitClient interface
+# Copyright (C) 2022 Eden Shalit <epopcop@gmail.com>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+
+
"""Requests HTTP client support for Dulwich.
To use this implementation as the HTTP implementation in Dulwich, override
@@ -9,19 +29,113 @@ the dulwich.client.HttpGitClient attribute:
This implementation is experimental and does not have any tests.
"""
+
from io import BytesIO
+
from requests import Session
-from ..client import AbstractHttpGitClient, HTTPProxyUnauthorized, HTTPUnauthorized, default_user_agent_string
+
+from ..client import (
+ AbstractHttpGitClient,
+ HTTPProxyUnauthorized,
+ HTTPUnauthorized,
+ default_user_agent_string,
+)
from ..errors import GitProtocolError, NotGitRepository
class RequestsHttpGitClient(AbstractHttpGitClient):
-
- def __init__(self, base_url, dumb=None, config=None, username=None,
- password=None, **kwargs) ->None:
+ def __init__(
+ self, base_url, dumb=None, config=None, username=None, password=None, **kwargs
+ ) -> None:
self._username = username
self._password = password
+
self.session = get_session(config)
+
if username is not None:
- self.session.auth = username, password
+ self.session.auth = (username, password)
+
super().__init__(base_url=base_url, dumb=dumb, **kwargs)
+
+ def _http_request(self, url, headers=None, data=None, allow_compression=False):
+ req_headers = self.session.headers.copy()
+ if headers is not None:
+ req_headers.update(headers)
+
+ if allow_compression:
+ req_headers["Accept-Encoding"] = "gzip"
+ else:
+ req_headers["Accept-Encoding"] = "identity"
+
+ if data:
+ resp = self.session.post(url, headers=req_headers, data=data)
+ else:
+ resp = self.session.get(url, headers=req_headers)
+
+ if resp.status_code == 404:
+ raise NotGitRepository
+ if resp.status_code == 401:
+ raise HTTPUnauthorized(resp.headers.get("WWW-Authenticate"), url)
+ if resp.status_code == 407:
+ raise HTTPProxyUnauthorized(resp.headers.get("Proxy-Authenticate"), url)
+ if resp.status_code != 200:
+ raise GitProtocolError(
+ "unexpected http resp %d for %s" % (resp.status_code, url)
+ )
+
+ # Add required fields as stated in AbstractHttpGitClient._http_request
+ resp.content_type = resp.headers.get("Content-Type")
+ resp.redirect_location = ""
+ if resp.history:
+ resp.redirect_location = resp.url
+
+ read = BytesIO(resp.content).read
+
+ return resp, read
+
+
+def get_session(config):
+ session = Session()
+ session.headers.update({"Pragma": "no-cache"})
+
+ proxy_server = user_agent = ca_certs = ssl_verify = None
+
+ if config is not None:
+ try:
+ proxy_server = config.get(b"http", b"proxy")
+ if isinstance(proxy_server, bytes):
+ proxy_server = proxy_server.decode()
+ except KeyError:
+ pass
+
+ try:
+ user_agent = config.get(b"http", b"useragent")
+ if isinstance(user_agent, bytes):
+ user_agent = user_agent.decode()
+ except KeyError:
+ pass
+
+ try:
+ ssl_verify = config.get_boolean(b"http", b"sslVerify")
+ except KeyError:
+ ssl_verify = True
+
+ try:
+ ca_certs = config.get(b"http", b"sslCAInfo")
+ if isinstance(ca_certs, bytes):
+ ca_certs = ca_certs.decode()
+ except KeyError:
+ ca_certs = None
+
+ if user_agent is None:
+ user_agent = default_user_agent_string()
+ session.headers.update({"User-agent": user_agent})
+
+ if ca_certs:
+ session.verify = ca_certs
+ elif ssl_verify is False:
+ session.verify = ssl_verify
+
+ if proxy_server:
+ session.proxies.update({"http": proxy_server, "https": proxy_server})
+ return session
diff --git a/dulwich/contrib/swift.py b/dulwich/contrib/swift.py
index cca06a4e..57887ceb 100644
--- a/dulwich/contrib/swift.py
+++ b/dulwich/contrib/swift.py
@@ -1,4 +1,31 @@
+# swift.py -- Repo implementation atop OpenStack SWIFT
+# Copyright (C) 2013 eNovance SAS <licensing@enovance.com>
+#
+# Author: Fabien Boucher <fabien.boucher@enovance.com>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Repo implementation atop OpenStack SWIFT."""
+
+# TODO: Refactor to share more code with dulwich/repo.py.
+# TODO(fbo): Second attempt to _send() must be notified via real log
+# TODO(fbo): More logs for operations
+
import json
import os
import posixpath
@@ -9,16 +36,33 @@ import urllib.parse as urlparse
import zlib
from configparser import ConfigParser
from io import BytesIO
+
from geventhttpclient import HTTPClient
+
from ..greenthreads import GreenThreadsMissingObjectFinder
from ..lru_cache import LRUSizeCache
from ..object_store import INFODIR, PACKDIR, PackBasedObjectStore
from ..objects import S_ISGITLINK, Blob, Commit, Tag, Tree
-from ..pack import Pack, PackData, PackIndexer, PackStreamCopier, _compute_object_size, compute_file_sha, iter_sha1, load_pack_index_file, read_pack_header, unpack_object, write_pack_header, write_pack_index_v2, write_pack_object
+from ..pack import (
+ Pack,
+ PackData,
+ PackIndexer,
+ PackStreamCopier,
+ _compute_object_size,
+ compute_file_sha,
+ iter_sha1,
+ load_pack_index_file,
+ read_pack_header,
+ unpack_object,
+ write_pack_header,
+ write_pack_index_v2,
+ write_pack_object,
+)
from ..protocol import TCP_GIT_PORT
from ..refs import InfoRefsContainer, read_info_refs, write_info_refs
from ..repo import OBJECTDIR, BaseRepo
from ..server import Backend, TCPGitServer
+
"""
# Configuration file sample
[swift]
@@ -48,7 +92,26 @@ cache_length = 20
class PackInfoMissingObjectFinder(GreenThreadsMissingObjectFinder):
- pass
+ def next(self):
+ while True:
+ if not self.objects_to_send:
+ return None
+ (sha, name, leaf) = self.objects_to_send.pop()
+ if sha not in self.sha_done:
+ break
+ if not leaf:
+ info = self.object_store.pack_info_get(sha)
+ if info[0] == Commit.type_num:
+ self.add_todo([(info[2], "", False)])
+ elif info[0] == Tree.type_num:
+ self.add_todo([tuple(i) for i in info[1]])
+ elif info[0] == Tag.type_num:
+ self.add_todo([(info[1], None, False)])
+ if sha in self._tagged:
+ self.add_todo([(self._tagged[sha], None, True)])
+ self.sha_done.add(sha)
+ self.progress("counting objects: %d\r" % len(self.sha_done))
+ return (sha, name)
def load_conf(path=None, file=None):
@@ -58,7 +121,26 @@ def load_conf(path=None, file=None):
path: The path to the configuration file
file: If provided read instead the file like object
"""
- pass
+ conf = ConfigParser()
+ if file:
+ try:
+ conf.read_file(file, path)
+ except AttributeError:
+ # read_file only exists in Python3
+ conf.readfp(file)
+ return conf
+ confpath = None
+ if not path:
+ try:
+ confpath = os.environ["DULWICH_SWIFT_CFG"]
+ except KeyError as exc:
+ raise Exception("You need to specify a configuration file") from exc
+ else:
+ confpath = path
+ if not os.path.isfile(confpath):
+ raise Exception(f"Unable to read configuration file {confpath}")
+ conf.read(confpath)
+ return conf
def swift_load_pack_index(scon, filename):
@@ -69,7 +151,45 @@ def swift_load_pack_index(scon, filename):
filename: Path to the index file objectise
Returns: a `PackIndexer` instance
"""
- pass
+ with scon.get_object(filename) as f:
+ return load_pack_index_file(filename, f)
+
+
+def pack_info_create(pack_data, pack_index):
+ pack = Pack.from_objects(pack_data, pack_index)
+ info = {}
+ for obj in pack.iterobjects():
+ # Commit
+ if obj.type_num == Commit.type_num:
+ info[obj.id] = (obj.type_num, obj.parents, obj.tree)
+ # Tree
+ elif obj.type_num == Tree.type_num:
+ shas = [
+ (s, n, not stat.S_ISDIR(m))
+ for n, m, s in obj.items()
+ if not S_ISGITLINK(m)
+ ]
+ info[obj.id] = (obj.type_num, shas)
+ # Blob
+ elif obj.type_num == Blob.type_num:
+ info[obj.id] = None
+ # Tag
+ elif obj.type_num == Tag.type_num:
+ info[obj.id] = (obj.type_num, obj.object[1])
+ return zlib.compress(json.dumps(info))
+
+
+def load_pack_info(filename, scon=None, file=None):
+ if not file:
+ f = scon.get_object(filename)
+ else:
+ f = file
+ if not f:
+ return None
+ try:
+ return json.loads(zlib.decompress(f.read()))
+ finally:
+ f.close()
class SwiftException(Exception):
@@ -79,7 +199,7 @@ class SwiftException(Exception):
class SwiftConnector:
"""A Connector to swift that manage authentication and errors catching."""
- def __init__(self, root, conf) ->None:
+ def __init__(self, root, conf) -> None:
"""Initialize a SwiftConnector.
Args:
@@ -87,42 +207,114 @@ class SwiftConnector:
conf: A ConfigParser Object
"""
self.conf = conf
- self.auth_ver = self.conf.get('swift', 'auth_ver')
- if self.auth_ver not in ['1', '2']:
- raise NotImplementedError(
- 'Wrong authentication version use either 1 or 2')
- self.auth_url = self.conf.get('swift', 'auth_url')
- self.user = self.conf.get('swift', 'username')
- self.password = self.conf.get('swift', 'password')
- self.concurrency = self.conf.getint('swift', 'concurrency') or 10
- self.http_timeout = self.conf.getint('swift', 'http_timeout') or 20
- self.http_pool_length = self.conf.getint('swift', 'http_pool_length'
- ) or 10
- self.region_name = self.conf.get('swift', 'region_name') or 'RegionOne'
- self.endpoint_type = self.conf.get('swift', 'endpoint_type'
- ) or 'internalURL'
- self.cache_length = self.conf.getint('swift', 'cache_length') or 20
- self.chunk_length = self.conf.getint('swift', 'chunk_length') or 12228
+ self.auth_ver = self.conf.get("swift", "auth_ver")
+ if self.auth_ver not in ["1", "2"]:
+ raise NotImplementedError("Wrong authentication version use either 1 or 2")
+ self.auth_url = self.conf.get("swift", "auth_url")
+ self.user = self.conf.get("swift", "username")
+ self.password = self.conf.get("swift", "password")
+ self.concurrency = self.conf.getint("swift", "concurrency") or 10
+ self.http_timeout = self.conf.getint("swift", "http_timeout") or 20
+ self.http_pool_length = self.conf.getint("swift", "http_pool_length") or 10
+ self.region_name = self.conf.get("swift", "region_name") or "RegionOne"
+ self.endpoint_type = self.conf.get("swift", "endpoint_type") or "internalURL"
+ self.cache_length = self.conf.getint("swift", "cache_length") or 20
+ self.chunk_length = self.conf.getint("swift", "chunk_length") or 12228
self.root = root
- block_size = 1024 * 12
- if self.auth_ver == '1':
+ block_size = 1024 * 12 # 12KB
+ if self.auth_ver == "1":
self.storage_url, self.token = self.swift_auth_v1()
else:
self.storage_url, self.token = self.swift_auth_v2()
- token_header = {'X-Auth-Token': str(self.token)}
- self.httpclient = HTTPClient.from_url(str(self.storage_url),
- concurrency=self.http_pool_length, block_size=block_size,
- connection_timeout=self.http_timeout, network_timeout=self.
- http_timeout, headers=token_header)
- self.base_path = str(posixpath.join(urlparse.urlparse(self.
- storage_url).path, self.root))
+
+ token_header = {"X-Auth-Token": str(self.token)}
+ self.httpclient = HTTPClient.from_url(
+ str(self.storage_url),
+ concurrency=self.http_pool_length,
+ block_size=block_size,
+ connection_timeout=self.http_timeout,
+ network_timeout=self.http_timeout,
+ headers=token_header,
+ )
+ self.base_path = str(
+ posixpath.join(urlparse.urlparse(self.storage_url).path, self.root)
+ )
+
+ def swift_auth_v1(self):
+ self.user = self.user.replace(";", ":")
+ auth_httpclient = HTTPClient.from_url(
+ self.auth_url,
+ connection_timeout=self.http_timeout,
+ network_timeout=self.http_timeout,
+ )
+ headers = {"X-Auth-User": self.user, "X-Auth-Key": self.password}
+ path = urlparse.urlparse(self.auth_url).path
+
+ ret = auth_httpclient.request("GET", path, headers=headers)
+
+ # Should do something with redirections (301 in my case)
+
+ if ret.status_code < 200 or ret.status_code >= 300:
+ raise SwiftException(
+ "AUTH v1.0 request failed on "
+ + f"{self.auth_url} with error code {ret.status_code} ({ret.items()!s})"
+ )
+ storage_url = ret["X-Storage-Url"]
+ token = ret["X-Auth-Token"]
+ return storage_url, token
+
+ def swift_auth_v2(self):
+ self.tenant, self.user = self.user.split(";")
+ auth_dict = {}
+ auth_dict["auth"] = {
+ "passwordCredentials": {
+ "username": self.user,
+ "password": self.password,
+ },
+ "tenantName": self.tenant,
+ }
+ auth_json = json.dumps(auth_dict)
+ headers = {"Content-Type": "application/json"}
+ auth_httpclient = HTTPClient.from_url(
+ self.auth_url,
+ connection_timeout=self.http_timeout,
+ network_timeout=self.http_timeout,
+ )
+ path = urlparse.urlparse(self.auth_url).path
+ if not path.endswith("tokens"):
+ path = posixpath.join(path, "tokens")
+ ret = auth_httpclient.request("POST", path, body=auth_json, headers=headers)
+
+ if ret.status_code < 200 or ret.status_code >= 300:
+ raise SwiftException(
+ "AUTH v2.0 request failed on "
+ + f"{str(auth_httpclient.get_base_url()) + path} with error code {ret.status_code} ({ret.items()!s})"
+ )
+ auth_ret_json = json.loads(ret.read())
+ token = auth_ret_json["access"]["token"]["id"]
+ catalogs = auth_ret_json["access"]["serviceCatalog"]
+ object_store = next(
+ o_store for o_store in catalogs if o_store["type"] == "object-store"
+ )
+ endpoints = object_store["endpoints"]
+ endpoint = next(
+ endp for endp in endpoints if endp["region"] == self.region_name
+ )
+ return endpoint[self.endpoint_type], token
def test_root_exists(self):
"""Check that Swift container exist.
Returns: True if exist or None it not
"""
- pass
+ ret = self.httpclient.request("HEAD", self.base_path)
+ if ret.status_code == 404:
+ return None
+ if ret.status_code < 200 or ret.status_code > 300:
+ raise SwiftException(
+ f"HEAD request failed with error code {ret.status_code}"
+ )
+ return True
def create_root(self):
"""Create the Swift container.
@@ -130,7 +322,12 @@ class SwiftConnector:
Raises:
SwiftException: if unable to create
"""
- pass
+ if not self.test_root_exists():
+ ret = self.httpclient.request("PUT", self.base_path)
+ if ret.status_code < 200 or ret.status_code > 300:
+ raise SwiftException(
+ f"PUT request failed with error code {ret.status_code}"
+ )
def get_container_objects(self):
"""Retrieve objects list in a container.
@@ -138,7 +335,17 @@ class SwiftConnector:
Returns: A list of dict that describe objects
or None if container does not exist
"""
- pass
+ qs = "?format=json"
+ path = self.base_path + qs
+ ret = self.httpclient.request("GET", path)
+ if ret.status_code == 404:
+ return None
+ if ret.status_code < 200 or ret.status_code > 300:
+ raise SwiftException(
+ f"GET request failed with error code {ret.status_code}"
+ )
+ content = ret.read()
+ return json.loads(content)
def get_object_stat(self, name):
"""Retrieve object stat.
@@ -148,7 +355,18 @@ class SwiftConnector:
Returns:
A dict that describe the object or None if object does not exist
"""
- pass
+ path = self.base_path + "/" + name
+ ret = self.httpclient.request("HEAD", path)
+ if ret.status_code == 404:
+ return None
+ if ret.status_code < 200 or ret.status_code > 300:
+ raise SwiftException(
+ f"HEAD request failed with error code {ret.status_code}"
+ )
+ resp_headers = {}
+ for header, value in ret.items():
+ resp_headers[header.lower()] = value
+ return resp_headers
def put_object(self, name, content):
"""Put an object.
@@ -159,7 +377,26 @@ class SwiftConnector:
Raises:
SwiftException: if unable to create
"""
- pass
+ content.seek(0)
+ data = content.read()
+ path = self.base_path + "/" + name
+ headers = {"Content-Length": str(len(data))}
+
+ def _send():
+ ret = self.httpclient.request("PUT", path, body=data, headers=headers)
+ return ret
+
+ try:
+ # Sometime got Broken Pipe - Dirty workaround
+ ret = _send()
+ except Exception:
+ # Second attempt work
+ ret = _send()
+
+ if ret.status_code < 200 or ret.status_code > 300:
+ raise SwiftException(
+ f"PUT request failed with error code {ret.status_code}"
+ )
def get_object(self, name, range=None):
"""Retrieve an object.
@@ -171,7 +408,22 @@ class SwiftConnector:
Returns:
A file like instance or bytestring if range is specified
"""
- pass
+ headers = {}
+ if range:
+ headers["Range"] = f"bytes={range}"
+ path = self.base_path + "/" + name
+ ret = self.httpclient.request("GET", path, headers=headers)
+ if ret.status_code == 404:
+ return None
+ if ret.status_code < 200 or ret.status_code > 300:
+ raise SwiftException(
+ f"GET request failed with error code {ret.status_code}"
+ )
+ content = ret.read()
+
+ if range:
+ return content
+ return BytesIO(content)
def del_object(self, name):
"""Delete an object.
@@ -181,7 +433,12 @@ class SwiftConnector:
Raises:
SwiftException: if unable to delete
"""
- pass
+ path = self.base_path + "/" + name
+ ret = self.httpclient.request("DELETE", path)
+ if ret.status_code < 200 or ret.status_code > 300:
+ raise SwiftException(
+ f"DELETE request failed with error code {ret.status_code}"
+ )
def del_root(self):
"""Delete the root container by removing container content.
@@ -189,7 +446,13 @@ class SwiftConnector:
Raises:
SwiftException: if unable to delete
"""
- pass
+ for obj in self.get_container_objects():
+ self.del_object(obj["name"])
+ ret = self.httpclient.request("DELETE", self.base_path)
+ if ret.status_code < 200 or ret.status_code > 300:
+ raise SwiftException(
+ f"DELETE request failed with error code {ret.status_code}"
+ )
class SwiftPackReader:
@@ -202,7 +465,7 @@ class SwiftPackReader:
to read from Swift.
"""
- def __init__(self, scon, filename, pack_length) ->None:
+ def __init__(self, scon, filename, pack_length) -> None:
"""Initialize a SwiftPackReader.
Args:
@@ -215,9 +478,17 @@ class SwiftPackReader:
self.pack_length = pack_length
self.offset = 0
self.base_offset = 0
- self.buff = b''
+ self.buff = b""
self.buff_length = self.scon.chunk_length
+ def _read(self, more=False):
+ if more:
+ self.buff_length = self.buff_length * 2
+ offset = self.base_offset
+ r = min(self.base_offset + self.buff_length, self.pack_length)
+ ret = self.scon.get_object(self.filename, range=f"{offset}-{r}")
+ self.buff = ret
+
def read(self, length):
"""Read a specified amount of Bytes form the pack object.
@@ -226,7 +497,18 @@ class SwiftPackReader:
Returns:
a bytestring
"""
- pass
+ end = self.offset + length
+ if self.base_offset + end > self.pack_length:
+ data = self.buff[self.offset :]
+ self.offset = end
+ return data
+ if end > len(self.buff):
+ # Need to read more from swift
+ self._read(more=True)
+ return self.read(length)
+ data = self.buff[self.offset : end]
+ self.offset = end
+ return data
def seek(self, offset):
"""Seek to a specified offset.
@@ -234,14 +516,16 @@ class SwiftPackReader:
Args:
offset: the offset to seek to
"""
- pass
+ self.base_offset = offset
+ self._read()
+ self.offset = 0
def read_checksum(self):
"""Read the checksum from the pack.
Returns: the checksum bytestring
"""
- pass
+ return self.scon.get_object(self.filename, range="-20")
class SwiftPackData(PackData):
@@ -251,7 +535,7 @@ class SwiftPackData(PackData):
using the Range header feature of Swift.
"""
- def __init__(self, scon, filename) ->None:
+ def __init__(self, scon, filename) -> None:
"""Initialize a SwiftPackReader.
Args:
@@ -262,14 +546,31 @@ class SwiftPackData(PackData):
self._filename = filename
self._header_size = 12
headers = self.scon.get_object_stat(self._filename)
- self.pack_length = int(headers['content-length'])
- pack_reader = SwiftPackReader(self.scon, self._filename, self.
- pack_length)
- version, self._num_objects = read_pack_header(pack_reader.read)
- self._offset_cache = LRUSizeCache(1024 * 1024 * self.scon.
- cache_length, compute_size=_compute_object_size)
+ self.pack_length = int(headers["content-length"])
+ pack_reader = SwiftPackReader(self.scon, self._filename, self.pack_length)
+ (version, self._num_objects) = read_pack_header(pack_reader.read)
+ self._offset_cache = LRUSizeCache(
+ 1024 * 1024 * self.scon.cache_length,
+ compute_size=_compute_object_size,
+ )
self.pack = None
+ def get_object_at(self, offset):
+ if offset in self._offset_cache:
+ return self._offset_cache[offset]
+ assert offset >= self._header_size
+ pack_reader = SwiftPackReader(self.scon, self._filename, self.pack_length)
+ pack_reader.seek(offset)
+ unpacked, _ = unpack_object(pack_reader.read)
+ return (unpacked.pack_type_num, unpacked._obj())
+
+ def get_stored_checksum(self):
+ pack_reader = SwiftPackReader(self.scon, self._filename, self.pack_length)
+ return pack_reader.read_checksum()
+
+ def close(self):
+ pass
+
class SwiftPack(Pack):
"""A Git pack object.
@@ -279,22 +580,22 @@ class SwiftPack(Pack):
PackData.
"""
- def __init__(self, *args, **kwargs) ->None:
- self.scon = kwargs['scon']
- del kwargs['scon']
+ def __init__(self, *args, **kwargs) -> None:
+ self.scon = kwargs["scon"]
+ del kwargs["scon"]
super().__init__(*args, **kwargs)
- self._pack_info_path = self._basename + '.info'
+ self._pack_info_path = self._basename + ".info"
self._pack_info = None
- self._pack_info_load = lambda : load_pack_info(self._pack_info_path,
- self.scon)
- self._idx_load = lambda : swift_load_pack_index(self.scon, self.
- _idx_path)
- self._data_load = lambda : SwiftPackData(self.scon, self._data_path)
+ self._pack_info_load = lambda: load_pack_info(self._pack_info_path, self.scon)
+ self._idx_load = lambda: swift_load_pack_index(self.scon, self._idx_path)
+ self._data_load = lambda: SwiftPackData(self.scon, self._data_path)
@property
def pack_info(self):
"""The pack data object being used."""
- pass
+ if self._pack_info is None:
+ self._pack_info = self._pack_info_load()
+ return self._pack_info
class SwiftObjectStore(PackBasedObjectStore):
@@ -304,7 +605,7 @@ class SwiftObjectStore(PackBasedObjectStore):
This object store only supports pack files and not loose objects.
"""
- def __init__(self, scon) ->None:
+ def __init__(self, scon) -> None:
"""Open a Swift object store.
Args:
@@ -316,9 +617,53 @@ class SwiftObjectStore(PackBasedObjectStore):
self.pack_dir = posixpath.join(OBJECTDIR, PACKDIR)
self._alternates = None
+ def _update_pack_cache(self):
+ objects = self.scon.get_container_objects()
+ pack_files = [
+ o["name"].replace(".pack", "")
+ for o in objects
+ if o["name"].endswith(".pack")
+ ]
+ ret = []
+ for basename in pack_files:
+ pack = SwiftPack(basename, scon=self.scon)
+ self._pack_cache[basename] = pack
+ ret.append(pack)
+ return ret
+
def _iter_loose_objects(self):
"""Loose objects are not supported by this repository."""
- pass
+ return []
+
+ def pack_info_get(self, sha):
+ for pack in self.packs:
+ if sha in pack:
+ return pack.pack_info[sha]
+
+ def _collect_ancestors(self, heads, common=set()):
+ def _find_parents(commit):
+ for pack in self.packs:
+ if commit in pack:
+ try:
+ parents = pack.pack_info[commit][1]
+ except KeyError:
+ # Seems to have no parents
+ return []
+ return parents
+
+ bases = set()
+ commits = set()
+ queue = []
+ queue.extend(heads)
+ while queue:
+ e = queue.pop(0)
+ if e in common:
+ bases.add(e)
+ elif e not in commits:
+ commits.add(e)
+ parents = _find_parents(e)
+ queue.extend(parents)
+ return (commits, bases)
def add_pack(self):
"""Add a new pack to this object store.
@@ -326,7 +671,47 @@ class SwiftObjectStore(PackBasedObjectStore):
Returns: Fileobject to write to and a commit function to
call when the pack is finished.
"""
- pass
+ f = BytesIO()
+
+ def commit():
+ f.seek(0)
+ pack = PackData(file=f, filename="")
+ entries = pack.sorted_entries()
+ if entries:
+ basename = posixpath.join(
+ self.pack_dir,
+ f"pack-{iter_sha1(entry[0] for entry in entries)}",
+ )
+ index = BytesIO()
+ write_pack_index_v2(index, entries, pack.get_stored_checksum())
+ self.scon.put_object(basename + ".pack", f)
+ f.close()
+ self.scon.put_object(basename + ".idx", index)
+ index.close()
+ final_pack = SwiftPack(basename, scon=self.scon)
+ final_pack.check_length_and_checksum()
+ self._add_cached_pack(basename, final_pack)
+ return final_pack
+ else:
+ return None
+
+ def abort():
+ pass
+
+ return f, commit, abort
+
+ def add_object(self, obj):
+ self.add_objects(
+ [
+ (obj, None),
+ ]
+ )
+
+ def _pack_cache_stale(self):
+ return False
+
+ def _get_loose_object(self, sha):
+ return None
def add_thin_pack(self, read_all, read_some):
"""Read a thin pack.
@@ -334,33 +719,140 @@ class SwiftObjectStore(PackBasedObjectStore):
Read it from a stream and complete it in a temporary file.
Then the pack and the corresponding index file are uploaded to Swift.
"""
- pass
+ fd, path = tempfile.mkstemp(prefix="tmp_pack_")
+ f = os.fdopen(fd, "w+b")
+ try:
+ indexer = PackIndexer(f, resolve_ext_ref=self.get_raw)
+ copier = PackStreamCopier(read_all, read_some, f, delta_iter=indexer)
+ copier.verify()
+ return self._complete_thin_pack(f, path, copier, indexer)
+ finally:
+ f.close()
+ os.unlink(path)
+
+ def _complete_thin_pack(self, f, path, copier, indexer):
+ entries = list(indexer)
+
+ # Update the header with the new number of objects.
+ f.seek(0)
+ write_pack_header(f, len(entries) + len(indexer.ext_refs()))
+
+ # Must flush before reading (http://bugs.python.org/issue3207)
+ f.flush()
+
+ # Rescan the rest of the pack, computing the SHA with the new header.
+ new_sha = compute_file_sha(f, end_ofs=-20)
+
+ # Must reposition before writing (http://bugs.python.org/issue3207)
+ f.seek(0, os.SEEK_CUR)
+
+ # Complete the pack.
+ for ext_sha in indexer.ext_refs():
+ assert len(ext_sha) == 20
+ type_num, data = self.get_raw(ext_sha)
+ offset = f.tell()
+ crc32 = write_pack_object(f, type_num, data, sha=new_sha)
+ entries.append((ext_sha, offset, crc32))
+ pack_sha = new_sha.digest()
+ f.write(pack_sha)
+ f.flush()
+
+ # Move the pack in.
+ entries.sort()
+ pack_base_name = posixpath.join(
+ self.pack_dir,
+ "pack-" + os.fsdecode(iter_sha1(e[0] for e in entries)),
+ )
+ self.scon.put_object(pack_base_name + ".pack", f)
+
+ # Write the index.
+ filename = pack_base_name + ".idx"
+ index_file = BytesIO()
+ write_pack_index_v2(index_file, entries, pack_sha)
+ self.scon.put_object(filename, index_file)
+
+ # Write pack info.
+ f.seek(0)
+ pack_data = PackData(filename="", file=f)
+ index_file.seek(0)
+ pack_index = load_pack_index_file("", index_file)
+ serialized_pack_info = pack_info_create(pack_data, pack_index)
+ f.close()
+ index_file.close()
+ pack_info_file = BytesIO(serialized_pack_info)
+ filename = pack_base_name + ".info"
+ self.scon.put_object(filename, pack_info_file)
+ pack_info_file.close()
+
+ # Add the pack to the store and return it.
+ final_pack = SwiftPack(pack_base_name, scon=self.scon)
+ final_pack.check_length_and_checksum()
+ self._add_cached_pack(pack_base_name, final_pack)
+ return final_pack
class SwiftInfoRefsContainer(InfoRefsContainer):
"""Manage references in info/refs object."""
- def __init__(self, scon, store) ->None:
+ def __init__(self, scon, store) -> None:
self.scon = scon
- self.filename = 'info/refs'
+ self.filename = "info/refs"
self.store = store
f = self.scon.get_object(self.filename)
if not f:
- f = BytesIO(b'')
+ f = BytesIO(b"")
super().__init__(f)
+ def _load_check_ref(self, name, old_ref):
+ self._check_refname(name)
+ f = self.scon.get_object(self.filename)
+ if not f:
+ return {}
+ refs = read_info_refs(f)
+ if old_ref is not None:
+ if refs[name] != old_ref:
+ return False
+ return refs
+
+ def _write_refs(self, refs):
+ f = BytesIO()
+ f.writelines(write_info_refs(refs, self.store))
+ self.scon.put_object(self.filename, f)
+
def set_if_equals(self, name, old_ref, new_ref):
"""Set a refname to new_ref only if it currently equals old_ref."""
- pass
+ if name == "HEAD":
+ return True
+ refs = self._load_check_ref(name, old_ref)
+ if not isinstance(refs, dict):
+ return False
+ refs[name] = new_ref
+ self._write_refs(refs)
+ self._refs[name] = new_ref
+ return True
def remove_if_equals(self, name, old_ref):
"""Remove a refname only if it currently equals old_ref."""
- pass
+ if name == "HEAD":
+ return True
+ refs = self._load_check_ref(name, old_ref)
+ if not isinstance(refs, dict):
+ return False
+ del refs[name]
+ self._write_refs(refs)
+ del self._refs[name]
+ return True
+
+ def allkeys(self):
+ try:
+ self._refs["HEAD"] = self._refs["refs/heads/master"]
+ except KeyError:
+ pass
+ return self._refs.keys()
class SwiftRepo(BaseRepo):
-
- def __init__(self, root, conf) ->None:
+ def __init__(self, root, conf) -> None:
"""Init a Git bare Repository on top of a Swift container.
References are managed in info/refs objects by
@@ -371,15 +863,15 @@ class SwiftRepo(BaseRepo):
root: The container which contains the bare repo
conf: A ConfigParser object
"""
- self.root = root.lstrip('/')
+ self.root = root.lstrip("/")
self.conf = conf
self.scon = SwiftConnector(self.root, self.conf)
objects = self.scon.get_container_objects()
if not objects:
- raise Exception(f'There is not any GIT repo here : {self.root}')
- objects = [o['name'].split('/')[0] for o in objects]
+ raise Exception(f"There is not any GIT repo here : {self.root}")
+ objects = [o["name"].split("/")[0] for o in objects]
if OBJECTDIR not in objects:
- raise Exception(f'This repository ({self.root}) is not bare.')
+ raise Exception(f"This repository ({self.root}) is not bare.")
self.bare = True
self._controldir = self.root
object_store = SwiftObjectStore(self.scon)
@@ -391,7 +883,7 @@ class SwiftRepo(BaseRepo):
Returns: True if permissions can be trusted, False otherwise.
"""
- pass
+ return False
def _put_named_file(self, filename, contents):
"""Put an object in a Swift container.
@@ -400,7 +892,9 @@ class SwiftRepo(BaseRepo):
filename: the path to the object to put on Swift
contents: the content as bytestring
"""
- pass
+ with BytesIO() as f:
+ f.write(contents)
+ self.scon.put_object(filename, f)
@classmethod
def init_bare(cls, scon, conf):
@@ -412,20 +906,118 @@ class SwiftRepo(BaseRepo):
Returns:
a `SwiftRepo` instance
"""
- pass
+ scon.create_root()
+ for obj in [
+ posixpath.join(OBJECTDIR, PACKDIR),
+ posixpath.join(INFODIR, "refs"),
+ ]:
+ scon.put_object(obj, BytesIO(b""))
+ ret = cls(scon.root, conf)
+ ret._init_files(True)
+ return ret
class SwiftSystemBackend(Backend):
-
- def __init__(self, logger, conf) ->None:
+ def __init__(self, logger, conf) -> None:
self.conf = conf
self.logger = logger
+ def open_repository(self, path):
+ self.logger.info("opening repository at %s", path)
+ return SwiftRepo(path, self.conf)
+
def cmd_daemon(args):
"""Entry point for starting a TCP git server."""
- pass
-
-
-if __name__ == '__main__':
+ import optparse
+
+ parser = optparse.OptionParser()
+ parser.add_option(
+ "-l",
+ "--listen_address",
+ dest="listen_address",
+ default="127.0.0.1",
+ help="Binding IP address.",
+ )
+ parser.add_option(
+ "-p",
+ "--port",
+ dest="port",
+ type=int,
+ default=TCP_GIT_PORT,
+ help="Binding TCP port.",
+ )
+ parser.add_option(
+ "-c",
+ "--swift_config",
+ dest="swift_config",
+ default="",
+ help="Path to the configuration file for Swift backend.",
+ )
+ options, args = parser.parse_args(args)
+
+ try:
+ import gevent
+ import geventhttpclient # noqa: F401
+ except ImportError:
+ print(
+ "gevent and geventhttpclient libraries are mandatory "
+ " for use the Swift backend."
+ )
+ sys.exit(1)
+ import gevent.monkey
+
+ gevent.monkey.patch_socket()
+ from dulwich import log_utils
+
+ logger = log_utils.getLogger(__name__)
+ conf = load_conf(options.swift_config)
+ backend = SwiftSystemBackend(logger, conf)
+
+ log_utils.default_logging_config()
+ server = TCPGitServer(backend, options.listen_address, port=options.port)
+ server.serve_forever()
+
+
+def cmd_init(args):
+ import optparse
+
+ parser = optparse.OptionParser()
+ parser.add_option(
+ "-c",
+ "--swift_config",
+ dest="swift_config",
+ default="",
+ help="Path to the configuration file for Swift backend.",
+ )
+ options, args = parser.parse_args(args)
+
+ conf = load_conf(options.swift_config)
+ if args == []:
+ parser.error("missing repository name")
+ repo = args[0]
+ scon = SwiftConnector(repo, conf)
+ SwiftRepo.init_bare(scon, conf)
+
+
+def main(argv=sys.argv):
+ commands = {
+ "init": cmd_init,
+ "daemon": cmd_daemon,
+ }
+
+ if len(sys.argv) < 2:
+ print(
+ "Usage: {} <{}> [OPTIONS...]".format(sys.argv[0], "|".join(commands.keys()))
+ )
+ sys.exit(1)
+
+ cmd = sys.argv[1]
+ if cmd not in commands:
+ print(f"No such subcommand: {cmd}")
+ sys.exit(1)
+ commands[cmd](sys.argv[2:])
+
+
+if __name__ == "__main__":
main()
diff --git a/dulwich/credentials.py b/dulwich/credentials.py
index e77322bf..05de0452 100644
--- a/dulwich/credentials.py
+++ b/dulwich/credentials.py
@@ -1,20 +1,90 @@
+# credentials.py -- support for git credential helpers
+
+# Copyright (C) 2022 Daniele Trifirò <daniele@iterative.ai>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Support for git credential helpers.
https://git-scm.com/book/en/v2/Git-Tools-Credential-Storage
"""
+
import sys
from typing import Iterator, Optional
from urllib.parse import ParseResult, urlparse
+
from .config import ConfigDict, SectionLike
-def match_partial_url(valid_url: ParseResult, partial_url: str) ->bool:
+def match_urls(url: ParseResult, url_prefix: ParseResult) -> bool:
+ base_match = (
+ url.scheme == url_prefix.scheme
+ and url.hostname == url_prefix.hostname
+ and url.port == url_prefix.port
+ )
+ user_match = url.username == url_prefix.username if url_prefix.username else True
+ path_match = url.path.rstrip("/").startswith(url_prefix.path.rstrip())
+ return base_match and user_match and path_match
+
+
+def match_partial_url(valid_url: ParseResult, partial_url: str) -> bool:
"""Matches a parsed url with a partial url (no scheme/netloc)."""
- pass
+ if "://" not in partial_url:
+ parsed = urlparse("scheme://" + partial_url)
+ else:
+ parsed = urlparse(partial_url)
+ if valid_url.scheme != parsed.scheme:
+ return False
+ if any(
+ (
+ (parsed.hostname and valid_url.hostname != parsed.hostname),
+ (parsed.username and valid_url.username != parsed.username),
+ (parsed.port and valid_url.port != parsed.port),
+ (parsed.path and parsed.path.rstrip("/") != valid_url.path.rstrip("/")),
+ ),
+ ):
+ return False
-def urlmatch_credential_sections(config: ConfigDict, url: Optional[str]
- ) ->Iterator[SectionLike]:
+ return True
+
+
+def urlmatch_credential_sections(
+ config: ConfigDict, url: Optional[str]
+) -> Iterator[SectionLike]:
"""Returns credential sections from the config which match the given URL."""
- pass
+ encoding = config.encoding or sys.getdefaultencoding()
+ parsed_url = urlparse(url or "")
+ for config_section in config.sections():
+ if config_section[0] != b"credential":
+ continue
+
+ if len(config_section) < 2:
+ yield config_section
+ continue
+
+ config_url = config_section[1].decode(encoding)
+ parsed_config_url = urlparse(config_url)
+ if parsed_config_url.scheme and parsed_config_url.netloc:
+ is_match = match_urls(parsed_url, parsed_config_url)
+ else:
+ is_match = match_partial_url(parsed_url, config_url)
+
+ if is_match:
+ yield config_section
diff --git a/dulwich/diff_tree.py b/dulwich/diff_tree.py
index 05be69e2..eeec9d48 100644
--- a/dulwich/diff_tree.py
+++ b/dulwich/diff_tree.py
@@ -1,28 +1,72 @@
+# diff_tree.py -- Utilities for diffing files and trees.
+# Copyright (C) 2010 Google, Inc.
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Utilities for diffing files and trees."""
+
import stat
from collections import defaultdict, namedtuple
from io import BytesIO
from itertools import chain
from typing import Dict, List, Optional
+
from .object_store import BaseObjectStore
from .objects import S_ISGITLINK, ObjectID, ShaFile, Tree, TreeEntry
-CHANGE_ADD = 'add'
-CHANGE_MODIFY = 'modify'
-CHANGE_DELETE = 'delete'
-CHANGE_RENAME = 'rename'
-CHANGE_COPY = 'copy'
-CHANGE_UNCHANGED = 'unchanged'
-RENAME_CHANGE_TYPES = CHANGE_RENAME, CHANGE_COPY
+
+# TreeChange type constants.
+CHANGE_ADD = "add"
+CHANGE_MODIFY = "modify"
+CHANGE_DELETE = "delete"
+CHANGE_RENAME = "rename"
+CHANGE_COPY = "copy"
+CHANGE_UNCHANGED = "unchanged"
+
+RENAME_CHANGE_TYPES = (CHANGE_RENAME, CHANGE_COPY)
+
_NULL_ENTRY = TreeEntry(None, None, None)
+
_MAX_SCORE = 100
RENAME_THRESHOLD = 60
MAX_FILES = 200
REWRITE_THRESHOLD = None
-class TreeChange(namedtuple('TreeChange', ['type', 'old', 'new'])):
+class TreeChange(namedtuple("TreeChange", ["type", "old", "new"])):
"""Named tuple a single change between two trees."""
+ @classmethod
+ def add(cls, new):
+ return cls(CHANGE_ADD, _NULL_ENTRY, new)
+
+ @classmethod
+ def delete(cls, old):
+ return cls(CHANGE_DELETE, old, _NULL_ENTRY)
+
+
+def _tree_entries(path: str, tree: Tree) -> List[TreeEntry]:
+ result: List[TreeEntry] = []
+ if not tree:
+ return result
+ for entry in tree.iteritems(name_order=True):
+ result.append(entry.in_path(path))
+ return result
+
def _merge_entries(path, tree1, tree2):
"""Merge the entries of two trees.
@@ -38,7 +82,38 @@ def _merge_entries(path, tree1, tree2):
entry will have all attributes set to None. If neither entry's path is
None, they are guaranteed to match.
"""
- pass
+ entries1 = _tree_entries(path, tree1)
+ entries2 = _tree_entries(path, tree2)
+ i1 = i2 = 0
+ len1 = len(entries1)
+ len2 = len(entries2)
+
+ result = []
+ while i1 < len1 and i2 < len2:
+ entry1 = entries1[i1]
+ entry2 = entries2[i2]
+ if entry1.path < entry2.path:
+ result.append((entry1, _NULL_ENTRY))
+ i1 += 1
+ elif entry1.path > entry2.path:
+ result.append((_NULL_ENTRY, entry2))
+ i2 += 1
+ else:
+ result.append((entry1, entry2))
+ i1 += 1
+ i2 += 1
+ for i in range(i1, len1):
+ result.append((entries1[i], _NULL_ENTRY))
+ for i in range(i2, len2):
+ result.append((_NULL_ENTRY, entries2[i]))
+ return result
+
+
+def _is_tree(entry):
+ mode = entry.mode
+ if mode is None:
+ return False
+ return stat.S_ISDIR(mode)
def walk_trees(store, tree1_id, tree2_id, prune_identical=False):
@@ -59,11 +134,40 @@ def walk_trees(store, tree1_id, tree2_id, prune_identical=False):
to None. If neither entry's path is None, they are guaranteed to
match.
"""
- pass
-
-
-def tree_changes(store, tree1_id, tree2_id, want_unchanged=False,
- rename_detector=None, include_trees=False, change_type_same=False):
+ # This could be fairly easily generalized to >2 trees if we find a use
+ # case.
+ mode1 = tree1_id and stat.S_IFDIR or None
+ mode2 = tree2_id and stat.S_IFDIR or None
+ todo = [(TreeEntry(b"", mode1, tree1_id), TreeEntry(b"", mode2, tree2_id))]
+ while todo:
+ entry1, entry2 = todo.pop()
+ is_tree1 = _is_tree(entry1)
+ is_tree2 = _is_tree(entry2)
+ if prune_identical and is_tree1 and is_tree2 and entry1 == entry2:
+ continue
+
+ tree1 = is_tree1 and store[entry1.sha] or None
+ tree2 = is_tree2 and store[entry2.sha] or None
+ path = entry1.path or entry2.path
+ todo.extend(reversed(_merge_entries(path, tree1, tree2)))
+ yield entry1, entry2
+
+
+def _skip_tree(entry, include_trees):
+ if entry.mode is None or (not include_trees and stat.S_ISDIR(entry.mode)):
+ return _NULL_ENTRY
+ return entry
+
+
+def tree_changes(
+ store,
+ tree1_id,
+ tree2_id,
+ want_unchanged=False,
+ rename_detector=None,
+ include_trees=False,
+ change_type_same=False,
+):
"""Find the differences between the contents of two trees.
Args:
@@ -81,11 +185,66 @@ def tree_changes(store, tree1_id, tree2_id, want_unchanged=False,
Iterator over TreeChange instances for each change between the
source and target tree.
"""
- pass
-
-
-def tree_changes_for_merge(store: BaseObjectStore, parent_tree_ids: List[
- ObjectID], tree_id: ObjectID, rename_detector=None):
+ if rename_detector is not None and tree1_id is not None and tree2_id is not None:
+ yield from rename_detector.changes_with_renames(
+ tree1_id,
+ tree2_id,
+ want_unchanged=want_unchanged,
+ include_trees=include_trees,
+ )
+ return
+
+ entries = walk_trees(
+ store, tree1_id, tree2_id, prune_identical=(not want_unchanged)
+ )
+ for entry1, entry2 in entries:
+ if entry1 == entry2 and not want_unchanged:
+ continue
+
+ # Treat entries for trees as missing.
+ entry1 = _skip_tree(entry1, include_trees)
+ entry2 = _skip_tree(entry2, include_trees)
+
+ if entry1 != _NULL_ENTRY and entry2 != _NULL_ENTRY:
+ if (
+ stat.S_IFMT(entry1.mode) != stat.S_IFMT(entry2.mode)
+ and not change_type_same
+ ):
+ # File type changed: report as delete/add.
+ yield TreeChange.delete(entry1)
+ entry1 = _NULL_ENTRY
+ change_type = CHANGE_ADD
+ elif entry1 == entry2:
+ change_type = CHANGE_UNCHANGED
+ else:
+ change_type = CHANGE_MODIFY
+ elif entry1 != _NULL_ENTRY:
+ change_type = CHANGE_DELETE
+ elif entry2 != _NULL_ENTRY:
+ change_type = CHANGE_ADD
+ else:
+ # Both were None because at least one was a tree.
+ continue
+ yield TreeChange(change_type, entry1, entry2)
+
+
+def _all_eq(seq, key, value):
+ for e in seq:
+ if key(e) != value:
+ return False
+ return True
+
+
+def _all_same(seq, key):
+ return _all_eq(seq[1:], key, key(seq[0]))
+
+
+def tree_changes_for_merge(
+ store: BaseObjectStore,
+ parent_tree_ids: List[ObjectID],
+ tree_id: ObjectID,
+ rename_detector=None,
+):
"""Get the tree changes for a merge tree relative to all its parents.
Args:
@@ -106,13 +265,50 @@ def tree_changes_for_merge(store: BaseObjectStore, parent_tree_ids: List[
in the merge tree is not found in any of the parents, or in the case of
deletes, if not all of the old SHAs match.
"""
- pass
+ all_parent_changes = [
+ tree_changes(store, t, tree_id, rename_detector=rename_detector)
+ for t in parent_tree_ids
+ ]
+ num_parents = len(parent_tree_ids)
+ changes_by_path: Dict[str, List[Optional[TreeChange]]] = defaultdict(
+ lambda: [None] * num_parents
+ )
+
+ # Organize by path.
+ for i, parent_changes in enumerate(all_parent_changes):
+ for change in parent_changes:
+ if change.type == CHANGE_DELETE:
+ path = change.old.path
+ else:
+ path = change.new.path
+ changes_by_path[path][i] = change
+
+ def old_sha(c):
+ return c.old.sha
+
+ def change_type(c):
+ return c.type
+
+ # Yield only conflicting changes.
+ for _, changes in sorted(changes_by_path.items()):
+ assert len(changes) == num_parents
+ have = [c for c in changes if c is not None]
+ if _all_eq(have, change_type, CHANGE_DELETE):
+ if not _all_same(have, old_sha):
+ yield changes
+ elif not _all_same(have, change_type):
+ yield changes
+ elif None not in changes:
+ # If no change was found relative to one parent, that means the SHA
+ # must have matched the SHA in that parent, so it is not a
+ # conflict.
+ yield changes
_BLOCK_SIZE = 64
-def _count_blocks(obj: ShaFile) ->Dict[int, int]:
+def _count_blocks(obj: ShaFile) -> Dict[int, int]:
"""Count the blocks in an object.
Splits the data into blocks either on lines or <=64-byte chunks of lines.
@@ -123,7 +319,30 @@ def _count_blocks(obj: ShaFile) ->Dict[int, int]:
Returns:
A dict of block hashcode -> total bytes occurring.
"""
- pass
+ block_counts: Dict[int, int] = defaultdict(int)
+ block = BytesIO()
+ n = 0
+
+ # Cache attrs as locals to avoid expensive lookups in the inner loop.
+ block_write = block.write
+ block_seek = block.seek
+ block_truncate = block.truncate
+ block_getvalue = block.getvalue
+
+ for c in chain.from_iterable(obj.as_raw_chunks()):
+ cb = c.to_bytes(1, "big")
+ block_write(cb)
+ n += 1
+ if cb == b"\n" or n == _BLOCK_SIZE:
+ value = block_getvalue()
+ block_counts[hash(value)] += len(value)
+ block_seek(0)
+ block_truncate()
+ n = 0
+ if n > 0:
+ last_block = block_getvalue()
+ block_counts[hash(last_block)] += len(last_block)
+ return block_counts
def _common_bytes(blocks1, blocks2):
@@ -137,7 +356,15 @@ def _common_bytes(blocks1, blocks2):
The number of bytes in common between blocks1 and blocks2. This is
only approximate due to possible hash collisions.
"""
- pass
+ # Iterate over the smaller of the two dicts, since this is symmetrical.
+ if len(blocks1) > len(blocks2):
+ blocks1, blocks2 = blocks2, blocks1
+ score = 0
+ for block, count1 in blocks1.items():
+ count2 = blocks2.get(block)
+ if count2:
+ score += min(count1, count2)
+ return score
def _similarity_score(obj1, obj2, block_cache=None):
@@ -154,15 +381,42 @@ def _similarity_score(obj1, obj2, block_cache=None):
number of bytes in common between the two objects divided by the
maximum size, scaled to the range 0-100.
"""
- pass
+ if block_cache is None:
+ block_cache = {}
+ if obj1.id not in block_cache:
+ block_cache[obj1.id] = _count_blocks(obj1)
+ if obj2.id not in block_cache:
+ block_cache[obj2.id] = _count_blocks(obj2)
+
+ common_bytes = _common_bytes(block_cache[obj1.id], block_cache[obj2.id])
+ max_size = max(obj1.raw_length(), obj2.raw_length())
+ if not max_size:
+ return _MAX_SCORE
+ return int(float(common_bytes) * _MAX_SCORE / max_size)
+
+
+def _tree_change_key(entry):
+ # Sort by old path then new path. If only one exists, use it for both keys.
+ path1 = entry.old.path
+ path2 = entry.new.path
+ if path1 is None:
+ path1 = path2
+ if path2 is None:
+ path2 = path1
+ return (path1, path2)
class RenameDetector:
"""Object for handling rename detection between two trees."""
- def __init__(self, store, rename_threshold=RENAME_THRESHOLD, max_files=
- MAX_FILES, rewrite_threshold=REWRITE_THRESHOLD, find_copies_harder=
- False) ->None:
+ def __init__(
+ self,
+ store,
+ rename_threshold=RENAME_THRESHOLD,
+ max_files=MAX_FILES,
+ rewrite_threshold=REWRITE_THRESHOLD,
+ find_copies_harder=False,
+ ) -> None:
"""Initialize the rename detector.
Args:
@@ -187,16 +441,214 @@ class RenameDetector:
self._find_copies_harder = find_copies_harder
self._want_unchanged = False
- def changes_with_renames(self, tree1_id, tree2_id, want_unchanged=False,
- include_trees=False):
+ def _reset(self):
+ self._adds = []
+ self._deletes = []
+ self._changes = []
+
+ def _should_split(self, change):
+ if (
+ self._rewrite_threshold is None
+ or change.type != CHANGE_MODIFY
+ or change.old.sha == change.new.sha
+ ):
+ return False
+ old_obj = self._store[change.old.sha]
+ new_obj = self._store[change.new.sha]
+ return _similarity_score(old_obj, new_obj) < self._rewrite_threshold
+
+ def _add_change(self, change):
+ if change.type == CHANGE_ADD:
+ self._adds.append(change)
+ elif change.type == CHANGE_DELETE:
+ self._deletes.append(change)
+ elif self._should_split(change):
+ self._deletes.append(TreeChange.delete(change.old))
+ self._adds.append(TreeChange.add(change.new))
+ elif (
+ self._find_copies_harder and change.type == CHANGE_UNCHANGED
+ ) or change.type == CHANGE_MODIFY:
+ # Treat all modifies as potential deletes for rename detection,
+ # but don't split them (to avoid spurious renames). Setting
+ # find_copies_harder means we treat unchanged the same as
+ # modified.
+ self._deletes.append(change)
+ else:
+ self._changes.append(change)
+
+ def _collect_changes(self, tree1_id, tree2_id):
+ want_unchanged = self._find_copies_harder or self._want_unchanged
+ for change in tree_changes(
+ self._store,
+ tree1_id,
+ tree2_id,
+ want_unchanged=want_unchanged,
+ include_trees=self._include_trees,
+ ):
+ self._add_change(change)
+
+ def _prune(self, add_paths, delete_paths):
+ self._adds = [a for a in self._adds if a.new.path not in add_paths]
+ self._deletes = [d for d in self._deletes if d.old.path not in delete_paths]
+
+ def _find_exact_renames(self):
+ add_map = defaultdict(list)
+ for add in self._adds:
+ add_map[add.new.sha].append(add.new)
+ delete_map = defaultdict(list)
+ for delete in self._deletes:
+ # Keep track of whether the delete was actually marked as a delete.
+ # If not, it needs to be marked as a copy.
+ is_delete = delete.type == CHANGE_DELETE
+ delete_map[delete.old.sha].append((delete.old, is_delete))
+
+ add_paths = set()
+ delete_paths = set()
+ for sha, sha_deletes in delete_map.items():
+ sha_adds = add_map[sha]
+ for (old, is_delete), new in zip(sha_deletes, sha_adds):
+ if stat.S_IFMT(old.mode) != stat.S_IFMT(new.mode):
+ continue
+ if is_delete:
+ delete_paths.add(old.path)
+ add_paths.add(new.path)
+ new_type = is_delete and CHANGE_RENAME or CHANGE_COPY
+ self._changes.append(TreeChange(new_type, old, new))
+
+ num_extra_adds = len(sha_adds) - len(sha_deletes)
+ # TODO(dborowitz): Less arbitrary way of dealing with extra copies.
+ old = sha_deletes[0][0]
+ if num_extra_adds > 0:
+ for new in sha_adds[-num_extra_adds:]:
+ add_paths.add(new.path)
+ self._changes.append(TreeChange(CHANGE_COPY, old, new))
+ self._prune(add_paths, delete_paths)
+
+ def _should_find_content_renames(self):
+ return len(self._adds) * len(self._deletes) <= self._max_files**2
+
+ def _rename_type(self, check_paths, delete, add):
+ if check_paths and delete.old.path == add.new.path:
+ # If the paths match, this must be a split modify, so make sure it
+ # comes out as a modify.
+ return CHANGE_MODIFY
+ elif delete.type != CHANGE_DELETE:
+ # If it's in deletes but not marked as a delete, it must have been
+ # added due to find_copies_harder, and needs to be marked as a
+ # copy.
+ return CHANGE_COPY
+ return CHANGE_RENAME
+
+ def _find_content_rename_candidates(self):
+ candidates = self._candidates = []
+ # TODO: Optimizations:
+ # - Compare object sizes before counting blocks.
+ # - Skip if delete's S_IFMT differs from all adds.
+ # - Skip if adds or deletes is empty.
+ # Match C git's behavior of not attempting to find content renames if
+ # the matrix size exceeds the threshold.
+ if not self._should_find_content_renames():
+ return
+
+ block_cache = {}
+ check_paths = self._rename_threshold is not None
+ for delete in self._deletes:
+ if S_ISGITLINK(delete.old.mode):
+ continue # Git links don't exist in this repo.
+ old_sha = delete.old.sha
+ old_obj = self._store[old_sha]
+ block_cache[old_sha] = _count_blocks(old_obj)
+ for add in self._adds:
+ if stat.S_IFMT(delete.old.mode) != stat.S_IFMT(add.new.mode):
+ continue
+ new_obj = self._store[add.new.sha]
+ score = _similarity_score(old_obj, new_obj, block_cache=block_cache)
+ if score > self._rename_threshold:
+ new_type = self._rename_type(check_paths, delete, add)
+ rename = TreeChange(new_type, delete.old, add.new)
+ candidates.append((-score, rename))
+
+ def _choose_content_renames(self):
+ # Sort scores from highest to lowest, but keep names in ascending
+ # order.
+ self._candidates.sort()
+
+ delete_paths = set()
+ add_paths = set()
+ for _, change in self._candidates:
+ new_path = change.new.path
+ if new_path in add_paths:
+ continue
+ old_path = change.old.path
+ orig_type = change.type
+ if old_path in delete_paths:
+ change = TreeChange(CHANGE_COPY, change.old, change.new)
+
+ # If the candidate was originally a copy, that means it came from a
+ # modified or unchanged path, so we don't want to prune it.
+ if orig_type != CHANGE_COPY:
+ delete_paths.add(old_path)
+ add_paths.add(new_path)
+ self._changes.append(change)
+ self._prune(add_paths, delete_paths)
+
+ def _join_modifies(self):
+ if self._rewrite_threshold is None:
+ return
+
+ modifies = {}
+ delete_map = {d.old.path: d for d in self._deletes}
+ for add in self._adds:
+ path = add.new.path
+ delete = delete_map.get(path)
+ if delete is not None and stat.S_IFMT(delete.old.mode) == stat.S_IFMT(
+ add.new.mode
+ ):
+ modifies[path] = TreeChange(CHANGE_MODIFY, delete.old, add.new)
+
+ self._adds = [a for a in self._adds if a.new.path not in modifies]
+ self._deletes = [a for a in self._deletes if a.new.path not in modifies]
+ self._changes += modifies.values()
+
+ def _sorted_changes(self):
+ result = []
+ result.extend(self._adds)
+ result.extend(self._deletes)
+ result.extend(self._changes)
+ result.sort(key=_tree_change_key)
+ return result
+
+ def _prune_unchanged(self):
+ if self._want_unchanged:
+ return
+ self._deletes = [d for d in self._deletes if d.type != CHANGE_UNCHANGED]
+
+ def changes_with_renames(
+ self, tree1_id, tree2_id, want_unchanged=False, include_trees=False
+ ):
"""Iterate TreeChanges between two tree SHAs, with rename detection."""
- pass
-
-
+ self._reset()
+ self._want_unchanged = want_unchanged
+ self._include_trees = include_trees
+ self._collect_changes(tree1_id, tree2_id)
+ self._find_exact_renames()
+ self._find_content_rename_candidates()
+ self._choose_content_renames()
+ self._join_modifies()
+ self._prune_unchanged()
+ return self._sorted_changes()
+
+
+# Hold on to the pure-python implementations for testing.
_is_tree_py = _is_tree
_merge_entries_py = _merge_entries
_count_blocks_py = _count_blocks
try:
- from dulwich._diff_tree import _count_blocks, _is_tree, _merge_entries
+ # Try to import Rust versions
+ from dulwich._diff_tree import ( # type: ignore
+ _count_blocks,
+ _is_tree,
+ _merge_entries,
+ )
except ImportError:
pass
diff --git a/dulwich/errors.py b/dulwich/errors.py
index 7984614e..0e270b7e 100644
--- a/dulwich/errors.py
+++ b/dulwich/errors.py
@@ -1,11 +1,37 @@
+# errors.py -- errors for dulwich
+# Copyright (C) 2007 James Westby <jw+debian@jameswestby.net>
+# Copyright (C) 2009-2012 Jelmer Vernooij <jelmer@jelmer.uk>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Dulwich-related exception classes and utility functions."""
+
+
+# Please do not add more errors here, but instead add them close to the code
+# that raises the error.
+
import binascii
class ChecksumMismatch(Exception):
"""A checksum didn't match the expected contents."""
- def __init__(self, expected, got, extra=None) ->None:
+ def __init__(self, expected, got, extra=None) -> None:
if len(expected) == 20:
expected = binascii.hexlify(expected)
if len(got) == 20:
@@ -14,11 +40,15 @@ class ChecksumMismatch(Exception):
self.got = got
self.extra = extra
if self.extra is None:
- Exception.__init__(self,
- f'Checksum mismatch: Expected {expected}, got {got}')
+ Exception.__init__(
+ self,
+ f"Checksum mismatch: Expected {expected}, got {got}",
+ )
else:
- Exception.__init__(self,
- f'Checksum mismatch: Expected {expected}, got {got}; {extra}')
+ Exception.__init__(
+ self,
+ f"Checksum mismatch: Expected {expected}, got {got}; {extra}",
+ )
class WrongObjectException(Exception):
@@ -29,65 +59,70 @@ class WrongObjectException(Exception):
Subclasses should define a type_name attribute that indicates what
was expected if they were raised.
"""
+
type_name: str
- def __init__(self, sha, *args, **kwargs) ->None:
- Exception.__init__(self, f'{sha} is not a {self.type_name}')
+ def __init__(self, sha, *args, **kwargs) -> None:
+ Exception.__init__(self, f"{sha} is not a {self.type_name}")
class NotCommitError(WrongObjectException):
"""Indicates that the sha requested does not point to a commit."""
- type_name = 'commit'
+
+ type_name = "commit"
class NotTreeError(WrongObjectException):
"""Indicates that the sha requested does not point to a tree."""
- type_name = 'tree'
+
+ type_name = "tree"
class NotTagError(WrongObjectException):
"""Indicates that the sha requested does not point to a tag."""
- type_name = 'tag'
+
+ type_name = "tag"
class NotBlobError(WrongObjectException):
"""Indicates that the sha requested does not point to a blob."""
- type_name = 'blob'
+
+ type_name = "blob"
class MissingCommitError(Exception):
"""Indicates that a commit was not found in the repository."""
- def __init__(self, sha, *args, **kwargs) ->None:
+ def __init__(self, sha, *args, **kwargs) -> None:
self.sha = sha
- Exception.__init__(self, f'{sha} is not in the revision store')
+ Exception.__init__(self, f"{sha} is not in the revision store")
class ObjectMissing(Exception):
"""Indicates that a requested object is missing."""
- def __init__(self, sha, *args, **kwargs) ->None:
- Exception.__init__(self, f'{sha} is not in the pack')
+ def __init__(self, sha, *args, **kwargs) -> None:
+ Exception.__init__(self, f"{sha} is not in the pack")
class ApplyDeltaError(Exception):
"""Indicates that applying a delta failed."""
- def __init__(self, *args, **kwargs) ->None:
+ def __init__(self, *args, **kwargs) -> None:
Exception.__init__(self, *args, **kwargs)
class NotGitRepository(Exception):
"""Indicates that no Git repository was found."""
- def __init__(self, *args, **kwargs) ->None:
+ def __init__(self, *args, **kwargs) -> None:
Exception.__init__(self, *args, **kwargs)
class GitProtocolError(Exception):
"""Git protocol exception."""
- def __init__(self, *args, **kwargs) ->None:
+ def __init__(self, *args, **kwargs) -> None:
Exception.__init__(self, *args, **kwargs)
def __eq__(self, other):
@@ -101,29 +136,30 @@ class SendPackError(GitProtocolError):
class HangupException(GitProtocolError):
"""Hangup exception."""
- def __init__(self, stderr_lines=None) ->None:
+ def __init__(self, stderr_lines=None) -> None:
if stderr_lines:
- super().__init__('\n'.join([line.decode('utf-8',
- 'surrogateescape') for line in stderr_lines]))
- else:
super().__init__(
- 'The remote server unexpectedly closed the connection.')
+ "\n".join(
+ [line.decode("utf-8", "surrogateescape") for line in stderr_lines]
+ )
+ )
+ else:
+ super().__init__("The remote server unexpectedly closed the connection.")
self.stderr_lines = stderr_lines
def __eq__(self, other):
- return isinstance(self, type(other)
- ) and self.stderr_lines == other.stderr_lines
+ return isinstance(self, type(other)) and self.stderr_lines == other.stderr_lines
class UnexpectedCommandError(GitProtocolError):
"""Unexpected command received in a proto line."""
- def __init__(self, command) ->None:
+ def __init__(self, command) -> None:
if command is None:
- command = 'flush-pkt'
+ command = "flush-pkt"
else:
- command = f'command {command}'
- super().__init__(f'Protocol got unexpected {command}')
+ command = f"command {command}"
+ super().__init__(f"Protocol got unexpected {command}")
class FileFormatException(Exception):
diff --git a/dulwich/fastexport.py b/dulwich/fastexport.py
index 79b34db3..182517ed 100644
--- a/dulwich/fastexport.py
+++ b/dulwich/fastexport.py
@@ -1,57 +1,248 @@
+# __init__.py -- Fast export/import functionality
+# Copyright (C) 2010-2013 Jelmer Vernooij <jelmer@jelmer.uk>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
+
"""Fast export/import functionality."""
+
import stat
from typing import Dict, Tuple
+
from fastimport import commands, parser, processor
from fastimport import errors as fastimport_errors
+
from .index import commit_tree
from .object_store import iter_tree_contents
from .objects import ZERO_SHA, Blob, Commit, Tag
+def split_email(text):
+ (name, email) = text.rsplit(b" <", 1)
+ return (name, email.rstrip(b">"))
+
+
class GitFastExporter:
"""Generate a fast-export output stream for Git objects."""
- def __init__(self, outf, store) ->None:
+ def __init__(self, outf, store) -> None:
self.outf = outf
self.store = store
self.markers: Dict[bytes, bytes] = {}
self._marker_idx = 0
+ def print_cmd(self, cmd):
+ self.outf.write(getattr(cmd, "__bytes__", cmd.__repr__)() + b"\n")
+
+ def _allocate_marker(self):
+ self._marker_idx += 1
+ return ("%d" % (self._marker_idx,)).encode("ascii")
+
+ def _export_blob(self, blob):
+ marker = self._allocate_marker()
+ self.markers[marker] = blob.id
+ return (commands.BlobCommand(marker, blob.data), marker)
+
+ def emit_blob(self, blob):
+ (cmd, marker) = self._export_blob(blob)
+ self.print_cmd(cmd)
+ return marker
+
+ def _iter_files(self, base_tree, new_tree):
+ for (
+ (old_path, new_path),
+ (old_mode, new_mode),
+ (old_hexsha, new_hexsha),
+ ) in self.store.tree_changes(base_tree, new_tree):
+ if new_path is None:
+ yield commands.FileDeleteCommand(old_path)
+ continue
+ if not stat.S_ISDIR(new_mode):
+ blob = self.store[new_hexsha]
+ marker = self.emit_blob(blob)
+ if old_path != new_path and old_path is not None:
+ yield commands.FileRenameCommand(old_path, new_path)
+ if old_mode != new_mode or old_hexsha != new_hexsha:
+ prefixed_marker = b":" + marker
+ yield commands.FileModifyCommand(
+ new_path, new_mode, prefixed_marker, None
+ )
+
+ def _export_commit(self, commit, ref, base_tree=None):
+ file_cmds = list(self._iter_files(base_tree, commit.tree))
+ marker = self._allocate_marker()
+ if commit.parents:
+ from_ = commit.parents[0]
+ merges = commit.parents[1:]
+ else:
+ from_ = None
+ merges = []
+ author, author_email = split_email(commit.author)
+ committer, committer_email = split_email(commit.committer)
+ cmd = commands.CommitCommand(
+ ref,
+ marker,
+ (author, author_email, commit.author_time, commit.author_timezone),
+ (
+ committer,
+ committer_email,
+ commit.commit_time,
+ commit.commit_timezone,
+ ),
+ commit.message,
+ from_,
+ merges,
+ file_cmds,
+ )
+ return (cmd, marker)
+
+ def emit_commit(self, commit, ref, base_tree=None):
+ cmd, marker = self._export_commit(commit, ref, base_tree)
+ self.print_cmd(cmd)
+ return marker
+
class GitImportProcessor(processor.ImportProcessor):
"""An import processor that imports into a Git repository using Dulwich."""
- def __init__(self, repo, params=None, verbose=False, outf=None) ->None:
+ # FIXME: Batch creation of objects?
+
+ def __init__(self, repo, params=None, verbose=False, outf=None) -> None:
processor.ImportProcessor.__init__(self, params, verbose)
self.repo = repo
self.last_commit = ZERO_SHA
self.markers: Dict[bytes, bytes] = {}
self._contents: Dict[bytes, Tuple[int, bytes]] = {}
+ def lookup_object(self, objectish):
+ if objectish.startswith(b":"):
+ return self.markers[objectish[1:]]
+ return objectish
+
+ def import_stream(self, stream):
+ p = parser.ImportParser(stream)
+ self.process(p.iter_commands)
+ return self.markers
+
def blob_handler(self, cmd):
"""Process a BlobCommand."""
- pass
+ blob = Blob.from_string(cmd.data)
+ self.repo.object_store.add_object(blob)
+ if cmd.mark:
+ self.markers[cmd.mark] = blob.id
def checkpoint_handler(self, cmd):
"""Process a CheckpointCommand."""
- pass
def commit_handler(self, cmd):
"""Process a CommitCommand."""
- pass
+ commit = Commit()
+ if cmd.author is not None:
+ author = cmd.author
+ else:
+ author = cmd.committer
+ (author_name, author_email, author_timestamp, author_timezone) = author
+ (
+ committer_name,
+ committer_email,
+ commit_timestamp,
+ commit_timezone,
+ ) = cmd.committer
+ commit.author = author_name + b" <" + author_email + b">"
+ commit.author_timezone = author_timezone
+ commit.author_time = int(author_timestamp)
+ commit.committer = committer_name + b" <" + committer_email + b">"
+ commit.commit_timezone = commit_timezone
+ commit.commit_time = int(commit_timestamp)
+ commit.message = cmd.message
+ commit.parents = []
+ if cmd.from_:
+ cmd.from_ = self.lookup_object(cmd.from_)
+ self._reset_base(cmd.from_)
+ for filecmd in cmd.iter_files():
+ if filecmd.name == b"filemodify":
+ if filecmd.data is not None:
+ blob = Blob.from_string(filecmd.data)
+ self.repo.object_store.add(blob)
+ blob_id = blob.id
+ else:
+ blob_id = self.lookup_object(filecmd.dataref)
+ self._contents[filecmd.path] = (filecmd.mode, blob_id)
+ elif filecmd.name == b"filedelete":
+ del self._contents[filecmd.path]
+ elif filecmd.name == b"filecopy":
+ self._contents[filecmd.dest_path] = self._contents[filecmd.src_path]
+ elif filecmd.name == b"filerename":
+ self._contents[filecmd.new_path] = self._contents[filecmd.old_path]
+ del self._contents[filecmd.old_path]
+ elif filecmd.name == b"filedeleteall":
+ self._contents = {}
+ else:
+ raise Exception(f"Command {filecmd.name} not supported")
+ commit.tree = commit_tree(
+ self.repo.object_store,
+ ((path, hexsha, mode) for (path, (mode, hexsha)) in self._contents.items()),
+ )
+ if self.last_commit != ZERO_SHA:
+ commit.parents.append(self.last_commit)
+ for merge in cmd.merges:
+ commit.parents.append(self.lookup_object(merge))
+ self.repo.object_store.add_object(commit)
+ self.repo[cmd.ref] = commit.id
+ self.last_commit = commit.id
+ if cmd.mark:
+ self.markers[cmd.mark] = commit.id
def progress_handler(self, cmd):
"""Process a ProgressCommand."""
- pass
+
+ def _reset_base(self, commit_id):
+ if self.last_commit == commit_id:
+ return
+ self._contents = {}
+ self.last_commit = commit_id
+ if commit_id != ZERO_SHA:
+ tree_id = self.repo[commit_id].tree
+ for (
+ path,
+ mode,
+ hexsha,
+ ) in iter_tree_contents(self.repo.object_store, tree_id):
+ self._contents[path] = (mode, hexsha)
def reset_handler(self, cmd):
"""Process a ResetCommand."""
- pass
+ if cmd.from_ is None:
+ from_ = ZERO_SHA
+ else:
+ from_ = self.lookup_object(cmd.from_)
+ self._reset_base(from_)
+ self.repo.refs[cmd.ref] = from_
def tag_handler(self, cmd):
"""Process a TagCommand."""
- pass
+ tag = Tag()
+ tag.tagger = cmd.tagger
+ tag.message = cmd.message
+ tag.name = cmd.tag
+ self.repo.add_object(tag)
+ self.repo.refs["refs/tags/" + tag.name] = tag.id
def feature_handler(self, cmd):
"""Process a FeatureCommand."""
- pass
+ raise fastimport_errors.UnknownFeature(cmd.feature_name)
diff --git a/dulwich/file.py b/dulwich/file.py
index f52c127c..d65a81dd 100644
--- a/dulwich/file.py
+++ b/dulwich/file.py
@@ -1,4 +1,25 @@
+# file.py -- Safe access to git files
+# Copyright (C) 2010 Google, Inc.
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Safe access to git files."""
+
import os
import sys
import warnings
@@ -7,15 +28,46 @@ from typing import ClassVar, Set
def ensure_dir_exists(dirname):
"""Ensure a directory exists, creating if necessary."""
- pass
+ try:
+ os.makedirs(dirname)
+ except FileExistsError:
+ pass
def _fancy_rename(oldname, newname):
"""Rename file with temporary backup file to rollback if rename fails."""
- pass
-
-
-def GitFile(filename, mode='rb', bufsize=-1, mask=420):
+ if not os.path.exists(newname):
+ try:
+ os.rename(oldname, newname)
+ except OSError:
+ raise
+ return
+
+ # Defer the tempfile import since it pulls in a lot of other things.
+ import tempfile
+
+ # destination file exists
+ try:
+ (fd, tmpfile) = tempfile.mkstemp(".tmp", prefix=oldname, dir=".")
+ os.close(fd)
+ os.remove(tmpfile)
+ except OSError:
+ # either file could not be created (e.g. permission problem)
+ # or could not be deleted (e.g. rude virus scanner)
+ raise
+ try:
+ os.rename(newname, tmpfile)
+ except OSError:
+ raise # no rename occurred
+ try:
+ os.rename(oldname, newname)
+ except OSError:
+ os.rename(tmpfile, newname)
+ raise
+ os.remove(tmpfile)
+
+
+def GitFile(filename, mode="rb", bufsize=-1, mask=0o644):
"""Create a file object that obeys the git file locking protocol.
Returns: a builtin file object or a _GitFile object
@@ -31,13 +83,22 @@ def GitFile(filename, mode='rb', bufsize=-1, mask=420):
world-readable.
"""
- pass
+ if "a" in mode:
+ raise OSError("append mode not supported for Git files")
+ if "+" in mode:
+ raise OSError("read/write mode not supported for Git files")
+ if "b" not in mode:
+ raise OSError("text mode not supported for Git files")
+ if "w" in mode:
+ return _GitFile(filename, mode, bufsize, mask)
+ else:
+ return open(filename, mode, bufsize)
class FileLocked(Exception):
"""File is already locked."""
- def __init__(self, filename, lockfilename) ->None:
+ def __init__(self, filename, lockfilename) -> None:
self.filename = filename
self.lockfilename = lockfilename
super().__init__(filename, lockfilename)
@@ -53,25 +114,48 @@ class _GitFile:
Note: You *must* call close() or abort() on a _GitFile for the lock to be
released. Typically this will happen in a finally block.
"""
- PROXY_PROPERTIES: ClassVar[Set[str]] = {'closed', 'encoding', 'errors',
- 'mode', 'name', 'newlines', 'softspace'}
- PROXY_METHODS: ClassVar[Set[str]] = {'__iter__', 'flush', 'fileno',
- 'isatty', 'read', 'readline', 'readlines', 'seek', 'tell',
- 'truncate', 'write', 'writelines'}
- def __init__(self, filename, mode, bufsize, mask) ->None:
+ PROXY_PROPERTIES: ClassVar[Set[str]] = {
+ "closed",
+ "encoding",
+ "errors",
+ "mode",
+ "name",
+ "newlines",
+ "softspace",
+ }
+ PROXY_METHODS: ClassVar[Set[str]] = {
+ "__iter__",
+ "flush",
+ "fileno",
+ "isatty",
+ "read",
+ "readline",
+ "readlines",
+ "seek",
+ "tell",
+ "truncate",
+ "write",
+ "writelines",
+ }
+
+ def __init__(self, filename, mode, bufsize, mask) -> None:
self._filename = filename
if isinstance(self._filename, bytes):
- self._lockfilename = self._filename + b'.lock'
+ self._lockfilename = self._filename + b".lock"
else:
- self._lockfilename = self._filename + '.lock'
+ self._lockfilename = self._filename + ".lock"
try:
- fd = os.open(self._lockfilename, os.O_RDWR | os.O_CREAT | os.
- O_EXCL | getattr(os, 'O_BINARY', 0), mask)
+ fd = os.open(
+ self._lockfilename,
+ os.O_RDWR | os.O_CREAT | os.O_EXCL | getattr(os, "O_BINARY", 0),
+ mask,
+ )
except FileExistsError as exc:
raise FileLocked(filename, self._lockfilename) from exc
self._file = os.fdopen(fd, mode, bufsize)
self._closed = False
+
for method in self.PROXY_METHODS:
setattr(self, method, getattr(self._file, method))
@@ -80,7 +164,15 @@ class _GitFile:
If the file is already closed, this is a no-op.
"""
- pass
+ if self._closed:
+ return
+ self._file.close()
+ try:
+ os.remove(self._lockfilename)
+ self._closed = True
+ except FileNotFoundError:
+ # The file may have been removed already, which is ok.
+ self._closed = True
def close(self):
"""Close this file, saving the lockfile over the original.
@@ -95,11 +187,27 @@ class _GitFile:
lock file is still closed, so further attempts to write to the same
file object will raise ValueError.
"""
- pass
+ if self._closed:
+ return
+ self._file.flush()
+ os.fsync(self._file.fileno())
+ self._file.close()
+ try:
+ if getattr(os, "replace", None) is not None:
+ os.replace(self._lockfilename, self._filename)
+ else:
+ if sys.platform != "win32":
+ os.rename(self._lockfilename, self._filename)
+ else:
+ # Windows versions prior to Vista don't support atomic
+ # renames
+ _fancy_rename(self._lockfilename, self._filename)
+ finally:
+ self.abort()
- def __del__(self) ->None:
- if not getattr(self, '_closed', True):
- warnings.warn(f'unclosed {self!r}', ResourceWarning, stacklevel=2)
+ def __del__(self) -> None:
+ if not getattr(self, "_closed", True):
+ warnings.warn(f"unclosed {self!r}", ResourceWarning, stacklevel=2)
self.abort()
def __enter__(self):
diff --git a/dulwich/graph.py b/dulwich/graph.py
index ea7dfbd7..9c18dca6 100644
--- a/dulwich/graph.py
+++ b/dulwich/graph.py
@@ -1,14 +1,120 @@
+# vim:ts=4:sw=4:softtabstop=4:smarttab:expandtab
+# Copyright (c) 2020 Kevin B. Hendricks, Stratford Ontario Canada
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+
"""Implementation of merge-base following the approach of git."""
+
from heapq import heappop, heappush
+
from .lru_cache import LRUCache
+# priority queue using builtin python minheap tools
+# why they do not have a builtin maxheap is simply ridiculous but
+# liveable with integer time stamps using negation
class WorkList:
-
def __init__(self):
self.pq = []
+ def add(self, item):
+ dt, cmt = item
+ heappush(self.pq, (-dt, cmt))
+
+ def get(self):
+ item = heappop(self.pq)
+ if item:
+ pr, cmt = item
+ return -pr, cmt
+ return None
+
+ def iter(self):
+ for pr, cmt in self.pq:
+ yield (-pr, cmt)
+
+
+def _find_lcas(lookup_parents, c1, c2s, lookup_stamp, min_stamp=0):
+ cands = []
+ cstates = {}
+
+ # Flags to Record State
+ _ANC_OF_1 = 1 # ancestor of commit 1
+ _ANC_OF_2 = 2 # ancestor of commit 2
+ _DNC = 4 # Do Not Consider
+ _LCA = 8 # potential LCA (Lowest Common Ancestor)
+
+ def _has_candidates(wlst, cstates):
+ for dt, cmt in wlst.iter():
+ if cmt in cstates:
+ if not ((cstates[cmt] & _DNC) == _DNC):
+ return True
+ return False
+
+ # initialize the working list states with ancestry info
+ # note possibility of c1 being one of c2s should be handled
+ wlst = WorkList()
+ cstates[c1] = _ANC_OF_1
+ wlst.add((lookup_stamp(c1), c1))
+ for c2 in c2s:
+ cflags = cstates.get(c2, 0)
+ cstates[c2] = cflags | _ANC_OF_2
+ wlst.add((lookup_stamp(c2), c2))
+
+ # loop while at least one working list commit is still viable (not marked as _DNC)
+ # adding any parents to the list in a breadth first manner
+ while _has_candidates(wlst, cstates):
+ dt, cmt = wlst.get()
+ # Look only at ANCESTRY and _DNC flags so that already
+ # found _LCAs can still be marked _DNC by lower _LCAS
+ cflags = cstates[cmt] & (_ANC_OF_1 | _ANC_OF_2 | _DNC)
+ if cflags == (_ANC_OF_1 | _ANC_OF_2):
+ # potential common ancestor if not already in candidates add it
+ if not (cstates[cmt] & _LCA) == _LCA:
+ cstates[cmt] = cstates[cmt] | _LCA
+ cands.append((dt, cmt))
+ # mark any parents of this node _DNC as all parents
+ # would be one generation further removed common ancestors
+ cflags = cflags | _DNC
+ parents = lookup_parents(cmt)
+ if parents:
+ for pcmt in parents:
+ pflags = cstates.get(pcmt, 0)
+ # if this parent was already visited with no new ancestry/flag information
+ # do not add it to the working list again
+ if (pflags & cflags) == cflags:
+ continue
+ pdt = lookup_stamp(pcmt)
+ if pdt < min_stamp:
+ continue
+ cstates[pcmt] = pflags | cflags
+ wlst.add((pdt, pcmt))
+ # walk final candidates removing any superseded by _DNC by later lower _LCAs
+ # remove any duplicates and sort it so that earliest is first
+ results = []
+ for dt, cmt in cands:
+ if not ((cstates[cmt] & _DNC) == _DNC) and (dt, cmt) not in results:
+ results.append((dt, cmt))
+ results.sort(key=lambda x: x[0])
+ lcas = [cmt for dt, cmt in results]
+ return lcas
+
+
+# actual git sorts these based on commit times
def find_merge_base(repo, commit_ids):
"""Find lowest common ancestors of commit_ids[0] and *any* of commits_ids[1:].
@@ -18,7 +124,31 @@ def find_merge_base(repo, commit_ids):
Returns:
list of lowest common ancestor commit_ids
"""
- pass
+ cmtcache = LRUCache(max_cache=128)
+ parents_provider = repo.parents_provider()
+
+ def lookup_stamp(cmtid):
+ if cmtid not in cmtcache:
+ cmtcache[cmtid] = repo.object_store[cmtid]
+ return cmtcache[cmtid].commit_time
+
+ def lookup_parents(cmtid):
+ commit = None
+ if cmtid in cmtcache:
+ commit = cmtcache[cmtid]
+ # must use parents provider to handle grafts and shallow
+ return parents_provider.get_parents(cmtid, commit=commit)
+
+ if not commit_ids:
+ return []
+ c1 = commit_ids[0]
+ if not len(commit_ids) > 1:
+ return [c1]
+ c2s = commit_ids[1:]
+ if c1 in c2s:
+ return [c1]
+ lcas = _find_lcas(lookup_parents, c1, c2s, lookup_stamp)
+ return lcas
def find_octopus_base(repo, commit_ids):
@@ -30,7 +160,34 @@ def find_octopus_base(repo, commit_ids):
Returns:
list of lowest common ancestor commit_ids
"""
- pass
+ cmtcache = LRUCache(max_cache=128)
+ parents_provider = repo.parents_provider()
+
+ def lookup_stamp(cmtid):
+ if cmtid not in cmtcache:
+ cmtcache[cmtid] = repo.object_store[cmtid]
+ return cmtcache[cmtid].commit_time
+
+ def lookup_parents(cmtid):
+ commit = None
+ if cmtid in cmtcache:
+ commit = cmtcache[cmtid]
+ # must use parents provider to handle grafts and shallow
+ return parents_provider.get_parents(cmtid, commit=commit)
+
+ if not commit_ids:
+ return []
+ if len(commit_ids) <= 2:
+ return find_merge_base(repo, commit_ids)
+ lcas = [commit_ids[0]]
+ others = commit_ids[1:]
+ for cmt in others:
+ next_lcas = []
+ for ca in lcas:
+ res = _find_lcas(lookup_parents, cmt, [ca], lookup_stamp)
+ next_lcas.extend(res)
+ lcas = next_lcas[:]
+ return lcas
def can_fast_forward(repo, c1, c2):
@@ -41,4 +198,25 @@ def can_fast_forward(repo, c1, c2):
c1: Commit id for first commit
c2: Commit id for second commit
"""
- pass
+ cmtcache = LRUCache(max_cache=128)
+ parents_provider = repo.parents_provider()
+
+ def lookup_stamp(cmtid):
+ if cmtid not in cmtcache:
+ cmtcache[cmtid] = repo.object_store[cmtid]
+ return cmtcache[cmtid].commit_time
+
+ def lookup_parents(cmtid):
+ commit = None
+ if cmtid in cmtcache:
+ commit = cmtcache[cmtid]
+ # must use parents provider to handle grafts and shallow
+ return parents_provider.get_parents(cmtid, commit=commit)
+
+ if c1 == c2:
+ return True
+
+ # Algorithm: Find the common ancestor
+ min_stamp = lookup_stamp(c1)
+ lcas = _find_lcas(lookup_parents, c1, [c2], lookup_stamp, min_stamp=min_stamp)
+ return lcas == [c1]
diff --git a/dulwich/greenthreads.py b/dulwich/greenthreads.py
index 72c31520..2255ac09 100644
--- a/dulwich/greenthreads.py
+++ b/dulwich/greenthreads.py
@@ -1,19 +1,67 @@
+# greenthreads.py -- Utility module for querying an ObjectStore with gevent
+# Copyright (C) 2013 eNovance SAS <licensing@enovance.com>
+#
+# Author: Fabien Boucher <fabien.boucher@enovance.com>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Utility module for querying an ObjectStore with gevent."""
+
from typing import FrozenSet, Optional, Set, Tuple
+
import gevent
from gevent import pool
-from .object_store import MissingObjectFinder, _collect_ancestors, _collect_filetree_revs
+
+from .object_store import (
+ MissingObjectFinder,
+ _collect_ancestors,
+ _collect_filetree_revs,
+)
from .objects import Commit, ObjectID, Tag
-def _split_commits_and_tags(obj_store, lst, *, ignore_unknown=False, pool=None
- ):
+def _split_commits_and_tags(obj_store, lst, *, ignore_unknown=False, pool=None):
"""Split object id list into two list with commit SHA1s and tag SHA1s.
Same implementation as object_store._split_commits_and_tags
except we use gevent to parallelize object retrieval.
"""
- pass
+ commits = set()
+ tags = set()
+
+ def find_commit_type(sha):
+ try:
+ o = obj_store[sha]
+ except KeyError:
+ if not ignore_unknown:
+ raise
+ else:
+ if isinstance(o, Commit):
+ commits.add(sha)
+ elif isinstance(o, Tag):
+ tags.add(sha)
+ commits.add(o.object[1])
+ else:
+ raise KeyError(f"Not a commit or a tag: {sha}")
+
+ jobs = [pool.spawn(find_commit_type, s) for s in lst]
+ gevent.joinall(jobs)
+ return (commits, tags)
class GreenThreadsMissingObjectFinder(MissingObjectFinder):
@@ -23,23 +71,37 @@ class GreenThreadsMissingObjectFinder(MissingObjectFinder):
except we use gevent to parallelize object retrieval.
"""
- def __init__(self, object_store, haves, wants, progress=None,
- get_tagged=None, concurrency=1, get_parents=None) ->None:
-
+ def __init__(
+ self,
+ object_store,
+ haves,
+ wants,
+ progress=None,
+ get_tagged=None,
+ concurrency=1,
+ get_parents=None,
+ ) -> None:
def collect_tree_sha(sha):
self.sha_done.add(sha)
cmt = object_store[sha]
_collect_filetree_revs(object_store, cmt.tree, self.sha_done)
+
self.object_store = object_store
p = pool.Pool(size=concurrency)
- have_commits, have_tags = _split_commits_and_tags(object_store,
- haves, ignore_unknown=True, pool=p)
- want_commits, want_tags = _split_commits_and_tags(object_store,
- wants, ignore_unknown=False, pool=p)
- all_ancestors: FrozenSet[ObjectID] = frozenset(_collect_ancestors(
- object_store, have_commits)[0])
- missing_commits, common_commits = _collect_ancestors(object_store,
- want_commits, all_ancestors)
+
+ have_commits, have_tags = _split_commits_and_tags(
+ object_store, haves, ignore_unknown=True, pool=p
+ )
+ want_commits, want_tags = _split_commits_and_tags(
+ object_store, wants, ignore_unknown=False, pool=p
+ )
+ all_ancestors: FrozenSet[ObjectID] = frozenset(
+ _collect_ancestors(object_store, have_commits)[0]
+ )
+ missing_commits, common_commits = _collect_ancestors(
+ object_store, want_commits, all_ancestors
+ )
+
self.sha_done = set()
jobs = [p.spawn(collect_tree_sha, c) for c in common_commits]
gevent.joinall(jobs)
@@ -47,8 +109,9 @@ class GreenThreadsMissingObjectFinder(MissingObjectFinder):
self.sha_done.add(t)
missing_tags = want_tags.difference(have_tags)
wants = missing_commits.union(missing_tags)
- self.objects_to_send: Set[Tuple[ObjectID, Optional[bytes], Optional
- [int], bool]] = {(w, None, 0, False) for w in wants}
+ self.objects_to_send: Set[
+ Tuple[ObjectID, Optional[bytes], Optional[int], bool]
+ ] = {(w, None, 0, False) for w in wants}
if progress is None:
self.progress = lambda x: None
else:
diff --git a/dulwich/hooks.py b/dulwich/hooks.py
index 88b83bac..b1f56fc5 100644
--- a/dulwich/hooks.py
+++ b/dulwich/hooks.py
@@ -1,6 +1,28 @@
+# hooks.py -- for dealing with git hooks
+# Copyright (C) 2012-2013 Jelmer Vernooij and others.
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Access to hooks."""
+
import os
import subprocess
+
from .errors import HookError
@@ -17,7 +39,7 @@ class Hook:
Returns:
a hook may return a useful value
"""
- pass
+ raise NotImplementedError(self.execute)
class ShellHook(Hook):
@@ -28,8 +50,15 @@ class ShellHook(Hook):
[0] http://www.kernel.org/pub/software/scm/git/docs/githooks.html
"""
- def __init__(self, name, path, numparam, pre_exec_callback=None,
- post_exec_callback=None, cwd=None) ->None:
+ def __init__(
+ self,
+ name,
+ path,
+ numparam,
+ pre_exec_callback=None,
+ post_exec_callback=None,
+ cwd=None,
+ ) -> None:
"""Setup shell hook definition.
Args:
@@ -49,59 +78,122 @@ class ShellHook(Hook):
self.name = name
self.filepath = path
self.numparam = numparam
+
self.pre_exec_callback = pre_exec_callback
self.post_exec_callback = post_exec_callback
+
self.cwd = cwd
def execute(self, *args):
"""Execute the hook with given args."""
- pass
+ if len(args) != self.numparam:
+ raise HookError(
+ "Hook %s executed with wrong number of args. \
+ Expected %d. Saw %d. args: %s"
+ % (self.name, self.numparam, len(args), args)
+ )
+
+ if self.pre_exec_callback is not None:
+ args = self.pre_exec_callback(*args)
+
+ try:
+ ret = subprocess.call(
+ [os.path.relpath(self.filepath, self.cwd), *list(args)], cwd=self.cwd
+ )
+ if ret != 0:
+ if self.post_exec_callback is not None:
+ self.post_exec_callback(0, *args)
+ raise HookError(
+ "Hook %s exited with non-zero status %d" % (self.name, ret)
+ )
+ if self.post_exec_callback is not None:
+ return self.post_exec_callback(1, *args)
+ except OSError: # no file. silent failure.
+ if self.post_exec_callback is not None:
+ self.post_exec_callback(0, *args)
class PreCommitShellHook(ShellHook):
"""pre-commit shell hook."""
- def __init__(self, cwd, controldir) ->None:
- filepath = os.path.join(controldir, 'hooks', 'pre-commit')
- ShellHook.__init__(self, 'pre-commit', filepath, 0, cwd=cwd)
+ def __init__(self, cwd, controldir) -> None:
+ filepath = os.path.join(controldir, "hooks", "pre-commit")
+
+ ShellHook.__init__(self, "pre-commit", filepath, 0, cwd=cwd)
class PostCommitShellHook(ShellHook):
"""post-commit shell hook."""
- def __init__(self, controldir) ->None:
- filepath = os.path.join(controldir, 'hooks', 'post-commit')
- ShellHook.__init__(self, 'post-commit', filepath, 0, cwd=controldir)
+ def __init__(self, controldir) -> None:
+ filepath = os.path.join(controldir, "hooks", "post-commit")
+
+ ShellHook.__init__(self, "post-commit", filepath, 0, cwd=controldir)
class CommitMsgShellHook(ShellHook):
"""commit-msg shell hook."""
- def __init__(self, controldir) ->None:
- filepath = os.path.join(controldir, 'hooks', 'commit-msg')
+ def __init__(self, controldir) -> None:
+ filepath = os.path.join(controldir, "hooks", "commit-msg")
def prepare_msg(*args):
import tempfile
- fd, path = tempfile.mkstemp()
- with os.fdopen(fd, 'wb') as f:
+
+ (fd, path) = tempfile.mkstemp()
+
+ with os.fdopen(fd, "wb") as f:
f.write(args[0])
- return path,
+
+ return (path,)
def clean_msg(success, *args):
if success:
- with open(args[0], 'rb') as f:
+ with open(args[0], "rb") as f:
new_msg = f.read()
os.unlink(args[0])
return new_msg
os.unlink(args[0])
- ShellHook.__init__(self, 'commit-msg', filepath, 1, prepare_msg,
- clean_msg, controldir)
+
+ ShellHook.__init__(
+ self, "commit-msg", filepath, 1, prepare_msg, clean_msg, controldir
+ )
class PostReceiveShellHook(ShellHook):
"""post-receive shell hook."""
- def __init__(self, controldir) ->None:
+ def __init__(self, controldir) -> None:
self.controldir = controldir
- filepath = os.path.join(controldir, 'hooks', 'post-receive')
- ShellHook.__init__(self, 'post-receive', path=filepath, numparam=0)
+ filepath = os.path.join(controldir, "hooks", "post-receive")
+ ShellHook.__init__(self, "post-receive", path=filepath, numparam=0)
+
+ def execute(self, client_refs):
+ # do nothing if the script doesn't exist
+ if not os.path.exists(self.filepath):
+ return None
+
+ try:
+ env = os.environ.copy()
+ env["GIT_DIR"] = self.controldir
+
+ p = subprocess.Popen(
+ self.filepath,
+ stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ env=env,
+ )
+
+ # client_refs is a list of (oldsha, newsha, ref)
+ in_data = b"\n".join([b" ".join(ref) for ref in client_refs])
+
+ out_data, err_data = p.communicate(in_data)
+
+ if (p.returncode != 0) or err_data:
+ err_fmt = b"post-receive exit code: %d\n" + b"stdout:\n%s\nstderr:\n%s"
+ err_msg = err_fmt % (p.returncode, out_data, err_data)
+ raise HookError(err_msg.decode("utf-8", "backslashreplace"))
+ return out_data
+ except OSError as err:
+ raise HookError(repr(err)) from err
diff --git a/dulwich/ignore.py b/dulwich/ignore.py
index c824ec53..a2c6d457 100644
--- a/dulwich/ignore.py
+++ b/dulwich/ignore.py
@@ -1,17 +1,77 @@
+# Copyright (C) 2017 Jelmer Vernooij <jelmer@jelmer.uk>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Parsing of gitignore files.
For details for the matching rules, see https://git-scm.com/docs/gitignore
"""
+
import os.path
import re
from contextlib import suppress
from typing import TYPE_CHECKING, BinaryIO, Dict, Iterable, List, Optional, Union
+
if TYPE_CHECKING:
from .repo import Repo
+
from .config import Config, get_xdg_config_home_path
-def translate(pat: bytes) ->bytes:
+def _translate_segment(segment: bytes) -> bytes:
+ if segment == b"*":
+ return b"[^/]+"
+ res = b""
+ i, n = 0, len(segment)
+ while i < n:
+ c = segment[i : i + 1]
+ i = i + 1
+ if c == b"*":
+ res += b"[^/]*"
+ elif c == b"?":
+ res += b"[^/]"
+ elif c == b"\\":
+ res += re.escape(segment[i : i + 1])
+ i += 1
+ elif c == b"[":
+ j = i
+ if j < n and segment[j : j + 1] == b"!":
+ j = j + 1
+ if j < n and segment[j : j + 1] == b"]":
+ j = j + 1
+ while j < n and segment[j : j + 1] != b"]":
+ j = j + 1
+ if j >= n:
+ res += b"\\["
+ else:
+ stuff = segment[i:j].replace(b"\\", b"\\\\")
+ i = j + 1
+ if stuff.startswith(b"!"):
+ stuff = b"^" + stuff[1:]
+ elif stuff.startswith(b"^"):
+ stuff = b"\\" + stuff
+ res += b"[" + stuff + b"]"
+ else:
+ res += re.escape(c)
+ return res
+
+
+def translate(pat: bytes) -> bytes:
"""Translate a shell PATTERN to a regular expression.
There is no way to quote meta-characters.
@@ -19,20 +79,60 @@ def translate(pat: bytes) ->bytes:
Originally copied from fnmatch in Python 2.7, but modified for Dulwich
to cope with features in Git ignore patterns.
"""
- pass
+ res = b"(?ms)"
+
+ if b"/" not in pat[:-1]:
+ # If there's no slash, this is a filename-based match
+ res += b"(.*/)?"
+
+ if pat.startswith(b"**/"):
+ # Leading **/
+ pat = pat[2:]
+ res += b"(.*/)?"
+ if pat.startswith(b"/"):
+ pat = pat[1:]
-def read_ignore_patterns(f: BinaryIO) ->Iterable[bytes]:
+ for i, segment in enumerate(pat.split(b"/")):
+ if segment == b"**":
+ res += b"(/.*)?"
+ continue
+ else:
+ res += (re.escape(b"/") if i > 0 else b"") + _translate_segment(segment)
+
+ if not pat.endswith(b"/"):
+ res += b"/?"
+
+ return res + b"\\Z"
+
+
+def read_ignore_patterns(f: BinaryIO) -> Iterable[bytes]:
"""Read a git ignore file.
Args:
f: File-like object to read from
Returns: List of patterns
"""
- pass
+ for line in f:
+ line = line.rstrip(b"\r\n")
+
+ # Ignore blank lines, they're used for readability.
+ if not line.strip():
+ continue
+
+ if line.startswith(b"#"):
+ # Comment
+ continue
+
+ # Trailing spaces are ignored unless they are quoted with a backslash.
+ while line.endswith(b" ") and not line.endswith(b"\\ "):
+ line = line[:-1]
+ line = line.replace(b"\\ ", b" ")
+
+ yield line
-def match_pattern(path: bytes, pattern: bytes, ignorecase: bool=False) ->bool:
+def match_pattern(path: bytes, pattern: bytes, ignorecase: bool = False) -> bool:
"""Match a gitignore-style pattern against a path.
Args:
@@ -42,20 +142,20 @@ def match_pattern(path: bytes, pattern: bytes, ignorecase: bool=False) ->bool:
Returns:
bool indicating whether the pattern matched
"""
- pass
+ return Pattern(pattern, ignorecase).match(path)
class Pattern:
"""A single ignore pattern."""
- def __init__(self, pattern: bytes, ignorecase: bool=False) ->None:
+ def __init__(self, pattern: bytes, ignorecase: bool = False) -> None:
self.pattern = pattern
self.ignorecase = ignorecase
- if pattern[0:1] == b'!':
+ if pattern[0:1] == b"!":
self.is_exclude = False
pattern = pattern[1:]
else:
- if pattern[0:1] == b'\\':
+ if pattern[0:1] == b"\\":
pattern = pattern[1:]
self.is_exclude = True
flags = 0
@@ -63,44 +163,47 @@ class Pattern:
flags = re.IGNORECASE
self._re = re.compile(translate(pattern), flags)
- def __bytes__(self) ->bytes:
+ def __bytes__(self) -> bytes:
return self.pattern
- def __str__(self) ->str:
+ def __str__(self) -> str:
return os.fsdecode(self.pattern)
- def __eq__(self, other: object) ->bool:
- return (isinstance(other, type(self)) and self.pattern == other.
- pattern and self.ignorecase == other.ignorecase)
+ def __eq__(self, other: object) -> bool:
+ return (
+ isinstance(other, type(self))
+ and self.pattern == other.pattern
+ and self.ignorecase == other.ignorecase
+ )
- def __repr__(self) ->str:
- return f'{type(self).__name__}({self.pattern!r}, {self.ignorecase!r})'
+ def __repr__(self) -> str:
+ return f"{type(self).__name__}({self.pattern!r}, {self.ignorecase!r})"
- def match(self, path: bytes) ->bool:
+ def match(self, path: bytes) -> bool:
"""Try to match a path against this ignore pattern.
Args:
path: Path to match (relative to ignore location)
Returns: boolean
"""
- pass
+ return bool(self._re.match(path))
class IgnoreFilter:
-
- def __init__(self, patterns: Iterable[bytes], ignorecase: bool=False,
- path=None) ->None:
+ def __init__(
+ self, patterns: Iterable[bytes], ignorecase: bool = False, path=None
+ ) -> None:
self._patterns: List[Pattern] = []
self._ignorecase = ignorecase
self._path = path
for pattern in patterns:
self.append_pattern(pattern)
- def append_pattern(self, pattern: bytes) ->None:
+ def append_pattern(self, pattern: bytes) -> None:
"""Add a pattern to the set."""
- pass
+ self._patterns.append(Pattern(pattern, self._ignorecase))
- def find_matching(self, path: Union[bytes, str]) ->Iterable[Pattern]:
+ def find_matching(self, path: Union[bytes, str]) -> Iterable[Pattern]:
"""Yield all matching patterns for path.
Args:
@@ -108,9 +211,13 @@ class IgnoreFilter:
Returns:
Iterator over iterators
"""
- pass
+ if not isinstance(path, bytes):
+ path = os.fsencode(path)
+ for pattern in self._patterns:
+ if pattern.match(path):
+ yield pattern
- def is_ignored(self, path: bytes) ->Optional[bool]:
+ def is_ignored(self, path: bytes) -> Optional[bool]:
"""Check whether a path is ignored.
For directories, include a trailing slash.
@@ -118,23 +225,31 @@ class IgnoreFilter:
Returns: status is None if file is not mentioned, True if it is
included, False if it is explicitly excluded.
"""
- pass
+ status = None
+ for pattern in self.find_matching(path):
+ status = pattern.is_exclude
+ return status
+
+ @classmethod
+ def from_path(cls, path, ignorecase: bool = False) -> "IgnoreFilter":
+ with open(path, "rb") as f:
+ return cls(read_ignore_patterns(f), ignorecase, path=path)
- def __repr__(self) ->str:
- path = getattr(self, '_path', None)
+ def __repr__(self) -> str:
+ path = getattr(self, "_path", None)
if path is not None:
- return f'{type(self).__name__}.from_path({path!r})'
+ return f"{type(self).__name__}.from_path({path!r})"
else:
- return f'<{type(self).__name__}>'
+ return f"<{type(self).__name__}>"
class IgnoreFilterStack:
"""Check for ignore status in multiple filters."""
- def __init__(self, filters) ->None:
+ def __init__(self, filters) -> None:
self._filters = filters
- def is_ignored(self, path: str) ->Optional[bool]:
+ def is_ignored(self, path: str) -> Optional[bool]:
"""Check whether a path is explicitly included or excluded in ignores.
Args:
@@ -143,10 +258,15 @@ class IgnoreFilterStack:
None if the file is not mentioned, True if it is included,
False if it is explicitly excluded.
"""
- pass
+ status = None
+ for filter in self._filters:
+ status = filter.is_ignored(path)
+ if status is not None:
+ return status
+ return status
-def default_user_ignore_filter_path(config: Config) ->str:
+def default_user_ignore_filter_path(config: Config) -> str:
"""Return default user ignore filter path.
Args:
@@ -154,25 +274,47 @@ def default_user_ignore_filter_path(config: Config) ->str:
Returns:
Path to a global ignore file
"""
- pass
+ try:
+ value = config.get((b"core",), b"excludesFile")
+ assert isinstance(value, bytes)
+ return value.decode(encoding="utf-8")
+ except KeyError:
+ pass
+
+ return get_xdg_config_home_path("git", "ignore")
class IgnoreFilterManager:
"""Ignore file manager."""
- def __init__(self, top_path: str, global_filters: List[IgnoreFilter],
- ignorecase: bool) ->None:
+ def __init__(
+ self,
+ top_path: str,
+ global_filters: List[IgnoreFilter],
+ ignorecase: bool,
+ ) -> None:
self._path_filters: Dict[str, Optional[IgnoreFilter]] = {}
self._top_path = top_path
self._global_filters = global_filters
self._ignorecase = ignorecase
- def __repr__(self) ->str:
- return (
- f'{type(self).__name__}({self._top_path}, {self._global_filters!r}, {self._ignorecase!r})'
- )
+ def __repr__(self) -> str:
+ return f"{type(self).__name__}({self._top_path}, {self._global_filters!r}, {self._ignorecase!r})"
+
+ def _load_path(self, path: str) -> Optional[IgnoreFilter]:
+ try:
+ return self._path_filters[path]
+ except KeyError:
+ pass
+
+ p = os.path.join(self._top_path, path, ".gitignore")
+ try:
+ self._path_filters[path] = IgnoreFilter.from_path(p, self._ignorecase)
+ except OSError:
+ self._path_filters[path] = None
+ return self._path_filters[path]
- def find_matching(self, path: str) ->Iterable[Pattern]:
+ def find_matching(self, path: str) -> Iterable[Pattern]:
"""Find matching patterns for path.
Args:
@@ -180,9 +322,28 @@ class IgnoreFilterManager:
Returns:
Iterator over Pattern instances
"""
- pass
-
- def is_ignored(self, path: str) ->Optional[bool]:
+ if os.path.isabs(path):
+ raise ValueError(f"{path} is an absolute path")
+ filters = [(0, f) for f in self._global_filters]
+ if os.path.sep != "/":
+ path = path.replace(os.path.sep, "/")
+ parts = path.split("/")
+ matches = []
+ for i in range(len(parts) + 1):
+ dirname = "/".join(parts[:i])
+ for s, f in filters:
+ relpath = "/".join(parts[s:i])
+ if i < len(parts):
+ # Paths leading up to the final part are all directories,
+ # so need a trailing slash.
+ relpath += "/"
+ matches += list(f.find_matching(relpath))
+ ignore_filter = self._load_path(dirname)
+ if ignore_filter is not None:
+ filters.insert(0, (i, ignore_filter))
+ return iter(matches)
+
+ def is_ignored(self, path: str) -> Optional[bool]:
"""Check whether a path is explicitly included or excluded in ignores.
Args:
@@ -191,10 +352,13 @@ class IgnoreFilterManager:
None if the file is not mentioned, True if it is included,
False if it is explicitly excluded.
"""
- pass
+ matches = list(self.find_matching(path))
+ if matches:
+ return matches[-1].is_exclude
+ return None
@classmethod
- def from_repo(cls, repo: 'Repo') ->'IgnoreFilterManager':
+ def from_repo(cls, repo: "Repo") -> "IgnoreFilterManager":
"""Create a IgnoreFilterManager from a repository.
Args:
@@ -202,4 +366,13 @@ class IgnoreFilterManager:
Returns:
A `IgnoreFilterManager` object
"""
- pass
+ global_filters = []
+ for p in [
+ os.path.join(repo.controldir(), "info", "exclude"),
+ default_user_ignore_filter_path(repo.get_config_stack()),
+ ]:
+ with suppress(OSError):
+ global_filters.append(IgnoreFilter.from_path(os.path.expanduser(p)))
+ config = repo.get_config_stack()
+ ignorecase = config.get_boolean((b"core"), (b"ignorecase"), False)
+ return cls(repo.path, global_filters, ignorecase)
diff --git a/dulwich/index.py b/dulwich/index.py
index 092ea76c..f3b3f24f 100644
--- a/dulwich/index.py
+++ b/dulwich/index.py
@@ -1,22 +1,74 @@
+# index.py -- File parser/writer for the git index file
+# Copyright (C) 2008-2013 Jelmer Vernooij <jelmer@jelmer.uk>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Parser for the git index file format."""
+
import os
import stat
import struct
import sys
from dataclasses import dataclass
from enum import Enum
-from typing import Any, BinaryIO, Callable, Dict, Iterable, Iterator, List, Optional, Tuple, Union
+from typing import (
+ Any,
+ BinaryIO,
+ Callable,
+ Dict,
+ Iterable,
+ Iterator,
+ List,
+ Optional,
+ Tuple,
+ Union,
+)
+
from .file import GitFile
from .object_store import iter_tree_contents
-from .objects import S_IFGITLINK, S_ISGITLINK, Blob, ObjectID, Tree, hex_to_sha, sha_to_hex
+from .objects import (
+ S_IFGITLINK,
+ S_ISGITLINK,
+ Blob,
+ ObjectID,
+ Tree,
+ hex_to_sha,
+ sha_to_hex,
+)
from .pack import ObjectContainer, SHA1Reader, SHA1Writer
-FLAG_STAGEMASK = 12288
+
+# 2-bit stage (during merge)
+FLAG_STAGEMASK = 0x3000
FLAG_STAGESHIFT = 12
-FLAG_NAMEMASK = 4095
-FLAG_VALID = 32768
-FLAG_EXTENDED = 16384
-EXTENDED_FLAG_SKIP_WORKTREE = 16384
-EXTENDED_FLAG_INTEND_TO_ADD = 8192
+FLAG_NAMEMASK = 0x0FFF
+
+# assume-valid
+FLAG_VALID = 0x8000
+
+# extended flag (must be zero in version 2)
+FLAG_EXTENDED = 0x4000
+
+# used by sparse checkout
+EXTENDED_FLAG_SKIP_WORKTREE = 0x4000
+
+# used by "git add -N"
+EXTENDED_FLAG_INTEND_TO_ADD = 0x2000
+
DEFAULT_VERSION = 2
@@ -42,6 +94,9 @@ class SerializedIndexEntry:
flags: int
extended_flags: int
+ def stage(self) -> Stage:
+ return Stage((self.flags & FLAG_STAGEMASK) >> FLAG_STAGESHIFT)
+
@dataclass
class IndexEntry:
@@ -55,15 +110,50 @@ class IndexEntry:
size: int
sha: bytes
+ @classmethod
+ def from_serialized(cls, serialized: SerializedIndexEntry) -> "IndexEntry":
+ return cls(
+ ctime=serialized.ctime,
+ mtime=serialized.mtime,
+ dev=serialized.dev,
+ ino=serialized.ino,
+ mode=serialized.mode,
+ uid=serialized.uid,
+ gid=serialized.gid,
+ size=serialized.size,
+ sha=serialized.sha,
+ )
+
+ def serialize(self, name: bytes, stage: Stage) -> SerializedIndexEntry:
+ return SerializedIndexEntry(
+ name=name,
+ ctime=self.ctime,
+ mtime=self.mtime,
+ dev=self.dev,
+ ino=self.ino,
+ mode=self.mode,
+ uid=self.uid,
+ gid=self.gid,
+ size=self.size,
+ sha=self.sha,
+ flags=stage.value << FLAG_STAGESHIFT,
+ extended_flags=0,
+ )
+
class ConflictedIndexEntry:
"""Index entry that represents a conflict."""
+
ancestor: Optional[IndexEntry]
this: Optional[IndexEntry]
other: Optional[IndexEntry]
- def __init__(self, ancestor: Optional[IndexEntry]=None, this: Optional[
- IndexEntry]=None, other: Optional[IndexEntry]=None) ->None:
+ def __init__(
+ self,
+ ancestor: Optional[IndexEntry] = None,
+ this: Optional[IndexEntry] = None,
+ other: Optional[IndexEntry] = None,
+ ) -> None:
self.ancestor = ancestor
self.this = this
self.other = other
@@ -73,7 +163,7 @@ class UnmergedEntries(Exception):
"""Unmerged entries exist in the index."""
-def pathsplit(path: bytes) ->Tuple[bytes, bytes]:
+def pathsplit(path: bytes) -> Tuple[bytes, bytes]:
"""Split a /-delimited path into a directory part and a basename.
Args:
@@ -82,12 +172,17 @@ def pathsplit(path: bytes) ->Tuple[bytes, bytes]:
Returns:
Tuple with directory name and basename
"""
- pass
+ try:
+ (dirname, basename) = path.rsplit(b"/", 1)
+ except ValueError:
+ return (b"", path)
+ else:
+ return (dirname, basename)
def pathjoin(*args):
"""Join a /-delimited path."""
- pass
+ return b"/".join([p for p in args if p])
def read_cache_time(f):
@@ -98,7 +193,7 @@ def read_cache_time(f):
Returns:
Tuple with seconds and nanoseconds
"""
- pass
+ return struct.unpack(">LL", f.read(8))
def write_cache_time(f, t):
@@ -108,52 +203,145 @@ def write_cache_time(f, t):
f: File-like object to write to
t: Time to write (as int, float or tuple with secs and nsecs)
"""
- pass
+ if isinstance(t, int):
+ t = (t, 0)
+ elif isinstance(t, float):
+ (secs, nsecs) = divmod(t, 1.0)
+ t = (int(secs), int(nsecs * 1000000000))
+ elif not isinstance(t, tuple):
+ raise TypeError(t)
+ f.write(struct.pack(">LL", *t))
-def read_cache_entry(f, version: int) ->SerializedIndexEntry:
+def read_cache_entry(f, version: int) -> SerializedIndexEntry:
"""Read an entry from a cache file.
Args:
f: File-like object to read from
"""
- pass
-
-
-def write_cache_entry(f, entry: SerializedIndexEntry, version: int) ->None:
+ beginoffset = f.tell()
+ ctime = read_cache_time(f)
+ mtime = read_cache_time(f)
+ (
+ dev,
+ ino,
+ mode,
+ uid,
+ gid,
+ size,
+ sha,
+ flags,
+ ) = struct.unpack(">LLLLLL20sH", f.read(20 + 4 * 6 + 2))
+ if flags & FLAG_EXTENDED:
+ if version < 3:
+ raise AssertionError("extended flag set in index with version < 3")
+ (extended_flags,) = struct.unpack(">H", f.read(2))
+ else:
+ extended_flags = 0
+ name = f.read(flags & FLAG_NAMEMASK)
+ # Padding:
+ if version < 4:
+ real_size = (f.tell() - beginoffset + 8) & ~7
+ f.read((beginoffset + real_size) - f.tell())
+ return SerializedIndexEntry(
+ name,
+ ctime,
+ mtime,
+ dev,
+ ino,
+ mode,
+ uid,
+ gid,
+ size,
+ sha_to_hex(sha),
+ flags & ~FLAG_NAMEMASK,
+ extended_flags,
+ )
+
+
+def write_cache_entry(f, entry: SerializedIndexEntry, version: int) -> None:
"""Write an index entry to a file.
Args:
f: File object
entry: IndexEntry to write, tuple with:
"""
- pass
+ beginoffset = f.tell()
+ write_cache_time(f, entry.ctime)
+ write_cache_time(f, entry.mtime)
+ flags = len(entry.name) | (entry.flags & ~FLAG_NAMEMASK)
+ if entry.extended_flags:
+ flags |= FLAG_EXTENDED
+ if flags & FLAG_EXTENDED and version is not None and version < 3:
+ raise AssertionError("unable to use extended flags in version < 3")
+ f.write(
+ struct.pack(
+ b">LLLLLL20sH",
+ entry.dev & 0xFFFFFFFF,
+ entry.ino & 0xFFFFFFFF,
+ entry.mode,
+ entry.uid,
+ entry.gid,
+ entry.size,
+ hex_to_sha(entry.sha),
+ flags,
+ )
+ )
+ if flags & FLAG_EXTENDED:
+ f.write(struct.pack(b">H", entry.extended_flags))
+ f.write(entry.name)
+ if version < 4:
+ real_size = (f.tell() - beginoffset + 8) & ~7
+ f.write(b"\0" * ((beginoffset + real_size) - f.tell()))
class UnsupportedIndexFormat(Exception):
"""An unsupported index format was encountered."""
- def __init__(self, version) ->None:
+ def __init__(self, version) -> None:
self.index_format_version = version
-def read_index(f: BinaryIO) ->Iterator[SerializedIndexEntry]:
+def read_index(f: BinaryIO) -> Iterator[SerializedIndexEntry]:
"""Read an index file, yielding the individual entries."""
- pass
+ header = f.read(4)
+ if header != b"DIRC":
+ raise AssertionError(f"Invalid index file header: {header!r}")
+ (version, num_entries) = struct.unpack(b">LL", f.read(4 * 2))
+ if version not in (1, 2, 3):
+ raise UnsupportedIndexFormat(version)
+ for i in range(num_entries):
+ yield read_cache_entry(f, version)
-def read_index_dict(f) ->Dict[bytes, Union[IndexEntry, ConflictedIndexEntry]]:
+def read_index_dict(f) -> Dict[bytes, Union[IndexEntry, ConflictedIndexEntry]]:
"""Read an index file and return it as a dictionary.
Dict Key is tuple of path and stage number, as
path alone is not unique
Args:
f: File object to read fromls.
"""
- pass
-
-
-def write_index(f: BinaryIO, entries: List[SerializedIndexEntry], version:
- Optional[int]=None):
+ ret: Dict[bytes, Union[IndexEntry, ConflictedIndexEntry]] = {}
+ for entry in read_index(f):
+ stage = entry.stage()
+ if stage == Stage.NORMAL:
+ ret[entry.name] = IndexEntry.from_serialized(entry)
+ else:
+ existing = ret.setdefault(entry.name, ConflictedIndexEntry())
+ if isinstance(existing, IndexEntry):
+ raise AssertionError(f"Non-conflicted entry for {entry.name!r} exists")
+ if stage == Stage.MERGE_CONFLICT_ANCESTOR:
+ existing.ancestor = IndexEntry.from_serialized(entry)
+ elif stage == Stage.MERGE_CONFLICT_THIS:
+ existing.this = IndexEntry.from_serialized(entry)
+ elif stage == Stage.MERGE_CONFLICT_OTHER:
+ existing.other = IndexEntry.from_serialized(entry)
+ return ret
+
+
+def write_index(
+ f: BinaryIO, entries: List[SerializedIndexEntry], version: Optional[int] = None
+):
"""Write an index file.
Args:
@@ -161,18 +349,44 @@ def write_index(f: BinaryIO, entries: List[SerializedIndexEntry], version:
version: Version number to write
entries: Iterable over the entries to write
"""
- pass
-
-
-def write_index_dict(f: BinaryIO, entries: Dict[bytes, Union[IndexEntry,
- ConflictedIndexEntry]], version: Optional[int]=None) ->None:
+ if version is None:
+ version = DEFAULT_VERSION
+ f.write(b"DIRC")
+ f.write(struct.pack(b">LL", version, len(entries)))
+ for entry in entries:
+ write_cache_entry(f, entry, version)
+
+
+def write_index_dict(
+ f: BinaryIO,
+ entries: Dict[bytes, Union[IndexEntry, ConflictedIndexEntry]],
+ version: Optional[int] = None,
+) -> None:
"""Write an index file based on the contents of a dictionary.
being careful to sort by path and then by stage.
"""
- pass
+ entries_list = []
+ for key in sorted(entries):
+ value = entries[key]
+ if isinstance(value, ConflictedIndexEntry):
+ if value.ancestor is not None:
+ entries_list.append(
+ value.ancestor.serialize(key, Stage.MERGE_CONFLICT_ANCESTOR)
+ )
+ if value.this is not None:
+ entries_list.append(
+ value.this.serialize(key, Stage.MERGE_CONFLICT_THIS)
+ )
+ if value.other is not None:
+ entries_list.append(
+ value.other.serialize(key, Stage.MERGE_CONFLICT_OTHER)
+ )
+ else:
+ entries_list.append(value.serialize(key, Stage.NORMAL))
+ write_index(f, entries_list, version=version)
-def cleanup_mode(mode: int) ->int:
+def cleanup_mode(mode: int) -> int:
"""Cleanup a mode value.
This will return a mode that can be stored in a tree object.
@@ -183,14 +397,24 @@ def cleanup_mode(mode: int) ->int:
Returns:
mode
"""
- pass
+ if stat.S_ISLNK(mode):
+ return stat.S_IFLNK
+ elif stat.S_ISDIR(mode):
+ return stat.S_IFDIR
+ elif S_ISGITLINK(mode):
+ return S_IFGITLINK
+ ret = stat.S_IFREG | 0o644
+ if mode & 0o100:
+ ret |= 0o111
+ return ret
class Index:
"""A Git Index file."""
+
_byname: Dict[bytes, Union[IndexEntry, ConflictedIndexEntry]]
- def __init__(self, filename: Union[bytes, str], read=True) ->None:
+ def __init__(self, filename: Union[bytes, str], read=True) -> None:
"""Create an index object associated with the given filename.
Args:
@@ -198,28 +422,47 @@ class Index:
read: Whether to initialize the index from the given file, should it exist.
"""
self._filename = filename
+ # TODO(jelmer): Store the version returned by read_index
self._version = None
self.clear()
if read:
self.read()
- def __repr__(self) ->str:
- return f'{self.__class__.__name__}({self._filename!r})'
+ @property
+ def path(self):
+ return self._filename
- def write(self) ->None:
+ def __repr__(self) -> str:
+ return f"{self.__class__.__name__}({self._filename!r})"
+
+ def write(self) -> None:
"""Write current contents of index to disk."""
- pass
+ f = GitFile(self._filename, "wb")
+ try:
+ f = SHA1Writer(f)
+ write_index_dict(f, self._byname, version=self._version)
+ finally:
+ f.close()
def read(self):
"""Read current contents of index from disk."""
- pass
+ if not os.path.exists(self._filename):
+ return
+ f = GitFile(self._filename, "rb")
+ try:
+ f = SHA1Reader(f)
+ self.update(read_index_dict(f))
+ # FIXME: Additional data?
+ f.read(os.path.getsize(self._filename) - f.tell() - 20)
+ f.check_sha()
+ finally:
+ f.close()
- def __len__(self) ->int:
+ def __len__(self) -> int:
"""Number of entries in this index file."""
return len(self._byname)
- def __getitem__(self, key: bytes) ->Union[IndexEntry, ConflictedIndexEntry
- ]:
+ def __getitem__(self, key: bytes) -> Union[IndexEntry, ConflictedIndexEntry]:
"""Retrieve entry by relative path and stage.
Returns: Either a IndexEntry or a ConflictedIndexEntry
@@ -227,39 +470,72 @@ class Index:
"""
return self._byname[key]
- def __iter__(self) ->Iterator[bytes]:
+ def __iter__(self) -> Iterator[bytes]:
"""Iterate over the paths and stages in this index."""
return iter(self._byname)
def __contains__(self, key):
return key in self._byname
- def get_sha1(self, path: bytes) ->bytes:
+ def get_sha1(self, path: bytes) -> bytes:
"""Return the (git object) SHA1 for the object at a path."""
- pass
+ value = self[path]
+ if isinstance(value, ConflictedIndexEntry):
+ raise UnmergedEntries
+ return value.sha
- def get_mode(self, path: bytes) ->int:
+ def get_mode(self, path: bytes) -> int:
"""Return the POSIX file mode for the object at a path."""
- pass
+ value = self[path]
+ if isinstance(value, ConflictedIndexEntry):
+ raise UnmergedEntries
+ return value.mode
- def iterobjects(self) ->Iterable[Tuple[bytes, bytes, int]]:
+ def iterobjects(self) -> Iterable[Tuple[bytes, bytes, int]]:
"""Iterate over path, sha, mode tuples for use with commit_tree."""
- pass
+ for path in self:
+ entry = self[path]
+ if isinstance(entry, ConflictedIndexEntry):
+ raise UnmergedEntries
+ yield path, entry.sha, cleanup_mode(entry.mode)
+
+ def has_conflicts(self) -> bool:
+ for value in self._byname.values():
+ if isinstance(value, ConflictedIndexEntry):
+ return True
+ return False
def clear(self):
"""Remove all contents from this index."""
- pass
+ self._byname = {}
- def __setitem__(self, name: bytes, value: Union[IndexEntry,
- ConflictedIndexEntry]) ->None:
+ def __setitem__(
+ self, name: bytes, value: Union[IndexEntry, ConflictedIndexEntry]
+ ) -> None:
assert isinstance(name, bytes)
self._byname[name] = value
- def __delitem__(self, name: bytes) ->None:
+ def __delitem__(self, name: bytes) -> None:
del self._byname[name]
- def changes_from_tree(self, object_store, tree: ObjectID,
- want_unchanged: bool=False):
+ def iteritems(
+ self,
+ ) -> Iterator[Tuple[bytes, Union[IndexEntry, ConflictedIndexEntry]]]:
+ return iter(self._byname.items())
+
+ def items(self) -> Iterator[Tuple[bytes, Union[IndexEntry, ConflictedIndexEntry]]]:
+ return iter(self._byname.items())
+
+ def update(self, entries: Dict[bytes, Union[IndexEntry, ConflictedIndexEntry]]):
+ for key, value in entries.items():
+ self[key] = value
+
+ def paths(self):
+ yield from self._byname.keys()
+
+ def changes_from_tree(
+ self, object_store, tree: ObjectID, want_unchanged: bool = False
+ ):
"""Find the differences between the contents of this index and a tree.
Args:
@@ -269,7 +545,18 @@ class Index:
Returns: Iterator over tuples with (oldpath, newpath), (oldmode,
newmode), (oldsha, newsha)
"""
- pass
+
+ def lookup_entry(path):
+ entry = self[path]
+ return entry.sha, cleanup_mode(entry.mode)
+
+ yield from changes_from_tree(
+ self.paths(),
+ lookup_entry,
+ object_store,
+ tree,
+ want_unchanged=want_unchanged,
+ )
def commit(self, object_store):
"""Create a new tree from an index.
@@ -279,11 +566,12 @@ class Index:
Returns:
Root tree SHA
"""
- pass
+ return commit_tree(object_store, self.iterobjects())
-def commit_tree(object_store: ObjectContainer, blobs: Iterable[Tuple[bytes,
- bytes, int]]) ->bytes:
+def commit_tree(
+ object_store: ObjectContainer, blobs: Iterable[Tuple[bytes, bytes, int]]
+) -> bytes:
"""Commit a new tree.
Args:
@@ -292,10 +580,40 @@ def commit_tree(object_store: ObjectContainer, blobs: Iterable[Tuple[bytes,
Returns:
SHA1 of the created tree.
"""
- pass
-
-
-def commit_index(object_store: ObjectContainer, index: Index) ->bytes:
+ trees: Dict[bytes, Any] = {b"": {}}
+
+ def add_tree(path):
+ if path in trees:
+ return trees[path]
+ dirname, basename = pathsplit(path)
+ t = add_tree(dirname)
+ assert isinstance(basename, bytes)
+ newtree = {}
+ t[basename] = newtree
+ trees[path] = newtree
+ return newtree
+
+ for path, sha, mode in blobs:
+ tree_path, basename = pathsplit(path)
+ tree = add_tree(tree_path)
+ tree[basename] = (mode, sha)
+
+ def build_tree(path):
+ tree = Tree()
+ for basename, entry in trees[path].items():
+ if isinstance(entry, dict):
+ mode = stat.S_IFDIR
+ sha = build_tree(pathjoin(path, basename))
+ else:
+ (mode, sha) = entry
+ tree.add(basename, mode, sha)
+ object_store.add_object(tree)
+ return tree.id
+
+ return build_tree(b"")
+
+
+def commit_index(object_store: ObjectContainer, index: Index) -> bytes:
"""Create a new tree from an index.
Args:
@@ -304,14 +622,22 @@ def commit_index(object_store: ObjectContainer, index: Index) ->bytes:
Note: This function is deprecated, use index.commit() instead.
Returns: Root tree sha.
"""
- pass
-
-
-def changes_from_tree(names: Iterable[bytes], lookup_entry: Callable[[bytes
- ], Tuple[bytes, int]], object_store: ObjectContainer, tree: Optional[
- bytes], want_unchanged=False) ->Iterable[Tuple[Tuple[Optional[bytes],
- Optional[bytes]], Tuple[Optional[int], Optional[int]], Tuple[Optional[
- bytes], Optional[bytes]]]]:
+ return commit_tree(object_store, index.iterobjects())
+
+
+def changes_from_tree(
+ names: Iterable[bytes],
+ lookup_entry: Callable[[bytes], Tuple[bytes, int]],
+ object_store: ObjectContainer,
+ tree: Optional[bytes],
+ want_unchanged=False,
+) -> Iterable[
+ Tuple[
+ Tuple[Optional[bytes], Optional[bytes]],
+ Tuple[Optional[int], Optional[int]],
+ Tuple[Optional[bytes], Optional[bytes]],
+ ]
+]:
"""Find the differences between the contents of a tree and
a working copy.
@@ -324,34 +650,94 @@ def changes_from_tree(names: Iterable[bytes], lookup_entry: Callable[[bytes
Returns: Iterator over tuples with (oldpath, newpath), (oldmode, newmode),
(oldsha, newsha)
"""
- pass
+ # TODO(jelmer): Support a include_trees option
+ other_names = set(names)
+
+ if tree is not None:
+ for name, mode, sha in iter_tree_contents(object_store, tree):
+ try:
+ (other_sha, other_mode) = lookup_entry(name)
+ except KeyError:
+ # Was removed
+ yield ((name, None), (mode, None), (sha, None))
+ else:
+ other_names.remove(name)
+ if want_unchanged or other_sha != sha or other_mode != mode:
+ yield ((name, name), (mode, other_mode), (sha, other_sha))
+
+ # Mention added files
+ for name in other_names:
+ try:
+ (other_sha, other_mode) = lookup_entry(name)
+ except KeyError:
+ pass
+ else:
+ yield ((None, name), (None, other_mode), (None, other_sha))
-def index_entry_from_stat(stat_val, hex_sha: bytes, mode: Optional[int]=None):
+def index_entry_from_stat(
+ stat_val,
+ hex_sha: bytes,
+ mode: Optional[int] = None,
+):
"""Create a new index entry from a stat value.
Args:
stat_val: POSIX stat_result instance
hex_sha: Hex sha of the object
"""
- pass
+ if mode is None:
+ mode = cleanup_mode(stat_val.st_mode)
+ return IndexEntry(
+ stat_val.st_ctime,
+ stat_val.st_mtime,
+ stat_val.st_dev,
+ stat_val.st_ino,
+ mode,
+ stat_val.st_uid,
+ stat_val.st_gid,
+ stat_val.st_size,
+ hex_sha,
+ )
-if sys.platform == 'win32':
+if sys.platform == "win32":
+ # On Windows, creating symlinks either requires administrator privileges
+ # or developer mode. Raise a more helpful error when we're unable to
+ # create symlinks
- class WindowsSymlinkPermissionError(PermissionError):
+ # https://github.com/jelmer/dulwich/issues/1005
- def __init__(self, errno, msg, filename) ->None:
- super(PermissionError, self).__init__(errno,
- f'Unable to create symlink; do you have developer mode enabled? {msg}'
- , filename)
+ class WindowsSymlinkPermissionError(PermissionError):
+ def __init__(self, errno, msg, filename) -> None:
+ super(PermissionError, self).__init__(
+ errno,
+ "Unable to create symlink; "
+ f"do you have developer mode enabled? {msg}",
+ filename,
+ )
+
+ def symlink(src, dst, target_is_directory=False, *, dir_fd=None):
+ try:
+ return os.symlink(
+ src, dst, target_is_directory=target_is_directory, dir_fd=dir_fd
+ )
+ except PermissionError as e:
+ raise WindowsSymlinkPermissionError(e.errno, e.strerror, e.filename) from e
else:
symlink = os.symlink
-def build_file_from_blob(blob: Blob, mode: int, target_path: bytes, *,
- honor_filemode=True, tree_encoding='utf-8', symlink_fn=None):
+def build_file_from_blob(
+ blob: Blob,
+ mode: int,
+ target_path: bytes,
+ *,
+ honor_filemode=True,
+ tree_encoding="utf-8",
+ symlink_fn=None,
+):
"""Build a file or symlink on disk based on a Git object.
Args:
@@ -363,22 +749,70 @@ def build_file_from_blob(blob: Blob, mode: int, target_path: bytes, *,
symlink: Function to use for creating symlinks
Returns: stat object for the file
"""
- pass
+ try:
+ oldstat = os.lstat(target_path)
+ except FileNotFoundError:
+ oldstat = None
+ contents = blob.as_raw_string()
+ if stat.S_ISLNK(mode):
+ if oldstat:
+ os.unlink(target_path)
+ if sys.platform == "win32":
+ # os.readlink on Python3 on Windows requires a unicode string.
+ contents = contents.decode(tree_encoding) # type: ignore
+ target_path = target_path.decode(tree_encoding) # type: ignore
+ (symlink_fn or symlink)(contents, target_path)
+ else:
+ if oldstat is not None and oldstat.st_size == len(contents):
+ with open(target_path, "rb") as f:
+ if f.read() == contents:
+ return oldstat
+ with open(target_path, "wb") as f:
+ # Write out file
+ f.write(contents)
-INVALID_DOTNAMES = b'.git', b'.', b'..', b''
+ if honor_filemode:
+ os.chmod(target_path, mode)
+ return os.lstat(target_path)
+
+
+INVALID_DOTNAMES = (b".git", b".", b"..", b"")
-def validate_path(path: bytes, element_validator=validate_path_element_default
- ) ->bool:
- """Default path validator that just checks for .git/."""
- pass
+def validate_path_element_default(element: bytes) -> bool:
+ return element.lower() not in INVALID_DOTNAMES
-def build_index_from_tree(root_path: Union[str, bytes], index_path: Union[
- str, bytes], object_store: ObjectContainer, tree_id: bytes,
- honor_filemode: bool=True, validate_path_element=
- validate_path_element_default, symlink_fn=None):
+
+def validate_path_element_ntfs(element: bytes) -> bool:
+ stripped = element.rstrip(b". ").lower()
+ if stripped in INVALID_DOTNAMES:
+ return False
+ if stripped == b"git~1":
+ return False
+ return True
+
+
+def validate_path(path: bytes, element_validator=validate_path_element_default) -> bool:
+ """Default path validator that just checks for .git/."""
+ parts = path.split(b"/")
+ for p in parts:
+ if not element_validator(p):
+ return False
+ else:
+ return True
+
+
+def build_index_from_tree(
+ root_path: Union[str, bytes],
+ index_path: Union[str, bytes],
+ object_store: ObjectContainer,
+ tree_id: bytes,
+ honor_filemode: bool = True,
+ validate_path_element=validate_path_element_default,
+ symlink_fn=None,
+):
"""Generate and materialize index from a tree.
Args:
@@ -394,10 +828,61 @@ def build_index_from_tree(root_path: Union[str, bytes], index_path: Union[
Note: existing index is wiped and contents are not merged
in a working dir. Suitable only for fresh clones.
"""
- pass
-
-
-def blob_from_path_and_mode(fs_path: bytes, mode: int, tree_encoding='utf-8'):
+ index = Index(index_path, read=False)
+ if not isinstance(root_path, bytes):
+ root_path = os.fsencode(root_path)
+
+ for entry in iter_tree_contents(object_store, tree_id):
+ if not validate_path(entry.path, validate_path_element):
+ continue
+ full_path = _tree_to_fs_path(root_path, entry.path)
+
+ if not os.path.exists(os.path.dirname(full_path)):
+ os.makedirs(os.path.dirname(full_path))
+
+ # TODO(jelmer): Merge new index into working tree
+ if S_ISGITLINK(entry.mode):
+ if not os.path.isdir(full_path):
+ os.mkdir(full_path)
+ st = os.lstat(full_path)
+ # TODO(jelmer): record and return submodule paths
+ else:
+ obj = object_store[entry.sha]
+ assert isinstance(obj, Blob)
+ st = build_file_from_blob(
+ obj,
+ entry.mode,
+ full_path,
+ honor_filemode=honor_filemode,
+ symlink_fn=symlink_fn,
+ )
+
+ # Add file to index
+ if not honor_filemode or S_ISGITLINK(entry.mode):
+ # we can not use tuple slicing to build a new tuple,
+ # because on windows that will convert the times to
+ # longs, which causes errors further along
+ st_tuple = (
+ entry.mode,
+ st.st_ino,
+ st.st_dev,
+ st.st_nlink,
+ st.st_uid,
+ st.st_gid,
+ st.st_size,
+ st.st_atime,
+ st.st_mtime,
+ st.st_ctime,
+ )
+ st = st.__class__(st_tuple)
+ # default to a stage 0 index entry (normal)
+ # when reading from the filesystem
+ index[entry.path] = index_entry_from_stat(st, entry.sha)
+
+ index.write()
+
+
+def blob_from_path_and_mode(fs_path: bytes, mode: int, tree_encoding="utf-8"):
"""Create a blob from a path and a stat object.
Args:
@@ -405,10 +890,21 @@ def blob_from_path_and_mode(fs_path: bytes, mode: int, tree_encoding='utf-8'):
mode: File mode
Returns: A `Blob` object
"""
- pass
+ assert isinstance(fs_path, bytes)
+ blob = Blob()
+ if stat.S_ISLNK(mode):
+ if sys.platform == "win32":
+ # os.readlink on Python3 on Windows requires a unicode string.
+ blob.data = os.readlink(os.fsdecode(fs_path)).encode(tree_encoding)
+ else:
+ blob.data = os.readlink(fs_path)
+ else:
+ with open(fs_path, "rb") as f:
+ blob.data = f.read()
+ return blob
-def blob_from_path_and_stat(fs_path: bytes, st, tree_encoding='utf-8'):
+def blob_from_path_and_stat(fs_path: bytes, st, tree_encoding="utf-8"):
"""Create a blob from a path and a stat object.
Args:
@@ -416,17 +912,31 @@ def blob_from_path_and_stat(fs_path: bytes, st, tree_encoding='utf-8'):
st: A stat object
Returns: A `Blob` object
"""
- pass
+ return blob_from_path_and_mode(fs_path, st.st_mode, tree_encoding)
-def read_submodule_head(path: Union[str, bytes]) ->Optional[bytes]:
+def read_submodule_head(path: Union[str, bytes]) -> Optional[bytes]:
"""Read the head commit of a submodule.
Args:
path: path to the submodule
Returns: HEAD sha, None if not a valid head/repository
"""
- pass
+ from .errors import NotGitRepository
+ from .repo import Repo
+
+ # Repo currently expects a "str", so decode if necessary.
+ # TODO(jelmer): Perhaps move this into Repo() ?
+ if not isinstance(path, str):
+ path = os.fsdecode(path)
+ try:
+ repo = Repo(path)
+ except NotGitRepository:
+ return None
+ try:
+ return repo.head()
+ except KeyError:
+ return None
def _has_directory_changed(tree_path: bytes, entry):
@@ -441,11 +951,22 @@ def _has_directory_changed(tree_path: bytes, entry):
Return true if the given path should be considered as changed and False
otherwise or if the path is not a directory.
"""
- pass
-
-
-def get_unstaged_changes(index: Index, root_path: Union[str, bytes],
- filter_blob_callback=None):
+ # This is actually a directory
+ if os.path.exists(os.path.join(tree_path, b".git")):
+ # Submodule
+ head = read_submodule_head(tree_path)
+ if entry.sha != head:
+ return True
+ else:
+ # The file was changed to a directory, so consider it removed.
+ return True
+
+ return False
+
+
+def get_unstaged_changes(
+ index: Index, root_path: Union[str, bytes], filter_blob_callback=None
+):
"""Walk through an index and check for differences against working tree.
Args:
@@ -453,10 +974,41 @@ def get_unstaged_changes(index: Index, root_path: Union[str, bytes],
root_path: path in which to find files
Returns: iterator over paths with unstaged changes
"""
- pass
+ # For each entry in the index check the sha1 & ensure not staged
+ if not isinstance(root_path, bytes):
+ root_path = os.fsencode(root_path)
+
+ for tree_path, entry in index.iteritems():
+ full_path = _tree_to_fs_path(root_path, tree_path)
+ if isinstance(entry, ConflictedIndexEntry):
+ # Conflicted files are always unstaged
+ yield tree_path
+ continue
+
+ try:
+ st = os.lstat(full_path)
+ if stat.S_ISDIR(st.st_mode):
+ if _has_directory_changed(tree_path, entry):
+ yield tree_path
+ continue
+
+ if not stat.S_ISREG(st.st_mode) and not stat.S_ISLNK(st.st_mode):
+ continue
+
+ blob = blob_from_path_and_stat(full_path, st)
+
+ if filter_blob_callback is not None:
+ blob = filter_blob_callback(blob, tree_path)
+ except FileNotFoundError:
+ # The file was removed, so we assume that counts as
+ # different from whatever file used to exist.
+ yield tree_path
+ else:
+ if blob.id != entry.sha:
+ yield tree_path
-os_sep_bytes = os.sep.encode('ascii')
+os_sep_bytes = os.sep.encode("ascii")
def _tree_to_fs_path(root_path: bytes, tree_path: bytes):
@@ -468,10 +1020,15 @@ def _tree_to_fs_path(root_path: bytes, tree_path: bytes):
Returns: File system path.
"""
- pass
+ assert isinstance(tree_path, bytes)
+ if os_sep_bytes != b"/":
+ sep_corrected_path = tree_path.replace(b"/", os_sep_bytes)
+ else:
+ sep_corrected_path = tree_path
+ return os.path.join(root_path, sep_corrected_path)
-def _fs_to_tree_path(fs_path: Union[str, bytes]) ->bytes:
+def _fs_to_tree_path(fs_path: Union[str, bytes]) -> bytes:
"""Convert a file system path to a git tree path.
Args:
@@ -479,11 +1036,29 @@ def _fs_to_tree_path(fs_path: Union[str, bytes]) ->bytes:
Returns: Git tree path as bytes
"""
- pass
-
-
-def index_entry_from_path(path: bytes, object_store: Optional[
- ObjectContainer]=None) ->Optional[IndexEntry]:
+ if not isinstance(fs_path, bytes):
+ fs_path_bytes = os.fsencode(fs_path)
+ else:
+ fs_path_bytes = fs_path
+ if os_sep_bytes != b"/":
+ tree_path = fs_path_bytes.replace(os_sep_bytes, b"/")
+ else:
+ tree_path = fs_path_bytes
+ return tree_path
+
+
+def index_entry_from_directory(st, path: bytes) -> Optional[IndexEntry]:
+ if os.path.exists(os.path.join(path, b".git")):
+ head = read_submodule_head(path)
+ if head is None:
+ return None
+ return index_entry_from_stat(st, head, mode=S_IFGITLINK)
+ return None
+
+
+def index_entry_from_path(
+ path: bytes, object_store: Optional[ObjectContainer] = None
+) -> Optional[IndexEntry]:
"""Create an index from a filesystem path.
This returns an index value for files, symlinks
@@ -496,12 +1071,25 @@ def index_entry_from_path(path: bytes, object_store: Optional[
save new blobs in
Returns: An index entry; None for directories
"""
- pass
+ assert isinstance(path, bytes)
+ st = os.lstat(path)
+ if stat.S_ISDIR(st.st_mode):
+ return index_entry_from_directory(st, path)
+ if stat.S_ISREG(st.st_mode) or stat.S_ISLNK(st.st_mode):
+ blob = blob_from_path_and_stat(path, st)
+ if object_store is not None:
+ object_store.add_object(blob)
+ return index_entry_from_stat(st, blob.id)
-def iter_fresh_entries(paths: Iterable[bytes], root_path: bytes,
- object_store: Optional[ObjectContainer]=None) ->Iterator[Tuple[bytes,
- Optional[IndexEntry]]]:
+ return None
+
+
+def iter_fresh_entries(
+ paths: Iterable[bytes],
+ root_path: bytes,
+ object_store: Optional[ObjectContainer] = None,
+) -> Iterator[Tuple[bytes, Optional[IndexEntry]]]:
"""Iterate over current versions of index entries on disk.
Args:
@@ -510,12 +1098,18 @@ def iter_fresh_entries(paths: Iterable[bytes], root_path: bytes,
object_store: Optional store to save new blobs in
Returns: Iterator over path, index_entry
"""
- pass
+ for path in paths:
+ p = _tree_to_fs_path(root_path, path)
+ try:
+ entry = index_entry_from_path(p, object_store=object_store)
+ except (FileNotFoundError, IsADirectoryError):
+ entry = None
+ yield path, entry
-def iter_fresh_objects(paths: Iterable[bytes], root_path: bytes,
- include_deleted=False, object_store=None) ->Iterator[Tuple[bytes,
- Optional[bytes], Optional[int]]]:
+def iter_fresh_objects(
+ paths: Iterable[bytes], root_path: bytes, include_deleted=False, object_store=None
+) -> Iterator[Tuple[bytes, Optional[bytes], Optional[int]]]:
"""Iterate over versions of objects on disk referenced by index.
Args:
@@ -525,7 +1119,12 @@ def iter_fresh_objects(paths: Iterable[bytes], root_path: bytes,
object_store: Optional object store to report new items to
Returns: Iterator over path, sha, mode
"""
- pass
+ for path, entry in iter_fresh_entries(paths, root_path, object_store=object_store):
+ if entry is None:
+ if include_deleted:
+ yield path, None, None
+ else:
+ yield path, entry.sha, cleanup_mode(entry.mode)
def refresh_index(index: Index, root_path: bytes):
@@ -537,7 +1136,9 @@ def refresh_index(index: Index, root_path: bytes):
index: Index to update
root_path: Root filesystem path
"""
- pass
+ for path, entry in iter_fresh_entries(index, root_path):
+ if entry:
+ index[path] = entry
class locked_index:
@@ -546,11 +1147,11 @@ class locked_index:
Works as a context manager.
"""
- def __init__(self, path: Union[bytes, str]) ->None:
+ def __init__(self, path: Union[bytes, str]) -> None:
self._path = path
def __enter__(self):
- self._file = GitFile(self._path, 'wb')
+ self._file = GitFile(self._path, "wb")
self._index = Index(self._path)
return self._index
diff --git a/dulwich/lfs.py b/dulwich/lfs.py
index b93c99c8..97933647 100644
--- a/dulwich/lfs.py
+++ b/dulwich/lfs.py
@@ -1,3 +1,23 @@
+# lfs.py -- Implementation of the LFS
+# Copyright (C) 2020 Jelmer Vernooij
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
import hashlib
import os
import tempfile
@@ -6,16 +26,49 @@ import tempfile
class LFSStore:
"""Stores objects on disk, indexed by SHA256."""
- def __init__(self, path) ->None:
+ def __init__(self, path) -> None:
self.path = path
+ @classmethod
+ def create(cls, lfs_dir):
+ if not os.path.isdir(lfs_dir):
+ os.mkdir(lfs_dir)
+ os.mkdir(os.path.join(lfs_dir, "tmp"))
+ os.mkdir(os.path.join(lfs_dir, "objects"))
+ return cls(lfs_dir)
+
+ @classmethod
+ def from_repo(cls, repo, create=False):
+ lfs_dir = os.path.join(repo.controldir, "lfs")
+ if create:
+ return cls.create(lfs_dir)
+ return cls(lfs_dir)
+
+ def _sha_path(self, sha):
+ return os.path.join(self.path, "objects", sha[0:2], sha[2:4], sha)
+
def open_object(self, sha):
"""Open an object by sha."""
- pass
+ try:
+ return open(self._sha_path(sha), "rb")
+ except FileNotFoundError as exc:
+ raise KeyError(sha) from exc
def write_object(self, chunks):
"""Write an object.
Returns: object SHA
"""
- pass
+ sha = hashlib.sha256()
+ tmpdir = os.path.join(self.path, "tmp")
+ with tempfile.NamedTemporaryFile(dir=tmpdir, mode="wb", delete=False) as f:
+ for chunk in chunks:
+ sha.update(chunk)
+ f.write(chunk)
+ f.flush()
+ tmppath = f.name
+ path = self._sha_path(sha.hexdigest())
+ if not os.path.exists(os.path.dirname(path)):
+ os.makedirs(os.path.dirname(path))
+ os.rename(tmppath, path)
+ return sha.hexdigest()
diff --git a/dulwich/line_ending.py b/dulwich/line_ending.py
index 9d4a6618..adfa91bb 100644
--- a/dulwich/line_ending.py
+++ b/dulwich/line_ending.py
@@ -1,4 +1,23 @@
-"""All line-ending related functions, from conversions to config processing.
+# line_ending.py -- Line ending conversion functions
+# Copyright (C) 2018-2018 Boris Feld <boris.feld@comet.ml>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+r"""All line-ending related functions, from conversions to config processing.
Line-ending normalization is a complex beast. Here is some notes and details
about how it seems to work.
@@ -42,23 +61,23 @@ There is multiple variables that impact the normalization.
First, a repository can contains a ``.gitattributes`` file (or more than one...)
that can further customize the operation on some file patterns, for example:
- \\*.txt text
+ \*.txt text
Force all ``.txt`` files to be treated as text files and to have their lines
endings normalized.
- \\*.jpg -text
+ \*.jpg -text
Force all ``.jpg`` files to be treated as binary files and to not have their
lines endings converted.
- \\*.vcproj text eol=crlf
+ \*.vcproj text eol=crlf
Force all ``.vcproj`` files to be treated as text files and to have their lines
endings converted into ``CRLF`` in working directory no matter the native EOL of
the platform.
- \\*.sh text eol=lf
+ \*.sh text eol=lf
Force all ``.sh`` files to be treated as text files and to have their lines
endings converted into ``LF`` in working directory no matter the native EOL of
@@ -67,7 +86,7 @@ the platform.
If the ``eol`` attribute is not defined, Git uses the ``core.eol`` configuration
value described later.
- \\* text=auto
+ \* text=auto
Force all files to be scanned by the text file heuristic detection and to have
their line endings normalized in case they are detected as text files.
@@ -116,11 +135,13 @@ Sources:
- https://git-scm.com/docs/gitattributes#_checking_out_and_checking_in
- https://adaptivepatchwork.com/2012/03/01/mind-the-end-of-your-line/
"""
+
from .object_store import iter_tree_contents
from .objects import Blob
from .patch import is_binary
-CRLF = b'\r\n'
-LF = b'\n'
+
+CRLF = b"\r\n"
+LF = b"\n"
def convert_crlf_to_lf(text_hunk):
@@ -130,7 +151,7 @@ def convert_crlf_to_lf(text_hunk):
text_hunk: A bytes string representing a text hunk
Returns: The text hunk with the same type, with CRLF replaced into LF
"""
- pass
+ return text_hunk.replace(CRLF, LF)
def convert_lf_to_crlf(text_hunk):
@@ -140,17 +161,25 @@ def convert_lf_to_crlf(text_hunk):
text_hunk: A bytes string representing a text hunk
Returns: The text hunk with the same type, with LF replaced into CRLF
"""
- pass
+ # TODO find a more efficient way of doing it
+ intermediary = text_hunk.replace(CRLF, LF)
+ return intermediary.replace(LF, CRLF)
def get_checkout_filter(core_eol, core_autocrlf, git_attributes):
"""Returns the correct checkout filter based on the passed arguments."""
- pass
+ # TODO this function should process the git_attributes for the path and if
+ # the text attribute is not defined, fallback on the
+ # get_checkout_filter_autocrlf function with the autocrlf value
+ return get_checkout_filter_autocrlf(core_autocrlf)
def get_checkin_filter(core_eol, core_autocrlf, git_attributes):
"""Returns the correct checkin filter based on the passed arguments."""
- pass
+ # TODO this function should process the git_attributes for the path and if
+ # the text attribute is not defined, fallback on the
+ # get_checkin_filter_autocrlf function with the autocrlf value
+ return get_checkin_filter_autocrlf(core_autocrlf)
def get_checkout_filter_autocrlf(core_autocrlf):
@@ -162,7 +191,10 @@ def get_checkout_filter_autocrlf(core_autocrlf):
Returns: Either None if no filter has to be applied or a function
accepting a single argument, a binary text hunk
"""
- pass
+ if core_autocrlf == b"true":
+ return convert_lf_to_crlf
+
+ return None
def get_checkin_filter_autocrlf(core_autocrlf):
@@ -174,7 +206,11 @@ def get_checkin_filter_autocrlf(core_autocrlf):
Returns: Either None if no filter has to be applied or a function
accepting a single argument, a binary text hunk
"""
- pass
+ if core_autocrlf == b"true" or core_autocrlf == b"input":
+ return convert_crlf_to_lf
+
+ # Checking filter should never be `convert_lf_to_crlf`
+ return None
class BlobNormalizer:
@@ -182,29 +218,45 @@ class BlobNormalizer:
on configuration, gitattributes, path and operation (checkin or checkout).
"""
- def __init__(self, config_stack, gitattributes) ->None:
+ def __init__(self, config_stack, gitattributes) -> None:
self.config_stack = config_stack
self.gitattributes = gitattributes
+
+ # Compute which filters we needs based on parameters
try:
- core_eol = config_stack.get('core', 'eol')
+ core_eol = config_stack.get("core", "eol")
except KeyError:
- core_eol = 'native'
+ core_eol = "native"
+
try:
- core_autocrlf = config_stack.get('core', 'autocrlf').lower()
+ core_autocrlf = config_stack.get("core", "autocrlf").lower()
except KeyError:
core_autocrlf = False
- self.fallback_read_filter = get_checkout_filter(core_eol,
- core_autocrlf, self.gitattributes)
- self.fallback_write_filter = get_checkin_filter(core_eol,
- core_autocrlf, self.gitattributes)
+
+ self.fallback_read_filter = get_checkout_filter(
+ core_eol, core_autocrlf, self.gitattributes
+ )
+ self.fallback_write_filter = get_checkin_filter(
+ core_eol, core_autocrlf, self.gitattributes
+ )
def checkin_normalize(self, blob, tree_path):
"""Normalize a blob during a checkin operation."""
- pass
+ if self.fallback_write_filter is not None:
+ return normalize_blob(
+ blob, self.fallback_write_filter, binary_detection=True
+ )
+
+ return blob
def checkout_normalize(self, blob, tree_path):
"""Normalize a blob during a checkout operation."""
- pass
+ if self.fallback_read_filter is not None:
+ return normalize_blob(
+ blob, self.fallback_read_filter, binary_detection=True
+ )
+
+ return blob
def normalize_blob(blob, conversion, binary_detection):
@@ -212,16 +264,41 @@ def normalize_blob(blob, conversion, binary_detection):
binary_detection is True and the blob content looks like binary, else
return a new blob with converted data.
"""
- pass
+ # Read the original blob
+ data = blob.data
+ # If we need to detect if a file is binary and the file is detected as
+ # binary, do not apply the conversion function and return the original
+ # chunked text
+ if binary_detection is True:
+ if is_binary(data):
+ return blob
-class TreeBlobNormalizer(BlobNormalizer):
+ # Now apply the conversion
+ converted_data = conversion(data)
+
+ new_blob = Blob()
+ new_blob.data = converted_data
+
+ return new_blob
- def __init__(self, config_stack, git_attributes, object_store, tree=None
- ) ->None:
+
+class TreeBlobNormalizer(BlobNormalizer):
+ def __init__(self, config_stack, git_attributes, object_store, tree=None) -> None:
super().__init__(config_stack, git_attributes)
if tree:
- self.existing_paths = {name for name, _, _ in
- iter_tree_contents(object_store, tree)}
+ self.existing_paths = {
+ name for name, _, _ in iter_tree_contents(object_store, tree)
+ }
else:
self.existing_paths = set()
+
+ def checkin_normalize(self, blob, tree_path):
+ # Existing files should only be normalized on checkin if it was
+ # previously normalized on checkout
+ if (
+ self.fallback_read_filter is not None
+ or tree_path not in self.existing_paths
+ ):
+ return super().checkin_normalize(blob, tree_path)
+ return blob
diff --git a/dulwich/log_utils.py b/dulwich/log_utils.py
index d6736a40..556332df 100644
--- a/dulwich/log_utils.py
+++ b/dulwich/log_utils.py
@@ -1,3 +1,23 @@
+# log_utils.py -- Logging utilities for Dulwich
+# Copyright (C) 2010 Google, Inc.
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Logging utilities for Dulwich.
Any module that uses logging needs to do compile-time initialization to set up
@@ -14,23 +34,33 @@ getLogger; this module exports that function for convenience. If a calling
module needs something else, it can import the standard logging module
directly.
"""
+
import logging
import sys
+
getLogger = logging.getLogger
class _NullHandler(logging.Handler):
"""No-op logging handler to avoid unexpected logging warnings."""
+ def emit(self, record):
+ pass
+
_NULL_HANDLER = _NullHandler()
-_DULWICH_LOGGER = getLogger('dulwich')
+_DULWICH_LOGGER = getLogger("dulwich")
_DULWICH_LOGGER.addHandler(_NULL_HANDLER)
def default_logging_config():
"""Set up the default Dulwich loggers."""
- pass
+ remove_null_handler()
+ logging.basicConfig(
+ level=logging.INFO,
+ stream=sys.stderr,
+ format="%(asctime)s %(levelname)s: %(message)s",
+ )
def remove_null_handler():
@@ -40,4 +70,4 @@ def remove_null_handler():
default_logging_config, calling this function first is a minor optimization
to avoid the overhead of using the _NullHandler.
"""
- pass
+ _DULWICH_LOGGER.removeHandler(_NULL_HANDLER)
diff --git a/dulwich/lru_cache.py b/dulwich/lru_cache.py
index 651ebe4c..5d93f370 100644
--- a/dulwich/lru_cache.py
+++ b/dulwich/lru_cache.py
@@ -1,59 +1,108 @@
+# lru_cache.py -- Simple LRU cache for dulwich
+# Copyright (C) 2006, 2008 Canonical Ltd
+# Copyright (C) 2022 Jelmer Vernooij <jelmer@jelmer.uk>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""A simple least-recently-used (LRU) cache."""
+
from typing import Callable, Dict, Generic, Iterable, Iterator, Optional, TypeVar
+
_null_key = object()
-K = TypeVar('K')
-V = TypeVar('V')
+
+
+K = TypeVar("K")
+V = TypeVar("V")
class _LRUNode(Generic[K, V]):
"""This maintains the linked-list which is the lru internals."""
- __slots__ = 'prev', 'next_key', 'key', 'value', 'cleanup', 'size'
- prev: Optional['_LRUNode[K, V]']
+
+ __slots__ = ("prev", "next_key", "key", "value", "cleanup", "size")
+
+ prev: Optional["_LRUNode[K, V]"]
next_key: K
size: Optional[int]
- def __init__(self, key: K, value: V, cleanup=None) ->None:
+ def __init__(self, key: K, value: V, cleanup=None) -> None:
self.prev = None
- self.next_key = _null_key
+ self.next_key = _null_key # type: ignore
self.key = key
self.value = value
self.cleanup = cleanup
+ # TODO: We could compute this 'on-the-fly' like we used to, and remove
+ # one pointer from this object, we just need to decide if it
+ # actually costs us much of anything in normal usage
self.size = None
- def __repr__(self) ->str:
+ def __repr__(self) -> str:
if self.prev is None:
prev_key = None
else:
prev_key = self.prev.key
- return (
- f'{self.__class__.__name__}({self.key!r} n:{self.next_key!r} p:{prev_key!r})'
- )
+ return f"{self.__class__.__name__}({self.key!r} n:{self.next_key!r} p:{prev_key!r})"
+
+ def run_cleanup(self) -> None:
+ if self.cleanup is not None:
+ self.cleanup(self.key, self.value)
+ self.cleanup = None
+ # Just make sure to break any refcycles, etc
+ del self.value
class LRUCache(Generic[K, V]):
"""A class which manages a cache of entries, removing unused ones."""
+
_least_recently_used: Optional[_LRUNode[K, V]]
_most_recently_used: Optional[_LRUNode[K, V]]
- def __init__(self, max_cache: int=100, after_cleanup_count: Optional[
- int]=None) ->None:
+ def __init__(
+ self, max_cache: int = 100, after_cleanup_count: Optional[int] = None
+ ) -> None:
self._cache: Dict[K, _LRUNode[K, V]] = {}
+ # The "HEAD" of the lru linked list
self._most_recently_used = None
+ # The "TAIL" of the lru linked list
self._least_recently_used = None
self._update_max_cache(max_cache, after_cleanup_count)
- def __contains__(self, key: K) ->bool:
+ def __contains__(self, key: K) -> bool:
return key in self._cache
- def __getitem__(self, key: K) ->V:
+ def __getitem__(self, key: K) -> V:
cache = self._cache
node = cache[key]
+ # Inlined from _record_access to decrease the overhead of __getitem__
+ # We also have more knowledge about structure if __getitem__ is
+ # succeeding, then we know that self._most_recently_used must not be
+ # None, etc.
mru = self._most_recently_used
if node is mru:
+ # Nothing to do, this node is already at the head of the queue
return node.value
+ # Remove this node from the old location
node_prev = node.prev
next_key = node.next_key
+ # benchmarking shows that the lookup of _null_key in globals is faster
+ # than the attribute lookup for (node is self._least_recently_used)
if next_key is _null_key:
+ # 'node' is the _least_recently_used, because it doesn't have a
+ # 'next' item. So move the current lru to the previous node.
self._least_recently_used = node_prev
else:
node_next = cache[next_key]
@@ -61,21 +110,56 @@ class LRUCache(Generic[K, V]):
assert node_prev
assert mru
node_prev.next_key = next_key
+ # Insert this node at the front of the list
node.next_key = mru.key
mru.prev = node
self._most_recently_used = node
node.prev = None
return node.value
- def __len__(self) ->int:
+ def __len__(self) -> int:
return len(self._cache)
- def _walk_lru(self) ->Iterator[_LRUNode[K, V]]:
+ def _walk_lru(self) -> Iterator[_LRUNode[K, V]]:
"""Walk the LRU list, only meant to be used in tests."""
- pass
-
- def add(self, key: K, value: V, cleanup: Optional[Callable[[K, V], None
- ]]=None) ->None:
+ node = self._most_recently_used
+ if node is not None:
+ if node.prev is not None:
+ raise AssertionError(
+ "the _most_recently_used entry is not"
+ " supposed to have a previous entry"
+ f" {node}"
+ )
+ while node is not None:
+ if node.next_key is _null_key:
+ if node is not self._least_recently_used:
+ raise AssertionError(
+ "only the last node should have" f" no next value: {node}"
+ )
+ node_next = None
+ else:
+ node_next = self._cache[node.next_key]
+ if node_next.prev is not node:
+ raise AssertionError(
+ "inconsistency found, node.next.prev" f" != node: {node}"
+ )
+ if node.prev is None:
+ if node is not self._most_recently_used:
+ raise AssertionError(
+ "only the _most_recently_used should"
+ f" not have a previous node: {node}"
+ )
+ else:
+ if node.prev.next_key != node.key:
+ raise AssertionError(
+ "inconsistency found, node.prev.next" f" != node: {node}"
+ )
+ yield node
+ node = node_next
+
+ def add(
+ self, key: K, value: V, cleanup: Optional[Callable[[K, V], None]] = None
+ ) -> None:
"""Add a new value to the cache.
Also, if the entry is ever removed from the cache, call
@@ -87,13 +171,34 @@ class LRUCache(Generic[K, V]):
cleanup: None or a function taking (key, value) to indicate
'value' should be cleaned up.
"""
- pass
+ if key is _null_key:
+ raise ValueError("cannot use _null_key as a key")
+ if key in self._cache:
+ node = self._cache[key]
+ node.run_cleanup()
+ node.value = value
+ node.cleanup = cleanup
+ else:
+ node = _LRUNode(key, value, cleanup=cleanup)
+ self._cache[key] = node
+ self._record_access(node)
+
+ if len(self._cache) > self._max_cache:
+ # Trigger the cleanup
+ self.cleanup()
- def cache_size(self) ->int:
+ def cache_size(self) -> int:
"""Get the number of entries we will cache."""
- pass
+ return self._max_cache
+
+ def get(self, key: K, default: Optional[V] = None) -> Optional[V]:
+ node = self._cache.get(key, None)
+ if node is None:
+ return default
+ self._record_access(node)
+ return node.value
- def keys(self) ->Iterable[K]:
+ def keys(self) -> Iterable[K]:
"""Get the list of keys currently cached.
Note that values returned here may not be available by the time you
@@ -102,11 +207,11 @@ class LRUCache(Generic[K, V]):
Returns: An unordered list of keys that are currently cached.
"""
- pass
+ return self._cache.keys()
- def items(self) ->Dict[K, V]:
+ def items(self) -> Dict[K, V]:
"""Get the key:value pairs as a dict."""
- pass
+ return {k: n.value for k, n in self._cache.items()}
def cleanup(self):
"""Clear the cache until it shrinks to the requested size.
@@ -114,32 +219,84 @@ class LRUCache(Generic[K, V]):
This does not completely wipe the cache, just makes sure it is under
the after_cleanup_count.
"""
- pass
+ # Make sure the cache is shrunk to the correct size
+ while len(self._cache) > self._after_cleanup_count:
+ self._remove_lru()
- def __setitem__(self, key: K, value: V) ->None:
+ def __setitem__(self, key: K, value: V) -> None:
"""Add a value to the cache, there will be no cleanup function."""
self.add(key, value, cleanup=None)
- def _record_access(self, node: _LRUNode[K, V]) ->None:
+ def _record_access(self, node: _LRUNode[K, V]) -> None:
"""Record that key was accessed."""
- pass
+ # Move 'node' to the front of the queue
+ if self._most_recently_used is None:
+ self._most_recently_used = node
+ self._least_recently_used = node
+ return
+ elif node is self._most_recently_used:
+ # Nothing to do, this node is already at the head of the queue
+ return
+ # We've taken care of the tail pointer, remove the node, and insert it
+ # at the front
+ # REMOVE
+ if node is self._least_recently_used:
+ self._least_recently_used = node.prev
+ if node.prev is not None:
+ node.prev.next_key = node.next_key
+ if node.next_key is not _null_key:
+ node_next = self._cache[node.next_key]
+ node_next.prev = node.prev
+ # INSERT
+ node.next_key = self._most_recently_used.key
+ self._most_recently_used.prev = node
+ self._most_recently_used = node
+ node.prev = None
- def _remove_lru(self) ->None:
+ def _remove_node(self, node: _LRUNode[K, V]) -> None:
+ if node is self._least_recently_used:
+ self._least_recently_used = node.prev
+ self._cache.pop(node.key)
+ # If we have removed all entries, remove the head pointer as well
+ if self._least_recently_used is None:
+ self._most_recently_used = None
+ node.run_cleanup()
+ # Now remove this node from the linked list
+ if node.prev is not None:
+ node.prev.next_key = node.next_key
+ if node.next_key is not _null_key:
+ node_next = self._cache[node.next_key]
+ node_next.prev = node.prev
+ # And remove this node's pointers
+ node.prev = None
+ node.next_key = _null_key # type: ignore
+
+ def _remove_lru(self) -> None:
"""Remove one entry from the lru, and handle consequences.
If there are no more references to the lru, then this entry should be
removed from the cache.
"""
- pass
+ assert self._least_recently_used
+ self._remove_node(self._least_recently_used)
- def clear(self) ->None:
+ def clear(self) -> None:
"""Clear out all of the cache."""
- pass
+ # Clean up in LRU order
+ while self._cache:
+ self._remove_lru()
- def resize(self, max_cache: int, after_cleanup_count: Optional[int]=None
- ) ->None:
+ def resize(self, max_cache: int, after_cleanup_count: Optional[int] = None) -> None:
"""Change the number of entries that will be cached."""
- pass
+ self._update_max_cache(max_cache, after_cleanup_count=after_cleanup_count)
+
+ def _update_max_cache(self, max_cache, after_cleanup_count=None):
+ self._max_cache = max_cache
+ if after_cleanup_count is None:
+ self._after_cleanup_count = self._max_cache * 8 / 10
+ else:
+ self._after_cleanup_count = min(after_cleanup_count, self._max_cache)
+ self.cleanup()
class LRUSizeCache(LRUCache[K, V]):
@@ -151,11 +308,15 @@ class LRUSizeCache(LRUCache[K, V]):
The size of items added will be computed using compute_size(value), which
defaults to len() if not supplied.
"""
+
_compute_size: Callable[[V], int]
- def __init__(self, max_size: int=1024 * 1024, after_cleanup_size:
- Optional[int]=None, compute_size: Optional[Callable[[V], int]]=None
- ) ->None:
+ def __init__(
+ self,
+ max_size: int = 1024 * 1024,
+ after_cleanup_size: Optional[int] = None,
+ compute_size: Optional[Callable[[V], int]] = None,
+ ) -> None:
"""Create a new LRUSizeCache.
Args:
@@ -172,14 +333,15 @@ class LRUSizeCache(LRUCache[K, V]):
"""
self._value_size = 0
if compute_size is None:
- self._compute_size = len
+ self._compute_size = len # type: ignore
else:
self._compute_size = compute_size
self._update_max_size(max_size, after_cleanup_size=after_cleanup_size)
LRUCache.__init__(self, max_cache=max(int(max_size / 512), 1))
- def add(self, key: K, value: V, cleanup: Optional[Callable[[K, V], None
- ]]=None) ->None:
+ def add(
+ self, key: K, value: V, cleanup: Optional[Callable[[K, V], None]] = None
+ ) -> None:
"""Add a new value to the cache.
Also, if the entry is ever removed from the cache, call
@@ -191,17 +353,59 @@ class LRUSizeCache(LRUCache[K, V]):
cleanup: None or a function taking (key, value) to indicate
'value' should be cleaned up.
"""
- pass
+ if key is _null_key:
+ raise ValueError("cannot use _null_key as a key")
+ node = self._cache.get(key, None)
+ value_len = self._compute_size(value)
+ if value_len >= self._after_cleanup_size:
+ # The new value is 'too big to fit', as it would fill up/overflow
+ # the cache all by itself
+ if node is not None:
+ # We won't be replacing the old node, so just remove it
+ self._remove_node(node)
+ if cleanup is not None:
+ cleanup(key, value)
+ return
+ if node is None:
+ node = _LRUNode(key, value, cleanup=cleanup)
+ self._cache[key] = node
+ else:
+ assert node.size is not None
+ self._value_size -= node.size
+ node.size = value_len
+ self._value_size += value_len
+ self._record_access(node)
+
+ if self._value_size > self._max_size:
+ # Time to cleanup
+ self.cleanup()
- def cleanup(self) ->None:
+ def cleanup(self) -> None:
"""Clear the cache until it shrinks to the requested size.
This does not completely wipe the cache, just makes sure it is under
the after_cleanup_size.
"""
- pass
+ # Make sure the cache is shrunk to the correct size
+ while self._value_size > self._after_cleanup_size:
+ self._remove_lru()
- def resize(self, max_size: int, after_cleanup_size: Optional[int]=None
- ) ->None:
+ def _remove_node(self, node: _LRUNode[K, V]) -> None:
+ assert node.size is not None
+ self._value_size -= node.size
+ LRUCache._remove_node(self, node)
+
+ def resize(self, max_size: int, after_cleanup_size: Optional[int] = None) -> None:
"""Change the number of bytes that will be cached."""
- pass
+ self._update_max_size(max_size, after_cleanup_size=after_cleanup_size)
+ max_cache = max(int(max_size / 512), 1)
+ self._update_max_cache(max_cache)
+
+ def _update_max_size(
+ self, max_size: int, after_cleanup_size: Optional[int] = None
+ ) -> None:
+ self._max_size = max_size
+ if after_cleanup_size is None:
+ self._after_cleanup_size = self._max_size * 8 // 10
+ else:
+ self._after_cleanup_size = min(after_cleanup_size, self._max_size)
diff --git a/dulwich/mailmap.py b/dulwich/mailmap.py
index d866cd63..9ed9a88b 100644
--- a/dulwich/mailmap.py
+++ b/dulwich/mailmap.py
@@ -1,7 +1,41 @@
+# mailmap.py -- Mailmap reader
+# Copyright (C) 2018 Jelmer Vernooij <jelmer@jelmer.uk>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Mailmap file reader."""
+
from typing import Dict, Optional, Tuple
+def parse_identity(text):
+ # TODO(jelmer): Integrate this with dulwich.fastexport.split_email and
+ # dulwich.repo.check_user_identity
+ (name, email) = text.rsplit(b"<", 1)
+ name = name.strip()
+ email = email.rstrip(b">").strip()
+ if not name:
+ name = None
+ if not email:
+ email = None
+ return (name, email)
+
+
def read_mailmap(f):
"""Read a mailmap.
@@ -10,13 +44,26 @@ def read_mailmap(f):
Returns: Iterator over
((canonical_name, canonical_email), (from_name, from_email)) tuples
"""
- pass
+ for line in f:
+ # Remove comments
+ line = line.split(b"#")[0]
+ line = line.strip()
+ if not line:
+ continue
+ (canonical_identity, from_identity) = line.split(b">", 1)
+ canonical_identity += b">"
+ if from_identity.strip():
+ parsed_from_identity = parse_identity(from_identity)
+ else:
+ parsed_from_identity = None
+ parsed_canonical_identity = parse_identity(canonical_identity)
+ yield parsed_canonical_identity, parsed_from_identity
class Mailmap:
"""Class for accessing a mailmap file."""
- def __init__(self, map=None) ->None:
+ def __init__(self, map=None) -> None:
self._table: Dict[Tuple[Optional[str], str], Tuple[str, str]] = {}
if map:
for canonical_identity, from_identity in map:
@@ -32,8 +79,38 @@ class Mailmap:
canonical_identity: The canonical identity (tuple)
from_identity: The from identity (tuple)
"""
- pass
+ if from_identity is None:
+ from_name, from_email = None, None
+ else:
+ (from_name, from_email) = from_identity
+ (canonical_name, canonical_email) = canonical_identity
+ if from_name is None and from_email is None:
+ self._table[canonical_name, None] = canonical_identity
+ self._table[None, canonical_email] = canonical_identity
+ else:
+ self._table[from_name, from_email] = canonical_identity
def lookup(self, identity):
"""Lookup an identity in this mailmail."""
- pass
+ if not isinstance(identity, tuple):
+ was_tuple = False
+ identity = parse_identity(identity)
+ else:
+ was_tuple = True
+ for query in [identity, (None, identity[1]), (identity[0], None)]:
+ canonical_identity = self._table.get(query)
+ if canonical_identity is not None:
+ identity = (
+ canonical_identity[0] or identity[0],
+ canonical_identity[1] or identity[1],
+ )
+ break
+ if was_tuple:
+ return identity
+ else:
+ return identity[0] + b" <" + identity[1] + b">"
+
+ @classmethod
+ def from_path(cls, path):
+ with open(path, "rb") as f:
+ return cls(read_mailmap(f))
diff --git a/dulwich/object_store.py b/dulwich/object_store.py
index 188df2bb..a28e1417 100644
--- a/dulwich/object_store.py
+++ b/dulwich/object_store.py
@@ -1,38 +1,130 @@
+# object_store.py -- Object store for git objects
+# Copyright (C) 2008-2013 Jelmer Vernooij <jelmer@jelmer.uk>
+# and others
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
+
"""Git object store interfaces and implementation."""
+
import os
import stat
import sys
import warnings
from contextlib import suppress
from io import BytesIO
-from typing import Callable, Dict, FrozenSet, Iterable, Iterator, List, Optional, Protocol, Sequence, Set, Tuple, cast
+from typing import (
+ Callable,
+ Dict,
+ FrozenSet,
+ Iterable,
+ Iterator,
+ List,
+ Optional,
+ Protocol,
+ Sequence,
+ Set,
+ Tuple,
+ cast,
+)
+
from .errors import NotTreeError
from .file import GitFile
-from .objects import S_ISGITLINK, ZERO_SHA, Blob, Commit, ObjectID, ShaFile, Tag, Tree, TreeEntry, hex_to_filename, hex_to_sha, object_class, sha_to_hex, valid_hexsha
-from .pack import PACK_SPOOL_FILE_MAX_SIZE, ObjectContainer, Pack, PackData, PackedObjectContainer, PackFileDisappeared, PackHint, PackIndexer, PackInflater, PackStreamCopier, UnpackedObject, extend_pack, full_unpacked_object, generate_unpacked_objects, iter_sha1, load_pack_index_file, pack_objects_to_data, write_pack_data, write_pack_index
+from .objects import (
+ S_ISGITLINK,
+ ZERO_SHA,
+ Blob,
+ Commit,
+ ObjectID,
+ ShaFile,
+ Tag,
+ Tree,
+ TreeEntry,
+ hex_to_filename,
+ hex_to_sha,
+ object_class,
+ sha_to_hex,
+ valid_hexsha,
+)
+from .pack import (
+ PACK_SPOOL_FILE_MAX_SIZE,
+ ObjectContainer,
+ Pack,
+ PackData,
+ PackedObjectContainer,
+ PackFileDisappeared,
+ PackHint,
+ PackIndexer,
+ PackInflater,
+ PackStreamCopier,
+ UnpackedObject,
+ extend_pack,
+ full_unpacked_object,
+ generate_unpacked_objects,
+ iter_sha1,
+ load_pack_index_file,
+ pack_objects_to_data,
+ write_pack_data,
+ write_pack_index,
+)
from .protocol import DEPTH_INFINITE
from .refs import PEELED_TAG_SUFFIX, Ref
-INFODIR = 'info'
-PACKDIR = 'pack'
-PACK_MODE = 292 if sys.platform != 'win32' else 420
+INFODIR = "info"
+PACKDIR = "pack"
+
+# use permissions consistent with Git; just readable by everyone
+# TODO: should packs also be non-writable on Windows? if so, that
+# would requite some rather significant adjustments to the test suite
+PACK_MODE = 0o444 if sys.platform != "win32" else 0o644
-class PackContainer(Protocol):
- def add_pack(self) ->Tuple[BytesIO, Callable[[], None], Callable[[], None]
- ]:
+class PackContainer(Protocol):
+ def add_pack(self) -> Tuple[BytesIO, Callable[[], None], Callable[[], None]]:
"""Add a new pack."""
- pass
class BaseObjectStore:
"""Object store interface."""
+ def determine_wants_all(
+ self, refs: Dict[Ref, ObjectID], depth: Optional[int] = None
+ ) -> List[ObjectID]:
+ def _want_deepen(sha):
+ if not depth:
+ return False
+ if depth == DEPTH_INFINITE:
+ return True
+ return depth > self._get_depth(sha)
+
+ return [
+ sha
+ for (ref, sha) in refs.items()
+ if (sha not in self or _want_deepen(sha))
+ and not ref.endswith(PEELED_TAG_SUFFIX)
+ and not sha == ZERO_SHA
+ ]
+
def contains_loose(self, sha):
"""Check if a particular object is present by SHA1 and is loose."""
- pass
+ raise NotImplementedError(self.contains_loose)
- def __contains__(self, sha1: bytes) ->bool:
+ def __contains__(self, sha1: bytes) -> bool:
"""Check if a particular object is present by SHA1.
This method makes no distinction between loose and packed objects.
@@ -42,7 +134,7 @@ class BaseObjectStore:
@property
def packs(self):
"""Iterable of pack objects."""
- pass
+ raise NotImplementedError
def get_raw(self, name):
"""Obtain the raw text for an object.
@@ -51,9 +143,9 @@ class BaseObjectStore:
name: sha for the object.
Returns: tuple with numeric type and object contents.
"""
- pass
+ raise NotImplementedError(self.get_raw)
- def __getitem__(self, sha1: ObjectID) ->ShaFile:
+ def __getitem__(self, sha1: ObjectID) -> ShaFile:
"""Obtain an object by SHA1."""
type_num, uncomp = self.get_raw(sha1)
return ShaFile.from_raw_string(type_num, uncomp, sha=sha1)
@@ -64,7 +156,7 @@ class BaseObjectStore:
def add_object(self, obj):
"""Add a single object to this object store."""
- pass
+ raise NotImplementedError(self.add_object)
def add_objects(self, objects, progress=None):
"""Add a set of objects to this object store.
@@ -72,10 +164,17 @@ class BaseObjectStore:
Args:
objects: Iterable over a list of (object, path) tuples
"""
- pass
-
- def tree_changes(self, source, target, want_unchanged=False,
- include_trees=False, change_type_same=False, rename_detector=None):
+ raise NotImplementedError(self.add_objects)
+
+ def tree_changes(
+ self,
+ source,
+ target,
+ want_unchanged=False,
+ include_trees=False,
+ change_type_same=False,
+ rename_detector=None,
+ ):
"""Find the differences between the contents of two trees.
Args:
@@ -88,7 +187,22 @@ class BaseObjectStore:
Returns: Iterator over tuples with
(oldpath, newpath), (oldmode, newmode), (oldsha, newsha)
"""
- pass
+ from .diff_tree import tree_changes
+
+ for change in tree_changes(
+ self,
+ source,
+ target,
+ want_unchanged=want_unchanged,
+ include_trees=include_trees,
+ change_type_same=change_type_same,
+ rename_detector=rename_detector,
+ ):
+ yield (
+ (change.old.path, change.new.path),
+ (change.old.mode, change.new.mode),
+ (change.old.sha, change.new.sha),
+ )
def iter_tree_contents(self, tree_id, include_trees=False):
"""Iterate the contents of a tree and all subtrees.
@@ -101,10 +215,32 @@ class BaseObjectStore:
Returns: Iterator over TreeEntry namedtuples for all the objects in a
tree.
"""
- pass
-
- def find_missing_objects(self, haves, wants, shallow=None, progress=
- None, get_tagged=None, get_parents=lambda commit: commit.parents):
+ warnings.warn(
+ "Please use dulwich.object_store.iter_tree_contents",
+ DeprecationWarning,
+ stacklevel=2,
+ )
+ return iter_tree_contents(self, tree_id, include_trees=include_trees)
+
+ def iterobjects_subset(
+ self, shas: Iterable[bytes], *, allow_missing: bool = False
+ ) -> Iterator[ShaFile]:
+ for sha in shas:
+ try:
+ yield self[sha]
+ except KeyError:
+ if not allow_missing:
+ raise
+
+ def find_missing_objects(
+ self,
+ haves,
+ wants,
+ shallow=None,
+ progress=None,
+ get_tagged=None,
+ get_parents=lambda commit: commit.parents,
+ ):
"""Find the missing objects required for a set of revisions.
Args:
@@ -119,7 +255,17 @@ class BaseObjectStore:
commit.
Returns: Iterator over (sha, path) pairs.
"""
- pass
+ warnings.warn("Please use MissingObjectFinder(store)", DeprecationWarning)
+ finder = MissingObjectFinder(
+ self,
+ haves=haves,
+ wants=wants,
+ shallow=shallow,
+ progress=progress,
+ get_tagged=get_tagged,
+ get_parents=get_parents,
+ )
+ return iter(finder)
def find_common_revisions(self, graphwalker):
"""Find which revisions this store has in common using graphwalker.
@@ -128,10 +274,18 @@ class BaseObjectStore:
graphwalker: A graphwalker object.
Returns: List of SHAs that are in common
"""
- pass
-
- def generate_pack_data(self, have, want, shallow=None, progress=None,
- ofs_delta=True) ->Tuple[int, Iterator[UnpackedObject]]:
+ haves = []
+ sha = next(graphwalker)
+ while sha:
+ if sha in self:
+ haves.append(sha)
+ graphwalker.ack(sha)
+ sha = next(graphwalker)
+ return haves
+
+ def generate_pack_data(
+ self, have, want, shallow=None, progress=None, ofs_delta=True
+ ) -> Tuple[int, Iterator[UnpackedObject]]:
"""Generate pack data objects for a set of wants/haves.
Args:
@@ -141,7 +295,17 @@ class BaseObjectStore:
ofs_delta: Whether OFS deltas can be included
progress: Optional progress reporting method
"""
- pass
+ # Note that the pack-specific implementation below is more efficient,
+ # as it reuses deltas
+ missing_objects = MissingObjectFinder(
+ self, haves=have, wants=want, shallow=shallow, progress=progress
+ )
+ object_ids = list(missing_objects)
+ return pack_objects_to_data(
+ [(self[oid], path) for oid, path in object_ids],
+ ofs_delta=ofs_delta,
+ progress=progress,
+ )
def peel_sha(self, sha):
"""Peel all tags from a SHA.
@@ -152,10 +316,19 @@ class BaseObjectStore:
intermediate tags; if the original ref does not point to a tag,
this will equal the original SHA1.
"""
- pass
-
- def _get_depth(self, head, get_parents=lambda commit: commit.parents,
- max_depth=None):
+ warnings.warn(
+ "Please use dulwich.object_store.peel_sha()",
+ DeprecationWarning,
+ stacklevel=2,
+ )
+ return peel_sha(self, sha)[1]
+
+ def _get_depth(
+ self,
+ head,
+ get_parents=lambda commit: commit.parents,
+ max_depth=None,
+ ):
"""Return the current available depth for the given head.
For commits with multiple parents, the largest possible depth will be
returned.
@@ -165,42 +338,81 @@ class BaseObjectStore:
get_parents: optional function for getting the parents of a commit
max_depth: maximum depth to search
"""
- pass
+ if head not in self:
+ return 0
+ current_depth = 1
+ queue = [(head, current_depth)]
+ while queue and (max_depth is None or current_depth < max_depth):
+ e, depth = queue.pop(0)
+ current_depth = max(current_depth, depth)
+ cmt = self[e]
+ if isinstance(cmt, Tag):
+ _cls, sha = cmt.object
+ cmt = self[sha]
+ queue.extend(
+ (parent, depth + 1) for parent in get_parents(cmt) if parent in self
+ )
+ return current_depth
def close(self):
"""Close any files opened by this object store."""
- pass
+ # Default implementation is a NO-OP
class PackBasedObjectStore(BaseObjectStore):
-
- def __init__(self, pack_compression_level=-1) ->None:
+ def __init__(self, pack_compression_level=-1) -> None:
self._pack_cache: Dict[str, Pack] = {}
self.pack_compression_level = pack_compression_level
- def add_pack(self) ->Tuple[BytesIO, Callable[[], None], Callable[[], None]
- ]:
+ def add_pack(self) -> Tuple[BytesIO, Callable[[], None], Callable[[], None]]:
"""Add a new pack to this object store."""
- pass
+ raise NotImplementedError(self.add_pack)
- def add_pack_data(self, count: int, unpacked_objects: Iterator[
- UnpackedObject], progress=None) ->None:
+ def add_pack_data(
+ self, count: int, unpacked_objects: Iterator[UnpackedObject], progress=None
+ ) -> None:
"""Add pack data to this object store.
Args:
count: Number of items to add
pack_data: Iterator over pack data tuples
"""
- pass
+ if count == 0:
+ # Don't bother writing an empty pack file
+ return
+ f, commit, abort = self.add_pack()
+ try:
+ write_pack_data(
+ f.write,
+ unpacked_objects,
+ num_records=count,
+ progress=progress,
+ compression_level=self.pack_compression_level,
+ )
+ except BaseException:
+ abort()
+ raise
+ else:
+ return commit()
+
+ @property
+ def alternates(self):
+ return []
def contains_packed(self, sha):
"""Check if a particular object is present by SHA1 and is packed.
This does not check alternates.
"""
- pass
+ for pack in self.packs:
+ try:
+ if sha in pack:
+ return True
+ except PackFileDisappeared:
+ pass
+ return False
- def __contains__(self, sha) ->bool:
+ def __contains__(self, sha) -> bool:
"""Check if a particular object is present by SHA1.
This method makes no distinction between loose and packed objects.
@@ -214,10 +426,15 @@ class PackBasedObjectStore(BaseObjectStore):
def _add_cached_pack(self, base_name, pack):
"""Add a newly appeared pack to the cache by path."""
- pass
-
- def generate_pack_data(self, have, want, shallow=None, progress=None,
- ofs_delta=True) ->Tuple[int, Iterator[UnpackedObject]]:
+ prev_pack = self._pack_cache.get(base_name)
+ if prev_pack is not pack:
+ self._pack_cache[base_name] = pack
+ if prev_pack:
+ prev_pack.close()
+
+ def generate_pack_data(
+ self, have, want, shallow=None, progress=None, ofs_delta=True
+ ) -> Tuple[int, Iterator[UnpackedObject]]:
"""Generate pack data objects for a set of wants/haves.
Args:
@@ -227,27 +444,70 @@ class PackBasedObjectStore(BaseObjectStore):
ofs_delta: Whether OFS deltas can be included
progress: Optional progress reporting method
"""
- pass
+ missing_objects = MissingObjectFinder(
+ self, haves=have, wants=want, shallow=shallow, progress=progress
+ )
+ remote_has = missing_objects.get_remote_has()
+ object_ids = list(missing_objects)
+ return len(object_ids), generate_unpacked_objects(
+ cast(PackedObjectContainer, self),
+ object_ids,
+ progress=progress,
+ ofs_delta=ofs_delta,
+ other_haves=remote_has,
+ )
+
+ def _clear_cached_packs(self):
+ pack_cache = self._pack_cache
+ self._pack_cache = {}
+ while pack_cache:
+ (name, pack) = pack_cache.popitem()
+ pack.close()
+
+ def _iter_cached_packs(self):
+ return self._pack_cache.values()
+
+ def _update_pack_cache(self):
+ raise NotImplementedError(self._update_pack_cache)
+
+ def close(self):
+ self._clear_cached_packs()
@property
def packs(self):
"""List with pack objects."""
- pass
+ return list(self._iter_cached_packs()) + list(self._update_pack_cache())
def _iter_alternate_objects(self):
"""Iterate over the SHAs of all the objects in alternate stores."""
- pass
+ for alternate in self.alternates:
+ yield from alternate
def _iter_loose_objects(self):
"""Iterate over the SHAs of all loose objects."""
- pass
+ raise NotImplementedError(self._iter_loose_objects)
+
+ def _get_loose_object(self, sha):
+ raise NotImplementedError(self._get_loose_object)
+
+ def _remove_loose_object(self, sha):
+ raise NotImplementedError(self._remove_loose_object)
+
+ def _remove_pack(self, name):
+ raise NotImplementedError(self._remove_pack)
def pack_loose_objects(self):
"""Pack loose objects.
Returns: Number of objects packed
"""
- pass
+ objects = set()
+ for sha in self._iter_loose_objects():
+ objects.add((self._get_loose_object(sha), None))
+ self.add_objects(list(objects))
+ for obj, path in objects:
+ self._remove_loose_object(obj.id)
+ return len(objects)
def repack(self):
"""Repack the packs in this repository.
@@ -255,7 +515,27 @@ class PackBasedObjectStore(BaseObjectStore):
Note that this implementation is fairly naive and currently keeps all
objects in memory while it repacks.
"""
- pass
+ loose_objects = set()
+ for sha in self._iter_loose_objects():
+ loose_objects.add(self._get_loose_object(sha))
+ objects = {(obj, None) for obj in loose_objects}
+ old_packs = {p.name(): p for p in self.packs}
+ for name, pack in old_packs.items():
+ objects.update((obj, None) for obj in pack.iterobjects())
+
+ # The name of the consolidated pack might match the name of a
+ # pre-existing pack. Take care not to remove the newly created
+ # consolidated pack.
+
+ consolidated = self.add_objects(objects)
+ old_packs.pop(consolidated.name(), None)
+
+ for obj in loose_objects:
+ self._remove_loose_object(obj.id)
+ for name, pack in old_packs.items():
+ self._remove_pack(pack)
+ self._update_pack_cache()
+ return len(objects)
def __iter__(self):
"""Iterate over the SHAs that are present in this store."""
@@ -273,7 +553,7 @@ class PackBasedObjectStore(BaseObjectStore):
This does not check alternates.
"""
- pass
+ return self._get_loose_object(sha) is not None
def get_raw(self, name):
"""Obtain the raw fulltext for an object.
@@ -282,19 +562,151 @@ class PackBasedObjectStore(BaseObjectStore):
name: sha for the object.
Returns: tuple with numeric type and object contents.
"""
- pass
-
- def get_unpacked_object(self, sha1: bytes, *, include_comp: bool=False
- ) ->UnpackedObject:
+ if name == ZERO_SHA:
+ raise KeyError(name)
+ if len(name) == 40:
+ sha = hex_to_sha(name)
+ hexsha = name
+ elif len(name) == 20:
+ sha = name
+ hexsha = None
+ else:
+ raise AssertionError(f"Invalid object name {name!r}")
+ for pack in self._iter_cached_packs():
+ try:
+ return pack.get_raw(sha)
+ except (KeyError, PackFileDisappeared):
+ pass
+ if hexsha is None:
+ hexsha = sha_to_hex(name)
+ ret = self._get_loose_object(hexsha)
+ if ret is not None:
+ return ret.type_num, ret.as_raw_string()
+ # Maybe something else has added a pack with the object
+ # in the mean time?
+ for pack in self._update_pack_cache():
+ try:
+ return pack.get_raw(sha)
+ except KeyError:
+ pass
+ for alternate in self.alternates:
+ try:
+ return alternate.get_raw(hexsha)
+ except KeyError:
+ pass
+ raise KeyError(hexsha)
+
+ def iter_unpacked_subset(
+ self,
+ shas,
+ *,
+ include_comp=False,
+ allow_missing: bool = False,
+ convert_ofs_delta: bool = True,
+ ) -> Iterator[ShaFile]:
+ todo: Set[bytes] = set(shas)
+ for p in self._iter_cached_packs():
+ for unpacked in p.iter_unpacked_subset(
+ todo,
+ include_comp=include_comp,
+ allow_missing=True,
+ convert_ofs_delta=convert_ofs_delta,
+ ):
+ yield unpacked
+ hexsha = sha_to_hex(unpacked.sha())
+ todo.remove(hexsha)
+ # Maybe something else has added a pack with the object
+ # in the mean time?
+ for p in self._update_pack_cache():
+ for unpacked in p.iter_unpacked_subset(
+ todo,
+ include_comp=include_comp,
+ allow_missing=True,
+ convert_ofs_delta=convert_ofs_delta,
+ ):
+ yield unpacked
+ hexsha = sha_to_hex(unpacked.sha())
+ todo.remove(hexsha)
+ for alternate in self.alternates:
+ for unpacked in alternate.iter_unpacked_subset(
+ todo,
+ include_comp=include_comp,
+ allow_missing=True,
+ convert_ofs_delta=convert_ofs_delta,
+ ):
+ yield unpacked
+ hexsha = sha_to_hex(unpacked.sha())
+ todo.remove(hexsha)
+
+ def iterobjects_subset(
+ self, shas: Iterable[bytes], *, allow_missing: bool = False
+ ) -> Iterator[ShaFile]:
+ todo: Set[bytes] = set(shas)
+ for p in self._iter_cached_packs():
+ for o in p.iterobjects_subset(todo, allow_missing=True):
+ yield o
+ todo.remove(o.id)
+ # Maybe something else has added a pack with the object
+ # in the mean time?
+ for p in self._update_pack_cache():
+ for o in p.iterobjects_subset(todo, allow_missing=True):
+ yield o
+ todo.remove(o.id)
+ for alternate in self.alternates:
+ for o in alternate.iterobjects_subset(todo, allow_missing=True):
+ yield o
+ todo.remove(o.id)
+ for oid in todo:
+ o = self._get_loose_object(oid)
+ if o is not None:
+ yield o
+ elif not allow_missing:
+ raise KeyError(oid)
+
+ def get_unpacked_object(
+ self, sha1: bytes, *, include_comp: bool = False
+ ) -> UnpackedObject:
"""Obtain the unpacked object.
Args:
sha1: sha for the object.
"""
- pass
+ if sha1 == ZERO_SHA:
+ raise KeyError(sha1)
+ if len(sha1) == 40:
+ sha = hex_to_sha(sha1)
+ hexsha = sha1
+ elif len(sha1) == 20:
+ sha = sha1
+ hexsha = None
+ else:
+ raise AssertionError(f"Invalid object sha1 {sha1!r}")
+ for pack in self._iter_cached_packs():
+ try:
+ return pack.get_unpacked_object(sha, include_comp=include_comp)
+ except (KeyError, PackFileDisappeared):
+ pass
+ if hexsha is None:
+ hexsha = sha_to_hex(sha1)
+ # Maybe something else has added a pack with the object
+ # in the mean time?
+ for pack in self._update_pack_cache():
+ try:
+ return pack.get_unpacked_object(sha, include_comp=include_comp)
+ except KeyError:
+ pass
+ for alternate in self.alternates:
+ try:
+ return alternate.get_unpacked_object(hexsha, include_comp=include_comp)
+ except KeyError:
+ pass
+ raise KeyError(hexsha)
- def add_objects(self, objects: Sequence[Tuple[ShaFile, Optional[str]]],
- progress: Optional[Callable[[str], None]]=None) ->None:
+ def add_objects(
+ self,
+ objects: Sequence[Tuple[ShaFile, Optional[str]]],
+ progress: Optional[Callable[[str], None]] = None,
+ ) -> None:
"""Add a set of objects to this object store.
Args:
@@ -302,14 +714,17 @@ class PackBasedObjectStore(BaseObjectStore):
__len__.
Returns: Pack object of the objects written.
"""
- pass
+ count = len(objects)
+ record_iter = (full_unpacked_object(o) for (o, p) in objects)
+ return self.add_pack_data(count, record_iter, progress=progress)
class DiskObjectStore(PackBasedObjectStore):
"""Git-style object store that exists on disk."""
- def __init__(self, path, loose_compression_level=-1,
- pack_compression_level=-1) ->None:
+ def __init__(
+ self, path, loose_compression_level=-1, pack_compression_level=-1
+ ) -> None:
"""Open an object store.
Args:
@@ -324,16 +739,143 @@ class DiskObjectStore(PackBasedObjectStore):
self.loose_compression_level = loose_compression_level
self.pack_compression_level = pack_compression_level
- def __repr__(self) ->str:
- return f'<{self.__class__.__name__}({self.path!r})>'
+ def __repr__(self) -> str:
+ return f"<{self.__class__.__name__}({self.path!r})>"
+
+ @classmethod
+ def from_config(cls, path, config):
+ try:
+ default_compression_level = int(
+ config.get((b"core",), b"compression").decode()
+ )
+ except KeyError:
+ default_compression_level = -1
+ try:
+ loose_compression_level = int(
+ config.get((b"core",), b"looseCompression").decode()
+ )
+ except KeyError:
+ loose_compression_level = default_compression_level
+ try:
+ pack_compression_level = int(
+ config.get((b"core",), "packCompression").decode()
+ )
+ except KeyError:
+ pack_compression_level = default_compression_level
+ return cls(path, loose_compression_level, pack_compression_level)
+
+ @property
+ def alternates(self):
+ if self._alternates is not None:
+ return self._alternates
+ self._alternates = []
+ for path in self._read_alternate_paths():
+ self._alternates.append(DiskObjectStore(path))
+ return self._alternates
+
+ def _read_alternate_paths(self):
+ try:
+ f = GitFile(os.path.join(self.path, INFODIR, "alternates"), "rb")
+ except FileNotFoundError:
+ return
+ with f:
+ for line in f.readlines():
+ line = line.rstrip(b"\n")
+ if line.startswith(b"#"):
+ continue
+ if os.path.isabs(line):
+ yield os.fsdecode(line)
+ else:
+ yield os.fsdecode(os.path.join(os.fsencode(self.path), line))
def add_alternate_path(self, path):
"""Add an alternate path to this object store."""
- pass
+ try:
+ os.mkdir(os.path.join(self.path, INFODIR))
+ except FileExistsError:
+ pass
+ alternates_path = os.path.join(self.path, INFODIR, "alternates")
+ with GitFile(alternates_path, "wb") as f:
+ try:
+ orig_f = open(alternates_path, "rb")
+ except FileNotFoundError:
+ pass
+ else:
+ with orig_f:
+ f.write(orig_f.read())
+ f.write(os.fsencode(path) + b"\n")
+
+ if not os.path.isabs(path):
+ path = os.path.join(self.path, path)
+ self.alternates.append(DiskObjectStore(path))
def _update_pack_cache(self):
"""Read and iterate over new pack files and cache them."""
- pass
+ try:
+ pack_dir_contents = os.listdir(self.pack_dir)
+ except FileNotFoundError:
+ self.close()
+ return []
+ pack_files = set()
+ for name in pack_dir_contents:
+ if name.startswith("pack-") and name.endswith(".pack"):
+ # verify that idx exists first (otherwise the pack was not yet
+ # fully written)
+ idx_name = os.path.splitext(name)[0] + ".idx"
+ if idx_name in pack_dir_contents:
+ pack_name = name[: -len(".pack")]
+ pack_files.add(pack_name)
+
+ # Open newly appeared pack files
+ new_packs = []
+ for f in pack_files:
+ if f not in self._pack_cache:
+ pack = Pack(os.path.join(self.pack_dir, f))
+ new_packs.append(pack)
+ self._pack_cache[f] = pack
+ # Remove disappeared pack files
+ for f in set(self._pack_cache) - pack_files:
+ self._pack_cache.pop(f).close()
+ return new_packs
+
+ def _get_shafile_path(self, sha):
+ # Check from object dir
+ return hex_to_filename(self.path, sha)
+
+ def _iter_loose_objects(self):
+ for base in os.listdir(self.path):
+ if len(base) != 2:
+ continue
+ for rest in os.listdir(os.path.join(self.path, base)):
+ sha = os.fsencode(base + rest)
+ if not valid_hexsha(sha):
+ continue
+ yield sha
+
+ def _get_loose_object(self, sha):
+ path = self._get_shafile_path(sha)
+ try:
+ return ShaFile.from_path(path)
+ except FileNotFoundError:
+ return None
+
+ def _remove_loose_object(self, sha):
+ os.remove(self._get_shafile_path(sha))
+
+ def _remove_pack(self, pack):
+ try:
+ del self._pack_cache[os.path.basename(pack._basename)]
+ except KeyError:
+ pass
+ pack.close()
+ os.remove(pack.data.path)
+ os.remove(pack.index.path)
+
+ def _get_pack_basepath(self, entries):
+ suffix = iter_sha1(entry[0] for entry in entries)
+ # TODO: Handle self.pack_dir being bytes
+ suffix = suffix.decode("ascii")
+ return os.path.join(self.pack_dir, "pack-" + suffix)
def _complete_pack(self, f, path, num_objects, indexer, progress=None):
"""Move a specific file containing a pack into the pack directory.
@@ -346,7 +888,58 @@ class DiskObjectStore(PackBasedObjectStore):
path: Path to the pack file.
indexer: A PackIndexer for indexing the pack.
"""
- pass
+ entries = []
+ for i, entry in enumerate(indexer):
+ if progress is not None:
+ progress(
+ ("generating index: %d/%d\r" % (i, num_objects)).encode("ascii")
+ )
+ entries.append(entry)
+
+ pack_sha, extra_entries = extend_pack(
+ f,
+ indexer.ext_refs(),
+ get_raw=self.get_raw,
+ compression_level=self.pack_compression_level,
+ progress=progress,
+ )
+ f.flush()
+ try:
+ fileno = f.fileno()
+ except AttributeError:
+ pass
+ else:
+ os.fsync(fileno)
+ f.close()
+
+ entries.extend(extra_entries)
+
+ # Move the pack in.
+ entries.sort()
+ pack_base_name = self._get_pack_basepath(entries)
+
+ for pack in self.packs:
+ if pack._basename == pack_base_name:
+ return pack
+
+ target_pack_path = pack_base_name + ".pack"
+ target_index_path = pack_base_name + ".idx"
+ if sys.platform == "win32":
+ # Windows might have the target pack file lingering. Attempt
+ # removal, silently passing if the target does not exist.
+ with suppress(FileNotFoundError):
+ os.remove(target_pack_path)
+ os.rename(path, target_pack_path)
+
+ # Write the index.
+ with GitFile(target_index_path, "wb", mask=PACK_MODE) as index_file:
+ write_pack_index(index_file, entries, pack_sha)
+
+ # Add the pack to the store and return it.
+ final_pack = Pack(pack_base_name)
+ final_pack.check_length_and_checksum()
+ self._add_cached_pack(pack_base_name, final_pack)
+ return final_pack
def add_thin_pack(self, read_all, read_some, progress=None):
"""Add a new thin pack to this object store.
@@ -363,7 +956,15 @@ class DiskObjectStore(PackBasedObjectStore):
Returns: A Pack object pointing at the now-completed thin pack in the
objects/pack directory.
"""
- pass
+ import tempfile
+
+ fd, path = tempfile.mkstemp(dir=self.path, prefix="tmp_pack_")
+ with os.fdopen(fd, "w+b") as f:
+ os.chmod(path, PACK_MODE)
+ indexer = PackIndexer(f, resolve_ext_ref=self.get_raw)
+ copier = PackStreamCopier(read_all, read_some, f, delta_iter=indexer)
+ copier.verify(progress=progress)
+ return self._complete_pack(f, path, len(copier), indexer, progress=progress)
def add_pack(self):
"""Add a new pack to this object store.
@@ -372,7 +973,30 @@ class DiskObjectStore(PackBasedObjectStore):
call when the pack is finished and an abort
function.
"""
- pass
+ import tempfile
+
+ fd, path = tempfile.mkstemp(dir=self.pack_dir, suffix=".pack")
+ f = os.fdopen(fd, "w+b")
+ os.chmod(path, PACK_MODE)
+
+ def commit():
+ if f.tell() > 0:
+ f.seek(0)
+ with PackData(path, f) as pd:
+ indexer = PackIndexer.for_pack_data(
+ pd, resolve_ext_ref=self.get_raw
+ )
+ return self._complete_pack(f, path, len(pd), indexer)
+ else:
+ f.close()
+ os.remove(path)
+ return None
+
+ def abort():
+ f.close()
+ os.remove(path)
+
+ return f, commit, abort
def add_object(self, obj):
"""Add a single object to this object store.
@@ -380,24 +1004,53 @@ class DiskObjectStore(PackBasedObjectStore):
Args:
obj: Object to add
"""
- pass
+ path = self._get_shafile_path(obj.id)
+ dir = os.path.dirname(path)
+ try:
+ os.mkdir(dir)
+ except FileExistsError:
+ pass
+ if os.path.exists(path):
+ return # Already there, no need to write again
+ with GitFile(path, "wb", mask=PACK_MODE) as f:
+ f.write(
+ obj.as_legacy_object(compression_level=self.loose_compression_level)
+ )
+
+ @classmethod
+ def init(cls, path):
+ try:
+ os.mkdir(path)
+ except FileExistsError:
+ pass
+ os.mkdir(os.path.join(path, "info"))
+ os.mkdir(os.path.join(path, PACKDIR))
+ return cls(path)
class MemoryObjectStore(BaseObjectStore):
"""Object store that keeps all objects in memory."""
- def __init__(self) ->None:
+ def __init__(self) -> None:
super().__init__()
self._data: Dict[str, ShaFile] = {}
self.pack_compression_level = -1
+ def _to_hexsha(self, sha):
+ if len(sha) == 40:
+ return sha
+ elif len(sha) == 20:
+ return sha_to_hex(sha)
+ else:
+ raise ValueError(f"Invalid sha {sha!r}")
+
def contains_loose(self, sha):
"""Check if a particular object is present by SHA1 and is loose."""
- pass
+ return self._to_hexsha(sha) in self._data
def contains_packed(self, sha):
"""Check if a particular object is present by SHA1 and is packed."""
- pass
+ return False
def __iter__(self):
"""Iterate over the SHAs that are present in this store."""
@@ -406,7 +1059,7 @@ class MemoryObjectStore(BaseObjectStore):
@property
def packs(self):
"""List with pack objects."""
- pass
+ return []
def get_raw(self, name: ObjectID):
"""Obtain the raw text for an object.
@@ -415,18 +1068,19 @@ class MemoryObjectStore(BaseObjectStore):
name: sha for the object.
Returns: tuple with numeric type and object contents.
"""
- pass
+ obj = self[self._to_hexsha(name)]
+ return obj.type_num, obj.as_raw_string()
def __getitem__(self, name: ObjectID):
return self._data[self._to_hexsha(name)].copy()
- def __delitem__(self, name: ObjectID) ->None:
+ def __delitem__(self, name: ObjectID) -> None:
"""Delete an object from this store, for testing only."""
del self._data[self._to_hexsha(name)]
def add_object(self, obj):
"""Add a single object to this object store."""
- pass
+ self._data[obj.id] = obj.copy()
def add_objects(self, objects, progress=None):
"""Add a set of objects to this object store.
@@ -434,7 +1088,8 @@ class MemoryObjectStore(BaseObjectStore):
Args:
objects: Iterable over a list of (object, path) tuples
"""
- pass
+ for obj, path in objects:
+ self.add_object(obj)
def add_pack(self):
"""Add a new pack to this object store.
@@ -445,17 +1100,37 @@ class MemoryObjectStore(BaseObjectStore):
Returns: Fileobject to write to and a commit function to
call when the pack is finished.
"""
- pass
+ from tempfile import SpooledTemporaryFile
- def add_pack_data(self, count: int, unpacked_objects: Iterator[
- UnpackedObject], progress=None) ->None:
+ f = SpooledTemporaryFile(max_size=PACK_SPOOL_FILE_MAX_SIZE, prefix="incoming-")
+
+ def commit():
+ size = f.tell()
+ if size > 0:
+ f.seek(0)
+ p = PackData.from_file(f, size)
+ for obj in PackInflater.for_pack_data(p, self.get_raw):
+ self.add_object(obj)
+ p.close()
+ else:
+ f.close()
+
+ def abort():
+ f.close()
+
+ return f, commit, abort
+
+ def add_pack_data(
+ self, count: int, unpacked_objects: Iterator[UnpackedObject], progress=None
+ ) -> None:
"""Add pack data to this object store.
Args:
count: Number of items to add
pack_data: Iterator over pack data tuples
"""
- pass
+ for unpacked_object in unpacked_objects:
+ self.add_object(unpacked_object.sha_file())
def add_thin_pack(self, read_all, read_some, progress=None):
"""Add a new thin pack to this object store.
@@ -470,12 +1145,23 @@ class MemoryObjectStore(BaseObjectStore):
read_some: Read function that returns at least one byte, but may
not return the number of bytes requested.
"""
- pass
+ f, commit, abort = self.add_pack()
+ try:
+ copier = PackStreamCopier(read_all, read_some, f)
+ copier.verify()
+ except BaseException:
+ abort()
+ raise
+ else:
+ commit()
class ObjectIterator(Protocol):
"""Interface for iterating over objects."""
+ def iterobjects(self) -> Iterator[ShaFile]:
+ raise NotImplementedError(self.iterobjects)
+
def tree_lookup_path(lookup_obj, root_sha, path):
"""Look up an object in a Git tree.
@@ -486,11 +1172,15 @@ def tree_lookup_path(lookup_obj, root_sha, path):
path: Path to lookup
Returns: A tuple of (mode, SHA) of the resulting path.
"""
- pass
+ tree = lookup_obj(root_sha)
+ if not isinstance(tree, Tree):
+ raise NotTreeError(root_sha)
+ return tree.lookup_path(lookup_obj, path)
-def _collect_filetree_revs(obj_store: ObjectContainer, tree_sha: ObjectID,
- kset: Set[ObjectID]) ->None:
+def _collect_filetree_revs(
+ obj_store: ObjectContainer, tree_sha: ObjectID, kset: Set[ObjectID]
+) -> None:
"""Collect SHA1s of files and directories for specified tree.
Args:
@@ -498,11 +1188,18 @@ def _collect_filetree_revs(obj_store: ObjectContainer, tree_sha: ObjectID,
tree_sha: tree reference to walk
kset: set to fill with references to files and directories
"""
- pass
-
-
-def _split_commits_and_tags(obj_store: ObjectContainer, lst, *,
- ignore_unknown=False) ->Tuple[Set[bytes], Set[bytes], Set[bytes]]:
+ filetree = obj_store[tree_sha]
+ assert isinstance(filetree, Tree)
+ for name, mode, sha in filetree.iteritems():
+ if not S_ISGITLINK(mode) and sha not in kset:
+ kset.add(sha)
+ if stat.S_ISDIR(mode):
+ _collect_filetree_revs(obj_store, sha, kset)
+
+
+def _split_commits_and_tags(
+ obj_store: ObjectContainer, lst, *, ignore_unknown=False
+) -> Tuple[Set[bytes], Set[bytes], Set[bytes]]:
"""Split object id list into three lists with commit, tag, and other SHAs.
Commits referenced by tags are included into commits
@@ -517,7 +1214,30 @@ def _split_commits_and_tags(obj_store: ObjectContainer, lst, *,
silently.
Returns: A tuple of (commits, tags, others) SHA1s
"""
- pass
+ commits: Set[bytes] = set()
+ tags: Set[bytes] = set()
+ others: Set[bytes] = set()
+ for e in lst:
+ try:
+ o = obj_store[e]
+ except KeyError:
+ if not ignore_unknown:
+ raise
+ else:
+ if isinstance(o, Commit):
+ commits.add(e)
+ elif isinstance(o, Tag):
+ tags.add(e)
+ tagged = o.object[1]
+ c, t, os = _split_commits_and_tags(
+ obj_store, [tagged], ignore_unknown=ignore_unknown
+ )
+ commits |= c
+ tags |= t
+ others |= os
+ else:
+ others.add(e)
+ return (commits, tags, others)
class MissingObjectFinder:
@@ -535,76 +1255,130 @@ class MissingObjectFinder:
tagged: dict of pointed-to sha -> tag sha for including tags
"""
- def __init__(self, object_store, haves, wants, *, shallow=None,
- progress=None, get_tagged=None, get_parents=lambda commit: commit.
- parents) ->None:
+ def __init__(
+ self,
+ object_store,
+ haves,
+ wants,
+ *,
+ shallow=None,
+ progress=None,
+ get_tagged=None,
+ get_parents=lambda commit: commit.parents,
+ ) -> None:
self.object_store = object_store
if shallow is None:
shallow = set()
self._get_parents = get_parents
+ # process Commits and Tags differently
+ # Note, while haves may list commits/tags not available locally,
+ # and such SHAs would get filtered out by _split_commits_and_tags,
+ # wants shall list only known SHAs, and otherwise
+ # _split_commits_and_tags fails with KeyError
have_commits, have_tags, have_others = _split_commits_and_tags(
- object_store, haves, ignore_unknown=True)
+ object_store, haves, ignore_unknown=True
+ )
want_commits, want_tags, want_others = _split_commits_and_tags(
- object_store, wants, ignore_unknown=False)
- all_ancestors = _collect_ancestors(object_store, have_commits,
- shallow=shallow, get_parents=self._get_parents)[0]
- missing_commits, common_commits = _collect_ancestors(object_store,
- want_commits, all_ancestors, shallow=shallow, get_parents=self.
- _get_parents)
+ object_store, wants, ignore_unknown=False
+ )
+ # all_ancestors is a set of commits that shall not be sent
+ # (complete repository up to 'haves')
+ all_ancestors = _collect_ancestors(
+ object_store, have_commits, shallow=shallow, get_parents=self._get_parents
+ )[0]
+ # all_missing - complete set of commits between haves and wants
+ # common - commits from all_ancestors we hit into while
+ # traversing parent hierarchy of wants
+ missing_commits, common_commits = _collect_ancestors(
+ object_store,
+ want_commits,
+ all_ancestors,
+ shallow=shallow,
+ get_parents=self._get_parents,
+ )
self.remote_has: Set[bytes] = set()
+ # Now, fill sha_done with commits and revisions of
+ # files and directories known to be both locally
+ # and on target. Thus these commits and files
+ # won't get selected for fetch
for h in common_commits:
self.remote_has.add(h)
cmt = object_store[h]
_collect_filetree_revs(object_store, cmt.tree, self.remote_has)
+ # record tags we have as visited, too
for t in have_tags:
self.remote_has.add(t)
self.sha_done = set(self.remote_has)
- self.objects_to_send: Set[Tuple[ObjectID, Optional[bytes], Optional
- [int], bool]] = {(w, None, Commit.type_num, False) for w in
- missing_commits}
+
+ # in fact, what we 'want' is commits, tags, and others
+ # we've found missing
+ self.objects_to_send: Set[
+ Tuple[ObjectID, Optional[bytes], Optional[int], bool]
+ ] = {(w, None, Commit.type_num, False) for w in missing_commits}
missing_tags = want_tags.difference(have_tags)
- self.objects_to_send.update({(w, None, Tag.type_num, False) for w in
- missing_tags})
+ self.objects_to_send.update(
+ {(w, None, Tag.type_num, False) for w in missing_tags}
+ )
missing_others = want_others.difference(have_others)
- self.objects_to_send.update({(w, None, None, False) for w in
- missing_others})
+ self.objects_to_send.update({(w, None, None, False) for w in missing_others})
+
if progress is None:
self.progress = lambda x: None
else:
self.progress = progress
self._tagged = get_tagged and get_tagged() or {}
- def __next__(self) ->Tuple[bytes, Optional[PackHint]]:
+ def get_remote_has(self):
+ return self.remote_has
+
+ def add_todo(
+ self, entries: Iterable[Tuple[ObjectID, Optional[bytes], Optional[int], bool]]
+ ):
+ self.objects_to_send.update([e for e in entries if e[0] not in self.sha_done])
+
+ def __next__(self) -> Tuple[bytes, Optional[PackHint]]:
while True:
if not self.objects_to_send:
- self.progress(('counting objects: %d, done.\n' % len(self.
- sha_done)).encode('ascii'))
+ self.progress(
+ ("counting objects: %d, done.\n" % len(self.sha_done)).encode(
+ "ascii"
+ )
+ )
raise StopIteration
- sha, name, type_num, leaf = self.objects_to_send.pop()
+ (sha, name, type_num, leaf) = self.objects_to_send.pop()
if sha not in self.sha_done:
break
if not leaf:
o = self.object_store[sha]
if isinstance(o, Commit):
- self.add_todo([(o.tree, b'', Tree.type_num, False)])
+ self.add_todo([(o.tree, b"", Tree.type_num, False)])
elif isinstance(o, Tree):
- self.add_todo([(s, n, Blob.type_num if stat.S_ISREG(m) else
- Tree.type_num, not stat.S_ISDIR(m)) for n, m, s in o.
- iteritems() if not S_ISGITLINK(m)])
+ self.add_todo(
+ [
+ (
+ s,
+ n,
+ (Blob.type_num if stat.S_ISREG(m) else Tree.type_num),
+ not stat.S_ISDIR(m),
+ )
+ for n, m, s in o.iteritems()
+ if not S_ISGITLINK(m)
+ ]
+ )
elif isinstance(o, Tag):
- self.add_todo([(o.object[1], None, o.object[0].type_num,
- False)])
+ self.add_todo([(o.object[1], None, o.object[0].type_num, False)])
if sha in self._tagged:
self.add_todo([(self._tagged[sha], None, None, True)])
self.sha_done.add(sha)
if len(self.sha_done) % 1000 == 0:
- self.progress(('counting objects: %d\r' % len(self.sha_done)).
- encode('ascii'))
+ self.progress(
+ ("counting objects: %d\r" % len(self.sha_done)).encode("ascii")
+ )
if type_num is None:
pack_hint = None
else:
- pack_hint = type_num, name
- return sha, pack_hint
+ pack_hint = (type_num, name)
+ return (sha, pack_hint)
def __iter__(self):
return self
@@ -618,7 +1392,7 @@ class ObjectStoreGraphWalker:
get_parents: Function to retrieve parents in the local repo
"""
- def __init__(self, local_heads, get_parents, shallow=None) ->None:
+ def __init__(self, local_heads, get_parents, shallow=None) -> None:
"""Create a new instance.
Args:
@@ -634,15 +1408,46 @@ class ObjectStoreGraphWalker:
def nak(self):
"""Nothing in common was found."""
- pass
def ack(self, sha):
"""Ack that a revision and its ancestors are present in the source."""
- pass
+ if len(sha) != 40:
+ raise ValueError(f"unexpected sha {sha!r} received")
+ ancestors = {sha}
+
+ # stop if we run out of heads to remove
+ while self.heads:
+ for a in ancestors:
+ if a in self.heads:
+ self.heads.remove(a)
+
+ # collect all ancestors
+ new_ancestors = set()
+ for a in ancestors:
+ ps = self.parents.get(a)
+ if ps is not None:
+ new_ancestors.update(ps)
+ self.parents[a] = None
+
+ # no more ancestors; stop
+ if not new_ancestors:
+ break
+
+ ancestors = new_ancestors
def next(self):
"""Iterate over ancestors of heads in the target."""
- pass
+ if self.heads:
+ ret = self.heads.pop()
+ try:
+ ps = self.get_parents(ret)
+ except KeyError:
+ return None
+ self.parents[ret] = ps
+ self.heads.update([p for p in ps if p not in self.parents])
+ return ret
+ return None
+
__next__ = next
@@ -667,16 +1472,57 @@ def commit_tree_changes(object_store, tree, changes):
changes: changes to apply
Returns: New tree root object
"""
- pass
+ # TODO(jelmer): Save up the objects and add them using .add_objects
+ # rather than with individual calls to .add_object.
+ nested_changes = {}
+ for path, new_mode, new_sha in changes:
+ try:
+ (dirname, subpath) = path.split(b"/", 1)
+ except ValueError:
+ if new_sha is None:
+ del tree[path]
+ else:
+ tree[path] = (new_mode, new_sha)
+ else:
+ nested_changes.setdefault(dirname, []).append((subpath, new_mode, new_sha))
+ for name, subchanges in nested_changes.items():
+ try:
+ orig_subtree = object_store[tree[name][1]]
+ except KeyError:
+ orig_subtree = Tree()
+ subtree = commit_tree_changes(object_store, orig_subtree, subchanges)
+ if len(subtree) == 0:
+ del tree[name]
+ else:
+ tree[name] = (stat.S_IFDIR, subtree.id)
+ object_store.add_object(tree)
+ return tree
class OverlayObjectStore(BaseObjectStore):
"""Object store that can overlay multiple object stores."""
- def __init__(self, bases, add_store=None) ->None:
+ def __init__(self, bases, add_store=None) -> None:
self.bases = bases
self.add_store = add_store
+ def add_object(self, object):
+ if self.add_store is None:
+ raise NotImplementedError(self.add_object)
+ return self.add_store.add_object(object)
+
+ def add_objects(self, objects, progress=None):
+ if self.add_store is None:
+ raise NotImplementedError(self.add_object)
+ return self.add_store.add_objects(objects, progress)
+
+ @property
+ def packs(self):
+ ret = []
+ for b in self.bases:
+ ret.extend(b.packs)
+ return ret
+
def __iter__(self):
done = set()
for b in self.bases:
@@ -685,10 +1531,68 @@ class OverlayObjectStore(BaseObjectStore):
yield o_id
done.add(o_id)
+ def iterobjects_subset(
+ self, shas: Iterable[bytes], *, allow_missing: bool = False
+ ) -> Iterator[ShaFile]:
+ todo = set(shas)
+ for b in self.bases:
+ for o in b.iterobjects_subset(todo, allow_missing=True):
+ yield o
+ todo.remove(o.id)
+ if todo and not allow_missing:
+ raise KeyError(o.id)
+
+ def iter_unpacked_subset(
+ self,
+ shas: Iterable[bytes],
+ *,
+ include_comp=False,
+ allow_missing: bool = False,
+ convert_ofs_delta=True,
+ ) -> Iterator[ShaFile]:
+ todo = set(shas)
+ for b in self.bases:
+ for o in b.iter_unpacked_subset(
+ todo,
+ include_comp=include_comp,
+ allow_missing=True,
+ convert_ofs_delta=convert_ofs_delta,
+ ):
+ yield o
+ todo.remove(o.id)
+ if todo and not allow_missing:
+ raise KeyError(o.id)
+
+ def get_raw(self, sha_id):
+ for b in self.bases:
+ try:
+ return b.get_raw(sha_id)
+ except KeyError:
+ pass
+ raise KeyError(sha_id)
+
+ def contains_packed(self, sha):
+ for b in self.bases:
+ if b.contains_packed(sha):
+ return True
+ return False
+
+ def contains_loose(self, sha):
+ for b in self.bases:
+ if b.contains_loose(sha):
+ return True
+ return False
+
def read_packs_file(f):
"""Yield the packs listed in a packs file."""
- pass
+ for line in f.read().splitlines():
+ if not line:
+ continue
+ (kind, name) = line.split(b" ", 1)
+ if kind != b"P":
+ continue
+ yield os.fsdecode(name)
class BucketBasedObjectStore(PackBasedObjectStore):
@@ -696,8 +1600,42 @@ class BucketBasedObjectStore(PackBasedObjectStore):
def _iter_loose_objects(self):
"""Iterate over the SHAs of all loose objects."""
+ return iter([])
+
+ def _get_loose_object(self, sha):
+ return None
+
+ def _remove_loose_object(self, sha):
+ # Doesn't exist..
pass
+ def _remove_pack(self, name):
+ raise NotImplementedError(self._remove_pack)
+
+ def _iter_pack_names(self):
+ raise NotImplementedError(self._iter_pack_names)
+
+ def _get_pack(self, name):
+ raise NotImplementedError(self._get_pack)
+
+ def _update_pack_cache(self):
+ pack_files = set(self._iter_pack_names())
+
+ # Open newly appeared pack files
+ new_packs = []
+ for f in pack_files:
+ if f not in self._pack_cache:
+ pack = self._get_pack(f)
+ new_packs.append(pack)
+ self._pack_cache[f] = pack
+ # Remove disappeared pack files
+ for f in set(self._pack_cache) - pack_files:
+ self._pack_cache.pop(f).close()
+ return new_packs
+
+ def _upload_pack(self, basename, pack_file, index_file):
+ raise NotImplementedError
+
def add_pack(self):
"""Add a new pack to this object store.
@@ -705,12 +1643,50 @@ class BucketBasedObjectStore(PackBasedObjectStore):
call when the pack is finished and an abort
function.
"""
- pass
-
-
-def _collect_ancestors(store: ObjectContainer, heads, common: FrozenSet[
- ObjectID]=frozenset(), shallow: FrozenSet[ObjectID]=frozenset(),
- get_parents=lambda commit: commit.parents):
+ import tempfile
+
+ pf = tempfile.SpooledTemporaryFile(
+ max_size=PACK_SPOOL_FILE_MAX_SIZE, prefix="incoming-"
+ )
+
+ def commit():
+ if pf.tell() == 0:
+ pf.close()
+ return None
+
+ pf.seek(0)
+ p = PackData(pf.name, pf)
+ entries = p.sorted_entries()
+ basename = iter_sha1(entry[0] for entry in entries).decode("ascii")
+ idxf = tempfile.SpooledTemporaryFile(
+ max_size=PACK_SPOOL_FILE_MAX_SIZE, prefix="incoming-"
+ )
+ checksum = p.get_stored_checksum()
+ write_pack_index(idxf, entries, checksum)
+ idxf.seek(0)
+ idx = load_pack_index_file(basename + ".idx", idxf)
+ for pack in self.packs:
+ if pack.get_stored_checksum() == p.get_stored_checksum():
+ p.close()
+ idx.close()
+ return pack
+ pf.seek(0)
+ idxf.seek(0)
+ self._upload_pack(basename, pf, idxf)
+ final_pack = Pack.from_objects(p, idx)
+ self._add_cached_pack(basename, final_pack)
+ return final_pack
+
+ return pf, commit, pf.close
+
+
+def _collect_ancestors(
+ store: ObjectContainer,
+ heads,
+ common: FrozenSet[ObjectID] = frozenset(),
+ shallow: FrozenSet[ObjectID] = frozenset(),
+ get_parents=lambda commit: commit.parents,
+):
"""Collect all ancestors of heads up to (excluding) those in common.
Args:
@@ -723,11 +1699,26 @@ def _collect_ancestors(store: ObjectContainer, heads, common: FrozenSet[
from heads but not present in common, B - common (shared) elements
that are directly reachable from heads
"""
- pass
-
-
-def iter_tree_contents(store: ObjectContainer, tree_id: Optional[ObjectID],
- *, include_trees: bool=False):
+ bases = set()
+ commits = set()
+ queue = []
+ queue.extend(heads)
+ while queue:
+ e = queue.pop(0)
+ if e in common:
+ bases.add(e)
+ elif e not in commits:
+ commits.add(e)
+ if e in shallow:
+ continue
+ cmt = store[e]
+ queue.extend(get_parents(cmt))
+ return (commits, bases)
+
+
+def iter_tree_contents(
+ store: ObjectContainer, tree_id: Optional[ObjectID], *, include_trees: bool = False
+):
"""Iterate the contents of a tree and all subtrees.
Iteration is depth-first pre-order, as in e.g. os.walk.
@@ -738,10 +1729,25 @@ def iter_tree_contents(store: ObjectContainer, tree_id: Optional[ObjectID],
Returns: Iterator over TreeEntry namedtuples for all the objects in a
tree.
"""
- pass
-
-
-def peel_sha(store: ObjectContainer, sha: bytes) ->Tuple[ShaFile, ShaFile]:
+ if tree_id is None:
+ return
+ # This could be fairly easily generalized to >2 trees if we find a use
+ # case.
+ todo = [TreeEntry(b"", stat.S_IFDIR, tree_id)]
+ while todo:
+ entry = todo.pop()
+ if stat.S_ISDIR(entry.mode):
+ extra = []
+ tree = store[entry.sha]
+ assert isinstance(tree, Tree)
+ for subentry in tree.iteritems(name_order=True):
+ extra.append(subentry.in_path(entry.path))
+ todo.extend(reversed(extra))
+ if not stat.S_ISDIR(entry.mode) or include_trees:
+ yield entry
+
+
+def peel_sha(store: ObjectContainer, sha: bytes) -> Tuple[ShaFile, ShaFile]:
"""Peel all tags from a SHA.
Args:
@@ -750,4 +1756,10 @@ def peel_sha(store: ObjectContainer, sha: bytes) ->Tuple[ShaFile, ShaFile]:
intermediate tags; if the original ref does not point to a tag,
this will equal the original SHA1.
"""
- pass
+ unpeeled = obj = store[sha]
+ obj_class = object_class(obj.type_name)
+ while obj_class is Tag:
+ assert isinstance(obj, Tag)
+ obj_class, sha = obj.object
+ obj = store[sha]
+ return unpeeled, obj
diff --git a/dulwich/objects.py b/dulwich/objects.py
index c6f09b4f..04e39250 100644
--- a/dulwich/objects.py
+++ b/dulwich/objects.py
@@ -1,4 +1,26 @@
+# objects.py -- Access to base git objects
+# Copyright (C) 2007 James Westby <jw+debian@jameswestby.net>
+# Copyright (C) 2008-2013 Jelmer Vernooij <jelmer@jelmer.uk>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Access to base git objects."""
+
import binascii
import os
import posixpath
@@ -8,26 +30,59 @@ import zlib
from collections import namedtuple
from hashlib import sha1
from io import BytesIO
-from typing import TYPE_CHECKING, BinaryIO, Dict, Iterable, Iterator, List, Optional, Tuple, Type, Union
-from .errors import ChecksumMismatch, FileFormatException, NotBlobError, NotCommitError, NotTagError, NotTreeError, ObjectFormatException
+from typing import (
+ TYPE_CHECKING,
+ BinaryIO,
+ Dict,
+ Iterable,
+ Iterator,
+ List,
+ Optional,
+ Tuple,
+ Type,
+ Union,
+)
+
+from .errors import (
+ ChecksumMismatch,
+ FileFormatException,
+ NotBlobError,
+ NotCommitError,
+ NotTagError,
+ NotTreeError,
+ ObjectFormatException,
+)
from .file import GitFile
+
if TYPE_CHECKING:
from _hashlib import HASH
-ZERO_SHA = b'0' * 40
-_TREE_HEADER = b'tree'
-_PARENT_HEADER = b'parent'
-_AUTHOR_HEADER = b'author'
-_COMMITTER_HEADER = b'committer'
-_ENCODING_HEADER = b'encoding'
-_MERGETAG_HEADER = b'mergetag'
-_GPGSIG_HEADER = b'gpgsig'
-_OBJECT_HEADER = b'object'
-_TYPE_HEADER = b'type'
-_TAG_HEADER = b'tag'
-_TAGGER_HEADER = b'tagger'
-S_IFGITLINK = 57344
-MAX_TIME = 9223372036854775807
-BEGIN_PGP_SIGNATURE = b'-----BEGIN PGP SIGNATURE-----'
+
+ZERO_SHA = b"0" * 40
+
+# Header fields for commits
+_TREE_HEADER = b"tree"
+_PARENT_HEADER = b"parent"
+_AUTHOR_HEADER = b"author"
+_COMMITTER_HEADER = b"committer"
+_ENCODING_HEADER = b"encoding"
+_MERGETAG_HEADER = b"mergetag"
+_GPGSIG_HEADER = b"gpgsig"
+
+# Header fields for objects
+_OBJECT_HEADER = b"object"
+_TYPE_HEADER = b"type"
+_TAG_HEADER = b"tag"
+_TAGGER_HEADER = b"tagger"
+
+
+S_IFGITLINK = 0o160000
+
+
+MAX_TIME = 9223372036854775807 # (2**63) - 1 - signed long int max
+
+BEGIN_PGP_SIGNATURE = b"-----BEGIN PGP SIGNATURE-----"
+
+
ObjectID = bytes
@@ -42,40 +97,93 @@ def S_ISGITLINK(m):
m: Mode to check
Returns: a ``boolean``
"""
- pass
+ return stat.S_IFMT(m) == S_IFGITLINK
+
+
+def _decompress(string):
+ dcomp = zlib.decompressobj()
+ dcomped = dcomp.decompress(string)
+ dcomped += dcomp.flush()
+ return dcomped
def sha_to_hex(sha):
"""Takes a string and returns the hex of the sha within."""
- pass
+ hexsha = binascii.hexlify(sha)
+ assert len(hexsha) == 40, f"Incorrect length of sha1 string: {hexsha!r}"
+ return hexsha
def hex_to_sha(hex):
"""Takes a hex sha and returns a binary sha."""
- pass
+ assert len(hex) == 40, f"Incorrect length of hexsha: {hex}"
+ try:
+ return binascii.unhexlify(hex)
+ except TypeError as exc:
+ if not isinstance(hex, bytes):
+ raise
+ raise ValueError(exc.args[0]) from exc
+
+
+def valid_hexsha(hex):
+ if len(hex) != 40:
+ return False
+ try:
+ binascii.unhexlify(hex)
+ except (TypeError, binascii.Error):
+ return False
+ else:
+ return True
def hex_to_filename(path, hex):
"""Takes a hex sha and returns its filename relative to the given path."""
- pass
+ # os.path.join accepts bytes or unicode, but all args must be of the same
+ # type. Make sure that hex which is expected to be bytes, is the same type
+ # as path.
+ if type(path) is not type(hex) and getattr(path, "encode", None) is not None:
+ hex = hex.decode("ascii")
+ dir = hex[:2]
+ file = hex[2:]
+ # Check from object dir
+ return os.path.join(path, dir, file)
def filename_to_hex(filename):
"""Takes an object filename and returns its corresponding hex sha."""
- pass
-
-
-def object_header(num_type: int, length: int) ->bytes:
+ # grab the last (up to) two path components
+ names = filename.rsplit(os.path.sep, 2)[-2:]
+ errmsg = f"Invalid object filename: {filename}"
+ assert len(names) == 2, errmsg
+ base, rest = names
+ assert len(base) == 2 and len(rest) == 38, errmsg
+ hex = (base + rest).encode("ascii")
+ hex_to_sha(hex)
+ return hex
+
+
+def object_header(num_type: int, length: int) -> bytes:
"""Return an object header for the given numeric type and text length."""
- pass
+ cls = object_class(num_type)
+ if cls is None:
+ raise AssertionError("unsupported class type num: %d" % num_type)
+ return cls.type_name + b" " + str(length).encode("ascii") + b"\0"
-def serializable_property(name: str, docstring: Optional[str]=None):
+def serializable_property(name: str, docstring: Optional[str] = None):
"""A property that helps tracking whether serialization is necessary."""
- pass
+ def set(obj, value):
+ setattr(obj, "_" + name, value)
+ obj._needs_serialization = True
+
+ def get(obj):
+ return getattr(obj, "_" + name)
-def object_class(type: Union[bytes, int]) ->Optional[Type['ShaFile']]:
+ return property(get, set, doc=docstring)
+
+
+def object_class(type: Union[bytes, int]) -> Optional[Type["ShaFile"]]:
"""Get the object class corresponding to the given type.
Args:
@@ -83,7 +191,7 @@ def object_class(type: Union[bytes, int]) ->Optional[Type['ShaFile']]:
Returns: The ShaFile subclass corresponding to the given type, or None if
type is not a valid type name/number.
"""
- pass
+ return _TYPE_MAP.get(type, None)
def check_hexsha(hex, error_msg):
@@ -95,10 +203,11 @@ def check_hexsha(hex, error_msg):
Raises:
ObjectFormatException: Raised when the string is not valid
"""
- pass
+ if not valid_hexsha(hex):
+ raise ObjectFormatException(f"{error_msg} {hex}")
-def check_identity(identity: bytes, error_msg: str) ->None:
+def check_identity(identity: bytes, error_msg: str) -> None:
"""Check if the specified identity is valid.
This will raise an exception if the identity is not valid.
@@ -107,7 +216,19 @@ def check_identity(identity: bytes, error_msg: str) ->None:
identity: Identity string
error_msg: Error message to use in exception
"""
- pass
+ email_start = identity.find(b"<")
+ email_end = identity.find(b">")
+ if not all(
+ [
+ email_start >= 1,
+ identity[email_start - 1] == b" "[0],
+ identity.find(b"<", email_start + 1) == -1,
+ email_end == len(identity) - 1,
+ b"\0" not in identity,
+ b"\n" not in identity,
+ ]
+ ):
+ raise ObjectFormatException(error_msg)
def check_time(time_seconds):
@@ -119,80 +240,120 @@ def check_time(time_seconds):
time_seconds: time in seconds
"""
- pass
+ # Prevent overflow error
+ if time_seconds > MAX_TIME:
+ raise ObjectFormatException(f"Date field should not exceed {MAX_TIME}")
def git_line(*items):
"""Formats items into a space separated line."""
- pass
+ return b" ".join(items) + b"\n"
class FixedSha:
"""SHA object that behaves like hashlib's but is given a fixed value."""
- __slots__ = '_hexsha', '_sha'
- def __init__(self, hexsha) ->None:
- if getattr(hexsha, 'encode', None) is not None:
- hexsha = hexsha.encode('ascii')
+ __slots__ = ("_hexsha", "_sha")
+
+ def __init__(self, hexsha) -> None:
+ if getattr(hexsha, "encode", None) is not None:
+ hexsha = hexsha.encode("ascii")
if not isinstance(hexsha, bytes):
- raise TypeError(f'Expected bytes for hexsha, got {hexsha!r}')
+ raise TypeError(f"Expected bytes for hexsha, got {hexsha!r}")
self._hexsha = hexsha
self._sha = hex_to_sha(hexsha)
- def digest(self) ->bytes:
+ def digest(self) -> bytes:
"""Return the raw SHA digest."""
- pass
+ return self._sha
- def hexdigest(self) ->str:
+ def hexdigest(self) -> str:
"""Return the hex SHA digest."""
- pass
+ return self._hexsha.decode("ascii")
class ShaFile:
"""A git SHA file."""
- __slots__ = '_chunked_text', '_sha', '_needs_serialization'
+
+ __slots__ = ("_chunked_text", "_sha", "_needs_serialization")
+
_needs_serialization: bool
type_name: bytes
type_num: int
_chunked_text: Optional[List[bytes]]
- _sha: Union[FixedSha, None, 'HASH']
+ _sha: Union[FixedSha, None, "HASH"]
@staticmethod
- def _parse_legacy_object_header(magic, f: BinaryIO) ->'ShaFile':
+ def _parse_legacy_object_header(magic, f: BinaryIO) -> "ShaFile":
"""Parse a legacy object, creating it but not reading the file."""
- pass
-
- def _parse_legacy_object(self, map) ->None:
+ bufsize = 1024
+ decomp = zlib.decompressobj()
+ header = decomp.decompress(magic)
+ start = 0
+ end = -1
+ while end < 0:
+ extra = f.read(bufsize)
+ header += decomp.decompress(extra)
+ magic += extra
+ end = header.find(b"\0", start)
+ start = len(header)
+ header = header[:end]
+ type_name, size = header.split(b" ", 1)
+ try:
+ int(size) # sanity check
+ except ValueError as exc:
+ raise ObjectFormatException(f"Object size not an integer: {exc}") from exc
+ obj_class = object_class(type_name)
+ if not obj_class:
+ raise ObjectFormatException(
+ "Not a known type: {}".format(type_name.decode("ascii"))
+ )
+ return obj_class()
+
+ def _parse_legacy_object(self, map) -> None:
"""Parse a legacy object, setting the raw string."""
- pass
+ text = _decompress(map)
+ header_end = text.find(b"\0")
+ if header_end < 0:
+ raise ObjectFormatException("Invalid object header, no \\0")
+ self.set_raw_string(text[header_end + 1 :])
- def as_legacy_object_chunks(self, compression_level: int=-1) ->Iterator[
- bytes]:
+ def as_legacy_object_chunks(self, compression_level: int = -1) -> Iterator[bytes]:
"""Return chunks representing the object in the experimental format.
Returns: List of strings
"""
- pass
+ compobj = zlib.compressobj(compression_level)
+ yield compobj.compress(self._header())
+ for chunk in self.as_raw_chunks():
+ yield compobj.compress(chunk)
+ yield compobj.flush()
- def as_legacy_object(self, compression_level: int=-1) ->bytes:
+ def as_legacy_object(self, compression_level: int = -1) -> bytes:
"""Return string representing the object in the experimental format."""
- pass
+ return b"".join(
+ self.as_legacy_object_chunks(compression_level=compression_level)
+ )
- def as_raw_chunks(self) ->List[bytes]:
+ def as_raw_chunks(self) -> List[bytes]:
"""Return chunks with serialization of the object.
Returns: List of strings, not necessarily one per line
"""
- pass
+ if self._needs_serialization:
+ self._sha = None
+ self._chunked_text = self._serialize()
+ self._needs_serialization = False
+ return self._chunked_text # type: ignore
- def as_raw_string(self) ->bytes:
+ def as_raw_string(self) -> bytes:
"""Return raw string with serialization of the object.
Returns: String object
"""
- pass
+ return b"".join(self.as_raw_chunks())
- def __bytes__(self) ->bytes:
+ def __bytes__(self) -> bytes:
"""Return raw string serialization of this object."""
return self.as_raw_string()
@@ -200,43 +361,97 @@ class ShaFile:
"""Return unique hash for this object."""
return hash(self.id)
- def as_pretty_string(self) ->str:
+ def as_pretty_string(self) -> str:
"""Return a string representing this object, fit for display."""
- pass
+ return self.as_raw_string().decode("utf-8", "replace")
- def set_raw_string(self, text: bytes, sha: Optional[ObjectID]=None) ->None:
+ def set_raw_string(self, text: bytes, sha: Optional[ObjectID] = None) -> None:
"""Set the contents of this object from a serialized string."""
- pass
+ if not isinstance(text, bytes):
+ raise TypeError(f"Expected bytes for text, got {text!r}")
+ self.set_raw_chunks([text], sha)
- def set_raw_chunks(self, chunks: List[bytes], sha: Optional[ObjectID]=None
- ) ->None:
+ def set_raw_chunks(
+ self, chunks: List[bytes], sha: Optional[ObjectID] = None
+ ) -> None:
"""Set the contents of this object from a list of chunks."""
- pass
+ self._chunked_text = chunks
+ self._deserialize(chunks)
+ if sha is None:
+ self._sha = None
+ else:
+ self._sha = FixedSha(sha) # type: ignore
+ self._needs_serialization = False
@staticmethod
def _parse_object_header(magic, f):
"""Parse a new style object, creating it but not reading the file."""
- pass
+ num_type = (ord(magic[0:1]) >> 4) & 7
+ obj_class = object_class(num_type)
+ if not obj_class:
+ raise ObjectFormatException("Not a known type %d" % num_type)
+ return obj_class()
- def _parse_object(self, map) ->None:
+ def _parse_object(self, map) -> None:
"""Parse a new style object, setting self._text."""
- pass
+ # skip type and size; type must have already been determined, and
+ # we trust zlib to fail if it's otherwise corrupted
+ byte = ord(map[0:1])
+ used = 1
+ while (byte & 0x80) != 0:
+ byte = ord(map[used : used + 1])
+ used += 1
+ raw = map[used:]
+ self.set_raw_string(_decompress(raw))
- def __init__(self) ->None:
+ @classmethod
+ def _is_legacy_object(cls, magic: bytes) -> bool:
+ b0 = ord(magic[0:1])
+ b1 = ord(magic[1:2])
+ word = (b0 << 8) + b1
+ return (b0 & 0x8F) == 0x08 and (word % 31) == 0
+
+ @classmethod
+ def _parse_file(cls, f):
+ map = f.read()
+ if not map:
+ raise EmptyFileException("Corrupted empty file detected")
+
+ if cls._is_legacy_object(map):
+ obj = cls._parse_legacy_object_header(map, f)
+ obj._parse_legacy_object(map)
+ else:
+ obj = cls._parse_object_header(map, f)
+ obj._parse_object(map)
+ return obj
+
+ def __init__(self) -> None:
"""Don't call this directly."""
self._sha = None
self._chunked_text = []
self._needs_serialization = True
+ def _deserialize(self, chunks: List[bytes]) -> None:
+ raise NotImplementedError(self._deserialize)
+
+ def _serialize(self) -> List[bytes]:
+ raise NotImplementedError(self._serialize)
+
@classmethod
def from_path(cls, path):
"""Open a SHA file from disk."""
- pass
+ with GitFile(path, "rb") as f:
+ return cls.from_file(f)
@classmethod
def from_file(cls, f):
"""Get the contents of a SHA file on disk."""
- pass
+ try:
+ obj = cls._parse_file(f)
+ obj._sha = None
+ return obj
+ except (IndexError, ValueError) as exc:
+ raise ObjectFormatException("invalid object header") from exc
@staticmethod
def from_raw_string(type_num, string, sha=None):
@@ -247,11 +462,17 @@ class ShaFile:
string: The raw uncompressed contents.
sha: Optional known sha for the object
"""
- pass
+ cls = object_class(type_num)
+ if cls is None:
+ raise AssertionError("unsupported class type num: %d" % type_num)
+ obj = cls()
+ obj.set_raw_string(string, sha)
+ return obj
@staticmethod
- def from_raw_chunks(type_num: int, chunks: List[bytes], sha: Optional[
- ObjectID]=None):
+ def from_raw_chunks(
+ type_num: int, chunks: List[bytes], sha: Optional[ObjectID] = None
+ ):
"""Creates an object of the indicated type from the raw chunks given.
Args:
@@ -259,12 +480,19 @@ class ShaFile:
chunks: An iterable of the raw uncompressed contents.
sha: Optional known sha for the object
"""
- pass
+ cls = object_class(type_num)
+ if cls is None:
+ raise AssertionError("unsupported class type num: %d" % type_num)
+ obj = cls()
+ obj.set_raw_chunks(chunks, sha)
+ return obj
@classmethod
def from_string(cls, string):
"""Create a ShaFile from a string."""
- pass
+ obj = cls()
+ obj.set_raw_string(string)
+ return obj
def _check_has_member(self, member, error_msg):
"""Check that the object has a given member variable.
@@ -276,9 +504,10 @@ class ShaFile:
ObjectFormatException: with the given error_msg if member is
missing or is None
"""
- pass
+ if getattr(self, member, None) is None:
+ raise ObjectFormatException(error_msg)
- def check(self) ->None:
+ def check(self) -> None:
"""Check this object for internal consistency.
Raises:
@@ -286,27 +515,52 @@ class ShaFile:
ChecksumMismatch: if the object was created with a SHA that does
not match its contents
"""
- pass
-
- def raw_length(self) ->int:
+ # TODO: if we find that error-checking during object parsing is a
+ # performance bottleneck, those checks should be moved to the class's
+ # check() method during optimization so we can still check the object
+ # when necessary.
+ old_sha = self.id
+ try:
+ self._deserialize(self.as_raw_chunks())
+ self._sha = None
+ new_sha = self.id
+ except Exception as exc:
+ raise ObjectFormatException(exc) from exc
+ if old_sha != new_sha:
+ raise ChecksumMismatch(new_sha, old_sha)
+
+ def _header(self):
+ return object_header(self.type_num, self.raw_length())
+
+ def raw_length(self) -> int:
"""Returns the length of the raw string of this object."""
- pass
+ return sum(map(len, self.as_raw_chunks()))
def sha(self):
"""The SHA1 object that is the name of this object."""
- pass
+ if self._sha is None or self._needs_serialization:
+ # this is a local because as_raw_chunks() overwrites self._sha
+ new_sha = sha1()
+ new_sha.update(self._header())
+ for chunk in self.as_raw_chunks():
+ new_sha.update(chunk)
+ self._sha = new_sha
+ return self._sha
def copy(self):
"""Create a new copy of this SHA1 object from its raw string."""
- pass
+ obj_class = object_class(self.type_num)
+ if obj_class is None:
+ raise AssertionError("invalid type num %d" % self.type_num)
+ return obj_class.from_raw_string(self.type_num, self.as_raw_string(), self.id)
@property
def id(self):
"""The hex SHA of this object."""
- pass
+ return self.sha().hexdigest().encode("ascii")
- def __repr__(self) ->str:
- return f'<{self.__class__.__name__} {self.id}>'
+ def __repr__(self) -> str:
+ return f"<{self.__class__.__name__} {self.id}>"
def __ne__(self, other):
"""Check whether this object does not match the other."""
@@ -331,19 +585,53 @@ class ShaFile:
class Blob(ShaFile):
"""A Git Blob object."""
+
__slots__ = ()
- type_name = b'blob'
+
+ type_name = b"blob"
type_num = 3
+
_chunked_text: List[bytes]
- def __init__(self) ->None:
+ def __init__(self) -> None:
super().__init__()
self._chunked_text = []
self._needs_serialization = False
- data = property(_get_data, _set_data, doc=
- 'The text contained within the blob object.')
- chunked = property(_get_chunked, _set_chunked, doc=
- 'The text in the blob object, as chunks (not necessarily lines)')
+
+ def _get_data(self):
+ return self.as_raw_string()
+
+ def _set_data(self, data):
+ self.set_raw_string(data)
+
+ data = property(
+ _get_data, _set_data, doc="The text contained within the blob object."
+ )
+
+ def _get_chunked(self):
+ return self._chunked_text
+
+ def _set_chunked(self, chunks: List[bytes]):
+ self._chunked_text = chunks
+
+ def _serialize(self):
+ return self._chunked_text
+
+ def _deserialize(self, chunks):
+ self._chunked_text = chunks
+
+ chunked = property(
+ _get_chunked,
+ _set_chunked,
+ doc="The text in the blob object, as chunks (not necessarily lines)",
+ )
+
+ @classmethod
+ def from_path(cls, path):
+ blob = ShaFile.from_path(path)
+ if not isinstance(blob, cls):
+ raise NotBlobError(path)
+ return blob
def check(self):
"""Check this object for internal consistency.
@@ -351,18 +639,39 @@ class Blob(ShaFile):
Raises:
ObjectFormatException: if the object is malformed in some way
"""
- pass
+ super().check()
- def splitlines(self) ->List[bytes]:
+ def splitlines(self) -> List[bytes]:
"""Return list of lines in this blob.
This preserves the original line endings.
"""
- pass
-
-
-def _parse_message(chunks: Iterable[bytes]) ->Iterator[Union[Tuple[None,
- None], Tuple[Optional[bytes], bytes]]]:
+ chunks = self.chunked
+ if not chunks:
+ return []
+ if len(chunks) == 1:
+ return chunks[0].splitlines(True)
+ remaining = None
+ ret = []
+ for chunk in chunks:
+ lines = chunk.splitlines(True)
+ if len(lines) > 1:
+ ret.append((remaining or b"") + lines[0])
+ ret.extend(lines[1:-1])
+ remaining = lines[-1]
+ elif len(lines) == 1:
+ if remaining is None:
+ remaining = lines.pop()
+ else:
+ remaining += lines.pop()
+ if remaining is not None:
+ ret.append(remaining)
+ return ret
+
+
+def _parse_message(
+ chunks: Iterable[bytes],
+) -> Iterator[Union[Tuple[None, None], Tuple[Optional[bytes], bytes]]]:
"""Parse a message with a list of fields and a body.
Args:
@@ -371,19 +680,83 @@ def _parse_message(chunks: Iterable[bytes]) ->Iterator[Union[Tuple[None,
order read from the text, possibly including duplicates. Includes a
field named None for the freeform tag/commit text.
"""
- pass
+ f = BytesIO(b"".join(chunks))
+ k = None
+ v = b""
+ eof = False
+
+ def _strip_last_newline(value):
+ """Strip the last newline from value."""
+ if value and value.endswith(b"\n"):
+ return value[:-1]
+ return value
+
+ # Parse the headers
+ #
+ # Headers can contain newlines. The next line is indented with a space.
+ # We store the latest key as 'k', and the accumulated value as 'v'.
+ for line in f:
+ if line.startswith(b" "):
+ # Indented continuation of the previous line
+ v += line[1:]
+ else:
+ if k is not None:
+ # We parsed a new header, return its value
+ yield (k, _strip_last_newline(v))
+ if line == b"\n":
+ # Empty line indicates end of headers
+ break
+ (k, v) = line.split(b" ", 1)
+
+ else:
+ # We reached end of file before the headers ended. We still need to
+ # return the previous header, then we need to return a None field for
+ # the text.
+ eof = True
+ if k is not None:
+ yield (k, _strip_last_newline(v))
+ yield (None, None)
+
+ if not eof:
+ # We didn't reach the end of file while parsing headers. We can return
+ # the rest of the file as a message.
+ yield (None, f.read())
+
+ f.close()
+
+
+def _format_message(headers, body):
+ for field, value in headers:
+ lines = value.split(b"\n")
+ yield git_line(field, lines[0])
+ for line in lines[1:]:
+ yield b" " + line + b"\n"
+ if body:
+ yield b"\n" # There must be a new line after the headers
+ yield body
class Tag(ShaFile):
"""A Git Tag object."""
- type_name = b'tag'
+
+ type_name = b"tag"
type_num = 4
- __slots__ = ('_tag_timezone_neg_utc', '_name', '_object_sha',
- '_object_class', '_tag_time', '_tag_timezone', '_tagger',
- '_message', '_signature')
+
+ __slots__ = (
+ "_tag_timezone_neg_utc",
+ "_name",
+ "_object_sha",
+ "_object_class",
+ "_tag_time",
+ "_tag_timezone",
+ "_tagger",
+ "_message",
+ "_signature",
+ )
+
_tagger: Optional[bytes]
- def __init__(self) ->None:
+ def __init__(self) -> None:
super().__init__()
self._tagger = None
self._tag_time = None
@@ -391,39 +764,159 @@ class Tag(ShaFile):
self._tag_timezone_neg_utc = False
self._signature = None
+ @classmethod
+ def from_path(cls, filename):
+ tag = ShaFile.from_path(filename)
+ if not isinstance(tag, cls):
+ raise NotTagError(filename)
+ return tag
+
def check(self):
"""Check this object for internal consistency.
Raises:
ObjectFormatException: if the object is malformed in some way
"""
- pass
+ super().check()
+ assert self._chunked_text is not None
+ self._check_has_member("_object_sha", "missing object sha")
+ self._check_has_member("_object_class", "missing object type")
+ self._check_has_member("_name", "missing tag name")
+
+ if not self._name:
+ raise ObjectFormatException("empty tag name")
+
+ check_hexsha(self._object_sha, "invalid object sha")
+
+ if self._tagger is not None:
+ check_identity(self._tagger, "invalid tagger")
+
+ self._check_has_member("_tag_time", "missing tag time")
+ check_time(self._tag_time)
+
+ last = None
+ for field, _ in _parse_message(self._chunked_text):
+ if field == _OBJECT_HEADER and last is not None:
+ raise ObjectFormatException("unexpected object")
+ elif field == _TYPE_HEADER and last != _OBJECT_HEADER:
+ raise ObjectFormatException("unexpected type")
+ elif field == _TAG_HEADER and last != _TYPE_HEADER:
+ raise ObjectFormatException("unexpected tag name")
+ elif field == _TAGGER_HEADER and last != _TAG_HEADER:
+ raise ObjectFormatException("unexpected tagger")
+ last = field
+
+ def _serialize(self):
+ headers = []
+ headers.append((_OBJECT_HEADER, self._object_sha))
+ headers.append((_TYPE_HEADER, self._object_class.type_name))
+ headers.append((_TAG_HEADER, self._name))
+ if self._tagger:
+ if self._tag_time is None:
+ headers.append((_TAGGER_HEADER, self._tagger))
+ else:
+ headers.append(
+ (
+ _TAGGER_HEADER,
+ format_time_entry(
+ self._tagger,
+ self._tag_time,
+ (self._tag_timezone, self._tag_timezone_neg_utc),
+ ),
+ )
+ )
+
+ if self.message is None and self._signature is None:
+ body = None
+ else:
+ body = (self.message or b"") + (self._signature or b"")
+ return list(_format_message(headers, body))
def _deserialize(self, chunks):
"""Grab the metadata attached to the tag."""
- pass
+ self._tagger = None
+ self._tag_time = None
+ self._tag_timezone = None
+ self._tag_timezone_neg_utc = False
+ for field, value in _parse_message(chunks):
+ if field == _OBJECT_HEADER:
+ self._object_sha = value
+ elif field == _TYPE_HEADER:
+ assert isinstance(value, bytes)
+ obj_class = object_class(value)
+ if not obj_class:
+ raise ObjectFormatException(f"Not a known type: {value!r}")
+ self._object_class = obj_class
+ elif field == _TAG_HEADER:
+ self._name = value
+ elif field == _TAGGER_HEADER:
+ (
+ self._tagger,
+ self._tag_time,
+ (self._tag_timezone, self._tag_timezone_neg_utc),
+ ) = parse_time_entry(value)
+ elif field is None:
+ if value is None:
+ self._message = None
+ self._signature = None
+ else:
+ try:
+ sig_idx = value.index(BEGIN_PGP_SIGNATURE)
+ except ValueError:
+ self._message = value
+ self._signature = None
+ else:
+ self._message = value[:sig_idx]
+ self._signature = value[sig_idx:]
+ else:
+ raise ObjectFormatException(f"Unknown field {field}")
def _get_object(self):
"""Get the object pointed to by this tag.
Returns: tuple of (object class, sha).
"""
- pass
+ return (self._object_class, self._object_sha)
+
+ def _set_object(self, value):
+ (self._object_class, self._object_sha) = value
+ self._needs_serialization = True
+
object = property(_get_object, _set_object)
- name = serializable_property('name', 'The name of this tag')
- tagger = serializable_property('tagger',
- 'Returns the name of the person who created this tag')
- tag_time = serializable_property('tag_time',
- 'The creation timestamp of the tag. As the number of seconds since the epoch'
- )
- tag_timezone = serializable_property('tag_timezone',
- 'The timezone that tag_time is in.')
- message = serializable_property('message',
- 'the message attached to this tag')
- signature = serializable_property('signature',
- 'Optional detached GPG signature')
-
- def verify(self, keyids: Optional[Iterable[str]]=None) ->None:
+
+ name = serializable_property("name", "The name of this tag")
+ tagger = serializable_property(
+ "tagger", "Returns the name of the person who created this tag"
+ )
+ tag_time = serializable_property(
+ "tag_time",
+ "The creation timestamp of the tag. As the number of seconds "
+ "since the epoch",
+ )
+ tag_timezone = serializable_property(
+ "tag_timezone", "The timezone that tag_time is in."
+ )
+ message = serializable_property("message", "the message attached to this tag")
+
+ signature = serializable_property("signature", "Optional detached GPG signature")
+
+ def sign(self, keyid: Optional[str] = None):
+ import gpg
+
+ with gpg.Context(armor=True) as c:
+ if keyid is not None:
+ key = c.get_key(keyid)
+ with gpg.Context(armor=True, signers=[key]) as ctx:
+ self.signature, unused_result = ctx.sign(
+ self.as_raw_string(),
+ mode=gpg.constants.sig.mode.DETACH,
+ )
+ else:
+ self.signature, unused_result = c.sign(
+ self.as_raw_string(), mode=gpg.constants.sig.mode.DETACH
+ )
+
+ def verify(self, keyids: Optional[Iterable[str]] = None) -> None:
"""Verify GPG signature for this tag (if it is signed).
Args:
@@ -437,15 +930,34 @@ class Tag(ShaFile):
gpg.errors.MissingSignatures: if tag was not signed by a key
specified in keyids
"""
- pass
-
-
-class TreeEntry(namedtuple('TreeEntry', ['path', 'mode', 'sha'])):
+ if self._signature is None:
+ return
+
+ import gpg
+
+ with gpg.Context() as ctx:
+ data, result = ctx.verify(
+ self.as_raw_string()[: -len(self._signature)],
+ signature=self._signature,
+ )
+ if keyids:
+ keys = [ctx.get_key(key) for key in keyids]
+ for key in keys:
+ for subkey in keys:
+ for sig in result.signatures:
+ if subkey.can_sign and subkey.fpr == sig.fpr:
+ return
+ raise gpg.errors.MissingSignatures(result, keys, results=(data, result))
+
+
+class TreeEntry(namedtuple("TreeEntry", ["path", "mode", "sha"])):
"""Named tuple encapsulating a single tree entry."""
def in_path(self, path: bytes):
"""Return a copy of this entry with the given path prepended."""
- pass
+ if not isinstance(self.path, bytes):
+ raise TypeError(f"Expected bytes for path, got {path!r}")
+ return TreeEntry(posixpath.join(path, self.path), self.mode, self.sha)
def parse_tree(text, strict=False):
@@ -458,7 +970,25 @@ def parse_tree(text, strict=False):
Raises:
ObjectFormatException: if the object was malformed in some way
"""
- pass
+ count = 0
+ length = len(text)
+ while count < length:
+ mode_end = text.index(b" ", count)
+ mode_text = text[count:mode_end]
+ if strict and mode_text.startswith(b"0"):
+ raise ObjectFormatException(f"Invalid mode '{mode_text}'")
+ try:
+ mode = int(mode_text, 8)
+ except ValueError as exc:
+ raise ObjectFormatException(f"Invalid mode '{mode_text}'") from exc
+ name_end = text.index(b"\0", mode_end)
+ name = text[mode_end + 1 : name_end]
+ count = name_end + 21
+ sha = text[name_end + 1 : count]
+ if len(sha) != 20:
+ raise ObjectFormatException("Sha has invalid length")
+ hexsha = sha_to_hex(sha)
+ yield (name, mode, hexsha)
def serialize_tree(items):
@@ -468,7 +998,10 @@ def serialize_tree(items):
items: Sorted iterable over (name, mode, sha) tuples
Returns: Serialized tree text as chunks
"""
- pass
+ for name, mode, hexsha in items:
+ yield (
+ (f"{mode:04o}").encode("ascii") + b" " + name + b"\0" + hex_to_sha(hexsha)
+ )
def sorted_tree_items(entries, name_order: bool):
@@ -481,24 +1014,37 @@ def sorted_tree_items(entries, name_order: bool):
entries: Dictionary mapping names to (mode, sha) tuples
Returns: Iterator over (name, mode, hexsha)
"""
- pass
+ if name_order:
+ key_func = key_entry_name_order
+ else:
+ key_func = key_entry
+ for name, entry in sorted(entries.items(), key=key_func):
+ mode, hexsha = entry
+ # Stricter type checks than normal to mirror checks in the Rust version.
+ mode = int(mode)
+ if not isinstance(hexsha, bytes):
+ raise TypeError(f"Expected bytes for SHA, got {hexsha!r}")
+ yield TreeEntry(name, mode, hexsha)
-def key_entry(entry) ->bytes:
+def key_entry(entry) -> bytes:
"""Sort key for tree entry.
Args:
entry: (name, value) tuple
"""
- pass
+ (name, value) = entry
+ if stat.S_ISDIR(value[0]):
+ name += b"/"
+ return name
def key_entry_name_order(entry):
"""Sort key for tree entry in name order."""
- pass
+ return entry[0]
-def pretty_format_tree_entry(name, mode, hexsha, encoding='utf-8') ->str:
+def pretty_format_tree_entry(name, mode, hexsha, encoding="utf-8") -> str:
"""Pretty format tree entry.
Args:
@@ -507,34 +1053,52 @@ def pretty_format_tree_entry(name, mode, hexsha, encoding='utf-8') ->str:
hexsha: Hexsha of the referenced object
Returns: string describing the tree entry
"""
- pass
+ if mode & stat.S_IFDIR:
+ kind = "tree"
+ else:
+ kind = "blob"
+ return "{:04o} {} {}\t{}\n".format(
+ mode,
+ kind,
+ hexsha.decode("ascii"),
+ name.decode(encoding, "replace"),
+ )
class SubmoduleEncountered(Exception):
"""A submodule was encountered while resolving a path."""
- def __init__(self, path, sha) ->None:
+ def __init__(self, path, sha) -> None:
self.path = path
self.sha = sha
class Tree(ShaFile):
"""A Git tree object."""
- type_name = b'tree'
+
+ type_name = b"tree"
type_num = 2
- __slots__ = '_entries'
- def __init__(self) ->None:
+ __slots__ = "_entries"
+
+ def __init__(self) -> None:
super().__init__()
self._entries: Dict[bytes, Tuple[int, bytes]] = {}
- def __contains__(self, name) ->bool:
+ @classmethod
+ def from_path(cls, filename):
+ tree = ShaFile.from_path(filename)
+ if not isinstance(tree, cls):
+ raise NotTreeError(filename)
+ return tree
+
+ def __contains__(self, name) -> bool:
return name in self._entries
def __getitem__(self, name):
return self._entries[name]
- def __setitem__(self, name, value) ->None:
+ def __setitem__(self, name, value) -> None:
"""Set a tree entry by name.
Args:
@@ -544,14 +1108,14 @@ class Tree(ShaFile):
a string.
"""
mode, hexsha = value
- self._entries[name] = mode, hexsha
+ self._entries[name] = (mode, hexsha)
self._needs_serialization = True
- def __delitem__(self, name) ->None:
+ def __delitem__(self, name) -> None:
del self._entries[name]
self._needs_serialization = True
- def __len__(self) ->int:
+ def __len__(self) -> int:
return len(self._entries)
def __iter__(self):
@@ -566,7 +1130,8 @@ class Tree(ShaFile):
name: The name of the entry, as a string.
hexsha: The hex SHA of the entry as a string.
"""
- pass
+ self._entries[name] = mode, hexsha
+ self._needs_serialization = True
def iteritems(self, name_order=False):
"""Iterate over entries.
@@ -576,18 +1141,25 @@ class Tree(ShaFile):
order.
Returns: Iterator over (name, mode, sha) tuples
"""
- pass
+ return sorted_tree_items(self._entries, name_order)
def items(self):
"""Return the sorted entries in this tree.
Returns: List with (name, mode, sha) tuples
"""
- pass
+ return list(self.iteritems())
def _deserialize(self, chunks):
"""Grab the entries in the tree."""
- pass
+ try:
+ parsed_entries = parse_tree(b"".join(chunks))
+ except ValueError as exc:
+ raise ObjectFormatException(exc) from exc
+ # TODO: list comprehension is for efficiency in the common (small)
+ # case; if memory efficiency in the large case is a concern, use a
+ # genexp.
+ self._entries = {n: (m, s) for n, m, s in parsed_entries}
def check(self):
"""Check this object for internal consistency.
@@ -595,7 +1167,44 @@ class Tree(ShaFile):
Raises:
ObjectFormatException: if the object is malformed in some way
"""
- pass
+ super().check()
+ assert self._chunked_text is not None
+ last = None
+ allowed_modes = (
+ stat.S_IFREG | 0o755,
+ stat.S_IFREG | 0o644,
+ stat.S_IFLNK,
+ stat.S_IFDIR,
+ S_IFGITLINK,
+ # TODO: optionally exclude as in git fsck --strict
+ stat.S_IFREG | 0o664,
+ )
+ for name, mode, sha in parse_tree(b"".join(self._chunked_text), True):
+ check_hexsha(sha, f"invalid sha {sha}")
+ if b"/" in name or name in (b"", b".", b"..", b".git"):
+ raise ObjectFormatException(
+ "invalid name {}".format(name.decode("utf-8", "replace"))
+ )
+
+ if mode not in allowed_modes:
+ raise ObjectFormatException(f"invalid mode {mode:06o}")
+
+ entry = (name, (mode, sha))
+ if last:
+ if key_entry(last) > key_entry(entry):
+ raise ObjectFormatException("entries not sorted")
+ if name == last[0]:
+ raise ObjectFormatException(f"duplicate entry {name}")
+ last = entry
+
+ def _serialize(self):
+ return list(serialize_tree(self.iteritems()))
+
+ def as_pretty_string(self) -> str:
+ text: List[str] = []
+ for name, mode, hexsha in self.iteritems():
+ text.append(pretty_format_tree_entry(name, mode, hexsha))
+ return "".join(text)
def lookup_path(self, lookup_obj, path):
"""Look up an object in a Git tree.
@@ -605,7 +1214,19 @@ class Tree(ShaFile):
path: Path to lookup
Returns: A tuple of (mode, SHA) of the resulting path.
"""
- pass
+ parts = path.split(b"/")
+ sha = self.id
+ mode = None
+ for i, p in enumerate(parts):
+ if not p:
+ continue
+ if mode is not None and S_ISGITLINK(mode):
+ raise SubmoduleEncountered(b"/".join(parts[:i]), sha)
+ obj = lookup_obj(sha)
+ if not isinstance(obj, Tree):
+ raise NotTreeError(sha)
+ mode, sha = obj[p]
+ return mode, sha
def parse_timezone(text):
@@ -617,7 +1238,24 @@ def parse_timezone(text):
and a boolean indicating whether this was a UTC timezone
prefixed with a negative sign (-0000).
"""
- pass
+ # cgit parses the first character as the sign, and the rest
+ # as an integer (using strtol), which could also be negative.
+ # We do the same for compatibility. See #697828.
+ if text[0] not in b"+-":
+ raise ValueError("Timezone must start with + or - ({text})".format(**vars()))
+ sign = text[:1]
+ offset = int(text[1:])
+ if sign == b"-":
+ offset = -offset
+ unnecessary_negative_timezone = offset >= 0 and sign == b"-"
+ signum = (offset < 0) and -1 or 1
+ offset = abs(offset)
+ hours = int(offset / 100)
+ minutes = offset % 100
+ return (
+ signum * (hours * 3600 + minutes * 60),
+ unnecessary_negative_timezone,
+ )
def format_timezone(offset, unnecessary_negative_timezone=False):
@@ -628,7 +1266,14 @@ def format_timezone(offset, unnecessary_negative_timezone=False):
unnecessary_negative_timezone: Whether to use a minus sign for
UTC or positive timezones (-0000 and --700 rather than +0000 / +0700).
"""
- pass
+ if offset % 60 != 0:
+ raise ValueError("Unable to handle non-minute offset.")
+ if offset < 0 or unnecessary_negative_timezone:
+ sign = "-"
+ offset = -offset
+ else:
+ sign = "+"
+ return ("%c%02d%02d" % (sign, offset / 3600, (offset / 60) % 60)).encode("ascii")
def parse_time_entry(value):
@@ -641,12 +1286,27 @@ def parse_time_entry(value):
field date)
Returns: Tuple of (author, time, (timezone, timezone_neg_utc))
"""
- pass
+ try:
+ sep = value.rindex(b"> ")
+ except ValueError:
+ return (value, None, (None, False))
+ try:
+ person = value[0 : sep + 1]
+ rest = value[sep + 2 :]
+ timetext, timezonetext = rest.rsplit(b" ", 1)
+ time = int(timetext)
+ timezone, timezone_neg_utc = parse_timezone(timezonetext)
+ except ValueError as exc:
+ raise ObjectFormatException(exc) from exc
+ return person, time, (timezone, timezone_neg_utc)
def format_time_entry(person, time, timezone_info):
"""Format an event."""
- pass
+ (timezone, timezone_neg_utc) = timezone_info
+ return b" ".join(
+ [person, str(time).encode("ascii"), format_timezone(timezone, timezone_neg_utc)]
+ )
def parse_commit(chunks):
@@ -657,20 +1317,75 @@ def parse_commit(chunks):
Returns: Tuple of (tree, parents, author_info, commit_info,
encoding, mergetag, gpgsig, message, extra)
"""
- pass
+ warnings.warn("parse_commit will be removed in 0.22", DeprecationWarning)
+ parents = []
+ extra = []
+ tree = None
+ author_info = (None, None, (None, None))
+ commit_info = (None, None, (None, None))
+ encoding = None
+ mergetag = []
+ message = None
+ gpgsig = None
+
+ for field, value in _parse_message(chunks):
+ # TODO(jelmer): Enforce ordering
+ if field == _TREE_HEADER:
+ tree = value
+ elif field == _PARENT_HEADER:
+ parents.append(value)
+ elif field == _AUTHOR_HEADER:
+ author_info = parse_time_entry(value)
+ elif field == _COMMITTER_HEADER:
+ commit_info = parse_time_entry(value)
+ elif field == _ENCODING_HEADER:
+ encoding = value
+ elif field == _MERGETAG_HEADER:
+ mergetag.append(Tag.from_string(value + b"\n"))
+ elif field == _GPGSIG_HEADER:
+ gpgsig = value
+ elif field is None:
+ message = value
+ else:
+ extra.append((field, value))
+ return (
+ tree,
+ parents,
+ author_info,
+ commit_info,
+ encoding,
+ mergetag,
+ gpgsig,
+ message,
+ extra,
+ )
class Commit(ShaFile):
"""A git commit object."""
- type_name = b'commit'
+
+ type_name = b"commit"
type_num = 1
- __slots__ = ('_parents', '_encoding', '_extra',
- '_author_timezone_neg_utc', '_commit_timezone_neg_utc',
- '_commit_time', '_author_time', '_author_timezone',
- '_commit_timezone', '_author', '_committer', '_tree', '_message',
- '_mergetag', '_gpgsig')
- def __init__(self) ->None:
+ __slots__ = (
+ "_parents",
+ "_encoding",
+ "_extra",
+ "_author_timezone_neg_utc",
+ "_commit_timezone_neg_utc",
+ "_commit_time",
+ "_author_time",
+ "_author_timezone",
+ "_commit_timezone",
+ "_author",
+ "_committer",
+ "_tree",
+ "_message",
+ "_mergetag",
+ "_gpgsig",
+ )
+
+ def __init__(self) -> None:
super().__init__()
self._parents: List[bytes] = []
self._encoding = None
@@ -680,15 +1395,121 @@ class Commit(ShaFile):
self._author_timezone_neg_utc = False
self._commit_timezone_neg_utc = False
+ @classmethod
+ def from_path(cls, path):
+ commit = ShaFile.from_path(path)
+ if not isinstance(commit, cls):
+ raise NotCommitError(path)
+ return commit
+
+ def _deserialize(self, chunks):
+ self._parents = []
+ self._extra = []
+ self._tree = None
+ author_info = (None, None, (None, None))
+ commit_info = (None, None, (None, None))
+ self._encoding = None
+ self._mergetag = []
+ self._message = None
+ self._gpgsig = None
+
+ for field, value in _parse_message(chunks):
+ # TODO(jelmer): Enforce ordering
+ if field == _TREE_HEADER:
+ self._tree = value
+ elif field == _PARENT_HEADER:
+ assert value is not None
+ self._parents.append(value)
+ elif field == _AUTHOR_HEADER:
+ author_info = parse_time_entry(value)
+ elif field == _COMMITTER_HEADER:
+ commit_info = parse_time_entry(value)
+ elif field == _ENCODING_HEADER:
+ self._encoding = value
+ elif field == _MERGETAG_HEADER:
+ assert value is not None
+ self._mergetag.append(Tag.from_string(value + b"\n"))
+ elif field == _GPGSIG_HEADER:
+ self._gpgsig = value
+ elif field is None:
+ self._message = value
+ else:
+ self._extra.append((field, value))
+
+ (
+ self._author,
+ self._author_time,
+ (self._author_timezone, self._author_timezone_neg_utc),
+ ) = author_info
+ (
+ self._committer,
+ self._commit_time,
+ (self._commit_timezone, self._commit_timezone_neg_utc),
+ ) = commit_info
+
def check(self):
"""Check this object for internal consistency.
Raises:
ObjectFormatException: if the object is malformed in some way
"""
- pass
-
- def verify(self, keyids: Optional[Iterable[str]]=None):
+ super().check()
+ assert self._chunked_text is not None
+ self._check_has_member("_tree", "missing tree")
+ self._check_has_member("_author", "missing author")
+ self._check_has_member("_committer", "missing committer")
+ self._check_has_member("_author_time", "missing author time")
+ self._check_has_member("_commit_time", "missing commit time")
+
+ for parent in self._parents:
+ check_hexsha(parent, "invalid parent sha")
+ check_hexsha(self._tree, "invalid tree sha")
+
+ check_identity(self._author, "invalid author")
+ check_identity(self._committer, "invalid committer")
+
+ check_time(self._author_time)
+ check_time(self._commit_time)
+
+ last = None
+ for field, _ in _parse_message(self._chunked_text):
+ if field == _TREE_HEADER and last is not None:
+ raise ObjectFormatException("unexpected tree")
+ elif field == _PARENT_HEADER and last not in (
+ _PARENT_HEADER,
+ _TREE_HEADER,
+ ):
+ raise ObjectFormatException("unexpected parent")
+ elif field == _AUTHOR_HEADER and last not in (
+ _TREE_HEADER,
+ _PARENT_HEADER,
+ ):
+ raise ObjectFormatException("unexpected author")
+ elif field == _COMMITTER_HEADER and last != _AUTHOR_HEADER:
+ raise ObjectFormatException("unexpected committer")
+ elif field == _ENCODING_HEADER and last != _COMMITTER_HEADER:
+ raise ObjectFormatException("unexpected encoding")
+ last = field
+
+ # TODO: optionally check for duplicate parents
+
+ def sign(self, keyid: Optional[str] = None):
+ import gpg
+
+ with gpg.Context(armor=True) as c:
+ if keyid is not None:
+ key = c.get_key(keyid)
+ with gpg.Context(armor=True, signers=[key]) as ctx:
+ self.gpgsig, unused_result = ctx.sign(
+ self.as_raw_string(),
+ mode=gpg.constants.sig.mode.DETACH,
+ )
+ else:
+ self.gpgsig, unused_result = c.sign(
+ self.as_raw_string(), mode=gpg.constants.sig.mode.DETACH
+ )
+
+ def verify(self, keyids: Optional[Iterable[str]] = None):
"""Verify GPG signature for this commit (if it is signed).
Args:
@@ -702,55 +1523,150 @@ class Commit(ShaFile):
gpg.errors.MissingSignatures: if commit was not signed by a key
specified in keyids
"""
- pass
- tree = serializable_property('tree',
- 'Tree that is the state of this commit')
+ if self._gpgsig is None:
+ return
+
+ import gpg
+
+ with gpg.Context() as ctx:
+ self_without_gpgsig = self.copy()
+ self_without_gpgsig._gpgsig = None
+ self_without_gpgsig.gpgsig = None
+ data, result = ctx.verify(
+ self_without_gpgsig.as_raw_string(),
+ signature=self._gpgsig,
+ )
+ if keyids:
+ keys = [ctx.get_key(key) for key in keyids]
+ for key in keys:
+ for subkey in keys:
+ for sig in result.signatures:
+ if subkey.can_sign and subkey.fpr == sig.fpr:
+ return
+ raise gpg.errors.MissingSignatures(result, keys, results=(data, result))
+
+ def _serialize(self):
+ headers = []
+ tree_bytes = self._tree.id if isinstance(self._tree, Tree) else self._tree
+ headers.append((_TREE_HEADER, tree_bytes))
+ for p in self._parents:
+ headers.append((_PARENT_HEADER, p))
+ headers.append(
+ (
+ _AUTHOR_HEADER,
+ format_time_entry(
+ self._author,
+ self._author_time,
+ (self._author_timezone, self._author_timezone_neg_utc),
+ ),
+ )
+ )
+ headers.append(
+ (
+ _COMMITTER_HEADER,
+ format_time_entry(
+ self._committer,
+ self._commit_time,
+ (self._commit_timezone, self._commit_timezone_neg_utc),
+ ),
+ )
+ )
+ if self.encoding:
+ headers.append((_ENCODING_HEADER, self.encoding))
+ for mergetag in self.mergetag:
+ headers.append((_MERGETAG_HEADER, mergetag.as_raw_string()[:-1]))
+ headers.extend(self._extra)
+ if self.gpgsig:
+ headers.append((_GPGSIG_HEADER, self.gpgsig))
+ return list(_format_message(headers, self._message))
+
+ tree = serializable_property("tree", "Tree that is the state of this commit")
def _get_parents(self):
"""Return a list of parents of this commit."""
- pass
+ return self._parents
def _set_parents(self, value):
"""Set a list of parents of this commit."""
- pass
- parents = property(_get_parents, _set_parents, doc=
- 'Parents of this commit, by their SHA1.')
+ self._needs_serialization = True
+ self._parents = value
+
+ parents = property(
+ _get_parents,
+ _set_parents,
+ doc="Parents of this commit, by their SHA1.",
+ )
def _get_extra(self):
"""Return extra settings of this commit."""
- pass
- extra = property(_get_extra, doc=
- 'Extra header fields not understood (presumably added in a newer version of git). Kept verbatim so the object can be correctly reserialized. For private commit metadata, use pseudo-headers in Commit.message, rather than this field.'
- )
- author = serializable_property('author',
- 'The name of the author of the commit')
- committer = serializable_property('committer',
- 'The name of the committer of the commit')
- message = serializable_property('message', 'The commit message')
- commit_time = serializable_property('commit_time',
- 'The timestamp of the commit. As the number of seconds since the epoch.'
+ warnings.warn(
+ "Commit.extra is deprecated. Use Commit._extra instead.",
+ DeprecationWarning,
+ stacklevel=2,
)
- commit_timezone = serializable_property('commit_timezone',
- 'The zone the commit time is in')
- author_time = serializable_property('author_time',
- 'The timestamp the commit was written. As the number of seconds since the epoch.'
- )
- author_timezone = serializable_property('author_timezone',
- 'Returns the zone the author time is in.')
- encoding = serializable_property('encoding',
- 'Encoding of the commit message.')
- mergetag = serializable_property('mergetag', 'Associated signed tag.')
- gpgsig = serializable_property('gpgsig', 'GPG Signature.')
+ return self._extra
+
+ extra = property(
+ _get_extra,
+ doc="Extra header fields not understood (presumably added in a "
+ "newer version of git). Kept verbatim so the object can "
+ "be correctly reserialized. For private commit metadata, use "
+ "pseudo-headers in Commit.message, rather than this field.",
+ )
+
+ author = serializable_property("author", "The name of the author of the commit")
+
+ committer = serializable_property(
+ "committer", "The name of the committer of the commit"
+ )
+
+ message = serializable_property("message", "The commit message")
+
+ commit_time = serializable_property(
+ "commit_time",
+ "The timestamp of the commit. As the number of seconds since the " "epoch.",
+ )
+
+ commit_timezone = serializable_property(
+ "commit_timezone", "The zone the commit time is in"
+ )
+
+ author_time = serializable_property(
+ "author_time",
+ "The timestamp the commit was written. As the number of "
+ "seconds since the epoch.",
+ )
+ author_timezone = serializable_property(
+ "author_timezone", "Returns the zone the author time is in."
+ )
+
+ encoding = serializable_property("encoding", "Encoding of the commit message.")
+
+ mergetag = serializable_property("mergetag", "Associated signed tag.")
+
+ gpgsig = serializable_property("gpgsig", "GPG Signature.")
+
+
+OBJECT_CLASSES = (
+ Commit,
+ Tree,
+ Blob,
+ Tag,
+)
-OBJECT_CLASSES = Commit, Tree, Blob, Tag
_TYPE_MAP: Dict[Union[bytes, int], Type[ShaFile]] = {}
+
for cls in OBJECT_CLASSES:
_TYPE_MAP[cls.type_name] = cls
_TYPE_MAP[cls.type_num] = cls
+
+
+# Hold on to the pure-python implementations for testing
_parse_tree_py = parse_tree
_sorted_tree_items_py = sorted_tree_items
try:
- from dulwich._objects import parse_tree, sorted_tree_items
+ # Try to import Rust versions
+ from dulwich._objects import parse_tree, sorted_tree_items # type: ignore
except ImportError:
pass
diff --git a/dulwich/objectspec.py b/dulwich/objectspec.py
index ad4be807..edaa5a43 100644
--- a/dulwich/objectspec.py
+++ b/dulwich/objectspec.py
@@ -1,12 +1,40 @@
+# objectspec.py -- Object specification
+# Copyright (C) 2014 Jelmer Vernooij <jelmer@jelmer.uk>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Object specification."""
+
from typing import TYPE_CHECKING, Iterator, List, Optional, Tuple, Union
+
if TYPE_CHECKING:
from .objects import Commit, ShaFile, Tree
from .refs import Ref, RefsContainer
from .repo import Repo
-def parse_object(repo: 'Repo', objectish: Union[bytes, str]) ->'ShaFile':
+def to_bytes(text: Union[str, bytes]) -> bytes:
+ if getattr(text, "encode", None) is not None:
+ text = text.encode("ascii") # type: ignore
+ return text # type: ignore
+
+
+def parse_object(repo: "Repo", objectish: Union[bytes, str]) -> "ShaFile":
"""Parse a string referring to an object.
Args:
@@ -16,10 +44,11 @@ def parse_object(repo: 'Repo', objectish: Union[bytes, str]) ->'ShaFile':
Raises:
KeyError: If the object can not be found
"""
- pass
+ objectish = to_bytes(objectish)
+ return repo[objectish]
-def parse_tree(repo: 'Repo', treeish: Union[bytes, str]) ->'Tree':
+def parse_tree(repo: "Repo", treeish: Union[bytes, str]) -> "Tree":
"""Parse a string referring to a tree.
Args:
@@ -29,11 +58,20 @@ def parse_tree(repo: 'Repo', treeish: Union[bytes, str]) ->'Tree':
Raises:
KeyError: If the object can not be found
"""
- pass
+ treeish = to_bytes(treeish)
+ try:
+ treeish = parse_ref(repo, treeish)
+ except KeyError: # treeish is commit sha
+ pass
+ o = repo[treeish]
+ if o.type_name == b"commit":
+ return repo[o.tree]
+ return o
-def parse_ref(container: Union['Repo', 'RefsContainer'], refspec: Union[str,
- bytes]) ->'Ref':
+def parse_ref(
+ container: Union["Repo", "RefsContainer"], refspec: Union[str, bytes]
+) -> "Ref":
"""Parse a string referring to a reference.
Args:
@@ -43,12 +81,27 @@ def parse_ref(container: Union['Repo', 'RefsContainer'], refspec: Union[str,
Raises:
KeyError: If the ref can not be found
"""
- pass
+ refspec = to_bytes(refspec)
+ possible_refs = [
+ refspec,
+ b"refs/" + refspec,
+ b"refs/tags/" + refspec,
+ b"refs/heads/" + refspec,
+ b"refs/remotes/" + refspec,
+ b"refs/remotes/" + refspec + b"/HEAD",
+ ]
+ for ref in possible_refs:
+ if ref in container:
+ return ref
+ raise KeyError(refspec)
-def parse_reftuple(lh_container: Union['Repo', 'RefsContainer'],
- rh_container: Union['Repo', 'RefsContainer'], refspec: Union[str, bytes
- ], force: bool=False) ->Tuple[Optional['Ref'], Optional['Ref'], bool]:
+def parse_reftuple(
+ lh_container: Union["Repo", "RefsContainer"],
+ rh_container: Union["Repo", "RefsContainer"],
+ refspec: Union[str, bytes],
+ force: bool = False,
+) -> Tuple[Optional["Ref"], Optional["Ref"], bool]:
"""Parse a reftuple spec.
Args:
@@ -59,12 +112,38 @@ def parse_reftuple(lh_container: Union['Repo', 'RefsContainer'],
Raises:
KeyError: If one of the refs can not be found
"""
- pass
+ refspec = to_bytes(refspec)
+ if refspec.startswith(b"+"):
+ force = True
+ refspec = refspec[1:]
+ lh: Optional[bytes]
+ rh: Optional[bytes]
+ if b":" in refspec:
+ (lh, rh) = refspec.split(b":")
+ else:
+ lh = rh = refspec
+ if lh == b"":
+ lh = None
+ else:
+ lh = parse_ref(lh_container, lh)
+ if rh == b"":
+ rh = None
+ else:
+ try:
+ rh = parse_ref(rh_container, rh)
+ except KeyError:
+ # TODO: check force?
+ if b"/" not in rh:
+ rh = b"refs/heads/" + rh
+ return (lh, rh, force)
-def parse_reftuples(lh_container: Union['Repo', 'RefsContainer'],
- rh_container: Union['Repo', 'RefsContainer'], refspecs: Union[bytes,
- List[bytes]], force: bool=False):
+def parse_reftuples(
+ lh_container: Union["Repo", "RefsContainer"],
+ rh_container: Union["Repo", "RefsContainer"],
+ refspecs: Union[bytes, List[bytes]],
+ force: bool = False,
+):
"""Parse a list of reftuple specs to a list of reftuples.
Args:
@@ -76,7 +155,13 @@ def parse_reftuples(lh_container: Union['Repo', 'RefsContainer'],
Raises:
KeyError: If one of the refs can not be found
"""
- pass
+ if not isinstance(refspecs, list):
+ refspecs = [refspecs]
+ ret = []
+ # TODO: Support * in refspecs
+ for refspec in refspecs:
+ ret.append(parse_reftuple(lh_container, rh_container, refspec, force=force))
+ return ret
def parse_refs(container, refspecs):
@@ -89,11 +174,18 @@ def parse_refs(container, refspecs):
Raises:
KeyError: If one of the refs can not be found
"""
- pass
+ # TODO: Support * in refspecs
+ if not isinstance(refspecs, list):
+ refspecs = [refspecs]
+ ret = []
+ for refspec in refspecs:
+ ret.append(parse_ref(container, refspec))
+ return ret
-def parse_commit_range(repo: 'Repo', committishs: Union[str, bytes]
- ) ->Iterator['Commit']:
+def parse_commit_range(
+ repo: "Repo", committishs: Union[str, bytes]
+) -> Iterator["Commit"]:
"""Parse a string referring to a range of commits.
Args:
@@ -104,23 +196,35 @@ def parse_commit_range(repo: 'Repo', committishs: Union[str, bytes]
KeyError: When the reference commits can not be found
ValueError: If the range can not be parsed
"""
- pass
+ committishs = to_bytes(committishs)
+ # TODO(jelmer): Support more than a single commit..
+ return iter([parse_commit(repo, committishs)])
class AmbiguousShortId(Exception):
"""The short id is ambiguous."""
- def __init__(self, prefix, options) ->None:
+ def __init__(self, prefix, options) -> None:
self.prefix = prefix
self.options = options
def scan_for_short_id(object_store, prefix):
"""Scan an object store for a short id."""
- pass
+ # TODO(jelmer): This could short-circuit looking for objects
+ # starting with a certain prefix.
+ ret = []
+ for object_id in object_store:
+ if object_id.startswith(prefix):
+ ret.append(object_store[object_id])
+ if not ret:
+ raise KeyError(prefix)
+ if len(ret) == 1:
+ return ret[0]
+ raise AmbiguousShortId(prefix, ret)
-def parse_commit(repo: 'Repo', committish: Union[str, bytes]) ->'Commit':
+def parse_commit(repo: "Repo", committish: Union[str, bytes]) -> "Commit":
"""Parse a string referring to a single commit.
Args:
@@ -131,4 +235,26 @@ def parse_commit(repo: 'Repo', committish: Union[str, bytes]) ->'Commit':
KeyError: When the reference commits can not be found
ValueError: If the range can not be parsed
"""
- pass
+ committish = to_bytes(committish)
+ try:
+ return repo[committish]
+ except KeyError:
+ pass
+ try:
+ return repo[parse_ref(repo, committish)]
+ except KeyError:
+ pass
+ if len(committish) >= 4 and len(committish) < 40:
+ try:
+ int(committish, 16)
+ except ValueError:
+ pass
+ else:
+ try:
+ return scan_for_short_id(repo.object_store, committish)
+ except KeyError:
+ pass
+ raise KeyError(committish)
+
+
+# TODO: parse_path_in_tree(), which handles e.g. v1.0:Documentation
diff --git a/dulwich/pack.py b/dulwich/pack.py
index 453c10c4..988f7a9d 100644
--- a/dulwich/pack.py
+++ b/dulwich/pack.py
@@ -1,3 +1,24 @@
+# pack.py -- For dealing with packed git objects.
+# Copyright (C) 2007 James Westby <jw+debian@jameswestby.net>
+# Copyright (C) 2008-2013 Jelmer Vernooij <jelmer@jelmer.uk>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Classes for dealing with packed git objects.
A pack is a compact representation of a bunch of objects, stored
@@ -10,14 +31,17 @@ To find an object you look in all of the index files 'til you find a
match for the object name. You then use the pointer got from this as
a pointer in to the corresponding packfile.
"""
+
import binascii
from collections import defaultdict, deque
from contextlib import suppress
from io import BytesIO, UnsupportedOperation
+
try:
from cdifflib import CSequenceMatcher as SequenceMatcher
except ModuleNotFoundError:
from difflib import SequenceMatcher
+
import os
import struct
import sys
@@ -27,24 +51,52 @@ from hashlib import sha1
from itertools import chain
from os import SEEK_CUR, SEEK_END
from struct import unpack_from
-from typing import BinaryIO, Callable, Deque, Dict, Generic, Iterable, Iterator, List, Optional, Protocol, Sequence, Set, Tuple, TypeVar, Union
+from typing import (
+ BinaryIO,
+ Callable,
+ Deque,
+ Dict,
+ Generic,
+ Iterable,
+ Iterator,
+ List,
+ Optional,
+ Protocol,
+ Sequence,
+ Set,
+ Tuple,
+ TypeVar,
+ Union,
+)
+
try:
import mmap
except ImportError:
has_mmap = False
else:
has_mmap = True
-if sys.platform == 'Plan9':
+
+# For some reason the above try, except fails to set has_mmap = False for plan9
+if sys.platform == "Plan9":
has_mmap = False
+
from .errors import ApplyDeltaError, ChecksumMismatch
from .file import GitFile
from .lru_cache import LRUSizeCache
from .objects import ObjectID, ShaFile, hex_to_sha, object_header, sha_to_hex
+
OFS_DELTA = 6
REF_DELTA = 7
-DELTA_TYPES = OFS_DELTA, REF_DELTA
+
+DELTA_TYPES = (OFS_DELTA, REF_DELTA)
+
+
DEFAULT_PACK_DELTA_WINDOW_SIZE = 10
+
+# Keep pack files under 16Mb in memory, otherwise write them out to disk
PACK_SPOOL_FILE_MAX_SIZE = 16 * 1024 * 1024
+
+
OldUnpackedObject = Union[Tuple[Union[bytes, int], List[bytes]], List[bytes]]
ResolveExtRefFn = Callable[[bytes], Tuple[int, OldUnpackedObject]]
ProgressFn = Callable[[int, str], None]
@@ -59,57 +111,76 @@ class UnresolvedDeltas(Exception):
class ObjectContainer(Protocol):
-
- def add_object(self, obj: ShaFile) ->None:
+ def add_object(self, obj: ShaFile) -> None:
"""Add a single object to this object store."""
- pass
- def add_objects(self, objects: Sequence[Tuple[ShaFile, Optional[str]]],
- progress: Optional[Callable[[str], None]]=None) ->None:
+ def add_objects(
+ self,
+ objects: Sequence[Tuple[ShaFile, Optional[str]]],
+ progress: Optional[Callable[[str], None]] = None,
+ ) -> None:
"""Add a set of objects to this object store.
Args:
objects: Iterable over a list of (object, path) tuples
"""
- pass
- def __contains__(self, sha1: bytes) ->bool:
+ def __contains__(self, sha1: bytes) -> bool:
"""Check if a hex sha is present."""
- def __getitem__(self, sha1: bytes) ->ShaFile:
+ def __getitem__(self, sha1: bytes) -> ShaFile:
"""Retrieve an object."""
class PackedObjectContainer(ObjectContainer):
-
- def get_unpacked_object(self, sha1: bytes, *, include_comp: bool=False
- ) ->'UnpackedObject':
+ def get_unpacked_object(
+ self, sha1: bytes, *, include_comp: bool = False
+ ) -> "UnpackedObject":
"""Get a raw unresolved object."""
- pass
+ raise NotImplementedError(self.get_unpacked_object)
+ def iterobjects_subset(
+ self, shas: Iterable[bytes], *, allow_missing: bool = False
+ ) -> Iterator[ShaFile]:
+ raise NotImplementedError(self.iterobjects_subset)
+
+ def iter_unpacked_subset(
+ self,
+ shas: Set[bytes],
+ include_comp: bool = False,
+ allow_missing: bool = False,
+ convert_ofs_delta: bool = True,
+ ) -> Iterator["UnpackedObject"]:
+ raise NotImplementedError(self.iter_unpacked_subset)
-class UnpackedObjectStream:
- def __iter__(self) ->Iterator['UnpackedObject']:
+class UnpackedObjectStream:
+ def __iter__(self) -> Iterator["UnpackedObject"]:
raise NotImplementedError(self.__iter__)
- def __len__(self) ->int:
+ def __len__(self) -> int:
raise NotImplementedError(self.__len__)
-def take_msb_bytes(read: Callable[[int], bytes], crc32: Optional[int]=None
- ) ->Tuple[List[int], Optional[int]]:
+def take_msb_bytes(
+ read: Callable[[int], bytes], crc32: Optional[int] = None
+) -> Tuple[List[int], Optional[int]]:
"""Read bytes marked with most significant bit.
Args:
read: Read function
"""
- pass
+ ret: List[int] = []
+ while len(ret) == 0 or ret[-1] & 0x80:
+ b = read(1)
+ if crc32 is not None:
+ crc32 = binascii.crc32(b, crc32)
+ ret.append(ord(b[:1]))
+ return ret, crc32
class PackFileDisappeared(Exception):
-
- def __init__(self, obj) ->None:
+ def __init__(self, obj) -> None:
self.obj = obj
@@ -123,17 +194,39 @@ class UnpackedObject:
End users of this object should take care that the function they're getting
this object from is guaranteed to set the members they need.
"""
- __slots__ = ['offset', '_sha', 'obj_type_num', 'obj_chunks',
- 'pack_type_num', 'delta_base', 'comp_chunks', 'decomp_chunks',
- 'decomp_len', 'crc32']
+
+ __slots__ = [
+ "offset", # Offset in its pack.
+ "_sha", # Cached binary SHA.
+ "obj_type_num", # Type of this object.
+ "obj_chunks", # Decompressed and delta-resolved chunks.
+ "pack_type_num", # Type of this object in the pack (may be a delta).
+ "delta_base", # Delta base offset or SHA.
+ "comp_chunks", # Compressed object chunks.
+ "decomp_chunks", # Decompressed object chunks.
+ "decomp_len", # Decompressed length of this object.
+ "crc32", # CRC32.
+ ]
+
obj_type_num: Optional[int]
obj_chunks: Optional[List[bytes]]
delta_base: Union[None, bytes, int]
decomp_chunks: List[bytes]
comp_chunks: Optional[List[bytes]]
- def __init__(self, pack_type_num, *, delta_base=None, decomp_len=None,
- crc32=None, sha=None, decomp_chunks=None, offset=None) ->None:
+ # TODO(dborowitz): read_zlib_chunks and unpack_object could very well be
+ # methods of this object.
+ def __init__(
+ self,
+ pack_type_num,
+ *,
+ delta_base=None,
+ decomp_len=None,
+ crc32=None,
+ sha=None,
+ decomp_chunks=None,
+ offset=None,
+ ) -> None:
self.offset = offset
self._sha = sha
self.pack_type_num = pack_type_num
@@ -145,6 +238,7 @@ class UnpackedObject:
else:
self.decomp_len = decomp_len
self.crc32 = crc32
+
if pack_type_num in DELTA_TYPES:
self.obj_type_num = None
self.obj_chunks = None
@@ -155,15 +249,24 @@ class UnpackedObject:
def sha(self):
"""Return the binary SHA of this object."""
- pass
+ if self._sha is None:
+ self._sha = obj_sha(self.obj_type_num, self.obj_chunks)
+ return self._sha
def sha_file(self):
"""Return a ShaFile from this object."""
- pass
+ assert self.obj_type_num is not None and self.obj_chunks is not None
+ return ShaFile.from_raw_chunks(self.obj_type_num, self.obj_chunks)
- def _obj(self) ->OldUnpackedObject:
+ # Only provided for backwards compatibility with code that expects either
+ # chunks or a delta tuple.
+ def _obj(self) -> OldUnpackedObject:
"""Return the decompressed chunks, or (delta base, delta chunks)."""
- pass
+ if self.pack_type_num in DELTA_TYPES:
+ assert isinstance(self.delta_base, (bytes, int))
+ return (self.delta_base, self.decomp_chunks)
+ else:
+ return self.decomp_chunks
def __eq__(self, other):
if not isinstance(other, UnpackedObject):
@@ -174,19 +277,22 @@ class UnpackedObject:
return True
def __ne__(self, other):
- return not self == other
+ return not (self == other)
- def __repr__(self) ->str:
- data = [f'{s}={getattr(self, s)!r}' for s in self.__slots__]
- return '{}({})'.format(self.__class__.__name__, ', '.join(data))
+ def __repr__(self) -> str:
+ data = [f"{s}={getattr(self, s)!r}" for s in self.__slots__]
+ return "{}({})".format(self.__class__.__name__, ", ".join(data))
_ZLIB_BUFSIZE = 4096
-def read_zlib_chunks(read_some: Callable[[int], bytes], unpacked:
- UnpackedObject, include_comp: bool=False, buffer_size: int=_ZLIB_BUFSIZE
- ) ->bytes:
+def read_zlib_chunks(
+ read_some: Callable[[int], bytes],
+ unpacked: UnpackedObject,
+ include_comp: bool = False,
+ buffer_size: int = _ZLIB_BUFSIZE,
+) -> bytes:
"""Read zlib data from a buffer.
This function requires that the buffer have additional data following the
@@ -210,7 +316,43 @@ def read_zlib_chunks(read_some: Callable[[int], bytes], unpacked:
Raises:
zlib.error: if a decompression error occurred.
"""
- pass
+ if unpacked.decomp_len <= -1:
+ raise ValueError("non-negative zlib data stream size expected")
+ decomp_obj = zlib.decompressobj()
+
+ comp_chunks = []
+ decomp_chunks = unpacked.decomp_chunks
+ decomp_len = 0
+ crc32 = unpacked.crc32
+
+ while True:
+ add = read_some(buffer_size)
+ if not add:
+ raise zlib.error("EOF before end of zlib stream")
+ comp_chunks.append(add)
+ decomp = decomp_obj.decompress(add)
+ decomp_len += len(decomp)
+ decomp_chunks.append(decomp)
+ unused = decomp_obj.unused_data
+ if unused:
+ left = len(unused)
+ if crc32 is not None:
+ crc32 = binascii.crc32(add[:-left], crc32)
+ if include_comp:
+ comp_chunks[-1] = add[:-left]
+ break
+ elif crc32 is not None:
+ crc32 = binascii.crc32(add, crc32)
+ if crc32 is not None:
+ crc32 &= 0xFFFFFFFF
+
+ if decomp_len != unpacked.decomp_len:
+ raise zlib.error("decompressed data does not match expected size")
+
+ unpacked.crc32 = crc32
+ if include_comp:
+ unpacked.comp_chunks = comp_chunks
+ return unused
def iter_sha1(iter):
@@ -220,7 +362,10 @@ def iter_sha1(iter):
iter: Iterator over string objects
Returns: 40-byte hex sha1 digest
"""
- pass
+ sha = sha1()
+ for name in iter:
+ sha.update(name)
+ return sha.hexdigest().encode("ascii")
def load_pack_index(path):
@@ -230,7 +375,30 @@ def load_pack_index(path):
path: Path to the index file
Returns: A PackIndex loaded from the given path
"""
- pass
+ with GitFile(path, "rb") as f:
+ return load_pack_index_file(path, f)
+
+
+def _load_file_contents(f, size=None):
+ try:
+ fd = f.fileno()
+ except (UnsupportedOperation, AttributeError):
+ fd = None
+ # Attempt to use mmap if possible
+ if fd is not None:
+ if size is None:
+ size = os.fstat(fd).st_size
+ if has_mmap:
+ try:
+ contents = mmap.mmap(fd, size, access=mmap.ACCESS_READ)
+ except OSError:
+ # Perhaps a socket?
+ pass
+ else:
+ return contents, size
+ contents = f.read()
+ size = len(contents)
+ return contents, size
def load_pack_index_file(path, f):
@@ -241,7 +409,15 @@ def load_pack_index_file(path, f):
f: File-like object
Returns: A PackIndex loaded from the given file
"""
- pass
+ contents, size = _load_file_contents(f)
+ if contents[:4] == b"\377tOc":
+ version = struct.unpack(b">L", contents[4:8])[0]
+ if version == 2:
+ return PackIndex2(path, file=f, contents=contents, size=size)
+ else:
+ raise KeyError("Unknown pack index format %d" % version)
+ else:
+ return PackIndex1(path, file=f, contents=contents, size=size)
def bisect_find_sha(start, end, sha, unpack_name):
@@ -254,7 +430,17 @@ def bisect_find_sha(start, end, sha, unpack_name):
unpack_name: Callback to retrieve SHA by index
Returns: Index of the SHA, or None if it wasn't found
"""
- pass
+ assert start <= end
+ while start <= end:
+ i = (start + end) // 2
+ file_sha = unpack_name(i)
+ if file_sha < sha:
+ start = i + 1
+ elif file_sha > sha:
+ end = i - 1
+ else:
+ return i
+ return None
PackIndexEntry = Tuple[bytes, int, Optional[int]]
@@ -270,8 +456,10 @@ class PackIndex:
def __eq__(self, other):
if not isinstance(other, PackIndex):
return False
- for (name1, _, _), (name2, _, _) in zip(self.iterentries(), other.
- iterentries()):
+
+ for (name1, _, _), (name2, _, _) in zip(
+ self.iterentries(), other.iterentries()
+ ):
if name1 != name2:
return False
return True
@@ -279,66 +467,82 @@ class PackIndex:
def __ne__(self, other):
return not self.__eq__(other)
- def __len__(self) ->int:
+ def __len__(self) -> int:
"""Return the number of entries in this pack index."""
raise NotImplementedError(self.__len__)
- def __iter__(self) ->Iterator[bytes]:
+ def __iter__(self) -> Iterator[bytes]:
"""Iterate over the SHAs in this pack."""
return map(sha_to_hex, self._itersha())
- def iterentries(self) ->Iterator[PackIndexEntry]:
+ def iterentries(self) -> Iterator[PackIndexEntry]:
"""Iterate over the entries in this pack index.
Returns: iterator over tuples with object name, offset in packfile and
crc32 checksum.
"""
- pass
+ raise NotImplementedError(self.iterentries)
- def get_pack_checksum(self) ->bytes:
+ def get_pack_checksum(self) -> bytes:
"""Return the SHA1 checksum stored for the corresponding packfile.
Returns: 20-byte binary digest
"""
- pass
+ raise NotImplementedError(self.get_pack_checksum)
+
+ def object_index(self, sha: bytes) -> int:
+ warnings.warn(
+ "Please use object_offset instead", DeprecationWarning, stacklevel=2
+ )
+ return self.object_offset(sha)
- def object_offset(self, sha: bytes) ->int:
+ def object_offset(self, sha: bytes) -> int:
"""Return the offset in to the corresponding packfile for the object.
Given the name of an object it will return the offset that object
lives at within the corresponding pack file. If the pack file doesn't
have the object then None will be returned.
"""
- pass
+ raise NotImplementedError(self.object_offset)
- def object_sha1(self, index: int) ->bytes:
+ def object_sha1(self, index: int) -> bytes:
"""Return the SHA1 corresponding to the index in the pack file."""
- pass
+ for name, offset, crc32 in self.iterentries():
+ if offset == index:
+ return name
+ else:
+ raise KeyError(index)
- def _object_offset(self, sha: bytes) ->int:
+ def _object_offset(self, sha: bytes) -> int:
"""See object_offset.
Args:
sha: A *binary* SHA string. (20 characters long)_
"""
- pass
+ raise NotImplementedError(self._object_offset)
- def objects_sha1(self) ->bytes:
+ def objects_sha1(self) -> bytes:
"""Return the hex SHA1 over all the shas of all objects in this pack.
Note: This is used for the filename of the pack.
"""
- pass
+ return iter_sha1(self._itersha())
- def _itersha(self) ->Iterator[bytes]:
+ def _itersha(self) -> Iterator[bytes]:
"""Yield all the SHA1's of the objects in the index, sorted."""
+ raise NotImplementedError(self._itersha)
+
+ def close(self):
+ pass
+
+ def check(self) -> None:
pass
class MemoryPackIndex(PackIndex):
"""Pack index that is stored entirely in memory."""
- def __init__(self, entries, pack_checksum=None) ->None:
+ def __init__(self, entries, pack_checksum=None) -> None:
"""Create a new MemoryPackIndex.
Args:
@@ -353,9 +557,34 @@ class MemoryPackIndex(PackIndex):
self._entries = entries
self._pack_checksum = pack_checksum
- def __len__(self) ->int:
+ def get_pack_checksum(self):
+ return self._pack_checksum
+
+ def __len__(self) -> int:
return len(self._entries)
+ def object_offset(self, sha):
+ if len(sha) == 40:
+ sha = hex_to_sha(sha)
+ return self._by_sha[sha]
+
+ def object_sha1(self, offset):
+ return self._by_offset[offset]
+
+ def _itersha(self):
+ return iter(self._by_sha)
+
+ def iterentries(self):
+ return iter(self._entries)
+
+ @classmethod
+ def for_pack(cls, pack):
+ return MemoryPackIndex(pack.sorted_entries(), pack.calculate_checksum())
+
+ @classmethod
+ def clone(cls, other_index):
+ return cls(other_index.iterentries(), other_index.get_pack_checksum())
+
class FilePackIndex(PackIndex):
"""Pack index that is based on a file.
@@ -368,136 +597,223 @@ class FilePackIndex(PackIndex):
the start and end offset and then bisect in to find if the value is
present.
"""
+
_fan_out_table: List[int]
- def __init__(self, filename, file=None, contents=None, size=None) ->None:
+ def __init__(self, filename, file=None, contents=None, size=None) -> None:
"""Create a pack index object.
Provide it with the name of the index file to consider, and it will map
it whenever required.
"""
self._filename = filename
+ # Take the size now, so it can be checked each time we map the file to
+ # ensure that it hasn't changed.
if file is None:
- self._file = GitFile(filename, 'rb')
+ self._file = GitFile(filename, "rb")
else:
self._file = file
if contents is None:
self._contents, self._size = _load_file_contents(self._file, size)
else:
- self._contents, self._size = contents, size
+ self._contents, self._size = (contents, size)
+
+ @property
+ def path(self) -> str:
+ return self._filename
def __eq__(self, other):
- if isinstance(other, FilePackIndex
- ) and self._fan_out_table != other._fan_out_table:
+ # Quick optimization:
+ if (
+ isinstance(other, FilePackIndex)
+ and self._fan_out_table != other._fan_out_table
+ ):
return False
+
return super().__eq__(other)
- def __len__(self) ->int:
+ def close(self) -> None:
+ self._file.close()
+ if getattr(self._contents, "close", None) is not None:
+ self._contents.close()
+
+ def __len__(self) -> int:
"""Return the number of entries in this pack index."""
return self._fan_out_table[-1]
- def _unpack_entry(self, i: int) ->PackIndexEntry:
+ def _unpack_entry(self, i: int) -> PackIndexEntry:
"""Unpack the i-th entry in the index file.
Returns: Tuple with object name (SHA), offset in pack file and CRC32
checksum (if known).
"""
- pass
+ raise NotImplementedError(self._unpack_entry)
def _unpack_name(self, i):
"""Unpack the i-th name from the index file."""
- pass
+ raise NotImplementedError(self._unpack_name)
def _unpack_offset(self, i):
"""Unpack the i-th object offset from the index file."""
- pass
+ raise NotImplementedError(self._unpack_offset)
def _unpack_crc32_checksum(self, i):
"""Unpack the crc32 checksum for the ith object from the index file."""
- pass
+ raise NotImplementedError(self._unpack_crc32_checksum)
+
+ def _itersha(self) -> Iterator[bytes]:
+ for i in range(len(self)):
+ yield self._unpack_name(i)
- def iterentries(self) ->Iterator[PackIndexEntry]:
+ def iterentries(self) -> Iterator[PackIndexEntry]:
"""Iterate over the entries in this pack index.
Returns: iterator over tuples with object name, offset in packfile and
crc32 checksum.
"""
- pass
-
- def check(self) ->None:
+ for i in range(len(self)):
+ yield self._unpack_entry(i)
+
+ def _read_fan_out_table(self, start_offset: int):
+ ret = []
+ for i in range(0x100):
+ fanout_entry = self._contents[
+ start_offset + i * 4 : start_offset + (i + 1) * 4
+ ]
+ ret.append(struct.unpack(">L", fanout_entry)[0])
+ return ret
+
+ def check(self) -> None:
"""Check that the stored checksum matches the actual checksum."""
- pass
+ actual = self.calculate_checksum()
+ stored = self.get_stored_checksum()
+ if actual != stored:
+ raise ChecksumMismatch(stored, actual)
- def calculate_checksum(self) ->bytes:
+ def calculate_checksum(self) -> bytes:
"""Calculate the SHA1 checksum over this pack index.
Returns: This is a 20-byte binary digest
"""
- pass
+ return sha1(self._contents[:-20]).digest()
- def get_pack_checksum(self) ->bytes:
+ def get_pack_checksum(self) -> bytes:
"""Return the SHA1 checksum stored for the corresponding packfile.
Returns: 20-byte binary digest
"""
- pass
+ return bytes(self._contents[-40:-20])
- def get_stored_checksum(self) ->bytes:
+ def get_stored_checksum(self) -> bytes:
"""Return the SHA1 checksum stored for this index.
Returns: 20-byte binary digest
"""
- pass
+ return bytes(self._contents[-20:])
- def object_offset(self, sha: bytes) ->int:
+ def object_offset(self, sha: bytes) -> int:
"""Return the offset in to the corresponding packfile for the object.
Given the name of an object it will return the offset that object
lives at within the corresponding pack file. If the pack file doesn't
have the object then None will be returned.
"""
- pass
-
- def _object_offset(self, sha: bytes) ->int:
+ if len(sha) == 40:
+ sha = hex_to_sha(sha)
+ try:
+ return self._object_offset(sha)
+ except ValueError as exc:
+ closed = getattr(self._contents, "closed", None)
+ if closed in (None, True):
+ raise PackFileDisappeared(self) from exc
+ raise
+
+ def _object_offset(self, sha: bytes) -> int:
"""See object_offset.
Args:
sha: A *binary* SHA string. (20 characters long)_
"""
- pass
+ assert len(sha) == 20
+ idx = ord(sha[:1])
+ if idx == 0:
+ start = 0
+ else:
+ start = self._fan_out_table[idx - 1]
+ end = self._fan_out_table[idx]
+ i = bisect_find_sha(start, end, sha, self._unpack_name)
+ if i is None:
+ raise KeyError(sha)
+ return self._unpack_offset(i)
class PackIndex1(FilePackIndex):
"""Version 1 Pack Index file."""
- def __init__(self, filename: str, file=None, contents=None, size=None
- ) ->None:
+ def __init__(self, filename: str, file=None, contents=None, size=None) -> None:
super().__init__(filename, file, contents, size)
self.version = 1
self._fan_out_table = self._read_fan_out_table(0)
+ def _unpack_entry(self, i):
+ (offset, name) = unpack_from(">L20s", self._contents, (0x100 * 4) + (i * 24))
+ return (name, offset, None)
+
+ def _unpack_name(self, i):
+ offset = (0x100 * 4) + (i * 24) + 4
+ return self._contents[offset : offset + 20]
+
+ def _unpack_offset(self, i):
+ offset = (0x100 * 4) + (i * 24)
+ return unpack_from(">L", self._contents, offset)[0]
+
+ def _unpack_crc32_checksum(self, i):
+ # Not stored in v1 index files
+ return None
+
class PackIndex2(FilePackIndex):
"""Version 2 Pack Index file."""
- def __init__(self, filename: str, file=None, contents=None, size=None
- ) ->None:
+ def __init__(self, filename: str, file=None, contents=None, size=None) -> None:
super().__init__(filename, file, contents, size)
- if self._contents[:4] != b'\xfftOc':
- raise AssertionError('Not a v2 pack index file')
- self.version, = unpack_from(b'>L', self._contents, 4)
+ if self._contents[:4] != b"\377tOc":
+ raise AssertionError("Not a v2 pack index file")
+ (self.version,) = unpack_from(b">L", self._contents, 4)
if self.version != 2:
- raise AssertionError('Version was %d' % self.version)
+ raise AssertionError("Version was %d" % self.version)
self._fan_out_table = self._read_fan_out_table(8)
- self._name_table_offset = 8 + 256 * 4
+ self._name_table_offset = 8 + 0x100 * 4
self._crc32_table_offset = self._name_table_offset + 20 * len(self)
- self._pack_offset_table_offset = self._crc32_table_offset + 4 * len(
- self)
- self._pack_offset_largetable_offset = (self.
- _pack_offset_table_offset + 4 * len(self))
+ self._pack_offset_table_offset = self._crc32_table_offset + 4 * len(self)
+ self._pack_offset_largetable_offset = self._pack_offset_table_offset + 4 * len(
+ self
+ )
+
+ def _unpack_entry(self, i):
+ return (
+ self._unpack_name(i),
+ self._unpack_offset(i),
+ self._unpack_crc32_checksum(i),
+ )
+
+ def _unpack_name(self, i):
+ offset = self._name_table_offset + i * 20
+ return self._contents[offset : offset + 20]
+
+ def _unpack_offset(self, i):
+ offset = self._pack_offset_table_offset + i * 4
+ offset = unpack_from(">L", self._contents, offset)[0]
+ if offset & (2**31):
+ offset = self._pack_offset_largetable_offset + (offset & (2**31 - 1)) * 8
+ offset = unpack_from(">Q", self._contents, offset)[0]
+ return offset
+
+ def _unpack_crc32_checksum(self, i):
+ return unpack_from(">L", self._contents, self._crc32_table_offset + i * 4)[0]
-def read_pack_header(read) ->Tuple[int, int]:
+def read_pack_header(read) -> Tuple[int, int]:
"""Read the header of a pack file.
Args:
@@ -505,12 +821,32 @@ def read_pack_header(read) ->Tuple[int, int]:
Returns: Tuple of (pack version, number of objects). If no data is
available to read, returns (None, None).
"""
- pass
-
-
-def unpack_object(read_all: Callable[[int], bytes], read_some: Optional[
- Callable[[int], bytes]]=None, compute_crc32=False, include_comp=False,
- zlib_bufsize=_ZLIB_BUFSIZE) ->Tuple[UnpackedObject, bytes]:
+ header = read(12)
+ if not header:
+ raise AssertionError("file too short to contain pack")
+ if header[:4] != b"PACK":
+ raise AssertionError(f"Invalid pack header {header!r}")
+ (version,) = unpack_from(b">L", header, 4)
+ if version not in (2, 3):
+ raise AssertionError("Version was %d" % version)
+ (num_objects,) = unpack_from(b">L", header, 8)
+ return (version, num_objects)
+
+
+def chunks_length(chunks: Union[bytes, Iterable[bytes]]) -> int:
+ if isinstance(chunks, bytes):
+ return len(chunks)
+ else:
+ return sum(map(len, chunks))
+
+
+def unpack_object(
+ read_all: Callable[[int], bytes],
+ read_some: Optional[Callable[[int], bytes]] = None,
+ compute_crc32=False,
+ include_comp=False,
+ zlib_bufsize=_ZLIB_BUFSIZE,
+) -> Tuple[UnpackedObject, bytes]:
"""Unpack a Git object.
Args:
@@ -534,12 +870,59 @@ def unpack_object(read_all: Callable[[int], bytes], read_some: Optional[
* decomp_len
* crc32 (if compute_crc32 is True)
"""
- pass
+ if read_some is None:
+ read_some = read_all
+ if compute_crc32:
+ crc32 = 0
+ else:
+ crc32 = None
+
+ raw, crc32 = take_msb_bytes(read_all, crc32=crc32)
+ type_num = (raw[0] >> 4) & 0x07
+ size = raw[0] & 0x0F
+ for i, byte in enumerate(raw[1:]):
+ size += (byte & 0x7F) << ((i * 7) + 4)
+
+ delta_base: Union[int, bytes, None]
+ raw_base = len(raw)
+ if type_num == OFS_DELTA:
+ raw, crc32 = take_msb_bytes(read_all, crc32=crc32)
+ raw_base += len(raw)
+ if raw[-1] & 0x80:
+ raise AssertionError
+ delta_base_offset = raw[0] & 0x7F
+ for byte in raw[1:]:
+ delta_base_offset += 1
+ delta_base_offset <<= 7
+ delta_base_offset += byte & 0x7F
+ delta_base = delta_base_offset
+ elif type_num == REF_DELTA:
+ delta_base_obj = read_all(20)
+ if crc32 is not None:
+ crc32 = binascii.crc32(delta_base_obj, crc32)
+ delta_base = delta_base_obj
+ raw_base += 20
+ else:
+ delta_base = None
+
+ unpacked = UnpackedObject(
+ type_num, delta_base=delta_base, decomp_len=size, crc32=crc32
+ )
+ unused = read_zlib_chunks(
+ read_some,
+ unpacked,
+ buffer_size=zlib_bufsize,
+ include_comp=include_comp,
+ )
+ return unpacked, unused
def _compute_object_size(value):
"""Compute the size of a unresolved object for use with LRUSizeCache."""
- pass
+ (num, obj) = value
+ if num in DELTA_TYPES:
+ return chunks_length(obj[1])
+ return chunks_length(obj)
class PackStreamReader:
@@ -549,8 +932,7 @@ class PackStreamReader:
appropriate.
"""
- def __init__(self, read_all, read_some=None, zlib_bufsize=_ZLIB_BUFSIZE
- ) ->None:
+ def __init__(self, read_all, read_some=None, zlib_bufsize=_ZLIB_BUFSIZE) -> None:
self.read_all = read_all
if read_some is None:
self.read_some = read_all
@@ -559,6 +941,7 @@ class PackStreamReader:
self.sha = sha1()
self._offset = 0
self._rbuf = BytesIO()
+ # trailer is a deque to avoid memory allocation on small reads
self._trailer: Deque[bytes] = deque()
self._zlib_bufsize = zlib_bufsize
@@ -573,20 +956,62 @@ class PackStreamReader:
size: The maximum number of bytes to read; the particular
behavior is callback-specific.
"""
- pass
+ data = read(size)
+
+ # maintain a trailer of the last 20 bytes we've read
+ n = len(data)
+ self._offset += n
+ tn = len(self._trailer)
+ if n >= 20:
+ to_pop = tn
+ to_add = 20
+ else:
+ to_pop = max(n + tn - 20, 0)
+ to_add = n
+ self.sha.update(
+ bytes(bytearray([self._trailer.popleft() for _ in range(to_pop)]))
+ )
+ self._trailer.extend(data[-to_add:])
+
+ # hash everything but the trailer
+ self.sha.update(data[:-to_add])
+ return data
+
+ def _buf_len(self):
+ buf = self._rbuf
+ start = buf.tell()
+ buf.seek(0, SEEK_END)
+ end = buf.tell()
+ buf.seek(start)
+ return end - start
+
+ @property
+ def offset(self):
+ return self._offset - self._buf_len()
def read(self, size):
"""Read, blocking until size bytes are read."""
- pass
+ buf_len = self._buf_len()
+ if buf_len >= size:
+ return self._rbuf.read(size)
+ buf_data = self._rbuf.read()
+ self._rbuf = BytesIO()
+ return buf_data + self._read(self.read_all, size - buf_len)
def recv(self, size):
"""Read up to size bytes, blocking until one byte is read."""
- pass
-
- def __len__(self) ->int:
+ buf_len = self._buf_len()
+ if buf_len:
+ data = self._rbuf.read(size)
+ if size >= buf_len:
+ self._rbuf = BytesIO()
+ return data
+ return self._read(self.read_some, size)
+
+ def __len__(self) -> int:
return self._num_objects
- def read_objects(self, compute_crc32=False) ->Iterator[UnpackedObject]:
+ def read_objects(self, compute_crc32=False) -> Iterator[UnpackedObject]:
"""Read the objects in this pack file.
Args:
@@ -607,7 +1032,37 @@ class PackStreamReader:
zlib.error: if an error occurred during zlib decompression.
IOError: if an error occurred writing to the output file.
"""
- pass
+ pack_version, self._num_objects = read_pack_header(self.read)
+
+ for i in range(self._num_objects):
+ offset = self.offset
+ unpacked, unused = unpack_object(
+ self.read,
+ read_some=self.recv,
+ compute_crc32=compute_crc32,
+ zlib_bufsize=self._zlib_bufsize,
+ )
+ unpacked.offset = offset
+
+ # prepend any unused data to current read buffer
+ buf = BytesIO()
+ buf.write(unused)
+ buf.write(self._rbuf.read())
+ buf.seek(0)
+ self._rbuf = buf
+
+ yield unpacked
+
+ if self._buf_len() < 20:
+ # If the read buffer is full, then the last read() got the whole
+ # trailer off the wire. If not, it means there is still some of the
+ # trailer to read. We need to read() all 20 bytes; N come from the
+ # read buffer and (20 - N) come from the wire.
+ self.read(20)
+
+ pack_sha = bytearray(self._trailer) # type: ignore
+ if pack_sha != self.sha.digest():
+ raise ChecksumMismatch(sha_to_hex(pack_sha), self.sha.hexdigest())
class PackStreamCopier(PackStreamReader):
@@ -617,7 +1072,7 @@ class PackStreamCopier(PackStreamReader):
appropriate and written out to the given file-like object.
"""
- def __init__(self, read_all, read_some, outfile, delta_iter=None) ->None:
+ def __init__(self, read_all, read_some, outfile, delta_iter=None) -> None:
"""Initialize the copier.
Args:
@@ -635,7 +1090,9 @@ class PackStreamCopier(PackStreamReader):
def _read(self, read, size):
"""Read data from the read callback and write it to the file."""
- pass
+ data = super()._read(read, size)
+ self.outfile.write(data)
+ return data
def verify(self, progress=None):
"""Verify a pack stream and write it to the output file.
@@ -643,12 +1100,28 @@ class PackStreamCopier(PackStreamReader):
See PackStreamReader.iterobjects for a list of exceptions this may
throw.
"""
- pass
+ i = 0 # default count of entries if read_objects() is empty
+ for i, unpacked in enumerate(self.read_objects()):
+ if self._delta_iter:
+ self._delta_iter.record(unpacked)
+ if progress is not None:
+ progress(
+ ("copying pack entries: %d/%d\r" % (i, len(self))).encode("ascii")
+ )
+ if progress is not None:
+ progress(("copied %d pack entries\n" % i).encode("ascii"))
def obj_sha(type, chunks):
"""Compute the SHA for a numeric type and object chunks."""
- pass
+ sha = sha1()
+ sha.update(object_header(type, chunks_length(chunks)))
+ if isinstance(chunks, bytes):
+ sha.update(chunks)
+ else:
+ for chunk in chunks:
+ sha.update(chunk)
+ return sha.digest()
def compute_file_sha(f, start_ofs=0, end_ofs=0, buffer_size=1 << 16):
@@ -662,7 +1135,21 @@ def compute_file_sha(f, start_ofs=0, end_ofs=0, buffer_size=1 << 16):
buffer_size: A buffer size for reading.
Returns: A new SHA object updated with data read from the file.
"""
- pass
+ sha = sha1()
+ f.seek(0, SEEK_END)
+ length = f.tell()
+ if (end_ofs < 0 and length + end_ofs < start_ofs) or end_ofs > length:
+ raise AssertionError(
+ "Attempt to read beyond file length. "
+ "start_ofs: %d, end_ofs: %d, file length: %d" % (start_ofs, end_ofs, length)
+ )
+ todo = length + end_ofs - start_ofs
+ f.seek(start_ofs)
+ while todo:
+ data = f.read(min(todo, buffer_size))
+ sha.update(data)
+ todo -= len(data)
+ return sha
class PackData:
@@ -692,7 +1179,7 @@ class PackData:
position. It will all just throw a zlib or KeyError.
"""
- def __init__(self, filename, file=None, size=None) ->None:
+ def __init__(self, filename, file=None, size=None) -> None:
"""Create a PackData object representing the pack in the given filename.
The file must exist and stay readable until the object is disposed of.
@@ -705,12 +1192,32 @@ class PackData:
self._size = size
self._header_size = 12
if file is None:
- self._file = GitFile(self._filename, 'rb')
+ self._file = GitFile(self._filename, "rb")
else:
self._file = file
- version, self._num_objects = read_pack_header(self._file.read)
+ (version, self._num_objects) = read_pack_header(self._file.read)
self._offset_cache = LRUSizeCache[int, Tuple[int, OldUnpackedObject]](
- 1024 * 1024 * 20, compute_size=_compute_object_size)
+ 1024 * 1024 * 20, compute_size=_compute_object_size
+ )
+
+ @property
+ def filename(self):
+ return os.path.basename(self._filename)
+
+ @property
+ def path(self):
+ return self._filename
+
+ @classmethod
+ def from_file(cls, file, size=None):
+ return cls(str(file), file=file, size=size)
+
+ @classmethod
+ def from_path(cls, path):
+ return cls(filename=path)
+
+ def close(self):
+ self._file.close()
def __enter__(self):
return self
@@ -723,7 +1230,20 @@ class PackData:
return self.get_stored_checksum() == other.get_stored_checksum()
return False
- def __len__(self) ->int:
+ def _get_size(self):
+ if self._size is not None:
+ return self._size
+ self._size = os.path.getsize(self._filename)
+ if self._size < self._header_size:
+ errmsg = "%s is too small for a packfile (%d < %d)" % (
+ self._filename,
+ self._size,
+ self._header_size,
+ )
+ raise AssertionError(errmsg)
+ return self._size
+
+ def __len__(self) -> int:
"""Returns the number of objects in this pack."""
return self._num_objects
@@ -732,10 +1252,27 @@ class PackData:
Returns: 20-byte binary SHA1 digest
"""
- pass
-
- def iterentries(self, progress=None, resolve_ext_ref: Optional[
- ResolveExtRefFn]=None):
+ return compute_file_sha(self._file, end_ofs=-20).digest()
+
+ def iter_unpacked(self, *, include_comp: bool = False):
+ self._file.seek(self._header_size)
+
+ if self._num_objects is None:
+ return
+
+ for _ in range(self._num_objects):
+ offset = self._file.tell()
+ unpacked, unused = unpack_object(
+ self._file.read, compute_crc32=False, include_comp=include_comp
+ )
+ unpacked.offset = offset
+ yield unpacked
+ # Back up over unused data.
+ self._file.seek(-len(unused), SEEK_CUR)
+
+ def iterentries(
+ self, progress=None, resolve_ext_ref: Optional[ResolveExtRefFn] = None
+ ):
"""Yield entries summarizing the contents of this pack.
Args:
@@ -743,10 +1280,18 @@ class PackData:
object count.
Returns: iterator of tuples with (sha, offset, crc32)
"""
- pass
-
- def sorted_entries(self, progress: Optional[ProgressFn]=None,
- resolve_ext_ref: Optional[ResolveExtRefFn]=None):
+ num_objects = self._num_objects
+ indexer = PackIndexer.for_pack_data(self, resolve_ext_ref=resolve_ext_ref)
+ for i, result in enumerate(indexer):
+ if progress is not None:
+ progress(i, num_objects)
+ yield result
+
+ def sorted_entries(
+ self,
+ progress: Optional[ProgressFn] = None,
+ resolve_ext_ref: Optional[ResolveExtRefFn] = None,
+ ):
"""Return entries in this pack, sorted by SHA.
Args:
@@ -754,7 +1299,9 @@ class PackData:
object count
Returns: Iterator of tuples with (sha, offset, crc32)
"""
- pass
+ return sorted(
+ self.iterentries(progress=progress, resolve_ext_ref=resolve_ext_ref)
+ )
def create_index_v1(self, filename, progress=None, resolve_ext_ref=None):
"""Create a version 1 file for this data file.
@@ -764,7 +1311,11 @@ class PackData:
progress: Progress report function
Returns: Checksum of index file
"""
- pass
+ entries = self.sorted_entries(
+ progress=progress, resolve_ext_ref=resolve_ext_ref
+ )
+ with GitFile(filename, "wb") as f:
+ return write_pack_index_v1(f, entries, self.calculate_checksum())
def create_index_v2(self, filename, progress=None, resolve_ext_ref=None):
"""Create a version 2 index file for this data file.
@@ -774,10 +1325,13 @@ class PackData:
progress: Progress report function
Returns: Checksum of index file
"""
- pass
+ entries = self.sorted_entries(
+ progress=progress, resolve_ext_ref=resolve_ext_ref
+ )
+ with GitFile(filename, "wb") as f:
+ return write_pack_index_v2(f, entries, self.calculate_checksum())
- def create_index(self, filename, progress=None, version=2,
- resolve_ext_ref=None):
+ def create_index(self, filename, progress=None, version=2, resolve_ext_ref=None):
"""Create an index file for this data file.
Args:
@@ -785,32 +1339,55 @@ class PackData:
progress: Progress report function
Returns: Checksum of index file
"""
- pass
+ if version == 1:
+ return self.create_index_v1(
+ filename, progress, resolve_ext_ref=resolve_ext_ref
+ )
+ elif version == 2:
+ return self.create_index_v2(
+ filename, progress, resolve_ext_ref=resolve_ext_ref
+ )
+ else:
+ raise ValueError("unknown index format %d" % version)
def get_stored_checksum(self):
"""Return the expected checksum stored in this pack."""
- pass
+ self._file.seek(-20, SEEK_END)
+ return self._file.read(20)
def check(self):
"""Check the consistency of this pack."""
- pass
-
- def get_unpacked_object_at(self, offset: int, *, include_comp: bool=False
- ) ->UnpackedObject:
+ actual = self.calculate_checksum()
+ stored = self.get_stored_checksum()
+ if actual != stored:
+ raise ChecksumMismatch(stored, actual)
+
+ def get_unpacked_object_at(
+ self, offset: int, *, include_comp: bool = False
+ ) -> UnpackedObject:
"""Given offset in the packfile return a UnpackedObject."""
- pass
+ assert offset >= self._header_size
+ self._file.seek(offset)
+ unpacked, _ = unpack_object(self._file.read, include_comp=include_comp)
+ unpacked.offset = offset
+ return unpacked
- def get_object_at(self, offset: int) ->Tuple[int, OldUnpackedObject]:
+ def get_object_at(self, offset: int) -> Tuple[int, OldUnpackedObject]:
"""Given an offset in to the packfile return the object that is there.
Using the associated index the location of an object can be looked up,
and then the packfile can be asked directly for that object using this
function.
"""
- pass
+ try:
+ return self._offset_cache[offset]
+ except KeyError:
+ pass
+ unpacked = self.get_unpacked_object_at(offset, include_comp=False)
+ return (unpacked.pack_type_num, unpacked._obj())
-T = TypeVar('T')
+T = TypeVar("T")
class DeltaChainIterator(Generic[T]):
@@ -833,10 +1410,11 @@ class DeltaChainIterator(Generic[T]):
* decomp_len
* crc32 (if _compute_crc32 is True)
"""
+
_compute_crc32 = False
_include_comp = False
- def __init__(self, file_obj, *, resolve_ext_ref=None) ->None:
+ def __init__(self, file_obj, *, resolve_ext_ref=None) -> None:
self._file = file_obj
self._resolve_ext_ref = resolve_ext_ref
self._pending_ofs: Dict[int, List[int]] = defaultdict(list)
@@ -844,38 +1422,222 @@ class DeltaChainIterator(Generic[T]):
self._full_ofs: List[Tuple[int, int]] = []
self._ext_refs: List[bytes] = []
- def __iter__(self) ->Iterator[T]:
+ @classmethod
+ def for_pack_data(cls, pack_data: PackData, resolve_ext_ref=None):
+ walker = cls(None, resolve_ext_ref=resolve_ext_ref)
+ walker.set_pack_data(pack_data)
+ for unpacked in pack_data.iter_unpacked(include_comp=False):
+ walker.record(unpacked)
+ return walker
+
+ @classmethod
+ def for_pack_subset(
+ cls,
+ pack: "Pack",
+ shas: Iterable[bytes],
+ *,
+ allow_missing: bool = False,
+ resolve_ext_ref=None,
+ ):
+ walker = cls(None, resolve_ext_ref=resolve_ext_ref)
+ walker.set_pack_data(pack.data)
+ todo = set()
+ for sha in shas:
+ assert isinstance(sha, bytes)
+ try:
+ off = pack.index.object_offset(sha)
+ except KeyError:
+ if not allow_missing:
+ raise
+ else:
+ todo.add(off)
+ done = set()
+ while todo:
+ off = todo.pop()
+ unpacked = pack.data.get_unpacked_object_at(off)
+ walker.record(unpacked)
+ done.add(off)
+ base_ofs = None
+ if unpacked.pack_type_num == OFS_DELTA:
+ base_ofs = unpacked.offset - unpacked.delta_base
+ elif unpacked.pack_type_num == REF_DELTA:
+ with suppress(KeyError):
+ assert isinstance(unpacked.delta_base, bytes)
+ base_ofs = pack.index.object_index(unpacked.delta_base)
+ if base_ofs is not None and base_ofs not in done:
+ todo.add(base_ofs)
+ return walker
+
+ def record(self, unpacked: UnpackedObject) -> None:
+ type_num = unpacked.pack_type_num
+ offset = unpacked.offset
+ if type_num == OFS_DELTA:
+ base_offset = offset - unpacked.delta_base
+ self._pending_ofs[base_offset].append(offset)
+ elif type_num == REF_DELTA:
+ assert isinstance(unpacked.delta_base, bytes)
+ self._pending_ref[unpacked.delta_base].append(offset)
+ else:
+ self._full_ofs.append((offset, type_num))
+
+ def set_pack_data(self, pack_data: PackData) -> None:
+ self._file = pack_data._file
+
+ def _walk_all_chains(self):
+ for offset, type_num in self._full_ofs:
+ yield from self._follow_chain(offset, type_num, None)
+ yield from self._walk_ref_chains()
+ assert not self._pending_ofs, repr(self._pending_ofs)
+
+ def _ensure_no_pending(self) -> None:
+ if self._pending_ref:
+ raise UnresolvedDeltas([sha_to_hex(s) for s in self._pending_ref])
+
+ def _walk_ref_chains(self):
+ if not self._resolve_ext_ref:
+ self._ensure_no_pending()
+ return
+
+ for base_sha, pending in sorted(self._pending_ref.items()):
+ if base_sha not in self._pending_ref:
+ continue
+ try:
+ type_num, chunks = self._resolve_ext_ref(base_sha)
+ except KeyError:
+ # Not an external ref, but may depend on one. Either it will
+ # get popped via a _follow_chain call, or we will raise an
+ # error below.
+ continue
+ self._ext_refs.append(base_sha)
+ self._pending_ref.pop(base_sha)
+ for new_offset in pending:
+ yield from self._follow_chain(new_offset, type_num, chunks)
+
+ self._ensure_no_pending()
+
+ def _result(self, unpacked: UnpackedObject) -> T:
+ raise NotImplementedError
+
+ def _resolve_object(
+ self, offset: int, obj_type_num: int, base_chunks: List[bytes]
+ ) -> UnpackedObject:
+ self._file.seek(offset)
+ unpacked, _ = unpack_object(
+ self._file.read,
+ include_comp=self._include_comp,
+ compute_crc32=self._compute_crc32,
+ )
+ unpacked.offset = offset
+ if base_chunks is None:
+ assert unpacked.pack_type_num == obj_type_num
+ else:
+ assert unpacked.pack_type_num in DELTA_TYPES
+ unpacked.obj_type_num = obj_type_num
+ unpacked.obj_chunks = apply_delta(base_chunks, unpacked.decomp_chunks)
+ return unpacked
+
+ def _follow_chain(self, offset: int, obj_type_num: int, base_chunks: List[bytes]):
+ # Unlike PackData.get_object_at, there is no need to cache offsets as
+ # this approach by design inflates each object exactly once.
+ todo = [(offset, obj_type_num, base_chunks)]
+ while todo:
+ (offset, obj_type_num, base_chunks) = todo.pop()
+ unpacked = self._resolve_object(offset, obj_type_num, base_chunks)
+ yield self._result(unpacked)
+
+ unblocked = chain(
+ self._pending_ofs.pop(unpacked.offset, []),
+ self._pending_ref.pop(unpacked.sha(), []),
+ )
+ todo.extend(
+ (new_offset, unpacked.obj_type_num, unpacked.obj_chunks) # type: ignore
+ for new_offset in unblocked
+ )
+
+ def __iter__(self) -> Iterator[T]:
return self._walk_all_chains()
+ def ext_refs(self):
+ return self._ext_refs
+
class UnpackedObjectIterator(DeltaChainIterator[UnpackedObject]):
"""Delta chain iterator that yield unpacked objects."""
+ def _result(self, unpacked):
+ return unpacked
+
class PackIndexer(DeltaChainIterator[PackIndexEntry]):
"""Delta chain iterator that yields index entries."""
+
_compute_crc32 = True
+ def _result(self, unpacked):
+ return unpacked.sha(), unpacked.offset, unpacked.crc32
+
class PackInflater(DeltaChainIterator[ShaFile]):
"""Delta chain iterator that yields ShaFile objects."""
+ def _result(self, unpacked):
+ return unpacked.sha_file()
+
class SHA1Reader:
"""Wrapper for file-like object that remembers the SHA1 of its data."""
- def __init__(self, f) ->None:
+ def __init__(self, f) -> None:
self.f = f
- self.sha1 = sha1(b'')
+ self.sha1 = sha1(b"")
+
+ def read(self, num=None):
+ data = self.f.read(num)
+ self.sha1.update(data)
+ return data
+
+ def check_sha(self):
+ stored = self.f.read(20)
+ if stored != self.sha1.digest():
+ raise ChecksumMismatch(self.sha1.hexdigest(), sha_to_hex(stored))
+
+ def close(self):
+ return self.f.close()
+
+ def tell(self):
+ return self.f.tell()
class SHA1Writer:
"""Wrapper for file-like object that remembers the SHA1 of its data."""
- def __init__(self, f) ->None:
+ def __init__(self, f) -> None:
self.f = f
self.length = 0
- self.sha1 = sha1(b'')
+ self.sha1 = sha1(b"")
+
+ def write(self, data):
+ self.sha1.update(data)
+ self.f.write(data)
+ self.length += len(data)
+
+ def write_sha(self):
+ sha = self.sha1.digest()
+ assert len(sha) == 20
+ self.f.write(sha)
+ self.length += len(sha)
+ return sha
+
+ def close(self):
+ sha = self.write_sha()
+ self.f.close()
+ return sha
+
+ def offset(self):
+ return self.length
+
+ def tell(self):
+ return self.f.tell()
def pack_object_header(type_num, delta_base, size):
@@ -887,7 +1649,26 @@ def pack_object_header(type_num, delta_base, size):
size: Uncompressed object size.
Returns: A header for a packed object.
"""
- pass
+ header = []
+ c = (type_num << 4) | (size & 15)
+ size >>= 4
+ while size:
+ header.append(c | 0x80)
+ c = size & 0x7F
+ size >>= 7
+ header.append(c)
+ if type_num == OFS_DELTA:
+ ret = [delta_base & 0x7F]
+ delta_base >>= 7
+ while delta_base:
+ delta_base -= 1
+ ret.insert(0, 0x80 | (delta_base & 0x7F))
+ delta_base >>= 7
+ header.extend(ret)
+ elif type_num == REF_DELTA:
+ assert len(delta_base) == 20
+ header += delta_base
+ return bytearray(header)
def pack_object_chunks(type, object, compression_level=-1):
@@ -899,7 +1680,17 @@ def pack_object_chunks(type, object, compression_level=-1):
compression_level: the zlib compression level
Returns: Chunks
"""
- pass
+ if type in DELTA_TYPES:
+ delta_base, object = object
+ else:
+ delta_base = None
+ if isinstance(object, bytes):
+ object = [object]
+ yield bytes(pack_object_header(type, delta_base, sum(map(len, object))))
+ compressor = zlib.compressobj(level=compression_level)
+ for data in object:
+ yield compressor.compress(data)
+ yield compressor.flush()
def write_pack_object(write, type, object, sha=None, compression_level=-1):
@@ -912,12 +1703,23 @@ def write_pack_object(write, type, object, sha=None, compression_level=-1):
compression_level: the zlib compression level
Returns: Tuple with offset at which the object was written, and crc32
"""
- pass
-
-
-def write_pack(filename, objects: Union[Sequence[ShaFile], Sequence[Tuple[
- ShaFile, Optional[bytes]]]], *, deltify: Optional[bool]=None,
- delta_window_size: Optional[int]=None, compression_level: int=-1):
+ crc32 = 0
+ for chunk in pack_object_chunks(type, object, compression_level=compression_level):
+ write(chunk)
+ if sha is not None:
+ sha.update(chunk)
+ crc32 = binascii.crc32(chunk, crc32)
+ return crc32 & 0xFFFFFFFF
+
+
+def write_pack(
+ filename,
+ objects: Union[Sequence[ShaFile], Sequence[Tuple[ShaFile, Optional[bytes]]]],
+ *,
+ deltify: Optional[bool] = None,
+ delta_window_size: Optional[int] = None,
+ compression_level: int = -1,
+):
"""Write a new pack data file.
Args:
@@ -929,22 +1731,75 @@ def write_pack(filename, objects: Union[Sequence[ShaFile], Sequence[Tuple[
compression_level: the zlib compression level
Returns: Tuple with checksum of pack file and index file
"""
- pass
+ with GitFile(filename + ".pack", "wb") as f:
+ entries, data_sum = write_pack_objects(
+ f.write,
+ objects,
+ delta_window_size=delta_window_size,
+ deltify=deltify,
+ compression_level=compression_level,
+ )
+ entries = sorted([(k, v[0], v[1]) for (k, v) in entries.items()])
+ with GitFile(filename + ".idx", "wb") as f:
+ return data_sum, write_pack_index_v2(f, entries, data_sum)
def pack_header_chunks(num_objects):
"""Yield chunks for a pack header."""
- pass
+ yield b"PACK" # Pack header
+ yield struct.pack(b">L", 2) # Pack version
+ yield struct.pack(b">L", num_objects) # Number of objects in pack
def write_pack_header(write, num_objects):
"""Write a pack header for the given number of objects."""
- pass
-
-
-def deltify_pack_objects(objects: Union[Iterator[bytes], Iterator[Tuple[
- ShaFile, Optional[bytes]]]], *, window_size: Optional[int]=None,
- progress=None) ->Iterator[UnpackedObject]:
+ if hasattr(write, "write"):
+ write = write.write
+ warnings.warn(
+ "write_pack_header() now takes a write rather than file argument",
+ DeprecationWarning,
+ stacklevel=2,
+ )
+ for chunk in pack_header_chunks(num_objects):
+ write(chunk)
+
+
+def find_reusable_deltas(
+ container: PackedObjectContainer,
+ object_ids: Set[bytes],
+ *,
+ other_haves: Optional[Set[bytes]] = None,
+ progress=None,
+) -> Iterator[UnpackedObject]:
+ if other_haves is None:
+ other_haves = set()
+ reused = 0
+ for i, unpacked in enumerate(
+ container.iter_unpacked_subset(
+ object_ids, allow_missing=True, convert_ofs_delta=True
+ )
+ ):
+ if progress is not None and i % 1000 == 0:
+ progress(
+ ("checking for reusable deltas: %d/%d\r" % (i, len(object_ids))).encode(
+ "utf-8"
+ )
+ )
+ if unpacked.pack_type_num == REF_DELTA:
+ hexsha = sha_to_hex(unpacked.delta_base)
+ if hexsha in object_ids or hexsha in other_haves:
+ yield unpacked
+ reused += 1
+ if progress is not None:
+ progress(("found %d deltas to reuse\n" % (reused,)).encode("utf-8"))
+
+
+def deltify_pack_objects(
+ objects: Union[Iterator[bytes], Iterator[Tuple[ShaFile, Optional[bytes]]]],
+ *,
+ window_size: Optional[int] = None,
+ progress=None,
+) -> Iterator[UnpackedObject]:
"""Generate deltas for pack objects.
Args:
@@ -953,41 +1808,185 @@ def deltify_pack_objects(objects: Union[Iterator[bytes], Iterator[Tuple[
Returns: Iterator over type_num, object id, delta_base, content
delta_base is None for full text entries
"""
- pass
-
-def pack_objects_to_data(objects: Union[Sequence[ShaFile], Sequence[Tuple[
- ShaFile, Optional[bytes]]]], *, deltify: Optional[bool]=None,
- delta_window_size: Optional[int]=None, ofs_delta: bool=True, progress=None
- ) ->Tuple[int, Iterator[UnpackedObject]]:
+ def objects_with_hints():
+ for e in objects:
+ if isinstance(e, ShaFile):
+ yield (e, (e.type_num, None))
+ else:
+ yield (e[0], (e[0].type_num, e[1]))
+
+ yield from deltas_from_sorted_objects(
+ sort_objects_for_delta(objects_with_hints()),
+ window_size=window_size,
+ progress=progress,
+ )
+
+
+def sort_objects_for_delta(
+ objects: Union[Iterator[ShaFile], Iterator[Tuple[ShaFile, Optional[PackHint]]]],
+) -> Iterator[ShaFile]:
+ magic = []
+ for entry in objects:
+ if isinstance(entry, tuple):
+ obj, hint = entry
+ if hint is None:
+ type_num = None
+ path = None
+ else:
+ (type_num, path) = hint
+ else:
+ obj = entry
+ magic.append((type_num, path, -obj.raw_length(), obj))
+ # Build a list of objects ordered by the magic Linus heuristic
+ # This helps us find good objects to diff against us
+ magic.sort()
+ return (x[3] for x in magic)
+
+
+def deltas_from_sorted_objects(
+ objects, window_size: Optional[int] = None, progress=None
+):
+ # TODO(jelmer): Use threads
+ if window_size is None:
+ window_size = DEFAULT_PACK_DELTA_WINDOW_SIZE
+
+ possible_bases: Deque[Tuple[bytes, int, List[bytes]]] = deque()
+ for i, o in enumerate(objects):
+ if progress is not None and i % 1000 == 0:
+ progress(("generating deltas: %d\r" % (i,)).encode("utf-8"))
+ raw = o.as_raw_chunks()
+ winner = raw
+ winner_len = sum(map(len, winner))
+ winner_base = None
+ for base_id, base_type_num, base in possible_bases:
+ if base_type_num != o.type_num:
+ continue
+ delta_len = 0
+ delta = []
+ for chunk in create_delta(base, raw):
+ delta_len += len(chunk)
+ if delta_len >= winner_len:
+ break
+ delta.append(chunk)
+ else:
+ winner_base = base_id
+ winner = delta
+ winner_len = sum(map(len, winner))
+ yield UnpackedObject(
+ o.type_num,
+ sha=o.sha().digest(),
+ delta_base=winner_base,
+ decomp_len=winner_len,
+ decomp_chunks=winner,
+ )
+ possible_bases.appendleft((o.sha().digest(), o.type_num, raw))
+ while len(possible_bases) > window_size:
+ possible_bases.pop()
+
+
+def pack_objects_to_data(
+ objects: Union[Sequence[ShaFile], Sequence[Tuple[ShaFile, Optional[bytes]]]],
+ *,
+ deltify: Optional[bool] = None,
+ delta_window_size: Optional[int] = None,
+ ofs_delta: bool = True,
+ progress=None,
+) -> Tuple[int, Iterator[UnpackedObject]]:
"""Create pack data from objects.
Args:
objects: Pack objects
Returns: Tuples with (type_num, hexdigest, delta base, object chunks)
"""
- pass
-
-
-def generate_unpacked_objects(container: PackedObjectContainer, object_ids:
- Sequence[Tuple[ObjectID, Optional[PackHint]]], delta_window_size:
- Optional[int]=None, deltify: Optional[bool]=None, reuse_deltas: bool=
- True, ofs_delta: bool=True, other_haves: Optional[Set[bytes]]=None,
- progress=None) ->Iterator[UnpackedObject]:
+ # TODO(jelmer): support deltaifying
+ count = len(objects)
+ if deltify is None:
+ # PERFORMANCE/TODO(jelmer): This should be enabled but is *much* too
+ # slow at the moment.
+ deltify = False
+ if deltify:
+ return (
+ count,
+ deltify_pack_objects(
+ iter(objects), # type: ignore
+ window_size=delta_window_size,
+ progress=progress,
+ ),
+ )
+ else:
+
+ def iter_without_path():
+ for o in objects:
+ if isinstance(o, tuple):
+ yield full_unpacked_object(o[0])
+ else:
+ yield full_unpacked_object(o)
+
+ return (count, iter_without_path())
+
+
+def generate_unpacked_objects(
+ container: PackedObjectContainer,
+ object_ids: Sequence[Tuple[ObjectID, Optional[PackHint]]],
+ delta_window_size: Optional[int] = None,
+ deltify: Optional[bool] = None,
+ reuse_deltas: bool = True,
+ ofs_delta: bool = True,
+ other_haves: Optional[Set[bytes]] = None,
+ progress=None,
+) -> Iterator[UnpackedObject]:
"""Create pack data from objects.
Args:
objects: Pack objects
Returns: Tuples with (type_num, hexdigest, delta base, object chunks)
"""
- pass
-
-
-def write_pack_from_container(write, container: PackedObjectContainer,
+ todo = dict(object_ids)
+ if reuse_deltas:
+ for unpack in find_reusable_deltas(
+ container, set(todo), other_haves=other_haves, progress=progress
+ ):
+ del todo[sha_to_hex(unpack.sha())]
+ yield unpack
+ if deltify is None:
+ # PERFORMANCE/TODO(jelmer): This should be enabled but is *much* too
+ # slow at the moment.
+ deltify = False
+ if deltify:
+ objects_to_delta = container.iterobjects_subset(
+ todo.keys(), allow_missing=False
+ )
+ yield from deltas_from_sorted_objects(
+ sort_objects_for_delta((o, todo[o.id]) for o in objects_to_delta),
+ window_size=delta_window_size,
+ progress=progress,
+ )
+ else:
+ for oid in todo:
+ yield full_unpacked_object(container[oid])
+
+
+def full_unpacked_object(o: ShaFile) -> UnpackedObject:
+ return UnpackedObject(
+ o.type_num,
+ delta_base=None,
+ crc32=None,
+ decomp_chunks=o.as_raw_chunks(),
+ sha=o.sha().digest(),
+ )
+
+
+def write_pack_from_container(
+ write,
+ container: PackedObjectContainer,
object_ids: Sequence[Tuple[ObjectID, Optional[PackHint]]],
- delta_window_size: Optional[int]=None, deltify: Optional[bool]=None,
- reuse_deltas: bool=True, compression_level: int=-1, other_haves:
- Optional[Set[bytes]]=None):
+ delta_window_size: Optional[int] = None,
+ deltify: Optional[bool] = None,
+ reuse_deltas: bool = True,
+ compression_level: int = -1,
+ other_haves: Optional[Set[bytes]] = None,
+):
"""Write a new pack data file.
Args:
@@ -1000,12 +1999,32 @@ def write_pack_from_container(write, container: PackedObjectContainer,
compression_level: the zlib compression level to use
Returns: Dict mapping id -> (offset, crc32 checksum), pack checksum
"""
- pass
-
-
-def write_pack_objects(write, objects: Union[Sequence[ShaFile], Sequence[
- Tuple[ShaFile, Optional[bytes]]]], *, delta_window_size: Optional[int]=
- None, deltify: Optional[bool]=None, compression_level: int=-1):
+ pack_contents_count = len(object_ids)
+ pack_contents = generate_unpacked_objects(
+ container,
+ object_ids,
+ delta_window_size=delta_window_size,
+ deltify=deltify,
+ reuse_deltas=reuse_deltas,
+ other_haves=other_haves,
+ )
+
+ return write_pack_data(
+ write,
+ pack_contents,
+ num_records=pack_contents_count,
+ compression_level=compression_level,
+ )
+
+
+def write_pack_objects(
+ write,
+ objects: Union[Sequence[ShaFile], Sequence[Tuple[ShaFile, Optional[bytes]]]],
+ *,
+ delta_window_size: Optional[int] = None,
+ deltify: Optional[bool] = None,
+ compression_level: int = -1,
+):
"""Write a new pack data file.
Args:
@@ -1017,25 +2036,50 @@ def write_pack_objects(write, objects: Union[Sequence[ShaFile], Sequence[
compression_level: the zlib compression level to use
Returns: Dict mapping id -> (offset, crc32 checksum), pack checksum
"""
- pass
+ pack_contents_count, pack_contents = pack_objects_to_data(objects, deltify=deltify)
+ return write_pack_data(
+ write,
+ pack_contents,
+ num_records=pack_contents_count,
+ compression_level=compression_level,
+ )
-class PackChunkGenerator:
- def __init__(self, num_records=None, records=None, progress=None,
- compression_level=-1, reuse_compressed=True) ->None:
- self.cs = sha1(b'')
+class PackChunkGenerator:
+ def __init__(
+ self,
+ num_records=None,
+ records=None,
+ progress=None,
+ compression_level=-1,
+ reuse_compressed=True,
+ ) -> None:
+ self.cs = sha1(b"")
self.entries: Dict[Union[int, bytes], Tuple[int, int]] = {}
- self._it = self._pack_data_chunks(num_records=num_records, records=
- records, progress=progress, compression_level=compression_level,
- reuse_compressed=reuse_compressed)
+ self._it = self._pack_data_chunks(
+ num_records=num_records,
+ records=records,
+ progress=progress,
+ compression_level=compression_level,
+ reuse_compressed=reuse_compressed,
+ )
+
+ def sha1digest(self):
+ return self.cs.digest()
def __iter__(self):
return self._it
- def _pack_data_chunks(self, records: Iterator[UnpackedObject], *,
- num_records=None, progress=None, compression_level: int=-1,
- reuse_compressed: bool=True) ->Iterator[bytes]:
+ def _pack_data_chunks(
+ self,
+ records: Iterator[UnpackedObject],
+ *,
+ num_records=None,
+ progress=None,
+ compression_level: int = -1,
+ reuse_compressed: bool = True,
+ ) -> Iterator[bytes]:
"""Iterate pack data file chunks.
Args:
@@ -1045,11 +2089,67 @@ class PackChunkGenerator:
compression_level: the zlib compression level
Returns: Dict mapping id -> (offset, crc32 checksum), pack checksum
"""
- pass
-
-
-def write_pack_data(write, records: Iterator[UnpackedObject], *,
- num_records=None, progress=None, compression_level=-1):
+ # Write the pack
+ if num_records is None:
+ num_records = len(records) # type: ignore
+ offset = 0
+ for chunk in pack_header_chunks(num_records):
+ yield chunk
+ self.cs.update(chunk)
+ offset += len(chunk)
+ actual_num_records = 0
+ for i, unpacked in enumerate(records):
+ type_num = unpacked.pack_type_num
+ if progress is not None and i % 1000 == 0:
+ progress(
+ ("writing pack data: %d/%d\r" % (i, num_records)).encode("ascii")
+ )
+ raw: Union[List[bytes], Tuple[int, List[bytes]], Tuple[bytes, List[bytes]]]
+ if unpacked.delta_base is not None:
+ try:
+ base_offset, base_crc32 = self.entries[unpacked.delta_base]
+ except KeyError:
+ type_num = REF_DELTA
+ assert isinstance(unpacked.delta_base, bytes)
+ raw = (unpacked.delta_base, unpacked.decomp_chunks)
+ else:
+ type_num = OFS_DELTA
+ raw = (offset - base_offset, unpacked.decomp_chunks)
+ else:
+ raw = unpacked.decomp_chunks
+ if unpacked.comp_chunks is not None and reuse_compressed:
+ chunks = unpacked.comp_chunks
+ else:
+ chunks = pack_object_chunks(
+ type_num, raw, compression_level=compression_level
+ )
+ crc32 = 0
+ object_size = 0
+ for chunk in chunks:
+ yield chunk
+ crc32 = binascii.crc32(chunk, crc32)
+ self.cs.update(chunk)
+ object_size += len(chunk)
+ actual_num_records += 1
+ self.entries[unpacked.sha()] = (offset, crc32)
+ offset += object_size
+ if actual_num_records != num_records:
+ raise AssertionError(
+ "actual records written differs: %d != %d"
+ % (actual_num_records, num_records)
+ )
+
+ yield self.cs.digest()
+
+
+def write_pack_data(
+ write,
+ records: Iterator[UnpackedObject],
+ *,
+ num_records=None,
+ progress=None,
+ compression_level=-1,
+):
"""Write a new pack data file.
Args:
@@ -1060,7 +2160,15 @@ def write_pack_data(write, records: Iterator[UnpackedObject], *,
compression_level: the zlib compression level
Returns: Dict mapping id -> (offset, crc32 checksum), pack checksum
"""
- pass
+ chunk_generator = PackChunkGenerator(
+ num_records=num_records,
+ records=records,
+ progress=progress,
+ compression_level=compression_level,
+ )
+ for chunk in chunk_generator:
+ write(chunk)
+ return chunk_generator.entries, chunk_generator.sha1digest()
def write_pack_index_v1(f, entries, pack_checksum):
@@ -1073,10 +2181,52 @@ def write_pack_index_v1(f, entries, pack_checksum):
pack_checksum: Checksum of the pack file.
Returns: The SHA of the written index file
"""
- pass
-
-
-_MAX_COPY_LEN = 65535
+ f = SHA1Writer(f)
+ fan_out_table = defaultdict(lambda: 0)
+ for name, offset, entry_checksum in entries:
+ fan_out_table[ord(name[:1])] += 1
+ # Fan-out table
+ for i in range(0x100):
+ f.write(struct.pack(">L", fan_out_table[i]))
+ fan_out_table[i + 1] += fan_out_table[i]
+ for name, offset, entry_checksum in entries:
+ if not (offset <= 0xFFFFFFFF):
+ raise TypeError("pack format 1 only supports offsets < 2Gb")
+ f.write(struct.pack(">L20s", offset, name))
+ assert len(pack_checksum) == 20
+ f.write(pack_checksum)
+ return f.write_sha()
+
+
+def _delta_encode_size(size) -> bytes:
+ ret = bytearray()
+ c = size & 0x7F
+ size >>= 7
+ while size:
+ ret.append(c | 0x80)
+ c = size & 0x7F
+ size >>= 7
+ ret.append(c)
+ return bytes(ret)
+
+
+# The length of delta compression copy operations in version 2 packs is limited
+# to 64K. To copy more, we use several copy operations. Version 3 packs allow
+# 24-bit lengths in copy operations, but we always make version 2 packs.
+_MAX_COPY_LEN = 0xFFFF
+
+
+def _encode_copy_operation(start, length):
+ scratch = bytearray([0x80])
+ for i in range(4):
+ if start & 0xFF << i * 8:
+ scratch.append((start >> i * 8) & 0xFF)
+ scratch[0] |= 1 << i
+ for i in range(2):
+ if length & 0xFF << i * 8:
+ scratch.append((length >> i * 8) & 0xFF)
+ scratch[0] |= 1 << (4 + i)
+ return bytes(scratch)
def create_delta(base_buf, target_buf):
@@ -1086,7 +2236,43 @@ def create_delta(base_buf, target_buf):
base_buf: Base buffer
target_buf: Target buffer
"""
- pass
+ if isinstance(base_buf, list):
+ base_buf = b"".join(base_buf)
+ if isinstance(target_buf, list):
+ target_buf = b"".join(target_buf)
+ assert isinstance(base_buf, bytes)
+ assert isinstance(target_buf, bytes)
+ # write delta header
+ yield _delta_encode_size(len(base_buf))
+ yield _delta_encode_size(len(target_buf))
+ # write out delta opcodes
+ seq = SequenceMatcher(isjunk=None, a=base_buf, b=target_buf)
+ for opcode, i1, i2, j1, j2 in seq.get_opcodes():
+ # Git patch opcodes don't care about deletes!
+ # if opcode == 'replace' or opcode == 'delete':
+ # pass
+ if opcode == "equal":
+ # If they are equal, unpacker will use data from base_buf
+ # Write out an opcode that says what range to use
+ copy_start = i1
+ copy_len = i2 - i1
+ while copy_len > 0:
+ to_copy = min(copy_len, _MAX_COPY_LEN)
+ yield _encode_copy_operation(copy_start, to_copy)
+ copy_start += to_copy
+ copy_len -= to_copy
+ if opcode == "replace" or opcode == "insert":
+ # If we are replacing a range or adding one, then we just
+ # output it to the stream (prefixed by its size)
+ s = j2 - j1
+ o = j1
+ while s > 127:
+ yield bytes([127])
+ yield memoryview(target_buf)[o : o + 127]
+ s -= 127
+ o += 127
+ yield bytes([s])
+ yield memoryview(target_buf)[o : o + s]
def apply_delta(src_buf, delta):
@@ -1096,11 +2282,73 @@ def apply_delta(src_buf, delta):
src_buf: Source buffer
delta: Delta instructions
"""
- pass
+ if not isinstance(src_buf, bytes):
+ src_buf = b"".join(src_buf)
+ if not isinstance(delta, bytes):
+ delta = b"".join(delta)
+ out = []
+ index = 0
+ delta_length = len(delta)
+
+ def get_delta_header_size(delta, index):
+ size = 0
+ i = 0
+ while delta:
+ cmd = ord(delta[index : index + 1])
+ index += 1
+ size |= (cmd & ~0x80) << i
+ i += 7
+ if not cmd & 0x80:
+ break
+ return size, index
+
+ src_size, index = get_delta_header_size(delta, index)
+ dest_size, index = get_delta_header_size(delta, index)
+ assert src_size == len(src_buf), "%d vs %d" % (src_size, len(src_buf))
+ while index < delta_length:
+ cmd = ord(delta[index : index + 1])
+ index += 1
+ if cmd & 0x80:
+ cp_off = 0
+ for i in range(4):
+ if cmd & (1 << i):
+ x = ord(delta[index : index + 1])
+ index += 1
+ cp_off |= x << (i * 8)
+ cp_size = 0
+ # Version 3 packs can contain copy sizes larger than 64K.
+ for i in range(3):
+ if cmd & (1 << (4 + i)):
+ x = ord(delta[index : index + 1])
+ index += 1
+ cp_size |= x << (i * 8)
+ if cp_size == 0:
+ cp_size = 0x10000
+ if (
+ cp_off + cp_size < cp_size
+ or cp_off + cp_size > src_size
+ or cp_size > dest_size
+ ):
+ break
+ out.append(src_buf[cp_off : cp_off + cp_size])
+ elif cmd != 0:
+ out.append(delta[index : index + cmd])
+ index += cmd
+ else:
+ raise ApplyDeltaError("Invalid opcode 0")
+ if index != delta_length:
+ raise ApplyDeltaError(f"delta not empty: {delta[index:]!r}")
-def write_pack_index_v2(f, entries: Iterable[PackIndexEntry], pack_checksum:
- bytes) ->bytes:
+ if dest_size != chunks_length(out):
+ raise ApplyDeltaError("dest size incorrect")
+
+ return out
+
+
+def write_pack_index_v2(
+ f, entries: Iterable[PackIndexEntry], pack_checksum: bytes
+) -> bytes:
"""Write a new pack index file.
Args:
@@ -1110,7 +2358,32 @@ def write_pack_index_v2(f, entries: Iterable[PackIndexEntry], pack_checksum:
pack_checksum: Checksum of the pack file.
Returns: The SHA of the index file written
"""
- pass
+ f = SHA1Writer(f)
+ f.write(b"\377tOc") # Magic!
+ f.write(struct.pack(">L", 2))
+ fan_out_table: Dict[int, int] = defaultdict(lambda: 0)
+ for name, offset, entry_checksum in entries:
+ fan_out_table[ord(name[:1])] += 1
+ # Fan-out table
+ largetable: List[int] = []
+ for i in range(0x100):
+ f.write(struct.pack(b">L", fan_out_table[i]))
+ fan_out_table[i + 1] += fan_out_table[i]
+ for name, offset, entry_checksum in entries:
+ f.write(name)
+ for name, offset, entry_checksum in entries:
+ f.write(struct.pack(b">L", entry_checksum))
+ for name, offset, entry_checksum in entries:
+ if offset < 2**31:
+ f.write(struct.pack(b">L", offset))
+ else:
+ f.write(struct.pack(b">L", 2**31 + len(largetable)))
+ largetable.append(offset)
+ for offset in largetable:
+ f.write(struct.pack(b">Q", offset))
+ assert len(pack_checksum) == 20
+ f.write(pack_checksum)
+ return f.write_sha()
write_pack_index = write_pack_index_v2
@@ -1118,20 +2391,23 @@ write_pack_index = write_pack_index_v2
class Pack:
"""A Git pack object."""
+
_data_load: Optional[Callable[[], PackData]]
_idx_load: Optional[Callable[[], PackIndex]]
+
_data: Optional[PackData]
_idx: Optional[PackIndex]
- def __init__(self, basename, resolve_ext_ref: Optional[ResolveExtRefFn]
- =None) ->None:
+ def __init__(
+ self, basename, resolve_ext_ref: Optional[ResolveExtRefFn] = None
+ ) -> None:
self._basename = basename
self._data = None
self._idx = None
- self._idx_path = self._basename + '.idx'
- self._data_path = self._basename + '.pack'
- self._data_load = lambda : PackData(self._data_path)
- self._idx_load = lambda : load_pack_index(self._idx_path)
+ self._idx_path = self._basename + ".idx"
+ self._data_path = self._basename + ".pack"
+ self._data_load = lambda: PackData(self._data_path)
+ self._idx_load = lambda: load_pack_index(self._idx_path)
self.resolve_ext_ref = resolve_ext_ref
@classmethod
@@ -1139,29 +2415,51 @@ class Pack:
"""Create a new pack object from callables to load pack data and
index objects.
"""
- pass
+ ret = cls("")
+ ret._data_load = data_fn
+ ret._idx_load = idx_fn
+ return ret
@classmethod
def from_objects(cls, data, idx):
"""Create a new pack object from pack data and index objects."""
- pass
+ ret = cls("")
+ ret._data = data
+ ret._data_load = None
+ ret._idx = idx
+ ret._idx_load = None
+ ret.check_length_and_checksum()
+ return ret
def name(self):
"""The SHA over the SHAs of the objects in this pack."""
- pass
+ return self.index.objects_sha1()
@property
- def data(self) ->PackData:
+ def data(self) -> PackData:
"""The pack data object being used."""
- pass
+ if self._data is None:
+ assert self._data_load
+ self._data = self._data_load()
+ self.check_length_and_checksum()
+ return self._data
@property
- def index(self) ->PackIndex:
+ def index(self) -> PackIndex:
"""The index being used.
Note: This may be an in-memory index
"""
- pass
+ if self._idx is None:
+ assert self._idx_load
+ self._idx = self._idx_load()
+ return self._idx
+
+ def close(self):
+ if self._data is not None:
+ self._data.close()
+ if self._idx is not None:
+ self._idx.close()
def __enter__(self):
return self
@@ -1172,30 +2470,49 @@ class Pack:
def __eq__(self, other):
return isinstance(self, type(other)) and self.index == other.index
- def __len__(self) ->int:
+ def __len__(self) -> int:
"""Number of entries in this pack."""
return len(self.index)
- def __repr__(self) ->str:
- return f'{self.__class__.__name__}({self._basename!r})'
+ def __repr__(self) -> str:
+ return f"{self.__class__.__name__}({self._basename!r})"
def __iter__(self):
"""Iterate over all the sha1s of the objects in this pack."""
return iter(self.index)
- def check_length_and_checksum(self) ->None:
+ def check_length_and_checksum(self) -> None:
"""Sanity check the length and checksum of the pack index and data."""
- pass
-
- def check(self) ->None:
+ assert len(self.index) == len(
+ self.data
+ ), f"Length mismatch: {len(self.index)} (index) != {len(self.data)} (data)"
+ idx_stored_checksum = self.index.get_pack_checksum()
+ data_stored_checksum = self.data.get_stored_checksum()
+ if idx_stored_checksum != data_stored_checksum:
+ raise ChecksumMismatch(
+ sha_to_hex(idx_stored_checksum),
+ sha_to_hex(data_stored_checksum),
+ )
+
+ def check(self) -> None:
"""Check the integrity of this pack.
Raises:
ChecksumMismatch: if a checksum for the index or data is wrong
"""
- pass
+ self.index.check()
+ self.data.check()
+ for obj in self.iterobjects():
+ obj.check()
+ # TODO: object connectivity checks
+
+ def get_stored_checksum(self) -> bytes:
+ return self.data.get_stored_checksum()
+
+ def pack_tuples(self):
+ return [(o, None) for o in self.iterobjects()]
- def __contains__(self, sha1: bytes) ->bool:
+ def __contains__(self, sha1: bytes) -> bool:
"""Check whether this pack contains a particular SHA1."""
try:
self.index.object_offset(sha1)
@@ -1203,16 +2520,84 @@ class Pack:
except KeyError:
return False
- def __getitem__(self, sha1: bytes) ->ShaFile:
+ def get_raw(self, sha1: bytes) -> Tuple[int, bytes]:
+ offset = self.index.object_offset(sha1)
+ obj_type, obj = self.data.get_object_at(offset)
+ type_num, chunks = self.resolve_object(offset, obj_type, obj)
+ return type_num, b"".join(chunks)
+
+ def __getitem__(self, sha1: bytes) -> ShaFile:
"""Retrieve the specified SHA1."""
type, uncomp = self.get_raw(sha1)
return ShaFile.from_raw_string(type, uncomp, sha=sha1)
- def iterobjects(self) ->Iterator[ShaFile]:
+ def iterobjects(self) -> Iterator[ShaFile]:
"""Iterate over the objects in this pack."""
- pass
-
- def keep(self, msg: Optional[bytes]=None) ->str:
+ return iter(
+ PackInflater.for_pack_data(self.data, resolve_ext_ref=self.resolve_ext_ref)
+ )
+
+ def iterobjects_subset(
+ self, shas: Iterable[ObjectID], *, allow_missing: bool = False
+ ) -> Iterator[ShaFile]:
+ return (
+ uo
+ for uo in PackInflater.for_pack_subset(
+ self,
+ shas,
+ allow_missing=allow_missing,
+ resolve_ext_ref=self.resolve_ext_ref,
+ )
+ if uo.id in shas
+ )
+
+ def iter_unpacked_subset(
+ self,
+ shas: Iterable[ObjectID],
+ *,
+ include_comp: bool = False,
+ allow_missing: bool = False,
+ convert_ofs_delta: bool = False,
+ ) -> Iterator[UnpackedObject]:
+ ofs_pending: Dict[int, List[UnpackedObject]] = defaultdict(list)
+ ofs: Dict[bytes, int] = {}
+ todo = set(shas)
+ for unpacked in self.iter_unpacked(include_comp=include_comp):
+ sha = unpacked.sha()
+ ofs[unpacked.offset] = sha
+ hexsha = sha_to_hex(sha)
+ if hexsha in todo:
+ if unpacked.pack_type_num == OFS_DELTA:
+ assert isinstance(unpacked.delta_base, int)
+ base_offset = unpacked.offset - unpacked.delta_base
+ try:
+ unpacked.delta_base = ofs[base_offset]
+ except KeyError:
+ ofs_pending[base_offset].append(unpacked)
+ continue
+ else:
+ unpacked.pack_type_num = REF_DELTA
+ yield unpacked
+ todo.remove(hexsha)
+ for child in ofs_pending.pop(unpacked.offset, []):
+ child.pack_type_num = REF_DELTA
+ child.delta_base = sha
+ yield child
+ assert not ofs_pending
+ if not allow_missing and todo:
+ raise UnresolvedDeltas(todo)
+
+ def iter_unpacked(self, include_comp=False):
+ ofs_to_entries = {
+ ofs: (sha, crc32) for (sha, ofs, crc32) in self.index.iterentries()
+ }
+ for unpacked in self.data.iter_unpacked(include_comp=include_comp):
+ (sha, crc32) = ofs_to_entries[unpacked.offset]
+ unpacked._sha = sha
+ unpacked.crc32 = crc32
+ yield unpacked
+
+ def keep(self, msg: Optional[bytes] = None) -> str:
"""Add a .keep file for the pack, preventing git from garbage collecting it.
Args:
@@ -1220,23 +2605,77 @@ class Pack:
to determine whether or not a .keep file is obsolete.
Returns: The path of the .keep file, as a string.
"""
- pass
-
- def get_ref(self, sha: bytes) ->Tuple[Optional[int], int, OldUnpackedObject
- ]:
+ keepfile_name = f"{self._basename}.keep"
+ with GitFile(keepfile_name, "wb") as keepfile:
+ if msg:
+ keepfile.write(msg)
+ keepfile.write(b"\n")
+ return keepfile_name
+
+ def get_ref(self, sha: bytes) -> Tuple[Optional[int], int, OldUnpackedObject]:
"""Get the object for a ref SHA, only looking in this pack."""
- pass
+ # TODO: cache these results
+ try:
+ offset = self.index.object_offset(sha)
+ except KeyError:
+ offset = None
+ if offset:
+ type, obj = self.data.get_object_at(offset)
+ elif self.resolve_ext_ref:
+ type, obj = self.resolve_ext_ref(sha)
+ else:
+ raise KeyError(sha)
+ return offset, type, obj
- def resolve_object(self, offset: int, type: int, obj, get_ref=None
- ) ->Tuple[int, Iterable[bytes]]:
+ def resolve_object(
+ self, offset: int, type: int, obj, get_ref=None
+ ) -> Tuple[int, Iterable[bytes]]:
"""Resolve an object, possibly resolving deltas when necessary.
Returns: Tuple with object type and contents.
"""
- pass
-
- def entries(self, progress: Optional[ProgressFn]=None) ->Iterator[
- PackIndexEntry]:
+ # Walk down the delta chain, building a stack of deltas to reach
+ # the requested object.
+ base_offset = offset
+ base_type = type
+ base_obj = obj
+ delta_stack = []
+ while base_type in DELTA_TYPES:
+ prev_offset = base_offset
+ if get_ref is None:
+ get_ref = self.get_ref
+ if base_type == OFS_DELTA:
+ (delta_offset, delta) = base_obj
+ # TODO: clean up asserts and replace with nicer error messages
+ base_offset = base_offset - delta_offset
+ base_type, base_obj = self.data.get_object_at(base_offset)
+ assert isinstance(base_type, int)
+ elif base_type == REF_DELTA:
+ (basename, delta) = base_obj
+ assert isinstance(basename, bytes) and len(basename) == 20
+ base_offset, base_type, base_obj = get_ref(basename)
+ assert isinstance(base_type, int)
+ if base_offset == prev_offset: # object is based on itself
+ raise UnresolvedDeltas(sha_to_hex(basename))
+ delta_stack.append((prev_offset, base_type, delta))
+
+ # Now grab the base object (mustn't be a delta) and apply the
+ # deltas all the way up the stack.
+ chunks = base_obj
+ for prev_offset, delta_type, delta in reversed(delta_stack):
+ chunks = apply_delta(chunks, delta)
+ # TODO(dborowitz): This can result in poor performance if
+ # large base objects are separated from deltas in the pack.
+ # We should reorganize so that we apply deltas to all
+ # objects in a chain one after the other to optimize cache
+ # performance.
+ if prev_offset is not None:
+ self.data._offset_cache[prev_offset] = base_type, chunks
+ return base_type, chunks
+
+ def entries(
+ self, progress: Optional[ProgressFn] = None
+ ) -> Iterator[PackIndexEntry]:
"""Yield entries summarizing the contents of this pack.
Args:
@@ -1244,10 +2683,13 @@ class Pack:
object count.
Returns: iterator of tuples with (sha, offset, crc32)
"""
- pass
+ return self.data.iterentries(
+ progress=progress, resolve_ext_ref=self.resolve_ext_ref
+ )
- def sorted_entries(self, progress: Optional[ProgressFn]=None) ->Iterator[
- PackIndexEntry]:
+ def sorted_entries(
+ self, progress: Optional[ProgressFn] = None
+ ) -> Iterator[PackIndexEntry]:
"""Return entries in this pack, sorted by SHA.
Args:
@@ -1255,30 +2697,88 @@ class Pack:
object count
Returns: Iterator of tuples with (sha, offset, crc32)
"""
- pass
+ return self.data.sorted_entries(
+ progress=progress, resolve_ext_ref=self.resolve_ext_ref
+ )
- def get_unpacked_object(self, sha: bytes, *, include_comp: bool=False,
- convert_ofs_delta: bool=True) ->UnpackedObject:
+ def get_unpacked_object(
+ self, sha: bytes, *, include_comp: bool = False, convert_ofs_delta: bool = True
+ ) -> UnpackedObject:
"""Get the unpacked object for a sha.
Args:
sha: SHA of object to fetch
include_comp: Whether to include compression data in UnpackedObject
"""
- pass
-
-
-def extend_pack(f: BinaryIO, object_ids: Set[ObjectID], get_raw, *,
- compression_level=-1, progress=None) ->Tuple[bytes, List]:
+ offset = self.index.object_offset(sha)
+ unpacked = self.data.get_unpacked_object_at(offset, include_comp=include_comp)
+ if unpacked.pack_type_num == OFS_DELTA and convert_ofs_delta:
+ assert isinstance(unpacked.delta_base, int)
+ unpacked.delta_base = self.index.object_sha1(offset - unpacked.delta_base)
+ unpacked.pack_type_num = REF_DELTA
+ return unpacked
+
+
+def extend_pack(
+ f: BinaryIO,
+ object_ids: Set[ObjectID],
+ get_raw,
+ *,
+ compression_level=-1,
+ progress=None,
+) -> Tuple[bytes, List]:
"""Extend a pack file with more objects.
The caller should make sure that object_ids does not contain any objects
that are already in the pack
"""
- pass
+ # Update the header with the new number of objects.
+ f.seek(0)
+ _version, num_objects = read_pack_header(f.read)
+
+ if object_ids:
+ f.seek(0)
+ write_pack_header(f.write, num_objects + len(object_ids))
+
+ # Must flush before reading (http://bugs.python.org/issue3207)
+ f.flush()
+
+ # Rescan the rest of the pack, computing the SHA with the new header.
+ new_sha = compute_file_sha(f, end_ofs=-20)
+
+ # Must reposition before writing (http://bugs.python.org/issue3207)
+ f.seek(0, os.SEEK_CUR)
+
+ extra_entries = []
+
+ # Complete the pack.
+ for i, object_id in enumerate(object_ids):
+ if progress is not None:
+ progress(
+ ("writing extra base objects: %d/%d\r" % (i, len(object_ids))).encode(
+ "ascii"
+ )
+ )
+ assert len(object_id) == 20
+ type_num, data = get_raw(object_id)
+ offset = f.tell()
+ crc32 = write_pack_object(
+ f.write,
+ type_num,
+ data,
+ sha=new_sha,
+ compression_level=compression_level,
+ )
+ extra_entries.append((object_id, offset, crc32))
+ pack_sha = new_sha.digest()
+ f.write(pack_sha)
+ return pack_sha, extra_entries
try:
- from dulwich._pack import apply_delta, bisect_find_sha
+ from dulwich._pack import ( # type: ignore
+ apply_delta, # type: ignore
+ bisect_find_sha, # type: ignore
+ )
except ImportError:
pass
diff --git a/dulwich/patch.py b/dulwich/patch.py
index dbafc30d..ae74615a 100644
--- a/dulwich/patch.py
+++ b/dulwich/patch.py
@@ -1,19 +1,41 @@
+# patch.py -- For dealing with packed-style patches.
+# Copyright (C) 2009-2013 Jelmer Vernooij <jelmer@jelmer.uk>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Classes for dealing with git am-style patches.
These patches are basically unified diffs with some extra metadata tacked
on.
"""
+
import email.parser
import time
from difflib import SequenceMatcher
from typing import BinaryIO, Optional, TextIO, Union
+
from .objects import S_ISGITLINK, Blob, Commit
from .pack import ObjectContainer
+
FIRST_FEW_BYTES = 8000
-def write_commit_patch(f, commit, contents, progress, version=None,
- encoding=None):
+def write_commit_patch(f, commit, contents, progress, version=None, encoding=None):
"""Write a individual file patch.
Args:
@@ -23,7 +45,48 @@ def write_commit_patch(f, commit, contents, progress, version=None,
Returns:
tuple with filename and contents
"""
- pass
+ encoding = encoding or getattr(f, "encoding", "ascii")
+ if isinstance(contents, str):
+ contents = contents.encode(encoding)
+ (num, total) = progress
+ f.write(
+ b"From "
+ + commit.id
+ + b" "
+ + time.ctime(commit.commit_time).encode(encoding)
+ + b"\n"
+ )
+ f.write(b"From: " + commit.author + b"\n")
+ f.write(
+ b"Date: " + time.strftime("%a, %d %b %Y %H:%M:%S %Z").encode(encoding) + b"\n"
+ )
+ f.write(
+ ("Subject: [PATCH %d/%d] " % (num, total)).encode(encoding)
+ + commit.message
+ + b"\n"
+ )
+ f.write(b"\n")
+ f.write(b"---\n")
+ try:
+ import subprocess
+
+ p = subprocess.Popen(
+ ["diffstat"], stdout=subprocess.PIPE, stdin=subprocess.PIPE
+ )
+ except (ImportError, OSError):
+ pass # diffstat not available?
+ else:
+ (diffstat, _) = p.communicate(contents)
+ f.write(diffstat)
+ f.write(b"\n")
+ f.write(contents)
+ f.write(b"-- \n")
+ if version is None:
+ from dulwich import __version__ as dulwich_version
+
+ f.write(b"Dulwich %d.%d.%d\n" % dulwich_version)
+ else:
+ f.write(version.encode(encoding) + b"\n")
def get_summary(commit):
@@ -33,22 +96,73 @@ def get_summary(commit):
commit: Commit
Returns: Summary string
"""
- pass
+ decoded = commit.message.decode(errors="replace")
+ return decoded.splitlines()[0].replace(" ", "-")
+# Unified Diff
def _format_range_unified(start, stop):
"""Convert range to the "ed" format."""
- pass
-
-
-def unified_diff(a, b, fromfile='', tofile='', fromfiledate='', tofiledate=
- '', n=3, lineterm='\n', tree_encoding='utf-8', output_encoding='utf-8'):
+ # Per the diff spec at http://www.unix.org/single_unix_specification/
+ beginning = start + 1 # lines start numbering with one
+ length = stop - start
+ if length == 1:
+ return f"{beginning}"
+ if not length:
+ beginning -= 1 # empty ranges begin at line just before the range
+ return f"{beginning},{length}"
+
+
+def unified_diff(
+ a,
+ b,
+ fromfile="",
+ tofile="",
+ fromfiledate="",
+ tofiledate="",
+ n=3,
+ lineterm="\n",
+ tree_encoding="utf-8",
+ output_encoding="utf-8",
+):
"""difflib.unified_diff that can detect "No newline at end of file" as
original "git diff" does.
Based on the same function in Python2.7 difflib.py
"""
- pass
+ started = False
+ for group in SequenceMatcher(None, a, b).get_grouped_opcodes(n):
+ if not started:
+ started = True
+ fromdate = f"\t{fromfiledate}" if fromfiledate else ""
+ todate = f"\t{tofiledate}" if tofiledate else ""
+ yield f"--- {fromfile.decode(tree_encoding)}{fromdate}{lineterm}".encode(
+ output_encoding
+ )
+ yield f"+++ {tofile.decode(tree_encoding)}{todate}{lineterm}".encode(
+ output_encoding
+ )
+
+ first, last = group[0], group[-1]
+ file1_range = _format_range_unified(first[1], last[2])
+ file2_range = _format_range_unified(first[3], last[4])
+ yield f"@@ -{file1_range} +{file2_range} @@{lineterm}".encode(output_encoding)
+
+ for tag, i1, i2, j1, j2 in group:
+ if tag == "equal":
+ for line in a[i1:i2]:
+ yield b" " + line
+ continue
+ if tag in ("replace", "delete"):
+ for line in a[i1:i2]:
+ if not line[-1:] == b"\n":
+ line += b"\n\\ No newline at end of file\n"
+ yield b"-" + line
+ if tag in ("replace", "insert"):
+ for line in b[j1:j2]:
+ if not line[-1:] == b"\n":
+ line += b"\n\\ No newline at end of file\n"
+ yield b"+" + line
def is_binary(content):
@@ -57,11 +171,24 @@ def is_binary(content):
Args:
content: Bytestring to check for binary content
"""
- pass
+ return b"\0" in content[:FIRST_FEW_BYTES]
+
+
+def shortid(hexsha):
+ if hexsha is None:
+ return b"0" * 7
+ else:
+ return hexsha[:7]
-def write_object_diff(f, store: ObjectContainer, old_file, new_file,
- diff_binary=False):
+def patch_filename(p, root):
+ if p is None:
+ return b"/dev/null"
+ else:
+ return root + b"/" + p
+
+
+def write_object_diff(f, store: ObjectContainer, old_file, new_file, diff_binary=False):
"""Write the diff for an object.
Args:
@@ -74,9 +201,51 @@ def write_object_diff(f, store: ObjectContainer, old_file, new_file,
Note: the tuple elements should be None for nonexistent files
"""
- pass
-
-
+ (old_path, old_mode, old_id) = old_file
+ (new_path, new_mode, new_id) = new_file
+ patched_old_path = patch_filename(old_path, b"a")
+ patched_new_path = patch_filename(new_path, b"b")
+
+ def content(mode, hexsha):
+ if hexsha is None:
+ return Blob.from_string(b"")
+ elif S_ISGITLINK(mode):
+ return Blob.from_string(b"Subproject commit " + hexsha + b"\n")
+ else:
+ return store[hexsha]
+
+ def lines(content):
+ if not content:
+ return []
+ else:
+ return content.splitlines()
+
+ f.writelines(
+ gen_diff_header((old_path, new_path), (old_mode, new_mode), (old_id, new_id))
+ )
+ old_content = content(old_mode, old_id)
+ new_content = content(new_mode, new_id)
+ if not diff_binary and (is_binary(old_content.data) or is_binary(new_content.data)):
+ binary_diff = (
+ b"Binary files "
+ + patched_old_path
+ + b" and "
+ + patched_new_path
+ + b" differ\n"
+ )
+ f.write(binary_diff)
+ else:
+ f.writelines(
+ unified_diff(
+ lines(old_content),
+ lines(new_content),
+ patched_old_path,
+ patched_new_path,
+ )
+ )
+
+
+# TODO(jelmer): Support writing unicode, rather than bytes.
def gen_diff_header(paths, modes, shas):
"""Write a blob diff header.
@@ -85,9 +254,31 @@ def gen_diff_header(paths, modes, shas):
modes: Tuple with old and new modes
shas: Tuple with old and new shas
"""
- pass
-
-
+ (old_path, new_path) = paths
+ (old_mode, new_mode) = modes
+ (old_sha, new_sha) = shas
+ if old_path is None and new_path is not None:
+ old_path = new_path
+ if new_path is None and old_path is not None:
+ new_path = old_path
+ old_path = patch_filename(old_path, b"a")
+ new_path = patch_filename(new_path, b"b")
+ yield b"diff --git " + old_path + b" " + new_path + b"\n"
+
+ if old_mode != new_mode:
+ if new_mode is not None:
+ if old_mode is not None:
+ yield (f"old file mode {old_mode:o}\n").encode("ascii")
+ yield (f"new file mode {new_mode:o}\n").encode("ascii")
+ else:
+ yield (f"deleted file mode {old_mode:o}\n").encode("ascii")
+ yield b"index " + shortid(old_sha) + b".." + shortid(new_sha)
+ if new_mode is not None and old_mode is not None:
+ yield (f" {new_mode:o}").encode("ascii")
+ yield b"\n"
+
+
+# TODO(jelmer): Support writing unicode, rather than bytes.
def write_blob_diff(f, old_file, new_file):
"""Write blob diff.
@@ -98,7 +289,29 @@ def write_blob_diff(f, old_file, new_file):
Note: The use of write_object_diff is recommended over this function.
"""
- pass
+ (old_path, old_mode, old_blob) = old_file
+ (new_path, new_mode, new_blob) = new_file
+ patched_old_path = patch_filename(old_path, b"a")
+ patched_new_path = patch_filename(new_path, b"b")
+
+ def lines(blob):
+ if blob is not None:
+ return blob.splitlines()
+ else:
+ return []
+
+ f.writelines(
+ gen_diff_header(
+ (old_path, new_path),
+ (old_mode, new_mode),
+ (getattr(old_blob, "id", None), getattr(new_blob, "id", None)),
+ )
+ )
+ old_contents = lines(old_blob)
+ new_contents = lines(new_blob)
+ f.writelines(
+ unified_diff(old_contents, new_contents, patched_old_path, patched_new_path)
+ )
def write_tree_diff(f, store, old_tree, new_tree, diff_binary=False):
@@ -111,11 +324,18 @@ def write_tree_diff(f, store, old_tree, new_tree, diff_binary=False):
diff_binary: Whether to diff files even if they
are considered binary files by is_binary().
"""
- pass
-
-
-def git_am_patch_split(f: Union[TextIO, BinaryIO], encoding: Optional[str]=None
- ):
+ changes = store.tree_changes(old_tree, new_tree)
+ for (oldpath, newpath), (oldmode, newmode), (oldsha, newsha) in changes:
+ write_object_diff(
+ f,
+ store,
+ (oldpath, oldmode, oldsha),
+ (newpath, newmode, newsha),
+ diff_binary=diff_binary,
+ )
+
+
+def git_am_patch_split(f: Union[TextIO, BinaryIO], encoding: Optional[str] = None):
"""Parse a git-am-style patch and split it up into bits.
Args:
@@ -123,7 +343,16 @@ def git_am_patch_split(f: Union[TextIO, BinaryIO], encoding: Optional[str]=None
encoding: Encoding to use when creating Git objects
Returns: Tuple with commit object, diff contents and git version
"""
- pass
+ encoding = encoding or getattr(f, "encoding", "ascii")
+ encoding = encoding or "ascii"
+ contents = f.read()
+ if isinstance(contents, bytes):
+ bparser = email.parser.BytesParser()
+ msg = bparser.parsebytes(contents)
+ else:
+ uparser = email.parser.Parser()
+ msg = uparser.parsestr(contents)
+ return parse_patch_message(msg, encoding)
def parse_patch_message(msg, encoding=None):
@@ -134,4 +363,41 @@ def parse_patch_message(msg, encoding=None):
encoding: Encoding to use to encode Git commits
Returns: Tuple with commit object, diff contents and git version
"""
- pass
+ c = Commit()
+ c.author = msg["from"].encode(encoding)
+ c.committer = msg["from"].encode(encoding)
+ try:
+ patch_tag_start = msg["subject"].index("[PATCH")
+ except ValueError:
+ subject = msg["subject"]
+ else:
+ close = msg["subject"].index("] ", patch_tag_start)
+ subject = msg["subject"][close + 2 :]
+ c.message = (subject.replace("\n", "") + "\n").encode(encoding)
+ first = True
+
+ body = msg.get_payload(decode=True)
+ lines = body.splitlines(True)
+ line_iter = iter(lines)
+
+ for line in line_iter:
+ if line == b"---\n":
+ break
+ if first:
+ if line.startswith(b"From: "):
+ c.author = line[len(b"From: ") :].rstrip()
+ else:
+ c.message += b"\n" + line
+ first = False
+ else:
+ c.message += line
+ diff = b""
+ for line in line_iter:
+ if line == b"-- \n":
+ break
+ diff += line
+ try:
+ version = next(line_iter).rstrip(b"\n")
+ except StopIteration:
+ version = None
+ return c, diff, version
diff --git a/dulwich/porcelain.py b/dulwich/porcelain.py
index 25aaa366..5c7ee29e 100644
--- a/dulwich/porcelain.py
+++ b/dulwich/porcelain.py
@@ -1,3 +1,23 @@
+# porcelain.py -- Porcelain-like layer on top of Dulwich
+# Copyright (C) 2013 Jelmer Vernooij <jelmer@jelmer.uk>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Simple wrapper that provides porcelain-like functions on top of Dulwich.
Currently implemented:
@@ -43,6 +63,7 @@ to the repository root.
Functions should generally accept both unicode strings and bytestrings
"""
+
import datetime
import fnmatch
import os
@@ -55,41 +76,94 @@ from contextlib import closing, contextmanager
from io import BytesIO, RawIOBase
from pathlib import Path
from typing import Dict, List, Optional, Tuple, Union
+
from .archive import tar_stream
from .client import get_transport_and_path
from .config import Config, ConfigFile, StackedConfig, read_submodules
-from .diff_tree import CHANGE_ADD, CHANGE_COPY, CHANGE_DELETE, CHANGE_MODIFY, CHANGE_RENAME, RENAME_CHANGE_TYPES
+from .diff_tree import (
+ CHANGE_ADD,
+ CHANGE_COPY,
+ CHANGE_DELETE,
+ CHANGE_MODIFY,
+ CHANGE_RENAME,
+ RENAME_CHANGE_TYPES,
+)
from .errors import SendPackError
from .file import ensure_dir_exists
from .graph import can_fast_forward
from .ignore import IgnoreFilterManager
-from .index import _fs_to_tree_path, blob_from_path_and_stat, build_file_from_blob, get_unstaged_changes, index_entry_from_stat
+from .index import (
+ _fs_to_tree_path,
+ blob_from_path_and_stat,
+ build_file_from_blob,
+ get_unstaged_changes,
+ index_entry_from_stat,
+)
from .object_store import iter_tree_contents, tree_lookup_path
-from .objects import Commit, Tag, format_timezone, parse_timezone, pretty_format_tree_entry
-from .objectspec import parse_commit, parse_object, parse_ref, parse_reftuples, parse_tree, to_bytes
+from .objects import (
+ Commit,
+ Tag,
+ format_timezone,
+ parse_timezone,
+ pretty_format_tree_entry,
+)
+from .objectspec import (
+ parse_commit,
+ parse_object,
+ parse_ref,
+ parse_reftuples,
+ parse_tree,
+ to_bytes,
+)
from .pack import write_pack_from_container, write_pack_index
from .patch import write_tree_diff
from .protocol import ZERO_SHA, Protocol
-from .refs import LOCAL_BRANCH_PREFIX, LOCAL_REMOTE_PREFIX, LOCAL_TAG_PREFIX, _import_remote_refs
+from .refs import (
+ LOCAL_BRANCH_PREFIX,
+ LOCAL_REMOTE_PREFIX,
+ LOCAL_TAG_PREFIX,
+ _import_remote_refs,
+)
from .repo import BaseRepo, Repo, get_user_identity
-from .server import FileSystemBackend, ReceivePackHandler, TCPGitServer, UploadPackHandler
+from .server import (
+ FileSystemBackend,
+ ReceivePackHandler,
+ TCPGitServer,
+ UploadPackHandler,
+)
from .server import update_server_info as server_update_server_info
-GitStatus = namedtuple('GitStatus', 'staged unstaged untracked')
+
+# Module level tuple definition for status output
+GitStatus = namedtuple("GitStatus", "staged unstaged untracked")
class NoneStream(RawIOBase):
"""Fallback if stdout or stderr are unavailable, does nothing."""
+ def read(self, size=-1):
+ return None
+
+ def readall(self):
+ return None
+
+ def readinto(self, b):
+ return None
+
+ def write(self, b):
+ return None
+
-default_bytes_out_stream = getattr(sys.stdout, 'buffer', None) or NoneStream()
-default_bytes_err_stream = getattr(sys.stderr, 'buffer', None) or NoneStream()
-DEFAULT_ENCODING = 'utf-8'
+default_bytes_out_stream = getattr(sys.stdout, "buffer", None) or NoneStream()
+default_bytes_err_stream = getattr(sys.stderr, "buffer", None) or NoneStream()
+
+
+DEFAULT_ENCODING = "utf-8"
class Error(Exception):
"""Porcelain-based error."""
- def __init__(self, msg) ->None:
+ def __init__(self, msg) -> None:
super().__init__(msg)
@@ -120,7 +194,44 @@ def parse_timezone_format(tz_str):
Raises:
TimezoneFormatError: if timezone information cannot be extracted
"""
- pass
+ import re
+
+ # Git internal format
+ internal_format_pattern = re.compile("^[0-9]+ [+-][0-9]{,4}$")
+ if re.match(internal_format_pattern, tz_str):
+ try:
+ tz_internal = parse_timezone(tz_str.split(" ")[1].encode(DEFAULT_ENCODING))
+ return tz_internal[0]
+ except ValueError:
+ pass
+
+ # RFC 2822
+ import email.utils
+
+ rfc_2822 = email.utils.parsedate_tz(tz_str)
+ if rfc_2822:
+ return rfc_2822[9]
+
+ # ISO 8601
+
+ # Supported offsets:
+ # sHHMM, sHH:MM, sHH
+ iso_8601_pattern = re.compile(
+ "[0-9] ?([+-])([0-9]{2})(?::(?=[0-9]{2}))?([0-9]{2})?$"
+ )
+ match = re.search(iso_8601_pattern, tz_str)
+ total_secs = 0
+ if match:
+ sign, hours, minutes = match.groups()
+ total_secs += int(hours) * 3600
+ if minutes:
+ total_secs += int(minutes) * 60
+ total_secs = -total_secs if sign == "-" else total_secs
+ return total_secs
+
+ # YYYY.MM.DD, MM/DD/YYYY, DD.MM.YYYY contain no timezone information
+
+ raise TimezoneFormatError(tz_str)
def get_user_timezones():
@@ -128,18 +239,31 @@ def get_user_timezones():
https://raw.githubusercontent.com/git/git/v2.3.0/Documentation/date-formats.txt
Returns: A tuple containing author timezone, committer timezone.
"""
- pass
+ local_timezone = time.localtime().tm_gmtoff
+
+ if os.environ.get("GIT_AUTHOR_DATE"):
+ author_timezone = parse_timezone_format(os.environ["GIT_AUTHOR_DATE"])
+ else:
+ author_timezone = local_timezone
+ if os.environ.get("GIT_COMMITTER_DATE"):
+ commit_timezone = parse_timezone_format(os.environ["GIT_COMMITTER_DATE"])
+ else:
+ commit_timezone = local_timezone
+
+ return author_timezone, commit_timezone
def open_repo(path_or_repo):
"""Open an argument that can be a repository or a path for a repository."""
- pass
+ if isinstance(path_or_repo, BaseRepo):
+ return path_or_repo
+ return Repo(path_or_repo)
@contextmanager
def _noop_context_manager(obj):
"""Context manager that has the same api as closing but does nothing."""
- pass
+ yield obj
def open_repo_closing(path_or_repo):
@@ -147,7 +271,9 @@ def open_repo_closing(path_or_repo):
returns a context manager that will close the repo on exit if the argument
is a path, else does nothing if the argument is a repo.
"""
- pass
+ if isinstance(path_or_repo, BaseRepo):
+ return _noop_context_manager(path_or_repo)
+ return closing(Repo(path_or_repo))
def path_to_tree_path(repopath, path, tree_encoding=DEFAULT_ENCODING):
@@ -159,13 +285,42 @@ def path_to_tree_path(repopath, path, tree_encoding=DEFAULT_ENCODING):
path: A path, absolute or relative to the cwd
Returns: A path formatted for use in e.g. an index
"""
- pass
+ # Resolve might returns a relative path on Windows
+ # https://bugs.python.org/issue38671
+ if sys.platform == "win32":
+ path = os.path.abspath(path)
+
+ path = Path(path)
+ resolved_path = path.resolve()
+
+ # Resolve and abspath seems to behave differently regarding symlinks,
+ # as we are doing abspath on the file path, we need to do the same on
+ # the repo path or they might not match
+ if sys.platform == "win32":
+ repopath = os.path.abspath(repopath)
+
+ repopath = Path(repopath).resolve()
+
+ try:
+ relpath = resolved_path.relative_to(repopath)
+ except ValueError:
+ # If path is a symlink that points to a file outside the repo, we
+ # want the relpath for the link itself, not the resolved target
+ if path.is_symlink():
+ parent = path.parent.resolve()
+ relpath = (parent / path.name).relative_to(repopath)
+ else:
+ raise
+ if sys.platform == "win32":
+ return str(relpath).replace(os.path.sep, "/").encode(tree_encoding)
+ else:
+ return bytes(relpath)
class DivergedBranches(Error):
"""Branches have diverged and fast-forward is not possible."""
- def __init__(self, current_sha, new_sha) ->None:
+ def __init__(self, current_sha, new_sha) -> None:
self.current_sha = current_sha
self.new_sha = new_sha
@@ -178,11 +333,20 @@ def check_diverged(repo, current_sha, new_sha):
current_sha: Current head sha
new_sha: New head sha
"""
- pass
+ try:
+ can = can_fast_forward(repo, current_sha, new_sha)
+ except KeyError:
+ can = False
+ if not can:
+ raise DivergedBranches(current_sha, new_sha)
-def archive(repo, committish=None, outstream=default_bytes_out_stream,
- errstream=default_bytes_err_stream):
+def archive(
+ repo,
+ committish=None,
+ outstream=default_bytes_out_stream,
+ errstream=default_bytes_err_stream,
+):
"""Create an archive.
Args:
@@ -191,16 +355,24 @@ def archive(repo, committish=None, outstream=default_bytes_out_stream,
outstream: Output stream (defaults to stdout)
errstream: Error stream (defaults to stderr)
"""
- pass
+ if committish is None:
+ committish = "HEAD"
+ with open_repo_closing(repo) as repo_obj:
+ c = parse_commit(repo_obj, committish)
+ for chunk in tar_stream(
+ repo_obj.object_store, repo_obj.object_store[c.tree], c.commit_time
+ ):
+ outstream.write(chunk)
-def update_server_info(repo='.'):
+def update_server_info(repo="."):
"""Update server info files for a repository.
Args:
repo: path to the repository
"""
- pass
+ with open_repo_closing(repo) as r:
+ server_update_server_info(r)
def symbolic_ref(repo, ref_name, force=False):
@@ -211,12 +383,36 @@ def symbolic_ref(repo, ref_name, force=False):
ref_name: short name of the new ref
force: force settings without checking if it exists in refs/heads
"""
- pass
-
-
-def commit(repo='.', message=None, author=None, author_timezone=None,
- committer=None, commit_timezone=None, encoding=None, no_verify=False,
- signoff=False):
+ with open_repo_closing(repo) as repo_obj:
+ ref_path = _make_branch_ref(ref_name)
+ if not force and ref_path not in repo_obj.refs.keys():
+ raise Error(f"fatal: ref `{ref_name}` is not a ref")
+ repo_obj.refs.set_symbolic_ref(b"HEAD", ref_path)
+
+
+def pack_refs(repo, all=False):
+ with open_repo_closing(repo) as repo_obj:
+ refs = repo_obj.refs
+ packed_refs = {
+ ref: refs[ref]
+ for ref in refs
+ if (all or ref.startswith(LOCAL_TAG_PREFIX)) and ref != b"HEAD"
+ }
+
+ refs.add_packed_refs(packed_refs)
+
+
+def commit(
+ repo=".",
+ message=None,
+ author=None,
+ author_timezone=None,
+ committer=None,
+ commit_timezone=None,
+ encoding=None,
+ no_verify=False,
+ signoff=False,
+):
"""Create a new commit.
Args:
@@ -232,7 +428,29 @@ def commit(repo='.', message=None, author=None, author_timezone=None,
pass a str containing Key ID to use a specific GPG key)
Returns: SHA1 of the new commit
"""
- pass
+ # FIXME: Support --all argument
+ if getattr(message, "encode", None):
+ message = message.encode(encoding or DEFAULT_ENCODING)
+ if getattr(author, "encode", None):
+ author = author.encode(encoding or DEFAULT_ENCODING)
+ if getattr(committer, "encode", None):
+ committer = committer.encode(encoding or DEFAULT_ENCODING)
+ local_timezone = get_user_timezones()
+ if author_timezone is None:
+ author_timezone = local_timezone[0]
+ if commit_timezone is None:
+ commit_timezone = local_timezone[1]
+ with open_repo_closing(repo) as r:
+ return r.do_commit(
+ message=message,
+ author=author,
+ author_timezone=author_timezone,
+ committer=committer,
+ commit_timezone=commit_timezone,
+ encoding=encoding,
+ no_verify=no_verify,
+ sign=signoff if isinstance(signoff, (str, bool)) else None,
+ )
def commit_tree(repo, tree, message=None, author=None, committer=None):
@@ -244,10 +462,13 @@ def commit_tree(repo, tree, message=None, author=None, committer=None):
author: Optional author name and email
committer: Optional committer name and email
"""
- pass
+ with open_repo_closing(repo) as r:
+ return r.do_commit(
+ message=message, tree=tree, committer=committer, author=author
+ )
-def init(path='.', *, bare=False, symlinks: Optional[bool]=None):
+def init(path=".", *, bare=False, symlinks: Optional[bool] = None):
"""Create a new git repository.
Args:
@@ -256,15 +477,52 @@ def init(path='.', *, bare=False, symlinks: Optional[bool]=None):
symlinks: Whether to create actual symlinks (defaults to autodetect)
Returns: A Repo instance
"""
- pass
-
-
-def clone(source, target=None, bare=False, checkout=None, errstream=
- default_bytes_err_stream, outstream=None, origin: Optional[str]=
- 'origin', depth: Optional[int]=None, branch: Optional[Union[str, bytes]
- ]=None, config: Optional[Config]=None, refspecs=None, refspec_encoding=
- DEFAULT_ENCODING, filter_spec=None, protocol_version: Optional[int]=
- None, **kwargs):
+ if not os.path.exists(path):
+ os.mkdir(path)
+
+ if bare:
+ return Repo.init_bare(path)
+ else:
+ return Repo.init(path, symlinks=symlinks)
+
+
+def encode_refspecs(refspecs, refspec_encoding):
+ if refspecs is None:
+ return [b"HEAD"]
+
+ def encode_refspec(ref):
+ if isinstance(ref, bytes):
+ return ref
+ else:
+ return ref.encode(refspec_encoding)
+
+ encoded_refs = []
+ if isinstance(refspecs, bytes) or isinstance(refspecs, str):
+ encoded_refs.append(encode_refspec(refspecs))
+ else:
+ for ref in refspecs:
+ encoded_refs.append(encode_refspec(ref))
+
+ return encoded_refs
+
+
+def clone(
+ source,
+ target=None,
+ bare=False,
+ checkout=None,
+ errstream=default_bytes_err_stream,
+ outstream=None,
+ origin: Optional[str] = "origin",
+ depth: Optional[int] = None,
+ branch: Optional[Union[str, bytes]] = None,
+ config: Optional[Config] = None,
+ refspecs=None,
+ refspec_encoding=DEFAULT_ENCODING,
+ filter_spec=None,
+ protocol_version: Optional[int] = None,
+ **kwargs,
+):
"""Clone a local or remote git repository.
Args:
@@ -290,10 +548,56 @@ def clone(source, target=None, bare=False, checkout=None, errstream=
mutually supported protocol version will be used.
Returns: The new repository
"""
- pass
+ if outstream is not None:
+ import warnings
+
+ warnings.warn(
+ "outstream= has been deprecated in favour of errstream=.",
+ DeprecationWarning,
+ stacklevel=3,
+ )
+ # TODO(jelmer): Capture logging output and stream to errstream
+
+ if config is None:
+ config = StackedConfig.default()
+
+ if checkout is None:
+ checkout = not bare
+ if checkout and bare:
+ raise Error("checkout and bare are incompatible")
+
+ encoded_refs = encode_refspecs(refspecs, refspec_encoding)
+
+ if target is None:
+ target = source.split("/")[-1]
+
+ if isinstance(branch, str):
+ branch = branch.encode(DEFAULT_ENCODING)
+
+ mkdir = not os.path.exists(target)
+ (client, path) = get_transport_and_path(source, config=config, **kwargs)
-def add(repo='.', paths=None):
+ if filter_spec:
+ filter_spec = filter_spec.encode("ascii")
+
+ return client.clone(
+ path,
+ target,
+ mkdir=mkdir,
+ bare=bare,
+ origin=origin,
+ checkout=checkout,
+ branch=branch,
+ progress=errstream.write,
+ depth=depth,
+ ref_prefix=encoded_refs,
+ filter_spec=filter_spec,
+ protocol_version=protocol_version,
+ )
+
+
+def add(repo=".", paths=None):
"""Add files to the staging area.
Args:
@@ -305,7 +609,33 @@ def add(repo='.', paths=None):
contain the path to an ignored directory (with trailing slash). Individual
files within ignored directories will not be returned.
"""
- pass
+ ignored = set()
+ with open_repo_closing(repo) as r:
+ repo_path = Path(r.path).resolve()
+ ignore_manager = IgnoreFilterManager.from_repo(r)
+ if not paths:
+ paths = list(
+ get_untracked_paths(
+ str(Path(os.getcwd()).resolve()),
+ str(repo_path),
+ r.open_index(),
+ )
+ )
+ relpaths = []
+ if not isinstance(paths, list):
+ paths = [paths]
+ for p in paths:
+ path = Path(p)
+ relpath = str(path.resolve().relative_to(repo_path))
+ # FIXME: Support patterns
+ if path.is_dir():
+ relpath = os.path.join(relpath, "")
+ if ignore_manager.is_ignored(relpath):
+ ignored.add(relpath)
+ continue
+ relpaths.append(relpath)
+ r.stage(relpaths)
+ return (relpaths, ignored)
def _is_subdir(subdir, parentdir):
@@ -314,10 +644,13 @@ def _is_subdir(subdir, parentdir):
If parentdir or subdir is a relative path, it will be disamgibuated
relative to the pwd.
"""
- pass
+ parentdir_abs = os.path.realpath(parentdir) + os.path.sep
+ subdir_abs = os.path.realpath(subdir) + os.path.sep
+ return subdir_abs.startswith(parentdir_abs)
-def clean(repo='.', target_dir=None):
+# TODO: option to remove ignored files also, in line with `git clean -fdx`
+def clean(repo=".", target_dir=None):
"""Remove any untracked files from the target directory recursively.
Equivalent to running ``git clean -fd`` in target_dir.
@@ -326,22 +659,110 @@ def clean(repo='.', target_dir=None):
repo: Repository where the files may be tracked
target_dir: Directory to clean - current directory if None
"""
- pass
+ if target_dir is None:
+ target_dir = os.getcwd()
+
+ with open_repo_closing(repo) as r:
+ if not _is_subdir(target_dir, r.path):
+ raise Error("target_dir must be in the repo's working dir")
+
+ config = r.get_config_stack()
+ config.get_boolean((b"clean",), b"requireForce", True)
+
+ # TODO(jelmer): if require_force is set, then make sure that -f, -i or
+ # -n is specified.
+
+ index = r.open_index()
+ ignore_manager = IgnoreFilterManager.from_repo(r)
+
+ paths_in_wd = _walk_working_dir_paths(target_dir, r.path)
+ # Reverse file visit order, so that files and subdirectories are
+ # removed before containing directory
+ for ap, is_dir in reversed(list(paths_in_wd)):
+ if is_dir:
+ # All subdirectories and files have been removed if untracked,
+ # so dir contains no tracked files iff it is empty.
+ is_empty = len(os.listdir(ap)) == 0
+ if is_empty:
+ os.rmdir(ap)
+ else:
+ ip = path_to_tree_path(r.path, ap)
+ is_tracked = ip in index
+ rp = os.path.relpath(ap, r.path)
+ is_ignored = ignore_manager.is_ignored(rp)
-def remove(repo='.', paths=None, cached=False):
+ if not is_tracked and not is_ignored:
+ os.remove(ap)
+
+
+def remove(repo=".", paths=None, cached=False):
"""Remove files from the staging area.
Args:
repo: Repository for the files
paths: Paths to remove
"""
- pass
+ with open_repo_closing(repo) as r:
+ index = r.open_index()
+ for p in paths:
+ full_path = os.fsencode(os.path.abspath(p))
+ tree_path = path_to_tree_path(r.path, p)
+ try:
+ index_sha = index[tree_path].sha
+ except KeyError as exc:
+ raise Error(f"{p} did not match any files") from exc
+
+ if not cached:
+ try:
+ st = os.lstat(full_path)
+ except OSError:
+ pass
+ else:
+ try:
+ blob = blob_from_path_and_stat(full_path, st)
+ except OSError:
+ pass
+ else:
+ try:
+ committed_sha = tree_lookup_path(
+ r.__getitem__, r[r.head()].tree, tree_path
+ )[1]
+ except KeyError:
+ committed_sha = None
+
+ if blob.id != index_sha and index_sha != committed_sha:
+ raise Error(
+ "file has staged content differing "
+ f"from both the file and head: {p}"
+ )
+
+ if index_sha != committed_sha:
+ raise Error(f"file has staged changes: {p}")
+ os.remove(full_path)
+ del index[tree_path]
+ index.write()
rm = remove
+def commit_decode(commit, contents, default_encoding=DEFAULT_ENCODING):
+ if commit.encoding:
+ encoding = commit.encoding.decode("ascii")
+ else:
+ encoding = default_encoding
+ return contents.decode(encoding, "replace")
+
+
+def commit_encode(commit, contents, default_encoding=DEFAULT_ENCODING):
+ if commit.encoding:
+ encoding = commit.encoding.decode("ascii")
+ else:
+ encoding = default_encoding
+ return contents.encode(encoding)
+
+
def print_commit(commit, decode, outstream=sys.stdout):
"""Write a human-readable commit log entry.
@@ -349,7 +770,25 @@ def print_commit(commit, decode, outstream=sys.stdout):
commit: A `Commit` object
outstream: A stream file to write to
"""
- pass
+ outstream.write("-" * 50 + "\n")
+ outstream.write("commit: " + commit.id.decode("ascii") + "\n")
+ if len(commit.parents) > 1:
+ outstream.write(
+ "merge: "
+ + "...".join([c.decode("ascii") for c in commit.parents[1:]])
+ + "\n"
+ )
+ outstream.write("Author: " + decode(commit.author) + "\n")
+ if commit.author != commit.committer:
+ outstream.write("Committer: " + decode(commit.committer) + "\n")
+
+ time_tuple = time.gmtime(commit.author_time + commit.author_timezone)
+ time_str = time.strftime("%a %b %d %Y %H:%M:%S", time_tuple)
+ timezone_str = format_timezone(commit.author_timezone).decode("ascii")
+ outstream.write("Date: " + time_str + " " + timezone_str + "\n")
+ outstream.write("\n")
+ outstream.write(decode(commit.message) + "\n")
+ outstream.write("\n")
def print_tag(tag, decode, outstream=sys.stdout):
@@ -360,7 +799,14 @@ def print_tag(tag, decode, outstream=sys.stdout):
decode: Function for decoding bytes to unicode string
outstream: A stream to write to
"""
- pass
+ outstream.write("Tagger: " + decode(tag.tagger) + "\n")
+ time_tuple = time.gmtime(tag.tag_time + tag.tag_timezone)
+ time_str = time.strftime("%a %b %d %Y %H:%M:%S", time_tuple)
+ timezone_str = format_timezone(tag.tag_timezone).decode("ascii")
+ outstream.write("Date: " + time_str + " " + timezone_str + "\n")
+ outstream.write("\n")
+ outstream.write(decode(tag.message))
+ outstream.write("\n")
def show_blob(repo, blob, decode, outstream=sys.stdout):
@@ -372,7 +818,7 @@ def show_blob(repo, blob, decode, outstream=sys.stdout):
decode: Function for decoding bytes to unicode string
outstream: A stream file to write to
"""
- pass
+ outstream.write(decode(blob.data))
def show_commit(repo, commit, decode, outstream=sys.stdout):
@@ -384,7 +830,16 @@ def show_commit(repo, commit, decode, outstream=sys.stdout):
decode: Function for decoding bytes to unicode string
outstream: Stream to write to
"""
- pass
+ print_commit(commit, decode=decode, outstream=outstream)
+ if commit.parents:
+ parent_commit = repo[commit.parents[0]]
+ base_tree = parent_commit.tree
+ else:
+ base_tree = None
+ diffstream = BytesIO()
+ write_tree_diff(diffstream, repo.object_store, base_tree, commit.tree)
+ diffstream.seek(0)
+ outstream.write(commit_decode(commit, diffstream.getvalue()))
def show_tree(repo, tree, decode, outstream=sys.stdout):
@@ -396,7 +851,8 @@ def show_tree(repo, tree, decode, outstream=sys.stdout):
decode: Function for decoding bytes to unicode string
outstream: Stream to write to
"""
- pass
+ for n in tree:
+ outstream.write(decode(n) + "\n")
def show_tag(repo, tag, decode, outstream=sys.stdout):
@@ -408,16 +864,56 @@ def show_tag(repo, tag, decode, outstream=sys.stdout):
decode: Function for decoding bytes to unicode string
outstream: Stream to write to
"""
- pass
+ print_tag(tag, decode, outstream)
+ show_object(repo, repo[tag.object[1]], decode, outstream)
-def print_name_status(changes):
- """Print a simple status summary, listing changed files."""
- pass
+def show_object(repo, obj, decode, outstream):
+ return {
+ b"tree": show_tree,
+ b"blob": show_blob,
+ b"commit": show_commit,
+ b"tag": show_tag,
+ }[obj.type_name](repo, obj, decode, outstream)
-def log(repo='.', paths=None, outstream=sys.stdout, max_entries=None,
- reverse=False, name_status=False):
+def print_name_status(changes):
+ """Print a simple status summary, listing changed files."""
+ for change in changes:
+ if not change:
+ continue
+ if isinstance(change, list):
+ change = change[0]
+ if change.type == CHANGE_ADD:
+ path1 = change.new.path
+ path2 = ""
+ kind = "A"
+ elif change.type == CHANGE_DELETE:
+ path1 = change.old.path
+ path2 = ""
+ kind = "D"
+ elif change.type == CHANGE_MODIFY:
+ path1 = change.new.path
+ path2 = ""
+ kind = "M"
+ elif change.type in RENAME_CHANGE_TYPES:
+ path1 = change.old.path
+ path2 = change.new.path
+ if change.type == CHANGE_RENAME:
+ kind = "R"
+ elif change.type == CHANGE_COPY:
+ kind = "C"
+ yield "%-8s%-20s%-20s" % (kind, path1, path2)
+
+
+def log(
+ repo=".",
+ paths=None,
+ outstream=sys.stdout,
+ max_entries=None,
+ reverse=False,
+ name_status=False,
+):
"""Write commit logs.
Args:
@@ -428,11 +924,27 @@ def log(repo='.', paths=None, outstream=sys.stdout, max_entries=None,
name_status: Print name status
max_entries: Optional maximum number of entries to display
"""
- pass
+ with open_repo_closing(repo) as r:
+ walker = r.get_walker(max_entries=max_entries, paths=paths, reverse=reverse)
+ for entry in walker:
+
+ def decode(x):
+ return commit_decode(entry.commit, x)
+ print_commit(entry.commit, decode, outstream)
+ if name_status:
+ outstream.writelines(
+ [line + "\n" for line in print_name_status(entry.changes())]
+ )
-def show(repo='.', objects=None, outstream=sys.stdout, default_encoding=
- DEFAULT_ENCODING):
+
+# TODO(jelmer): better default for encoding?
+def show(
+ repo=".",
+ objects=None,
+ outstream=sys.stdout,
+ default_encoding=DEFAULT_ENCODING,
+):
"""Print the changes in a commit.
Args:
@@ -442,7 +954,24 @@ def show(repo='.', objects=None, outstream=sys.stdout, default_encoding=
default_encoding: Default encoding to use if none is set in the
commit
"""
- pass
+ if objects is None:
+ objects = ["HEAD"]
+ if not isinstance(objects, list):
+ objects = [objects]
+ with open_repo_closing(repo) as r:
+ for objectish in objects:
+ o = parse_object(r, objectish)
+ if isinstance(o, Commit):
+
+ def decode(x):
+ return commit_decode(o, x, default_encoding)
+
+ else:
+
+ def decode(x):
+ return x.decode(default_encoding)
+
+ show_object(r, o, decode, outstream)
def diff_tree(repo, old_tree, new_tree, outstream=default_bytes_out_stream):
@@ -454,7 +983,8 @@ def diff_tree(repo, old_tree, new_tree, outstream=default_bytes_out_stream):
new_tree: Id of new tree
outstream: Stream to write to
"""
- pass
+ with open_repo_closing(repo) as r:
+ write_tree_diff(outstream, r.object_store, old_tree, new_tree)
def rev_list(repo, commits, outstream=sys.stdout):
@@ -465,7 +995,16 @@ def rev_list(repo, commits, outstream=sys.stdout):
commits: Commits over which to iterate
outstream: Stream to write to
"""
- pass
+ with open_repo_closing(repo) as r:
+ for entry in r.get_walker(include=[r[c].id for c in commits]):
+ outstream.write(entry.commit.id + b"\n")
+
+
+def _canonical_part(url: str) -> str:
+ name = url.rsplit("/", 1)[-1]
+ if name.endswith(".git"):
+ name = name[:-4]
+ return name
def submodule_add(repo, url, path=None, name=None):
@@ -476,7 +1015,22 @@ def submodule_add(repo, url, path=None, name=None):
url: URL of repository to add as submodule
path: Path where submodule should live
"""
- pass
+ with open_repo_closing(repo) as r:
+ if path is None:
+ path = os.path.relpath(_canonical_part(url), r.path)
+ if name is None:
+ name = path
+
+ # TODO(jelmer): Move this logic to dulwich.submodule
+ gitmodules_path = os.path.join(r.path, ".gitmodules")
+ try:
+ config = ConfigFile.from_path(gitmodules_path)
+ except FileNotFoundError:
+ config = ConfigFile()
+ config.path = gitmodules_path
+ config.set(("submodule", name), "url", url)
+ config.set(("submodule", name), "path", path)
+ config.write_to_path()
def submodule_init(repo):
@@ -485,7 +1039,13 @@ def submodule_init(repo):
Args:
repo: Path to repository
"""
- pass
+ with open_repo_closing(repo) as r:
+ config = r.get_config()
+ gitmodules_path = os.path.join(r.path, ".gitmodules")
+ for path, url, name in read_submodules(gitmodules_path):
+ config.set((b"submodule", name), b"active", True)
+ config.set((b"submodule", name), b"url", url)
+ config.write_to_path()
def submodule_list(repo):
@@ -494,12 +1054,25 @@ def submodule_list(repo):
Args:
repo: Path to repository
"""
- pass
-
-
-def tag_create(repo, tag, author=None, message=None, annotated=False,
- objectish='HEAD', tag_time=None, tag_timezone=None, sign=False,
- encoding=DEFAULT_ENCODING):
+ from .submodule import iter_cached_submodules
+
+ with open_repo_closing(repo) as r:
+ for path, sha in iter_cached_submodules(r.object_store, r[r.head()].tree):
+ yield path, sha.decode(DEFAULT_ENCODING)
+
+
+def tag_create(
+ repo,
+ tag,
+ author=None,
+ message=None,
+ annotated=False,
+ objectish="HEAD",
+ tag_time=None,
+ tag_timezone=None,
+ sign=False,
+ encoding=DEFAULT_ENCODING,
+):
"""Creates a tag in git via dulwich calls.
Args:
@@ -515,7 +1088,35 @@ def tag_create(repo, tag, author=None, message=None, annotated=False,
pass True to use default GPG key,
pass a str containing Key ID to use a specific GPG key)
"""
- pass
+ with open_repo_closing(repo) as r:
+ object = parse_object(r, objectish)
+
+ if annotated:
+ # Create the tag object
+ tag_obj = Tag()
+ if author is None:
+ author = get_user_identity(r.get_config_stack())
+ tag_obj.tagger = author
+ tag_obj.message = message + "\n".encode(encoding)
+ tag_obj.name = tag
+ tag_obj.object = (type(object), object.id)
+ if tag_time is None:
+ tag_time = int(time.time())
+ tag_obj.tag_time = tag_time
+ if tag_timezone is None:
+ tag_timezone = get_user_timezones()[1]
+ elif isinstance(tag_timezone, str):
+ tag_timezone = parse_timezone(tag_timezone)
+ tag_obj.tag_timezone = tag_timezone
+ if sign:
+ tag_obj.sign(sign if isinstance(sign, str) else None)
+
+ r.object_store.add_object(tag_obj)
+ tag_id = tag_obj.id
+ else:
+ tag_id = object.id
+
+ r.refs[_make_tag_ref(tag)] = tag_id
def tag_list(repo, outstream=sys.stdout):
@@ -525,7 +1126,9 @@ def tag_list(repo, outstream=sys.stdout):
repo: Path to repository
outstream: Stream to write tags to
"""
- pass
+ with open_repo_closing(repo) as r:
+ tags = sorted(r.refs.as_dict(b"refs/tags"))
+ return tags
def tag_delete(repo, name):
@@ -535,10 +1138,18 @@ def tag_delete(repo, name):
repo: Path to repository
name: Name of tag to remove
"""
- pass
+ with open_repo_closing(repo) as r:
+ if isinstance(name, bytes):
+ names = [name]
+ elif isinstance(name, list):
+ names = name
+ else:
+ raise Error(f"Unexpected tag name type {name!r}")
+ for name in names:
+ del r.refs[_make_tag_ref(name)]
-def reset(repo, mode, treeish='HEAD'):
+def reset(repo, mode, treeish="HEAD"):
"""Reset current HEAD to the specified state.
Args:
@@ -546,12 +1157,47 @@ def reset(repo, mode, treeish='HEAD'):
mode: Mode ("hard", "soft", "mixed")
treeish: Treeish to reset to
"""
- pass
+ if mode != "hard":
+ raise Error("hard is the only mode currently supported")
+ with open_repo_closing(repo) as r:
+ tree = parse_tree(r, treeish)
+ r.reset_index(tree.id)
-def push(repo, remote_location=None, refspecs=None, outstream=
- default_bytes_out_stream, errstream=default_bytes_err_stream, force=
- False, **kwargs):
+
+def get_remote_repo(
+ repo: Repo, remote_location: Optional[Union[str, bytes]] = None
+) -> Tuple[Optional[str], str]:
+ config = repo.get_config()
+ if remote_location is None:
+ remote_location = get_branch_remote(repo)
+ if isinstance(remote_location, str):
+ encoded_location = remote_location.encode()
+ else:
+ encoded_location = remote_location
+
+ section = (b"remote", encoded_location)
+
+ remote_name: Optional[str] = None
+
+ if config.has_section(section):
+ remote_name = encoded_location.decode()
+ encoded_location = config.get(section, "url")
+ else:
+ remote_name = None
+
+ return (remote_name, encoded_location.decode())
+
+
+def push(
+ repo,
+ remote_location=None,
+ refspecs=None,
+ outstream=default_bytes_out_stream,
+ errstream=default_bytes_err_stream,
+ force=False,
+ **kwargs,
+):
"""Remote push with dulwich via dulwich.client.
Args:
@@ -562,13 +1208,82 @@ def push(repo, remote_location=None, refspecs=None, outstream=
errstream: A stream file to write errors
force: Force overwriting refs
"""
- pass
-
-
-def pull(repo, remote_location=None, refspecs=None, outstream=
- default_bytes_out_stream, errstream=default_bytes_err_stream,
- fast_forward=True, force=False, refspec_encoding=DEFAULT_ENCODING,
- filter_spec=None, protocol_version=None, **kwargs):
+ # Open the repo
+ with open_repo_closing(repo) as r:
+ if refspecs is None:
+ refspecs = [active_branch(r)]
+ (remote_name, remote_location) = get_remote_repo(r, remote_location)
+
+ # Get the client and path
+ client, path = get_transport_and_path(
+ remote_location, config=r.get_config_stack(), **kwargs
+ )
+
+ selected_refs = []
+ remote_changed_refs = {}
+
+ def update_refs(refs):
+ selected_refs.extend(parse_reftuples(r.refs, refs, refspecs, force=force))
+ new_refs = {}
+ # TODO: Handle selected_refs == {None: None}
+ for lh, rh, force_ref in selected_refs:
+ if lh is None:
+ new_refs[rh] = ZERO_SHA
+ remote_changed_refs[rh] = None
+ else:
+ try:
+ localsha = r.refs[lh]
+ except KeyError as exc:
+ raise Error(f"No valid ref {lh} in local repository") from exc
+ if not force_ref and rh in refs:
+ check_diverged(r, refs[rh], localsha)
+ new_refs[rh] = localsha
+ remote_changed_refs[rh] = localsha
+ return new_refs
+
+ err_encoding = getattr(errstream, "encoding", None) or DEFAULT_ENCODING
+ remote_location = client.get_url(path)
+ try:
+ result = client.send_pack(
+ path,
+ update_refs,
+ generate_pack_data=r.generate_pack_data,
+ progress=errstream.write,
+ )
+ except SendPackError as exc:
+ raise Error(
+ "Push to " + remote_location + " failed -> " + exc.args[0].decode(),
+ ) from exc
+ else:
+ errstream.write(
+ b"Push to " + remote_location.encode(err_encoding) + b" successful.\n"
+ )
+
+ for ref, error in (result.ref_status or {}).items():
+ if error is not None:
+ errstream.write(
+ b"Push of ref %s failed: %s\n" % (ref, error.encode(err_encoding))
+ )
+ else:
+ errstream.write(b"Ref %s updated\n" % ref)
+
+ if remote_name is not None:
+ _import_remote_refs(r.refs, remote_name, remote_changed_refs)
+
+
+def pull(
+ repo,
+ remote_location=None,
+ refspecs=None,
+ outstream=default_bytes_out_stream,
+ errstream=default_bytes_err_stream,
+ fast_forward=True,
+ force=False,
+ refspec_encoding=DEFAULT_ENCODING,
+ filter_spec=None,
+ protocol_version=None,
+ **kwargs,
+):
"""Pull from remote via dulwich.client.
Args:
@@ -586,10 +1301,58 @@ def pull(repo, remote_location=None, refspecs=None, outstream=
protocol_version: desired Git protocol version. By default the highest
mutually supported protocol version will be used
"""
- pass
-
-
-def status(repo='.', ignored=False, untracked_files='all'):
+ # Open the repo
+ with open_repo_closing(repo) as r:
+ (remote_name, remote_location) = get_remote_repo(r, remote_location)
+
+ encoded_refs = encode_refspecs(refspecs, refspec_encoding)
+ selected_refs = []
+
+ def determine_wants(remote_refs, **kwargs):
+ selected_refs.extend(
+ parse_reftuples(remote_refs, r.refs, encoded_refs, force=force)
+ )
+ return [
+ remote_refs[lh]
+ for (lh, rh, force_ref) in selected_refs
+ if remote_refs[lh] not in r.object_store
+ ]
+
+ client, path = get_transport_and_path(
+ remote_location, config=r.get_config_stack(), **kwargs
+ )
+ if filter_spec:
+ filter_spec = filter_spec.encode("ascii")
+ fetch_result = client.fetch(
+ path,
+ r,
+ progress=errstream.write,
+ determine_wants=determine_wants,
+ ref_prefix=refspecs,
+ filter_spec=filter_spec,
+ protocol_version=protocol_version,
+ )
+ for lh, rh, force_ref in selected_refs:
+ if not force_ref and rh in r.refs:
+ try:
+ check_diverged(r, r.refs.follow(rh)[1], fetch_result.refs[lh])
+ except DivergedBranches as exc:
+ if fast_forward:
+ raise
+ else:
+ raise NotImplementedError("merge is not yet supported") from exc
+ r.refs[rh] = fetch_result.refs[lh]
+ if selected_refs:
+ r[b"HEAD"] = fetch_result.refs[selected_refs[0][1]]
+
+ # Perform 'git checkout .' - syncs staged changes
+ tree = r[b"HEAD"].tree
+ r.reset_index(tree=tree)
+ if remote_name is not None:
+ _import_remote_refs(r.refs, remote_name, fetch_result.refs)
+
+
+def status(repo=".", ignored=False, untracked_files="all"):
"""Returns staged, unstaged, and untracked changes relative to the HEAD.
Args:
@@ -608,7 +1371,30 @@ def status(repo='.', ignored=False, untracked_files='all'):
unstaged - list of unstaged paths (diff index/working-tree)
untracked - list of untracked, un-ignored & non-.git paths
"""
- pass
+ with open_repo_closing(repo) as r:
+ # 1. Get status of staged
+ tracked_changes = get_tree_changes(r)
+ # 2. Get status of unstaged
+ index = r.open_index()
+ normalizer = r.get_blob_normalizer()
+ filter_callback = normalizer.checkin_normalize
+ unstaged_changes = list(get_unstaged_changes(index, r.path, filter_callback))
+
+ untracked_paths = get_untracked_paths(
+ r.path,
+ r.path,
+ index,
+ exclude_ignored=not ignored,
+ untracked_files=untracked_files,
+ )
+ if sys.platform == "win32":
+ untracked_changes = [
+ path.replace(os.path.sep, "/") for path in untracked_paths
+ ]
+ else:
+ untracked_changes = list(untracked_paths)
+
+ return GitStatus(tracked_changes, unstaged_changes, untracked_changes)
def _walk_working_dir_paths(frompath, basepath, prune_dirnames=None):
@@ -620,11 +1406,32 @@ def _walk_working_dir_paths(frompath, basepath, prune_dirnames=None):
prune_dirnames: Optional callback to prune dirnames during os.walk
dirnames will be set to result of prune_dirnames(dirpath, dirnames)
"""
- pass
+ for dirpath, dirnames, filenames in os.walk(frompath):
+ # Skip .git and below.
+ if ".git" in dirnames:
+ dirnames.remove(".git")
+ if dirpath != basepath:
+ continue
+
+ if ".git" in filenames:
+ filenames.remove(".git")
+ if dirpath != basepath:
+ continue
+
+ if dirpath != frompath:
+ yield dirpath, True
+
+ for filename in filenames:
+ filepath = os.path.join(dirpath, filename)
+ yield filepath, False
+
+ if prune_dirnames:
+ dirnames[:] = prune_dirnames(dirpath, dirnames)
-def get_untracked_paths(frompath, basepath, index, exclude_ignored=False,
- untracked_files='all'):
+def get_untracked_paths(
+ frompath, basepath, index, exclude_ignored=False, untracked_files="all"
+):
"""Get untracked paths.
Args:
@@ -641,7 +1448,44 @@ def get_untracked_paths(frompath, basepath, index, exclude_ignored=False,
If exclude_ignored is False, only the path to an ignored directory will
be yielded, no files inside the directory will be returned
"""
- pass
+ if untracked_files == "normal":
+ raise NotImplementedError("normal is not yet supported")
+
+ if untracked_files not in ("no", "all"):
+ raise ValueError("untracked_files must be one of (no, all)")
+
+ if untracked_files == "no":
+ return
+
+ with open_repo_closing(basepath) as r:
+ ignore_manager = IgnoreFilterManager.from_repo(r)
+
+ ignored_dirs = []
+
+ def prune_dirnames(dirpath, dirnames):
+ for i in range(len(dirnames) - 1, -1, -1):
+ path = os.path.join(dirpath, dirnames[i])
+ ip = os.path.join(os.path.relpath(path, basepath), "")
+ if ignore_manager.is_ignored(ip):
+ if not exclude_ignored:
+ ignored_dirs.append(
+ os.path.join(os.path.relpath(path, frompath), "")
+ )
+ del dirnames[i]
+ return dirnames
+
+ for ap, is_dir in _walk_working_dir_paths(
+ frompath, basepath, prune_dirnames=prune_dirnames
+ ):
+ if not is_dir:
+ ip = path_to_tree_path(basepath, ap)
+ if ip not in index:
+ if not exclude_ignored or not ignore_manager.is_ignored(
+ os.path.relpath(ap, basepath)
+ ):
+ yield os.path.relpath(ap, frompath)
+
+ yield from ignored_dirs
def get_tree_changes(repo):
@@ -651,10 +1495,35 @@ def get_tree_changes(repo):
repo: repo path or object
Returns: dict with lists for each type of change
"""
- pass
-
-
-def daemon(path='.', address=None, port=None):
+ with open_repo_closing(repo) as r:
+ index = r.open_index()
+
+ # Compares the Index to the HEAD & determines changes
+ # Iterate through the changes and report add/delete/modify
+ # TODO: call out to dulwich.diff_tree somehow.
+ tracked_changes = {
+ "add": [],
+ "delete": [],
+ "modify": [],
+ }
+ try:
+ tree_id = r[b"HEAD"].tree
+ except KeyError:
+ tree_id = None
+
+ for change in index.changes_from_tree(r.object_store, tree_id):
+ if not change[0][0]:
+ tracked_changes["add"].append(change[0][1])
+ elif not change[0][1]:
+ tracked_changes["delete"].append(change[0][0])
+ elif change[0][0] == change[0][1]:
+ tracked_changes["modify"].append(change[0][0])
+ else:
+ raise NotImplementedError("git mv ops not yet supported")
+ return tracked_changes
+
+
+def daemon(path=".", address=None, port=None):
"""Run a daemon serving Git requests over TCP/IP.
Args:
@@ -662,10 +1531,13 @@ def daemon(path='.', address=None, port=None):
address: Optional address to listen on (defaults to ::)
port: Optional port to listen on (defaults to TCP_GIT_PORT)
"""
- pass
+ # TODO(jelmer): Support git-daemon-export-ok and --export-all.
+ backend = FileSystemBackend(path)
+ server = TCPGitServer(backend, address, port)
+ server.serve_forever()
-def web_daemon(path='.', address=None, port=None):
+def web_daemon(path=".", address=None, port=None):
"""Run a daemon serving Git requests over HTTP.
Args:
@@ -673,10 +1545,26 @@ def web_daemon(path='.', address=None, port=None):
address: Optional address to listen on (defaults to ::)
port: Optional port to listen on (defaults to 80)
"""
- pass
-
-
-def upload_pack(path='.', inf=None, outf=None):
+ from .web import (
+ WSGIRequestHandlerLogger,
+ WSGIServerLogger,
+ make_server,
+ make_wsgi_chain,
+ )
+
+ backend = FileSystemBackend(path)
+ app = make_wsgi_chain(backend)
+ server = make_server(
+ address,
+ port,
+ app,
+ handler_class=WSGIRequestHandlerLogger,
+ server_class=WSGIServerLogger,
+ )
+ server.serve_forever()
+
+
+def upload_pack(path=".", inf=None, outf=None):
"""Upload a pack file after negotiating its contents using smart protocol.
Args:
@@ -684,10 +1572,25 @@ def upload_pack(path='.', inf=None, outf=None):
inf: Input stream to communicate with client
outf: Output stream to communicate with client
"""
- pass
+ if outf is None:
+ outf = getattr(sys.stdout, "buffer", sys.stdout)
+ if inf is None:
+ inf = getattr(sys.stdin, "buffer", sys.stdin)
+ path = os.path.expanduser(path)
+ backend = FileSystemBackend(path)
+
+ def send_fn(data):
+ outf.write(data)
+ outf.flush()
+ proto = Protocol(inf.read, send_fn)
+ handler = UploadPackHandler(backend, [path], proto)
+ # FIXME: Catch exceptions and write a single-line summary to outf.
+ handler.handle()
+ return 0
-def receive_pack(path='.', inf=None, outf=None):
+
+def receive_pack(path=".", inf=None, outf=None):
"""Receive a pack file after negotiating its contents using smart protocol.
Args:
@@ -695,7 +1598,34 @@ def receive_pack(path='.', inf=None, outf=None):
inf: Input stream to communicate with client
outf: Output stream to communicate with client
"""
- pass
+ if outf is None:
+ outf = getattr(sys.stdout, "buffer", sys.stdout)
+ if inf is None:
+ inf = getattr(sys.stdin, "buffer", sys.stdin)
+ path = os.path.expanduser(path)
+ backend = FileSystemBackend(path)
+
+ def send_fn(data):
+ outf.write(data)
+ outf.flush()
+
+ proto = Protocol(inf.read, send_fn)
+ handler = ReceivePackHandler(backend, [path], proto)
+ # FIXME: Catch exceptions and write a single-line summary to outf.
+ handler.handle()
+ return 0
+
+
+def _make_branch_ref(name):
+ if getattr(name, "encode", None):
+ name = name.encode(DEFAULT_ENCODING)
+ return LOCAL_BRANCH_PREFIX + name
+
+
+def _make_tag_ref(name):
+ if getattr(name, "encode", None):
+ name = name.encode(DEFAULT_ENCODING)
+ return LOCAL_TAG_PREFIX + name
def branch_delete(repo, name):
@@ -705,7 +1635,13 @@ def branch_delete(repo, name):
repo: Path to the repository
name: Name of the branch
"""
- pass
+ with open_repo_closing(repo) as r:
+ if isinstance(name, list):
+ names = name
+ else:
+ names = [name]
+ for name in names:
+ del r.refs[_make_branch_ref(name)]
def branch_create(repo, name, objectish=None, force=False):
@@ -717,7 +1653,17 @@ def branch_create(repo, name, objectish=None, force=False):
objectish: Target object to point new branch at (defaults to HEAD)
force: Force creation of branch, even if it already exists
"""
- pass
+ with open_repo_closing(repo) as r:
+ if objectish is None:
+ objectish = "HEAD"
+ object = parse_object(r, objectish)
+ refname = _make_branch_ref(name)
+ ref_message = b"branch: Created from " + objectish.encode(DEFAULT_ENCODING)
+ if force:
+ r.refs.set_if_equals(refname, None, object.id, message=ref_message)
+ else:
+ if not r.refs.add_if_new(refname, object.id, message=ref_message):
+ raise Error(f"Branch with name {name} already exists.")
def branch_list(repo):
@@ -726,7 +1672,8 @@ def branch_list(repo):
Args:
repo: Path to the repository
"""
- pass
+ with open_repo_closing(repo) as r:
+ return r.refs.keys(base=LOCAL_BRANCH_PREFIX)
def active_branch(repo):
@@ -740,7 +1687,11 @@ def active_branch(repo):
KeyError: if the repository does not have a working tree
IndexError: if HEAD is floating
"""
- pass
+ with open_repo_closing(repo) as r:
+ active_ref = r.refs.follow(b"HEAD")[0][1]
+ if not active_ref.startswith(LOCAL_BRANCH_PREFIX):
+ raise ValueError(active_ref)
+ return active_ref[len(LOCAL_BRANCH_PREFIX) :]
def get_branch_remote(repo):
@@ -753,12 +1704,28 @@ def get_branch_remote(repo):
Raises:
KeyError: if the repository does not have a working tree
"""
- pass
-
-
-def fetch(repo, remote_location=None, outstream=sys.stdout, errstream=
- default_bytes_err_stream, message=None, depth=None, prune=False,
- prune_tags=False, force=False, **kwargs):
+ with open_repo_closing(repo) as r:
+ branch_name = active_branch(r.path)
+ config = r.get_config()
+ try:
+ remote_name = config.get((b"branch", branch_name), b"remote")
+ except KeyError:
+ remote_name = b"origin"
+ return remote_name
+
+
+def fetch(
+ repo,
+ remote_location=None,
+ outstream=sys.stdout,
+ errstream=default_bytes_err_stream,
+ message=None,
+ depth=None,
+ prune=False,
+ prune_tags=False,
+ force=False,
+ **kwargs,
+):
"""Fetch objects from a remote server.
Args:
@@ -773,11 +1740,30 @@ def fetch(repo, remote_location=None, outstream=sys.stdout, errstream=
Returns:
Dictionary with refs on the remote
"""
- pass
-
-
-def for_each_ref(repo: Union[Repo, str]='.', pattern: Optional[Union[str,
- bytes]]=None) ->List[Tuple[bytes, bytes, bytes]]:
+ with open_repo_closing(repo) as r:
+ (remote_name, remote_location) = get_remote_repo(r, remote_location)
+ if message is None:
+ message = b"fetch: from " + remote_location.encode(DEFAULT_ENCODING)
+ client, path = get_transport_and_path(
+ remote_location, config=r.get_config_stack(), **kwargs
+ )
+ fetch_result = client.fetch(path, r, progress=errstream.write, depth=depth)
+ if remote_name is not None:
+ _import_remote_refs(
+ r.refs,
+ remote_name,
+ fetch_result.refs,
+ message,
+ prune=prune,
+ prune_tags=prune_tags,
+ )
+ return fetch_result
+
+
+def for_each_ref(
+ repo: Union[Repo, str] = ".",
+ pattern: Optional[Union[str, bytes]] = None,
+) -> List[Tuple[bytes, bytes, bytes]]:
"""Iterate over all refs that match the (optional) pattern.
Args:
@@ -786,10 +1772,49 @@ def for_each_ref(repo: Union[Repo, str]='.', pattern: Optional[Union[str,
Returns:
List of bytes tuples with: (sha, object_type, ref_name)
"""
- pass
+ if isinstance(pattern, str):
+ pattern = os.fsencode(pattern)
+
+ with open_repo_closing(repo) as r:
+ refs = r.get_refs()
+
+ if pattern:
+ matching_refs: Dict[bytes, bytes] = {}
+ pattern_parts = pattern.split(b"/")
+ for ref, sha in refs.items():
+ matches = False
+
+ # git for-each-ref uses glob (7) style patterns, but fnmatch
+ # is greedy and also matches slashes, unlike glob.glob.
+ # We have to check parts of the pattern individually.
+ # See https://github.com/python/cpython/issues/72904
+ ref_parts = ref.split(b"/")
+ if len(ref_parts) > len(pattern_parts):
+ continue
+
+ for pat, ref_part in zip(pattern_parts, ref_parts):
+ matches = fnmatch.fnmatchcase(ref_part, pat)
+ if not matches:
+ break
+
+ if matches:
+ matching_refs[ref] = sha
+
+ refs = matching_refs
+
+ ret: List[Tuple[bytes, bytes, bytes]] = [
+ (sha, r.get_object(sha).type_name, ref)
+ for ref, sha in sorted(
+ refs.items(),
+ key=lambda ref_sha: ref_sha[0],
+ )
+ if ref != b"HEAD"
+ ]
+ return ret
-def ls_remote(remote, config: Optional[Config]=None, **kwargs):
+
+def ls_remote(remote, config: Optional[Config] = None, **kwargs):
"""List the refs in a remote.
Args:
@@ -798,7 +1823,10 @@ def ls_remote(remote, config: Optional[Config]=None, **kwargs):
Returns:
Dictionary with remote refs
"""
- pass
+ if config is None:
+ config = StackedConfig.default()
+ client, host_path = get_transport_and_path(remote, config=config, **kwargs)
+ return client.get_refs(host_path)
def repack(repo):
@@ -809,11 +1837,19 @@ def repack(repo):
Args:
repo: Path to the repository
"""
- pass
+ with open_repo_closing(repo) as r:
+ r.object_store.pack_loose_objects()
-def pack_objects(repo, object_ids, packf, idxf, delta_window_size=None,
- deltify=None, reuse_deltas=True):
+def pack_objects(
+ repo,
+ object_ids,
+ packf,
+ idxf,
+ delta_window_size=None,
+ deltify=None,
+ reuse_deltas=True,
+):
"""Pack objects into a file.
Args:
@@ -826,11 +1862,27 @@ def pack_objects(repo, object_ids, packf, idxf, delta_window_size=None,
deltify: Whether to deltify objects
reuse_deltas: Allow reuse of existing deltas while deltifying
"""
- pass
-
-
-def ls_tree(repo, treeish=b'HEAD', outstream=sys.stdout, recursive=False,
- name_only=False):
+ with open_repo_closing(repo) as r:
+ entries, data_sum = write_pack_from_container(
+ packf.write,
+ r.object_store,
+ [(oid, None) for oid in object_ids],
+ deltify=deltify,
+ delta_window_size=delta_window_size,
+ reuse_deltas=reuse_deltas,
+ )
+ if idxf is not None:
+ entries = sorted([(k, v[0], v[1]) for (k, v) in entries.items()])
+ write_pack_index(idxf, entries, data_sum)
+
+
+def ls_tree(
+ repo,
+ treeish=b"HEAD",
+ outstream=sys.stdout,
+ recursive=False,
+ name_only=False,
+):
"""List contents of a tree.
Args:
@@ -840,7 +1892,21 @@ def ls_tree(repo, treeish=b'HEAD', outstream=sys.stdout, recursive=False,
recursive: Whether to recursively list files
name_only: Only print item name
"""
- pass
+
+ def list_tree(store, treeid, base):
+ for name, mode, sha in store[treeid].iteritems():
+ if base:
+ name = posixpath.join(base, name)
+ if name_only:
+ outstream.write(name + b"\n")
+ else:
+ outstream.write(pretty_format_tree_entry(name, mode, sha))
+ if stat.S_ISDIR(mode) and recursive:
+ list_tree(store, sha, name)
+
+ with open_repo_closing(repo) as r:
+ tree = parse_tree(r, treeish)
+ list_tree(r.object_store, tree.id, "")
def remote_add(repo: Repo, name: Union[bytes, str], url: Union[bytes, str]):
@@ -851,7 +1917,17 @@ def remote_add(repo: Repo, name: Union[bytes, str], url: Union[bytes, str]):
name: Remote name
url: Remote URL
"""
- pass
+ if not isinstance(name, bytes):
+ name = name.encode(DEFAULT_ENCODING)
+ if not isinstance(url, bytes):
+ url = url.encode(DEFAULT_ENCODING)
+ with open_repo_closing(repo) as r:
+ c = r.get_config()
+ section = (b"remote", name)
+ if c.has_section(section):
+ raise RemoteExists(section)
+ c.set(section, b"url", url)
+ c.write_to_path()
def remote_remove(repo: Repo, name: Union[bytes, str]):
@@ -861,7 +1937,13 @@ def remote_remove(repo: Repo, name: Union[bytes, str]):
repo: Path to the repository
name: Remote name
"""
- pass
+ if not isinstance(name, bytes):
+ name = name.encode(DEFAULT_ENCODING)
+ with open_repo_closing(repo) as r:
+ c = r.get_config()
+ section = (b"remote", name)
+ del c[section]
+ c.write_to_path()
def check_ignore(repo, paths, no_index=False):
@@ -873,7 +1955,16 @@ def check_ignore(repo, paths, no_index=False):
no_index: Don't check index
Returns: List of ignored files
"""
- pass
+ with open_repo_closing(repo) as r:
+ index = r.open_index()
+ ignore_manager = IgnoreFilterManager.from_repo(r)
+ for path in paths:
+ if not no_index and path_to_tree_path(r.path, path) in index:
+ continue
+ if os.path.isabs(path):
+ path = os.path.relpath(path, r.path)
+ if ignore_manager.is_ignored(path):
+ yield path
def update_head(repo, target, detached=False, new_branch=None):
@@ -887,10 +1978,24 @@ def update_head(repo, target, detached=False, new_branch=None):
target: Branch or committish to switch to
new_branch: New branch to create
"""
- pass
-
-
-def reset_file(repo, file_path: str, target: bytes=b'HEAD', symlink_fn=None):
+ with open_repo_closing(repo) as r:
+ if new_branch is not None:
+ to_set = _make_branch_ref(new_branch)
+ else:
+ to_set = b"HEAD"
+ if detached:
+ # TODO(jelmer): Provide some way so that the actual ref gets
+ # updated rather than what it points to, so the delete isn't
+ # necessary.
+ del r.refs[to_set]
+ r.refs[to_set] = parse_commit(r, target).id
+ else:
+ r.refs.set_symbolic_ref(to_set, parse_ref(r, target))
+ if new_branch is not None:
+ r.refs.set_symbolic_ref(b"HEAD", to_set)
+
+
+def reset_file(repo, file_path: str, target: bytes = b"HEAD", symlink_fn=None):
"""Reset the file to specific commit or branch.
Args:
@@ -898,10 +2003,43 @@ def reset_file(repo, file_path: str, target: bytes=b'HEAD', symlink_fn=None):
file_path: file to reset, relative to the repository path
target: branch or commit or b'HEAD' to reset
"""
- pass
-
-
-def checkout_branch(repo, target: Union[bytes, str], force: bool=False):
+ tree = parse_tree(repo, treeish=target)
+ tree_path = _fs_to_tree_path(file_path)
+
+ file_entry = tree.lookup_path(repo.object_store.__getitem__, tree_path)
+ full_path = os.path.join(os.fsencode(repo.path), tree_path)
+ blob = repo.object_store[file_entry[1]]
+ mode = file_entry[0]
+ build_file_from_blob(blob, mode, full_path, symlink_fn=symlink_fn)
+
+
+def _update_head_during_checkout_branch(repo, target):
+ checkout_target = None
+ if target == b"HEAD": # Do not update head while trying to checkout to HEAD.
+ pass
+ elif target in repo.refs.keys(base=LOCAL_BRANCH_PREFIX):
+ update_head(repo, target)
+ else:
+ # If checking out a remote branch, create a local one without the remote name prefix.
+ config = repo.get_config()
+ name = target.split(b"/")[0]
+ section = (b"remote", name)
+ if config.has_section(section):
+ checkout_target = target.replace(name + b"/", b"")
+ try:
+ branch_create(
+ repo, checkout_target, (LOCAL_REMOTE_PREFIX + target).decode()
+ )
+ except Error:
+ pass
+ update_head(repo, LOCAL_BRANCH_PREFIX + checkout_target)
+ else:
+ update_head(repo, target, detached=True)
+
+ return checkout_target
+
+
+def checkout_branch(repo, target: Union[bytes, str], force: bool = False):
"""Switch branches or restore working tree files.
The implementation of this function will probably not scale well
@@ -914,7 +2052,78 @@ def checkout_branch(repo, target: Union[bytes, str], force: bool=False):
target: branch name or commit sha to checkout
force: true or not to force checkout
"""
- pass
+ target = to_bytes(target)
+
+ current_tree = parse_tree(repo, repo.head())
+ target_tree = parse_tree(repo, target)
+
+ if force:
+ repo.reset_index(target_tree.id)
+ _update_head_during_checkout_branch(repo, target)
+ else:
+ status_report = status(repo)
+ changes = list(
+ set(
+ status_report[0]["add"]
+ + status_report[0]["delete"]
+ + status_report[0]["modify"]
+ + status_report[1]
+ )
+ )
+ index = 0
+ while index < len(changes):
+ change = changes[index]
+ try:
+ current_tree.lookup_path(repo.object_store.__getitem__, change)
+ try:
+ target_tree.lookup_path(repo.object_store.__getitem__, change)
+ index += 1
+ except KeyError:
+ raise CheckoutError(
+ "Your local changes to the following files would be overwritten by checkout: "
+ + change.decode()
+ )
+ except KeyError:
+ changes.pop(index)
+
+ # Update head.
+ checkout_target = _update_head_during_checkout_branch(repo, target)
+ if checkout_target is not None:
+ target_tree = parse_tree(repo, checkout_target)
+
+ dealt_with = set()
+ repo_index = repo.open_index()
+ for entry in iter_tree_contents(repo.object_store, target_tree.id):
+ dealt_with.add(entry.path)
+ if entry.path in changes:
+ continue
+ full_path = os.path.join(os.fsencode(repo.path), entry.path)
+ blob = repo.object_store[entry.sha]
+ ensure_dir_exists(os.path.dirname(full_path))
+ st = build_file_from_blob(blob, entry.mode, full_path)
+ repo_index[entry.path] = index_entry_from_stat(st, entry.sha)
+
+ repo_index.write()
+
+ for entry in iter_tree_contents(repo.object_store, current_tree.id):
+ if entry.path not in dealt_with:
+ repo.unstage([entry.path])
+
+ # Remove the untracked files which are in the current_file_set.
+ repo_index = repo.open_index()
+ for change in repo_index.changes_from_tree(repo.object_store, current_tree.id):
+ path_change = change[0]
+ if path_change[1] is None:
+ file_name = path_change[0]
+ full_path = os.path.join(repo.path, file_name.decode())
+ if os.path.isfile(full_path):
+ os.remove(full_path)
+ dir_path = os.path.dirname(full_path)
+ while dir_path != repo.path:
+ is_empty = len(os.listdir(dir_path)) == 0
+ if is_empty:
+ os.rmdir(dir_path)
+ dir_path = os.path.dirname(dir_path)
def check_mailmap(repo, contact):
@@ -925,7 +2134,14 @@ def check_mailmap(repo, contact):
contact: Contact name and/or email
Returns: Canonical contact data
"""
- pass
+ with open_repo_closing(repo) as r:
+ from .mailmap import Mailmap
+
+ try:
+ mailmap = Mailmap.from_path(os.path.join(r.path, ".mailmap"))
+ except FileNotFoundError:
+ mailmap = Mailmap()
+ return mailmap.lookup(contact)
def fsck(repo):
@@ -935,37 +2151,65 @@ def fsck(repo):
repo: A path to the repository
Returns: Iterator over errors/warnings
"""
- pass
+ with open_repo_closing(repo) as r:
+ # TODO(jelmer): check pack files
+ # TODO(jelmer): check graph
+ # TODO(jelmer): check refs
+ for sha in r.object_store:
+ o = r.object_store[sha]
+ try:
+ o.check()
+ except Exception as e:
+ yield (sha, e)
def stash_list(repo):
"""List all stashes in a repository."""
- pass
+ with open_repo_closing(repo) as r:
+ from .stash import Stash
+
+ stash = Stash.from_repo(r)
+ return enumerate(list(stash.stashes()))
def stash_push(repo):
"""Push a new stash onto the stack."""
- pass
+ with open_repo_closing(repo) as r:
+ from .stash import Stash
+
+ stash = Stash.from_repo(r)
+ stash.push()
def stash_pop(repo, index):
"""Pop a stash from the stack."""
- pass
+ with open_repo_closing(repo) as r:
+ from .stash import Stash
+
+ stash = Stash.from_repo(r)
+ stash.pop(index)
def stash_drop(repo, index):
"""Drop a stash from the stack."""
- pass
+ with open_repo_closing(repo) as r:
+ from .stash import Stash
+
+ stash = Stash.from_repo(r)
+ stash.drop(index)
def ls_files(repo):
"""List all files in an index."""
- pass
+ with open_repo_closing(repo) as r:
+ return sorted(r.open_index())
def find_unique_abbrev(object_store, object_id):
"""For now, just return 7 characters."""
- pass
+ # TODO(jelmer): Add some logic here to return a number of characters that
+ # scales relative with the size of the repository
+ return object_id.decode("ascii")[:7]
def describe(repo, abbrev=7):
@@ -978,7 +2222,64 @@ def describe(repo, abbrev=7):
Examples: "gabcdefh", "v0.1" or "v0.1-5-gabcdefh".
"""
- pass
+ # Get the repository
+ with open_repo_closing(repo) as r:
+ # Get a list of all tags
+ refs = r.get_refs()
+ tags = {}
+ for key, value in refs.items():
+ key = key.decode()
+ obj = r.get_object(value)
+ if "tags" not in key:
+ continue
+
+ _, tag = key.rsplit("/", 1)
+
+ try:
+ commit = obj.object
+ except AttributeError:
+ continue
+ else:
+ commit = r.get_object(commit[1])
+ tags[tag] = [
+ datetime.datetime(*time.gmtime(commit.commit_time)[:6]),
+ commit.id.decode("ascii"),
+ ]
+
+ sorted_tags = sorted(tags.items(), key=lambda tag: tag[1][0], reverse=True)
+
+ # If there are no tags, return the current commit
+ if len(sorted_tags) == 0:
+ return f"g{find_unique_abbrev(r.object_store, r[r.head()].id)}"
+
+ # We're now 0 commits from the top
+ commit_count = 0
+
+ # Get the latest commit
+ latest_commit = r[r.head()]
+
+ # Walk through all commits
+ walker = r.get_walker()
+ for entry in walker:
+ # Check if tag
+ commit_id = entry.commit.id.decode("ascii")
+ for tag in sorted_tags:
+ tag_name = tag[0]
+ tag_commit = tag[1][1]
+ if commit_id == tag_commit:
+ if commit_count == 0:
+ return tag_name
+ else:
+ return "{}-{}-g{}".format(
+ tag_name,
+ commit_count,
+ latest_commit.id.decode("ascii")[:abbrev],
+ )
+
+ commit_count += 1
+
+ # Return plain commit if no parent tag can be found
+ return "g{}".format(latest_commit.id.decode("ascii")[:abbrev])
def get_object_by_path(repo, path, committish=None):
@@ -990,7 +2291,16 @@ def get_object_by_path(repo, path, committish=None):
committish: Commit to look up path in
Returns: A `ShaFile` object
"""
- pass
+ if committish is None:
+ committish = "HEAD"
+ # Get the repository
+ with open_repo_closing(repo) as r:
+ commit = parse_commit(r, committish)
+ base_tree = commit.tree
+ if not isinstance(path, bytes):
+ path = commit_encode(commit, path)
+ (mode, sha) = tree_lookup_path(r.object_store.__getitem__, base_tree, path)
+ return r[sha]
def write_tree(repo):
@@ -1000,4 +2310,5 @@ def write_tree(repo):
repo: Repository for which to write tree
Returns: tree id for the tree that was written
"""
- pass
+ with open_repo_closing(repo) as r:
+ return r.open_index().commit(r.object_store)
diff --git a/dulwich/protocol.py b/dulwich/protocol.py
index 00409a50..7b489d2e 100644
--- a/dulwich/protocol.py
+++ b/dulwich/protocol.py
@@ -1,62 +1,175 @@
+# protocol.py -- Shared parts of the git protocols
+# Copyright (C) 2008 John Carr <john.carr@unrouted.co.uk>
+# Copyright (C) 2008-2012 Jelmer Vernooij <jelmer@jelmer.uk>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Generic functions for talking the git smart server protocol."""
+
from io import BytesIO
from os import SEEK_END
+
import dulwich
+
from .errors import GitProtocolError, HangupException
+
TCP_GIT_PORT = 9418
+
+# Git protocol version 0 is the original Git protocol, which lacked a
+# version number until Git protocol version 1 was introduced by Brandon
+# Williams in 2017.
+#
+# Protocol version 1 is simply the original v0 protocol with the addition of
+# a single packet line, which precedes the ref advertisement, indicating the
+# protocol version being used. This was done in preparation for protocol v2.
+#
+# Git protocol version 2 was first introduced by Brandon Williams in 2018 and
+# adds many features. See the gitprotocol-v2(5) manual page for details.
+# As of 2024, Git only implements version 2 during 'git fetch' and still uses
+# version 0 during 'git push'.
GIT_PROTOCOL_VERSIONS = [0, 1, 2]
DEFAULT_GIT_PROTOCOL_VERSION_FETCH = 2
DEFAULT_GIT_PROTOCOL_VERSION_SEND = 0
-ZERO_SHA = b'0' * 40
+
+ZERO_SHA = b"0" * 40
+
SINGLE_ACK = 0
MULTI_ACK = 1
MULTI_ACK_DETAILED = 2
+
+# pack data
SIDE_BAND_CHANNEL_DATA = 1
+# progress messages
SIDE_BAND_CHANNEL_PROGRESS = 2
+# fatal error message just before stream aborts
SIDE_BAND_CHANNEL_FATAL = 3
-CAPABILITY_ATOMIC = b'atomic'
-CAPABILITY_DEEPEN_SINCE = b'deepen-since'
-CAPABILITY_DEEPEN_NOT = b'deepen-not'
-CAPABILITY_DEEPEN_RELATIVE = b'deepen-relative'
-CAPABILITY_DELETE_REFS = b'delete-refs'
-CAPABILITY_INCLUDE_TAG = b'include-tag'
-CAPABILITY_MULTI_ACK = b'multi_ack'
-CAPABILITY_MULTI_ACK_DETAILED = b'multi_ack_detailed'
-CAPABILITY_NO_DONE = b'no-done'
-CAPABILITY_NO_PROGRESS = b'no-progress'
-CAPABILITY_OFS_DELTA = b'ofs-delta'
-CAPABILITY_QUIET = b'quiet'
-CAPABILITY_REPORT_STATUS = b'report-status'
-CAPABILITY_SHALLOW = b'shallow'
-CAPABILITY_SIDE_BAND = b'side-band'
-CAPABILITY_SIDE_BAND_64K = b'side-band-64k'
-CAPABILITY_THIN_PACK = b'thin-pack'
-CAPABILITY_AGENT = b'agent'
-CAPABILITY_SYMREF = b'symref'
-CAPABILITY_ALLOW_TIP_SHA1_IN_WANT = b'allow-tip-sha1-in-want'
-CAPABILITY_ALLOW_REACHABLE_SHA1_IN_WANT = b'allow-reachable-sha1-in-want'
-CAPABILITY_FETCH = b'fetch'
-CAPABILITY_FILTER = b'filter'
-CAPABILITIES_REF = b'capabilities^{}'
-COMMON_CAPABILITIES = [CAPABILITY_OFS_DELTA, CAPABILITY_SIDE_BAND,
- CAPABILITY_SIDE_BAND_64K, CAPABILITY_AGENT, CAPABILITY_NO_PROGRESS]
-KNOWN_UPLOAD_CAPABILITIES = set([*COMMON_CAPABILITIES, CAPABILITY_THIN_PACK,
- CAPABILITY_MULTI_ACK, CAPABILITY_MULTI_ACK_DETAILED,
- CAPABILITY_INCLUDE_TAG, CAPABILITY_DEEPEN_SINCE, CAPABILITY_SYMREF,
- CAPABILITY_SHALLOW, CAPABILITY_DEEPEN_NOT, CAPABILITY_DEEPEN_RELATIVE,
- CAPABILITY_ALLOW_TIP_SHA1_IN_WANT,
- CAPABILITY_ALLOW_REACHABLE_SHA1_IN_WANT, CAPABILITY_FETCH])
-KNOWN_RECEIVE_CAPABILITIES = set([*COMMON_CAPABILITIES,
- CAPABILITY_REPORT_STATUS, CAPABILITY_DELETE_REFS, CAPABILITY_QUIET,
- CAPABILITY_ATOMIC])
-DEPTH_INFINITE = 2147483647
-NAK_LINE = b'NAK\n'
-COMMAND_DEEPEN = b'deepen'
-COMMAND_SHALLOW = b'shallow'
-COMMAND_UNSHALLOW = b'unshallow'
-COMMAND_DONE = b'done'
-COMMAND_WANT = b'want'
-COMMAND_HAVE = b'have'
+
+CAPABILITY_ATOMIC = b"atomic"
+CAPABILITY_DEEPEN_SINCE = b"deepen-since"
+CAPABILITY_DEEPEN_NOT = b"deepen-not"
+CAPABILITY_DEEPEN_RELATIVE = b"deepen-relative"
+CAPABILITY_DELETE_REFS = b"delete-refs"
+CAPABILITY_INCLUDE_TAG = b"include-tag"
+CAPABILITY_MULTI_ACK = b"multi_ack"
+CAPABILITY_MULTI_ACK_DETAILED = b"multi_ack_detailed"
+CAPABILITY_NO_DONE = b"no-done"
+CAPABILITY_NO_PROGRESS = b"no-progress"
+CAPABILITY_OFS_DELTA = b"ofs-delta"
+CAPABILITY_QUIET = b"quiet"
+CAPABILITY_REPORT_STATUS = b"report-status"
+CAPABILITY_SHALLOW = b"shallow"
+CAPABILITY_SIDE_BAND = b"side-band"
+CAPABILITY_SIDE_BAND_64K = b"side-band-64k"
+CAPABILITY_THIN_PACK = b"thin-pack"
+CAPABILITY_AGENT = b"agent"
+CAPABILITY_SYMREF = b"symref"
+CAPABILITY_ALLOW_TIP_SHA1_IN_WANT = b"allow-tip-sha1-in-want"
+CAPABILITY_ALLOW_REACHABLE_SHA1_IN_WANT = b"allow-reachable-sha1-in-want"
+CAPABILITY_FETCH = b"fetch"
+CAPABILITY_FILTER = b"filter"
+
+# Magic ref that is used to attach capabilities to when
+# there are no refs. Should always be ste to ZERO_SHA.
+CAPABILITIES_REF = b"capabilities^{}"
+
+COMMON_CAPABILITIES = [
+ CAPABILITY_OFS_DELTA,
+ CAPABILITY_SIDE_BAND,
+ CAPABILITY_SIDE_BAND_64K,
+ CAPABILITY_AGENT,
+ CAPABILITY_NO_PROGRESS,
+]
+KNOWN_UPLOAD_CAPABILITIES = set(
+ [
+ *COMMON_CAPABILITIES,
+ CAPABILITY_THIN_PACK,
+ CAPABILITY_MULTI_ACK,
+ CAPABILITY_MULTI_ACK_DETAILED,
+ CAPABILITY_INCLUDE_TAG,
+ CAPABILITY_DEEPEN_SINCE,
+ CAPABILITY_SYMREF,
+ CAPABILITY_SHALLOW,
+ CAPABILITY_DEEPEN_NOT,
+ CAPABILITY_DEEPEN_RELATIVE,
+ CAPABILITY_ALLOW_TIP_SHA1_IN_WANT,
+ CAPABILITY_ALLOW_REACHABLE_SHA1_IN_WANT,
+ CAPABILITY_FETCH,
+ ]
+)
+KNOWN_RECEIVE_CAPABILITIES = set(
+ [
+ *COMMON_CAPABILITIES,
+ CAPABILITY_REPORT_STATUS,
+ CAPABILITY_DELETE_REFS,
+ CAPABILITY_QUIET,
+ CAPABILITY_ATOMIC,
+ ]
+)
+
+DEPTH_INFINITE = 0x7FFFFFFF
+
+NAK_LINE = b"NAK\n"
+
+
+def agent_string():
+ return ("dulwich/" + ".".join(map(str, dulwich.__version__))).encode("ascii")
+
+
+def capability_agent():
+ return CAPABILITY_AGENT + b"=" + agent_string()
+
+
+def capability_symref(from_ref, to_ref):
+ return CAPABILITY_SYMREF + b"=" + from_ref + b":" + to_ref
+
+
+def extract_capability_names(capabilities):
+ return {parse_capability(c)[0] for c in capabilities}
+
+
+def parse_capability(capability):
+ parts = capability.split(b"=", 1)
+ if len(parts) == 1:
+ return (parts[0], None)
+ return tuple(parts)
+
+
+def symref_capabilities(symrefs):
+ return [capability_symref(*k) for k in symrefs]
+
+
+COMMAND_DEEPEN = b"deepen"
+COMMAND_SHALLOW = b"shallow"
+COMMAND_UNSHALLOW = b"unshallow"
+COMMAND_DONE = b"done"
+COMMAND_WANT = b"want"
+COMMAND_HAVE = b"have"
+
+
+def format_cmd_pkt(cmd, *args):
+ return cmd + b" " + b"".join([(a + b"\0") for a in args])
+
+
+def parse_cmd_pkt(line):
+ splice_at = line.find(b" ")
+ cmd, args = line[:splice_at], line[splice_at + 1 :]
+ assert args[-1:] == b"\x00"
+ return cmd, args[:-1].split(b"\0")
def pkt_line(data):
@@ -67,7 +180,9 @@ def pkt_line(data):
Returns: The data prefixed with its length in pkt-line format; if data was
None, returns the flush-pkt ('0000').
"""
- pass
+ if data is None:
+ return b"0000"
+ return ("%04x" % (len(data) + 4)).encode("ascii") + data
class Protocol:
@@ -82,13 +197,17 @@ class Protocol:
Documentation/technical/protocol-common.txt
"""
- def __init__(self, read, write, close=None, report_activity=None) ->None:
+ def __init__(self, read, write, close=None, report_activity=None) -> None:
self.read = read
self.write = write
self._close = close
self.report_activity = report_activity
self._readahead = None
+ def close(self):
+ if self._close:
+ self._close()
+
def __enter__(self):
return self
@@ -103,7 +222,34 @@ class Protocol:
Returns: The next string from the stream, without the length prefix, or
None for a flush-pkt ('0000') or delim-pkt ('0001').
"""
- pass
+ if self._readahead is None:
+ read = self.read
+ else:
+ read = self._readahead.read
+ self._readahead = None
+
+ try:
+ sizestr = read(4)
+ if not sizestr:
+ raise HangupException
+ size = int(sizestr, 16)
+ if size == 0 or size == 1: # flush-pkt or delim-pkt
+ if self.report_activity:
+ self.report_activity(4, "read")
+ return None
+ if self.report_activity:
+ self.report_activity(size, "read")
+ pkt_contents = read(size - 4)
+ except ConnectionResetError as exc:
+ raise HangupException from exc
+ except OSError as exc:
+ raise GitProtocolError(str(exc)) from exc
+ else:
+ if len(pkt_contents) + 4 != size:
+ raise GitProtocolError(
+ f"Length of pkt read {len(pkt_contents) + 4:04x} does not match length prefix {size:04x}"
+ )
+ return pkt_contents
def eof(self):
"""Test whether the protocol stream has reached EOF.
@@ -113,7 +259,12 @@ class Protocol:
Returns: True if the stream is at EOF, False otherwise.
"""
- pass
+ try:
+ next_line = self.read_pkt_line()
+ except HangupException:
+ return True
+ self.unread_pkt_line(next_line)
+ return False
def unread_pkt_line(self, data):
"""Unread a single line of data into the readahead buffer.
@@ -127,7 +278,9 @@ class Protocol:
Raises:
ValueError: If more than one pkt-line is unread.
"""
- pass
+ if self._readahead is not None:
+ raise ValueError("Attempted to unread multiple pkt-lines.")
+ self._readahead = BytesIO(pkt_line(data))
def read_pkt_seq(self):
"""Read a sequence of pkt-lines from the remote git process.
@@ -135,7 +288,10 @@ class Protocol:
Returns: Yields each line of data up to but not including the next
flush-pkt.
"""
- pass
+ pkt = self.read_pkt_line()
+ while pkt:
+ yield pkt
+ pkt = self.read_pkt_line()
def write_pkt_line(self, line):
"""Sends a pkt-line to the remote git process.
@@ -144,7 +300,13 @@ class Protocol:
line: A string containing the data to send, without the length
prefix.
"""
- pass
+ try:
+ line = pkt_line(line)
+ self.write(line)
+ if self.report_activity:
+ self.report_activity(len(line), "write")
+ except OSError as exc:
+ raise GitProtocolError(str(exc)) from exc
def write_sideband(self, channel, blob):
"""Write multiplexed data to the sideband.
@@ -153,7 +315,12 @@ class Protocol:
channel: An int specifying the channel to write to.
blob: A blob of data (as a string) to send on this channel.
"""
- pass
+ # a pktline can be a max of 65520. a sideband line can therefore be
+ # 65520-5 = 65515
+ # WTF: Why have the len in ASCII, but the channel in binary.
+ while blob:
+ self.write_pkt_line(bytes(bytearray([channel])) + blob[:65515])
+ blob = blob[65515:]
def send_cmd(self, cmd, *args):
"""Send a command and some arguments to a git server.
@@ -164,7 +331,7 @@ class Protocol:
cmd: The remote service to access.
args: List of arguments to send to remove service.
"""
- pass
+ self.write_pkt_line(format_cmd_pkt(cmd, *args))
def read_cmd(self):
"""Read a command and some arguments from the git client.
@@ -173,10 +340,11 @@ class Protocol:
Returns: A tuple of (command, [list of arguments]).
"""
- pass
+ line = self.read_pkt_line()
+ return parse_cmd_pkt(line)
-_RBUFSIZE = 8192
+_RBUFSIZE = 8192 # Default read buffer size.
class ReceivableProtocol(Protocol):
@@ -191,14 +359,98 @@ class ReceivableProtocol(Protocol):
will still block until at least one byte is read.
"""
- def __init__(self, recv, write, close=None, report_activity=None,
- rbufsize=_RBUFSIZE) ->None:
- super().__init__(self.read, write, close=close, report_activity=
- report_activity)
+ def __init__(
+ self, recv, write, close=None, report_activity=None, rbufsize=_RBUFSIZE
+ ) -> None:
+ super().__init__(self.read, write, close=close, report_activity=report_activity)
self._recv = recv
self._rbuf = BytesIO()
self._rbufsize = rbufsize
+ def read(self, size):
+ # From _fileobj.read in socket.py in the Python 2.6.5 standard library,
+ # with the following modifications:
+ # - omit the size <= 0 branch
+ # - seek back to start rather than 0 in case some buffer has been
+ # consumed.
+ # - use SEEK_END instead of the magic number.
+ # Copyright (c) 2001-2010 Python Software Foundation; All Rights
+ # Reserved
+ # Licensed under the Python Software Foundation License.
+ # TODO: see if buffer is more efficient than cBytesIO.
+ assert size > 0
+
+ # Our use of BytesIO rather than lists of string objects returned by
+ # recv() minimizes memory usage and fragmentation that occurs when
+ # rbufsize is large compared to the typical return value of recv().
+ buf = self._rbuf
+ start = buf.tell()
+ buf.seek(0, SEEK_END)
+ # buffer may have been partially consumed by recv()
+ buf_len = buf.tell() - start
+ if buf_len >= size:
+ # Already have size bytes in our buffer? Extract and return.
+ buf.seek(start)
+ rv = buf.read(size)
+ self._rbuf = BytesIO()
+ self._rbuf.write(buf.read())
+ self._rbuf.seek(0)
+ return rv
+
+ self._rbuf = BytesIO() # reset _rbuf. we consume it via buf.
+ while True:
+ left = size - buf_len
+ # recv() will malloc the amount of memory given as its
+ # parameter even though it often returns much less data
+ # than that. The returned data string is short lived
+ # as we copy it into a BytesIO and free it. This avoids
+ # fragmentation issues on many platforms.
+ data = self._recv(left)
+ if not data:
+ break
+ n = len(data)
+ if n == size and not buf_len:
+ # Shortcut. Avoid buffer data copies when:
+ # - We have no data in our buffer.
+ # AND
+ # - Our call to recv returned exactly the
+ # number of bytes we were asked to read.
+ return data
+ if n == left:
+ buf.write(data)
+ del data # explicit free
+ break
+ assert n <= left, "_recv(%d) returned %d bytes" % (left, n)
+ buf.write(data)
+ buf_len += n
+ del data # explicit free
+ # assert buf_len == buf.tell()
+ buf.seek(start)
+ return buf.read()
+
+ def recv(self, size):
+ assert size > 0
+
+ buf = self._rbuf
+ start = buf.tell()
+ buf.seek(0, SEEK_END)
+ buf_len = buf.tell()
+ buf.seek(start)
+
+ left = buf_len - start
+ if not left:
+ # only read from the wire if our read buffer is exhausted
+ data = self._recv(self._rbufsize)
+ if len(data) == size:
+ # shortcut: skip the buffer if we read exactly size bytes
+ return data
+ buf = BytesIO()
+ buf.write(data)
+ buf.seek(0)
+ del data # explicit free
+ self._rbuf = buf
+ return buf.read(size)
+
def extract_capabilities(text):
"""Extract a capabilities list from a string, if present.
@@ -207,7 +459,10 @@ def extract_capabilities(text):
text: String to extract from
Returns: Tuple with text with capabilities removed and list of capabilities
"""
- pass
+ if b"\0" not in text:
+ return text, []
+ text, capabilities = text.rstrip().split(b"\0")
+ return (text, capabilities.strip().split(b" "))
def extract_want_line_capabilities(text):
@@ -222,12 +477,19 @@ def extract_want_line_capabilities(text):
text: Want line to extract from
Returns: Tuple with text with capabilities removed and list of capabilities
"""
- pass
+ split_text = text.rstrip().split(b" ")
+ if len(split_text) < 3:
+ return text, []
+ return (b" ".join(split_text[:2]), split_text[2:])
def ack_type(capabilities):
"""Extract the ack type from a capabilities list."""
- pass
+ if b"multi_ack_detailed" in capabilities:
+ return MULTI_ACK_DETAILED
+ elif b"multi_ack" in capabilities:
+ return MULTI_ACK
+ return SINGLE_ACK
class BufferedPktLineWriter:
@@ -238,7 +500,7 @@ class BufferedPktLineWriter:
(including length prefix) reach the buffer size.
"""
- def __init__(self, write, bufsize=65515) ->None:
+ def __init__(self, write, bufsize=65515) -> None:
"""Initialize the BufferedPktLineWriter.
Args:
@@ -252,24 +514,79 @@ class BufferedPktLineWriter:
def write(self, data):
"""Write data, wrapping it in a pkt-line."""
- pass
+ line = pkt_line(data)
+ line_len = len(line)
+ over = self._buflen + line_len - self._bufsize
+ if over >= 0:
+ start = line_len - over
+ self._wbuf.write(line[:start])
+ self.flush()
+ else:
+ start = 0
+ saved = line[start:]
+ self._wbuf.write(saved)
+ self._buflen += len(saved)
def flush(self):
"""Flush all data from the buffer."""
- pass
+ data = self._wbuf.getvalue()
+ if data:
+ self._write(data)
+ self._len = 0
+ self._wbuf = BytesIO()
class PktLineParser:
"""Packet line parser that hands completed packets off to a callback."""
- def __init__(self, handle_pkt) ->None:
+ def __init__(self, handle_pkt) -> None:
self.handle_pkt = handle_pkt
self._readahead = BytesIO()
def parse(self, data):
"""Parse a fragment of data and call back for any completed packets."""
- pass
+ self._readahead.write(data)
+ buf = self._readahead.getvalue()
+ if len(buf) < 4:
+ return
+ while len(buf) >= 4:
+ size = int(buf[:4], 16)
+ if size == 0:
+ self.handle_pkt(None)
+ buf = buf[4:]
+ elif size <= len(buf):
+ self.handle_pkt(buf[4:size])
+ buf = buf[size:]
+ else:
+ break
+ self._readahead = BytesIO()
+ self._readahead.write(buf)
def get_tail(self):
"""Read back any unused data."""
- pass
+ return self._readahead.getvalue()
+
+
+def format_capability_line(capabilities):
+ return b"".join([b" " + c for c in capabilities])
+
+
+def format_ref_line(ref, sha, capabilities=None):
+ if capabilities is None:
+ return sha + b" " + ref + b"\n"
+ else:
+ return sha + b" " + ref + b"\0" + format_capability_line(capabilities) + b"\n"
+
+
+def format_shallow_line(sha):
+ return COMMAND_SHALLOW + b" " + sha
+
+
+def format_unshallow_line(sha):
+ return COMMAND_UNSHALLOW + b" " + sha
+
+
+def format_ack_line(sha, ack_type=b""):
+ if ack_type:
+ ack_type = b" " + ack_type
+ return b"ACK " + sha + ack_type + b"\n"
diff --git a/dulwich/reflog.py b/dulwich/reflog.py
index eb9fc2f8..9bea4485 100644
--- a/dulwich/reflog.py
+++ b/dulwich/reflog.py
@@ -1,12 +1,36 @@
+# reflog.py -- Parsing and writing reflog files
+# Copyright (C) 2015 Jelmer Vernooij and others.
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Utilities for reading and generating reflogs."""
+
import collections
+
from .objects import ZERO_SHA, format_timezone, parse_timezone
-Entry = collections.namedtuple('Entry', ['old_sha', 'new_sha', 'committer',
- 'timestamp', 'timezone', 'message'])
+Entry = collections.namedtuple(
+ "Entry",
+ ["old_sha", "new_sha", "committer", "timestamp", "timezone", "message"],
+)
-def format_reflog_line(old_sha, new_sha, committer, timestamp, timezone,
- message):
+
+def format_reflog_line(old_sha, new_sha, committer, timestamp, timezone, message):
"""Generate a single reflog line.
Args:
@@ -17,7 +41,21 @@ def format_reflog_line(old_sha, new_sha, committer, timestamp, timezone,
timezone: Timezone
message: Message
"""
- pass
+ if old_sha is None:
+ old_sha = ZERO_SHA
+ return (
+ old_sha
+ + b" "
+ + new_sha
+ + b" "
+ + committer
+ + b" "
+ + str(int(timestamp)).encode("ascii")
+ + b" "
+ + format_timezone(timezone)
+ + b"\t"
+ + message
+ )
def parse_reflog_line(line):
@@ -28,7 +66,17 @@ def parse_reflog_line(line):
Returns: Tuple of (old_sha, new_sha, committer, timestamp, timezone,
message)
"""
- pass
+ (begin, message) = line.split(b"\t", 1)
+ (old_sha, new_sha, rest) = begin.split(b" ", 2)
+ (committer, timestamp_str, timezone_str) = rest.rsplit(b" ", 2)
+ return Entry(
+ old_sha,
+ new_sha,
+ committer,
+ int(timestamp_str),
+ parse_timezone(timezone_str)[0],
+ message,
+ )
def read_reflog(f):
@@ -38,7 +86,8 @@ def read_reflog(f):
f: File-like object
Returns: Iterator over Entry objects
"""
- pass
+ for line in f:
+ yield parse_reflog_line(line)
def drop_reflog_entry(f, index, rewrite=False):
@@ -50,4 +99,51 @@ def drop_reflog_entry(f, index, rewrite=False):
rewrite: If a reflog entry's predecessor is removed, set its
old SHA to the new SHA of the entry that now precedes it
"""
- pass
+ if index < 0:
+ raise ValueError("Invalid reflog index %d" % index)
+
+ log = []
+ offset = f.tell()
+ for line in f:
+ log.append((offset, parse_reflog_line(line)))
+ offset = f.tell()
+
+ inverse_index = len(log) - index - 1
+ write_offset = log[inverse_index][0]
+ f.seek(write_offset)
+
+ if index == 0:
+ f.truncate()
+ return
+
+ del log[inverse_index]
+ if rewrite and index > 0 and log:
+ if inverse_index == 0:
+ previous_new = ZERO_SHA
+ else:
+ previous_new = log[inverse_index - 1][1].new_sha
+ offset, entry = log[inverse_index]
+ log[inverse_index] = (
+ offset,
+ Entry(
+ previous_new,
+ entry.new_sha,
+ entry.committer,
+ entry.timestamp,
+ entry.timezone,
+ entry.message,
+ ),
+ )
+
+ for _, entry in log[inverse_index:]:
+ f.write(
+ format_reflog_line(
+ entry.old_sha,
+ entry.new_sha,
+ entry.committer,
+ entry.timestamp,
+ entry.timezone,
+ entry.message,
+ )
+ )
+ f.truncate()
diff --git a/dulwich/refs.py b/dulwich/refs.py
index 3cbaa3f6..f9eb7999 100644
--- a/dulwich/refs.py
+++ b/dulwich/refs.py
@@ -1,27 +1,54 @@
+# refs.py -- For dealing with git refs
+# Copyright (C) 2008-2013 Jelmer Vernooij <jelmer@jelmer.uk>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
+
"""Ref handling."""
+
import os
import warnings
from contextlib import suppress
from typing import Any, Dict, Optional, Set
+
from .errors import PackedRefsException, RefFormatError
from .file import GitFile, ensure_dir_exists
from .objects import ZERO_SHA, ObjectID, Tag, git_line, valid_hexsha
from .pack import ObjectContainer
+
Ref = bytes
-HEADREF = b'HEAD'
-SYMREF = b'ref: '
-LOCAL_BRANCH_PREFIX = b'refs/heads/'
-LOCAL_TAG_PREFIX = b'refs/tags/'
-LOCAL_REMOTE_PREFIX = b'refs/remotes/'
-BAD_REF_CHARS = set(b'\x7f ~^:?*[')
-PEELED_TAG_SUFFIX = b'^{}'
+
+HEADREF = b"HEAD"
+SYMREF = b"ref: "
+LOCAL_BRANCH_PREFIX = b"refs/heads/"
+LOCAL_TAG_PREFIX = b"refs/tags/"
+LOCAL_REMOTE_PREFIX = b"refs/remotes/"
+BAD_REF_CHARS = set(b"\177 ~^:?*[")
+PEELED_TAG_SUFFIX = b"^{}"
+
+# For backwards compatibility
ANNOTATED_TAG_SUFFIX = PEELED_TAG_SUFFIX
class SymrefLoop(Exception):
"""There is a loop between one or more symrefs."""
- def __init__(self, ref, depth) ->None:
+ def __init__(self, ref, depth) -> None:
self.ref = ref
self.depth = depth
@@ -33,7 +60,9 @@ def parse_symref_value(contents):
contents: Contents to parse
Returns: Destination
"""
- pass
+ if contents.startswith(SYMREF):
+ return contents[len(SYMREF) :].rstrip(b"\r\n")
+ raise ValueError(contents)
def check_ref_format(refname: Ref):
@@ -48,17 +77,59 @@ def check_ref_format(refname: Ref):
refname: The refname to check
Returns: True if refname is valid, False otherwise
"""
- pass
+ # These could be combined into one big expression, but are listed
+ # separately to parallel [1].
+ if b"/." in refname or refname.startswith(b"."):
+ return False
+ if b"/" not in refname:
+ return False
+ if b".." in refname:
+ return False
+ for i, c in enumerate(refname):
+ if ord(refname[i : i + 1]) < 0o40 or c in BAD_REF_CHARS:
+ return False
+ if refname[-1] in b"/.":
+ return False
+ if refname.endswith(b".lock"):
+ return False
+ if b"@{" in refname:
+ return False
+ if b"\\" in refname:
+ return False
+ return True
class RefsContainer:
"""A container for refs."""
- def __init__(self, logger=None) ->None:
+ def __init__(self, logger=None) -> None:
self._logger = logger
- def set_symbolic_ref(self, name, other, committer=None, timestamp=None,
- timezone=None, message=None):
+ def _log(
+ self,
+ ref,
+ old_sha,
+ new_sha,
+ committer=None,
+ timestamp=None,
+ timezone=None,
+ message=None,
+ ):
+ if self._logger is None:
+ return
+ if message is None:
+ return
+ self._logger(ref, old_sha, new_sha, committer, timestamp, timezone, message)
+
+ def set_symbolic_ref(
+ self,
+ name,
+ other,
+ committer=None,
+ timestamp=None,
+ timezone=None,
+ message=None,
+ ):
"""Make a ref point at another ref.
Args:
@@ -66,7 +137,7 @@ class RefsContainer:
other: Name of the ref to point at
message: Optional message
"""
- pass
+ raise NotImplementedError(self.set_symbolic_ref)
def get_packed_refs(self):
"""Get contents of the packed-refs file.
@@ -76,7 +147,7 @@ class RefsContainer:
Note: Will return an empty dictionary when no packed-refs file is
present.
"""
- pass
+ raise NotImplementedError(self.get_packed_refs)
def add_packed_refs(self, new_refs: Dict[Ref, Optional[ObjectID]]):
"""Add the given refs as packed refs.
@@ -85,7 +156,7 @@ class RefsContainer:
new_refs: A mapping of ref names to targets; if a target is None that
means remove the ref
"""
- pass
+ raise NotImplementedError(self.add_packed_refs)
def get_peeled(self, name):
"""Return the cached peeled value of a ref, if available.
@@ -96,11 +167,40 @@ class RefsContainer:
a tag, this will be the SHA the ref refers to. If the ref may point
to a tag, but no cached information is available, None is returned.
"""
- pass
+ return None
+
+ def import_refs(
+ self,
+ base: Ref,
+ other: Dict[Ref, ObjectID],
+ committer: Optional[bytes] = None,
+ timestamp: Optional[bytes] = None,
+ timezone: Optional[bytes] = None,
+ message: Optional[bytes] = None,
+ prune: bool = False,
+ ):
+ if prune:
+ to_delete = set(self.subkeys(base))
+ else:
+ to_delete = set()
+ for name, value in other.items():
+ if value is None:
+ to_delete.add(name)
+ else:
+ self.set_if_equals(
+ b"/".join((base, name)), None, value, message=message
+ )
+ if to_delete:
+ try:
+ to_delete.remove(name)
+ except KeyError:
+ pass
+ for ref in to_delete:
+ self.remove_if_equals(b"/".join((base, ref)), None, message=message)
def allkeys(self):
"""All refs present in this container."""
- pass
+ raise NotImplementedError(self.allkeys)
def __iter__(self):
return iter(self.allkeys())
@@ -113,7 +213,10 @@ class RefsContainer:
Returns: An unsorted set of valid refs in this container, including
packed refs.
"""
- pass
+ if base is not None:
+ return self.subkeys(base)
+ else:
+ return self.allkeys()
def subkeys(self, base):
"""Refs present in this container under a base.
@@ -123,11 +226,28 @@ class RefsContainer:
Returns: A set of valid refs in this container under the base; the base
prefix is stripped from the ref names returned.
"""
- pass
+ keys = set()
+ base_len = len(base) + 1
+ for refname in self.allkeys():
+ if refname.startswith(base):
+ keys.add(refname[base_len:])
+ return keys
def as_dict(self, base=None):
"""Return the contents of this container as a dictionary."""
- pass
+ ret = {}
+ keys = self.keys(base)
+ if base is None:
+ base = b""
+ else:
+ base = base.rstrip(b"/")
+ for key in keys:
+ try:
+ ret[key] = self[(base + b"/" + key).strip(b"/")]
+ except (SymrefLoop, KeyError):
+ continue # Unable to resolve
+
+ return ret
def _check_refname(self, name):
"""Ensure a refname is valid and lives in refs or is HEAD.
@@ -143,7 +263,10 @@ class RefsContainer:
Raises:
KeyError: if a refname is not HEAD or is otherwise not valid.
"""
- pass
+ if name in (HEADREF, b"refs/stash"):
+ return
+ if not name.startswith(b"refs/") or not check_ref_format(name[5:]):
+ raise RefFormatError(name)
def read_ref(self, refname):
"""Read a reference without following any references.
@@ -153,7 +276,10 @@ class RefsContainer:
Returns: The contents of the ref file, or None if it does
not exist.
"""
- pass
+ contents = self.read_loose_ref(refname)
+ if not contents:
+ contents = self.get_packed_refs().get(refname, None)
+ return contents
def read_loose_ref(self, name):
"""Read a loose reference and return its contents.
@@ -163,7 +289,7 @@ class RefsContainer:
Returns: The contents of the ref file, or None if it does
not exist.
"""
- pass
+ raise NotImplementedError(self.read_loose_ref)
def follow(self, name):
"""Follow a reference name.
@@ -171,9 +297,21 @@ class RefsContainer:
Returns: a tuple of (refnames, sha), wheres refnames are the names of
references in the chain
"""
- pass
-
- def __contains__(self, refname) ->bool:
+ contents = SYMREF + name
+ depth = 0
+ refnames = []
+ while contents.startswith(SYMREF):
+ refname = contents[len(SYMREF) :]
+ refnames.append(refname)
+ contents = self.read_ref(refname)
+ if not contents:
+ break
+ depth += 1
+ if depth > 5:
+ raise SymrefLoop(name, depth)
+ return refnames, contents
+
+ def __contains__(self, refname) -> bool:
if self.read_ref(refname):
return True
return False
@@ -188,8 +326,16 @@ class RefsContainer:
raise KeyError(name)
return sha
- def set_if_equals(self, name, old_ref, new_ref, committer=None,
- timestamp=None, timezone=None, message=None):
+ def set_if_equals(
+ self,
+ name,
+ old_ref,
+ new_ref,
+ committer=None,
+ timestamp=None,
+ timezone=None,
+ message=None,
+ ):
"""Set a refname to new_ref only if it currently equals old_ref.
This method follows all symbolic references if applicable for the
@@ -204,19 +350,20 @@ class RefsContainer:
message: Message for reflog
Returns: True if the set was successful, False otherwise.
"""
- pass
+ raise NotImplementedError(self.set_if_equals)
- def add_if_new(self, name, ref, committer=None, timestamp=None,
- timezone=None, message=None):
+ def add_if_new(
+ self, name, ref, committer=None, timestamp=None, timezone=None, message=None
+ ):
"""Add a new reference only if it does not already exist.
Args:
name: Ref name
ref: Ref value
"""
- pass
+ raise NotImplementedError(self.add_if_new)
- def __setitem__(self, name, ref) ->None:
+ def __setitem__(self, name, ref) -> None:
"""Set a reference name to point to the given SHA1.
This method follows all symbolic references if applicable for the
@@ -232,8 +379,15 @@ class RefsContainer:
"""
self.set_if_equals(name, None, ref)
- def remove_if_equals(self, name, old_ref, committer=None, timestamp=
- None, timezone=None, message=None):
+ def remove_if_equals(
+ self,
+ name,
+ old_ref,
+ committer=None,
+ timestamp=None,
+ timezone=None,
+ message=None,
+ ):
"""Remove a refname only if it currently equals old_ref.
This method does not follow symbolic references, even if applicable for
@@ -247,9 +401,9 @@ class RefsContainer:
message: Message for reflog
Returns: True if the delete was successful, False otherwise.
"""
- pass
+ raise NotImplementedError(self.remove_if_equals)
- def __delitem__(self, name) ->None:
+ def __delitem__(self, name) -> None:
"""Remove a refname.
This method does not follow symbolic references, even if applicable for
@@ -269,7 +423,15 @@ class RefsContainer:
Returns: Dictionary mapping source ref to target ref
"""
- pass
+ ret = {}
+ for src in self.allkeys():
+ try:
+ dst = parse_symref_value(self.read_ref(src))
+ except ValueError:
+ pass
+ else:
+ ret[src] = dst
+ return ret
class DictRefsContainer(RefsContainer):
@@ -279,62 +441,243 @@ class DictRefsContainer(RefsContainer):
threadsafe.
"""
- def __init__(self, refs, logger=None) ->None:
+ def __init__(self, refs, logger=None) -> None:
super().__init__(logger=logger)
self._refs = refs
self._peeled: Dict[bytes, ObjectID] = {}
self._watchers: Set[Any] = set()
+ def allkeys(self):
+ return self._refs.keys()
+
+ def read_loose_ref(self, name):
+ return self._refs.get(name, None)
+
+ def get_packed_refs(self):
+ return {}
+
+ def _notify(self, ref, newsha):
+ for watcher in self._watchers:
+ watcher._notify((ref, newsha))
+
+ def set_symbolic_ref(
+ self,
+ name: Ref,
+ other: Ref,
+ committer=None,
+ timestamp=None,
+ timezone=None,
+ message=None,
+ ):
+ old = self.follow(name)[-1]
+ new = SYMREF + other
+ self._refs[name] = new
+ self._notify(name, new)
+ self._log(
+ name,
+ old,
+ new,
+ committer=committer,
+ timestamp=timestamp,
+ timezone=timezone,
+ message=message,
+ )
+
+ def set_if_equals(
+ self,
+ name,
+ old_ref,
+ new_ref,
+ committer=None,
+ timestamp=None,
+ timezone=None,
+ message=None,
+ ):
+ if old_ref is not None and self._refs.get(name, ZERO_SHA) != old_ref:
+ return False
+ realnames, _ = self.follow(name)
+ for realname in realnames:
+ self._check_refname(realname)
+ old = self._refs.get(realname)
+ self._refs[realname] = new_ref
+ self._notify(realname, new_ref)
+ self._log(
+ realname,
+ old,
+ new_ref,
+ committer=committer,
+ timestamp=timestamp,
+ timezone=timezone,
+ message=message,
+ )
+ return True
+
+ def add_if_new(
+ self,
+ name: Ref,
+ ref: ObjectID,
+ committer=None,
+ timestamp=None,
+ timezone=None,
+ message: Optional[bytes] = None,
+ ):
+ if name in self._refs:
+ return False
+ self._refs[name] = ref
+ self._notify(name, ref)
+ self._log(
+ name,
+ None,
+ ref,
+ committer=committer,
+ timestamp=timestamp,
+ timezone=timezone,
+ message=message,
+ )
+ return True
+
+ def remove_if_equals(
+ self,
+ name,
+ old_ref,
+ committer=None,
+ timestamp=None,
+ timezone=None,
+ message=None,
+ ):
+ if old_ref is not None and self._refs.get(name, ZERO_SHA) != old_ref:
+ return False
+ try:
+ old = self._refs.pop(name)
+ except KeyError:
+ pass
+ else:
+ self._notify(name, None)
+ self._log(
+ name,
+ old,
+ None,
+ committer=committer,
+ timestamp=timestamp,
+ timezone=timezone,
+ message=message,
+ )
+ return True
+
+ def get_peeled(self, name):
+ return self._peeled.get(name)
+
def _update(self, refs):
"""Update multiple refs; intended only for testing."""
- pass
+ # TODO(dborowitz): replace this with a public function that uses
+ # set_if_equal.
+ for ref, sha in refs.items():
+ self.set_if_equals(ref, None, sha)
def _update_peeled(self, peeled):
"""Update cached peeled refs; intended only for testing."""
- pass
+ self._peeled.update(peeled)
class InfoRefsContainer(RefsContainer):
"""Refs container that reads refs from a info/refs file."""
- def __init__(self, f) ->None:
+ def __init__(self, f) -> None:
self._refs = {}
self._peeled = {}
for line in f.readlines():
- sha, name = line.rstrip(b'\n').split(b'\t')
+ sha, name = line.rstrip(b"\n").split(b"\t")
if name.endswith(PEELED_TAG_SUFFIX):
name = name[:-3]
if not check_ref_format(name):
- raise ValueError(f'invalid ref name {name!r}')
+ raise ValueError(f"invalid ref name {name!r}")
self._peeled[name] = sha
else:
if not check_ref_format(name):
- raise ValueError(f'invalid ref name {name!r}')
+ raise ValueError(f"invalid ref name {name!r}")
self._refs[name] = sha
+ def allkeys(self):
+ return self._refs.keys()
+
+ def read_loose_ref(self, name):
+ return self._refs.get(name, None)
+
+ def get_packed_refs(self):
+ return {}
+
+ def get_peeled(self, name):
+ try:
+ return self._peeled[name]
+ except KeyError:
+ return self._refs[name]
+
class DiskRefsContainer(RefsContainer):
"""Refs container that reads refs from disk."""
- def __init__(self, path, worktree_path=None, logger=None) ->None:
+ def __init__(self, path, worktree_path=None, logger=None) -> None:
super().__init__(logger=logger)
- if getattr(path, 'encode', None) is not None:
+ if getattr(path, "encode", None) is not None:
path = os.fsencode(path)
self.path = path
if worktree_path is None:
worktree_path = path
- if getattr(worktree_path, 'encode', None) is not None:
+ if getattr(worktree_path, "encode", None) is not None:
worktree_path = os.fsencode(worktree_path)
self.worktree_path = worktree_path
self._packed_refs = None
self._peeled_refs = None
- def __repr__(self) ->str:
- return f'{self.__class__.__name__}({self.path!r})'
+ def __repr__(self) -> str:
+ return f"{self.__class__.__name__}({self.path!r})"
+
+ def subkeys(self, base):
+ subkeys = set()
+ path = self.refpath(base)
+ for root, unused_dirs, files in os.walk(path):
+ dir = root[len(path) :]
+ if os.path.sep != "/":
+ dir = dir.replace(os.fsencode(os.path.sep), b"/")
+ dir = dir.strip(b"/")
+ for filename in files:
+ refname = b"/".join(([dir] if dir else []) + [filename])
+ # check_ref_format requires at least one /, so we prepend the
+ # base before calling it.
+ if check_ref_format(base + b"/" + refname):
+ subkeys.add(refname)
+ for key in self.get_packed_refs():
+ if key.startswith(base):
+ subkeys.add(key[len(base) :].strip(b"/"))
+ return subkeys
+
+ def allkeys(self):
+ allkeys = set()
+ if os.path.exists(self.refpath(HEADREF)):
+ allkeys.add(HEADREF)
+ path = self.refpath(b"")
+ refspath = self.refpath(b"refs")
+ for root, unused_dirs, files in os.walk(refspath):
+ dir = root[len(path) :]
+ if os.path.sep != "/":
+ dir = dir.replace(os.fsencode(os.path.sep), b"/")
+ for filename in files:
+ refname = b"/".join([dir, filename])
+ if check_ref_format(refname):
+ allkeys.add(refname)
+ allkeys.update(self.get_packed_refs())
+ return allkeys
def refpath(self, name):
"""Return the disk path of a ref."""
- pass
+ if os.path.sep != "/":
+ name = name.replace(b"/", os.fsencode(os.path.sep))
+ # TODO: as the 'HEAD' reference is working tree specific, it
+ # should actually not be a part of RefsContainer
+ if name == HEADREF:
+ return os.path.join(self.worktree_path, name)
+ else:
+ return os.path.join(self.path, name)
def get_packed_refs(self):
"""Get contents of the packed-refs file.
@@ -344,7 +687,29 @@ class DiskRefsContainer(RefsContainer):
Note: Will return an empty dictionary when no packed-refs file is
present.
"""
- pass
+ # TODO: invalidate the cache on repacking
+ if self._packed_refs is None:
+ # set both to empty because we want _peeled_refs to be
+ # None if and only if _packed_refs is also None.
+ self._packed_refs = {}
+ self._peeled_refs = {}
+ path = os.path.join(self.path, b"packed-refs")
+ try:
+ f = GitFile(path, "rb")
+ except FileNotFoundError:
+ return {}
+ with f:
+ first_line = next(iter(f)).rstrip()
+ if first_line.startswith(b"# pack-refs") and b" peeled" in first_line:
+ for sha, name, peeled in read_packed_refs_with_peeled(f):
+ self._packed_refs[name] = sha
+ if peeled:
+ self._peeled_refs[name] = peeled
+ else:
+ f.seek(0)
+ for sha, name in read_packed_refs(f):
+ self._packed_refs[name] = sha
+ return self._packed_refs
def add_packed_refs(self, new_refs: Dict[Ref, Optional[ObjectID]]):
"""Add the given refs as packed refs.
@@ -353,7 +718,34 @@ class DiskRefsContainer(RefsContainer):
new_refs: A mapping of ref names to targets; if a target is None that
means remove the ref
"""
- pass
+ if not new_refs:
+ return
+
+ path = os.path.join(self.path, b"packed-refs")
+
+ with GitFile(path, "wb") as f:
+ # reread cached refs from disk, while holding the lock
+ packed_refs = self.get_packed_refs().copy()
+
+ for ref, target in new_refs.items():
+ # sanity check
+ if ref == HEADREF:
+ raise ValueError("cannot pack HEAD")
+
+ # remove any loose refs pointing to this one -- please
+ # note that this bypasses remove_if_equals as we don't
+ # want to affect packed refs in here
+ with suppress(OSError):
+ os.remove(self.refpath(ref))
+
+ if target is not None:
+ packed_refs[ref] = target
+ else:
+ packed_refs.pop(ref, None)
+
+ write_packed_refs(f, packed_refs, self._peeled_refs)
+
+ self._packed_refs = packed_refs
def get_peeled(self, name):
"""Return the cached peeled value of a ref, if available.
@@ -364,7 +756,15 @@ class DiskRefsContainer(RefsContainer):
a tag, this will be the SHA the ref refers to. If the ref may point
to a tag, but no cached information is available, None is returned.
"""
- pass
+ self.get_packed_refs()
+ if self._peeled_refs is None or name not in self._packed_refs:
+ # No cache: no peeled refs were read, or this ref is loose
+ return None
+ if name in self._peeled_refs:
+ return self._peeled_refs[name]
+ else:
+ # Known not peelable
+ return self[name]
def read_loose_ref(self, name):
"""Read a reference file and return its contents.
@@ -380,10 +780,52 @@ class DiskRefsContainer(RefsContainer):
Raises:
IOError: if any other error occurs
"""
- pass
-
- def set_symbolic_ref(self, name, other, committer=None, timestamp=None,
- timezone=None, message=None):
+ filename = self.refpath(name)
+ try:
+ with GitFile(filename, "rb") as f:
+ header = f.read(len(SYMREF))
+ if header == SYMREF:
+ # Read only the first line
+ return header + next(iter(f)).rstrip(b"\r\n")
+ else:
+ # Read only the first 40 bytes
+ return header + f.read(40 - len(SYMREF))
+ except (OSError, UnicodeError):
+ # don't assume anything specific about the error; in
+ # particular, invalid or forbidden paths can raise weird
+ # errors depending on the specific operating system
+ return None
+
+ def _remove_packed_ref(self, name):
+ if self._packed_refs is None:
+ return
+ filename = os.path.join(self.path, b"packed-refs")
+ # reread cached refs from disk, while holding the lock
+ f = GitFile(filename, "wb")
+ try:
+ self._packed_refs = None
+ self.get_packed_refs()
+
+ if name not in self._packed_refs:
+ return
+
+ del self._packed_refs[name]
+ with suppress(KeyError):
+ del self._peeled_refs[name]
+ write_packed_refs(f, self._packed_refs, self._peeled_refs)
+ f.close()
+ finally:
+ f.abort()
+
+ def set_symbolic_ref(
+ self,
+ name,
+ other,
+ committer=None,
+ timestamp=None,
+ timezone=None,
+ message=None,
+ ):
"""Make a ref point at another ref.
Args:
@@ -391,10 +833,38 @@ class DiskRefsContainer(RefsContainer):
other: Name of the ref to point at
message: Optional message to describe the change
"""
- pass
-
- def set_if_equals(self, name, old_ref, new_ref, committer=None,
- timestamp=None, timezone=None, message=None):
+ self._check_refname(name)
+ self._check_refname(other)
+ filename = self.refpath(name)
+ f = GitFile(filename, "wb")
+ try:
+ f.write(SYMREF + other + b"\n")
+ sha = self.follow(name)[-1]
+ self._log(
+ name,
+ sha,
+ sha,
+ committer=committer,
+ timestamp=timestamp,
+ timezone=timezone,
+ message=message,
+ )
+ except BaseException:
+ f.abort()
+ raise
+ else:
+ f.close()
+
+ def set_if_equals(
+ self,
+ name,
+ old_ref,
+ new_ref,
+ committer=None,
+ timestamp=None,
+ timezone=None,
+ message=None,
+ ):
"""Set a refname to new_ref only if it currently equals old_ref.
This method follows all symbolic references, and can be used to perform
@@ -408,10 +878,61 @@ class DiskRefsContainer(RefsContainer):
message: Set message for reflog
Returns: True if the set was successful, False otherwise.
"""
- pass
-
- def add_if_new(self, name: bytes, ref: bytes, committer=None, timestamp
- =None, timezone=None, message: Optional[bytes]=None):
+ self._check_refname(name)
+ try:
+ realnames, _ = self.follow(name)
+ realname = realnames[-1]
+ except (KeyError, IndexError, SymrefLoop):
+ realname = name
+ filename = self.refpath(realname)
+
+ # make sure none of the ancestor folders is in packed refs
+ probe_ref = os.path.dirname(realname)
+ packed_refs = self.get_packed_refs()
+ while probe_ref:
+ if packed_refs.get(probe_ref, None) is not None:
+ raise NotADirectoryError(filename)
+ probe_ref = os.path.dirname(probe_ref)
+
+ ensure_dir_exists(os.path.dirname(filename))
+ with GitFile(filename, "wb") as f:
+ if old_ref is not None:
+ try:
+ # read again while holding the lock
+ orig_ref = self.read_loose_ref(realname)
+ if orig_ref is None:
+ orig_ref = self.get_packed_refs().get(realname, ZERO_SHA)
+ if orig_ref != old_ref:
+ f.abort()
+ return False
+ except OSError:
+ f.abort()
+ raise
+ try:
+ f.write(new_ref + b"\n")
+ except OSError:
+ f.abort()
+ raise
+ self._log(
+ realname,
+ old_ref,
+ new_ref,
+ committer=committer,
+ timestamp=timestamp,
+ timezone=timezone,
+ message=message,
+ )
+ return True
+
+ def add_if_new(
+ self,
+ name: bytes,
+ ref: bytes,
+ committer=None,
+ timestamp=None,
+ timezone=None,
+ message: Optional[bytes] = None,
+ ):
"""Add a new reference only if it does not already exist.
This method follows symrefs, and only ensures that the last ref in the
@@ -423,10 +944,46 @@ class DiskRefsContainer(RefsContainer):
message: Optional message for reflog
Returns: True if the add was successful, False otherwise.
"""
- pass
-
- def remove_if_equals(self, name, old_ref, committer=None, timestamp=
- None, timezone=None, message=None):
+ try:
+ realnames, contents = self.follow(name)
+ if contents is not None:
+ return False
+ realname = realnames[-1]
+ except (KeyError, IndexError):
+ realname = name
+ self._check_refname(realname)
+ filename = self.refpath(realname)
+ ensure_dir_exists(os.path.dirname(filename))
+ with GitFile(filename, "wb") as f:
+ if os.path.exists(filename) or name in self.get_packed_refs():
+ f.abort()
+ return False
+ try:
+ f.write(ref + b"\n")
+ except OSError:
+ f.abort()
+ raise
+ else:
+ self._log(
+ name,
+ None,
+ ref,
+ committer=committer,
+ timestamp=timestamp,
+ timezone=timezone,
+ message=message,
+ )
+ return True
+
+ def remove_if_equals(
+ self,
+ name,
+ old_ref,
+ committer=None,
+ timestamp=None,
+ timezone=None,
+ message=None,
+ ):
"""Remove a refname only if it currently equals old_ref.
This method does not follow symbolic references. It can be used to
@@ -439,12 +996,78 @@ class DiskRefsContainer(RefsContainer):
message: Optional message
Returns: True if the delete was successful, False otherwise.
"""
- pass
+ self._check_refname(name)
+ filename = self.refpath(name)
+ ensure_dir_exists(os.path.dirname(filename))
+ f = GitFile(filename, "wb")
+ try:
+ if old_ref is not None:
+ orig_ref = self.read_loose_ref(name)
+ if orig_ref is None:
+ orig_ref = self.get_packed_refs().get(name, ZERO_SHA)
+ if orig_ref != old_ref:
+ return False
+
+ # remove the reference file itself
+ try:
+ found = os.path.lexists(filename)
+ except OSError:
+ # may only be packed, or otherwise unstorable
+ found = False
+
+ if found:
+ os.remove(filename)
+
+ self._remove_packed_ref(name)
+ self._log(
+ name,
+ old_ref,
+ None,
+ committer=committer,
+ timestamp=timestamp,
+ timezone=timezone,
+ message=message,
+ )
+ finally:
+ # never write, we just wanted the lock
+ f.abort()
+
+ # outside of the lock, clean-up any parent directory that might now
+ # be empty. this ensures that re-creating a reference of the same
+ # name of what was previously a directory works as expected
+ parent = name
+ while True:
+ try:
+ parent, _ = parent.rsplit(b"/", 1)
+ except ValueError:
+ break
+
+ if parent == b"refs":
+ break
+ parent_filename = self.refpath(parent)
+ try:
+ os.rmdir(parent_filename)
+ except OSError:
+ # this can be caused by the parent directory being
+ # removed by another process, being not empty, etc.
+ # in any case, this is non fatal because we already
+ # removed the reference, just ignore it
+ break
+
+ return True
def _split_ref_line(line):
"""Split a single ref line into a tuple of SHA1 and name."""
- pass
+ fields = line.rstrip(b"\n\r").split(b" ")
+ if len(fields) != 2:
+ raise PackedRefsException(f"invalid ref line {line!r}")
+ sha, name = fields
+ if not valid_hexsha(sha):
+ raise PackedRefsException(f"Invalid hex sha {sha!r}")
+ if not check_ref_format(name):
+ raise PackedRefsException(f"invalid ref name {name!r}")
+ return (sha, name)
def read_packed_refs(f):
@@ -454,7 +1077,13 @@ def read_packed_refs(f):
f: file-like object to read from
Returns: Iterator over tuples with SHA1s and ref names.
"""
- pass
+ for line in f:
+ if line.startswith(b"#"):
+ # Comment
+ continue
+ if line.startswith(b"^"):
+ raise PackedRefsException("found peeled ref in packed-refs without peeled")
+ yield _split_ref_line(line)
def read_packed_refs_with_peeled(f):
@@ -466,7 +1095,27 @@ def read_packed_refs_with_peeled(f):
Args:
f: file-like object to read from, seek'ed to the second line
"""
- pass
+ last = None
+ for line in f:
+ if line[0] == b"#":
+ continue
+ line = line.rstrip(b"\r\n")
+ if line.startswith(b"^"):
+ if not last:
+ raise PackedRefsException("unexpected peeled ref line")
+ if not valid_hexsha(line[1:]):
+ raise PackedRefsException(f"Invalid hex sha {line[1:]!r}")
+ sha, name = _split_ref_line(last)
+ last = None
+ yield (sha, name, line[1:])
+ else:
+ if last:
+ sha, name = _split_ref_line(last)
+ yield (sha, name, None)
+ last = line
+ if last:
+ sha, name = _split_ref_line(last)
+ yield (sha, name, None)
def write_packed_refs(f, packed_refs, peeled_refs=None):
@@ -477,20 +1126,167 @@ def write_packed_refs(f, packed_refs, peeled_refs=None):
packed_refs: dict of refname to sha of packed refs to write
peeled_refs: dict of refname to peeled value of sha
"""
- pass
+ if peeled_refs is None:
+ peeled_refs = {}
+ else:
+ f.write(b"# pack-refs with: peeled\n")
+ for refname in sorted(packed_refs.keys()):
+ f.write(git_line(packed_refs[refname], refname))
+ if refname in peeled_refs:
+ f.write(b"^" + peeled_refs[refname] + b"\n")
+
+
+def read_info_refs(f):
+ ret = {}
+ for line in f.readlines():
+ (sha, name) = line.rstrip(b"\r\n").split(b"\t", 1)
+ ret[name] = sha
+ return ret
def write_info_refs(refs, store: ObjectContainer):
"""Generate info refs."""
- pass
+ # TODO: Avoid recursive import :(
+ from .object_store import peel_sha
+ for name, sha in sorted(refs.items()):
+ # get_refs() includes HEAD as a special case, but we don't want to
+ # advertise it
+ if name == HEADREF:
+ continue
+ try:
+ o = store[sha]
+ except KeyError:
+ continue
+ unpeeled, peeled = peel_sha(store, sha)
+ yield o.id + b"\t" + name + b"\n"
+ if o.id != peeled.id:
+ yield peeled.id + b"\t" + name + PEELED_TAG_SUFFIX + b"\n"
-def strip_peeled_refs(refs):
- """Remove all peeled refs."""
- pass
+def is_local_branch(x):
+ return x.startswith(LOCAL_BRANCH_PREFIX)
-def _set_default_branch(refs: RefsContainer, origin: bytes, origin_head:
- bytes, branch: bytes, ref_message: Optional[bytes]) ->bytes:
+
+def strip_peeled_refs(refs):
+ """Remove all peeled refs."""
+ return {
+ ref: sha for (ref, sha) in refs.items() if not ref.endswith(PEELED_TAG_SUFFIX)
+ }
+
+
+def _set_origin_head(refs, origin, origin_head):
+ # set refs/remotes/origin/HEAD
+ origin_base = b"refs/remotes/" + origin + b"/"
+ if origin_head and origin_head.startswith(LOCAL_BRANCH_PREFIX):
+ origin_ref = origin_base + HEADREF
+ target_ref = origin_base + origin_head[len(LOCAL_BRANCH_PREFIX) :]
+ if target_ref in refs:
+ refs.set_symbolic_ref(origin_ref, target_ref)
+
+
+def _set_default_branch(
+ refs: RefsContainer,
+ origin: bytes,
+ origin_head: bytes,
+ branch: bytes,
+ ref_message: Optional[bytes],
+) -> bytes:
"""Set the default branch."""
- pass
+ origin_base = b"refs/remotes/" + origin + b"/"
+ if branch:
+ origin_ref = origin_base + branch
+ if origin_ref in refs:
+ local_ref = LOCAL_BRANCH_PREFIX + branch
+ refs.add_if_new(local_ref, refs[origin_ref], ref_message)
+ head_ref = local_ref
+ elif LOCAL_TAG_PREFIX + branch in refs:
+ head_ref = LOCAL_TAG_PREFIX + branch
+ else:
+ raise ValueError(f"{os.fsencode(branch)!r} is not a valid branch or tag")
+ elif origin_head:
+ head_ref = origin_head
+ if origin_head.startswith(LOCAL_BRANCH_PREFIX):
+ origin_ref = origin_base + origin_head[len(LOCAL_BRANCH_PREFIX) :]
+ else:
+ origin_ref = origin_head
+ try:
+ refs.add_if_new(head_ref, refs[origin_ref], ref_message)
+ except KeyError:
+ pass
+ else:
+ raise ValueError("neither origin_head nor branch are provided")
+ return head_ref
+
+
+def _set_head(refs, head_ref, ref_message):
+ if head_ref.startswith(LOCAL_TAG_PREFIX):
+ # detach HEAD at specified tag
+ head = refs[head_ref]
+ if isinstance(head, Tag):
+ _cls, obj = head.object
+ head = obj.get_object(obj).id
+ del refs[HEADREF]
+ refs.set_if_equals(HEADREF, None, head, message=ref_message)
+ else:
+ # set HEAD to specific branch
+ try:
+ head = refs[head_ref]
+ refs.set_symbolic_ref(HEADREF, head_ref)
+ refs.set_if_equals(HEADREF, None, head, message=ref_message)
+ except KeyError:
+ head = None
+ return head
+
+
+def _import_remote_refs(
+ refs_container: RefsContainer,
+ remote_name: str,
+ refs: Dict[str, str],
+ message: Optional[bytes] = None,
+ prune: bool = False,
+ prune_tags: bool = False,
+):
+ stripped_refs = strip_peeled_refs(refs)
+ branches = {
+ n[len(LOCAL_BRANCH_PREFIX) :]: v
+ for (n, v) in stripped_refs.items()
+ if n.startswith(LOCAL_BRANCH_PREFIX)
+ }
+ refs_container.import_refs(
+ b"refs/remotes/" + remote_name.encode(),
+ branches,
+ message=message,
+ prune=prune,
+ )
+ tags = {
+ n[len(LOCAL_TAG_PREFIX) :]: v
+ for (n, v) in stripped_refs.items()
+ if n.startswith(LOCAL_TAG_PREFIX) and not n.endswith(PEELED_TAG_SUFFIX)
+ }
+ refs_container.import_refs(
+ LOCAL_TAG_PREFIX, tags, message=message, prune=prune_tags
+ )
+
+
+def serialize_refs(store, refs):
+ # TODO: Avoid recursive import :(
+ from .object_store import peel_sha
+
+ ret = {}
+ for ref, sha in refs.items():
+ try:
+ unpeeled, peeled = peel_sha(store, sha)
+ except KeyError:
+ warnings.warn(
+ "ref {} points at non-present sha {}".format(
+ ref.decode("utf-8", "replace"), sha.decode("ascii")
+ ),
+ UserWarning,
+ )
+ continue
+ else:
+ if isinstance(unpeeled, Tag):
+ ret[ref + PEELED_TAG_SUFFIX] = peeled.id
+ ret[ref] = unpeeled.id
+ return ret
diff --git a/dulwich/repo.py b/dulwich/repo.py
index bdec106d..63af3208 100644
--- a/dulwich/repo.py
+++ b/dulwich/repo.py
@@ -1,3 +1,25 @@
+# repo.py -- For dealing with git repositories.
+# Copyright (C) 2007 James Westby <jw+debian@jameswestby.net>
+# Copyright (C) 2008-2013 Jelmer Vernooij <jelmer@jelmer.uk>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
+
"""Repository access.
This module contains the base class for git repositories
@@ -5,42 +27,120 @@ This module contains the base class for git repositories
local disk (Repo).
"""
+
import os
import stat
import sys
import time
import warnings
from io import BytesIO
-from typing import TYPE_CHECKING, Any, BinaryIO, Callable, Dict, FrozenSet, Iterable, List, Optional, Set, Tuple, Union
+from typing import (
+ TYPE_CHECKING,
+ Any,
+ BinaryIO,
+ Callable,
+ Dict,
+ FrozenSet,
+ Iterable,
+ List,
+ Optional,
+ Set,
+ Tuple,
+ Union,
+)
+
if TYPE_CHECKING:
+ # There are no circular imports here, but we try to defer imports as long
+ # as possible to reduce start-up time for anything that doesn't need
+ # these imports.
from .config import ConfigFile, StackedConfig
from .index import Index
-from .errors import CommitError, HookError, NoIndexPresent, NotBlobError, NotCommitError, NotGitRepository, NotTagError, NotTreeError, RefFormatError
+
+from .errors import (
+ CommitError,
+ HookError,
+ NoIndexPresent,
+ NotBlobError,
+ NotCommitError,
+ NotGitRepository,
+ NotTagError,
+ NotTreeError,
+ RefFormatError,
+)
from .file import GitFile
-from .hooks import CommitMsgShellHook, Hook, PostCommitShellHook, PostReceiveShellHook, PreCommitShellHook
+from .hooks import (
+ CommitMsgShellHook,
+ Hook,
+ PostCommitShellHook,
+ PostReceiveShellHook,
+ PreCommitShellHook,
+)
from .line_ending import BlobNormalizer, TreeBlobNormalizer
-from .object_store import DiskObjectStore, MemoryObjectStore, MissingObjectFinder, ObjectStoreGraphWalker, PackBasedObjectStore, peel_sha
-from .objects import Blob, Commit, ObjectID, ShaFile, Tag, Tree, check_hexsha, valid_hexsha
+from .object_store import (
+ DiskObjectStore,
+ MemoryObjectStore,
+ MissingObjectFinder,
+ ObjectStoreGraphWalker,
+ PackBasedObjectStore,
+ peel_sha,
+)
+from .objects import (
+ Blob,
+ Commit,
+ ObjectID,
+ ShaFile,
+ Tag,
+ Tree,
+ check_hexsha,
+ valid_hexsha,
+)
from .pack import generate_unpacked_objects
-from .refs import ANNOTATED_TAG_SUFFIX, LOCAL_BRANCH_PREFIX, LOCAL_TAG_PREFIX, SYMREF, DictRefsContainer, DiskRefsContainer, InfoRefsContainer, Ref, RefsContainer, _set_default_branch, _set_head, _set_origin_head, check_ref_format, read_packed_refs, read_packed_refs_with_peeled, serialize_refs, write_packed_refs
-CONTROLDIR = '.git'
-OBJECTDIR = 'objects'
-REFSDIR = 'refs'
-REFSDIR_TAGS = 'tags'
-REFSDIR_HEADS = 'heads'
-INDEX_FILENAME = 'index'
-COMMONDIR = 'commondir'
-GITDIR = 'gitdir'
-WORKTREES = 'worktrees'
-BASE_DIRECTORIES = [['branches'], [REFSDIR], [REFSDIR, REFSDIR_TAGS], [
- REFSDIR, REFSDIR_HEADS], ['hooks'], ['info']]
-DEFAULT_BRANCH = b'master'
+from .refs import (
+ ANNOTATED_TAG_SUFFIX, # noqa: F401
+ LOCAL_BRANCH_PREFIX,
+ LOCAL_TAG_PREFIX, # noqa: F401
+ SYMREF, # noqa: F401
+ DictRefsContainer,
+ DiskRefsContainer,
+ InfoRefsContainer, # noqa: F401
+ Ref,
+ RefsContainer,
+ _set_default_branch,
+ _set_head,
+ _set_origin_head,
+ check_ref_format, # noqa: F401
+ read_packed_refs, # noqa: F401
+ read_packed_refs_with_peeled, # noqa: F401
+ serialize_refs,
+ write_packed_refs, # noqa: F401
+)
+
+CONTROLDIR = ".git"
+OBJECTDIR = "objects"
+REFSDIR = "refs"
+REFSDIR_TAGS = "tags"
+REFSDIR_HEADS = "heads"
+INDEX_FILENAME = "index"
+COMMONDIR = "commondir"
+GITDIR = "gitdir"
+WORKTREES = "worktrees"
+
+BASE_DIRECTORIES = [
+ ["branches"],
+ [REFSDIR],
+ [REFSDIR, REFSDIR_TAGS],
+ [REFSDIR, REFSDIR_HEADS],
+ ["hooks"],
+ ["info"],
+]
+
+DEFAULT_BRANCH = b"master"
class InvalidUserIdentity(Exception):
"""User identity is not of the format 'user <email>'."""
- def __init__(self, identity) ->None:
+ def __init__(self, identity) -> None:
self.identity = identity
@@ -48,8 +148,46 @@ class DefaultIdentityNotFound(Exception):
"""Default identity could not be determined."""
-def get_user_identity(config: 'StackedConfig', kind: Optional[str]=None
- ) ->bytes:
+# TODO(jelmer): Cache?
+def _get_default_identity() -> Tuple[str, str]:
+ import socket
+
+ for name in ("LOGNAME", "USER", "LNAME", "USERNAME"):
+ username = os.environ.get(name)
+ if username:
+ break
+ else:
+ username = None
+
+ try:
+ import pwd
+ except ImportError:
+ fullname = None
+ else:
+ try:
+ entry = pwd.getpwuid(os.getuid()) # type: ignore
+ except KeyError:
+ fullname = None
+ else:
+ if getattr(entry, "gecos", None):
+ fullname = entry.pw_gecos.split(",")[0]
+ else:
+ fullname = None
+ if username is None:
+ username = entry.pw_name
+ if not fullname:
+ if username is None:
+ raise DefaultIdentityNotFound("no username found")
+ fullname = username
+ email = os.environ.get("EMAIL")
+ if email is None:
+ if username is None:
+ raise DefaultIdentityNotFound("no username found")
+ email = f"{username}@{socket.gethostname()}"
+ return (fullname, email)
+
+
+def get_user_identity(config: "StackedConfig", kind: Optional[str] = None) -> bytes:
"""Determine the identity to use for new commits.
If kind is set, this first checks
@@ -70,7 +208,33 @@ def get_user_identity(config: 'StackedConfig', kind: Optional[str]=None
Returns:
A user identity
"""
- pass
+ user: Optional[bytes] = None
+ email: Optional[bytes] = None
+ if kind:
+ user_uc = os.environ.get("GIT_" + kind + "_NAME")
+ if user_uc is not None:
+ user = user_uc.encode("utf-8")
+ email_uc = os.environ.get("GIT_" + kind + "_EMAIL")
+ if email_uc is not None:
+ email = email_uc.encode("utf-8")
+ if user is None:
+ try:
+ user = config.get(("user",), "name")
+ except KeyError:
+ user = None
+ if email is None:
+ try:
+ email = config.get(("user",), "email")
+ except KeyError:
+ email = None
+ default_user, default_email = _get_default_identity()
+ if user is None:
+ user = default_user.encode("utf-8")
+ if email is None:
+ email = default_email.encode("utf-8")
+ if email.startswith(b"<") and email.endswith(b">"):
+ email = email[1:-1]
+ return user + b" <" + email + b">"
def check_user_identity(identity):
@@ -81,10 +245,19 @@ def check_user_identity(identity):
Raises:
InvalidUserIdentity: Raised when identity is invalid
"""
- pass
-
-
-def parse_graftpoints(graftpoints: Iterable[bytes]) ->Dict[bytes, List[bytes]]:
+ try:
+ fst, snd = identity.split(b" <", 1)
+ except ValueError as exc:
+ raise InvalidUserIdentity(identity) from exc
+ if b">" not in snd:
+ raise InvalidUserIdentity(identity)
+ if b"\0" in identity or b"\n" in identity:
+ raise InvalidUserIdentity(identity)
+
+
+def parse_graftpoints(
+ graftpoints: Iterable[bytes],
+) -> Dict[bytes, List[bytes]]:
"""Convert a list of graftpoints into a dict.
Args:
@@ -98,10 +271,24 @@ def parse_graftpoints(graftpoints: Iterable[bytes]) ->Dict[bytes, List[bytes]]:
https://git.wiki.kernel.org/index.php/GraftPoint
"""
- pass
+ grafts = {}
+ for line in graftpoints:
+ raw_graft = line.split(None, 1)
+
+ commit = raw_graft[0]
+ if len(raw_graft) == 2:
+ parents = raw_graft[1].split()
+ else:
+ parents = []
+
+ for sha in [commit, *parents]:
+ check_hexsha(sha, "Invalid graftpoint")
+ grafts[commit] = parents
+ return grafts
-def serialize_graftpoints(graftpoints: Dict[bytes, List[bytes]]) ->bytes:
+
+def serialize_graftpoints(graftpoints: Dict[bytes, List[bytes]]) -> bytes:
"""Convert a dictionary of grafts into string.
The graft dictionary is:
@@ -113,7 +300,13 @@ def serialize_graftpoints(graftpoints: Dict[bytes, List[bytes]]) ->bytes:
https://git.wiki.kernel.org/index.php/GraftPoint
"""
- pass
+ graft_lines = []
+ for commit, parents in graftpoints.items():
+ if parents:
+ graft_lines.append(commit + b" " + b" ".join(parents))
+ else:
+ graft_lines.append(commit)
+ return b"\n".join(graft_lines)
def _set_filesystem_hidden(path):
@@ -122,16 +315,40 @@ def _set_filesystem_hidden(path):
On win32 uses SetFileAttributesW api:
<https://docs.microsoft.com/windows/desktop/api/fileapi/nf-fileapi-setfileattributesw>
"""
- pass
+ if sys.platform == "win32":
+ import ctypes
+ from ctypes.wintypes import BOOL, DWORD, LPCWSTR
+ FILE_ATTRIBUTE_HIDDEN = 2
+ SetFileAttributesW = ctypes.WINFUNCTYPE(BOOL, LPCWSTR, DWORD)(
+ ("SetFileAttributesW", ctypes.windll.kernel32)
+ )
-class ParentsProvider:
+ if isinstance(path, bytes):
+ path = os.fsdecode(path)
+ if not SetFileAttributesW(path, FILE_ATTRIBUTE_HIDDEN):
+ pass # Could raise or log `ctypes.WinError()` here
+
+ # Could implement other platform specific filesystem hiding here
- def __init__(self, store, grafts={}, shallows=[]) ->None:
+
+class ParentsProvider:
+ def __init__(self, store, grafts={}, shallows=[]) -> None:
self.store = store
self.grafts = grafts
self.shallows = set(shallows)
+ def get_parents(self, commit_id, commit=None):
+ try:
+ return self.grafts[commit_id]
+ except KeyError:
+ pass
+ if commit_id in self.shallows:
+ return []
+ if commit is None:
+ commit = self.store[commit_id]
+ return commit.parents
+
class BaseRepo:
"""Base class for a git repository.
@@ -146,8 +363,7 @@ class BaseRepo:
repository
"""
- def __init__(self, object_store: PackBasedObjectStore, refs: RefsContainer
- ) ->None:
+ def __init__(self, object_store: PackBasedObjectStore, refs: RefsContainer) -> None:
"""Open a repository.
This shouldn't be called directly, but rather through one of the
@@ -159,28 +375,51 @@ class BaseRepo:
"""
self.object_store = object_store
self.refs = refs
+
self._graftpoints: Dict[bytes, List[bytes]] = {}
self.hooks: Dict[str, Hook] = {}
- def _determine_file_mode(self) ->bool:
+ def _determine_file_mode(self) -> bool:
"""Probe the file-system to determine whether permissions can be trusted.
Returns: True if permissions can be trusted, False otherwise.
"""
- pass
+ raise NotImplementedError(self._determine_file_mode)
- def _determine_symlinks(self) ->bool:
+ def _determine_symlinks(self) -> bool:
"""Probe the filesystem to determine whether symlinks can be created.
Returns: True if symlinks can be created, False otherwise.
"""
- pass
+ # For now, just mimic the old behaviour
+ return sys.platform != "win32"
- def _init_files(self, bare: bool, symlinks: Optional[bool]=None) ->None:
+ def _init_files(self, bare: bool, symlinks: Optional[bool] = None) -> None:
"""Initialize a default set of named files."""
- pass
+ from .config import ConfigFile
- def get_named_file(self, path: str) ->Optional[BinaryIO]:
+ self._put_named_file("description", b"Unnamed repository")
+ f = BytesIO()
+ cf = ConfigFile()
+ cf.set("core", "repositoryformatversion", "0")
+ if self._determine_file_mode():
+ cf.set("core", "filemode", True)
+ else:
+ cf.set("core", "filemode", False)
+
+ if symlinks is None and not bare:
+ symlinks = self._determine_symlinks()
+
+ if symlinks is False:
+ cf.set("core", "symlinks", symlinks)
+
+ cf.set("core", "bare", bare)
+ cf.set("core", "logallrefupdates", True)
+ cf.write_to_file(f)
+ self._put_named_file("config", f.getvalue())
+ self._put_named_file(os.path.join("info", "exclude"), b"")
+
+ def get_named_file(self, path: str) -> Optional[BinaryIO]:
"""Get a file from the control dir with a specific name.
Although the filename should be interpreted as a filename relative to
@@ -191,7 +430,7 @@ class BaseRepo:
path: The path to the file, relative to the control dir.
Returns: An open file object, or None if the file does not exist.
"""
- pass
+ raise NotImplementedError(self.get_named_file)
def _put_named_file(self, path: str, contents: bytes):
"""Write a file to the control dir with the given name and contents.
@@ -200,20 +439,20 @@ class BaseRepo:
path: The path to the file, relative to the control dir.
contents: A string to write to the file.
"""
- pass
+ raise NotImplementedError(self._put_named_file)
def _del_named_file(self, path: str):
"""Delete a file in the control directory with the given name."""
- pass
+ raise NotImplementedError(self._del_named_file)
- def open_index(self) ->'Index':
+ def open_index(self) -> "Index":
"""Open the index for this repository.
Raises:
NoIndexPresent: If no index is present
Returns: The matching `Index`
"""
- pass
+ raise NotImplementedError(self.open_index)
def fetch(self, target, determine_wants=None, progress=None, depth=None):
"""Fetch objects into another repository.
@@ -226,10 +465,25 @@ class BaseRepo:
depth: Optional shallow fetch depth
Returns: The local refs
"""
- pass
-
- def fetch_pack_data(self, determine_wants, graph_walker, progress,
- get_tagged=None, depth=None):
+ if determine_wants is None:
+ determine_wants = target.object_store.determine_wants_all
+ count, pack_data = self.fetch_pack_data(
+ determine_wants,
+ target.get_graph_walker(),
+ progress=progress,
+ depth=depth,
+ )
+ target.object_store.add_pack_data(count, pack_data, progress)
+ return self.get_refs()
+
+ def fetch_pack_data(
+ self,
+ determine_wants,
+ graph_walker,
+ progress,
+ get_tagged=None,
+ depth=None,
+ ):
"""Fetch the pack data required for a set of revisions.
Args:
@@ -245,10 +499,23 @@ class BaseRepo:
depth: Shallow fetch depth
Returns: count and iterator over pack data
"""
- pass
-
- def find_missing_objects(self, determine_wants, graph_walker, progress,
- get_tagged=None, depth=None) ->Optional[MissingObjectFinder]:
+ missing_objects = self.find_missing_objects(
+ determine_wants, graph_walker, progress, get_tagged, depth=depth
+ )
+ remote_has = missing_objects.get_remote_has()
+ object_ids = list(missing_objects)
+ return len(object_ids), generate_unpacked_objects(
+ self.object_store, object_ids, progress=progress, other_haves=remote_has
+ )
+
+ def find_missing_objects(
+ self,
+ determine_wants,
+ graph_walker,
+ progress,
+ get_tagged=None,
+ depth=None,
+ ) -> Optional[MissingObjectFinder]:
"""Fetch the missing objects required for a set of revisions.
Args:
@@ -264,11 +531,74 @@ class BaseRepo:
depth: Shallow fetch depth
Returns: iterator over objects, with __len__ implemented
"""
- pass
-
- def generate_pack_data(self, have: List[ObjectID], want: List[ObjectID],
- progress: Optional[Callable[[str], None]]=None, ofs_delta: Optional
- [bool]=None):
+ if depth not in (None, 0):
+ raise NotImplementedError("depth not supported yet")
+
+ refs = serialize_refs(self.object_store, self.get_refs())
+
+ wants = determine_wants(refs)
+ if not isinstance(wants, list):
+ raise TypeError("determine_wants() did not return a list")
+
+ shallows: FrozenSet[ObjectID] = getattr(graph_walker, "shallow", frozenset())
+ unshallows: FrozenSet[ObjectID] = getattr(
+ graph_walker, "unshallow", frozenset()
+ )
+
+ if wants == []:
+ # TODO(dborowitz): find a way to short-circuit that doesn't change
+ # this interface.
+
+ if shallows or unshallows:
+ # Do not send a pack in shallow short-circuit path
+ return None
+
+ class DummyMissingObjectFinder:
+ def get_remote_has(self):
+ return None
+
+ def __len__(self) -> int:
+ return 0
+
+ def __iter__(self):
+ yield from []
+
+ return DummyMissingObjectFinder() # type: ignore
+
+ # If the graph walker is set up with an implementation that can
+ # ACK/NAK to the wire, it will write data to the client through
+ # this call as a side-effect.
+ haves = self.object_store.find_common_revisions(graph_walker)
+
+ # Deal with shallow requests separately because the haves do
+ # not reflect what objects are missing
+ if shallows or unshallows:
+ # TODO: filter the haves commits from iter_shas. the specific
+ # commits aren't missing.
+ haves = []
+
+ parents_provider = ParentsProvider(self.object_store, shallows=shallows)
+
+ def get_parents(commit):
+ return parents_provider.get_parents(commit.id, commit)
+
+ return MissingObjectFinder(
+ self.object_store,
+ haves=haves,
+ wants=wants,
+ shallow=self.get_shallow(),
+ progress=progress,
+ get_tagged=get_tagged,
+ get_parents=get_parents,
+ )
+
+ def generate_pack_data(
+ self,
+ have: List[ObjectID],
+ want: List[ObjectID],
+ progress: Optional[Callable[[str], None]] = None,
+ ofs_delta: Optional[bool] = None,
+ ):
"""Generate pack data objects for a set of wants/haves.
Args:
@@ -277,10 +607,17 @@ class BaseRepo:
ofs_delta: Whether OFS deltas can be included
progress: Optional progress reporting method
"""
- pass
-
- def get_graph_walker(self, heads: Optional[List[ObjectID]]=None
- ) ->ObjectStoreGraphWalker:
+ return self.object_store.generate_pack_data(
+ have,
+ want,
+ shallow=self.get_shallow(),
+ progress=progress,
+ ofs_delta=ofs_delta,
+ )
+
+ def get_graph_walker(
+ self, heads: Optional[List[ObjectID]] = None
+ ) -> ObjectStoreGraphWalker:
"""Retrieve a graph walker.
A graph walker is used by a remote repository (or proxy)
@@ -290,20 +627,45 @@ class BaseRepo:
heads: Repository heads to use (optional)
Returns: A graph walker object
"""
- pass
-
- def get_refs(self) ->Dict[bytes, bytes]:
+ if heads is None:
+ heads = [
+ sha
+ for sha in self.refs.as_dict(b"refs/heads").values()
+ if sha in self.object_store
+ ]
+ parents_provider = ParentsProvider(self.object_store)
+ return ObjectStoreGraphWalker(
+ heads, parents_provider.get_parents, shallow=self.get_shallow()
+ )
+
+ def get_refs(self) -> Dict[bytes, bytes]:
"""Get dictionary with all refs.
Returns: A ``dict`` mapping ref names to SHA1s
"""
- pass
+ return self.refs.as_dict()
- def head(self) ->bytes:
+ def head(self) -> bytes:
"""Return the SHA1 pointed at by HEAD."""
- pass
+ return self.refs[b"HEAD"]
+
+ def _get_object(self, sha, cls):
+ assert len(sha) in (20, 40)
+ ret = self.get_object(sha)
+ if not isinstance(ret, cls):
+ if cls is Commit:
+ raise NotCommitError(ret)
+ elif cls is Blob:
+ raise NotBlobError(ret)
+ elif cls is Tree:
+ raise NotTreeError(ret)
+ elif cls is Tag:
+ raise NotTagError(ret)
+ else:
+ raise Exception(f"Type invalid: {ret.type_name!r} != {cls.type_name!r}")
+ return ret
- def get_object(self, sha: bytes) ->ShaFile:
+ def get_object(self, sha: bytes) -> ShaFile:
"""Retrieve the object with the specified SHA.
Args:
@@ -312,10 +674,16 @@ class BaseRepo:
Raises:
KeyError: when the object can not be found
"""
- pass
+ return self.object_store[sha]
- def get_parents(self, sha: bytes, commit: Optional[Commit]=None) ->List[
- bytes]:
+ def parents_provider(self) -> ParentsProvider:
+ return ParentsProvider(
+ self.object_store,
+ grafts=self._graftpoints,
+ shallows=self.get_shallow(),
+ )
+
+ def get_parents(self, sha: bytes, commit: Optional[Commit] = None) -> List[bytes]:
"""Retrieve the parents of a specific commit.
If the specific commit is a graftpoint, the graft parents
@@ -326,18 +694,18 @@ class BaseRepo:
commit: Optional commit matching the sha
Returns: List of parents
"""
- pass
+ return self.parents_provider().get_parents(sha, commit)
- def get_config(self) ->'ConfigFile':
+ def get_config(self) -> "ConfigFile":
"""Retrieve the config object.
Returns: `ConfigFile` object for the ``.git/config`` file.
"""
- pass
+ raise NotImplementedError(self.get_config)
- def get_worktree_config(self) ->'ConfigFile':
+ def get_worktree_config(self) -> "ConfigFile":
"""Retrieve the worktree config object."""
- pass
+ raise NotImplementedError(self.get_worktree_config)
def get_description(self):
"""Retrieve the description for this repository.
@@ -345,7 +713,7 @@ class BaseRepo:
Returns: String with the description of the repository
as set by the user.
"""
- pass
+ raise NotImplementedError(self.get_description)
def set_description(self, description):
"""Set the description for this repository.
@@ -353,9 +721,9 @@ class BaseRepo:
Args:
description: Text to set as description for this repository.
"""
- pass
+ raise NotImplementedError(self.set_description)
- def get_config_stack(self) ->'StackedConfig':
+ def get_config_stack(self) -> "StackedConfig":
"""Return a config stack for this repository.
This stack accesses the configuration for both this repository
@@ -364,14 +732,26 @@ class BaseRepo:
Returns: `Config` instance for this repository
"""
- pass
+ from .config import ConfigFile, StackedConfig
+
+ local_config = self.get_config()
+ backends: List[ConfigFile] = [local_config]
+ if local_config.get_boolean((b"extensions",), b"worktreeconfig", False):
+ backends.append(self.get_worktree_config())
- def get_shallow(self) ->Set[ObjectID]:
+ backends += StackedConfig.default_backends()
+ return StackedConfig(backends, writable=local_config)
+
+ def get_shallow(self) -> Set[ObjectID]:
"""Get the set of shallow commits.
Returns: Set of shallow commits.
"""
- pass
+ f = self.get_named_file("shallow")
+ if f is None:
+ return set()
+ with f:
+ return {line.strip() for line in f}
def update_shallow(self, new_shallow, new_unshallow):
"""Update the list of shallow objects.
@@ -380,9 +760,17 @@ class BaseRepo:
new_shallow: Newly shallow objects
new_unshallow: Newly no longer shallow objects
"""
- pass
+ shallow = self.get_shallow()
+ if new_shallow:
+ shallow.update(new_shallow)
+ if new_unshallow:
+ shallow.difference_update(new_unshallow)
+ if shallow:
+ self._put_named_file("shallow", b"".join([sha + b"\n" for sha in shallow]))
+ else:
+ self._del_named_file("shallow")
- def get_peeled(self, ref: Ref) ->ObjectID:
+ def get_peeled(self, ref: Ref) -> ObjectID:
"""Get the peeled value of a ref.
Args:
@@ -391,9 +779,12 @@ class BaseRepo:
intermediate tags; if the original ref does not point to a tag,
this will equal the original SHA1.
"""
- pass
+ cached = self.refs.get_peeled(ref)
+ if cached is not None:
+ return cached
+ return peel_sha(self.object_store, self.refs[ref])[1].id
- def get_walker(self, include: Optional[List[bytes]]=None, *args, **kwargs):
+ def get_walker(self, include: Optional[List[bytes]] = None, *args, **kwargs):
"""Obtain a walker for this repository.
Args:
@@ -419,7 +810,14 @@ class BaseRepo:
Walker.
Returns: A `Walker` object
"""
- pass
+ from .walk import Walker
+
+ if include is None:
+ include = [self.head()]
+
+ kwargs["get_parents"] = lambda commit: self.get_parents(commit.id, commit)
+
+ return Walker(self.object_store, include, *args, **kwargs)
def __getitem__(self, name: Union[ObjectID, Ref]):
"""Retrieve a Git object by SHA1 or ref.
@@ -431,8 +829,7 @@ class BaseRepo:
KeyError: when the specified ref or object does not exist
"""
if not isinstance(name, bytes):
- raise TypeError(
- f"'name' must be bytestring, not {type(name).__name__:.80}")
+ raise TypeError(f"'name' must be bytestring, not {type(name).__name__:.80}")
if len(name) in (20, 40):
try:
return self.object_store[name]
@@ -443,25 +840,25 @@ class BaseRepo:
except RefFormatError as exc:
raise KeyError(name) from exc
- def __contains__(self, name: bytes) ->bool:
+ def __contains__(self, name: bytes) -> bool:
"""Check if a specific Git object or ref is present.
Args:
name: Git object SHA1 or ref name
"""
- if len(name) == 20 or len(name) == 40 and valid_hexsha(name):
+ if len(name) == 20 or (len(name) == 40 and valid_hexsha(name)):
return name in self.object_store or name in self.refs
else:
return name in self.refs
- def __setitem__(self, name: bytes, value: Union[ShaFile, bytes]) ->None:
+ def __setitem__(self, name: bytes, value: Union[ShaFile, bytes]) -> None:
"""Set a ref.
Args:
name: ref name
value: Ref value - either a ShaFile object, or a hex sha
"""
- if name.startswith(b'refs/') or name == b'HEAD':
+ if name.startswith(b"refs/") or name == b"HEAD":
if isinstance(value, ShaFile):
self.refs[name] = value.id
elif isinstance(value, bytes):
@@ -471,21 +868,26 @@ class BaseRepo:
else:
raise ValueError(name)
- def __delitem__(self, name: bytes) ->None:
+ def __delitem__(self, name: bytes) -> None:
"""Remove a ref.
Args:
name: Name of the ref to remove
"""
- if name.startswith(b'refs/') or name == b'HEAD':
+ if name.startswith(b"refs/") or name == b"HEAD":
del self.refs[name]
else:
raise ValueError(name)
- def _get_user_identity(self, config: 'StackedConfig', kind: Optional[
- str]=None) ->bytes:
+ def _get_user_identity(
+ self, config: "StackedConfig", kind: Optional[str] = None
+ ) -> bytes:
"""Determine the identity to use for new commits."""
- pass
+ warnings.warn(
+ "use get_user_identity() rather than Repo._get_user_identity",
+ DeprecationWarning,
+ )
+ return get_user_identity(config)
def _add_graftpoints(self, updated_graftpoints: Dict[bytes, List[bytes]]):
"""Add or modify graftpoints.
@@ -493,22 +895,45 @@ class BaseRepo:
Args:
updated_graftpoints: Dict of commit shas to list of parent shas
"""
- pass
+ # Simple validation
+ for commit, parents in updated_graftpoints.items():
+ for sha in [commit, *parents]:
+ check_hexsha(sha, "Invalid graftpoint")
+
+ self._graftpoints.update(updated_graftpoints)
- def _remove_graftpoints(self, to_remove: List[bytes]=[]) ->None:
+ def _remove_graftpoints(self, to_remove: List[bytes] = []) -> None:
"""Remove graftpoints.
Args:
to_remove: List of commit shas
"""
- pass
-
- def do_commit(self, message: Optional[bytes]=None, committer: Optional[
- bytes]=None, author: Optional[bytes]=None, commit_timestamp=None,
- commit_timezone=None, author_timestamp=None, author_timezone=None,
- tree: Optional[ObjectID]=None, encoding: Optional[bytes]=None, ref:
- Ref=b'HEAD', merge_heads: Optional[List[ObjectID]]=None, no_verify:
- bool=False, sign: bool=False):
+ for sha in to_remove:
+ del self._graftpoints[sha]
+
+ def _read_heads(self, name):
+ f = self.get_named_file(name)
+ if f is None:
+ return []
+ with f:
+ return [line.strip() for line in f.readlines() if line.strip()]
+
+ def do_commit(
+ self,
+ message: Optional[bytes] = None,
+ committer: Optional[bytes] = None,
+ author: Optional[bytes] = None,
+ commit_timestamp=None,
+ commit_timezone=None,
+ author_timestamp=None,
+ author_timezone=None,
+ tree: Optional[ObjectID] = None,
+ encoding: Optional[bytes] = None,
+ ref: Ref = b"HEAD",
+ merge_heads: Optional[List[ObjectID]] = None,
+ no_verify: bool = False,
+ sign: bool = False,
+ ):
"""Create a new commit.
If not specified, committer and author default to
@@ -538,7 +963,124 @@ class BaseRepo:
Returns:
New commit SHA1
"""
- pass
+ try:
+ if not no_verify:
+ self.hooks["pre-commit"].execute()
+ except HookError as exc:
+ raise CommitError(exc) from exc
+ except KeyError: # no hook defined, silent fallthrough
+ pass
+
+ c = Commit()
+ if tree is None:
+ index = self.open_index()
+ c.tree = index.commit(self.object_store)
+ else:
+ if len(tree) != 40:
+ raise ValueError("tree must be a 40-byte hex sha string")
+ c.tree = tree
+
+ config = self.get_config_stack()
+ if merge_heads is None:
+ merge_heads = self._read_heads("MERGE_HEAD")
+ if committer is None:
+ committer = get_user_identity(config, kind="COMMITTER")
+ check_user_identity(committer)
+ c.committer = committer
+ if commit_timestamp is None:
+ # FIXME: Support GIT_COMMITTER_DATE environment variable
+ commit_timestamp = time.time()
+ c.commit_time = int(commit_timestamp)
+ if commit_timezone is None:
+ # FIXME: Use current user timezone rather than UTC
+ commit_timezone = 0
+ c.commit_timezone = commit_timezone
+ if author is None:
+ author = get_user_identity(config, kind="AUTHOR")
+ c.author = author
+ check_user_identity(author)
+ if author_timestamp is None:
+ # FIXME: Support GIT_AUTHOR_DATE environment variable
+ author_timestamp = commit_timestamp
+ c.author_time = int(author_timestamp)
+ if author_timezone is None:
+ author_timezone = commit_timezone
+ c.author_timezone = author_timezone
+ if encoding is None:
+ try:
+ encoding = config.get(("i18n",), "commitEncoding")
+ except KeyError:
+ pass # No dice
+ if encoding is not None:
+ c.encoding = encoding
+ if message is None:
+ # FIXME: Try to read commit message from .git/MERGE_MSG
+ raise ValueError("No commit message specified")
+
+ try:
+ if no_verify:
+ c.message = message
+ else:
+ c.message = self.hooks["commit-msg"].execute(message)
+ if c.message is None:
+ c.message = message
+ except HookError as exc:
+ raise CommitError(exc) from exc
+ except KeyError: # no hook defined, message not modified
+ c.message = message
+
+ keyid = sign if isinstance(sign, str) else None
+
+ if ref is None:
+ # Create a dangling commit
+ c.parents = merge_heads
+ if sign:
+ c.sign(keyid)
+ self.object_store.add_object(c)
+ else:
+ try:
+ old_head = self.refs[ref]
+ c.parents = [old_head, *merge_heads]
+ if sign:
+ c.sign(keyid)
+ self.object_store.add_object(c)
+ ok = self.refs.set_if_equals(
+ ref,
+ old_head,
+ c.id,
+ message=b"commit: " + message,
+ committer=committer,
+ timestamp=commit_timestamp,
+ timezone=commit_timezone,
+ )
+ except KeyError:
+ c.parents = merge_heads
+ if sign:
+ c.sign(keyid)
+ self.object_store.add_object(c)
+ ok = self.refs.add_if_new(
+ ref,
+ c.id,
+ message=b"commit: " + message,
+ committer=committer,
+ timestamp=commit_timestamp,
+ timezone=commit_timezone,
+ )
+ if not ok:
+ # Fail if the atomic compare-and-swap failed, leaving the
+ # commit and all its objects as garbage.
+ raise CommitError(f"{ref!r} changed during commit")
+
+ self._del_named_file("MERGE_HEAD")
+
+ try:
+ self.hooks["post-commit"].execute()
+ except HookError as e: # silent failure
+ warnings.warn(f"post-commit hook failed: {e}", UserWarning)
+ except KeyError: # no hook defined, silent fallthrough
+ pass
+
+ return c.id
def read_gitfile(f):
@@ -550,20 +1092,23 @@ def read_gitfile(f):
f: File-like object to read from
Returns: A path
"""
- pass
+ cs = f.read()
+ if not cs.startswith("gitdir: "):
+ raise ValueError("Expected file to start with 'gitdir: '")
+ return cs[len("gitdir: ") :].rstrip("\n")
class UnsupportedVersion(Exception):
"""Unsupported repository version."""
- def __init__(self, version) ->None:
+ def __init__(self, version) -> None:
self.version = version
class UnsupportedExtension(Exception):
"""Unsupported repository extension."""
- def __init__(self, extension) ->None:
+ def __init__(self, extension) -> None:
self.extension = extension
@@ -584,22 +1129,31 @@ class Repo(BaseRepo):
directory (if the repository is bare)
bare: Whether this is a bare repository
"""
+
path: str
bare: bool
- def __init__(self, root: str, object_store: Optional[
- PackBasedObjectStore]=None, bare: Optional[bool]=None) ->None:
+ def __init__(
+ self,
+ root: str,
+ object_store: Optional[PackBasedObjectStore] = None,
+ bare: Optional[bool] = None,
+ ) -> None:
hidden_path = os.path.join(root, CONTROLDIR)
if bare is None:
- if os.path.isfile(hidden_path) or os.path.isdir(os.path.join(
- hidden_path, OBJECTDIR)):
+ if os.path.isfile(hidden_path) or os.path.isdir(
+ os.path.join(hidden_path, OBJECTDIR)
+ ):
bare = False
- elif os.path.isdir(os.path.join(root, OBJECTDIR)
- ) and os.path.isdir(os.path.join(root, REFSDIR)):
+ elif os.path.isdir(os.path.join(root, OBJECTDIR)) and os.path.isdir(
+ os.path.join(root, REFSDIR)
+ ):
bare = True
else:
- raise NotGitRepository('No git repository was found at {path}'
- .format(**dict(path=root)))
+ raise NotGitRepository(
+ "No git repository was found at {path}".format(**dict(path=root))
+ )
+
self.bare = bare
if bare is False:
if os.path.isfile(hidden_path):
@@ -613,48 +1167,85 @@ class Repo(BaseRepo):
commondir = self.get_named_file(COMMONDIR)
if commondir is not None:
with commondir:
- self._commondir = os.path.join(self.controldir(), os.
- fsdecode(commondir.read().rstrip(b'\r\n')))
+ self._commondir = os.path.join(
+ self.controldir(),
+ os.fsdecode(commondir.read().rstrip(b"\r\n")),
+ )
else:
self._commondir = self._controldir
self.path = root
config = self.get_config()
try:
- repository_format_version = config.get('core',
- 'repositoryformatversion')
- format_version = 0 if repository_format_version is None else int(
- repository_format_version)
+ repository_format_version = config.get("core", "repositoryformatversion")
+ format_version = (
+ 0
+ if repository_format_version is None
+ else int(repository_format_version)
+ )
except KeyError:
format_version = 0
+
if format_version not in (0, 1):
raise UnsupportedVersion(format_version)
- for extension, _value in config.items((b'extensions',)):
- if extension.lower() not in (b'worktreeconfig',):
+
+ for extension, _value in config.items((b"extensions",)):
+ if extension.lower() not in (b"worktreeconfig",):
raise UnsupportedExtension(extension)
+
if object_store is None:
- object_store = DiskObjectStore.from_config(os.path.join(self.
- commondir(), OBJECTDIR), config)
- refs = DiskRefsContainer(self.commondir(), self._controldir, logger
- =self._write_reflog)
+ object_store = DiskObjectStore.from_config(
+ os.path.join(self.commondir(), OBJECTDIR), config
+ )
+ refs = DiskRefsContainer(
+ self.commondir(), self._controldir, logger=self._write_reflog
+ )
BaseRepo.__init__(self, object_store, refs)
+
self._graftpoints = {}
- graft_file = self.get_named_file(os.path.join('info', 'grafts'),
- basedir=self.commondir())
+ graft_file = self.get_named_file(
+ os.path.join("info", "grafts"), basedir=self.commondir()
+ )
if graft_file:
with graft_file:
self._graftpoints.update(parse_graftpoints(graft_file))
- graft_file = self.get_named_file('shallow', basedir=self.commondir())
+ graft_file = self.get_named_file("shallow", basedir=self.commondir())
if graft_file:
with graft_file:
self._graftpoints.update(parse_graftpoints(graft_file))
- self.hooks['pre-commit'] = PreCommitShellHook(self.path, self.
- controldir())
- self.hooks['commit-msg'] = CommitMsgShellHook(self.controldir())
- self.hooks['post-commit'] = PostCommitShellHook(self.controldir())
- self.hooks['post-receive'] = PostReceiveShellHook(self.controldir())
+
+ self.hooks["pre-commit"] = PreCommitShellHook(self.path, self.controldir())
+ self.hooks["commit-msg"] = CommitMsgShellHook(self.controldir())
+ self.hooks["post-commit"] = PostCommitShellHook(self.controldir())
+ self.hooks["post-receive"] = PostReceiveShellHook(self.controldir())
+
+ def _write_reflog(
+ self, ref, old_sha, new_sha, committer, timestamp, timezone, message
+ ):
+ from .reflog import format_reflog_line
+
+ path = os.path.join(self.controldir(), "logs", os.fsdecode(ref))
+ try:
+ os.makedirs(os.path.dirname(path))
+ except FileExistsError:
+ pass
+ if committer is None:
+ config = self.get_config_stack()
+ committer = self._get_user_identity(config)
+ check_user_identity(committer)
+ if timestamp is None:
+ timestamp = int(time.time())
+ if timezone is None:
+ timezone = 0 # FIXME
+ with open(path, "ab") as f:
+ f.write(
+ format_reflog_line(
+ old_sha, new_sha, committer, timestamp, timezone, message
+ )
+ + b"\n"
+ )
@classmethod
- def discover(cls, start='.'):
+ def discover(cls, start="."):
"""Iterate parent directories to discover a repository.
Return a Repo object for the first parent directory that looks like a
@@ -663,11 +1254,20 @@ class Repo(BaseRepo):
Args:
start: The directory to start discovery from (defaults to '.')
"""
- pass
+ remaining = True
+ path = os.path.abspath(start)
+ while remaining:
+ try:
+ return cls(path)
+ except NotGitRepository:
+ path, remaining = os.path.split(path)
+ raise NotGitRepository(
+ "No git repository was found at {path}".format(**dict(path=start))
+ )
def controldir(self):
"""Return the path of the control directory."""
- pass
+ return self._controldir
def commondir(self):
"""Return the path of the common directory.
@@ -677,21 +1277,38 @@ class Repo(BaseRepo):
For a linked working tree, it is the control directory of the
main working tree.
"""
- pass
+ return self._commondir
def _determine_file_mode(self):
"""Probe the file-system to determine whether permissions can be trusted.
Returns: True if permissions can be trusted, False otherwise.
"""
- pass
+ fname = os.path.join(self.path, ".probe-permissions")
+ with open(fname, "w") as f:
+ f.write("")
+
+ st1 = os.lstat(fname)
+ try:
+ os.chmod(fname, st1.st_mode ^ stat.S_IXUSR)
+ except PermissionError:
+ return False
+ st2 = os.lstat(fname)
+
+ os.unlink(fname)
+
+ mode_differs = st1.st_mode != st2.st_mode
+ st2_has_exec = (st2.st_mode & stat.S_IXUSR) != 0
+
+ return mode_differs and st2_has_exec
def _determine_symlinks(self):
"""Probe the filesystem to determine whether symlinks can be created.
Returns: True if symlinks can be created, False otherwise.
"""
- pass
+ # TODO(jelmer): Actually probe disk / look at filesystem
+ return sys.platform != "win32"
def _put_named_file(self, path, contents):
"""Write a file to the control dir with the given name and contents.
@@ -700,7 +1317,15 @@ class Repo(BaseRepo):
path: The path to the file, relative to the control dir.
contents: A string to write to the file.
"""
- pass
+ path = path.lstrip(os.path.sep)
+ with GitFile(os.path.join(self.controldir(), path), "wb") as f:
+ f.write(contents)
+
+ def _del_named_file(self, path):
+ try:
+ os.unlink(os.path.join(self.controldir(), path))
+ except FileNotFoundError:
+ return
def get_named_file(self, path, basedir=None):
"""Get a file from the control dir with a specific name.
@@ -715,33 +1340,104 @@ class Repo(BaseRepo):
control dir.
Returns: An open file object, or None if the file does not exist.
"""
- pass
+ # TODO(dborowitz): sanitize filenames, since this is used directly by
+ # the dumb web serving code.
+ if basedir is None:
+ basedir = self.controldir()
+ path = path.lstrip(os.path.sep)
+ try:
+ return open(os.path.join(basedir, path), "rb")
+ except FileNotFoundError:
+ return None
def index_path(self):
"""Return path to the index file."""
- pass
+ return os.path.join(self.controldir(), INDEX_FILENAME)
- def open_index(self) ->'Index':
+ def open_index(self) -> "Index":
"""Open the index for this repository.
Raises:
NoIndexPresent: If no index is present
Returns: The matching `Index`
"""
- pass
+ from .index import Index
+
+ if not self.has_index():
+ raise NoIndexPresent
+ return Index(self.index_path())
def has_index(self):
"""Check if an index is present."""
- pass
-
- def stage(self, fs_paths: Union[str, bytes, os.PathLike, Iterable[Union
- [str, bytes, os.PathLike]]]) ->None:
+ # Bare repos must never have index files; non-bare repos may have a
+ # missing index file, which is treated as empty.
+ return not self.bare
+
+ def stage(
+ self,
+ fs_paths: Union[
+ str, bytes, os.PathLike, Iterable[Union[str, bytes, os.PathLike]]
+ ],
+ ) -> None:
"""Stage a set of paths.
Args:
fs_paths: List of paths, relative to the repository path
"""
- pass
+ root_path_bytes = os.fsencode(self.path)
+
+ if isinstance(fs_paths, (str, bytes, os.PathLike)):
+ fs_paths = [fs_paths]
+ fs_paths = list(fs_paths)
+
+ from .index import (
+ _fs_to_tree_path,
+ blob_from_path_and_stat,
+ index_entry_from_directory,
+ index_entry_from_stat,
+ )
+
+ index = self.open_index()
+ blob_normalizer = self.get_blob_normalizer()
+ for fs_path in fs_paths:
+ if not isinstance(fs_path, bytes):
+ fs_path = os.fsencode(fs_path)
+ if os.path.isabs(fs_path):
+ raise ValueError(
+ f"path {fs_path!r} should be relative to "
+ "repository root, not absolute"
+ )
+ tree_path = _fs_to_tree_path(fs_path)
+ full_path = os.path.join(root_path_bytes, fs_path)
+ try:
+ st = os.lstat(full_path)
+ except OSError:
+ # File no longer exists
+ try:
+ del index[tree_path]
+ except KeyError:
+ pass # already removed
+ else:
+ if stat.S_ISDIR(st.st_mode):
+ entry = index_entry_from_directory(st, full_path)
+ if entry:
+ index[tree_path] = entry
+ else:
+ try:
+ del index[tree_path]
+ except KeyError:
+ pass
+ elif not stat.S_ISREG(st.st_mode) and not stat.S_ISLNK(st.st_mode):
+ try:
+ del index[tree_path]
+ except KeyError:
+ pass
+ else:
+ blob = blob_from_path_and_stat(full_path, st)
+ blob = blob_normalizer.checkin_normalize(blob, fs_path)
+ self.object_store.add_object(blob)
+ index[tree_path] = index_entry_from_stat(st, blob.id)
+ index.write()
def unstage(self, fs_paths: List[str]):
"""Unstage specific file in the index
@@ -749,11 +1445,68 @@ class Repo(BaseRepo):
fs_paths: a list of files to unstage,
relative to the repository path.
"""
- pass
+ from .index import IndexEntry, _fs_to_tree_path
+
+ index = self.open_index()
+ try:
+ tree_id = self[b"HEAD"].tree
+ except KeyError:
+ # no head mean no commit in the repo
+ for fs_path in fs_paths:
+ tree_path = _fs_to_tree_path(fs_path)
+ del index[tree_path]
+ index.write()
+ return
+
+ for fs_path in fs_paths:
+ tree_path = _fs_to_tree_path(fs_path)
+ try:
+ tree = self.object_store[tree_id]
+ assert isinstance(tree, Tree)
+ tree_entry = tree.lookup_path(self.object_store.__getitem__, tree_path)
+ except KeyError:
+ # if tree_entry didn't exist, this file was being added, so
+ # remove index entry
+ try:
+ del index[tree_path]
+ continue
+ except KeyError as exc:
+ raise KeyError(f"file '{tree_path.decode()}' not in index") from exc
+
+ st = None
+ try:
+ st = os.lstat(os.path.join(self.path, fs_path))
+ except FileNotFoundError:
+ pass
- def clone(self, target_path, *, mkdir=True, bare=False, origin=
- b'origin', checkout=None, branch=None, progress=None, depth=None,
- symlinks=None) ->'Repo':
+ index_entry = IndexEntry(
+ ctime=(self[b"HEAD"].commit_time, 0),
+ mtime=(self[b"HEAD"].commit_time, 0),
+ dev=st.st_dev if st else 0,
+ ino=st.st_ino if st else 0,
+ mode=tree_entry[0],
+ uid=st.st_uid if st else 0,
+ gid=st.st_gid if st else 0,
+ size=len(self[tree_entry[1]].data),
+ sha=tree_entry[1],
+ )
+
+ index[tree_path] = index_entry
+ index.write()
+
+ def clone(
+ self,
+ target_path,
+ *,
+ mkdir=True,
+ bare=False,
+ origin=b"origin",
+ checkout=None,
+ branch=None,
+ progress=None,
+ depth=None,
+ symlinks=None,
+ ) -> "Repo":
"""Clone this repository.
Args:
@@ -770,32 +1523,157 @@ class Repo(BaseRepo):
symlinks: Symlinks setting (default to autodetect)
Returns: Created repository as `Repo`
"""
- pass
+ encoded_path = os.fsencode(self.path)
+
+ if mkdir:
+ os.mkdir(target_path)
+
+ try:
+ if not bare:
+ target = Repo.init(target_path, symlinks=symlinks)
+ if checkout is None:
+ checkout = True
+ else:
+ if checkout:
+ raise ValueError("checkout and bare are incompatible")
+ target = Repo.init_bare(target_path)
- def reset_index(self, tree: Optional[bytes]=None):
+ try:
+ target_config = target.get_config()
+ target_config.set((b"remote", origin), b"url", encoded_path)
+ target_config.set(
+ (b"remote", origin),
+ b"fetch",
+ b"+refs/heads/*:refs/remotes/" + origin + b"/*",
+ )
+ target_config.write_to_path()
+
+ ref_message = b"clone: from " + encoded_path
+ self.fetch(target, depth=depth)
+ target.refs.import_refs(
+ b"refs/remotes/" + origin,
+ self.refs.as_dict(b"refs/heads"),
+ message=ref_message,
+ )
+ target.refs.import_refs(
+ b"refs/tags", self.refs.as_dict(b"refs/tags"), message=ref_message
+ )
+
+ head_chain, origin_sha = self.refs.follow(b"HEAD")
+ origin_head = head_chain[-1] if head_chain else None
+ if origin_sha and not origin_head:
+ # set detached HEAD
+ target.refs[b"HEAD"] = origin_sha
+ else:
+ _set_origin_head(target.refs, origin, origin_head)
+ head_ref = _set_default_branch(
+ target.refs, origin, origin_head, branch, ref_message
+ )
+
+ # Update target head
+ if head_ref:
+ head = _set_head(target.refs, head_ref, ref_message)
+ else:
+ head = None
+
+ if checkout and head is not None:
+ target.reset_index()
+ except BaseException:
+ target.close()
+ raise
+ except BaseException:
+ if mkdir:
+ import shutil
+
+ shutil.rmtree(target_path)
+ raise
+ return target
+
+ def reset_index(self, tree: Optional[bytes] = None):
"""Reset the index back to a specific tree.
Args:
tree: Tree SHA to reset to, None for current HEAD tree.
"""
- pass
+ from .index import (
+ build_index_from_tree,
+ symlink,
+ validate_path_element_default,
+ validate_path_element_ntfs,
+ )
+
+ if tree is None:
+ head = self[b"HEAD"]
+ if isinstance(head, Tag):
+ _cls, obj = head.object
+ head = self.get_object(obj)
+ tree = head.tree
+ config = self.get_config()
+ honor_filemode = config.get_boolean(b"core", b"filemode", os.name != "nt")
+ if config.get_boolean(b"core", b"core.protectNTFS", os.name == "nt"):
+ validate_path_element = validate_path_element_ntfs
+ else:
+ validate_path_element = validate_path_element_default
+ if config.get_boolean(b"core", b"symlinks", True):
+ symlink_fn = symlink
+ else:
+
+ def symlink_fn(source, target): # type: ignore
+ with open(
+ target, "w" + ("b" if isinstance(source, bytes) else "")
+ ) as f:
+ f.write(source)
+
+ return build_index_from_tree(
+ self.path,
+ self.index_path(),
+ self.object_store,
+ tree,
+ honor_filemode=honor_filemode,
+ validate_path_element=validate_path_element,
+ symlink_fn=symlink_fn,
+ )
+
+ def get_worktree_config(self) -> "ConfigFile":
+ from .config import ConfigFile
+
+ path = os.path.join(self.commondir(), "config.worktree")
+ try:
+ return ConfigFile.from_path(path)
+ except FileNotFoundError:
+ cf = ConfigFile()
+ cf.path = path
+ return cf
- def get_config(self) ->'ConfigFile':
+ def get_config(self) -> "ConfigFile":
"""Retrieve the config object.
Returns: `ConfigFile` object for the ``.git/config`` file.
"""
- pass
+ from .config import ConfigFile
+
+ path = os.path.join(self._commondir, "config")
+ try:
+ return ConfigFile.from_path(path)
+ except FileNotFoundError:
+ ret = ConfigFile()
+ ret.path = path
+ return ret
def get_description(self):
"""Retrieve the description of this repository.
Returns: A string describing the repository or None.
"""
- pass
+ path = os.path.join(self._controldir, "description")
+ try:
+ with GitFile(path, "rb") as f:
+ return f.read()
+ except FileNotFoundError:
+ return None
- def __repr__(self) ->str:
- return f'<Repo at {self.path!r}>'
+ def __repr__(self) -> str:
+ return f"<Repo at {self.path!r}>"
def set_description(self, description):
"""Set the description for this repository.
@@ -803,11 +1681,47 @@ class Repo(BaseRepo):
Args:
description: Text to set as description for this repository.
"""
- pass
+ self._put_named_file("description", description)
@classmethod
- def init(cls, path: str, *, mkdir: bool=False, config=None,
- default_branch=None, symlinks: Optional[bool]=None) ->'Repo':
+ def _init_maybe_bare(
+ cls,
+ path,
+ controldir,
+ bare,
+ object_store=None,
+ config=None,
+ default_branch=None,
+ symlinks: Optional[bool] = None,
+ ):
+ for d in BASE_DIRECTORIES:
+ os.mkdir(os.path.join(controldir, *d))
+ if object_store is None:
+ object_store = DiskObjectStore.init(os.path.join(controldir, OBJECTDIR))
+ ret = cls(path, bare=bare, object_store=object_store)
+ if default_branch is None:
+ if config is None:
+ from .config import StackedConfig
+
+ config = StackedConfig.default()
+ try:
+ default_branch = config.get("init", "defaultBranch")
+ except KeyError:
+ default_branch = DEFAULT_BRANCH
+ ret.refs.set_symbolic_ref(b"HEAD", LOCAL_BRANCH_PREFIX + default_branch)
+ ret._init_files(bare=bare, symlinks=symlinks)
+ return ret
+
+ @classmethod
+ def init(
+ cls,
+ path: str,
+ *,
+ mkdir: bool = False,
+ config=None,
+ default_branch=None,
+ symlinks: Optional[bool] = None,
+ ) -> "Repo":
"""Create a new repository.
Args:
@@ -815,11 +1729,22 @@ class Repo(BaseRepo):
mkdir: Whether to create the directory
Returns: `Repo` instance
"""
- pass
+ if mkdir:
+ os.mkdir(path)
+ controldir = os.path.join(path, CONTROLDIR)
+ os.mkdir(controldir)
+ _set_filesystem_hidden(controldir)
+ return cls._init_maybe_bare(
+ path,
+ controldir,
+ False,
+ config=config,
+ default_branch=default_branch,
+ symlinks=symlinks,
+ )
@classmethod
- def _init_new_working_directory(cls, path, main_repo, identifier=None,
- mkdir=False):
+ def _init_new_working_directory(cls, path, main_repo, identifier=None, mkdir=False):
"""Create a new working directory linked to a repository.
Args:
@@ -829,11 +1754,37 @@ class Repo(BaseRepo):
mkdir: Whether to create the directory
Returns: `Repo` instance
"""
- pass
+ if mkdir:
+ os.mkdir(path)
+ if identifier is None:
+ identifier = os.path.basename(path)
+ main_worktreesdir = os.path.join(main_repo.controldir(), WORKTREES)
+ worktree_controldir = os.path.join(main_worktreesdir, identifier)
+ gitdirfile = os.path.join(path, CONTROLDIR)
+ with open(gitdirfile, "wb") as f:
+ f.write(b"gitdir: " + os.fsencode(worktree_controldir) + b"\n")
+ try:
+ os.mkdir(main_worktreesdir)
+ except FileExistsError:
+ pass
+ try:
+ os.mkdir(worktree_controldir)
+ except FileExistsError:
+ pass
+ with open(os.path.join(worktree_controldir, GITDIR), "wb") as f:
+ f.write(os.fsencode(gitdirfile) + b"\n")
+ with open(os.path.join(worktree_controldir, COMMONDIR), "wb") as f:
+ f.write(b"../..\n")
+ with open(os.path.join(worktree_controldir, "HEAD"), "wb") as f:
+ f.write(main_repo.head() + b"\n")
+ r = cls(path)
+ r.reset_index()
+ return r
@classmethod
- def init_bare(cls, path, *, mkdir=False, object_store=None, config=None,
- default_branch=None):
+ def init_bare(
+ cls, path, *, mkdir=False, object_store=None, config=None, default_branch=None
+ ):
"""Create a new bare repository.
``path`` should already exist and be an empty directory.
@@ -842,12 +1793,22 @@ class Repo(BaseRepo):
path: Path to create bare repository in
Returns: a `Repo` instance
"""
- pass
+ if mkdir:
+ os.mkdir(path)
+ return cls._init_maybe_bare(
+ path,
+ path,
+ True,
+ object_store=object_store,
+ config=config,
+ default_branch=default_branch,
+ )
+
create = init_bare
def close(self):
"""Close any files opened by this repository."""
- pass
+ self.object_store.close()
def __enter__(self):
return self
@@ -857,7 +1818,19 @@ class Repo(BaseRepo):
def get_blob_normalizer(self):
"""Return a BlobNormalizer object."""
- pass
+ # TODO Parse the git attributes files
+ git_attributes = {}
+ config_stack = self.get_config_stack()
+ try:
+ tree = self.object_store[self.refs[b"HEAD"]].tree
+ return TreeBlobNormalizer(
+ config_stack,
+ git_attributes,
+ self.object_store,
+ tree,
+ )
+ except KeyError:
+ return BlobNormalizer(config_stack, git_attributes)
class MemoryRepo(BaseRepo):
@@ -867,29 +1840,39 @@ class MemoryRepo(BaseRepo):
those have a stronger dependency on the filesystem.
"""
- def __init__(self) ->None:
+ def __init__(self) -> None:
from .config import ConfigFile
+
self._reflog: List[Any] = []
refs_container = DictRefsContainer({}, logger=self._append_reflog)
- BaseRepo.__init__(self, MemoryObjectStore(), refs_container)
+ BaseRepo.__init__(self, MemoryObjectStore(), refs_container) # type: ignore
self._named_files: Dict[str, bytes] = {}
self.bare = True
self._config = ConfigFile()
self._description = None
+ def _append_reflog(self, *args):
+ self._reflog.append(args)
+
+ def set_description(self, description):
+ self._description = description
+
+ def get_description(self):
+ return self._description
+
def _determine_file_mode(self):
"""Probe the file-system to determine whether permissions can be trusted.
Returns: True if permissions can be trusted, False otherwise.
"""
- pass
+ return sys.platform != "win32"
def _determine_symlinks(self):
"""Probe the file-system to determine whether permissions can be trusted.
Returns: True if permissions can be trusted, False otherwise.
"""
- pass
+ return sys.platform != "win32"
def _put_named_file(self, path, contents):
"""Write a file to the control dir with the given name and contents.
@@ -898,7 +1881,13 @@ class MemoryRepo(BaseRepo):
path: The path to the file, relative to the control dir.
contents: A string to write to the file.
"""
- pass
+ self._named_files[path] = contents
+
+ def _del_named_file(self, path):
+ try:
+ del self._named_files[path]
+ except KeyError:
+ pass
def get_named_file(self, path, basedir=None):
"""Get a file from the control dir with a specific name.
@@ -911,7 +1900,10 @@ class MemoryRepo(BaseRepo):
path: The path to the file, relative to the control dir.
Returns: An open file object, or None if the file does not exist.
"""
- pass
+ contents = self._named_files.get(path, None)
+ if contents is None:
+ return None
+ return BytesIO(contents)
def open_index(self):
"""Fail to open index for this repo, since it is bare.
@@ -919,14 +1911,14 @@ class MemoryRepo(BaseRepo):
Raises:
NoIndexPresent: Raised when no index is present
"""
- pass
+ raise NoIndexPresent
def get_config(self):
"""Retrieve the config object.
Returns: `ConfigFile` object.
"""
- pass
+ return self._config
@classmethod
def init_bare(cls, objects, refs):
@@ -938,4 +1930,10 @@ class MemoryRepo(BaseRepo):
refs: Refs as dictionary, mapping names
to object SHA1s
"""
- pass
+ ret = cls()
+ for obj in objects:
+ ret.object_store.add_object(obj)
+ for refname, sha in refs.items():
+ ret.refs.add_if_new(refname, sha)
+ ret._init_files(bare=True)
+ return ret
diff --git a/dulwich/server.py b/dulwich/server.py
index 77efd9ac..281577fb 100644
--- a/dulwich/server.py
+++ b/dulwich/server.py
@@ -1,3 +1,24 @@
+# server.py -- Implementation of the server side git protocols
+# Copyright (C) 2008 John Carr <john.carr@unrouted.co.uk>
+# Copyright(C) 2011-2012 Jelmer Vernooij <jelmer@jelmer.uk>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Git smart network protocol server implementation.
For more detailed implementation on the network protocol, see the
@@ -20,6 +41,7 @@ Currently supported capabilities:
* shallow
* symref
"""
+
import collections
import os
import socket
@@ -30,15 +52,68 @@ import zlib
from functools import partial
from typing import Dict, Iterable, List, Optional, Set, Tuple, cast
from typing import Protocol as TypingProtocol
+
from dulwich import log_utils
+
from .archive import tar_stream
-from .errors import ApplyDeltaError, ChecksumMismatch, GitProtocolError, HookError, NotGitRepository, ObjectFormatException, UnexpectedCommandError
+from .errors import (
+ ApplyDeltaError,
+ ChecksumMismatch,
+ GitProtocolError,
+ HookError,
+ NotGitRepository,
+ ObjectFormatException,
+ UnexpectedCommandError,
+)
from .object_store import peel_sha
from .objects import Commit, ObjectID, valid_hexsha
from .pack import ObjectContainer, PackedObjectContainer, write_pack_from_container
-from .protocol import CAPABILITIES_REF, CAPABILITY_AGENT, CAPABILITY_DELETE_REFS, CAPABILITY_INCLUDE_TAG, CAPABILITY_MULTI_ACK, CAPABILITY_MULTI_ACK_DETAILED, CAPABILITY_NO_DONE, CAPABILITY_NO_PROGRESS, CAPABILITY_OFS_DELTA, CAPABILITY_QUIET, CAPABILITY_REPORT_STATUS, CAPABILITY_SHALLOW, CAPABILITY_SIDE_BAND_64K, CAPABILITY_THIN_PACK, COMMAND_DEEPEN, COMMAND_DONE, COMMAND_HAVE, COMMAND_SHALLOW, COMMAND_UNSHALLOW, COMMAND_WANT, MULTI_ACK, MULTI_ACK_DETAILED, NAK_LINE, SIDE_BAND_CHANNEL_DATA, SIDE_BAND_CHANNEL_FATAL, SIDE_BAND_CHANNEL_PROGRESS, SINGLE_ACK, TCP_GIT_PORT, ZERO_SHA, BufferedPktLineWriter, Protocol, ReceivableProtocol, ack_type, capability_agent, extract_capabilities, extract_want_line_capabilities, format_ack_line, format_ref_line, format_shallow_line, format_unshallow_line, symref_capabilities
+from .protocol import (
+ CAPABILITIES_REF,
+ CAPABILITY_AGENT,
+ CAPABILITY_DELETE_REFS,
+ CAPABILITY_INCLUDE_TAG,
+ CAPABILITY_MULTI_ACK,
+ CAPABILITY_MULTI_ACK_DETAILED,
+ CAPABILITY_NO_DONE,
+ CAPABILITY_NO_PROGRESS,
+ CAPABILITY_OFS_DELTA,
+ CAPABILITY_QUIET,
+ CAPABILITY_REPORT_STATUS,
+ CAPABILITY_SHALLOW,
+ CAPABILITY_SIDE_BAND_64K,
+ CAPABILITY_THIN_PACK,
+ COMMAND_DEEPEN,
+ COMMAND_DONE,
+ COMMAND_HAVE,
+ COMMAND_SHALLOW,
+ COMMAND_UNSHALLOW,
+ COMMAND_WANT,
+ MULTI_ACK,
+ MULTI_ACK_DETAILED,
+ NAK_LINE,
+ SIDE_BAND_CHANNEL_DATA,
+ SIDE_BAND_CHANNEL_FATAL,
+ SIDE_BAND_CHANNEL_PROGRESS,
+ SINGLE_ACK,
+ TCP_GIT_PORT,
+ ZERO_SHA,
+ BufferedPktLineWriter,
+ Protocol,
+ ReceivableProtocol,
+ ack_type,
+ capability_agent,
+ extract_capabilities,
+ extract_want_line_capabilities,
+ format_ack_line,
+ format_ref_line,
+ format_shallow_line,
+ format_unshallow_line,
+ symref_capabilities,
+)
from .refs import PEELED_TAG_SUFFIX, RefsContainer, write_info_refs
from .repo import BaseRepo, Repo
+
logger = log_utils.getLogger(__name__)
@@ -54,7 +129,7 @@ class Backend:
NotGitRepository: no git repository was found at path
Returns: Instance of BackendRepo
"""
- pass
+ raise NotImplementedError(self.open_repository)
class BackendRepo(TypingProtocol):
@@ -63,17 +138,18 @@ class BackendRepo(TypingProtocol):
The methods required here are a subset of those provided by
dulwich.repo.Repo.
"""
+
object_store: PackedObjectContainer
refs: RefsContainer
- def get_refs(self) ->Dict[bytes, bytes]:
+ def get_refs(self) -> Dict[bytes, bytes]:
"""Get all the refs in the repository.
Returns: dict of name -> sha
"""
- pass
+ raise NotImplementedError
- def get_peeled(self, name: bytes) ->Optional[bytes]:
+ def get_peeled(self, name: bytes) -> Optional[bytes]:
"""Return the cached peeled value of a ref, if available.
Args:
@@ -83,10 +159,11 @@ class BackendRepo(TypingProtocol):
information about a tag is available, this method may return None,
but it should attempt to peel the tag if possible.
"""
- pass
+ return None
- def find_missing_objects(self, determine_wants, graph_walker, progress,
- get_tagged=None):
+ def find_missing_objects(
+ self, determine_wants, graph_walker, progress, get_tagged=None
+ ):
"""Yield the objects required for a list of commits.
Args:
@@ -94,60 +171,167 @@ class BackendRepo(TypingProtocol):
get_tagged: Function that returns a dict of pointed-to sha ->
tag sha for including tags.
"""
- pass
+ raise NotImplementedError
class DictBackend(Backend):
"""Trivial backend that looks up Git repositories in a dictionary."""
- def __init__(self, repos) ->None:
+ def __init__(self, repos) -> None:
self.repos = repos
+ def open_repository(self, path: str) -> BaseRepo:
+ logger.debug("Opening repository at %s", path)
+ try:
+ return self.repos[path]
+ except KeyError as exc:
+ raise NotGitRepository(
+ "No git repository was found at {path}".format(**dict(path=path))
+ ) from exc
+
class FileSystemBackend(Backend):
"""Simple backend looking up Git repositories in the local file system."""
- def __init__(self, root=os.sep) ->None:
+ def __init__(self, root=os.sep) -> None:
super().__init__()
- self.root = (os.path.abspath(root) + os.sep).replace(os.sep * 2, os.sep
- )
+ self.root = (os.path.abspath(root) + os.sep).replace(os.sep * 2, os.sep)
+
+ def open_repository(self, path):
+ logger.debug("opening repository at %s", path)
+ abspath = os.path.abspath(os.path.join(self.root, path)) + os.sep
+ normcase_abspath = os.path.normcase(abspath)
+ normcase_root = os.path.normcase(self.root)
+ if not normcase_abspath.startswith(normcase_root):
+ raise NotGitRepository(f"Path {path!r} not inside root {self.root!r}")
+ return Repo(abspath)
class Handler:
"""Smart protocol command handler base class."""
- def __init__(self, backend, proto, stateless_rpc=False) ->None:
+ def __init__(self, backend, proto, stateless_rpc=False) -> None:
self.backend = backend
self.proto = proto
self.stateless_rpc = stateless_rpc
+ def handle(self) -> None:
+ raise NotImplementedError(self.handle)
+
class PackHandler(Handler):
"""Protocol handler for packs."""
- def __init__(self, backend, proto, stateless_rpc=False) ->None:
+ def __init__(self, backend, proto, stateless_rpc=False) -> None:
super().__init__(backend, proto, stateless_rpc)
self._client_capabilities: Optional[Set[bytes]] = None
+ # Flags needed for the no-done capability
self._done_received = False
@classmethod
- def required_capabilities(cls) ->Iterable[bytes]:
+ def capabilities(cls) -> Iterable[bytes]:
+ raise NotImplementedError(cls.capabilities)
+
+ @classmethod
+ def innocuous_capabilities(cls) -> Iterable[bytes]:
+ return [
+ CAPABILITY_INCLUDE_TAG,
+ CAPABILITY_THIN_PACK,
+ CAPABILITY_NO_PROGRESS,
+ CAPABILITY_OFS_DELTA,
+ capability_agent(),
+ ]
+
+ @classmethod
+ def required_capabilities(cls) -> Iterable[bytes]:
"""Return a list of capabilities that we require the client to have."""
- pass
+ return []
+
+ def set_client_capabilities(self, caps: Iterable[bytes]) -> None:
+ allowable_caps = set(self.innocuous_capabilities())
+ allowable_caps.update(self.capabilities())
+ for cap in caps:
+ if cap.startswith(CAPABILITY_AGENT + b"="):
+ continue
+ if cap not in allowable_caps:
+ raise GitProtocolError(
+ f"Client asked for capability {cap!r} that " "was not advertised."
+ )
+ for cap in self.required_capabilities():
+ if cap not in caps:
+ raise GitProtocolError(
+ "Client does not support required " f"capability {cap!r}."
+ )
+ self._client_capabilities = set(caps)
+ logger.info("Client capabilities: %s", caps)
+
+ def has_capability(self, cap: bytes) -> bool:
+ if self._client_capabilities is None:
+ raise GitProtocolError(
+ f"Server attempted to access capability {cap!r} " "before asking client"
+ )
+ return cap in self._client_capabilities
+
+ def notify_done(self) -> None:
+ self._done_received = True
class UploadPackHandler(PackHandler):
"""Protocol handler for uploading a pack to the client."""
- def __init__(self, backend, args, proto, stateless_rpc=False,
- advertise_refs=False) ->None:
+ def __init__(
+ self, backend, args, proto, stateless_rpc=False, advertise_refs=False
+ ) -> None:
super().__init__(backend, proto, stateless_rpc=stateless_rpc)
self.repo = backend.open_repository(args[0])
self._graph_walker = None
self.advertise_refs = advertise_refs
+ # A state variable for denoting that the have list is still
+ # being processed, and the client is not accepting any other
+ # data (such as side-band, see the progress method here).
self._processing_have_lines = False
- def get_tagged(self, refs=None, repo=None) ->Dict[ObjectID, ObjectID]:
+ @classmethod
+ def capabilities(cls):
+ return [
+ CAPABILITY_MULTI_ACK_DETAILED,
+ CAPABILITY_MULTI_ACK,
+ CAPABILITY_SIDE_BAND_64K,
+ CAPABILITY_THIN_PACK,
+ CAPABILITY_OFS_DELTA,
+ CAPABILITY_NO_PROGRESS,
+ CAPABILITY_INCLUDE_TAG,
+ CAPABILITY_SHALLOW,
+ CAPABILITY_NO_DONE,
+ ]
+
+ @classmethod
+ def required_capabilities(cls):
+ return (
+ CAPABILITY_SIDE_BAND_64K,
+ CAPABILITY_THIN_PACK,
+ CAPABILITY_OFS_DELTA,
+ )
+
+ def progress(self, message: bytes):
+ pass
+
+ def _start_pack_send_phase(self):
+ if self.has_capability(CAPABILITY_SIDE_BAND_64K):
+ # The provided haves are processed, and it is safe to send side-
+ # band data now.
+ if not self.has_capability(CAPABILITY_NO_PROGRESS):
+ self.progress = partial(
+ self.proto.write_sideband, SIDE_BAND_CHANNEL_PROGRESS
+ )
+
+ self.write_pack_data = partial(
+ self.proto.write_sideband, SIDE_BAND_CHANNEL_DATA
+ )
+ else:
+ self.write_pack_data = self.proto.write
+
+ def get_tagged(self, refs=None, repo=None) -> Dict[ObjectID, ObjectID]:
"""Get a dict of peeled values of tags to their original tag shas.
Args:
@@ -158,7 +342,78 @@ class UploadPackHandler(PackHandler):
Returns: dict of peeled_sha -> tag_sha, where tag_sha is the sha of a
tag whose peeled value is peeled_sha.
"""
- pass
+ if not self.has_capability(CAPABILITY_INCLUDE_TAG):
+ return {}
+ if refs is None:
+ refs = self.repo.get_refs()
+ if repo is None:
+ repo = getattr(self.repo, "repo", None)
+ if repo is None:
+ # Bail if we don't have a Repo available; this is ok since
+ # clients must be able to handle if the server doesn't include
+ # all relevant tags.
+ # TODO: fix behavior when missing
+ return {}
+ # TODO(jelmer): Integrate this with the refs logic in
+ # Repo.find_missing_objects
+ tagged = {}
+ for name, sha in refs.items():
+ peeled_sha = repo.get_peeled(name)
+ if peeled_sha != sha:
+ tagged[peeled_sha] = sha
+ return tagged
+
+ def handle(self):
+ # Note the fact that client is only processing responses related
+ # to the have lines it sent, and any other data (including side-
+ # band) will be be considered a fatal error.
+ self._processing_have_lines = True
+
+ graph_walker = _ProtocolGraphWalker(
+ self,
+ self.repo.object_store,
+ self.repo.get_peeled,
+ self.repo.refs.get_symrefs,
+ )
+ wants = []
+
+ def wants_wrapper(refs, **kwargs):
+ wants.extend(graph_walker.determine_wants(refs, **kwargs))
+ return wants
+
+ missing_objects = self.repo.find_missing_objects(
+ wants_wrapper,
+ graph_walker,
+ self.progress,
+ get_tagged=self.get_tagged,
+ )
+
+ object_ids = list(missing_objects)
+
+ # Did the process short-circuit (e.g. in a stateless RPC call)? Note
+ # that the client still expects a 0-object pack in most cases.
+ # Also, if it also happens that the object_iter is instantiated
+ # with a graph walker with an implementation that talks over the
+ # wire (which is this instance of this class) this will actually
+ # iterate through everything and write things out to the wire.
+ if len(wants) == 0:
+ return
+
+ if not graph_walker.handle_done(
+ not self.has_capability(CAPABILITY_NO_DONE), self._done_received
+ ):
+ return
+
+ self._start_pack_send_phase()
+ self.progress(
+ ("counting objects: %d, done.\n" % len(object_ids)).encode("ascii")
+ )
+
+ write_pack_from_container(
+ self.write_pack_data, self.repo.object_store, object_ids
+ )
+ # we are done
+ self.proto.write_pkt_line(None)
def _split_proto_line(line, allowed):
@@ -180,7 +435,28 @@ def _split_proto_line(line, allowed):
UnexpectedCommandError: if the line cannot be parsed into one of the
allowed return values.
"""
- pass
+ if not line:
+ fields = [None]
+ else:
+ fields = line.rstrip(b"\n").split(b" ", 1)
+ command = fields[0]
+ if allowed is not None and command not in allowed:
+ raise UnexpectedCommandError(command)
+ if len(fields) == 1 and command in (COMMAND_DONE, None):
+ return (command, None)
+ elif len(fields) == 2:
+ if command in (
+ COMMAND_WANT,
+ COMMAND_HAVE,
+ COMMAND_SHALLOW,
+ COMMAND_UNSHALLOW,
+ ):
+ if not valid_hexsha(fields[1]):
+ raise GitProtocolError("Invalid sha")
+ return tuple(fields)
+ elif command == COMMAND_DEEPEN:
+ return command, int(fields[1])
+ raise GitProtocolError(f"Received invalid line from client: {line!r}")
def _find_shallow(store: ObjectContainer, heads, depth):
@@ -195,7 +471,56 @@ def _find_shallow(store: ObjectContainer, heads, depth):
considered shallow and unshallow according to the arguments. Note that
these sets may overlap if a commit is reachable along multiple paths.
"""
- pass
+ parents: Dict[bytes, List[bytes]] = {}
+
+ def get_parents(sha):
+ result = parents.get(sha, None)
+ if not result:
+ result = store[sha].parents
+ parents[sha] = result
+ return result
+
+ todo = [] # stack of (sha, depth)
+ for head_sha in heads:
+ _unpeeled, peeled = peel_sha(store, head_sha)
+ if isinstance(peeled, Commit):
+ todo.append((peeled.id, 1))
+
+ not_shallow = set()
+ shallow = set()
+ while todo:
+ sha, cur_depth = todo.pop()
+ if cur_depth < depth:
+ not_shallow.add(sha)
+ new_depth = cur_depth + 1
+ todo.extend((p, new_depth) for p in get_parents(sha))
+ else:
+ shallow.add(sha)
+
+ return shallow, not_shallow
+
+
+def _want_satisfied(store: ObjectContainer, haves, want, earliest):
+ o = store[want]
+ pending = collections.deque([o])
+ known = {want}
+ while pending:
+ commit = pending.popleft()
+ if commit.id in haves:
+ return True
+ if not isinstance(commit, Commit):
+ # non-commit wants are assumed to be satisfied
+ continue
+ for parent in commit.parents:
+ if parent in known:
+ continue
+ known.add(parent)
+ parent_obj = store[parent]
+ assert isinstance(parent_obj, Commit)
+ # TODO: handle parents with later commit times than children
+ if parent_obj.commit_time >= earliest:
+ pending.append(parent_obj)
+ return False
def _all_wants_satisfied(store: ObjectContainer, haves, wants):
@@ -208,7 +533,17 @@ def _all_wants_satisfied(store: ObjectContainer, haves, wants):
Note: Wants are specified with set_wants rather than passed in since
in the current interface they are determined outside this class.
"""
- pass
+ haves = set(haves)
+ if haves:
+ have_objs = [store[h] for h in haves]
+ earliest = min([h.commit_time for h in have_objs if isinstance(h, Commit)])
+ else:
+ earliest = 0
+ for want in wants:
+ if not _want_satisfied(store, haves, want, earliest):
+ return False
+
+ return True
class _ProtocolGraphWalker:
@@ -225,8 +560,9 @@ class _ProtocolGraphWalker:
any calls to next() or ack() are made.
"""
- def __init__(self, handler, object_store: ObjectContainer, get_peeled,
- get_symrefs) ->None:
+ def __init__(
+ self, handler, object_store: ObjectContainer, get_peeled, get_symrefs
+ ) -> None:
self.handler = handler
self.store: ObjectContainer = object_store
self.get_peeled = get_peeled
@@ -261,7 +597,97 @@ class _ProtocolGraphWalker:
heads: a dict of refname->SHA1 to advertise
Returns: a list of SHA1s requested by the client
"""
+ symrefs = self.get_symrefs()
+ values = set(heads.values())
+ if self.advertise_refs or not self.stateless_rpc:
+ for i, (ref, sha) in enumerate(sorted(heads.items())):
+ try:
+ peeled_sha = self.get_peeled(ref)
+ except KeyError:
+ # Skip refs that are inaccessible
+ # TODO(jelmer): Integrate with Repo.find_missing_objects refs
+ # logic.
+ continue
+ if i == 0:
+ logger.info("Sending capabilities: %s", self.handler.capabilities())
+ line = format_ref_line(
+ ref,
+ sha,
+ self.handler.capabilities()
+ + symref_capabilities(symrefs.items()),
+ )
+ else:
+ line = format_ref_line(ref, sha)
+ self.proto.write_pkt_line(line)
+ if peeled_sha != sha:
+ self.proto.write_pkt_line(
+ format_ref_line(ref + PEELED_TAG_SUFFIX, peeled_sha)
+ )
+
+ # i'm done..
+ self.proto.write_pkt_line(None)
+
+ if self.advertise_refs:
+ return []
+
+ # Now client will sending want want want commands
+ want = self.proto.read_pkt_line()
+ if not want:
+ return []
+ line, caps = extract_want_line_capabilities(want)
+ self.handler.set_client_capabilities(caps)
+ self.set_ack_type(ack_type(caps))
+ allowed = (COMMAND_WANT, COMMAND_SHALLOW, COMMAND_DEEPEN, None)
+ command, sha = _split_proto_line(line, allowed)
+
+ want_revs = []
+ while command == COMMAND_WANT:
+ if sha not in values:
+ raise GitProtocolError(f"Client wants invalid object {sha}")
+ want_revs.append(sha)
+ command, sha = self.read_proto_line(allowed)
+
+ self.set_wants(want_revs)
+ if command in (COMMAND_SHALLOW, COMMAND_DEEPEN):
+ self.unread_proto_line(command, sha)
+ self._handle_shallow_request(want_revs)
+
+ if self.stateless_rpc and self.proto.eof():
+ # The client may close the socket at this point, expecting a
+ # flush-pkt from the server. We might be ready to send a packfile
+ # at this point, so we need to explicitly short-circuit in this
+ # case.
+ return []
+
+ return want_revs
+
+ def unread_proto_line(self, command, value):
+ if isinstance(value, int):
+ value = str(value).encode("ascii")
+ self.proto.unread_pkt_line(command + b" " + value)
+
+ def nak(self):
pass
+
+ def ack(self, have_ref):
+ if len(have_ref) != 40:
+ raise ValueError(f"invalid sha {have_ref!r}")
+ return self._impl.ack(have_ref)
+
+ def reset(self):
+ self._cached = True
+ self._cache_index = 0
+
+ def next(self):
+ if not self._cached:
+ if not self._impl and self.stateless_rpc:
+ return None
+ return next(self._impl)
+ self._cache_index += 1
+ if self._cache_index > len(self._cache):
+ return None
+ return self._cache[self._cache_index]
+
__next__ = next
def read_proto_line(self, allowed):
@@ -274,7 +700,48 @@ class _ProtocolGraphWalker:
Raises:
UnexpectedCommandError: If an error occurred reading the line.
"""
- pass
+ return _split_proto_line(self.proto.read_pkt_line(), allowed)
+
+ def _handle_shallow_request(self, wants):
+ while True:
+ command, val = self.read_proto_line((COMMAND_DEEPEN, COMMAND_SHALLOW))
+ if command == COMMAND_DEEPEN:
+ depth = val
+ break
+ self.client_shallow.add(val)
+ self.read_proto_line((None,)) # consume client's flush-pkt
+
+ shallow, not_shallow = _find_shallow(self.store, wants, depth)
+
+ # Update self.shallow instead of reassigning it since we passed a
+ # reference to it before this method was called.
+ self.shallow.update(shallow - not_shallow)
+ new_shallow = self.shallow - self.client_shallow
+ unshallow = self.unshallow = not_shallow & self.client_shallow
+
+ for sha in sorted(new_shallow):
+ self.proto.write_pkt_line(format_shallow_line(sha))
+ for sha in sorted(unshallow):
+ self.proto.write_pkt_line(format_unshallow_line(sha))
+
+ self.proto.write_pkt_line(None)
+
+ def notify_done(self):
+ # relay the message down to the handler.
+ self.handler.notify_done()
+
+ def send_ack(self, sha, ack_type=b""):
+ self.proto.write_pkt_line(format_ack_line(sha, ack_type))
+
+ def send_nak(self):
+ self.proto.write_pkt_line(NAK_LINE)
+
+ def handle_done(self, done_required, done_received):
+ # Delegate this to the implementation.
+ return self._impl.handle_done(done_required, done_received)
+
+ def set_wants(self, wants):
+ self._wants = wants
def all_wants_satisfied(self, haves):
"""Check whether all the current wants are satisfied by a set of haves.
@@ -284,92 +751,483 @@ class _ProtocolGraphWalker:
Note: Wants are specified with set_wants rather than passed in since
in the current interface they are determined outside this class.
"""
- pass
+ return _all_wants_satisfied(self.store, haves, self._wants)
+
+ def set_ack_type(self, ack_type):
+ impl_classes = {
+ MULTI_ACK: MultiAckGraphWalkerImpl,
+ MULTI_ACK_DETAILED: MultiAckDetailedGraphWalkerImpl,
+ SINGLE_ACK: SingleAckGraphWalkerImpl,
+ }
+ self._impl = impl_classes[ack_type](self)
-_GRAPH_WALKER_COMMANDS = COMMAND_HAVE, COMMAND_DONE, None
+_GRAPH_WALKER_COMMANDS = (COMMAND_HAVE, COMMAND_DONE, None)
class SingleAckGraphWalkerImpl:
"""Graph walker implementation that speaks the single-ack protocol."""
- def __init__(self, walker) ->None:
+ def __init__(self, walker) -> None:
self.walker = walker
self._common: List[bytes] = []
+
+ def ack(self, have_ref):
+ if not self._common:
+ self.walker.send_ack(have_ref)
+ self._common.append(have_ref)
+
+ def next(self):
+ command, sha = self.walker.read_proto_line(_GRAPH_WALKER_COMMANDS)
+ if command in (None, COMMAND_DONE):
+ # defer the handling of done
+ self.walker.notify_done()
+ return None
+ elif command == COMMAND_HAVE:
+ return sha
+
__next__ = next
+ def handle_done(self, done_required, done_received):
+ if not self._common:
+ self.walker.send_nak()
+
+ if done_required and not done_received:
+ # we are not done, especially when done is required; skip
+ # the pack for this request and especially do not handle
+ # the done.
+ return False
+
+ if not done_received and not self._common:
+ # Okay we are not actually done then since the walker picked
+ # up no haves. This is usually triggered when client attempts
+ # to pull from a source that has no common base_commit.
+ # See: test_server.MultiAckDetailedGraphWalkerImplTestCase.\
+ # test_multi_ack_stateless_nodone
+ return False
+
+ return True
+
class MultiAckGraphWalkerImpl:
"""Graph walker implementation that speaks the multi-ack protocol."""
- def __init__(self, walker) ->None:
+ def __init__(self, walker) -> None:
self.walker = walker
self._found_base = False
self._common: List[bytes] = []
+
+ def ack(self, have_ref):
+ self._common.append(have_ref)
+ if not self._found_base:
+ self.walker.send_ack(have_ref, b"continue")
+ if self.walker.all_wants_satisfied(self._common):
+ self._found_base = True
+ # else we blind ack within next
+
+ def next(self):
+ while True:
+ command, sha = self.walker.read_proto_line(_GRAPH_WALKER_COMMANDS)
+ if command is None:
+ self.walker.send_nak()
+ # in multi-ack mode, a flush-pkt indicates the client wants to
+ # flush but more have lines are still coming
+ continue
+ elif command == COMMAND_DONE:
+ self.walker.notify_done()
+ return None
+ elif command == COMMAND_HAVE:
+ if self._found_base:
+ # blind ack
+ self.walker.send_ack(sha, b"continue")
+ return sha
+
__next__ = next
+ def handle_done(self, done_required, done_received):
+ if done_required and not done_received:
+ # we are not done, especially when done is required; skip
+ # the pack for this request and especially do not handle
+ # the done.
+ return False
+
+ if not done_received and not self._common:
+ # Okay we are not actually done then since the walker picked
+ # up no haves. This is usually triggered when client attempts
+ # to pull from a source that has no common base_commit.
+ # See: test_server.MultiAckDetailedGraphWalkerImplTestCase.\
+ # test_multi_ack_stateless_nodone
+ return False
+
+ # don't nak unless no common commits were found, even if not
+ # everything is satisfied
+ if self._common:
+ self.walker.send_ack(self._common[-1])
+ else:
+ self.walker.send_nak()
+ return True
+
class MultiAckDetailedGraphWalkerImpl:
"""Graph walker implementation speaking the multi-ack-detailed protocol."""
- def __init__(self, walker) ->None:
+ def __init__(self, walker) -> None:
self.walker = walker
self._common: List[bytes] = []
+
+ def ack(self, have_ref):
+ # Should only be called iff have_ref is common
+ self._common.append(have_ref)
+ self.walker.send_ack(have_ref, b"common")
+
+ def next(self):
+ while True:
+ command, sha = self.walker.read_proto_line(_GRAPH_WALKER_COMMANDS)
+ if command is None:
+ if self.walker.all_wants_satisfied(self._common):
+ self.walker.send_ack(self._common[-1], b"ready")
+ self.walker.send_nak()
+ if self.walker.stateless_rpc:
+ # The HTTP version of this request a flush-pkt always
+ # signifies an end of request, so we also return
+ # nothing here as if we are done (but not really, as
+ # it depends on whether no-done capability was
+ # specified and that's handled in handle_done which
+ # may or may not call post_nodone_check depending on
+ # that).
+ return None
+ elif command == COMMAND_DONE:
+ # Let the walker know that we got a done.
+ self.walker.notify_done()
+ break
+ elif command == COMMAND_HAVE:
+ # return the sha and let the caller ACK it with the
+ # above ack method.
+ return sha
+ # don't nak unless no common commits were found, even if not
+ # everything is satisfied
+
__next__ = next
+ def handle_done(self, done_required, done_received):
+ if done_required and not done_received:
+ # we are not done, especially when done is required; skip
+ # the pack for this request and especially do not handle
+ # the done.
+ return False
+
+ if not done_received and not self._common:
+ # Okay we are not actually done then since the walker picked
+ # up no haves. This is usually triggered when client attempts
+ # to pull from a source that has no common base_commit.
+ # See: test_server.MultiAckDetailedGraphWalkerImplTestCase.\
+ # test_multi_ack_stateless_nodone
+ return False
+
+ # don't nak unless no common commits were found, even if not
+ # everything is satisfied
+ if self._common:
+ self.walker.send_ack(self._common[-1])
+ else:
+ self.walker.send_nak()
+ return True
+
class ReceivePackHandler(PackHandler):
"""Protocol handler for downloading a pack from the client."""
- def __init__(self, backend, args, proto, stateless_rpc=False,
- advertise_refs=False) ->None:
+ def __init__(
+ self, backend, args, proto, stateless_rpc=False, advertise_refs=False
+ ) -> None:
super().__init__(backend, proto, stateless_rpc=stateless_rpc)
self.repo = backend.open_repository(args[0])
self.advertise_refs = advertise_refs
+ @classmethod
+ def capabilities(cls) -> Iterable[bytes]:
+ return [
+ CAPABILITY_REPORT_STATUS,
+ CAPABILITY_DELETE_REFS,
+ CAPABILITY_QUIET,
+ CAPABILITY_OFS_DELTA,
+ CAPABILITY_SIDE_BAND_64K,
+ CAPABILITY_NO_DONE,
+ ]
+
+ def _apply_pack(
+ self, refs: List[Tuple[bytes, bytes, bytes]]
+ ) -> List[Tuple[bytes, bytes]]:
+ all_exceptions = (
+ IOError,
+ OSError,
+ ChecksumMismatch,
+ ApplyDeltaError,
+ AssertionError,
+ socket.error,
+ zlib.error,
+ ObjectFormatException,
+ )
+ status = []
+ will_send_pack = False
+
+ for command in refs:
+ if command[1] != ZERO_SHA:
+ will_send_pack = True
+
+ if will_send_pack:
+ # TODO: more informative error messages than just the exception
+ # string
+ try:
+ recv = getattr(self.proto, "recv", None)
+ self.repo.object_store.add_thin_pack(self.proto.read, recv)
+ status.append((b"unpack", b"ok"))
+ except all_exceptions as e:
+ status.append((b"unpack", str(e).replace("\n", "").encode("utf-8")))
+ # The pack may still have been moved in, but it may contain
+ # broken objects. We trust a later GC to clean it up.
+ else:
+ # The git protocol want to find a status entry related to unpack
+ # process even if no pack data has been sent.
+ status.append((b"unpack", b"ok"))
+
+ for oldsha, sha, ref in refs:
+ ref_status = b"ok"
+ try:
+ if sha == ZERO_SHA:
+ if CAPABILITY_DELETE_REFS not in self.capabilities():
+ raise GitProtocolError(
+ "Attempted to delete refs without delete-refs "
+ "capability."
+ )
+ try:
+ self.repo.refs.remove_if_equals(ref, oldsha)
+ except all_exceptions:
+ ref_status = b"failed to delete"
+ else:
+ try:
+ self.repo.refs.set_if_equals(ref, oldsha, sha)
+ except all_exceptions:
+ ref_status = b"failed to write"
+ except KeyError:
+ ref_status = b"bad ref"
+ status.append((ref, ref_status))
+
+ return status
+
+ def _report_status(self, status: List[Tuple[bytes, bytes]]) -> None:
+ if self.has_capability(CAPABILITY_SIDE_BAND_64K):
+ writer = BufferedPktLineWriter(
+ lambda d: self.proto.write_sideband(SIDE_BAND_CHANNEL_DATA, d)
+ )
+ write = writer.write
+
+ def flush():
+ writer.flush()
+ self.proto.write_pkt_line(None)
+
+ else:
+ write = self.proto.write_pkt_line
+
+ def flush():
+ pass
+
+ for name, msg in status:
+ if name == b"unpack":
+ write(b"unpack " + msg + b"\n")
+ elif msg == b"ok":
+ write(b"ok " + name + b"\n")
+ else:
+ write(b"ng " + name + b" " + msg + b"\n")
+ write(None)
+ flush()
+
+ def _on_post_receive(self, client_refs):
+ hook = self.repo.hooks.get("post-receive", None)
+ if not hook:
+ return
+ try:
+ output = hook.execute(client_refs)
+ if output:
+ self.proto.write_sideband(SIDE_BAND_CHANNEL_PROGRESS, output)
+ except HookError as err:
+ self.proto.write_sideband(SIDE_BAND_CHANNEL_FATAL, str(err).encode("utf-8"))
+
+ def handle(self) -> None:
+ if self.advertise_refs or not self.stateless_rpc:
+ refs = sorted(self.repo.get_refs().items())
+ symrefs = sorted(self.repo.refs.get_symrefs().items())
+
+ if not refs:
+ refs = [(CAPABILITIES_REF, ZERO_SHA)]
+ logger.info("Sending capabilities: %s", self.capabilities())
+ self.proto.write_pkt_line(
+ format_ref_line(
+ refs[0][0],
+ refs[0][1],
+ self.capabilities() + symref_capabilities(symrefs),
+ )
+ )
+ for i in range(1, len(refs)):
+ ref = refs[i]
+ self.proto.write_pkt_line(format_ref_line(ref[0], ref[1]))
-class UploadArchiveHandler(Handler):
+ self.proto.write_pkt_line(None)
+ if self.advertise_refs:
+ return
- def __init__(self, backend, args, proto, stateless_rpc=False) ->None:
+ client_refs = []
+ ref = self.proto.read_pkt_line()
+
+ # if ref is none then client doesn't want to send us anything..
+ if ref is None:
+ return
+
+ ref, caps = extract_capabilities(ref)
+ self.set_client_capabilities(caps)
+
+ # client will now send us a list of (oldsha, newsha, ref)
+ while ref:
+ client_refs.append(ref.split())
+ ref = self.proto.read_pkt_line()
+
+ # backend can now deal with this refs and read a pack using self.read
+ status = self._apply_pack(client_refs)
+
+ self._on_post_receive(client_refs)
+
+ # when we have read all the pack from the client, send a status report
+ # if the client asked for it
+ if self.has_capability(CAPABILITY_REPORT_STATUS):
+ self._report_status(status)
+
+
+class UploadArchiveHandler(Handler):
+ def __init__(self, backend, args, proto, stateless_rpc=False) -> None:
super().__init__(backend, proto, stateless_rpc)
self.repo = backend.open_repository(args[0])
-
-DEFAULT_HANDLERS = {b'git-upload-pack': UploadPackHandler,
- b'git-receive-pack': ReceivePackHandler, b'git-upload-archive':
- UploadArchiveHandler}
+ def handle(self) -> None:
+ def write(x):
+ return self.proto.write_sideband(SIDE_BAND_CHANNEL_DATA, x)
+
+ arguments = []
+ for pkt in self.proto.read_pkt_seq():
+ (key, value) = pkt.split(b" ", 1)
+ if key != b"argument":
+ raise GitProtocolError(f"unknown command {key}")
+ arguments.append(value.rstrip(b"\n"))
+ prefix = b""
+ format = "tar"
+ i = 0
+ store: ObjectContainer = self.repo.object_store
+ while i < len(arguments):
+ argument = arguments[i]
+ if argument == b"--prefix":
+ i += 1
+ prefix = arguments[i]
+ elif argument == b"--format":
+ i += 1
+ format = arguments[i].decode("ascii")
+ else:
+ commit_sha = self.repo.refs[argument]
+ tree = store[cast(Commit, store[commit_sha]).tree]
+ i += 1
+ self.proto.write_pkt_line(b"ACK")
+ self.proto.write_pkt_line(None)
+ for chunk in tar_stream(
+ store, tree, mtime=time.time(), prefix=prefix, format=format
+ ):
+ write(chunk)
+ self.proto.write_pkt_line(None)
+
+
+# Default handler classes for git services.
+DEFAULT_HANDLERS = {
+ b"git-upload-pack": UploadPackHandler,
+ b"git-receive-pack": ReceivePackHandler,
+ b"git-upload-archive": UploadArchiveHandler,
+}
class TCPGitRequestHandler(socketserver.StreamRequestHandler):
-
- def __init__(self, handlers, *args, **kwargs) ->None:
+ def __init__(self, handlers, *args, **kwargs) -> None:
self.handlers = handlers
socketserver.StreamRequestHandler.__init__(self, *args, **kwargs)
+ def handle(self):
+ proto = ReceivableProtocol(self.connection.recv, self.wfile.write)
+ command, args = proto.read_cmd()
+ logger.info("Handling %s request, args=%s", command, args)
+
+ cls = self.handlers.get(command, None)
+ if not callable(cls):
+ raise GitProtocolError(f"Invalid service {command}")
+ h = cls(self.server.backend, args, proto)
+ h.handle()
+
class TCPGitServer(socketserver.TCPServer):
allow_reuse_address = True
serve = socketserver.TCPServer.serve_forever
- def __init__(self, backend, listen_addr, port=TCP_GIT_PORT, handlers=None
- ) ->None:
+ def _make_handler(self, *args, **kwargs):
+ return TCPGitRequestHandler(self.handlers, *args, **kwargs)
+
+ def __init__(self, backend, listen_addr, port=TCP_GIT_PORT, handlers=None) -> None:
self.handlers = dict(DEFAULT_HANDLERS)
if handlers is not None:
self.handlers.update(handlers)
self.backend = backend
- logger.info('Listening for TCP connections on %s:%d', listen_addr, port
- )
- socketserver.TCPServer.__init__(self, (listen_addr, port), self.
- _make_handler)
+ logger.info("Listening for TCP connections on %s:%d", listen_addr, port)
+ socketserver.TCPServer.__init__(self, (listen_addr, port), self._make_handler)
+ def verify_request(self, request, client_address):
+ logger.info("Handling request from %s", client_address)
+ return True
-def main(argv=sys.argv):
- """Entry point for starting a TCP git server."""
- pass
+ def handle_error(self, request, client_address):
+ logger.exception(
+ "Exception happened during processing of request " "from %s",
+ client_address,
+ )
-def serve_command(handler_cls, argv=sys.argv, backend=None, inf=sys.stdin,
- outf=sys.stdout):
+def main(argv=sys.argv):
+ """Entry point for starting a TCP git server."""
+ import optparse
+
+ parser = optparse.OptionParser()
+ parser.add_option(
+ "-l",
+ "--listen_address",
+ dest="listen_address",
+ default="localhost",
+ help="Binding IP address.",
+ )
+ parser.add_option(
+ "-p",
+ "--port",
+ dest="port",
+ type=int,
+ default=TCP_GIT_PORT,
+ help="Binding TCP port.",
+ )
+ options, args = parser.parse_args(argv)
+
+ log_utils.default_logging_config()
+ if len(args) > 1:
+ gitdir = args[1]
+ else:
+ gitdir = "."
+ # TODO(jelmer): Support git-daemon-export-ok and --export-all.
+ backend = FileSystemBackend(gitdir)
+ server = TCPGitServer(backend, options.listen_address, options.port)
+ server.serve_forever()
+
+
+def serve_command(
+ handler_cls, argv=sys.argv, backend=None, inf=sys.stdin, outf=sys.stdout
+):
"""Serve a single command.
This is mostly useful for the implementation of commands used by e.g.
@@ -383,17 +1241,30 @@ def serve_command(handler_cls, argv=sys.argv, backend=None, inf=sys.stdin,
outf: File-like object to write to, defaults to standard output.
Returns: Exit code for use with sys.exit. 0 on success, 1 on failure.
"""
- pass
+ if backend is None:
+ backend = FileSystemBackend()
+
+ def send_fn(data):
+ outf.write(data)
+ outf.flush()
+
+ proto = Protocol(inf.read, send_fn)
+ handler = handler_cls(backend, argv[1:], proto)
+ # FIXME: Catch exceptions and write a single-line summary to outf.
+ handler.handle()
+ return 0
def generate_info_refs(repo):
"""Generate an info refs file."""
- pass
+ refs = repo.get_refs()
+ return write_info_refs(refs, repo.object_store)
def generate_objects_info_packs(repo):
"""Generate an index for for packs."""
- pass
+ for pack in repo.object_store.packs:
+ yield (b"P " + os.fsencode(pack.data.filename) + b"\n")
def update_server_info(repo):
@@ -402,8 +1273,15 @@ def update_server_info(repo):
This generates info/refs and objects/info/packs,
similar to "git update-server-info".
"""
- pass
+ repo._put_named_file(
+ os.path.join("info", "refs"), b"".join(generate_info_refs(repo))
+ )
+
+ repo._put_named_file(
+ os.path.join("objects", "info", "packs"),
+ b"".join(generate_objects_info_packs(repo)),
+ )
-if __name__ == '__main__':
+if __name__ == "__main__":
main()
diff --git a/dulwich/stash.py b/dulwich/stash.py
index c4d9b763..0b577241 100644
--- a/dulwich/stash.py
+++ b/dulwich/stash.py
@@ -1,9 +1,32 @@
+# stash.py
+# Copyright (C) 2018 Jelmer Vernooij <jelmer@samba.org>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Stash handling."""
+
import os
+
from .file import GitFile
from .index import commit_tree, iter_fresh_objects
from .reflog import drop_reflog_entry, read_reflog
-DEFAULT_STASH_REF = b'refs/stash'
+
+DEFAULT_STASH_REF = b"refs/stash"
class Stash:
@@ -12,18 +35,39 @@ class Stash:
Note that this doesn't currently update the working tree.
"""
- def __init__(self, repo, ref=DEFAULT_STASH_REF) ->None:
+ def __init__(self, repo, ref=DEFAULT_STASH_REF) -> None:
self._ref = ref
self._repo = repo
+ @property
+ def _reflog_path(self):
+ return os.path.join(self._repo.commondir(), "logs", os.fsdecode(self._ref))
+
+ def stashes(self):
+ try:
+ with GitFile(self._reflog_path, "rb") as f:
+ return reversed(list(read_reflog(f)))
+ except FileNotFoundError:
+ return []
+
@classmethod
def from_repo(cls, repo):
"""Create a new stash from a Repo object."""
- pass
+ return cls(repo)
def drop(self, index):
"""Drop entry with specified index."""
- pass
+ with open(self._reflog_path, "rb+") as f:
+ drop_reflog_entry(f, index, rewrite=True)
+ if len(self) == 0:
+ os.remove(self._reflog_path)
+ del self._repo.refs[self._ref]
+ return
+ if index == 0:
+ self._repo.refs[self._ref] = self[0].new_sha
+
+ def pop(self, index):
+ raise NotImplementedError(self.pop)
def push(self, committer=None, author=None, message=None):
"""Create a new stash.
@@ -33,10 +77,53 @@ class Stash:
author: Optional author name to use
message: Optional commit message
"""
- pass
+ # First, create the index commit.
+ commit_kwargs = {}
+ if committer is not None:
+ commit_kwargs["committer"] = committer
+ if author is not None:
+ commit_kwargs["author"] = author
+
+ index = self._repo.open_index()
+ index_tree_id = index.commit(self._repo.object_store)
+ index_commit_id = self._repo.do_commit(
+ ref=None,
+ tree=index_tree_id,
+ message=b"Index stash",
+ merge_heads=[self._repo.head()],
+ no_verify=True,
+ **commit_kwargs,
+ )
+
+ # Then, the working tree one.
+ stash_tree_id = commit_tree(
+ self._repo.object_store,
+ iter_fresh_objects(
+ index,
+ os.fsencode(self._repo.path),
+ object_store=self._repo.object_store,
+ ),
+ )
+
+ if message is None:
+ message = b"A stash on " + self._repo.head()
+
+ # TODO(jelmer): Just pass parents into do_commit()?
+ self._repo.refs[self._ref] = self._repo.head()
+
+ cid = self._repo.do_commit(
+ ref=self._ref,
+ tree=stash_tree_id,
+ message=message,
+ merge_heads=[index_commit_id],
+ no_verify=True,
+ **commit_kwargs,
+ )
+
+ return cid
def __getitem__(self, index):
return list(self.stashes())[index]
- def __len__(self) ->int:
+ def __len__(self) -> int:
return len(list(self.stashes()))
diff --git a/dulwich/submodule.py b/dulwich/submodule.py
index 5b8c520a..895c3408 100644
--- a/dulwich/submodule.py
+++ b/dulwich/submodule.py
@@ -1,11 +1,32 @@
+# config.py - Reading and writing Git config files
+# Copyright (C) 2011-2013 Jelmer Vernooij <jelmer@jelmer.uk>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Working with Git submodules."""
+
from typing import Iterator, Tuple
+
from .object_store import iter_tree_contents
from .objects import S_ISGITLINK
-def iter_cached_submodules(store, root_tree_id: bytes) ->Iterator[Tuple[str,
- bytes]]:
+def iter_cached_submodules(store, root_tree_id: bytes) -> Iterator[Tuple[str, bytes]]:
"""Iterate over cached submodules.
Args:
@@ -15,4 +36,6 @@ def iter_cached_submodules(store, root_tree_id: bytes) ->Iterator[Tuple[str,
Returns:
Iterator over over (path, sha) tuples
"""
- pass
+ for entry in iter_tree_contents(store, root_tree_id):
+ if S_ISGITLINK(entry.mode):
+ yield entry.path, entry.sha
diff --git a/dulwich/tests/test_object_store.py b/dulwich/tests/test_object_store.py
index 85d70259..313be5d3 100644
--- a/dulwich/tests/test_object_store.py
+++ b/dulwich/tests/test_object_store.py
@@ -1,25 +1,296 @@
+# test_object_store.py -- tests for object_store.py
+# Copyright (C) 2008 Jelmer Vernooij <jelmer@jelmer.uk>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Tests for the object store interface."""
+
from unittest import skipUnless
+
from dulwich.index import commit_tree
-from dulwich.object_store import iter_tree_contents, peel_sha
-from dulwich.objects import Blob, TreeEntry
+from dulwich.object_store import (
+ iter_tree_contents,
+ peel_sha,
+)
+from dulwich.objects import (
+ Blob,
+ TreeEntry,
+)
from dulwich.protocol import DEPTH_INFINITE
+
from .utils import make_object, make_tag
+
try:
from unittest.mock import patch
except ImportError:
- patch = None
-testobject = make_object(Blob, data=b'yummy data')
+ patch = None # type: ignore
+
+
+testobject = make_object(Blob, data=b"yummy data")
class ObjectStoreTests:
+ def test_determine_wants_all(self):
+ self.assertEqual(
+ [b"1" * 40],
+ self.store.determine_wants_all({b"refs/heads/foo": b"1" * 40}),
+ )
+
+ def test_determine_wants_all_zero(self):
+ self.assertEqual(
+ [], self.store.determine_wants_all({b"refs/heads/foo": b"0" * 40})
+ )
+
+ @skipUnless(patch, "Required mock.patch")
+ def test_determine_wants_all_depth(self):
+ self.store.add_object(testobject)
+ refs = {b"refs/heads/foo": testobject.id}
+ with patch.object(self.store, "_get_depth", return_value=1) as m:
+ self.assertEqual([], self.store.determine_wants_all(refs, depth=0))
+ self.assertEqual(
+ [testobject.id],
+ self.store.determine_wants_all(refs, depth=DEPTH_INFINITE),
+ )
+ m.assert_not_called()
+
+ self.assertEqual([], self.store.determine_wants_all(refs, depth=1))
+ m.assert_called_with(testobject.id)
+ self.assertEqual(
+ [testobject.id], self.store.determine_wants_all(refs, depth=2)
+ )
+
+ def test_get_depth(self):
+ self.assertEqual(0, self.store._get_depth(testobject.id))
+
+ self.store.add_object(testobject)
+ self.assertEqual(
+ 1, self.store._get_depth(testobject.id, get_parents=lambda x: [])
+ )
+
+ parent = make_object(Blob, data=b"parent data")
+ self.store.add_object(parent)
+ self.assertEqual(
+ 2,
+ self.store._get_depth(
+ testobject.id,
+ get_parents=lambda x: [parent.id] if x == testobject else [],
+ ),
+ )
+
+ def test_iter(self):
+ self.assertEqual([], list(self.store))
+
+ def test_get_nonexistant(self):
+ self.assertRaises(KeyError, lambda: self.store[b"a" * 40])
+
+ def test_contains_nonexistant(self):
+ self.assertNotIn(b"a" * 40, self.store)
+
+ def test_add_objects_empty(self):
+ self.store.add_objects([])
+
+ def test_add_commit(self):
+ # TODO: Argh, no way to construct Git commit objects without
+ # access to a serialized form.
+ self.store.add_objects([])
def test_store_resilience(self):
"""Test if updating an existing stored object doesn't erase the
object from the store.
"""
- pass
+ test_object = make_object(Blob, data=b"data")
+
+ self.store.add_object(test_object)
+ test_object_id = test_object.id
+ test_object.data = test_object.data + b"update"
+ stored_test_object = self.store[test_object_id]
+
+ self.assertNotEqual(test_object.id, stored_test_object.id)
+ self.assertEqual(stored_test_object.id, test_object_id)
+
+ def test_add_object(self):
+ self.store.add_object(testobject)
+ self.assertEqual({testobject.id}, set(self.store))
+ self.assertIn(testobject.id, self.store)
+ r = self.store[testobject.id]
+ self.assertEqual(r, testobject)
+
+ def test_add_objects(self):
+ data = [(testobject, "mypath")]
+ self.store.add_objects(data)
+ self.assertEqual({testobject.id}, set(self.store))
+ self.assertIn(testobject.id, self.store)
+ r = self.store[testobject.id]
+ self.assertEqual(r, testobject)
+
+ def test_tree_changes(self):
+ blob_a1 = make_object(Blob, data=b"a1")
+ blob_a2 = make_object(Blob, data=b"a2")
+ blob_b = make_object(Blob, data=b"b")
+ for blob in [blob_a1, blob_a2, blob_b]:
+ self.store.add_object(blob)
+
+ blobs_1 = [(b"a", blob_a1.id, 0o100644), (b"b", blob_b.id, 0o100644)]
+ tree1_id = commit_tree(self.store, blobs_1)
+ blobs_2 = [(b"a", blob_a2.id, 0o100644), (b"b", blob_b.id, 0o100644)]
+ tree2_id = commit_tree(self.store, blobs_2)
+ change_a = (
+ (b"a", b"a"),
+ (0o100644, 0o100644),
+ (blob_a1.id, blob_a2.id),
+ )
+ self.assertEqual([change_a], list(self.store.tree_changes(tree1_id, tree2_id)))
+ self.assertEqual(
+ [
+ change_a,
+ ((b"b", b"b"), (0o100644, 0o100644), (blob_b.id, blob_b.id)),
+ ],
+ list(self.store.tree_changes(tree1_id, tree2_id, want_unchanged=True)),
+ )
+
+ def test_iter_tree_contents(self):
+ blob_a = make_object(Blob, data=b"a")
+ blob_b = make_object(Blob, data=b"b")
+ blob_c = make_object(Blob, data=b"c")
+ for blob in [blob_a, blob_b, blob_c]:
+ self.store.add_object(blob)
+
+ blobs = [
+ (b"a", blob_a.id, 0o100644),
+ (b"ad/b", blob_b.id, 0o100644),
+ (b"ad/bd/c", blob_c.id, 0o100755),
+ (b"ad/c", blob_c.id, 0o100644),
+ (b"c", blob_c.id, 0o100644),
+ ]
+ tree_id = commit_tree(self.store, blobs)
+ self.assertEqual(
+ [TreeEntry(p, m, h) for (p, h, m) in blobs],
+ list(iter_tree_contents(self.store, tree_id)),
+ )
+ self.assertEqual([], list(iter_tree_contents(self.store, None)))
+
+ def test_iter_tree_contents_include_trees(self):
+ blob_a = make_object(Blob, data=b"a")
+ blob_b = make_object(Blob, data=b"b")
+ blob_c = make_object(Blob, data=b"c")
+ for blob in [blob_a, blob_b, blob_c]:
+ self.store.add_object(blob)
+
+ blobs = [
+ (b"a", blob_a.id, 0o100644),
+ (b"ad/b", blob_b.id, 0o100644),
+ (b"ad/bd/c", blob_c.id, 0o100755),
+ ]
+ tree_id = commit_tree(self.store, blobs)
+ tree = self.store[tree_id]
+ tree_ad = self.store[tree[b"ad"][1]]
+ tree_bd = self.store[tree_ad[b"bd"][1]]
+
+ expected = [
+ TreeEntry(b"", 0o040000, tree_id),
+ TreeEntry(b"a", 0o100644, blob_a.id),
+ TreeEntry(b"ad", 0o040000, tree_ad.id),
+ TreeEntry(b"ad/b", 0o100644, blob_b.id),
+ TreeEntry(b"ad/bd", 0o040000, tree_bd.id),
+ TreeEntry(b"ad/bd/c", 0o100755, blob_c.id),
+ ]
+ actual = iter_tree_contents(self.store, tree_id, include_trees=True)
+ self.assertEqual(expected, list(actual))
+
+ def make_tag(self, name, obj):
+ tag = make_tag(obj, name=name)
+ self.store.add_object(tag)
+ return tag
+
+ def test_peel_sha(self):
+ self.store.add_object(testobject)
+ tag1 = self.make_tag(b"1", testobject)
+ tag2 = self.make_tag(b"2", testobject)
+ tag3 = self.make_tag(b"3", testobject)
+ for obj in [testobject, tag1, tag2, tag3]:
+ self.assertEqual((obj, testobject), peel_sha(self.store, obj.id))
+
+ def test_get_raw(self):
+ self.store.add_object(testobject)
+ self.assertEqual(
+ (Blob.type_num, b"yummy data"), self.store.get_raw(testobject.id)
+ )
+
+ def test_close(self):
+ # For now, just check that close doesn't barf.
+ self.store.add_object(testobject)
+ self.store.close()
class PackBasedObjectStoreTests(ObjectStoreTests):
- pass
+ def tearDown(self):
+ for pack in self.store.packs:
+ pack.close()
+
+ def test_empty_packs(self):
+ self.assertEqual([], list(self.store.packs))
+
+ def test_pack_loose_objects(self):
+ b1 = make_object(Blob, data=b"yummy data")
+ self.store.add_object(b1)
+ b2 = make_object(Blob, data=b"more yummy data")
+ self.store.add_object(b2)
+ b3 = make_object(Blob, data=b"even more yummy data")
+ b4 = make_object(Blob, data=b"and more yummy data")
+ self.store.add_objects([(b3, None), (b4, None)])
+ self.assertEqual({b1.id, b2.id, b3.id, b4.id}, set(self.store))
+ self.assertEqual(1, len(self.store.packs))
+ self.assertEqual(2, self.store.pack_loose_objects())
+ self.assertNotEqual([], list(self.store.packs))
+ self.assertEqual(0, self.store.pack_loose_objects())
+
+ def test_repack(self):
+ b1 = make_object(Blob, data=b"yummy data")
+ self.store.add_object(b1)
+ b2 = make_object(Blob, data=b"more yummy data")
+ self.store.add_object(b2)
+ b3 = make_object(Blob, data=b"even more yummy data")
+ b4 = make_object(Blob, data=b"and more yummy data")
+ self.store.add_objects([(b3, None), (b4, None)])
+ b5 = make_object(Blob, data=b"and more data")
+ b6 = make_object(Blob, data=b"and some more data")
+ self.store.add_objects([(b5, None), (b6, None)])
+ self.assertEqual({b1.id, b2.id, b3.id, b4.id, b5.id, b6.id}, set(self.store))
+ self.assertEqual(2, len(self.store.packs))
+ self.assertEqual(6, self.store.repack())
+ self.assertEqual(1, len(self.store.packs))
+ self.assertEqual(0, self.store.pack_loose_objects())
+
+ def test_repack_existing(self):
+ b1 = make_object(Blob, data=b"yummy data")
+ self.store.add_object(b1)
+ b2 = make_object(Blob, data=b"more yummy data")
+ self.store.add_object(b2)
+ self.store.add_objects([(b1, None), (b2, None)])
+ self.store.add_objects([(b2, None)])
+ self.assertEqual({b1.id, b2.id}, set(self.store))
+ self.assertEqual(2, len(self.store.packs))
+ self.assertEqual(2, self.store.repack())
+ self.assertEqual(1, len(self.store.packs))
+ self.assertEqual(0, self.store.pack_loose_objects())
+
+ self.assertEqual({b1.id, b2.id}, set(self.store))
+ self.assertEqual(1, len(self.store.packs))
+ self.assertEqual(2, self.store.repack())
+ self.assertEqual(1, len(self.store.packs))
+ self.assertEqual(0, self.store.pack_loose_objects())
diff --git a/dulwich/tests/utils.py b/dulwich/tests/utils.py
index 51ce7d04..2a1dafd3 100644
--- a/dulwich/tests/utils.py
+++ b/dulwich/tests/utils.py
@@ -1,4 +1,25 @@
+# utils.py -- Test utilities for Dulwich.
+# Copyright (C) 2010 Google, Inc.
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""Utility functions common to Dulwich tests."""
+
import datetime
import os
import shutil
@@ -7,11 +28,23 @@ import time
import types
import warnings
from unittest import SkipTest
+
from dulwich.index import commit_tree
from dulwich.objects import Commit, FixedSha, Tag, object_class
-from dulwich.pack import DELTA_TYPES, OFS_DELTA, REF_DELTA, SHA1Writer, create_delta, obj_sha, write_pack_header, write_pack_object
+from dulwich.pack import (
+ DELTA_TYPES,
+ OFS_DELTA,
+ REF_DELTA,
+ SHA1Writer,
+ create_delta,
+ obj_sha,
+ write_pack_header,
+ write_pack_object,
+)
from dulwich.repo import Repo
-F = 33188
+
+# Plain files are very frequently used in tests, so let the mode be very short.
+F = 0o100644 # Shorthand mode for Files.
def open_repo(name, temp_dir=None):
@@ -28,12 +61,21 @@ def open_repo(name, temp_dir=None):
temporary directory will be created.
Returns: An initialized Repo object that lives in a temporary directory.
"""
- pass
+ if temp_dir is None:
+ temp_dir = tempfile.mkdtemp()
+ repo_dir = os.path.join(
+ os.path.dirname(__file__), "..", "..", "testdata", "repos", name
+ )
+ temp_repo_dir = os.path.join(temp_dir, name)
+ shutil.copytree(repo_dir, temp_repo_dir, symlinks=True)
+ return Repo(temp_repo_dir)
def tear_down_repo(repo):
"""Tear down a test repository."""
- pass
+ repo.close()
+ temp_dir = os.path.dirname(repo.path.rstrip(os.sep))
+ shutil.rmtree(temp_dir)
def make_object(cls, **attrs):
@@ -47,7 +89,26 @@ def make_object(cls, **attrs):
attrs: dict of attributes to set on the new object.
Returns: A newly initialized object of type cls.
"""
- pass
+
+ class TestObject(cls):
+ """Class that inherits from the given class, but without __slots__.
+
+ Note that classes with __slots__ can't have arbitrary attributes
+ monkey-patched in, so this is a class that is exactly the same only
+ with a __dict__ instead of __slots__.
+ """
+
+ TestObject.__name__ = "TestObject_" + cls.__name__
+
+ obj = TestObject()
+ for name, value in attrs.items():
+ if name == "id":
+ # id property is read-only, so we overwrite sha instead.
+ sha = FixedSha(value)
+ obj.sha = lambda: sha
+ else:
+ setattr(obj, name, value)
+ return obj
def make_commit(**attrs):
@@ -57,7 +118,20 @@ def make_commit(**attrs):
attrs: dict of attributes to overwrite from the default values.
Returns: A newly initialized Commit object.
"""
- pass
+ default_time = 1262304000 # 2010-01-01 00:00:00
+ all_attrs = {
+ "author": b"Test Author <test@nodomain.com>",
+ "author_time": default_time,
+ "author_timezone": 0,
+ "committer": b"Test Committer <test@nodomain.com>",
+ "commit_time": default_time,
+ "commit_timezone": 0,
+ "message": b"Test message.",
+ "parents": [],
+ "tree": b"0" * 40,
+ }
+ all_attrs.update(attrs)
+ return make_object(Commit, **all_attrs)
def make_tag(target, **attrs):
@@ -68,12 +142,28 @@ def make_tag(target, **attrs):
attrs: dict of attributes to overwrite from the default values.
Returns: A newly initialized Tag object.
"""
- pass
+ target_id = target.id
+ target_type = object_class(target.type_name)
+ default_time = int(time.mktime(datetime.datetime(2010, 1, 1).timetuple()))
+ all_attrs = {
+ "tagger": b"Test Author <test@nodomain.com>",
+ "tag_time": default_time,
+ "tag_timezone": 0,
+ "message": b"Test message.",
+ "object": (target_type, target_id),
+ "name": b"Test Tag",
+ }
+ all_attrs.update(attrs)
+ return make_object(Tag, **all_attrs)
def functest_builder(method, func):
"""Generate a test method that tests the given function."""
- pass
+
+ def do_test(self):
+ method(self, func)
+
+ return do_test
def ext_functest_builder(method, func):
@@ -97,7 +187,13 @@ def ext_functest_builder(method, func):
function implementation to test.
func: The function implementation to pass to method.
"""
- pass
+
+ def do_test(self):
+ if not isinstance(func, types.BuiltinFunctionType):
+ raise SkipTest(f"{func} extension not found")
+ method(self, func)
+
+ return do_test
def build_pack(f, objects_spec, store=None):
@@ -119,7 +215,61 @@ def build_pack(f, objects_spec, store=None):
Returns: A list of tuples in the order specified by objects_spec:
(offset, type num, data, sha, CRC32)
"""
- pass
+ sf = SHA1Writer(f)
+ num_objects = len(objects_spec)
+ write_pack_header(sf.write, num_objects)
+
+ full_objects = {}
+ offsets = {}
+ crc32s = {}
+
+ while len(full_objects) < num_objects:
+ for i, (type_num, data) in enumerate(objects_spec):
+ if type_num not in DELTA_TYPES:
+ full_objects[i] = (type_num, data, obj_sha(type_num, [data]))
+ continue
+ base, data = data
+ if isinstance(base, int):
+ if base not in full_objects:
+ continue
+ base_type_num, _, _ = full_objects[base]
+ else:
+ base_type_num, _ = store.get_raw(base)
+ full_objects[i] = (
+ base_type_num,
+ data,
+ obj_sha(base_type_num, [data]),
+ )
+
+ for i, (type_num, obj) in enumerate(objects_spec):
+ offset = f.tell()
+ if type_num == OFS_DELTA:
+ base_index, data = obj
+ base = offset - offsets[base_index]
+ _, base_data, _ = full_objects[base_index]
+ obj = (base, list(create_delta(base_data, data)))
+ elif type_num == REF_DELTA:
+ base_ref, data = obj
+ if isinstance(base_ref, int):
+ _, base_data, base = full_objects[base_ref]
+ else:
+ base_type_num, base_data = store.get_raw(base_ref)
+ base = obj_sha(base_type_num, base_data)
+ obj = (base, list(create_delta(base_data, data)))
+
+ crc32 = write_pack_object(sf.write, type_num, obj)
+ offsets[i] = offset
+ crc32s[i] = crc32
+
+ expected = []
+ for i in range(num_objects):
+ type_num, data, sha = full_objects[i]
+ assert len(sha) == 20
+ expected.append((offsets[i], type_num, data, sha, crc32s[i]))
+
+ sf.write_sha()
+ f.seek(0)
+ return expected
def build_commit_graph(object_store, commit_spec, trees=None, attrs=None):
@@ -154,9 +304,62 @@ def build_commit_graph(object_store, commit_spec, trees=None, attrs=None):
Raises:
ValueError: If an undefined commit identifier is listed as a parent.
"""
- pass
+ if trees is None:
+ trees = {}
+ if attrs is None:
+ attrs = {}
+ commit_time = 0
+ nums = {}
+ commits = []
+
+ for commit in commit_spec:
+ commit_num = commit[0]
+ try:
+ parent_ids = [nums[pn] for pn in commit[1:]]
+ except KeyError as exc:
+ (missing_parent,) = exc.args
+ raise ValueError("Unknown parent %i" % missing_parent) from exc
+
+ blobs = []
+ for entry in trees.get(commit_num, []):
+ if len(entry) == 2:
+ path, blob = entry
+ entry = (path, blob, F)
+ path, blob, mode = entry
+ blobs.append((path, blob.id, mode))
+ object_store.add_object(blob)
+ tree_id = commit_tree(object_store, blobs)
+
+ commit_attrs = {
+ "message": ("Commit %i" % commit_num).encode("ascii"),
+ "parents": parent_ids,
+ "tree": tree_id,
+ "commit_time": commit_time,
+ }
+ commit_attrs.update(attrs.get(commit_num, {}))
+ commit_obj = make_commit(**commit_attrs)
+
+ # By default, increment the time by a lot. Out-of-order commits should
+ # be closer together than this because their main cause is clock skew.
+ commit_time = commit_attrs["commit_time"] + 100
+ nums[commit_num] = commit_obj.id
+ object_store.add_object(commit_obj)
+ commits.append(commit_obj)
+
+ return commits
def setup_warning_catcher():
"""Wrap warnings.showwarning with code that records warnings."""
- pass
+ caught_warnings = []
+ original_showwarning = warnings.showwarning
+
+ def custom_showwarning(*args, **kwargs):
+ caught_warnings.append(args[0])
+
+ warnings.showwarning = custom_showwarning
+
+ def restore_showwarning():
+ warnings.showwarning = original_showwarning
+
+ return caught_warnings, restore_showwarning
diff --git a/dulwich/walk.py b/dulwich/walk.py
index bdb51329..58f9a428 100644
--- a/dulwich/walk.py
+++ b/dulwich/walk.py
@@ -1,21 +1,53 @@
+# walk.py -- General implementation of walking commits and their contents.
+# Copyright (C) 2010 Google, Inc.
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""General implementation of walking commits and their contents."""
+
import collections
import heapq
from itertools import chain
from typing import Deque, Dict, List, Optional, Set, Tuple
-from .diff_tree import RENAME_CHANGE_TYPES, RenameDetector, TreeChange, tree_changes, tree_changes_for_merge
+
+from .diff_tree import (
+ RENAME_CHANGE_TYPES,
+ RenameDetector,
+ TreeChange,
+ tree_changes,
+ tree_changes_for_merge,
+)
from .errors import MissingCommitError
from .objects import Commit, ObjectID, Tag
-ORDER_DATE = 'date'
-ORDER_TOPO = 'topo'
-ALL_ORDERS = ORDER_DATE, ORDER_TOPO
+
+ORDER_DATE = "date"
+ORDER_TOPO = "topo"
+
+ALL_ORDERS = (ORDER_DATE, ORDER_TOPO)
+
+# Maximum number of commits to walk past a commit time boundary.
_MAX_EXTRA_COMMITS = 5
class WalkEntry:
"""Object encapsulating a single result from a walk."""
- def __init__(self, walker, commit) ->None:
+ def __init__(self, walker, commit) -> None:
self.commit = commit
self._store = walker.store
self._get_parents = walker.get_parents
@@ -34,17 +66,63 @@ class WalkEntry:
the empty tree. For merge commits, a list of lists of TreeChange
objects; see dulwich.diff.tree_changes_for_merge.
"""
- pass
+ cached = self._changes.get(path_prefix)
+ if cached is None:
+ commit = self.commit
+ if not self._get_parents(commit):
+ changes_func = tree_changes
+ parent = None
+ elif len(self._get_parents(commit)) == 1:
+ changes_func = tree_changes
+ parent = self._store[self._get_parents(commit)[0]].tree
+ if path_prefix:
+ mode, subtree_sha = parent.lookup_path(
+ self._store.__getitem__,
+ path_prefix,
+ )
+ parent = self._store[subtree_sha]
+ else:
+ changes_func = tree_changes_for_merge
+ parent = [self._store[p].tree for p in self._get_parents(commit)]
+ if path_prefix:
+ parent_trees = [self._store[p] for p in parent]
+ parent = []
+ for p in parent_trees:
+ try:
+ mode, st = p.lookup_path(
+ self._store.__getitem__,
+ path_prefix,
+ )
+ except KeyError:
+ pass
+ else:
+ parent.append(st)
+ commit_tree_sha = commit.tree
+ if path_prefix:
+ commit_tree = self._store[commit_tree_sha]
+ mode, commit_tree_sha = commit_tree.lookup_path(
+ self._store.__getitem__,
+ path_prefix,
+ )
+ cached = list(
+ changes_func(
+ self._store,
+ parent,
+ commit_tree_sha,
+ rename_detector=self._rename_detector,
+ )
+ )
+ self._changes[path_prefix] = cached
+ return self._changes[path_prefix]
- def __repr__(self) ->str:
- return (
- f'<WalkEntry commit={self.commit.id}, changes={self.changes()!r}>')
+ def __repr__(self) -> str:
+ return f"<WalkEntry commit={self.commit.id}, changes={self.changes()!r}>"
class _CommitTimeQueue:
"""Priority queue of WalkEntry objects by commit time."""
- def __init__(self, walker: 'Walker') ->None:
+ def __init__(self, walker: "Walker") -> None:
self._walker = walker
self._store = walker.store
self._get_parents = walker.get_parents
@@ -57,8 +135,91 @@ class _CommitTimeQueue:
self._last = None
self._extra_commits_left = _MAX_EXTRA_COMMITS
self._is_finished = False
+
for commit_id in chain(walker.include, walker.excluded):
self._push(commit_id)
+
+ def _push(self, object_id: bytes):
+ try:
+ obj = self._store[object_id]
+ except KeyError as exc:
+ raise MissingCommitError(object_id) from exc
+ if isinstance(obj, Tag):
+ self._push(obj.object[1])
+ return
+ # TODO(jelmer): What to do about non-Commit and non-Tag objects?
+ commit = obj
+ if commit.id not in self._pq_set and commit.id not in self._done:
+ heapq.heappush(self._pq, (-commit.commit_time, commit))
+ self._pq_set.add(commit.id)
+ self._seen.add(commit.id)
+
+ def _exclude_parents(self, commit):
+ excluded = self._excluded
+ seen = self._seen
+ todo = [commit]
+ while todo:
+ commit = todo.pop()
+ for parent in self._get_parents(commit):
+ if parent not in excluded and parent in seen:
+ # TODO: This is inefficient unless the object store does
+ # some caching (which DiskObjectStore currently does not).
+ # We could either add caching in this class or pass around
+ # parsed queue entry objects instead of commits.
+ todo.append(self._store[parent])
+ excluded.add(parent)
+
+ def next(self):
+ if self._is_finished:
+ return None
+ while self._pq:
+ _, commit = heapq.heappop(self._pq)
+ sha = commit.id
+ self._pq_set.remove(sha)
+ if sha in self._done:
+ continue
+ self._done.add(sha)
+
+ for parent_id in self._get_parents(commit):
+ self._push(parent_id)
+
+ reset_extra_commits = True
+ is_excluded = sha in self._excluded
+ if is_excluded:
+ self._exclude_parents(commit)
+ if self._pq and all(c.id in self._excluded for _, c in self._pq):
+ _, n = self._pq[0]
+ if self._last and n.commit_time >= self._last.commit_time:
+ # If the next commit is newer than the last one, we
+ # need to keep walking in case its parents (which we
+ # may not have seen yet) are excluded. This gives the
+ # excluded set a chance to "catch up" while the commit
+ # is still in the Walker's output queue.
+ reset_extra_commits = True
+ else:
+ reset_extra_commits = False
+
+ if self._min_time is not None and commit.commit_time < self._min_time:
+ # We want to stop walking at min_time, but commits at the
+ # boundary may be out of order with respect to their parents.
+ # So we walk _MAX_EXTRA_COMMITS more commits once we hit this
+ # boundary.
+ reset_extra_commits = False
+
+ if reset_extra_commits:
+ # We're not at a boundary, so reset the counter.
+ self._extra_commits_left = _MAX_EXTRA_COMMITS
+ else:
+ self._extra_commits_left -= 1
+ if not self._extra_commits_left:
+ break
+
+ if not is_excluded:
+ self._last = commit
+ return WalkEntry(self._walker, commit)
+ self._is_finished = True
+ return None
+
__next__ = next
@@ -69,12 +230,22 @@ class Walker:
be treated as iterators of Commit objects.
"""
- def __init__(self, store, include: List[bytes], exclude: Optional[List[
- bytes]]=None, order: str='date', reverse: bool=False, max_entries:
- Optional[int]=None, paths: Optional[List[bytes]]=None,
- rename_detector: Optional[RenameDetector]=None, follow: bool=False,
- since: Optional[int]=None, until: Optional[int]=None, get_parents=
- lambda commit: commit.parents, queue_cls=_CommitTimeQueue) ->None:
+ def __init__(
+ self,
+ store,
+ include: List[bytes],
+ exclude: Optional[List[bytes]] = None,
+ order: str = "date",
+ reverse: bool = False,
+ max_entries: Optional[int] = None,
+ paths: Optional[List[bytes]] = None,
+ rename_detector: Optional[RenameDetector] = None,
+ follow: bool = False,
+ since: Optional[int] = None,
+ until: Optional[int] = None,
+ get_parents=lambda commit: commit.parents,
+ queue_cls=_CommitTimeQueue,
+ ) -> None:
"""Constructor.
Args:
@@ -101,10 +272,14 @@ class Walker:
iterator protocol. The constructor takes a single argument, the
Walker.
"""
+ # Note: when adding arguments to this method, please also update
+ # dulwich.repo.BaseRepo.get_walker
if order not in ALL_ORDERS:
- raise ValueError(f'Unknown walk order {order}')
+ raise ValueError(f"Unknown walk order {order}")
self.store = store
if isinstance(include, bytes):
+ # TODO(jelmer): Really, this should require a single type.
+ # Print deprecation warning here?
include = [include]
self.include = include
self.excluded = set(exclude or [])
@@ -119,10 +294,41 @@ class Walker:
self.follow = follow
self.since = since
self.until = until
+
self._num_entries = 0
self._queue = queue_cls(self)
self._out_queue: Deque[WalkEntry] = collections.deque()
+ def _path_matches(self, changed_path):
+ if changed_path is None:
+ return False
+ if self.paths is None:
+ return True
+ for followed_path in self.paths:
+ if changed_path == followed_path:
+ return True
+ if (
+ changed_path.startswith(followed_path)
+ and changed_path[len(followed_path)] == b"/"[0]
+ ):
+ return True
+ return False
+
+ def _change_matches(self, change):
+ if not change:
+ return False
+
+ old_path = change.old.path
+ new_path = change.new.path
+ if self._path_matches(new_path):
+ if self.follow and change.type in RENAME_CHANGE_TYPES:
+ self.paths.add(old_path)
+ self.paths.remove(new_path)
+ return True
+ elif self._path_matches(old_path):
+ return True
+ return False
+
def _should_return(self, entry):
"""Determine if a walk entry should be returned..
@@ -131,7 +337,45 @@ class Walker:
Returns: True if the WalkEntry should be returned by this walk, or
False otherwise (e.g. if it doesn't match any requested paths).
"""
- pass
+ commit = entry.commit
+ if self.since is not None and commit.commit_time < self.since:
+ return False
+ if self.until is not None and commit.commit_time > self.until:
+ return False
+ if commit.id in self.excluded:
+ return False
+
+ if self.paths is None:
+ return True
+
+ if len(self.get_parents(commit)) > 1:
+ for path_changes in entry.changes():
+ # For merge commits, only include changes with conflicts for
+ # this path. Since a rename conflict may include different
+ # old.paths, we have to check all of them.
+ for change in path_changes:
+ if self._change_matches(change):
+ return True
+ else:
+ for change in entry.changes():
+ if self._change_matches(change):
+ return True
+ return None
+
+ def _next(self):
+ max_entries = self.max_entries
+ while max_entries is None or self._num_entries < max_entries:
+ entry = next(self._queue)
+ if entry is not None:
+ self._out_queue.append(entry)
+ if entry is None or len(self._out_queue) > _MAX_EXTRA_COMMITS:
+ if not self._out_queue:
+ return None
+ entry = self._out_queue.popleft()
+ if self._should_return(entry):
+ self._num_entries += 1
+ return entry
+ return None
def _reorder(self, results):
"""Possibly reorder a results iterator.
@@ -142,7 +386,11 @@ class Walker:
Returns: An iterator or list of WalkEntry objects, in the order
required by the Walker.
"""
- pass
+ if self.order == ORDER_TOPO:
+ results = _topo_reorder(results, self.get_parents)
+ if self.reverse:
+ results = reversed(list(results))
+ return results
def __iter__(self):
return iter(self._reorder(iter(self._next, None)))
@@ -160,4 +408,25 @@ def _topo_reorder(entries, get_parents=lambda commit: commit.parents):
Returns: iterator over WalkEntry objects from entries in FIFO order, except
where a parent would be yielded before any of its children.
"""
- pass
+ todo = collections.deque()
+ pending = {}
+ num_children = collections.defaultdict(int)
+ for entry in entries:
+ todo.append(entry)
+ for p in get_parents(entry.commit):
+ num_children[p] += 1
+
+ while todo:
+ entry = todo.popleft()
+ commit = entry.commit
+ commit_id = commit.id
+ if num_children[commit_id]:
+ pending[commit_id] = entry
+ continue
+ for parent_id in get_parents(commit):
+ num_children[parent_id] -= 1
+ if not num_children[parent_id]:
+ parent_entry = pending.pop(parent_id, None)
+ if parent_entry:
+ todo.appendleft(parent_entry)
+ yield entry
diff --git a/dulwich/web.py b/dulwich/web.py
index f8c648e5..f62b3f1c 100644
--- a/dulwich/web.py
+++ b/dulwich/web.py
@@ -1,4 +1,26 @@
+# web.py -- WSGI smart-http server
+# Copyright (C) 2010 Google, Inc.
+# Copyright (C) 2012 Jelmer Vernooij <jelmer@jelmer.uk>
+#
+# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
+# General Public License as public by the Free Software Foundation; version 2.0
+# or (at your option) any later version. You can redistribute it and/or
+# modify it under the terms of either of these two licenses.
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# You should have received a copy of the licenses; if not, see
+# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
+# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
+# License, Version 2.0.
+#
+
"""HTTP server for dulwich that implements the git smart HTTP protocol."""
+
import os
import re
import sys
@@ -6,21 +28,90 @@ import time
from io import BytesIO
from typing import Callable, ClassVar, Dict, Iterator, List, Optional, Tuple
from urllib.parse import parse_qs
-from wsgiref.simple_server import ServerHandler, WSGIRequestHandler, WSGIServer, make_server
+from wsgiref.simple_server import (
+ ServerHandler,
+ WSGIRequestHandler,
+ WSGIServer,
+ make_server,
+)
+
from dulwich import log_utils
+
from .protocol import ReceivableProtocol
from .repo import BaseRepo, NotGitRepository, Repo
-from .server import DEFAULT_HANDLERS, Backend, DictBackend, generate_info_refs, generate_objects_info_packs
+from .server import (
+ DEFAULT_HANDLERS,
+ Backend,
+ DictBackend,
+ generate_info_refs,
+ generate_objects_info_packs,
+)
+
logger = log_utils.getLogger(__name__)
-HTTP_OK = '200 OK'
-HTTP_NOT_FOUND = '404 Not Found'
-HTTP_FORBIDDEN = '403 Forbidden'
-HTTP_ERROR = '500 Internal Server Error'
-NO_CACHE_HEADERS = [('Expires', 'Fri, 01 Jan 1980 00:00:00 GMT'), ('Pragma',
- 'no-cache'), ('Cache-Control', 'no-cache, max-age=0, must-revalidate')]
-def url_prefix(mat) ->str:
+# HTTP error strings
+HTTP_OK = "200 OK"
+HTTP_NOT_FOUND = "404 Not Found"
+HTTP_FORBIDDEN = "403 Forbidden"
+HTTP_ERROR = "500 Internal Server Error"
+
+
+NO_CACHE_HEADERS = [
+ ("Expires", "Fri, 01 Jan 1980 00:00:00 GMT"),
+ ("Pragma", "no-cache"),
+ ("Cache-Control", "no-cache, max-age=0, must-revalidate"),
+]
+
+
+def cache_forever_headers(now=None):
+ if now is None:
+ now = time.time()
+ return [
+ ("Date", date_time_string(now)),
+ ("Expires", date_time_string(now + 31536000)),
+ ("Cache-Control", "public, max-age=31536000"),
+ ]
+
+
+def date_time_string(timestamp: Optional[float] = None) -> str:
+ # From BaseHTTPRequestHandler.date_time_string in BaseHTTPServer.py in the
+ # Python 2.6.5 standard library, following modifications:
+ # - Made a global rather than an instance method.
+ # - weekdayname and monthname are renamed and locals rather than class
+ # variables.
+ # Copyright (c) 2001-2010 Python Software Foundation; All Rights Reserved
+ weekdays = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
+ months = [
+ None,
+ "Jan",
+ "Feb",
+ "Mar",
+ "Apr",
+ "May",
+ "Jun",
+ "Jul",
+ "Aug",
+ "Sep",
+ "Oct",
+ "Nov",
+ "Dec",
+ ]
+ if timestamp is None:
+ timestamp = time.time()
+ year, month, day, hh, mm, ss, wd = time.gmtime(timestamp)[:7]
+ return "%s, %02d %3s %4d %02d:%02d:%02d GMD" % (
+ weekdays[wd],
+ day,
+ months[month],
+ year,
+ hh,
+ mm,
+ ss,
+ )
+
+
+def url_prefix(mat) -> str:
"""Extract the URL prefix from a regex match.
Args:
@@ -29,12 +120,12 @@ def url_prefix(mat) ->str:
original string. Normalized to start with one leading slash and end
with zero.
"""
- pass
+ return "/" + mat.string[: mat.start()].strip("/")
-def get_repo(backend, mat) ->BaseRepo:
+def get_repo(backend, mat) -> BaseRepo:
"""Get a Repo instance for the given backend and URL regex match."""
- pass
+ return backend.open_repository(url_prefix(mat))
def send_file(req, f, content_type):
@@ -46,15 +137,140 @@ def send_file(req, f, content_type):
content_type: The MIME type for the file.
Returns: Iterator over the contents of the file, as chunks.
"""
- pass
+ if f is None:
+ yield req.not_found("File not found")
+ return
+ try:
+ req.respond(HTTP_OK, content_type)
+ while True:
+ data = f.read(10240)
+ if not data:
+ break
+ yield data
+ except OSError:
+ yield req.error("Error reading file")
+ finally:
+ f.close()
+
+
+def _url_to_path(url):
+ return url.replace("/", os.path.sep)
+
+
+def get_text_file(req, backend, mat):
+ req.nocache()
+ path = _url_to_path(mat.group())
+ logger.info("Sending plain text file %s", path)
+ return send_file(req, get_repo(backend, mat).get_named_file(path), "text/plain")
+
+
+def get_loose_object(req, backend, mat):
+ sha = (mat.group(1) + mat.group(2)).encode("ascii")
+ logger.info("Sending loose object %s", sha)
+ object_store = get_repo(backend, mat).object_store
+ if not object_store.contains_loose(sha):
+ yield req.not_found("Object not found")
+ return
+ try:
+ data = object_store[sha].as_legacy_object()
+ except OSError:
+ yield req.error("Error reading object")
+ return
+ req.cache_forever()
+ req.respond(HTTP_OK, "application/x-git-loose-object")
+ yield data
+
+
+def get_pack_file(req, backend, mat):
+ req.cache_forever()
+ path = _url_to_path(mat.group())
+ logger.info("Sending pack file %s", path)
+ return send_file(
+ req,
+ get_repo(backend, mat).get_named_file(path),
+ "application/x-git-packed-objects",
+ )
+
+
+def get_idx_file(req, backend, mat):
+ req.cache_forever()
+ path = _url_to_path(mat.group())
+ logger.info("Sending pack file %s", path)
+ return send_file(
+ req,
+ get_repo(backend, mat).get_named_file(path),
+ "application/x-git-packed-objects-toc",
+ )
+
+
+def get_info_refs(req, backend, mat):
+ params = parse_qs(req.environ["QUERY_STRING"])
+ service = params.get("service", [None])[0]
+ try:
+ repo = get_repo(backend, mat)
+ except NotGitRepository as e:
+ yield req.not_found(str(e))
+ return
+ if service and not req.dumb:
+ handler_cls = req.handlers.get(service.encode("ascii"), None)
+ if handler_cls is None:
+ yield req.forbidden("Unsupported service")
+ return
+ req.nocache()
+ write = req.respond(HTTP_OK, f"application/x-{service}-advertisement")
+ proto = ReceivableProtocol(BytesIO().read, write)
+ handler = handler_cls(
+ backend,
+ [url_prefix(mat)],
+ proto,
+ stateless_rpc=True,
+ advertise_refs=True,
+ )
+ handler.proto.write_pkt_line(b"# service=" + service.encode("ascii") + b"\n")
+ handler.proto.write_pkt_line(None)
+ handler.handle()
+ else:
+ # non-smart fallback
+ # TODO: select_getanyfile() (see http-backend.c)
+ req.nocache()
+ req.respond(HTTP_OK, "text/plain")
+ logger.info("Emulating dumb info/refs")
+ yield from generate_info_refs(repo)
+
+
+def get_info_packs(req, backend, mat):
+ req.nocache()
+ req.respond(HTTP_OK, "text/plain")
+ logger.info("Emulating dumb info/packs")
+ return generate_objects_info_packs(get_repo(backend, mat))
+
+
+def _chunk_iter(f):
+ while True:
+ line = f.readline()
+ length = int(line.rstrip(), 16)
+ chunk = f.read(length + 2)
+ if length == 0:
+ break
+ yield chunk[:-2]
class ChunkReader:
-
- def __init__(self, f) ->None:
+ def __init__(self, f) -> None:
self._iter = _chunk_iter(f)
self._buffer: List[bytes] = []
+ def read(self, n):
+ while sum(map(len, self._buffer)) < n:
+ try:
+ self._buffer.append(next(self._iter))
+ except StopIteration:
+ break
+ f = b"".join(self._buffer)
+ ret = f[:n]
+ self._buffer = [f[n:]]
+ return ret
+
class _LengthLimitedFile:
"""Wrapper class to limit the length of reads from a file-like object.
@@ -64,10 +280,45 @@ class _LengthLimitedFile:
but not implemented in wsgiref as of 2.5.
"""
- def __init__(self, input, max_bytes) ->None:
+ def __init__(self, input, max_bytes) -> None:
self._input = input
self._bytes_avail = max_bytes
+ def read(self, size=-1):
+ if self._bytes_avail <= 0:
+ return b""
+ if size == -1 or size > self._bytes_avail:
+ size = self._bytes_avail
+ self._bytes_avail -= size
+ return self._input.read(size)
+
+ # TODO: support more methods as necessary
+
+
+def handle_service_request(req, backend, mat):
+ service = mat.group().lstrip("/")
+ logger.info("Handling service request for %s", service)
+ handler_cls = req.handlers.get(service.encode("ascii"), None)
+ if handler_cls is None:
+ yield req.forbidden("Unsupported service")
+ return
+ try:
+ get_repo(backend, mat)
+ except NotGitRepository as e:
+ yield req.not_found(str(e))
+ return
+ req.nocache()
+ write = req.respond(HTTP_OK, f"application/x-{service}-result")
+ if req.environ.get("HTTP_TRANSFER_ENCODING") == "chunked":
+ read = ChunkReader(req.environ["wsgi.input"]).read
+ else:
+ read = req.environ["wsgi.input"].read
+ proto = ReceivableProtocol(read, write)
+ # TODO(jelmer): Find a way to pass in repo, rather than having handler_cls
+ # reopen.
+ handler = handler_cls(backend, [url_prefix(mat)], proto, stateless_rpc=True)
+ handler.handle()
+
class HTTPGitRequest:
"""Class encapsulating the state of a single git HTTP request.
@@ -76,8 +327,9 @@ class HTTPGitRequest:
environ: the WSGI environment for the request.
"""
- def __init__(self, environ, start_response, dumb: bool=False, handlers=None
- ) ->None:
+ def __init__(
+ self, environ, start_response, dumb: bool = False, handlers=None
+ ) -> None:
self.environ = environ
self.dumb = dumb
self.handlers = handlers
@@ -87,32 +339,51 @@ class HTTPGitRequest:
def add_header(self, name, value):
"""Add a header to the response."""
- pass
-
- def respond(self, status: str=HTTP_OK, content_type: Optional[str]=None,
- headers: Optional[List[Tuple[str, str]]]=None):
+ self._headers.append((name, value))
+
+ def respond(
+ self,
+ status: str = HTTP_OK,
+ content_type: Optional[str] = None,
+ headers: Optional[List[Tuple[str, str]]] = None,
+ ):
"""Begin a response with the given status and other headers."""
- pass
+ if headers:
+ self._headers.extend(headers)
+ if content_type:
+ self._headers.append(("Content-Type", content_type))
+ self._headers.extend(self._cache_headers)
- def not_found(self, message: str) ->bytes:
+ return self._start_response(status, self._headers)
+
+ def not_found(self, message: str) -> bytes:
"""Begin a HTTP 404 response and return the text of a message."""
- pass
+ self._cache_headers = []
+ logger.info("Not found: %s", message)
+ self.respond(HTTP_NOT_FOUND, "text/plain")
+ return message.encode("ascii")
- def forbidden(self, message: str) ->bytes:
+ def forbidden(self, message: str) -> bytes:
"""Begin a HTTP 403 response and return the text of a message."""
- pass
+ self._cache_headers = []
+ logger.info("Forbidden: %s", message)
+ self.respond(HTTP_FORBIDDEN, "text/plain")
+ return message.encode("ascii")
- def error(self, message: str) ->bytes:
+ def error(self, message: str) -> bytes:
"""Begin a HTTP 500 response and return the text of a message."""
- pass
+ self._cache_headers = []
+ logger.error("Error: %s", message)
+ self.respond(HTTP_ERROR, "text/plain")
+ return message.encode("ascii")
- def nocache(self) ->None:
+ def nocache(self) -> None:
"""Set the response to never be cached by the client."""
- pass
+ self._cache_headers = NO_CACHE_HEADERS
- def cache_forever(self) ->None:
+ def cache_forever(self) -> None:
"""Set the response to be cached forever by the client."""
- pass
+ self._cache_headers = cache_forever_headers()
class HTTPGitApplication:
@@ -121,23 +392,37 @@ class HTTPGitApplication:
Attributes:
backend: the Backend object backing this application
"""
- services: ClassVar[Dict[Tuple[str, re.Pattern], Callable[[
- HTTPGitRequest, Backend, re.Match], Iterator[bytes]]]] = {('GET',
- re.compile('/HEAD$')): get_text_file, ('GET', re.compile(
- '/info/refs$')): get_info_refs, ('GET', re.compile(
- '/objects/info/alternates$')): get_text_file, ('GET', re.compile(
- '/objects/info/http-alternates$')): get_text_file, ('GET', re.
- compile('/objects/info/packs$')): get_info_packs, ('GET', re.
- compile('/objects/([0-9a-f]{2})/([0-9a-f]{38})$')):
- get_loose_object, ('GET', re.compile(
- '/objects/pack/pack-([0-9a-f]{40})\\.pack$')): get_pack_file, (
- 'GET', re.compile('/objects/pack/pack-([0-9a-f]{40})\\.idx$')):
- get_idx_file, ('POST', re.compile('/git-upload-pack$')):
- handle_service_request, ('POST', re.compile('/git-receive-pack$')):
- handle_service_request}
-
- def __init__(self, backend, dumb: bool=False, handlers=None,
- fallback_app=None) ->None:
+
+ services: ClassVar[
+ Dict[
+ Tuple[str, re.Pattern],
+ Callable[[HTTPGitRequest, Backend, re.Match], Iterator[bytes]],
+ ]
+ ] = {
+ ("GET", re.compile("/HEAD$")): get_text_file,
+ ("GET", re.compile("/info/refs$")): get_info_refs,
+ ("GET", re.compile("/objects/info/alternates$")): get_text_file,
+ ("GET", re.compile("/objects/info/http-alternates$")): get_text_file,
+ ("GET", re.compile("/objects/info/packs$")): get_info_packs,
+ (
+ "GET",
+ re.compile("/objects/([0-9a-f]{2})/([0-9a-f]{38})$"),
+ ): get_loose_object,
+ (
+ "GET",
+ re.compile("/objects/pack/pack-([0-9a-f]{40})\\.pack$"),
+ ): get_pack_file,
+ (
+ "GET",
+ re.compile("/objects/pack/pack-([0-9a-f]{40})\\.idx$"),
+ ): get_idx_file,
+ ("POST", re.compile("/git-upload-pack$")): handle_service_request,
+ ("POST", re.compile("/git-receive-pack$")): handle_service_request,
+ }
+
+ def __init__(
+ self, backend, dumb: bool = False, handlers=None, fallback_app=None
+ ) -> None:
self.backend = backend
self.dumb = dumb
self.handlers = dict(DEFAULT_HANDLERS)
@@ -146,10 +431,12 @@ class HTTPGitApplication:
self.handlers.update(handlers)
def __call__(self, environ, start_response):
- path = environ['PATH_INFO']
- method = environ['REQUEST_METHOD']
- req = HTTPGitRequest(environ, start_response, dumb=self.dumb,
- handlers=self.handlers)
+ path = environ["PATH_INFO"]
+ method = environ["REQUEST_METHOD"]
+ req = HTTPGitRequest(
+ environ, start_response, dumb=self.dumb, handlers=self.handlers
+ )
+ # environ['QUERY_STRING'] has qs args
handler = None
for smethod, spath in self.services.keys():
if smethod != method:
@@ -158,11 +445,13 @@ class HTTPGitApplication:
if mat:
handler = self.services[smethod, spath]
break
+
if handler is None:
if self.fallback_app is not None:
return self.fallback_app(environ, start_response)
else:
- return [req.not_found('Sorry, that method is not supported')]
+ return [req.not_found("Sorry, that method is not supported")]
+
return handler(req, self.backend, mat)
@@ -171,17 +460,20 @@ class GunzipFilter:
passing on to the underlying application.
"""
- def __init__(self, application) ->None:
+ def __init__(self, application) -> None:
self.app = application
def __call__(self, environ, start_response):
import gzip
- if environ.get('HTTP_CONTENT_ENCODING', '') == 'gzip':
- environ['wsgi.input'] = gzip.GzipFile(filename=None, fileobj=
- environ['wsgi.input'], mode='rb')
- del environ['HTTP_CONTENT_ENCODING']
- if 'CONTENT_LENGTH' in environ:
- del environ['CONTENT_LENGTH']
+
+ if environ.get("HTTP_CONTENT_ENCODING", "") == "gzip":
+ environ["wsgi.input"] = gzip.GzipFile(
+ filename=None, fileobj=environ["wsgi.input"], mode="rb"
+ )
+ del environ["HTTP_CONTENT_ENCODING"]
+ if "CONTENT_LENGTH" in environ:
+ del environ["CONTENT_LENGTH"]
+
return self.app(environ, start_response)
@@ -190,14 +482,19 @@ class LimitedInputFilter:
specified in Content-Length.
"""
- def __init__(self, application) ->None:
+ def __init__(self, application) -> None:
self.app = application
def __call__(self, environ, start_response):
- content_length = environ.get('CONTENT_LENGTH', '')
+ # This is not necessary if this app is run from a conforming WSGI
+ # server. Unfortunately, there's no way to tell that at this point.
+ # TODO: git may used HTTP/1.1 chunked encoding instead of specifying
+ # content-length
+ content_length = environ.get("CONTENT_LENGTH", "")
if content_length:
- environ['wsgi.input'] = _LengthLimitedFile(environ['wsgi.input'
- ], int(content_length))
+ environ["wsgi.input"] = _LengthLimitedFile(
+ environ["wsgi.input"], int(content_length)
+ )
return self.app(environ, start_response)
@@ -205,32 +502,107 @@ def make_wsgi_chain(*args, **kwargs):
"""Factory function to create an instance of HTTPGitApplication,
correctly wrapped with needed middleware.
"""
- pass
+ app = HTTPGitApplication(*args, **kwargs)
+ wrapped_app = LimitedInputFilter(GunzipFilter(app))
+ return wrapped_app
class ServerHandlerLogger(ServerHandler):
"""ServerHandler that uses dulwich's logger for logging exceptions."""
+ def log_exception(self, exc_info):
+ logger.exception(
+ "Exception happened during processing of request",
+ exc_info=exc_info,
+ )
+
+ def log_message(self, format, *args):
+ logger.info(format, *args)
+
+ def log_error(self, *args):
+ logger.error(*args)
+
class WSGIRequestHandlerLogger(WSGIRequestHandler):
"""WSGIRequestHandler that uses dulwich's logger for logging exceptions."""
+ def log_exception(self, exc_info):
+ logger.exception(
+ "Exception happened during processing of request",
+ exc_info=exc_info,
+ )
+
+ def log_message(self, format, *args):
+ logger.info(format, *args)
+
+ def log_error(self, *args):
+ logger.error(*args)
+
def handle(self):
"""Handle a single HTTP request."""
- pass
+ self.raw_requestline = self.rfile.readline()
+ if not self.parse_request(): # An error code has been sent, just exit
+ return
+ handler = ServerHandlerLogger(
+ self.rfile, self.wfile, self.get_stderr(), self.get_environ()
+ )
+ handler.request_handler = self # backpointer for logging
+ handler.run(self.server.get_app())
-class WSGIServerLogger(WSGIServer):
+class WSGIServerLogger(WSGIServer):
def handle_error(self, request, client_address):
"""Handle an error."""
- pass
+ logger.exception(
+ f"Exception happened during processing of request from {client_address!s}"
+ )
def main(argv=sys.argv):
"""Entry point for starting an HTTP git server."""
- pass
-
-
-if __name__ == '__main__':
+ import optparse
+
+ parser = optparse.OptionParser()
+ parser.add_option(
+ "-l",
+ "--listen_address",
+ dest="listen_address",
+ default="localhost",
+ help="Binding IP address.",
+ )
+ parser.add_option(
+ "-p",
+ "--port",
+ dest="port",
+ type=int,
+ default=8000,
+ help="Port to listen on.",
+ )
+ options, args = parser.parse_args(argv)
+
+ if len(args) > 1:
+ gitdir = args[1]
+ else:
+ gitdir = os.getcwd()
+
+ log_utils.default_logging_config()
+ backend = DictBackend({"/": Repo(gitdir)})
+ app = make_wsgi_chain(backend)
+ server = make_server(
+ options.listen_address,
+ options.port,
+ app,
+ handler_class=WSGIRequestHandlerLogger,
+ server_class=WSGIServerLogger,
+ )
+ logger.info(
+ "Listening for HTTP connections on %s:%d",
+ options.listen_address,
+ options.port,
+ )
+ server.serve_forever()
+
+
+if __name__ == "__main__":
main()