This is an archive of the discontinued Mercurial Phabricator instance.

Differential D1539

remotefilelog: make sure metacache is always initalized
ClosedPublic

Authored by wlis on Nov 28 2017, 8:17 PM.
Tags
None
Subscribers
quark

Details

Reviewers
quark
Group Reviewers
Restricted Project
Commits
rFBHGXc5cf0dda2c9f: remotefilelog: make sure metacache is always initalized
Summary

This adds initialization of metacache in remaining place where it can be uninitalized when using threads
The previous state did fail on some hg update operations on Windows. It didn't
affect posix as that doesn't actually use threads so we always have metacache
initalized from the constructor

Test Plan

Run hg update that failed wihtout this change on windows and see it
suceed.
run tests on CentOS

Diff Detail

Repository
rFBHGX Facebook Mercurial Extensions
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

wlis created this revision.Nov 28 2017, 8:17 PM
Herald added a reviewer: Restricted Project. · View Herald TranscriptNov 28 2017, 8:17 PM
quark accepted this revision.Nov 28 2017, 8:26 PM
quark added a subscriber: quark.
quark added inline comments.
remotefilelog/contentstore.py
144–145

Maybe this line could be removed then for consistency.

This revision is now accepted and ready to land.Nov 28 2017, 8:26 PM
wlis updated this revision to Diff 3954.Nov 28 2017, 8:41 PM
Closed by commit rFBHGXc5cf0dda2c9f: remotefilelog: make sure metacache is always initalized (authored by wlis). · Explain WhyNov 29 2017, 10:08 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mremotefilelog/contentstore.py (9 lines)

Diff 3995

remotefilelog/contentstore.py

def markforrefresh(self): def markforrefresh(self):
for store in self.stores: for store in self.stores:
if util.safehasattr(store, 'markforrefresh'): if util.safehasattr(store, 'markforrefresh'):
store.markforrefresh() store.markforrefresh()
class remotefilelogcontentstore(basestore.basestore): class remotefilelogcontentstore(basestore.basestore):
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
super(remotefilelogcontentstore, self).__init__(*args, **kwargs) super(remotefilelogcontentstore, self).__init__(*args, **kwargs)
self._threaddata = threading.local() self._threaddata = threading.local()
self._threaddata.metacache = (None, None) # (node, meta)
quarkUnsubmitted
Not Done

Maybe this line could be removed then for consistency.

quark: Maybe this line could be removed then for consistency.
def get(self, name, node): def get(self, name, node):
# return raw revision text # return raw revision text
data = self._getdata(name, node) data = self._getdata(name, node)
offset, size, flags = shallowutil.parsesizeflags(data) offset, size, flags = shallowutil.parsesizeflags(data)
content = data[offset:offset + size] content = data[offset:offset + size]
ancestormap = shallowutil.ancestormap(data) ancestormap = shallowutil.ancestormap(data)
# Since remotefilelog content stores just contain full texts, we return # Since remotefilelog content stores just contain full texts, we return
# a fake delta chain that just consists of a single full text revision. # a fake delta chain that just consists of a single full text revision.
# The nullid in the deltabasenode slot indicates that the revision is a # The nullid in the deltabasenode slot indicates that the revision is a
# fulltext. # fulltext.
revision = self.get(name, node) revision = self.get(name, node)
return [(name, node, None, nullid, revision)] return [(name, node, None, nullid, revision)]
def getmeta(self, name, node): def getmeta(self, name, node):
self._sanitizemetacache()
if node != self._threaddata.metacache[0]: if node != self._threaddata.metacache[0]:
data = self._getdata(name, node) data = self._getdata(name, node)
offset, size, flags = shallowutil.parsesizeflags(data) offset, size, flags = shallowutil.parsesizeflags(data)
self._updatemetacache(node, size, flags) self._updatemetacache(node, size, flags)
return self._threaddata.metacache[1] return self._threaddata.metacache[1]
def add(self, name, node, data): def add(self, name, node, data):
raise RuntimeError("cannot add content only to remotefilelog " raise RuntimeError("cannot add content only to remotefilelog "
"contentstore") "contentstore")
def _updatemetacache(self, node, size, flags): def _sanitizemetacache(self):
metacache = getattr(self._threaddata, 'metacache', None) metacache = getattr(self._threaddata, 'metacache', None)
if metacache is None: if metacache is None:
self._threaddata.metacache = (None, None) self._threaddata.metacache = (None, None) # (node, meta)
def _updatemetacache(self, node, size, flags):
self._sanitizemetacache()
if node == self._threaddata.metacache[0]: if node == self._threaddata.metacache[0]:
return return
meta = {constants.METAKEYFLAG: flags, meta = {constants.METAKEYFLAG: flags,
constants.METAKEYSIZE: size} constants.METAKEYSIZE: size}
self._threaddata.metacache = (node, meta) self._threaddata.metacache = (node, meta)
class remotecontentstore(object): class remotecontentstore(object):
def __init__(self, ui, fileservice, shared): def __init__(self, ui, fileservice, shared):