mirror of
https://github.com/facebook/sapling.git
synced 2024-10-09 00:14:35 +03:00
afb08fe68c
When path is too long to be an Unix socket address, we create a socket in a temporary directory and link from the long path to the shorter one. But checks in server code at startup were insufficient in this case, and used to raise an unclear "tried linking .hg/inotify.sock to a temporary socket but .hg/inotify.sock already exists"
493 lines
15 KiB
Python
493 lines
15 KiB
Python
# server.py - common entry point for inotify status server
|
|
#
|
|
# Copyright 2009 Nicolas Dumazet <nicdumz@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 mercurial.i18n import _
|
|
from mercurial import cmdutil, osutil, util
|
|
import common
|
|
|
|
import errno
|
|
import os
|
|
import socket
|
|
import stat
|
|
import struct
|
|
import sys
|
|
import tempfile
|
|
|
|
class AlreadyStartedException(Exception):
|
|
pass
|
|
class TimeoutException(Exception):
|
|
pass
|
|
|
|
def join(a, b):
|
|
if a:
|
|
if a[-1] == '/':
|
|
return a + b
|
|
return a + '/' + b
|
|
return b
|
|
|
|
def split(path):
|
|
c = path.rfind('/')
|
|
if c == -1:
|
|
return '', path
|
|
return path[:c], path[c + 1:]
|
|
|
|
walk_ignored_errors = (errno.ENOENT, errno.ENAMETOOLONG)
|
|
|
|
def walk(dirstate, absroot, root):
|
|
'''Like os.walk, but only yields regular files.'''
|
|
|
|
# This function is critical to performance during startup.
|
|
|
|
def walkit(root, reporoot):
|
|
files, dirs = [], []
|
|
|
|
try:
|
|
fullpath = join(absroot, root)
|
|
for name, kind in osutil.listdir(fullpath):
|
|
if kind == stat.S_IFDIR:
|
|
if name == '.hg':
|
|
if not reporoot:
|
|
return
|
|
else:
|
|
dirs.append(name)
|
|
path = join(root, name)
|
|
if dirstate._ignore(path):
|
|
continue
|
|
for result in walkit(path, False):
|
|
yield result
|
|
elif kind in (stat.S_IFREG, stat.S_IFLNK):
|
|
files.append(name)
|
|
yield fullpath, dirs, files
|
|
|
|
except OSError, err:
|
|
if err.errno == errno.ENOTDIR:
|
|
# fullpath was a directory, but has since been replaced
|
|
# by a file.
|
|
yield fullpath, dirs, files
|
|
elif err.errno not in walk_ignored_errors:
|
|
raise
|
|
|
|
return walkit(root, root == '')
|
|
|
|
class directory(object):
|
|
"""
|
|
Representing a directory
|
|
|
|
* path is the relative path from repo root to this directory
|
|
* files is a dict listing the files in this directory
|
|
- keys are file names
|
|
- values are file status
|
|
* dirs is a dict listing the subdirectories
|
|
- key are subdirectories names
|
|
- values are directory objects
|
|
"""
|
|
def __init__(self, relpath=''):
|
|
self.path = relpath
|
|
self.files = {}
|
|
self.dirs = {}
|
|
|
|
def dir(self, relpath):
|
|
"""
|
|
Returns the directory contained at the relative path relpath.
|
|
Creates the intermediate directories if necessary.
|
|
"""
|
|
if not relpath:
|
|
return self
|
|
l = relpath.split('/')
|
|
ret = self
|
|
while l:
|
|
next = l.pop(0)
|
|
try:
|
|
ret = ret.dirs[next]
|
|
except KeyError:
|
|
d = directory(join(ret.path, next))
|
|
ret.dirs[next] = d
|
|
ret = d
|
|
return ret
|
|
|
|
def walk(self, states, visited=None):
|
|
"""
|
|
yield (filename, status) pairs for items in the trees
|
|
that have status in states.
|
|
filenames are relative to the repo root
|
|
"""
|
|
for file, st in self.files.iteritems():
|
|
if st in states:
|
|
yield join(self.path, file), st
|
|
for dir in self.dirs.itervalues():
|
|
if visited is not None:
|
|
visited.add(dir.path)
|
|
for e in dir.walk(states):
|
|
yield e
|
|
|
|
def lookup(self, states, path, visited):
|
|
"""
|
|
yield root-relative filenames that match path, and whose
|
|
status are in states:
|
|
* if path is a file, yield path
|
|
* if path is a directory, yield directory files
|
|
* if path is not tracked, yield nothing
|
|
"""
|
|
if path[-1] == '/':
|
|
path = path[:-1]
|
|
|
|
paths = path.split('/')
|
|
|
|
# we need to check separately for last node
|
|
last = paths.pop()
|
|
|
|
tree = self
|
|
try:
|
|
for dir in paths:
|
|
tree = tree.dirs[dir]
|
|
except KeyError:
|
|
# path is not tracked
|
|
visited.add(tree.path)
|
|
return
|
|
|
|
try:
|
|
# if path is a directory, walk it
|
|
target = tree.dirs[last]
|
|
visited.add(target.path)
|
|
for file, st in target.walk(states, visited):
|
|
yield file
|
|
except KeyError:
|
|
try:
|
|
if tree.files[last] in states:
|
|
# path is a file
|
|
visited.add(tree.path)
|
|
yield path
|
|
except KeyError:
|
|
# path is not tracked
|
|
pass
|
|
|
|
class repowatcher(object):
|
|
"""
|
|
Watches inotify events
|
|
"""
|
|
statuskeys = 'almr!?'
|
|
|
|
def __init__(self, ui, dirstate, root):
|
|
self.ui = ui
|
|
self.dirstate = dirstate
|
|
|
|
self.wprefix = join(root, '')
|
|
self.prefixlen = len(self.wprefix)
|
|
|
|
self.tree = directory()
|
|
self.statcache = {}
|
|
self.statustrees = dict([(s, directory()) for s in self.statuskeys])
|
|
|
|
self.ds_info = self.dirstate_info()
|
|
|
|
self.last_event = None
|
|
|
|
|
|
def handle_timeout(self):
|
|
pass
|
|
|
|
def dirstate_info(self):
|
|
try:
|
|
st = os.lstat(self.wprefix + '.hg/dirstate')
|
|
return st.st_mtime, st.st_ino
|
|
except OSError, err:
|
|
if err.errno != errno.ENOENT:
|
|
raise
|
|
return 0, 0
|
|
|
|
def filestatus(self, fn, st):
|
|
try:
|
|
type_, mode, size, time = self.dirstate._map[fn][:4]
|
|
except KeyError:
|
|
type_ = '?'
|
|
if type_ == 'n':
|
|
st_mode, st_size, st_mtime = st
|
|
if size == -1:
|
|
return 'l'
|
|
if size and (size != st_size or (mode ^ st_mode) & 0100):
|
|
return 'm'
|
|
if time != int(st_mtime):
|
|
return 'l'
|
|
return 'n'
|
|
if type_ == '?' and self.dirstate._dirignore(fn):
|
|
# we must check not only if the file is ignored, but if any part
|
|
# of its path match an ignore pattern
|
|
return 'i'
|
|
return type_
|
|
|
|
def updatefile(self, wfn, osstat):
|
|
'''
|
|
update the file entry of an existing file.
|
|
|
|
osstat: (mode, size, time) tuple, as returned by os.lstat(wfn)
|
|
'''
|
|
|
|
self._updatestatus(wfn, self.filestatus(wfn, osstat))
|
|
|
|
def deletefile(self, wfn, oldstatus):
|
|
'''
|
|
update the entry of a file which has been deleted.
|
|
|
|
oldstatus: char in statuskeys, status of the file before deletion
|
|
'''
|
|
if oldstatus == 'r':
|
|
newstatus = 'r'
|
|
elif oldstatus in 'almn':
|
|
newstatus = '!'
|
|
else:
|
|
newstatus = None
|
|
|
|
self.statcache.pop(wfn, None)
|
|
self._updatestatus(wfn, newstatus)
|
|
|
|
def _updatestatus(self, wfn, newstatus):
|
|
'''
|
|
Update the stored status of a file.
|
|
|
|
newstatus: - char in (statuskeys + 'ni'), new status to apply.
|
|
- or None, to stop tracking wfn
|
|
'''
|
|
root, fn = split(wfn)
|
|
d = self.tree.dir(root)
|
|
|
|
oldstatus = d.files.get(fn)
|
|
# oldstatus can be either:
|
|
# - None : fn is new
|
|
# - a char in statuskeys: fn is a (tracked) file
|
|
|
|
if self.ui.debugflag and oldstatus != newstatus:
|
|
self.ui.note(_('status: %r %s -> %s\n') %
|
|
(wfn, oldstatus, newstatus))
|
|
|
|
if oldstatus and oldstatus in self.statuskeys \
|
|
and oldstatus != newstatus:
|
|
del self.statustrees[oldstatus].dir(root).files[fn]
|
|
|
|
if newstatus in (None, 'i'):
|
|
d.files.pop(fn, None)
|
|
elif oldstatus != newstatus:
|
|
d.files[fn] = newstatus
|
|
if newstatus != 'n':
|
|
self.statustrees[newstatus].dir(root).files[fn] = newstatus
|
|
|
|
def check_deleted(self, key):
|
|
# Files that had been deleted but were present in the dirstate
|
|
# may have vanished from the dirstate; we must clean them up.
|
|
nuke = []
|
|
for wfn, ignore in self.statustrees[key].walk(key):
|
|
if wfn not in self.dirstate:
|
|
nuke.append(wfn)
|
|
for wfn in nuke:
|
|
root, fn = split(wfn)
|
|
del self.statustrees[key].dir(root).files[fn]
|
|
del self.tree.dir(root).files[fn]
|
|
|
|
def update_hgignore(self):
|
|
# An update of the ignore file can potentially change the
|
|
# states of all unknown and ignored files.
|
|
|
|
# XXX If the user has other ignore files outside the repo, or
|
|
# changes their list of ignore files at run time, we'll
|
|
# potentially never see changes to them. We could get the
|
|
# client to report to us what ignore data they're using.
|
|
# But it's easier to do nothing than to open that can of
|
|
# worms.
|
|
|
|
if '_ignore' in self.dirstate.__dict__:
|
|
delattr(self.dirstate, '_ignore')
|
|
self.ui.note(_('rescanning due to .hgignore change\n'))
|
|
self.handle_timeout()
|
|
self.scan()
|
|
|
|
def getstat(self, wpath):
|
|
try:
|
|
return self.statcache[wpath]
|
|
except KeyError:
|
|
try:
|
|
return self.stat(wpath)
|
|
except OSError, err:
|
|
if err.errno != errno.ENOENT:
|
|
raise
|
|
|
|
def stat(self, wpath):
|
|
try:
|
|
st = os.lstat(join(self.wprefix, wpath))
|
|
ret = st.st_mode, st.st_size, st.st_mtime
|
|
self.statcache[wpath] = ret
|
|
return ret
|
|
except OSError:
|
|
self.statcache.pop(wpath, None)
|
|
raise
|
|
|
|
class socketlistener(object):
|
|
"""
|
|
Listens for client queries on unix socket inotify.sock
|
|
"""
|
|
def __init__(self, ui, root, repowatcher, timeout):
|
|
self.ui = ui
|
|
self.repowatcher = repowatcher
|
|
self.sock = socket.socket(socket.AF_UNIX)
|
|
self.sockpath = join(root, '.hg/inotify.sock')
|
|
|
|
self.realsockpath = self.sockpath
|
|
if os.path.islink(self.sockpath):
|
|
if os.path.exists(self.sockpath):
|
|
self.realsockpath = os.readlink(self.sockpath)
|
|
else:
|
|
raise util.Abort('inotify-server: cannot start: '
|
|
'.hg/inotify.sock is a broken symlink')
|
|
try:
|
|
self.sock.bind(self.realsockpath)
|
|
except socket.error, err:
|
|
if err.args[0] == errno.EADDRINUSE:
|
|
raise AlreadyStartedException(_('cannot start: socket is '
|
|
'already bound'))
|
|
if err.args[0] == "AF_UNIX path too long":
|
|
tempdir = tempfile.mkdtemp(prefix="hg-inotify-")
|
|
self.realsockpath = os.path.join(tempdir, "inotify.sock")
|
|
try:
|
|
self.sock.bind(self.realsockpath)
|
|
os.symlink(self.realsockpath, self.sockpath)
|
|
except (OSError, socket.error), inst:
|
|
try:
|
|
os.unlink(self.realsockpath)
|
|
except:
|
|
pass
|
|
os.rmdir(tempdir)
|
|
if inst.errno == errno.EEXIST:
|
|
raise AlreadyStartedException(_('cannot start: tried '
|
|
'linking .hg/inotify.sock to a temporary socket but'
|
|
' .hg/inotify.sock already exists'))
|
|
raise
|
|
else:
|
|
raise
|
|
self.sock.listen(5)
|
|
self.fileno = self.sock.fileno
|
|
|
|
def answer_stat_query(self, cs):
|
|
names = cs.read().split('\0')
|
|
|
|
states = names.pop()
|
|
|
|
self.ui.note(_('answering query for %r\n') % states)
|
|
|
|
visited = set()
|
|
if not names:
|
|
def genresult(states, tree):
|
|
for fn, state in tree.walk(states):
|
|
yield fn
|
|
else:
|
|
def genresult(states, tree):
|
|
for fn in names:
|
|
for f in tree.lookup(states, fn, visited):
|
|
yield f
|
|
|
|
return ['\0'.join(r) for r in [
|
|
genresult('l', self.repowatcher.statustrees['l']),
|
|
genresult('m', self.repowatcher.statustrees['m']),
|
|
genresult('a', self.repowatcher.statustrees['a']),
|
|
genresult('r', self.repowatcher.statustrees['r']),
|
|
genresult('!', self.repowatcher.statustrees['!']),
|
|
'?' in states
|
|
and genresult('?', self.repowatcher.statustrees['?'])
|
|
or [],
|
|
[],
|
|
'c' in states and genresult('n', self.repowatcher.tree) or [],
|
|
visited
|
|
]]
|
|
|
|
def answer_dbug_query(self):
|
|
return ['\0'.join(self.repowatcher.debug())]
|
|
|
|
def accept_connection(self):
|
|
sock, addr = self.sock.accept()
|
|
|
|
cs = common.recvcs(sock)
|
|
version = ord(cs.read(1))
|
|
|
|
if version != common.version:
|
|
self.ui.warn(_('received query from incompatible client '
|
|
'version %d\n') % version)
|
|
try:
|
|
# try to send back our version to the client
|
|
# this way, the client too is informed of the mismatch
|
|
sock.sendall(chr(common.version))
|
|
except:
|
|
pass
|
|
return
|
|
|
|
type = cs.read(4)
|
|
|
|
if type == 'STAT':
|
|
results = self.answer_stat_query(cs)
|
|
elif type == 'DBUG':
|
|
results = self.answer_dbug_query()
|
|
else:
|
|
self.ui.warn(_('unrecognized query type: %s\n') % type)
|
|
return
|
|
|
|
try:
|
|
try:
|
|
v = chr(common.version)
|
|
|
|
sock.sendall(v + type + struct.pack(common.resphdrfmts[type],
|
|
*map(len, results)))
|
|
sock.sendall(''.join(results))
|
|
finally:
|
|
sock.shutdown(socket.SHUT_WR)
|
|
except socket.error, err:
|
|
if err.args[0] != errno.EPIPE:
|
|
raise
|
|
|
|
if sys.platform == 'linux2':
|
|
import linuxserver as _server
|
|
else:
|
|
raise ImportError
|
|
|
|
master = _server.master
|
|
|
|
def start(ui, dirstate, root, opts):
|
|
timeout = opts.get('idle_timeout')
|
|
if timeout:
|
|
timeout = float(timeout) * 60000
|
|
else:
|
|
timeout = None
|
|
|
|
class service(object):
|
|
def init(self):
|
|
try:
|
|
self.master = master(ui, dirstate, root, timeout)
|
|
except AlreadyStartedException, inst:
|
|
raise util.Abort("inotify-server: %s" % inst)
|
|
|
|
def run(self):
|
|
try:
|
|
try:
|
|
self.master.run()
|
|
except TimeoutException:
|
|
pass
|
|
finally:
|
|
self.master.shutdown()
|
|
|
|
if 'inserve' not in sys.argv:
|
|
runargs = util.hgcmd() + ['inserve', '-R', root]
|
|
else:
|
|
runargs = util.hgcmd() + sys.argv[1:]
|
|
|
|
pidfile = ui.config('inotify', 'pidfile')
|
|
if opts['daemon'] and pidfile is not None and 'pid-file' not in runargs:
|
|
runargs.append("--pid-file=%s" % pidfile)
|
|
|
|
service = service()
|
|
logfile = ui.config('inotify', 'log')
|
|
|
|
appendpid = ui.configbool('inotify', 'appendpid', False)
|
|
|
|
ui.debug('starting inotify server: %s\n' % ' '.join(runargs))
|
|
cmdutil.service(opts, initfn=service.init, runfn=service.run,
|
|
logfile=logfile, runargs=runargs, appendpid=appendpid)
|