blobstore.py
568 lines
| 20.9 KiB
| text/x-python
|
PythonLexer
|
r35097 | # blobstore.py - local and remote (speaking Git-LFS protocol) blob storages | ||
# | ||||
# Copyright 2017 Facebook, Inc. | ||||
# | ||||
# This software may be used and distributed according to the terms of the | ||||
# GNU General Public License version 2 or any later version. | ||||
from __future__ import absolute_import | ||||
|
r37535 | import errno | ||
|
r35492 | import hashlib | ||
|
r35097 | import json | ||
import os | ||||
import re | ||||
|
r35491 | import socket | ||
|
r35097 | |||
|
r35098 | from mercurial.i18n import _ | ||
|
r35097 | from mercurial import ( | ||
error, | ||||
|
r35363 | pathutil, | ||
|
r36619 | pycompat, | ||
|
r35097 | url as urlmod, | ||
util, | ||||
vfs as vfsmod, | ||||
|
r35449 | worker, | ||
|
r35097 | ) | ||
|
r35281 | from ..largefiles import lfutil | ||
|
r35097 | # 64 bytes for SHA256 | ||
|
r36473 | _lfsre = re.compile(br'\A[a-f0-9]{64}\Z') | ||
|
r35097 | |||
class lfsvfs(vfsmod.vfs): | ||||
def join(self, path): | ||||
"""split the path at first two characters, like: XX/XXXXX...""" | ||||
if not _lfsre.match(path): | ||||
raise error.ProgrammingError('unexpected lfs path: %s' % path) | ||||
return super(lfsvfs, self).join(path[0:2], path[2:]) | ||||
|
r35363 | def walk(self, path=None, onerror=None): | ||
|
r35397 | """Yield (dirpath, [], oids) tuple for blobs under path | ||
|
r35363 | |||
Oids only exist in the root of this vfs, so dirpath is always ''. | ||||
""" | ||||
root = os.path.normpath(self.base) | ||||
# when dirpath == root, dirpath[prefixlen:] becomes empty | ||||
# because len(dirpath) < prefixlen. | ||||
prefixlen = len(pathutil.normasprefix(root)) | ||||
oids = [] | ||||
for dirpath, dirs, files in os.walk(self.reljoin(self.base, path or ''), | ||||
onerror=onerror): | ||||
dirpath = dirpath[prefixlen:] | ||||
# Silently skip unexpected files and directories | ||||
if len(dirpath) == 2: | ||||
oids.extend([dirpath + f for f in files | ||||
if _lfsre.match(dirpath + f)]) | ||||
|
r35397 | yield ('', [], oids) | ||
|
r35363 | |||
|
r37535 | class nullvfs(lfsvfs): | ||
def __init__(self): | ||||
pass | ||||
def exists(self, oid): | ||||
return False | ||||
def read(self, oid): | ||||
# store.read() calls into here if the blob doesn't exist in its | ||||
# self.vfs. Raise the same error as a normal vfs when asked to read a | ||||
# file that doesn't exist. The only difference is the full file path | ||||
# isn't available in the error. | ||||
raise IOError(errno.ENOENT, '%s: No such file or directory' % oid) | ||||
def walk(self, path=None, onerror=None): | ||||
return ('', [], []) | ||||
def write(self, oid, data): | ||||
pass | ||||
|
r35097 | class filewithprogress(object): | ||
"""a file-like object that supports __len__ and read. | ||||
Useful to provide progress information for how many bytes are read. | ||||
""" | ||||
def __init__(self, fp, callback): | ||||
self._fp = fp | ||||
self._callback = callback # func(readsize) | ||||
fp.seek(0, os.SEEK_END) | ||||
self._len = fp.tell() | ||||
fp.seek(0) | ||||
def __len__(self): | ||||
return self._len | ||||
def read(self, size): | ||||
if self._fp is None: | ||||
return b'' | ||||
data = self._fp.read(size) | ||||
if data: | ||||
if self._callback: | ||||
self._callback(len(data)) | ||||
else: | ||||
self._fp.close() | ||||
self._fp = None | ||||
return data | ||||
class local(object): | ||||
"""Local blobstore for large file contents. | ||||
This blobstore is used both as a cache and as a staging area for large blobs | ||||
to be uploaded to the remote blobstore. | ||||
""" | ||||
def __init__(self, repo): | ||||
fullpath = repo.svfs.join('lfs/objects') | ||||
self.vfs = lfsvfs(fullpath) | ||||
|
r37580 | |||
if repo.ui.configbool('experimental', 'lfs.disableusercache'): | ||||
|
r37535 | self.cachevfs = nullvfs() | ||
else: | ||||
|
r37580 | usercache = lfutil._usercachedir(repo.ui, 'lfs') | ||
self.cachevfs = lfsvfs(usercache) | ||||
|
r35489 | self.ui = repo.ui | ||
|
r35097 | |||
|
r35543 | def open(self, oid): | ||
"""Open a read-only file descriptor to the named blob, in either the | ||||
usercache or the local store.""" | ||||
|
r35555 | # The usercache is the most likely place to hold the file. Commit will | ||
# write to both it and the local store, as will anything that downloads | ||||
# the blobs. However, things like clone without an update won't | ||||
# populate the local store. For an init + push of a local clone, | ||||
# the usercache is the only place it _could_ be. If not present, the | ||||
# missing file msg here will indicate the local repo, not the usercache. | ||||
|
r35543 | if self.cachevfs.exists(oid): | ||
return self.cachevfs(oid, 'rb') | ||||
return self.vfs(oid, 'rb') | ||||
|
r35565 | def download(self, oid, src): | ||
"""Read the blob from the remote source in chunks, verify the content, | ||||
and write to this local blobstore.""" | ||||
sha256 = hashlib.sha256() | ||||
with self.vfs(oid, 'wb', atomictemp=True) as fp: | ||||
for chunk in util.filechunkiter(src, size=1048576): | ||||
fp.write(chunk) | ||||
sha256.update(chunk) | ||||
realoid = sha256.hexdigest() | ||||
if realoid != oid: | ||||
raise error.Abort(_('corrupt remote lfs object: %s') % oid) | ||||
|
r37535 | self._linktousercache(oid) | ||
|
r35565 | |||
|
r35567 | def write(self, oid, data): | ||
"""Write blob to local blobstore. | ||||
|
r35492 | |||
|
r35567 | This should only be called from the filelog during a commit or similar. | ||
As such, there is no need to verify the data. Imports from a remote | ||||
store must use ``download()`` instead.""" | ||||
|
r35097 | with self.vfs(oid, 'wb', atomictemp=True) as fp: | ||
fp.write(data) | ||||
|
r37535 | self._linktousercache(oid) | ||
def _linktousercache(self, oid): | ||||
|
r35281 | # XXX: should we verify the content of the cache, and hardlink back to | ||
# the local store on success, but truncate, write and link on failure? | ||||
|
r37535 | if (not self.cachevfs.exists(oid) | ||
and not isinstance(self.cachevfs, nullvfs)): | ||||
|
r35567 | self.ui.note(_('lfs: adding %s to the usercache\n') % oid) | ||
lfutil.link(self.vfs.join(oid), self.cachevfs.join(oid)) | ||||
|
r35281 | |||
|
r35492 | def read(self, oid, verify=True): | ||
|
r35097 | """Read blob from local blobstore.""" | ||
|
r35281 | if not self.vfs.exists(oid): | ||
|
r35492 | blob = self._read(self.cachevfs, oid, verify) | ||
|
r35493 | |||
# Even if revlog will verify the content, it needs to be verified | ||||
# now before making the hardlink to avoid propagating corrupt blobs. | ||||
# Don't abort if corruption is detected, because `hg verify` will | ||||
# give more useful info about the corruption- simply don't add the | ||||
# hardlink. | ||||
if verify or hashlib.sha256(blob).hexdigest() == oid: | ||||
self.ui.note(_('lfs: found %s in the usercache\n') % oid) | ||||
lfutil.link(self.cachevfs.join(oid), self.vfs.join(oid)) | ||||
|
r35489 | else: | ||
self.ui.note(_('lfs: found %s in the local lfs store\n') % oid) | ||||
|
r35492 | blob = self._read(self.vfs, oid, verify) | ||
return blob | ||||
def _read(self, vfs, oid, verify): | ||||
"""Read blob (after verifying) from the given store""" | ||||
blob = vfs.read(oid) | ||||
if verify: | ||||
_verify(oid, blob) | ||||
return blob | ||||
|
r35097 | |||
|
r37163 | def verify(self, oid): | ||
"""Indicate whether or not the hash of the underlying file matches its | ||||
name.""" | ||||
sha256 = hashlib.sha256() | ||||
with self.open(oid) as fp: | ||||
for chunk in util.filechunkiter(fp, size=1048576): | ||||
sha256.update(chunk) | ||||
return oid == sha256.hexdigest() | ||||
|
r35097 | def has(self, oid): | ||
"""Returns True if the local blobstore contains the requested blob, | ||||
False otherwise.""" | ||||
|
r35281 | return self.cachevfs.exists(oid) or self.vfs.exists(oid) | ||
|
r35097 | |||
class _gitlfsremote(object): | ||||
def __init__(self, repo, url): | ||||
ui = repo.ui | ||||
self.ui = ui | ||||
baseurl, authinfo = url.authinfo() | ||||
self.baseurl = baseurl.rstrip('/') | ||||
|
r35456 | useragent = repo.ui.config('experimental', 'lfs.user-agent') | ||
if not useragent: | ||||
|
r35751 | useragent = 'git-lfs/2.3.4 (Mercurial %s)' % util.version() | ||
|
r35455 | self.urlopener = urlmod.opener(ui, authinfo, useragent) | ||
|
r35099 | self.retry = ui.configint('lfs', 'retry') | ||
|
r35097 | |||
def writebatch(self, pointers, fromstore): | ||||
"""Batch upload from local to remote blobstore.""" | ||||
|
r35945 | self._batch(_deduplicate(pointers), fromstore, 'upload') | ||
|
r35097 | |||
def readbatch(self, pointers, tostore): | ||||
"""Batch download from remote to local blostore.""" | ||||
|
r35945 | self._batch(_deduplicate(pointers), tostore, 'download') | ||
|
r35097 | |||
def _batchrequest(self, pointers, action): | ||||
"""Get metadata about objects pointed by pointers for given action | ||||
Return decoded JSON object like {'objects': [{'oid': '', 'size': 1}]} | ||||
See https://github.com/git-lfs/git-lfs/blob/master/docs/api/batch.md | ||||
""" | ||||
objects = [{'oid': p.oid(), 'size': p.size()} for p in pointers] | ||||
requestdata = json.dumps({ | ||||
'objects': objects, | ||||
'operation': action, | ||||
}) | ||||
batchreq = util.urlreq.request('%s/objects/batch' % self.baseurl, | ||||
data=requestdata) | ||||
batchreq.add_header('Accept', 'application/vnd.git-lfs+json') | ||||
batchreq.add_header('Content-Type', 'application/vnd.git-lfs+json') | ||||
try: | ||||
|
r36944 | rsp = self.urlopener.open(batchreq) | ||
rawjson = rsp.read() | ||||
|
r35097 | except util.urlerr.httperror as ex: | ||
raise LfsRemoteError(_('LFS HTTP error: %s (action=%s)') | ||||
% (ex, action)) | ||||
try: | ||||
response = json.loads(rawjson) | ||||
except ValueError: | ||||
raise LfsRemoteError(_('LFS server returns invalid JSON: %s') | ||||
% rawjson) | ||||
|
r36944 | |||
if self.ui.debugflag: | ||||
self.ui.debug('Status: %d\n' % rsp.status) | ||||
# lfs-test-server and hg serve return headers in different order | ||||
self.ui.debug('%s\n' | ||||
% '\n'.join(sorted(str(rsp.info()).splitlines()))) | ||||
if 'objects' in response: | ||||
response['objects'] = sorted(response['objects'], | ||||
key=lambda p: p['oid']) | ||||
self.ui.debug('%s\n' | ||||
|
r37164 | % json.dumps(response, indent=2, | ||
separators=('', ': '), sort_keys=True)) | ||||
|
r36944 | |||
|
r35097 | return response | ||
|
r35684 | def _checkforservererror(self, pointers, responses, action): | ||
|
r35097 | """Scans errors from objects | ||
|
r35712 | Raises LfsRemoteError if any objects have an error""" | ||
|
r35097 | for response in responses: | ||
|
r35684 | # The server should return 404 when objects cannot be found. Some | ||
# server implementation (ex. lfs-test-server) does not set "error" | ||||
# but just removes "download" from "actions". Treat that case | ||||
# as the same as 404 error. | ||||
|
r37259 | if 'error' not in response: | ||
if (action == 'download' | ||||
and action not in response.get('actions', [])): | ||||
code = 404 | ||||
|
r35713 | else: | ||
|
r37259 | continue | ||
else: | ||||
# An error dict without a code doesn't make much sense, so | ||||
# treat as a server error. | ||||
code = response.get('error').get('code', 500) | ||||
ptrmap = {p.oid(): p for p in pointers} | ||||
p = ptrmap.get(response['oid'], None) | ||||
if p: | ||||
filename = getattr(p, 'filename', 'unknown') | ||||
errors = { | ||||
404: 'The object does not exist', | ||||
410: 'The object was removed by the owner', | ||||
422: 'Validation error', | ||||
500: 'Internal server error', | ||||
} | ||||
msg = errors.get(code, 'status code %d' % code) | ||||
raise LfsRemoteError(_('LFS server error for "%s": %s') | ||||
% (filename, msg)) | ||||
else: | ||||
raise LfsRemoteError( | ||||
_('LFS server error. Unsolicited response for oid %s') | ||||
% response['oid']) | ||||
|
r35097 | |||
def _extractobjects(self, response, pointers, action): | ||||
"""extract objects from response of the batch API | ||||
response: parsed JSON object returned by batch API | ||||
return response['objects'] filtered by action | ||||
raise if any object has an error | ||||
""" | ||||
# Scan errors from objects - fail early | ||||
objects = response.get('objects', []) | ||||
|
r35684 | self._checkforservererror(pointers, objects, action) | ||
|
r35097 | |||
# Filter objects with given action. Practically, this skips uploading | ||||
# objects which exist in the server. | ||||
filteredobjects = [o for o in objects if action in o.get('actions', [])] | ||||
return filteredobjects | ||||
|
r35449 | def _basictransfer(self, obj, action, localstore): | ||
|
r35097 | """Download or upload a single object using basic transfer protocol | ||
obj: dict, an object description returned by batch API | ||||
action: string, one of ['upload', 'download'] | ||||
localstore: blobstore.local | ||||
See https://github.com/git-lfs/git-lfs/blob/master/docs/api/\ | ||||
basic-transfers.md | ||||
""" | ||||
|
r36619 | oid = pycompat.bytestr(obj['oid']) | ||
|
r35097 | |||
|
r36619 | href = pycompat.bytestr(obj['actions'][action].get('href')) | ||
|
r35097 | headers = obj['actions'][action].get('header', {}).items() | ||
request = util.urlreq.request(href) | ||||
if action == 'upload': | ||||
# If uploading blobs, read data from local blobstore. | ||||
|
r37234 | if not localstore.verify(oid): | ||
raise error.Abort(_('detected corrupt lfs object: %s') % oid, | ||||
hint=_('run hg verify')) | ||||
|
r35544 | request.data = filewithprogress(localstore.open(oid), None) | ||
|
r35097 | request.get_method = lambda: 'PUT' | ||
|
r37260 | request.add_header('Content-Type', 'application/octet-stream') | ||
|
r35097 | |||
for k, v in headers: | ||||
request.add_header(k, v) | ||||
response = b'' | ||||
try: | ||||
req = self.urlopener.open(request) | ||||
|
r36944 | |||
if self.ui.debugflag: | ||||
self.ui.debug('Status: %d\n' % req.status) | ||||
# lfs-test-server and hg serve return headers in different order | ||||
self.ui.debug('%s\n' | ||||
% '\n'.join(sorted(str(req.info()).splitlines()))) | ||||
|
r35566 | if action == 'download': | ||
# If downloading blobs, store downloaded data to local blobstore | ||||
localstore.download(oid, req) | ||||
else: | ||||
while True: | ||||
data = req.read(1048576) | ||||
if not data: | ||||
break | ||||
response += data | ||||
if response: | ||||
self.ui.debug('lfs %s response: %s' % (action, response)) | ||||
|
r35097 | except util.urlerr.httperror as ex: | ||
|
r35752 | if self.ui.debugflag: | ||
|
r35771 | self.ui.debug('%s: %s\n' % (oid, ex.read())) | ||
|
r35097 | raise LfsRemoteError(_('HTTP error: %s (oid=%s, action=%s)') | ||
% (ex, oid, action)) | ||||
def _batch(self, pointers, localstore, action): | ||||
if action not in ['upload', 'download']: | ||||
raise error.ProgrammingError('invalid Git-LFS action: %s' % action) | ||||
response = self._batchrequest(pointers, action) | ||||
objects = self._extractobjects(response, pointers, action) | ||||
total = sum(x.get('size', 0) for x in objects) | ||||
|
r35449 | sizes = {} | ||
for obj in objects: | ||||
sizes[obj.get('oid')] = obj.get('size', 0) | ||||
|
r35097 | topic = {'upload': _('lfs uploading'), | ||
'download': _('lfs downloading')}[action] | ||||
|
r35494 | if len(objects) > 1: | ||
self.ui.note(_('lfs: need to transfer %d objects (%s)\n') | ||||
% (len(objects), util.bytecount(total))) | ||||
|
r35097 | self.ui.progress(topic, 0, total=total) | ||
|
r35449 | def transfer(chunk): | ||
for obj in chunk: | ||||
objsize = obj.get('size', 0) | ||||
if self.ui.verbose: | ||||
if action == 'download': | ||||
msg = _('lfs: downloading %s (%s)\n') | ||||
elif action == 'upload': | ||||
msg = _('lfs: uploading %s (%s)\n') | ||||
|
r35494 | self.ui.note(msg % (obj.get('oid'), | ||
util.bytecount(objsize))) | ||||
|
r35449 | retry = self.retry | ||
while True: | ||||
try: | ||||
self._basictransfer(obj, action, localstore) | ||||
yield 1, obj.get('oid') | ||||
break | ||||
|
r35491 | except socket.error as ex: | ||
|
r35449 | if retry > 0: | ||
|
r35494 | self.ui.note( | ||
_('lfs: failed: %r (remaining retry %d)\n') | ||||
% (ex, retry)) | ||||
|
r35449 | retry -= 1 | ||
continue | ||||
raise | ||||
|
r35750 | # Until https multiplexing gets sorted out | ||
if self.ui.configbool('experimental', 'lfs.worker-enable'): | ||||
oids = worker.worker(self.ui, 0.1, transfer, (), | ||||
sorted(objects, key=lambda o: o.get('oid'))) | ||||
else: | ||||
oids = transfer(sorted(objects, key=lambda o: o.get('oid'))) | ||||
|
r35449 | processed = 0 | ||
|
r35899 | blobs = 0 | ||
|
r35449 | for _one, oid in oids: | ||
processed += sizes[oid] | ||||
|
r35899 | blobs += 1 | ||
|
r35449 | self.ui.progress(topic, processed, total=total) | ||
|
r35494 | self.ui.note(_('lfs: processed: %s\n') % oid) | ||
|
r35097 | self.ui.progress(topic, pos=None, total=total) | ||
|
r35899 | if blobs > 0: | ||
if action == 'upload': | ||||
self.ui.status(_('lfs: uploaded %d files (%s)\n') | ||||
% (blobs, util.bytecount(processed))) | ||||
# TODO: coalesce the download requests, and comment this in | ||||
#elif action == 'download': | ||||
# self.ui.status(_('lfs: downloaded %d files (%s)\n') | ||||
# % (blobs, util.bytecount(processed))) | ||||
|
r35097 | def __del__(self): | ||
# copied from mercurial/httppeer.py | ||||
urlopener = getattr(self, 'urlopener', None) | ||||
if urlopener: | ||||
for h in urlopener.handlers: | ||||
h.close() | ||||
getattr(h, "close_all", lambda : None)() | ||||
class _dummyremote(object): | ||||
"""Dummy store storing blobs to temp directory.""" | ||||
def __init__(self, repo, url): | ||||
fullpath = repo.vfs.join('lfs', url.path) | ||||
self.vfs = lfsvfs(fullpath) | ||||
def writebatch(self, pointers, fromstore): | ||||
|
r35945 | for p in _deduplicate(pointers): | ||
|
r35492 | content = fromstore.read(p.oid(), verify=True) | ||
|
r35097 | with self.vfs(p.oid(), 'wb', atomictemp=True) as fp: | ||
fp.write(content) | ||||
def readbatch(self, pointers, tostore): | ||||
|
r35945 | for p in _deduplicate(pointers): | ||
|
r35566 | with self.vfs(p.oid(), 'rb') as fp: | ||
tostore.download(p.oid(), fp) | ||||
|
r35097 | |||
class _nullremote(object): | ||||
"""Null store storing blobs to /dev/null.""" | ||||
def __init__(self, repo, url): | ||||
pass | ||||
def writebatch(self, pointers, fromstore): | ||||
pass | ||||
def readbatch(self, pointers, tostore): | ||||
pass | ||||
class _promptremote(object): | ||||
"""Prompt user to set lfs.url when accessed.""" | ||||
def __init__(self, repo, url): | ||||
pass | ||||
def writebatch(self, pointers, fromstore, ui=None): | ||||
self._prompt() | ||||
def readbatch(self, pointers, tostore, ui=None): | ||||
self._prompt() | ||||
def _prompt(self): | ||||
raise error.Abort(_('lfs.url needs to be configured')) | ||||
_storemap = { | ||||
'https': _gitlfsremote, | ||||
'http': _gitlfsremote, | ||||
'file': _dummyremote, | ||||
'null': _nullremote, | ||||
None: _promptremote, | ||||
} | ||||
|
r35945 | def _deduplicate(pointers): | ||
"""Remove any duplicate oids that exist in the list""" | ||||
reduced = util.sortdict() | ||||
for p in pointers: | ||||
reduced[p.oid()] = p | ||||
return reduced.values() | ||||
|
r35492 | def _verify(oid, content): | ||
realoid = hashlib.sha256(content).hexdigest() | ||||
if realoid != oid: | ||||
raise error.Abort(_('detected corrupt lfs object: %s') % oid, | ||||
hint=_('run hg verify')) | ||||
|
r35097 | def remote(repo): | ||
|
r37536 | """remotestore factory. return a store in _storemap depending on config | ||
If ``lfs.url`` is specified, use that remote endpoint. Otherwise, try to | ||||
infer the endpoint, based on the remote repository using the same path | ||||
adjustments as git. As an extension, 'http' is supported as well so that | ||||
``hg serve`` works out of the box. | ||||
https://github.com/git-lfs/git-lfs/blob/master/docs/api/server-discovery.md | ||||
""" | ||||
|
r35632 | url = util.url(repo.ui.config('lfs', 'url') or '') | ||
|
r37536 | if url.scheme is None: | ||
|
r37581 | if util.safehasattr(repo, '_subtoppath'): | ||
# The pull command sets this during the optional update phase, which | ||||
# tells exactly where the pull originated, whether 'paths.default' | ||||
# or explicit. | ||||
defaulturl = util.url(repo._subtoppath) | ||||
else: | ||||
# TODO: investigate 'paths.remote:lfsurl' style path customization, | ||||
# and fall back to inferring from 'paths.remote' if unspecified. | ||||
defaulturl = util.url(repo.ui.config('paths', 'default') or b'') | ||||
|
r37536 | |||
# TODO: support local paths as well. | ||||
# TODO: consider the ssh -> https transformation that git applies | ||||
if defaulturl.scheme in (b'http', b'https'): | ||||
defaulturl.path = defaulturl.path or b'' + b'.git/info/lfs' | ||||
url = util.url(bytes(defaulturl)) | ||||
repo.ui.note(_('lfs: assuming remote store: %s\n') % url) | ||||
|
r35097 | scheme = url.scheme | ||
if scheme not in _storemap: | ||||
raise error.Abort(_('lfs: unknown url scheme: %s') % scheme) | ||||
return _storemap[scheme](repo, url) | ||||
class LfsRemoteError(error.RevlogError): | ||||
pass | ||||