proto.py
175 lines
| 6.6 KiB
| text/x-python
|
PythonLexer
|
r15168 | # Copyright 2011 Fog Creek Software | ||
# | ||||
# This software may be used and distributed according to the terms of the | ||||
# GNU General Public License version 2 or any later version. | ||||
import os | ||||
import urllib2 | ||||
|
r19917 | import re | ||
|
r15168 | |||
|
r17192 | from mercurial import error, httppeer, util, wireproto | ||
|
r15168 | from mercurial.i18n import _ | ||
import lfutil | ||||
|
r15255 | LARGEFILES_REQUIRED_MSG = ('\nThis repository uses the largefiles extension.' | ||
'\n\nPlease enable it in your Mercurial config ' | ||||
'file.\n') | ||||
|
r15168 | |||
|
r18922 | # these will all be replaced by largefiles.uisetup | ||
capabilitiesorig = None | ||||
ssholdcallstream = None | ||||
httpoldcallstream = None | ||||
|
r15168 | def putlfile(repo, proto, sha): | ||
|
r15317 | '''Put a largefile into a repository's local store and into the | ||
user cache.''' | ||||
|
r15168 | proto.redirect() | ||
|
r15391 | |||
|
r16594 | path = lfutil.storepath(repo, sha) | ||
util.makedirs(os.path.dirname(path)) | ||||
tmpfp = util.atomictempfile(path, createmode=repo.store.createmode) | ||||
|
r15168 | try: | ||
|
r25079 | proto.getfile(tmpfp) | ||
tmpfp._fp.seek(0) | ||||
if sha != lfutil.hexsha1(tmpfp._fp): | ||||
raise IOError(0, _('largefile contents do not match hash')) | ||||
tmpfp.close() | ||||
lfutil.linktousercache(repo, sha) | ||||
|
r25660 | except IOError as e: | ||
|
r25079 | repo.ui.warn(_('largefiles: failed to put %s into store: %s\n') % | ||
(sha, e.strerror)) | ||||
return wireproto.pushres(1) | ||||
|
r15168 | finally: | ||
|
r16155 | tmpfp.discard() | ||
|
r15168 | |||
return wireproto.pushres(0) | ||||
def getlfile(repo, proto, sha): | ||||
|
r15252 | '''Retrieve a largefile from the repository-local cache or system | ||
cache.''' | ||||
|
r15168 | filename = lfutil.findfile(repo, sha) | ||
if not filename: | ||||
|
r26587 | raise error.Abort(_('requested largefile %s not present in cache') | ||
% sha) | ||||
|
r15168 | f = open(filename, 'rb') | ||
length = os.fstat(f.fileno())[6] | ||||
|
r15252 | |||
# Since we can't set an HTTP content-length header here, and | ||||
# Mercurial core provides no way to give the length of a streamres | ||||
# (and reading the entire file into RAM would be ill-advised), we | ||||
# just send the length on the first line of the response, like the | ||||
# ssh proto does for string responses. | ||||
|
r15168 | def generator(): | ||
yield '%d\n' % length | ||||
|
r19009 | for chunk in util.filechunkiter(f): | ||
|
r15168 | yield chunk | ||
return wireproto.streamres(generator()) | ||||
def statlfile(repo, proto, sha): | ||||
|
r18488 | '''Return '2\n' if the largefile is missing, '0\n' if it seems to be in | ||
good condition. | ||||
The value 1 is reserved for mismatched checksum, but that is too expensive | ||||
to be verified on every stat and must be caught be running 'hg verify' | ||||
server side.''' | ||||
|
r15168 | filename = lfutil.findfile(repo, sha) | ||
if not filename: | ||||
return '2\n' | ||||
|
r18488 | return '0\n' | ||
|
r15168 | |||
def wirereposetup(ui, repo): | ||||
class lfileswirerepository(repo.__class__): | ||||
def putlfile(self, sha, fd): | ||||
# unfortunately, httprepository._callpush tries to convert its | ||||
# input file-like into a bundle before sending it, so we can't use | ||||
# it ... | ||||
|
r17192 | if issubclass(self.__class__, httppeer.httppeer): | ||
|
r26825 | res = self._call('putlfile', data=fd, sha=sha, | ||
headers={'content-type':'application/mercurial-0.1'}) | ||||
|
r15168 | try: | ||
|
r15778 | d, output = res.split('\n', 1) | ||
for l in output.splitlines(True): | ||||
|
r19949 | self.ui.warn(_('remote: '), l) # assume l ends with \n | ||
|
r15778 | return int(d) | ||
|
r26825 | except ValueError: | ||
|
r19947 | self.ui.warn(_('unexpected putlfile response: %r\n') % res) | ||
|
r15168 | return 1 | ||
# ... but we can't use sshrepository._call because the data= | ||||
# argument won't get sent, and _callpush does exactly what we want | ||||
# in this case: send the data straight through | ||||
else: | ||||
try: | ||||
ret, output = self._callpush("putlfile", fd, sha=sha) | ||||
if ret == "": | ||||
raise error.ResponseError(_('putlfile failed:'), | ||||
output) | ||||
return int(ret) | ||||
except IOError: | ||||
return 1 | ||||
except ValueError: | ||||
raise error.ResponseError( | ||||
_('putlfile failed (unexpected response):'), ret) | ||||
def getlfile(self, sha): | ||||
|
r19004 | """returns an iterable with the chunks of the file with sha sha""" | ||
|
r15168 | stream = self._callstream("getlfile", sha=sha) | ||
length = stream.readline() | ||||
try: | ||||
length = int(length) | ||||
except ValueError: | ||||
|
r15170 | self._abort(error.ResponseError(_("unexpected response:"), | ||
length)) | ||||
|
r19004 | |||
|
r19005 | # SSH streams will block if reading more than length | ||
for chunk in util.filechunkiter(stream, 128 * 1024, length): | ||||
|
r19004 | yield chunk | ||
|
r19006 | # HTTP streams must hit the end to process the last empty | ||
# chunk of Chunked-Encoding so the connection can be reused. | ||||
if issubclass(self.__class__, httppeer.httppeer): | ||||
chunk = stream.read(1) | ||||
if chunk: | ||||
self._abort(error.ResponseError(_("unexpected response:"), | ||||
chunk)) | ||||
|
r15168 | |||
|
r21084 | @wireproto.batchable | ||
|
r15168 | def statlfile(self, sha): | ||
|
r21084 | f = wireproto.future() | ||
|
r17127 | result = {'sha': sha} | ||
yield result, f | ||||
|
r15168 | try: | ||
|
r17127 | yield int(f.value) | ||
|
r15168 | except (ValueError, urllib2.HTTPError): | ||
|
r15252 | # If the server returns anything but an integer followed by a | ||
|
r15168 | # newline, newline, it's not speaking our language; if we get | ||
# an HTTP error, we can't be sure the largefile is present; | ||||
|
r15252 | # either way, consider it missing. | ||
|
r17127 | yield 2 | ||
|
r15168 | |||
repo.__class__ = lfileswirerepository | ||||
# advertise the largefiles=serve capability | ||||
def capabilities(repo, proto): | ||||
|
r16247 | return capabilitiesorig(repo, proto) + ' largefiles=serve' | ||
|
r15168 | |||
def heads(repo, proto): | ||||
if lfutil.islfilesrepo(repo): | ||||
|
r15224 | return wireproto.ooberror(LARGEFILES_REQUIRED_MSG) | ||
|
r15168 | return wireproto.heads(repo, proto) | ||
|
r16247 | def sshrepocallstream(self, cmd, **args): | ||
|
r15168 | if cmd == 'heads' and self.capable('largefiles'): | ||
cmd = 'lheads' | ||||
if cmd == 'batch' and self.capable('largefiles'): | ||||
args['cmds'] = args['cmds'].replace('heads ', 'lheads ') | ||||
|
r16247 | return ssholdcallstream(self, cmd, **args) | ||
|
r15168 | |||
|
r19917 | headsre = re.compile(r'(^|;)heads\b') | ||
|
r16247 | def httprepocallstream(self, cmd, **args): | ||
|
r15168 | if cmd == 'heads' and self.capable('largefiles'): | ||
cmd = 'lheads' | ||||
if cmd == 'batch' and self.capable('largefiles'): | ||||
|
r19917 | args['cmds'] = headsre.sub('lheads', args['cmds']) | ||
|
r16247 | return httpoldcallstream(self, cmd, **args) | ||