1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
# state.py - fsmonitor persistent state
#
# Copyright 2013-2016 Facebook, Inc.
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.
import errno
import os
import socket
import struct
from mercurial.i18n import _
from mercurial import (
encoding,
pathutil,
util,
)
_version = 4
_versionformat = b">I"
class state:
def __init__(self, repo):
self._vfs = repo.vfs
self._ui = repo.ui
self._rootdir = pathutil.normasprefix(repo.root)
self._lastclock = None
self._identity = util.filestat(None)
self.mode = self._ui.config(b'fsmonitor', b'mode')
self.walk_on_invalidate = self._ui.configbool(
b'fsmonitor', b'walk_on_invalidate'
)
self.timeout = float(self._ui.config(b'fsmonitor', b'timeout'))
def get(self):
try:
file = self._vfs(b'fsmonitor.state', b'rb')
except IOError as inst:
self._identity = util.filestat(None)
if inst.errno != errno.ENOENT:
raise
return None, None, None
self._identity = util.filestat.fromfp(file)
versionbytes = file.read(4)
if len(versionbytes) < 4:
self._ui.log(
b'fsmonitor',
b'fsmonitor: state file only has %d bytes, '
b'nuking state\n' % len(versionbytes),
)
self.invalidate()
return None, None, None
try:
diskversion = struct.unpack(_versionformat, versionbytes)[0]
if diskversion != _version:
# different version, nuke state and start over
self._ui.log(
b'fsmonitor',
b'fsmonitor: version switch from %d to '
b'%d, nuking state\n' % (diskversion, _version),
)
self.invalidate()
return None, None, None
state = file.read().split(b'\0')
# state = hostname\0clock\0ignorehash\0 + list of files, each
# followed by a \0
if len(state) < 3:
self._ui.log(
b'fsmonitor',
b'fsmonitor: state file truncated (expected '
b'3 chunks, found %d), nuking state\n',
len(state),
)
self.invalidate()
return None, None, None
diskhostname = state[0]
hostname = encoding.strtolocal(socket.gethostname())
if diskhostname != hostname:
# file got moved to a different host
self._ui.log(
b'fsmonitor',
b'fsmonitor: stored hostname "%s" '
b'different from current "%s", nuking state\n'
% (diskhostname, hostname),
)
self.invalidate()
return None, None, None
clock = state[1]
ignorehash = state[2]
# discard the value after the last \0
notefiles = state[3:-1]
finally:
file.close()
return clock, ignorehash, notefiles
def set(self, clock, ignorehash, notefiles):
if clock is None:
self.invalidate()
return
# Read the identity from the file on disk rather than from the open file
# pointer below, because the latter is actually a brand new file.
identity = util.filestat.frompath(self._vfs.join(b'fsmonitor.state'))
if identity != self._identity:
self._ui.debug(
b'skip updating fsmonitor.state: identity mismatch\n'
)
return
try:
file = self._vfs(
b'fsmonitor.state', b'wb', atomictemp=True, checkambig=True
)
except (IOError, OSError):
self._ui.warn(_(b"warning: unable to write out fsmonitor state\n"))
return
with file:
file.write(struct.pack(_versionformat, _version))
file.write(encoding.strtolocal(socket.gethostname()) + b'\0')
file.write(clock + b'\0')
file.write(ignorehash + b'\0')
if notefiles:
file.write(b'\0'.join(notefiles))
file.write(b'\0')
def invalidate(self):
try:
os.unlink(os.path.join(self._rootdir, b'.hg', b'fsmonitor.state'))
except FileNotFoundError:
pass
self._identity = util.filestat(None)
def setlastclock(self, clock):
self._lastclock = clock
def getlastclock(self):
return self._lastclock
|
