posix: always seek to EOF when opening a file in append mode
Python 3 already does this, so skip it there.
Consider the program:
#include <stdio.h>
int main() {
FILE *f = fopen("narf", "w");
fprintf(f, "narf\n");
fclose(f);
f = fopen("narf", "a");
printf("%ld\n", ftell(f));
fprintf(f, "troz\n");
printf("%ld\n", ftell(f));
return 0;
}
on macOS, FreeBSD, and Linux with glibc, this program prints
5
10
but on musl libc (Alpine Linux and probably others) this prints
0
10
By my reading of
https://pubs.opengroup.org/onlinepubs/
009695399/functions/fopen.html
this is technically correct, specifically:
> Opening a file with append mode (a as the first character in the
> mode argument) shall cause all subsequent writes to the file to be
> forced to the then current end-of-file, regardless of intervening
> calls to fseek().
in other words, the file position doesn't really matter in append-mode
files, and we can't depend on it being at all meaningful unless we
perform a seek() before tell() after open(..., 'a'). Experimentally
after a .write() we can do a .tell() and it'll always be reasonable,
but I'm unclear from reading the specification if that's a smart thing
to rely on. This matches what we do on Windows and what Python 3 does
for free, so let's just be consistent. Thanks to Yuya for the idea.
# wireprotosimplecache.py - Extension providing in-memory wire protocol cache
#
# Copyright 2018 Gregory Szorc <gregory.szorc@gmail.com>
#
# 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
from mercurial import (
extensions,
registrar,
repository,
util,
wireprotoserver,
wireprototypes,
wireprotov2server,
)
from mercurial.utils import (
interfaceutil,
stringutil,
)
CACHE = None
configtable = {}
configitem = registrar.configitem(configtable)
configitem(b'simplecache', b'cacheapi',
default=False)
configitem(b'simplecache', b'cacheobjects',
default=False)
configitem(b'simplecache', b'redirectsfile',
default=None)
# API handler that makes cached keys available.
def handlecacherequest(rctx, req, res, checkperm, urlparts):
if rctx.repo.ui.configbool(b'simplecache', b'cacheobjects'):
res.status = b'500 Internal Server Error'
res.setbodybytes(b'cacheobjects not supported for api server')
return
if not urlparts:
res.status = b'200 OK'
res.headers[b'Content-Type'] = b'text/plain'
res.setbodybytes(b'simple cache server')
return
key = b'/'.join(urlparts)
if key not in CACHE:
res.status = b'404 Not Found'
res.headers[b'Content-Type'] = b'text/plain'
res.setbodybytes(b'key not found in cache')
return
res.status = b'200 OK'
res.headers[b'Content-Type'] = b'application/mercurial-cbor'
res.setbodybytes(CACHE[key])
def cachedescriptor(req, repo):
return {}
wireprotoserver.API_HANDLERS[b'simplecache'] = {
b'config': (b'simplecache', b'cacheapi'),
b'handler': handlecacherequest,
b'apidescriptor': cachedescriptor,
}
@interfaceutil.implementer(repository.iwireprotocolcommandcacher)
class memorycacher(object):
def __init__(self, ui, command, encodefn, redirecttargets, redirecthashes,
req):
self.ui = ui
self.encodefn = encodefn
self.redirecttargets = redirecttargets
self.redirecthashes = redirecthashes
self.req = req
self.key = None
self.cacheobjects = ui.configbool(b'simplecache', b'cacheobjects')
self.cacheapi = ui.configbool(b'simplecache', b'cacheapi')
self.buffered = []
ui.log(b'simplecache', b'cacher constructed for %s\n', command)
def __enter__(self):
return self
def __exit__(self, exctype, excvalue, exctb):
if exctype:
self.ui.log(b'simplecache', b'cacher exiting due to error\n')
def adjustcachekeystate(self, state):
# Needed in order to make tests deterministic. Don't copy this
# pattern for production caches!
del state[b'repo']
def setcachekey(self, key):
self.key = key
return True
def lookup(self):
if self.key not in CACHE:
self.ui.log(b'simplecache', b'cache miss for %s\n', self.key)
return None
entry = CACHE[self.key]
self.ui.log(b'simplecache', b'cache hit for %s\n', self.key)
redirectable = True
if not self.cacheapi:
redirectable = False
elif not self.redirecttargets:
redirectable = False
else:
clienttargets = set(self.redirecttargets)
ourtargets = set(t[b'name'] for t in loadredirecttargets(self.ui))
# We only ever redirect to a single target (for now). So we don't
# need to store which target matched.
if not clienttargets & ourtargets:
redirectable = False
if redirectable:
paths = self.req.dispatchparts[:-3]
paths.append(b'simplecache')
paths.append(self.key)
url = b'%s/%s' % (self.req.baseurl, b'/'.join(paths))
#url = b'http://example.com/%s' % self.key
self.ui.log(b'simplecache', b'sending content redirect for %s to '
b'%s\n', self.key, url)
response = wireprototypes.alternatelocationresponse(
url=url,
mediatype=b'application/mercurial-cbor')
return {b'objs': [response]}
if self.cacheobjects:
return {
b'objs': entry,
}
else:
return {
b'objs': [wireprototypes.encodedresponse(entry)],
}
def onobject(self, obj):
if self.cacheobjects:
self.buffered.append(obj)
else:
self.buffered.extend(self.encodefn(obj))
yield obj
def onfinished(self):
self.ui.log(b'simplecache', b'storing cache entry for %s\n', self.key)
if self.cacheobjects:
CACHE[self.key] = self.buffered
else:
CACHE[self.key] = b''.join(self.buffered)
return []
def makeresponsecacher(orig, repo, proto, command, args, objencoderfn,
redirecttargets, redirecthashes):
return memorycacher(repo.ui, command, objencoderfn, redirecttargets,
redirecthashes, proto._req)
def loadredirecttargets(ui):
path = ui.config(b'simplecache', b'redirectsfile')
if not path:
return []
with open(path, 'rb') as fh:
s = fh.read()
return stringutil.evalpythonliteral(s)
def getadvertisedredirecttargets(orig, repo, proto):
return loadredirecttargets(repo.ui)
def extsetup(ui):
global CACHE
CACHE = util.lrucachedict(10000)
extensions.wrapfunction(wireprotov2server, b'makeresponsecacher',
makeresponsecacher)
extensions.wrapfunction(wireprotov2server, b'getadvertisedredirecttargets',
getadvertisedredirecttargets)