We are currently indexing your data, so search results may be incomplete until we finish.
First public release of Kiln BFiles
Changeset e9febbf6d1d9…
by
Benjamin Pollack <benjamin@fogcreek.com>
Changes to 65 files · Browse files at e9febbf6d1d9 Diff from another changeset...
-
design.txt
-
kbfiles/__init__.py
-
kbfiles/basestore.py
-
kbfiles/bfcommands.py
-
kbfiles/bfsetup.py
-
kbfiles/bfutil.py
-
kbfiles/httpstore.py
-
kbfiles/localstore.py
-
tests/README
-
tests/common.py
-
tests/hgtest.py
-
tests/kilntest.py
-
tests/test-add.py
-
tests/test-add.py.out
-
tests/test-addremove.py
-
tests/test-addremove.py.out
-
tests/test-archive.py
-
tests/test-archive.py.out
-
tests/test-backout.py
-
tests/test-backout.py.out
-
tests/test-bisect.py
-
tests/test-bisect.py.out
-
tests/test-clone.py
-
tests/test-clone.py.out
-
tests/test-commit.py
-
tests/test-commit.py.out
-
tests/test-convert.py
-
tests/test-convert.py.out
-
tests/test-converttags.py
-
tests/test-converttags.py.out
-
tests/test-copyrename.py
-
tests/test-copyrename.py.out
-
tests/test-edit.py
-
tests/test-edit.py.out
-
tests/test-fetch.py
-
tests/test-fetch.py.out
-
tests/test-forget.py
-
tests/test-forget.py.out
-
tests/test-kiln.py
-
tests/test-kiln.py.out
-
tests/test-kilnnobfiles.py
-
tests/test-kilnnobfiles.py.out
-
tests/test-outgoing.py
-
tests/test-outgoing.py.out
-
tests/test-permissions.py
-
tests/test-permissions.py.out
-
tests/test-pushpull.py
-
tests/test-pushpull.py.out
-
tests/test-remove.py
-
tests/test-remove.py.out
-
tests/test-repo1.bundle
-
tests/test-reposetup.py
-
tests/test-reposetup.py.out
-
tests/test-revert.py
-
tests/test-revert.py.out
-
tests/test-schemes.py
-
tests/test-schemes.py.out
-
tests/test-status.py
-
tests/test-status.py.out
-
tests/test-summary.py
-
tests/test-summary.py.out
-
tests/test-update.py
-
tests/test-update.py.out
-
tests/test-verify.py
-
tests/test-verify.py.out
|
|
@@ -0,0 +1,42 @@ + = bfiles - manage large binary files =
+This extension is based off of Greg Ward's bfiles extension which can be found
+at http://mercurial.selenic.com/wiki/BfilesExtension.
+
+== The Bfile Store ==
+
+Bfile stores are simply directories where each file is a bfile. The filename
+is the sha1 hash of the bfile. The path is not necessary because all interactions
+with the store have one of these forms:
+
+-Download a bfile with this hash
+-Upload a bfile with this hash
+-Check if the store has a bfile with this hash
+
+== The Local Repository ==
+
+The local repository has a bfile store in .hg/bfiles which holds a subset of the
+bfiles needed. On a clone only the bfiles at tip are downloaded. When bfiles are
+downloaded from the central store a copy is saved in this store.
+
+== The Global Cache ==
+
+Bfiles in a local repository store are hard linked to files in the global cache. Before
+a file is downloaded we check if it is in the global cache.
+
+== Implementation Details ==
+
+Each bfile has a standin which is in .hgbfiles. The standin is tracked by Mercurial.
+The contents of the standin is the SHA1 hash of the bfile. When a bfile is added/removed/
+copied/renamed/etc the same operation is applied to the standin. Thus the history of the
+standin is the history of the bfile.
+
+For performance reasons the contents of a standin is only updated before a commit.
+Standins are added/removed/copied/renamed from add/remove/copy/rename Mercurial
+commands but their contents will not be updated. The contents of a standin will always
+be the hash of the bfile as of the last commit. To support some commands (revert) some
+standins are temporarily updated but will be changed back after the command is finished.
+
+A Mercurial dirstate object tracks the state of the bfiles. The dirstate uses the
+last modified time and current size to detect if a file has changed (without reading
+the entire contents of the file).
+
|
|
|
|
@@ -0,0 +1,32 @@ + '''track large binary files
+
+Large binary files tend to be not very compressible, not very "diffable",
+and not at all mergeable. Such files are not handled well by Mercurial\'s
+storage format (revlog), which is based on compressed binary deltas.
+bfiles solves this problem by adding a centralized client-server layer on
+top of Mercurial: big files live in a *central store* out on the network
+somewhere, and you only fetch the big files that you need when you need
+them.
+
+bfiles works by maintaining a *standin* in .hgbfiles/ for each big file.
+The standins are small (41 bytes: an SHA-1 hash plus newline) and are
+tracked by Mercurial. Big file revisions are identified by the SHA-1 hash
+of their contents, which is written to the standin. bfiles uses that
+revision ID to get/put big file revisions from/to the central store.
+
+A complete tutorial for using bfiles is included in ``usage.txt`` in the
+bfiles source distribution. See
+http://vc.gerg.ca/hg/hg-bfiles/raw-file/tip/usage.txt for the latest
+version.
+'''
+
+from mercurial import commands
+import bfsetup
+import bfcommands
+
+reposetup = bfsetup.reposetup
+uisetup = bfsetup.uisetup
+
+commands.norepo += " kbfconvert"
+
+cmdtable = bfcommands.cmdtable
|
|
|
|
|
@@ -0,0 +1,180 @@ + '''Base class for store implementations and store-related utility code.'''
+
+import os
+import tempfile
+import binascii
+import bfutil
+
+from mercurial import util, node, error, url as url_, hg
+from mercurial.i18n import _
+
+class StoreError(Exception):
+ '''Raised when there is a problem getting files from or putting
+ files to a central store.'''
+ def __init__(self, filename, hash, url, detail):
+ self.filename = filename
+ self.hash = hash
+ self.url = url
+ self.detail = detail
+
+ def longmessage(self):
+ return ("%s: %s\n"
+ "(failed URL: %s)\n"
+ % (self.filename, self.detail, self.url))
+
+ def __str__(self):
+ return "%s: %s" % (self.url, self.detail)
+
+class basestore(object):
+ def __init__(self, ui, repo, url):
+ self.ui = ui
+ self.repo = repo
+ self.url = url
+
+ def put(self, source, hash):
+ '''Put source file into the store under <filename>/<hash>.'''
+ raise NotImplementedError('abstract method')
+
+ def exists(self, hash):
+ '''Check to see if the store contains the given hash.'''
+ raise NotImplementedError('abstract method')
+
+ def get(self, files):
+ '''Get the specified big files from the store and write to local
+ files under repo.root. files is a list of (filename, hash)
+ tuples. Return (success, missing), lists of files successfuly
+ downloaded and those not found in the store. success is a list
+ of (filename, hash) tuples; missing is a list of filenames that
+ we could not get. (The detailed error message will already have
+ been presented to the user, so missing is just supplied as a
+ summary.)'''
+ success = []
+ missing = []
+ ui = self.ui
+
+ at = 0
+ for filename, hash in files:
+ ui.progress(_('Getting kbfiles'), at, unit='kbfile', total=len(files))
+ at += 1
+ ui.note(_('getting %s\n') % filename)
+ outfilename = self.repo.wjoin(filename)
+ destdir = os.path.dirname(outfilename)
+ util.makedirs(destdir)
+ if not os.path.isdir(destdir):
+ self.abort(error.RepoError(_('cannot create dest directory %s') % destdir))
+
+ # No need to pass mode='wb' to fdopen(), since mkstemp() already
+ # opened the file in binary mode.
+ (tmpfd, tmpfilename) = tempfile.mkstemp(
+ dir=destdir, prefix=os.path.basename(filename))
+ tmpfile = os.fdopen(tmpfd, 'w')
+
+ try:
+ bhash = self._getfile(tmpfile, filename, hash)
+ except StoreError, err:
+ ui.warn(err.longmessage())
+ os.remove(tmpfilename)
+ missing.append(filename)
+ continue
+
+ hhash = binascii.hexlify(bhash)
+ if hhash != hash:
+ ui.warn(_('%s: data corruption (expected %s, got %s)\n')
+ % (filename, hash, hhash))
+ os.remove(tmpfilename)
+ missing.append(filename)
+ else:
+ if os.path.exists(outfilename): # for windows
+ os.remove(outfilename)
+ os.rename(tmpfilename, outfilename)
+ bfutil.copy_to_cache(self.repo, self.repo['.'].node(), filename, True)
+ success.append((filename, hhash))
+
+ ui.progress(_('Getting bfiles'), None)
+ return (success, missing)
+
+ def verify(self, revs, contents=False):
+ '''Verify the existence (and, optionally, contents) of every big
+ file revision referenced by every changeset in revs.
+ Return 0 if all is well, non-zero on any errors.'''
+ write = self.ui.write
+ failed = False
+
+ write(_('searching %d changesets for big files\n') % len(revs))
+ verified = set() # set of (filename, filenode) tuples
+
+ for rev in revs:
+ cctx = self.repo[rev]
+ cset = "%d:%s" % (cctx.rev(), node.short(cctx.node()))
+
+ for standin in cctx:
+ failed = (self._verifyfile(cctx,
+ cset,
+ contents,
+ standin,
+ verified)
+ or failed)
+
+ num_revs = len(verified)
+ num_bfiles = len(set([fname for (fname, fnode) in verified]))
+ if contents:
+ write(_('verified contents of %d revisions of %d big files\n')
+ % (num_revs, num_bfiles))
+ else:
+ write(_('verified existence of %d revisions of %d big files\n')
+ % (num_revs, num_bfiles))
+
+ return int(failed)
+
+ def _getfile(self, tmpfile, filename, hash):
+ '''Fetch one revision of one file from the store and write it
+ to tmpfile. Compute the hash of the file on-the-fly as it
+ downloads and return the binary hash. Close tmpfile. Raise
+ StoreError if unable to download the file (e.g. it does not
+ exist in the store).'''
+ raise NotImplementedError('abstract method')
+
+ def _verifyfile(self, cctx, cset, contents, standin, verified):
+ '''Perform the actual verification of a file in the store.
+ '''
+ raise NotImplementedError('abstract method')
+
+import localstore, httpstore
+
+_store_provider = {
+ 'file': (localstore, 'localstore'),
+ 'http': (httpstore, 'httpstore'),
+ 'https': (httpstore, 'httpstore'),
+ }
+
+# During clone this function is passed the src's ui object
+# but it needs the dest's ui object so it can read out of
+# the config file. Use repo.ui instead.
+def _open_store(repo, path=None, put=False):
+ ui = repo.ui
+ if not path:
+ path = ui.expandpath('default-push', 'default')
+ # If 'default-push' and 'default' can't be expanded
+ # they are just returned. In that case use the empty string which
+ # use the filescheme.
+ if path is 'default-push' or path is 'default':
+ path = ''
+
+ # The path could be a scheme so use Mercurial's normal functionality
+ # to resolve the scheme to a repository and use its path
+ if path:
+ path = hg.repository(ui, path).path
+
+ match = url_.scheme_re.match(path)
+ if not match: # regular filesystem path
+ scheme = 'file'
+ else:
+ scheme = match.group(1)
+
+ try:
+ (mod, klass) = _store_provider[scheme]
+ except KeyError:
+ raise util.Abort(_('unsupported URL scheme %r') % scheme)
+
+ klass = getattr(mod, klass)
+ return klass(ui, repo, path)
|
|
|
|
@@ -0,0 +1,523 @@ + '''High-level command functions: bfadd() et. al, plus the cmdtable.'''
+
+import os
+import shutil
+
+from mercurial import util, match as match_, hg, node, context, error
+from mercurial.i18n import _
+
+import bfutil, basestore
+
+# -- Commands ----------------------------------------------------------
+
+def bfconvert(ui, src, dest, *pats, **opts):
+ '''Convert a repository to a repository using bfiles
+
+ Convert source repository creating an identical
+ repository, except that all files that match the
+ patterns given, or are over a given size will
+ be added as bfiles. The size of a file is the size of the
+ first version of the file. After running this command you
+ will need to set the store then run bfput on the new
+ repository to upload the bfiles to the central store.
+ '''
+
+ if opts['tonormal']:
+ tobfile = False
+ else:
+ tobfile = True
+ size = opts['size']
+ if not size:
+ size = ui.config(bfutil.long_name, 'size', default=None)
+ try:
+ size = int(size)
+ except ValueError:
+ raise util.Abort(_('bfiles.size must be integer, was %s\n') % size)
+ except TypeError:
+ raise util.Abort(_('size must be specified'))
+
+ try:
+ rsrc = hg.repository(ui, src)
+ if not rsrc.local():
+ raise util.Abort(_('%s is not a local Mercurial repo') % src)
+ except error.RepoError, err:
+ ui.traceback()
+ raise util.Abort(err.args[0])
+ if os.path.exists(dest):
+ if not os.path.isdir(dest):
+ raise util.Abort(_('destination %s already exists') % dest)
+ elif os.listdir(dest):
+ raise util.Abort(_('destination %s is not empty') % dest)
+ try:
+ ui.status(_('initializing destination %s\n') % dest)
+ rdst = hg.repository(ui, dest, create=True)
+ if not rdst.local():
+ raise util.Abort(_('%s is not a local Mercurial repo') % dest)
+ except error.RepoError:
+ ui.traceback()
+ raise util.Abort(_('%s is not a repo') % dest)
+
+ try:
+ # Lock destination to prevent modification while it is converted to.
+ # Don't need to lock src because we are just reading from its history
+ # which can't change.
+ dst_lock = rdst.lock()
+
+ # Get a list of all changesets in the source. The easy way to do this
+ # is to simply walk the changelog, using changelog.nodesbewteen().
+ # Take a look at mercurial/revlog.py:639 for more details.
+ # Use a generator instead of a list to decrease memory usage
+ ctxs = (rsrc[ctx] for ctx in rsrc.changelog.nodesbetween(None, rsrc.heads())[0])
+ revmap = {node.nullid: node.nullid}
+ if tobfile:
+ bfiles = set()
+ normalfiles = set()
+ if not pats:
+ pats = ui.config(bfutil.long_name, 'patterns', default=())
+ if pats:
+ pats = pats.split(' ')
+ if pats:
+ matcher = match_.match(rsrc.root, '', list(pats))
+ else:
+ matcher = None
+
+ bfiletohash = {}
+ for ctx in ctxs:
+ ui.progress(_('Converting revisions'), ctx.rev(), unit=_('revision'), total=rsrc['tip'].rev())
+ _bfconvert_addchangeset(rsrc, rdst, ctx, revmap,
+ bfiles, normalfiles, matcher, size, bfiletohash)
+ ui.progress(_('Converting revisions'), None)
+
+ if os.path.exists(rdst.wjoin(bfutil.short_name)):
+ shutil.rmtree(rdst.wjoin(bfutil.short_name))
+
+ for f in bfiletohash.keys():
+ if os.path.isfile(rdst.wjoin(f)):
+ os.unlink(rdst.wjoin(f))
+ try:
+ os.removedirs(os.path.dirname(rdst.wjoin(f)))
+ except:
+ pass
+
+ else:
+ for ctx in ctxs:
+ ui.progress(_('Converting revisions'), ctx.rev(), unit=_('revision'), total=rsrc['tip'].rev())
+ _addchangeset(ui, rsrc, rdst, ctx, revmap)
+
+ ui.progress(_('Converting revisions'), None)
+ except:
+ # we failed, remove the new directory
+ shutil.rmtree(rdst.root)
+ raise
+ finally:
+ dst_lock.release()
+
+def _addchangeset(ui, rsrc, rdst, ctx, revmap):
+ # Convert src parents to dst parents
+ parents = []
+ for p in ctx.parents():
+ parents.append(revmap[p.node()])
+ while len(parents) < 2:
+ parents.append(node.nullid)
+
+ # Generate list of changed files
+ files = set(ctx.files())
+ if node.nullid not in parents:
+ mc = ctx.manifest()
+ mp1 = ctx.parents()[0].manifest()
+ mp2 = ctx.parents()[1].manifest()
+ for f in mp1:
+ if f not in mc:
+ files.add(f)
+ for f in mp2:
+ if f not in mc:
+ files.add(f)
+ for f in mc:
+ if mc[f] != mp1.get(f, None) or mc[f] != mp2.get(f, None):
+ files.add(f)
+
+ def getfilectx(repo, memctx, f):
+ if bfutil.standin(f) in files:
+ # if the file isn't in the manifest then it was removed
+ # or renamed, raise IOError to indicate this
+ try:
+ fctx = ctx.filectx(bfutil.standin(f))
+ except error.LookupError:
+ raise IOError()
+ renamed = fctx.renamed()
+ if renamed:
+ renamed = bfutil.split_standin(renamed[0])
+
+ hash = fctx.data().strip()
+ path = bfutil.find_file(rsrc, hash)
+ ### TODO: What if the file is not cached?
+ data = ''
+ with open(path, 'rb') as fd:
+ data = fd.read()
+ return context.memfilectx(f, data, 'l' in fctx.flags(),
+ 'x' in fctx.flags(), renamed)
+ else:
+ try:
+ fctx = ctx.filectx(f)
+ except error.LookupError:
+ raise IOError()
+ renamed = fctx.renamed()
+ if renamed:
+ renamed = renamed[0]
+ data = fctx.data()
+ if f == '.hgtags':
+ newdata = []
+ for line in data.splitlines():
+ id, name = line.split(' ', 1)
+ newdata.append('%s %s\n' % (node.hex(revmap[node.bin(id)]), name))
+ data = ''.join(newdata)
+ return context.memfilectx(f, data, 'l' in fctx.flags(),
+ 'x' in fctx.flags(), renamed)
+
+ dstfiles = []
+ for file in files:
+ if bfutil.is_standin(file):
+ dstfiles.append(bfutil.split_standin(file))
+ else:
+ dstfiles.append(file)
+ # Commit
+ mctx = context.memctx(rdst, parents, ctx.description(), dstfiles,
+ getfilectx, ctx.user(), ctx.date(), ctx.extra())
+ ret = rdst.commitctx(mctx)
+ rdst.dirstate.setparents(ret)
+ revmap[ctx.node()] = rdst.changelog.tip()
+
+def _bfconvert_addchangeset(rsrc, rdst, ctx, revmap, bfiles, normalfiles, matcher, size, bfiletohash):
+ # Convert src parents to dst parents
+ parents = []
+ for p in ctx.parents():
+ parents.append(revmap[p.node()])
+ while len(parents) < 2:
+ parents.append(node.nullid)
+
+ # Generate list of changed files
+ files = set(ctx.files())
+ if node.nullid not in parents:
+ mc = ctx.manifest()
+ mp1 = ctx.parents()[0].manifest()
+ mp2 = ctx.parents()[1].manifest()
+ for f in mp1:
+ if f not in mc:
+ files.add(f)
+ for f in mp2:
+ if f not in mc:
+ files.add(f)
+ for f in mc:
+ if mc[f] != mp1.get(f, None) or mc[f] != mp2.get(f, None):
+ files.add(f)
+
+ dstfiles = []
+ for f in files:
+ if f not in bfiles and f not in normalfiles:
+ isbfile = _is_bfile(f, ctx, matcher, size)
+ # If this file was renamed or copied then copy
+ # the bfileness of its predecessor
+ if f in ctx.manifest():
+ fctx = ctx.filectx(f)
+ renamed = fctx.renamed()
+ renamedbfile = renamed and renamed[0] in bfiles
+ isbfile |= renamedbfile
+ if 'l' in fctx.flags():
+ if renamedbfile:
+ raise util.Abort(_('Renamed/copied bfile %s becomes symlink') % f)
+ isbfile = False
+ if isbfile:
+ bfiles.add(f)
+ else:
+ normalfiles.add(f)
+
+ if f in bfiles:
+ dstfiles.append(bfutil.standin(f))
+ # bfile in manifest if it has not been removed/renamed
+ if f in ctx.manifest():
+ if 'l' in ctx.filectx(f).flags():
+ if renamed and renamed[0] in bfiles:
+ raise util.Abort(_('bfile %s becomes symlink') % f)
+
+ # bfile was modified, update standins
+ fullpath = rdst.wjoin(f)
+ bfutil.create_dir(os.path.dirname(fullpath))
+ m = util.sha1('')
+ m.update(ctx[f].data())
+ hash = m.hexdigest()
+ if f not in bfiletohash or bfiletohash[f] != hash:
+ with open(fullpath, 'wb') as fd:
+ fd.write(ctx[f].data())
+ executable = 'x' in ctx[f].flags()
+ os.chmod(fullpath, bfutil.get_mode(executable))
+ bfutil.write_standin(rdst, bfutil.standin(f), hash, executable)
+ bfiletohash[f] = hash
+ else:
+ # normal file
+ dstfiles.append(f)
+
+ def getfilectx(repo, memctx, f):
+ if bfutil.is_standin(f):
+ # if the file isn't in the manifest then it was removed
+ # or renamed, raise IOError to indicate this
+ srcfname = bfutil.split_standin(f)
+ try:
+ fctx = ctx.filectx(srcfname)
+ except error.LookupError:
+ raise IOError()
+ renamed = fctx.renamed()
+ if renamed:
+ # standin is always a bfile because bfileness
+ # doesn't change after rename or copy
+ renamed = bfutil.standin(renamed[0])
+
+ return context.memfilectx(f, bfiletohash[srcfname], 'l' in fctx.flags(),
+ 'x' in fctx.flags(), renamed)
+ else:
+ try:
+ fctx = ctx.filectx(f)
+ except error.LookupError:
+ raise IOError()
+ renamed = fctx.renamed()
+ if renamed:
+ renamed = renamed[0]
+
+ data = fctx.data()
+ if f == '.hgtags':
+ newdata = []
+ for line in data.splitlines():
+ id, name = line.split(' ', 1)
+ newdata.append('%s %s\n' % (node.hex(revmap[node.bin(id)]), name))
+ data = ''.join(newdata)
+ return context.memfilectx(f, data, 'l' in fctx.flags(),
+ 'x' in fctx.flags(), renamed)
+
+ # Commit
+ mctx = context.memctx(rdst, parents, ctx.description(), dstfiles,
+ getfilectx, ctx.user(), ctx.date(), ctx.extra())
+ ret = rdst.commitctx(mctx)
+ rdst.dirstate.setparents(ret)
+ revmap[ctx.node()] = rdst.changelog.tip()
+
+def _is_bfile(file, ctx, matcher, size):
+ '''
+ A file is a bfile if it matches a pattern or is over
+ the given size.
+ '''
+ # Never store hgtags or hgignore as bfiles
+ if file == '.hgtags' or file == '.hgignore' or file == '.hgsigs':
+ return False
+ if matcher and matcher(file):
+ return True
+ try:
+ return ctx.filectx(file).size() >= size * 1024 * 1024
+ except error.LookupError:
+ return False
+
+def upload_bfiles(ui, rsrc, rdst, files):
+ '''upload big files to the central store'''
+
+ if not files:
+ return
+
+ # Don't upload locally. All bfiles are in the system wide cache
+ # so the other repo can just get them from there.
+ if not rdst.path.startswith('http'):
+ return
+
+ store = basestore._open_store(rsrc, rdst.path, put=True)
+
+ at = 0
+ for hash in files:
+ ui.progress(_('Uploading bfiles'), at, unit='bfile', total=len(files))
+ if store.exists(hash):
+ at += 1
+ continue
+ source = bfutil.find_file(rsrc, hash)
+ if not source:
+ raise util.Abort(_('Missing bfile %s needs to be uploaded') % hash)
+ # XXX check for errors here
+ store.put(source, hash)
+ at += 1
+ ui.progress('Uploading bfiles', None)
+
+def verify_bfiles(ui, repo, all=False, contents=False):
+ '''Verify that every big file revision in the current changeset
+ exists in the central store. With --contents, also verify that
+ the contents of each big file revision are correct (SHA-1 hash
+ matches the revision ID). With --all, check every changeset in
+ this repository.'''
+ if all:
+ # Pass a list to the function rather than an iterator because we know a list will work.
+ revs = range(len(repo))
+ else:
+ revs = ['.']
+
+ store = basestore._open_store(repo)
+ return store.verify(revs, contents=contents)
+
+def revert_bfiles(ui, repo):
+ wlock = repo.wlock()
+ try:
+ bfdirstate = bfutil.open_bfdirstate(ui, repo)
+ s = bfdirstate.status(match_.always(repo.root, repo.getcwd()), [], False, False, False)
+ (unsure, modified, added, removed, missing, unknown, ignored, clean) = s
+
+ bfiles = bfutil.list_bfiles(repo)
+ toget = []
+ at = 0
+ updated = 0
+ for bfile in bfiles:
+ if not os.path.exists(repo.wjoin(bfutil.standin(bfile))):
+ bfdirstate.remove(bfile)
+ continue
+ if os.path.exists(repo.wjoin(bfutil.standin(os.path.join(bfile + '.orig')))):
+ shutil.copyfile(repo.wjoin(bfile), repo.wjoin(bfile + '.orig'))
+ at += 1
+ expectedhash = repo[None][bfutil.standin(bfile)].data().strip()
+ mode = os.stat(repo.wjoin(bfutil.standin(bfile))).st_mode
+ if not os.path.exists(repo.wjoin(bfile)) or expectedhash != bfutil.hashfile(repo.wjoin(bfile)):
+ path = bfutil.find_file(repo, expectedhash)
+ if path is None:
+ toget.append((bfile, expectedhash))
+ else:
+ util.makedirs(os.path.dirname(repo.wjoin(bfile)))
+ shutil.copy(path, repo.wjoin(bfile))
+ os.chmod(repo.wjoin(bfile), mode)
+ updated += 1
+ if bfutil.standin(bfile) not in repo['.']:
+ bfdirstate.add(bfutil.unixpath(bfile))
+ elif expectedhash == repo['.'][bfutil.standin(bfile)].data().strip():
+ bfdirstate.normal(bfutil.unixpath(bfile))
+ else:
+ bfutil.dirstate_normaldirty(bfdirstate, bfutil.unixpath(bfile))
+ elif os.path.exists(repo.wjoin(bfile)) and mode != os.stat(repo.wjoin(bfile)).st_mode:
+ os.chmod(repo.wjoin(bfile), mode)
+ updated += 1
+ if bfutil.standin(bfile) not in repo['.']:
+ bfdirstate.add(bfutil.unixpath(bfile))
+ elif expectedhash == repo['.'][bfutil.standin(bfile)].data().strip():
+ bfdirstate.normal(bfutil.unixpath(bfile))
+ else:
+ bfutil.dirstate_normaldirty(bfdirstate, bfutil.unixpath(bfile))
+
+ if toget:
+ store = basestore._open_store(repo)
+ (success, missing) = store.get(toget)
+ else:
+ success, missing = [], []
+
+ for (filename, hash) in success:
+ mode = os.stat(repo.wjoin(bfutil.standin(filename))).st_mode
+ os.chmod(repo.wjoin(filename), mode)
+ updated += 1
+ if bfutil.standin(filename) not in repo['.']:
+ bfdirstate.add(bfutil.unixpath(filename))
+ elif hash == repo['.'][bfutil.standin(filename)].data().strip():
+ bfdirstate.normal(bfutil.unixpath(filename))
+ else:
+ bfutil.dirstate_normaldirty(bfdirstate, bfutil.unixpath(filename))
+
+ removed = 0
+ for bfile in bfdirstate:
+ if not os.path.exists(repo.wjoin(bfutil.standin(bfile))):
+ if os.path.exists(repo.wjoin(bfile)):
+ os.unlink(repo.wjoin(bfile))
+ removed += 1
+ if bfutil.standin(bfile) in repo['.']:
+ bfdirstate.remove(bfutil.unixpath(bfile))
+ else:
+ bfdirstate.forget(bfutil.unixpath(bfile))
+ else:
+ state = repo.dirstate[bfutil.standin(bfile)]
+ if state == 'n':
+ bfdirstate.normal(bfile)
+ elif state == 'r':
+ bfdirstate.remove(bfile)
+ elif state == 'a':
+ bfdirstate.add(bfile)
+ elif state == '?':
+ bfdirstate.forget(bfile)
+ bfdirstate.write()
+ finally:
+ wlock.release()
+
+def update_bfiles(ui, repo):
+ wlock = repo.wlock()
+ try:
+ bfdirstate = bfutil.open_bfdirstate(ui, repo)
+ s = bfdirstate.status(match_.always(repo.root, repo.getcwd()), [], False, False, False)
+ (unsure, modified, added, removed, missing, unknown, ignored, clean) = s
+
+ bfiles = bfutil.list_bfiles(repo)
+ toget = []
+ at = 0
+ updated = 0
+ removed = 0
+ printed = False
+ if bfiles:
+ ui.status(_('Getting changed bfiles\n'))
+ printed = True
+
+ for bfile in bfiles:
+ at += 1
+ if os.path.exists(repo.wjoin(bfile)) and not os.path.exists(repo.wjoin(bfutil.standin(bfile))):
+ os.unlink(repo.wjoin(bfile))
+ removed += 1
+ bfdirstate.forget(bfutil.unixpath(bfile))
+ continue
+ expectedhash = repo[None][bfutil.standin(bfile)].data().strip()
+ mode = os.stat(repo.wjoin(bfutil.standin(bfile))).st_mode
+ if not os.path.exists(repo.wjoin(bfile)) or expectedhash != bfutil.hashfile(repo.wjoin(bfile)):
+ path = bfutil.find_file(repo, expectedhash)
+ if not path:
+ toget.append((bfile, expectedhash))
+ else:
+ util.makedirs(os.path.dirname(repo.wjoin(bfile)))
+ shutil.copy(path, repo.wjoin(bfile))
+ os.chmod(repo.wjoin(bfile), mode)
+ updated += 1
+ bfdirstate.normal(bfutil.unixpath(bfile))
+ elif os.path.exists(repo.wjoin(bfile)) and mode != os.stat(repo.wjoin(bfile)).st_mode:
+ os.chmod(repo.wjoin(bfile), mode)
+ updated += 1
+ bfdirstate.normal(bfutil.unixpath(bfile))
+
+ if toget:
+ store = basestore._open_store(repo)
+ (success, missing) = store.get(toget)
+ else:
+ success, missing = [],[]
+
+ for (filename, hash) in success:
+ mode = os.stat(repo.wjoin(bfutil.standin(filename))).st_mode
+ os.chmod(repo.wjoin(filename), mode)
+ updated += 1
+ bfdirstate.normal(bfutil.unixpath(filename))
+
+ for bfile in bfdirstate:
+ if bfile not in bfiles:
+ if os.path.exists(repo.wjoin(bfile)):
+ if not printed:
+ ui.status(_('Getting changed bfiles\n'))
+ printed = True
+ os.unlink(repo.wjoin(bfile))
+ removed += 1
+ bfdirstate.forget(bfutil.unixpath(bfile))
+
+ bfdirstate.write()
+ if printed:
+ ui.status(_('%d big files updated, %d removed\n') % (updated, removed))
+ finally:
+ wlock.release()
+
+# -- hg commands declarations ------------------------------------------------
+
+
+cmdtable = {
+ 'kbfconvert': (bfconvert,
+ [('s', 'size', 0, 'All files over this size '
+ '(in megabytes) will be considered bfiles. This can also be specified in your hgrc as [bfiles].size.'),
+ ('','tonormal',False, 'Convert from a bfiles repo to a normal repo')],
+ _('hg kbfconvert SOURCE DEST [FILE ...]')),
+ }
|
|
|
|
@@ -0,0 +1,1044 @@ + '''Setup code for bfiles extension: reposetup(), uisetup().'''
+
+import os
+import types
+import copy
+
+from mercurial import hg, extensions, commands, util, context, cmdutil, \
+ match as match_, filemerge, node, archival, httprepo, error
+from mercurial.i18n import _
+from mercurial.node import hex
+import bfutil, bfcommands
+
+def hgversion():
+ from mercurial.__version__ import version
+ return [int(n) for n in version.partition('+')[0].split('.')]
+hgversion = hgversion()
+
+# -- Wrappers: modify existing commands --------------------------------
+
+def reposetup(ui, repo):
+ # add a kbfiles-specific querystring argument to remote requests, so kiln can reject
+ # operations on a kbfiles-enabled remote repo from a non-kbfiles local repo.
+ if issubclass(repo.__class__, httprepo.httprepository):
+ class kbfilesrepo(repo.__class__):
+ # The function we want to override is do_cmd for Mercurial <= 1.6
+ # and _callstream for Mercurial > 1.6. Wrap whichever one we can find.
+ if hasattr(repo.__class__, 'do_cmd'):
+ def do_cmd(self, cmd, **args):
+ args['kbfiles'] = 'true'
+ return super(repo.__class__, self).do_cmd(cmd, **args)
+ if hasattr(repo.__class__, '_callstream'):
+ def _callstream(self, cmd, **args):
+ args['kbfiles'] = 'true'
+ return super(repo.__class__, self)._callstream(cmd, **args)
+ repo.__class__ = kbfilesrepo
+
+ # bfiles doesn't support non-local repositories -- get out quick in
+ # such a case
+ if not repo.local():
+ return
+
+ for name in ('status', 'commitctx', 'commit', 'push'):
+ method = getattr(repo, name)
+ #if not (isinstance(method, types.MethodType) and
+ # method.im_func is repo.__class__.commitctx.im_func):
+ if isinstance(method, types.FunctionType) and method.func_name == 'wrap':
+ ui.warn(_('kbfiles: repo method %r appears to have already been '
+ 'wrapped by another extension: '
+ 'kbfiles may behave incorrectly\n')
+ % name)
+
+ class bfiles_repo(repo.__class__):
+ bfstatus = False
+ def status_nobfiles(self, *args, **kwargs):
+ return super(bfiles_repo, self).status(*args, **kwargs)
+
+ # Figure out the status of big files and insert them into the
+ # appropriate list in the result. Also removes standin files from
+ # the listing. This function reverts to the original status if
+ # self.bfstatus is False
+ def status(self, node1='.', node2=None, match=None, ignored=False, clean=False, unknown=False, subrepos=None):
+ listignored, listclean, listunknown = ignored, clean, unknown
+ if not self.bfstatus:
+ try:
+ return super(bfiles_repo, self).status(node1, node2, match, listignored, listclean, listunknown, subrepos)
+ except TypeError:
+ return super(bfiles_repo, self).status(node1, node2, match, listignored, listclean, listunknown)
+ else:
+ # some calls in this function rely on the old version of status
+ self.bfstatus = False
+ if isinstance(node1, context.changectx):
+ ctx1 = node1
+ else:
+ ctx1 = repo[node1]
+ if isinstance(node2, context.changectx):
+ ctx2 = node2
+ else:
+ ctx2 = repo[node2]
+ working = ctx2.rev() is None
+ parentworking = working and ctx1 == self['.']
+
+ def inctx(file, ctx):
+ try:
+ if ctx.rev() is None:
+ return file in ctx.manifest()
+ ctx[file]
+ return True
+ except:
+ return False
+
+ # create a copy of match that matches standins instead of bfiles
+ # if matcher not set then it is the always matcher so overwrite that
+ if match is None:
+ match = match_.always(self.root, self.getcwd())
+
+ def tostandin(file):
+ if inctx(bfutil.standin(file), ctx2):
+ return bfutil.standin(file)
+ return file
+
+ m = copy.copy(match)
+ m._files = [tostandin(f) for f in m._files]
+
+ # get ignored clean and unknown but remove them later if they were not asked for
+ try:
+ result = super(bfiles_repo, self).status(node1, node2, m, True, True, True, subrepos)
+ except TypeError:
+ result = super(bfiles_repo, self).status(node1, node2, m, True, True, True)
+ if working:
+ # Hold the wlock while we read bfiles and update the bfdirstate
+ wlock = repo.wlock()
+ try:
+ # Any non bfiles that were explicitly listed must be taken out or
+ # bfdirstate.status will report an error. The status of these files
+ # was already computed using super's status.
+ bfdirstate = bfutil.open_bfdirstate(ui, self)
+ match._files = [f for f in match._files if f in bfdirstate]
+ s = bfdirstate.status(match, [], listignored, listclean, listunknown)
+ (unsure, modified, added, removed, missing, unknown, ignored, clean) = s
+ if parentworking:
+ for bfile in unsure:
+ if ctx1[bfutil.standin(bfile)].data().strip() != bfutil.hashfile(self.wjoin(bfile)):
+ modified.append(bfile)
+ else:
+ clean.append(bfile)
+ bfdirstate.normal(bfutil.unixpath(bfile))
+ bfdirstate.write()
+ else:
+ tocheck = unsure + modified + added + clean
+ modified, added, clean = [], [], []
+
+ for bfile in tocheck:
+ standin = bfutil.standin(bfile)
+ if inctx(standin, ctx1):
+ if ctx1[standin].data().strip() != bfutil.hashfile(self.wjoin(bfile)):
+ modified.append(bfile)
+ else:
+ clean.append(bfile)
+ else:
+ added.append(bfile)
+ finally:
+ wlock.release()
+
+ for standin in ctx1.manifest():
+ if not bfutil.is_standin(standin):
+ continue
+ bfile = bfutil.split_standin(standin)
+ if not match(bfile):
+ continue
+ if bfile not in bfdirstate:
+ removed.append(bfile)
+ # Handle unknown and ignored differently
+ bfiles = (modified, added, removed, missing, [], [], clean)
+ result = list(result)
+ # Unknown files
+ result[4] = [f for f in unknown if repo.dirstate[f] == '?' and not bfutil.is_standin(f)]
+ # Ignored files must be ignored by both the dirstate and bfdirstate
+ result[5] = set(ignored).intersection(set(result[5]))
+ # combine normal files and bfiles
+ normals = [[fn for fn in filelist if not bfutil.is_standin(fn)] for filelist in result]
+ result = [sorted(list1 + list2) for (list1, list2) in zip(normals, bfiles)]
+ else:
+ def toname(f):
+ if bfutil.is_standin(f):
+ return bfutil.split_standin(f)
+ return f
+ result = [[toname(f) for f in items] for items in result]
+
+ if not listunknown:
+ result[4] = []
+ if not listignored:
+ result[5] = []
+ if not listclean:
+ result[6] = []
+ self.bfstatus = True
+ return result
+
+ # This call happens after a commit has occurred. Copy all of the bfiles
+ # into the cache
+ def commitctx(self, *args, **kwargs):
+ node = super(bfiles_repo, self).commitctx(*args, **kwargs)
+ ctx = self[node]
+ for filename in ctx.files():
+ if bfutil.is_standin(filename) and filename in ctx.manifest():
+ realfile = bfutil.split_standin(filename)
+ bfutil.copy_to_cache(self, ctx.node(), realfile)
+
+ return node
+
+ # This call happens before a commit has occurred. The bfile standins
+ # have not had their contents updated (to reflect the hash of their bfile).
+ # Do that here.
+ def commit(self, text="", user=None, date=None, match=None, force=False,
+ editor=False, extra={}):
+ orig = super(bfiles_repo, self).commit
+
+ wlock = repo.wlock()
+ try:
+ # Case 1: user calls commit with no specific files or
+ # include/exclude patterns: refresh and commit everything.
+ if (match is None) or (not match.anypats() and not match.files()):
+ bfiles = bfutil.list_bfiles(self)
+ bfdirstate = bfutil.open_bfdirstate(ui, self)
+ # this only loops through bfiles that exist (not removed/renamed)
+ for bfile in bfiles:
+ if os.path.exists(self.wjoin(bfutil.standin(bfile))):
+ bfutil.update_standin(self, bfutil.standin(bfile))
+ bfdirstate.normal(bfutil.unixpath(bfile))
+ for bfile in bfdirstate:
+ if not os.path.exists(repo.wjoin(bfutil.standin(bfile))):
+ bfdirstate.forget(bfutil.unixpath(bfile))
+ bfdirstate.write()
+
+ return orig(text=text, user=user, date=date, match=match,
+ force=force, editor=editor, extra=extra)
+
+ for file in match.files():
+ if bfutil.is_standin(file):
+ raise util.Abort("Don't commit bfile standin. Commit bfile.")
+
+ # Case 2: user calls commit with specified patterns: refresh any
+ # matching big files.
+ smatcher = bfutil.compose_standin_matcher(self, match)
+ standins = bfutil.dirstate_walk(self.dirstate, smatcher)
+
+ # No matching big files: get out of the way and pass control to
+ # the usual commit() method.
+ if not standins:
+ return orig(text=text, user=user, date=date, match=match,
+ force=force, editor=editor, extra=extra)
+
+ # Refresh all matching big files. It's possible that the commit
+ # will end up failing, in which case the big files will stay
+ # refreshed. No harm done: the user modified them and asked to
+ # commit them, so sooner or later we're going to refresh the
+ # standins. Might as well leave them refreshed.
+ bfdirstate = bfutil.open_bfdirstate(ui, self)
+ for standin in standins:
+ bfile = bfutil.split_standin(standin)
+ if bfdirstate[bfile] is not 'r':
+ bfutil.update_standin(self, standin)
+ bfdirstate.normal(bfutil.unixpath(bfile))
+ else:
+ bfdirstate.forget(bfutil.unixpath(bfile))
+ bfdirstate.write()
+
+ # Cook up a new matcher that only matches regular files or
+ # standins corresponding to the big files requested by the user.
+ # Have to modify _files to prevent commit() from complaining
+ # "not tracked" for big files.
+ bfiles = bfutil.list_bfiles(repo)
+ match = copy.copy(match)
+ orig_matchfn = match.matchfn
+
+ # Check both the list of bfiles and the list of standins because if a bfile was removed, it
+ # won't be in the list of bfiles at this point
+ match._files += sorted(standins)
+
+ actualfiles = []
+ for f in match._files:
+ fstandin = bfutil.standin(f)
+
+ # Ignore known bfiles and standins
+ if f in bfiles or fstandin in standins:
+ continue
+
+ # Append directory separator to avoid collisions
+ if not fstandin.endswith('/'):
+ fstandin += '/'
+
+ # Prevalidate matching standin directories
+ if any(st for st in match._files if st.startswith(fstandin)):
+ continue
+ actualfiles.append(f)
+ match._files = actualfiles
+
+ def matchfn(f):
+ if orig_matchfn(f):
+ return f not in bfiles
+ else:
+ return f in standins
+
+ match.matchfn = matchfn
+ return orig(text=text, user=user, date=date, match=match,
+ force=force, editor=editor, extra=extra)
+ finally:
+ wlock.release()
+
+ def push(self, remote, force=False, revs=None, newbranch=False):
+ o = bfutil.findoutgoing(repo, remote, force)
+ if o:
+ toupload = set()
+ o = repo.changelog.nodesbetween(o, revs)[0]
+ for n in o:
+ parents = [p for p in repo.changelog.parents(n) if p != node.nullid]
+ ctx = repo[n]
+ files = set(ctx.files())
+ if len(parents) == 2:
+ mc = ctx.manifest()
+ mp1 = ctx.parents()[0].manifest()
+ mp2 = ctx.parents()[1].manifest()
+ for f in mp1:
+ if f not in mc:
+ files.add(f)
+ for f in mp2:
+ if f not in mc:
+ files.add(f)
+ for f in mc:
+ if mc[f] != mp1.get(f, None) or mc[f] != mp2.get(f, None):
+ files.add(f)
+
+ toupload = toupload.union(set([ctx[f].data().strip() for f in files if bfutil.is_standin(f) and f in ctx]))
+ bfcommands.upload_bfiles(ui, self, remote, toupload)
+ # Mercurial >= 1.6 takes the newbranch argument, try that first.
+ try:
+ return super(bfiles_repo, self).push(remote, force, revs, newbranch)
+ except TypeError:
+ return super(bfiles_repo, self).push(remote, force, revs)
+
+ repo.__class__ = bfiles_repo
+
+# Add works by going through the files that the user wanted to add
+# and checking if they should be added as bfiles. Then making a new
+# matcher which matches only the normal files and running the original
+# version of add.
+def override_add(orig, ui, repo, *pats, **opts):
+ bf = opts.pop('bf', None)
+
+ bfsize = opts.pop('bfsize', None)
+ if bfsize:
+ try:
+ bfsize = int(bfsize)
+ except ValueError:
+ raise util.Abort(_('size must be an integer, was %s\n') % bfsize)
+ else:
+ if os.path.exists(repo.wjoin(bfutil.short_name)):
+ bfsize = ui.config(bfutil.long_name, 'size', default='10')
+ if bfsize:
+ try:
+ bfsize = int(bfsize)
+ except ValueError:
+ raise util.Abort(_('bfiles.size must be integer, was %s\n') % bfsize)
+
+ bfmatcher = None
+ if os.path.exists(repo.wjoin(bfutil.short_name)):
+ bfpats = ui.config(bfutil.long_name, 'patterns', default=())
+ if bfpats:
+ bfpats = bfpats.split(' ')
+ bfmatcher = match_.match(repo.root, '', list(bfpats))
+
+ bfnames = []
+ m = cmdutil.match(repo, pats, opts)
+ m.bad = lambda x,y: None
+ wctx = repo[None]
+ for f in repo.walk(m):
+ exact = m.exact(f)
+ bfile = bfutil.standin(f) in wctx
+ nfile = f in wctx
+
+ if exact and bfile:
+ ui.warn(_('%s already a bfile\n') % f)
+ continue
+ # Don't warn the user when they attempt to add a normal tracked file. The normal add code
+ # will do that for us.
+ if exact and nfile:
+ continue
+ if exact or (not bfile and not nfile):
+ if bf or (bfsize and os.path.getsize(repo.wjoin(f)) >= bfsize*1024*1024) \
+ or (bfmatcher and bfmatcher(f)):
+ bfnames.append(f)
+ if ui.verbose or not exact:
+ ui.status(_('adding %s as bfile\n') % m.rel(f))
+
+ bad = []
+ standins = []
+
+ # Need to lock otherwise there could be a race condition inbetween when standins are created
+ # and added to the repo
+ wlock = repo.wlock()
+ try:
+ if not opts.get('dry_run'):
+ bfdirstate = bfutil.open_bfdirstate(ui, repo)
+ for f in bfnames:
+ standinname = bfutil.standin(f)
+ bfutil.write_standin(repo, standinname, hash='', executable=bfutil.get_executable(repo.wjoin(f)))
+ standins.append(standinname)
+ if bfdirstate[bfutil.unixpath(f)] == 'r':
+ bfdirstate.normallookup(bfutil.unixpath(f))
+ else:
+ bfdirstate.add(bfutil.unixpath(f))
+ bfdirstate.write()
+ bad += [bfutil.split_standin(f) for f in bfutil.repo_add(repo, standins) if f in m.files()]
+ finally:
+ wlock.release()
+
+ oldmatch = cmdutil.match
+ manifest = repo[None].manifest()
+ def override_match(repo, pats=[], opts={}, globbed=False, default='relpath'):
+ match = oldmatch(repo, pats, opts, globbed, default)
+ m = copy.copy(match)
+ notbfile = lambda f: not bfutil.is_standin(f) and bfutil.standin(f) not in manifest
+ m._files = [f for f in m._files if notbfile(f)]
+ m._fmap = set(m._files)
+ orig_matchfn = m.matchfn
+ m.matchfn = lambda f: notbfile(f) and orig_matchfn(f) or None
+ return m
+ cmdutil.match = override_match
+ result = orig(ui, repo, *pats, **opts)
+ cmdutil.match = oldmatch
+
+ return (result is 1 or bad) and 1 or 0
+
+def override_remove(orig, ui, repo, *pats, **opts):
+ wctx = repo[None].manifest()
+ oldmatch = cmdutil.match
+ def override_match(repo, pats=[], opts={}, globbed=False, default='relpath'):
+ match = oldmatch(repo, pats, opts, globbed, default)
+ m = copy.copy(match)
+ notbfile = lambda f: not bfutil.is_standin(f) and bfutil.standin(f) not in wctx
+ m._files = [f for f in m._files if notbfile(f)]
+ m._fmap = set(m._files)
+ orig_matchfn = m.matchfn
+ m.matchfn = lambda f: orig_matchfn(f) and notbfile(f)
+ return m
+ cmdutil.match = override_match
+ orig(ui, repo, *pats, **opts)
+ cmdutil.match = oldmatch
+
+ after, force = opts.get('after'), opts.get('force')
+ if not pats and not after:
+ raise util.Abort(_('no files specified'))
+ m = cmdutil.match(repo, pats, opts)
+ try:
+ repo.bfstatus = True
+ s = repo.status(match=m, clean=True)
+ finally:
+ repo.bfstatus = False
+ modified, added, deleted, clean = [[f for f in list if bfutil.standin(f) in wctx] for list in [s[0], s[1], s[3], s[6]]]
+
+ def warn(files, reason):
+ for f in files:
+ ui.warn(_('not removing %s: file %s (use -f to force removal)\n')
+ % (m.rel(f), reason))
+
+ if force:
+ remove, forget = modified + deleted + clean, added
+ elif after:
+ remove, forget = deleted, []
+ warn(modified + added + clean, _('still exists'))
+ else:
+ remove, forget = deleted + clean, []
+ warn(modified, _('is modified'))
+ warn(added, _('has been marked for add'))
+
+ for f in sorted(remove + forget):
+ if ui.verbose or not m.exact(f):
+ ui.status(_('removing %s\n') % m.rel(f))
+
+ # Need to lock because standin files are deleted then removed from the repository
+ # and we could race inbetween.
+ wlock = repo.wlock()
+ try:
+ bfdirstate = bfutil.open_bfdirstate(ui, repo)
+ for f in remove:
+ if not after:
+ os.unlink(repo.wjoin(f))
+ currentdir = os.path.split(f)[0]
+ while currentdir and not os.listdir(repo.wjoin(currentdir)):
+ os.rmdir(repo.wjoin(currentdir))
+ currentdir = os.path.split(currentdir)[0]
+ bfdirstate.remove(bfutil.unixpath(f))
+ bfdirstate.write()
+
+ forget = [bfutil.standin(f) for f in forget]
+ remove = [bfutil.standin(f) for f in remove]
+ bfutil.repo_forget(repo, forget)
+ bfutil.repo_remove(repo, remove, unlink=True)
+ finally:
+ wlock.release()
+
+def override_status(orig, ui, repo, *pats, **opts):
+ try:
+ repo.bfstatus = True
+ return orig(ui, repo, *pats, **opts)
+ finally:
+ repo.bfstatus = False
+
+def override_verify(orig, ui, repo, *pats, **opts):
+ bf = opts.pop('bf', False)
+ all = opts.pop('bfa', False)
+ contents = opts.pop('bfc', False)
+
+ result = orig(ui, repo, *pats, **opts)
+ if bf:
+ result = result or bfcommands.verify_bfiles(ui, repo, all, contents)
+ return result
+
+# Override needs to refresh standins so that update's normal merge
+# will go through properly. Then the other update hook (overriding repo.update)
+# will get the new files. Filemerge is also overriden so that the merge
+# will merge standins correctly.
+def override_update(orig, ui, repo, *pats, **opts):
+ bfdirstate = bfutil.open_bfdirstate(ui, repo)
+ s = bfdirstate.status(match_.always(repo.root, repo.getcwd()), [], False, False, False)
+ (unsure, modified, added, removed, missing, unknown, ignored, clean) = s
+
+ # Need to lock between the standins getting updated and their bfiles getting updated
+ wlock = repo.wlock()
+ try:
+ if opts['check']:
+ mod = len(modified) > 0
+ for bfile in unsure:
+ standin = bfutil.standin(bfile)
+ if repo['.'][standin].data().strip() != bfutil.hashfile(repo.wjoin(bfile)):
+ mod = True
+ else:
+ bfdirstate.normal(bfutil.unixpath(bfile))
+ bfdirstate.write()
+ if mod:
+ raise util.Abort(_('uncommitted local changes'))
+ # XXX handle removed differently
+ if not opts['clean']:
+ for bfile in unsure + modified + added:
+ bfutil.update_standin(repo, bfutil.standin(bfile))
+ finally:
+ wlock.release()
+ return orig(ui, repo, *pats, **opts)
+
+# Override filemerge to prompt the user about how they wish to merge bfiles.
+# This will handle identical edits, and copy/rename + edit without prompting the user.
+def override_filemerge(origfn, repo, mynode, orig, fcd, fco, fca):
+ # Use better variable names here. Because this is a wrapper we cannot change
+ # the variable names in the function declaration.
+ fcdest, fcother, fcancestor = fcd, fco, fca
+ if not bfutil.is_standin(orig):
+ return origfn(repo, mynode, orig, fcdest, fcother, fcancestor)
+ else:
+ if not fcother.cmp(fcdest): # files identical?
+ return None
+
+ if fcancestor == fcother: # backwards, use working dir parent as ancestor
+ fcancestor = fcdest.parents()[0]
+
+ if orig != fcother.path():
+ repo.ui.status(_('merging %s and %s to %s\n')
+ % (bfutil.split_standin(orig), bfutil.split_standin(fcother.path()), bfutil.split_standin(fcdest.path())))
+ else:
+ repo.ui.status(_('merging %s\n') % bfutil.split_standin(fcdest.path()))
+
+ if fcancestor.path() != fcother.path() and fcother.data() == fcancestor.data():
+ return 0
+ if fcancestor.path() != fcdest.path() and fcdest.data() == fcancestor.data():
+ repo.wwrite(fcdest.path(), fcother.data(), fcother.flags())
+ return 0
+
+ if repo.ui.promptchoice(_('bfile %s has a merge conflict\n'
+ 'keep (l)ocal or take (o)ther?') % bfutil.split_standin(orig),
+ (_('&Local'), _('&Other')), 0) == 0:
+ return 0
+ else:
+ repo.wwrite(fcdest.path(), fcother.data(), fcother.flags())
+ return 0
+
+# Copy first changes the matchers to match standins instead of bfiles.
+# Then it overrides util.copyfile in that function it checks if the destination
+# bfile already exists. It also keeps a list of copied files so that the bfiles
+# can be copied and the dirstate updated.
+def override_copy(orig, ui, repo, pats, opts, rename=False):
+ # doesn't remove bfile on rename
+ if len(pats) < 2:
+ # this isn't legal, let the original function deal with it
+ return orig(ui, repo, pats, opts, rename)
+
+ def makestandin(relpath):
+ return os.path.join(os.path.relpath('.', repo.getcwd()), bfutil.standin(util.canonpath(repo.root, repo.getcwd(), relpath)))
+
+ fullpats = cmdutil.expandpats(pats)
+ dest = fullpats[-1]
+
+ if os.path.isdir(dest):
+ if not os.path.isdir(makestandin(dest)):
+ os.makedirs(makestandin(dest))
+ # This could copy both bfiles and normal files in one command, but we don't want
+ # to do that first replace their matcher to only match normal files and run it
+ # then replace it to just match bfiles and run it again
+ nonormalfiles = False
+ nobfiles = False
+ oldmatch = cmdutil.match
+ try:
+ manifest = repo[None].manifest()
+ def override_match(repo, pats=[], opts={}, globbed=False, default='relpath'):
+ match = oldmatch(repo, pats, opts, globbed, default)
+ m = copy.copy(match)
+ notbfile = lambda f: not bfutil.is_standin(f) and bfutil.standin(f) not in manifest
+ m._files = [f for f in m._files if notbfile(f)]
+ m._fmap = set(m._files)
+ orig_matchfn = m.matchfn
+ m.matchfn = lambda f: notbfile(f) and orig_matchfn(f) or None
+ return m
+ cmdutil.match = override_match
+ result = orig(ui, repo, pats, opts, rename)
+ except util.Abort as e:
+ if str(e) != 'no files to copy':
+ raise e
+ else:
+ nonormalfiles = True
+ result = 0
+ finally:
+ cmdutil.match = oldmatch
+
+ # The first rename can cause our current working directory to be removed. In that case
+ # there is nothing left to copy/rename so just quit.
+ try:
+ repo.getcwd()
+ except OSError:
+ return result
+
+ try:
+ # When we call orig below it creates the standins but we don't add them to the dir state
+ # until later so lock during that time.
+ wlock = repo.wlock()
+
+ manifest = repo[None].manifest()
+ def override_match(repo, pats=[], opts={}, globbed=False, default='relpath'):
+ newpats = []
+ # The patterns were previously mangled to add .hgbfiles, we need to remove that now
+ for pat in pats:
+ if match_.patkind(pat) == None and bfutil.short_name in pat:
+ newpats.append(pat.replace( bfutil.short_name, ''))
+ else:
+ newpats.append(pat)
+ match = oldmatch(repo, newpats, opts, globbed, default)
+ m = copy.copy(match)
+ bfile = lambda f: bfutil.standin(f) in manifest
+ m._files = [bfutil.standin(f) for f in m._files if bfile(f)]
+ m._fmap = set(m._files)
+ orig_matchfn = m.matchfn
+ m.matchfn = lambda f: bfutil.is_standin(f) and bfile(bfutil.split_standin(f)) and orig_matchfn(bfutil.split_standin(f)) or None
+ return m
+ cmdutil.match = override_match
+ listpats = []
+ for pat in pats:
+ if match_.patkind(pat) != None:
+ listpats.append(pat)
+ else:
+ listpats.append(makestandin(pat))
+
+ try:
+ origcopyfile = util.copyfile
+ copiedfiles = []
+ def override_copyfile(src, dest):
+ if bfutil.short_name in src and bfutil.short_name in dest:
+ destbfile = dest.replace(bfutil.short_name, '')
+ if not opts['force'] and os.path.exists(destbfile):
+ raise IOError('', _('destination bfile already exists'))
+ copiedfiles.append((src, dest))
+ origcopyfile(src, dest)
+
+ util.copyfile = override_copyfile
+ result += orig(ui, repo, listpats, opts, rename)
+ finally:
+ util.copyfile = origcopyfile
+
+ bfdirstate = bfutil.open_bfdirstate(ui, repo)
+ for (src, dest) in copiedfiles:
+ if bfutil.short_name in src and bfutil.short_name in dest:
+ srcbfile = src.replace(bfutil.short_name, '')
+ destbfile = dest.replace(bfutil.short_name, '')
+ destbfiledir = os.path.dirname(destbfile) or '.'
+ if not os.path.isdir(destbfiledir):
+ os.makedirs(destbfiledir)
+ if rename:
+ os.rename(srcbfile, destbfile)
+ bfdirstate.remove(bfutil.unixpath(os.path.relpath(srcbfile, repo.root)))
+ else:
+ util.copyfile(srcbfile, destbfile)
+ bfdirstate.add(bfutil.unixpath(os.path.relpath(destbfile, repo.root)))
+ bfdirstate.write()
+ except util.Abort as e:
+ if str(e) != 'no files to copy':
+ raise e
+ else:
+ nobfiles = True
+ finally:
+ cmdutil.match = oldmatch
+ wlock.release()
+
+ if nobfiles and nonormalfiles:
+ raise util.Abort(_('no files to copy'))
+
+ return result
+
+# Standins are only updated (to match the hash of bfiles) before commits.
+# Update the standins then run the original revert (changing the matcher to hit standins
+# instead of bfiles). Based on the resulting standins update the bfiles. Then return the
+# standins to their proper state
+def override_revert(orig, ui, repo, *pats, **opts):
+ # Because we put the standins in a bad state (by updating them) and then return them
+ # to a correct state we need to lock to prevent others from changing them in their
+ # incorrect state.
+ wlock = repo.wlock()
+ try:
+ bfdirstate = bfutil.open_bfdirstate(ui, repo)
+ (modified, added, removed, missing, unknown, ignored, clean) = bfutil.bfdirstate_status(bfdirstate, repo, repo['.'].rev())
+ for bfile in modified:
+ bfutil.update_standin(repo, bfutil.standin(bfile))
+
+ oldmatch = cmdutil.match
+ try:
+ ctx = repo[opts.get('rev')]
+ def override_match(repo, pats=[], opts={}, globbed=False, default='relpath'):
+ match = oldmatch(repo, pats, opts, globbed, default)
+ m = copy.copy(match)
+ def tostandin(f):
+ if bfutil.standin(f) in repo[None] or bfutil.standin(f) in ctx:
+ return bfutil.standin(f)
+ return f
+ m._files = [tostandin(f) for f in m._files]
+ m._fmap = set(m._files)
+ orig_matchfn = m.matchfn
+ def matchfn(f):
+ if bfutil.is_standin(f):
+ return orig_matchfn(bfutil.split_standin(f)) and (f in repo[None] or f in ctx)
+ return orig_matchfn(f)
+ m.matchfn = matchfn
+ return m
+ cmdutil.match = override_match
+ orig(ui, repo, *pats, **opts)
+ finally:
+ cmdutil.match = oldmatch
+ bfcommands.revert_bfiles(ui, repo)
+ for bfile in modified:
+ if os.path.exists(repo.wjoin(bfutil.standin(bfile))) and bfile in repo['.']:
+ bfutil.write_standin(repo, bfutil.standin(bfile), repo['.'][bfile].data().strip(), 'x' in repo['.'][bfile].flags())
+ finally:
+ wlock.release()
+
+def hg_update(orig, repo, node):
+ result = orig(repo, node)
+ # XXX check if it worked first
+ bfcommands.update_bfiles(repo.ui, repo)
+ return result
+
+def hg_clean(orig, repo, node, show_stats=True):
+ result = orig(repo, node, show_stats)
+ bfcommands.update_bfiles(repo.ui, repo)
+ return result
+
+def hg_merge(orig, repo, node, force=None, remind=True):
+ result = orig(repo, node, force, remind)
+ bfcommands.update_bfiles(repo.ui, repo)
+ return result
+
+# When we rebase a repository with remotely changed bfiles, we need
+# to explicitly do a clean update so that the entries in .kbf are
+# udpated and the new bfiles are pulled
+def override_pull(orig, ui, repo, source="default", **opts):
+ result = orig(ui, repo, source, **opts)
+ if opts.get('rebase', False):
+ commands.update(repo.ui, repo, clean = True)
+ return result
+
+def override_archive(orig, repo, dest, node, kind, decode=True, matchfn=None,
+ prefix=None, mtime=None, subrepos=None):
+ # No need to lock because we are only reading history and bfile caches
+ # neither of which are modified
+
+ if kind not in archival.archivers:
+ raise util.Abort(_("unknown archive type '%s'") % kind)
+
+ ctx = repo[node]
+
+ # In Mercurial <= 1.5 the prefix is passed to the archiver so try that
+ # if that doesn't work we are probably in Mercurial >= 1.6 where the
+ # prefix is not handled by the archiver
+ try:
+ archiver = archival.archivers[kind](dest, prefix, mtime or ctx.date()[0])
+
+ def write(name, mode, islink, getdata):
+ if matchfn and not matchfn(name):
+ return
+ data = getdata()
+ if decode:
+ data = repo.wwritedata(name, data)
+ archiver.addfile(name, mode, islink, data)
+ except TypeError:
+ if kind == 'files':
+ if prefix:
+ raise util.Abort(_('cannot give prefix when archiving to files'))
+ else:
+ prefix = archival.tidyprefix(dest, kind, prefix)
+
+ def write(name, mode, islink, getdata):
+ if matchfn and not matchfn(name):
+ return
+ data = getdata()
+ if decode:
+ data = repo.wwritedata(name, data)
+ archiver.addfile(prefix + name, mode, islink, data)
+
+ archiver = archival.archivers[kind](dest, mtime or ctx.date()[0])
+
+ if repo.ui.configbool("ui", "archivemeta", True):
+ def metadata():
+ base = 'repo: %s\nnode: %s\nbranch: %s\n' % (
+ hex(repo.changelog.node(0)), hex(node), ctx.branch())
+
+ tags = ''.join('tag: %s\n' % t for t in ctx.tags()
+ if repo.tagtype(t) == 'global')
+ if not tags:
+ repo.ui.pushbuffer()
+ opts = {'template': '{latesttag}\n{latesttagdistance}',
+ 'style': '', 'patch': None, 'git': None}
+ cmdutil.show_changeset(repo.ui, repo, opts).show(ctx)
+ ltags, dist = repo.ui.popbuffer().split('\n')
+ tags = ''.join('latesttag: %s\n' % t for t in ltags.split(':'))
+ tags += 'latesttagdistance: %s\n' % dist
+
+ return base + tags
+
+ write('.hg_archival.txt', 0644, False, metadata)
+
+ for f in ctx:
+ ff = ctx.flags(f)
+ getdata = ctx[f].data
+ if bfutil.is_standin(f):
+ path = bfutil.find_file(repo, getdata().strip())
+ ### TODO: What if the file is not cached?
+ f = bfutil.split_standin(f)
+
+ def getdatafn():
+ with open(path, 'rb') as fd:
+ return fd.read()
+
+ getdata = getdatafn
+ write(f, 'x' in ff and 0755 or 0644, 'l' in ff, getdata)
+ archiver.done()
+
+# If a bfile is modified the change is not reflected in its standin until a commit.
+# cmdutil.bail_if_changed raises an exception if the repo has uncommitted changes.
+# Wrap it to also check if bfiles were changed. This is used by bisect and backout.
+def override_bail_if_changed(orig, repo):
+ orig(repo)
+ repo.bfstatus = True
+ modified, added, removed, deleted = repo.status()[:4]
+ repo.bfstatus = False
+ if modified or added or removed or deleted:
+ raise util.Abort(_('outstanding uncommitted changes'))
+
+# Fetch doesn't use cmdutil.bail_if_changed so override it to add the check
+def override_fetch(orig, ui, repo, *pats, **opts):
+ repo.bfstatus = True
+ modified, added, removed, deleted = repo.status()[:4]
+ repo.bfstatus = False
+ if modified or added or removed or deleted:
+ raise util.Abort(_('outstanding uncommitted changes'))
+ return orig(ui, repo, *pats, **opts)
+
+def override_forget(orig, ui, repo, *pats, **opts):
+ wctx = repo[None].manifest()
+ oldmatch = cmdutil.match
+ def override_match(repo, pats=[], opts={}, globbed=False, default='relpath'):
+ match = oldmatch(repo, pats, opts, globbed, default)
+ m = copy.copy(match)
+ notbfile = lambda f: not bfutil.is_standin(f) and bfutil.standin(f) not in wctx
+ m._files = [f for f in m._files if notbfile(f)]
+ m._fmap = set(m._files)
+ orig_matchfn = m.matchfn
+ m.matchfn = lambda f: orig_matchfn(f) and notbfile(f)
+ return m
+ cmdutil.match = override_match
+ orig(ui, repo, *pats, **opts)
+ cmdutil.match = oldmatch
+
+ m = cmdutil.match(repo, pats, opts)
+ try:
+ repo.bfstatus = True
+ s = repo.status(match=m, clean=True)
+ finally:
+ repo.bfstatus = False
+ forget = sorted(s[0] + s[1] + s[3] + s[6])
+ forget = [f for f in forget if bfutil.standin(f) in wctx]
+
+ for f in forget:
+ if bfutil.standin(f) not in repo.dirstate and not os.path.isdir(m.rel(bfutil.standin(f))):
+ ui.warn(_('not removing %s: file is already untracked\n')
+ % m.rel(f))
+
+ for f in forget:
+ if ui.verbose or not m.exact(f):
+ ui.status(_('removing %s\n') % m.rel(f))
+
+ # Need to lock because standin files are deleted then removed from the repository
+ # and we could race inbetween.
+ wlock = repo.wlock()
+ try:
+ bfdirstate = bfutil.open_bfdirstate(ui, repo)
+ for f in forget:
+ bfdirstate.remove(bfutil.unixpath(f))
+ bfdirstate.write()
+ bfutil.repo_remove(repo, [bfutil.standin(f) for f in forget], unlink=True)
+ finally:
+ wlock.release()
+
+def get_outgoing_bfiles(ui, repo, dest=None, **opts):
+ dest = ui.expandpath(dest or 'default-push', dest or 'default')
+ dest, branches = hg.parseurl(dest, opts.get('branch'))
+ revs, checkout = hg.addbranchrevs(repo, repo, branches, opts.get('rev'))
+ if revs:
+ revs = [repo.lookup(rev) for rev in revs]
+
+ # Mercurial <= 1.5 had remoteui in cmdutil, then it moved to hg
+ try:
+ remoteui = cmdutil.remoteui
+ except AttributeError:
+ remoteui = hg.remoteui
+
+ try:
+ remote = hg.repository(remoteui(repo, opts), dest)
+ except error.RepoError:
+ return None
+ o = bfutil.findoutgoing(repo, remote, False)
+ if not o:
+ return None
+ o = repo.changelog.nodesbetween(o, revs)[0]
+ if opts.get('newest_first'):
+ o.reverse()
+
+ toupload = set()
+ for n in o:
+ parents = [p for p in repo.changelog.parents(n) if p != node.nullid]
+ ctx = repo[n]
+ files = set(ctx.files())
+ if len(parents) == 2:
+ mc = ctx.manifest()
+ mp1 = ctx.parents()[0].manifest()
+ mp2 = ctx.parents()[1].manifest()
+ for f in mp1:
+ if f not in mc:
+ files.add(f)
+ for f in mp2:
+ if f not in mc:
+ files.add(f)
+ for f in mc:
+ if mc[f] != mp1.get(f, None) or mc[f] != mp2.get(f, None):
+ files.add(f)
+ toupload = toupload.union(set([f for f in files if bfutil.is_standin(f) and f in ctx]))
+ return toupload
+
+def override_outgoing(orig, ui, repo, dest=None, **opts):
+ orig(ui, repo, dest, **opts)
+
+ if opts.pop('bf', None):
+ toupload = get_outgoing_bfiles(ui, repo, dest, **opts)
+ if toupload is None:
+ ui.status(_('kbfiles: No remote repo\n'))
+ else:
+ ui.status(_('kbfiles to upload:\n'))
+ for file in toupload:
+ ui.status(bfutil.split_standin(file) + '\n')
+ ui.status('\n')
+
+def override_summary(orig, ui, repo, *pats, **opts):
+ orig(ui, repo, *pats, **opts)
+
+ if opts.pop('bf', None):
+ toupload = get_outgoing_bfiles(ui, repo, None, **opts)
+ if toupload is None:
+ ui.status(_('kbfiles: No remote repo\n'))
+ else:
+ ui.status(_('kbfiles: %d to upload\n') % len(toupload))
+
+def override_addremove(orig, ui, repo, *pats, **opts):
+ # Check if the parent or child has bfiles if they do don't allow it.
+ # If there is a symlink in the manifest then getting the manifest throws an exception
+ # catch it and let addremove deal with it. This happens in Mercurial's test
+ # test-addremove-symlink
+ try:
+ manifesttip = set(repo['tip'].manifest())
+ except util.Abort:
+ manifesttip = set()
+ try:
+ manifestworking = set(repo[None].manifest())
+ except util.Abort:
+ manifestworking = set()
+
+ # Manifests are only iterable so turn them into sets then union
+ for file in manifesttip.union(manifestworking):
+ if file.startswith(bfutil.short_name):
+ raise util.Abort(_('addremove cannot be run on a repo with bfiles'))
+
+ return orig(ui, repo, *pats, **opts)
+
+def uisetup(ui):
+ # Disable auto-status for some commands which assume that all
+ # files in the result are under Mercurial's control
+
+ entry = extensions.wrapcommand(commands.table, 'add', override_add)
+ addopt = [('', 'bf', None, _('add as bfile')),
+ ('', 'bfsize', '', _('add all files above this size (in megabytes) as bfiles (default: 10)'))]
+ entry[1].extend(addopt)
+
+ entry = extensions.wrapcommand(commands.table, 'addremove', override_addremove)
+ entry = extensions.wrapcommand(commands.table, 'remove', override_remove)
+ entry = extensions.wrapcommand(commands.table, 'forget', override_forget)
+ entry = extensions.wrapcommand(commands.table, 'status', override_status)
+
+ entry = extensions.wrapcommand(commands.table, 'verify', override_verify)
+ verifyopt = [('', 'bf', None, _('verify bfiles')),
+ ('', 'bfa', None, _('verify all revisions of bfiles not just current')),
+ ('', 'bfc', None, _('verify bfile contents not just existence'))]
+ entry[1].extend(verifyopt)
+
+ entry = extensions.wrapcommand(commands.table, 'outgoing', override_outgoing)
+ outgoingopt = [('', 'bf', None, _('display outgoing bfiles'))]
+ entry[1].extend(outgoingopt)
+ entry = extensions.wrapcommand(commands.table, 'summary', override_summary)
+ summaryopt = [('', 'bf', None, _('display outgoing bfiles'))]
+ entry[1].extend(summaryopt)
+
+ entry = extensions.wrapcommand(commands.table, 'update', override_update)
+ entry = extensions.wrapcommand(commands.table, 'pull', override_pull)
+ entry = extensions.wrapfunction(filemerge, 'filemerge', override_filemerge)
+ entry = extensions.wrapfunction(cmdutil, 'copy', override_copy)
+
+ # Backout calls revert so we need to override both the command and the function
+ entry = extensions.wrapcommand(commands.table, 'revert', override_revert)
+ entry = extensions.wrapfunction(commands, 'revert', override_revert)
+
+ # clone uses hg._update instead of hg.update even though they are the
+ # same function... so wrap both of them)
+ extensions.wrapfunction(hg, 'update', hg_update)
+ extensions.wrapfunction(hg, '_update', hg_update)
+ extensions.wrapfunction(hg, 'clean', hg_clean)
+ extensions.wrapfunction(hg, 'merge', hg_merge)
+
+ extensions.wrapfunction(archival, 'archive', override_archive)
+ extensions.wrapfunction(cmdutil, 'bail_if_changed', override_bail_if_changed)
+
+ for name, module in extensions.extensions():
+ if name == 'fetch':
+ extensions.wrapcommand(getattr(module, 'cmdtable'), 'fetch', override_fetch)
+
+
|
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
|
@@ -0,0 +1,59 @@ + '''Store class for local filesystem.'''
+
+import os
+
+from mercurial import util
+from mercurial.i18n import _
+import bfutil, basestore
+
+class localstore(basestore.basestore):
+ '''Because there is a system wide cache, the local store always uses that cache.
+ Since the cache is updated elsewhere, we can just read from it here as if it were the store.'''
+
+ def __init__(self, ui, repo, url):
+ url = os.path.join(url, '.hg', bfutil.long_name)
+ super(localstore, self).__init__(ui, repo, util.expandpath(url))
+
+ def put(self, source, filename, hash):
+ '''Any file that is put must already be in the system wide cache so do nothing.'''
+ return
+
+ def exists(self, hash):
+ return bfutil.in_system_cache(self.repo.ui, hash)
+
+ def _getfile(self, tmpfile, filename, hash):
+ if bfutil.in_system_cache(self.ui, hash):
+ return bfutil.system_cache_path(self.ui, hash)
+ raise basestore.StoreError(filename, hash, '', _("Can't get file locally"))
+
+ def _verifyfile(self, cctx, cset, contents, standin, verified):
+ filename = bfutil.split_standin(standin)
+ if not filename:
+ return False
+ fctx = cctx[standin]
+ key = (filename, fctx.filenode())
+ if key in verified:
+ return False
+
+ expect_hash = fctx.data()[0:40]
+ verified.add(key)
+ if not bfutil.in_system_cache(self.ui, expect_hash):
+ self.ui.warn(
+ _('changeset %s: %s missing\n'
+ ' (%s: %s)\n')
+ % (cset, filename, expect_hash, err.strerror))
+ return True # failed
+
+ if contents:
+ store_path = bfutil.system_cache_path(self.ui, expect_hash)
+ actual_hash = bfutil.hashfile(store_path)
+ if actual_hash != expect_hash:
+ self.ui.warn(
+ _('changeset %s: %s: contents differ\n'
+ ' (%s:\n'
+ ' expected hash %s,\n'
+ ' but got %s)\n')
+ % (cset, filename,
+ store_path, expect_hash, actual_hash))
+ return True # failed
+ return False
|
|
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
|
@@ -0,0 +1,13 @@ + % test with bfiles
+hg init
+hg add --bf foo
+hg addremove
+hg commit -m 'added foo'
+hg addremove
+
+% test without bfiles
+hg init
+hg add foo
+hg addremove
+hg commit -m 'added foo'
+hg addremove
|
|
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
|
|
|
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
|
This file's diff was not loaded because this changeset is very large. Load changes Loading... |
||
Add a tag
Loading...