mercurial: comparison hgext/remotefilelog/shallowrepo.py

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 if not os.path.exists(localpath):
 os.makedirs(localpath)
 # Instantiate local data stores
 localcontent = contentstore.remotefilelogcontentstore(
-repo, localpath, repo.name, shared=False)
+repo, localpath, repo.name, shared=False
+)
 localmetadata = metadatastore.remotefilelogmetadatastore(
-repo, localpath, repo.name, shared=False)
+repo, localpath, repo.name, shared=False
+)
 return localcontent, localmetadata
 def makecachestores(repo):
 """Typically machine-wide, cache of remote data; can be discarded."""
 # Instantiate shared cache stores
 cachepath = shallowutil.getcachepath(repo.ui)
 cachecontent = contentstore.remotefilelogcontentstore(
-repo, cachepath, repo.name, shared=True)
+repo, cachepath, repo.name, shared=True
+)
 cachemetadata = metadatastore.remotefilelogmetadatastore(
-repo, cachepath, repo.name, shared=True)
+repo, cachepath, repo.name, shared=True
+)
 repo.sharedstore = cachecontent
 repo.shareddatastores.append(cachecontent)
 repo.sharedhistorystores.append(cachemetadata)
 return cachecontent, cachemetadata
 def makeremotestores(repo, cachecontent, cachemetadata):
 """These stores fetch data from a remote server."""
 # Instantiate remote stores
 repo.fileservice = fileserverclient.fileserverclient(repo)
 remotecontent = contentstore.remotecontentstore(
-repo.ui, repo.fileservice, cachecontent)
+repo.ui, repo.fileservice, cachecontent
+)
 remotemetadata = metadatastore.remotemetadatastore(
-repo.ui, repo.fileservice, cachemetadata)
+repo.ui, repo.fileservice, cachemetadata
+)
 return remotecontent, remotemetadata
 def makepackstores(repo):
 """Packs are more efficient (to read from) cache stores."""
 # Instantiate pack stores
-packpath = shallowutil.getcachepackpath(repo,
+packpath = shallowutil.getcachepackpath(repo, constants.FILEPACK_CATEGORY)
-constants.FILEPACK_CATEGORY)
 packcontentstore = datapack.datapackstore(repo.ui, packpath)
 packmetadatastore = historypack.historypackstore(repo.ui, packpath)
 repo.shareddatastores.append(packcontentstore)
 repo.sharedhistorystores.append(packmetadatastore)
-shallowutil.reportpackmetrics(repo.ui, 'filestore', packcontentstore,
+shallowutil.reportpackmetrics(
-packmetadatastore)
+repo.ui, 'filestore', packcontentstore, packmetadatastore
+)
 return packcontentstore, packmetadatastore
 def makeunionstores(repo):
 """Union stores iterate the other stores and return the first result."""
 repo.shareddatastores = []
 repo.sharedhistorystores = []
 packcontentstore, packmetadatastore = makepackstores(repo)
 cachecontent, cachemetadata = makecachestores(repo)
 localcontent, localmetadata = makelocalstores(repo)
-remotecontent, remotemetadata = makeremotestores(repo, cachecontent,
+remotecontent, remotemetadata = makeremotestores(
-cachemetadata)
+repo, cachecontent, cachemetadata
+)
 # Instantiate union stores
 repo.contentstore = contentstore.unioncontentstore(
-packcontentstore, cachecontent,
+packcontentstore,
-localcontent, remotecontent, writestore=localcontent)
+cachecontent,
+localcontent,
+remotecontent,
+writestore=localcontent,
+)
 repo.metadatastore = metadatastore.unionmetadatastore(
-packmetadatastore, cachemetadata, localmetadata, remotemetadata,
+packmetadatastore,
-writestore=localmetadata)
+cachemetadata,
+localmetadata,
+remotemetadata,
+writestore=localmetadata,
+)
 fileservicedatawrite = cachecontent
 fileservicehistorywrite = cachemetadata
-repo.fileservice.setstore(repo.contentstore, repo.metadatastore,
+repo.fileservice.setstore(
-fileservicedatawrite, fileservicehistorywrite)
+repo.contentstore,
-shallowutil.reportpackmetrics(repo.ui, 'filestore',
+repo.metadatastore,
-packcontentstore, packmetadatastore)
+fileservicedatawrite,
+fileservicehistorywrite,
+)
+shallowutil.reportpackmetrics(
+repo.ui, 'filestore', packcontentstore, packmetadatastore
+)
 def wraprepo(repo):
 class shallowrepository(repo.__class__):
 @util.propertycache
 def name(self):
 return self.ui.config('remotefilelog', 'reponame')
 @util.propertycache
 def fallbackpath(self):
-path = repo.ui.config("remotefilelog", "fallbackpath",
+path = repo.ui.config(
-repo.ui.config('paths', 'default'))
+"remotefilelog",
+"fallbackpath",
+repo.ui.config('paths', 'default'),
+)
 if not path:
-raise error.Abort("no remotefilelog server "
+raise error.Abort(
-"configured - is your .hg/hgrc trusted?")
+"no remotefilelog server "
+"configured - is your .hg/hgrc trusted?"
+)
 return path
 def maybesparsematch(self, *revs, **kwargs):
 '''
 def filectx(self, path, *args, **kwargs):
 if self.shallowmatch(path):
 return remotefilectx.remotefilectx(self, path, *args, **kwargs)
 else:
-return super(shallowrepository, self).filectx(path, *args,
+return super(shallowrepository, self).filectx(
-**kwargs)
+path, *args, **kwargs
+)
 @localrepo.unfilteredmethod
 def commitctx(self, ctx, error=False, origctx=None):
 """Add a new revision to current repository.
 Revision information is passed via the context argument.
 for f in ctx.modified() + ctx.added():
 fparent1 = m1.get(f, nullid)
 if fparent1 != nullid:
 files.append((f, hex(fparent1)))
 self.fileservice.prefetch(files)
-return super(shallowrepository, self).commitctx(ctx,
+return super(shallowrepository, self).commitctx(
-error=error,
+ctx, error=error, origctx=origctx
-origctx=origctx)
+)
-def backgroundprefetch(self, revs, base=None, repack=False, pats=None,
+def backgroundprefetch(
-opts=None, ensurestart=False):
+self,
+revs,
+base=None,
+repack=False,
+pats=None,
+opts=None,
+ensurestart=False,
+):
 """Runs prefetch in background with optional repack
 """
 cmd = [procutil.hgexecutable(), '-R', repo.origroot, 'prefetch']
 if repack:
 cmd.append('--repack')
 if revs:
 cmd += ['-r', revs]
 # We know this command will find a binary, so don't block
 # on it starting.
-procutil.runbgcommand(cmd, encoding.environ,
+procutil.runbgcommand(
-ensurestart=ensurestart)
+cmd, encoding.environ, ensurestart=ensurestart
+)
 def prefetch(self, revs, base=None, pats=None, opts=None):
 """Prefetches all the necessary file revisions for the given revs
 Optionally runs repack in background
 """
-with repo._lock(repo.svfs, 'prefetchlock', True, None, None,
+with repo._lock(
-_('prefetching in %s') % repo.origroot):
+repo.svfs,
+'prefetchlock',
+True,
+None,
+None,
+_('prefetching in %s') % repo.origroot,
+):
 self._prefetch(revs, base, pats, opts)
 def _prefetch(self, revs, base=None, pats=None, opts=None):
 fallbackpath = self.fallbackpath
 if fallbackpath:
 # If we know a rev is on the server, we should fetch the server
 # version of those files, since our local file versions might
 # become obsolete if the local commits are stripped.
 localrevs = repo.revs('outgoing(%s)', fallbackpath)
 if base is not None and base != nullrev:
-serverbase = list(repo.revs('first(reverse(::%s) - %ld)',
+serverbase = list(
-base, localrevs))
+repo.revs('first(reverse(::%s) - %ld)', base, localrevs)
+)
 if serverbase:
 base = serverbase[0]
 else:
 localrevs = repo
 repo.shallowmatch = match.always()
 makeunionstores(repo)
-repo.includepattern = repo.ui.configlist("remotefilelog", "includepattern",
+repo.includepattern = repo.ui.configlist(
-None)
+"remotefilelog", "includepattern", None
-repo.excludepattern = repo.ui.configlist("remotefilelog", "excludepattern",
+)
-None)
+repo.excludepattern = repo.ui.configlist(
+"remotefilelog", "excludepattern", None
+)
 if not util.safehasattr(repo, 'connectionpool'):
 repo.connectionpool = connectionpool.connectionpool(repo)
 if repo.includepattern or repo.excludepattern:
-repo.shallowmatch = match.match(repo.root, '', None,
+repo.shallowmatch = match.match(
-repo.includepattern, repo.excludepattern)
+repo.root, '', None, repo.includepattern, repo.excludepattern
+)

changeset 43076	2372284d9457
parent 42842	2c74337e6483
child 43077	687b865b95ad