1
=== modified file 'src/provisioningserver/utils/fs.py'
2
--- src/provisioningserver/utils/fs.py	2015-10-14 16:27:21 +0000
3
+++ src/provisioningserver/utils/fs.py	2017-02-08 18:01:00 +0000
4
@@ -52,10 +52,7 @@
5
52
import sys
52
import sys
6
53
import tempfile
53
import tempfile
7
54
import threading
54
import threading
12
55
from time import (
55
from time import sleep
9
56
    sleep,
10
57
    time,
11
58
)
13
59
56
14
60
from provisioningserver.utils import sudo
57
from provisioningserver.utils import sudo
15
61
from provisioningserver.utils.shell import ExternalProcessError
58
from provisioningserver.utils.shell import ExternalProcessError
16
@@ -207,69 +204,26 @@
17
207
        raise
204
        raise
18
208
205
19
209
206
20
210
def pick_new_mtime(old_mtime=None, starting_age=1000):
21
211
    """Choose a new modification time for a file that needs it updated.
22
212
23
213
    This function is used to manage the modification time of files
24
214
    for which we need to see an increment in the modification time
25
215
    each time the file is modified.  This is the case for DNS zone
26
216
    files which only get properly reloaded if BIND sees that the
27
217
    modification time is > to the time it has in its database.
28
218
29
219
    Modification time can have a resolution as low as one second in
30
220
    some relevant environments (we have observed this with ext3).
31
221
    To produce mtime changes regardless, we set a file's modification
32
222
    time in the past when it is first written, and
33
223
    increment it by 1 second on each subsequent write.
34
224
35
225
    However we also want to be careful not to set the modification time
36
226
    in the future, mostly because BIND does not deal with that very
37
227
    well.
38
228
39
229
    :param old_mtime: File's previous modification time, as a number
40
230
        with a unity of one second, or None if it did not previously
41
231
        exist.
42
232
    :param starting_age: If the file did not exist previously, set its
43
233
        modification time this many seconds in the past.
44
234
    """
45
235
    now = time()
46
236
    if old_mtime is None:
47
237
        # File is new.  Set modification time in the past to have room for
48
238
        # sub-second modifications.
49
239
        return now - starting_age
50
240
    elif old_mtime + 1 <= now:
51
241
        # There is room to increment the file's mtime by one second
52
242
        # without ending up in the future.
53
243
        return old_mtime + 1
54
244
    else:
55
245
        # We can't increase the file's modification time.  Give up and
56
246
        # return the previous modification time.
57
247
        return old_mtime
58
248
59
249
60
250
def incremental_write(content, filename, mode=0o600):
207
def incremental_write(content, filename, mode=0o600):
63
251
    """Write the given `content` into the file `filename` and
208
    """Write the given `content` into the file `filename`.  In the past, this
64
252
    increment the modification time by 1 sec.
209
    would potentially change modification time to arbitrary values.
65
253
210
66
254
    :param mode: Access permissions for the file.
211
    :param mode: Access permissions for the file.
67
255
    """
212
    """
69
256
    old_mtime = get_mtime(filename)
213
    # We used to change modification time on the files, in an attempt to out
70
214
    # smart BIND into loading zones on file systems where time was not granular
71
215
    # enough.  BIND got smarter about how it loads zones and remembers when it
72
216
    # last loaded the zone: either the then-current time, or the mtime of the
73
217
    # file, whichever is later.  When BIND then gets a reload request, it
74
218
    # compares the current time to the loadtime for the domain, and skips it if
75
219
    # the file is not new.  If we set mtime in the past, then zones don't load.
76
220
    # If we set it in the future, then we WILL sometimes hit the race condition
77
221
    # where BIND looks at the time after we atomic_write, but before we manage
78
222
    # to set the time into the future.  N.B.: /etc on filesystems with 1-second
79
223
    # granularity are no longer supported by MAAS.  The good news is that since
80
224
    # 2.6, linux has supported nanosecond-granular time.  As of bind9
81
225
    # 1:9.10.3.dfsg.P2-5, BIND even uses it.
82
257
    atomic_write(content, filename, mode=mode)
226
    atomic_write(content, filename, mode=mode)
83
258
    new_mtime = pick_new_mtime(old_mtime)
84
259
    os.utime(filename, (new_mtime, new_mtime))
85
260
86
261
87
262
def get_mtime(filename):
88
263
    """Return a file's modification time, or None if it does not exist."""
89
264
    try:
90
265
        return os.stat(filename).st_mtime
91
266
    except OSError as e:
92
267
        if e.errno == errno.ENOENT:
93
268
            # File does not exist.  Be helpful, return None.
94
269
            return None
95
270
        else:
96
271
            # Other failure.  The caller will want to know.
97
272
            raise
98
273
227
99
274
228
100
275
def sudo_write_file(filename, contents, encoding='utf-8', mode=0o644):
229
def sudo_write_file(filename, contents, encoding='utf-8', mode=0o644):
101
276
230
102
=== modified file 'src/provisioningserver/utils/tests/test_fs.py'
103
--- src/provisioningserver/utils/tests/test_fs.py	2015-10-14 18:00:50 +0000
104
+++ src/provisioningserver/utils/tests/test_fs.py	2017-02-08 18:01:00 +0000
105
@@ -17,7 +17,6 @@
106
17
from base64 import urlsafe_b64encode
17
from base64 import urlsafe_b64encode
107
18
import os
18
import os
108
19
import os.path
19
import os.path
109
20
from random import randint
110
21
import re
20
import re
111
22
from shutil import rmtree
21
from shutil import rmtree
112
23
import stat
22
import stat
113
@@ -31,7 +30,6 @@
114
31
30
115
32
from maastesting import root
31
from maastesting import root
116
33
from maastesting.factory import factory
32
from maastesting.factory import factory
117
34
from maastesting.fakemethod import FakeMethod
118
35
from maastesting.matchers import (
33
from maastesting.matchers import (
119
36
    MockCalledOnceWith,
34
    MockCalledOnceWith,
120
37
    MockCallsMatch,
35
    MockCallsMatch,
121
@@ -52,9 +50,7 @@
122
52
    ensure_dir,
50
    ensure_dir,
123
53
    FileLock,
51
    FileLock,
124
54
    get_maas_provision_command,
52
    get_maas_provision_command,
125
55
    get_mtime,
126
56
    incremental_write,
53
    incremental_write,
127
57
    pick_new_mtime,
128
58
    read_text_file,
54
    read_text_file,
129
59
    RunLock,
55
    RunLock,
130
60
    sudo_delete_file,
56
    sudo_delete_file,
131
@@ -264,8 +260,22 @@
132
264
        old_mtime = os.stat(filename).st_mtime - 10
260
        old_mtime = os.stat(filename).st_mtime - 10
133
265
        os.utime(filename, (old_mtime, old_mtime))
261
        os.utime(filename, (old_mtime, old_mtime))
134
266
        incremental_write(content, filename)
262
        incremental_write(content, filename)
137
267
        self.assertAlmostEqual(
263
        # should be much closer to new_time than to old_mtime.
138
268
            os.stat(filename).st_mtime, old_mtime + 1, delta=0.01)
264
        new_time = time.time()
139
265
        self.assertAlmostEqual(
140
266
            os.stat(filename).st_mtime, new_time, delta=2.0)
141
267
142
268
    def test_incremental_write_does_not_set_future_time(self):
143
269
        content = factory.make_bytes()
144
270
        filename = self.make_file(contents=factory.make_string())
145
271
        # Pretend that this file is older than it is.  So that
146
272
        # incrementing its mtime won't put it in the future.
147
273
        old_mtime = os.stat(filename).st_mtime + 10
148
274
        os.utime(filename, (old_mtime, old_mtime))
149
275
        incremental_write(content, filename)
150
276
        new_time = time.time()
151
277
        self.assertAlmostEqual(
152
278
            os.stat(filename).st_mtime, new_time, delta=2.0)
153
269
279
154
270
    def test_incremental_write_sets_permissions(self):
280
    def test_incremental_write_sets_permissions(self):
155
271
        atomic_file = self.make_file()
281
        atomic_file = self.make_file()
156
@@ -274,54 +284,6 @@
157
274
        self.assertEqual(mode, stat.S_IMODE(os.stat(atomic_file).st_mode))
284
        self.assertEqual(mode, stat.S_IMODE(os.stat(atomic_file).st_mode))
158
275
285
159
276
286
160
277
class TestGetMTime(MAASTestCase):
161
278
    """Test `get_mtime`."""
162
279
163
280
    def test_get_mtime_returns_None_for_nonexistent_file(self):
164
281
        nonexistent_file = os.path.join(
165
282
            self.make_dir(), factory.make_name('nonexistent-file'))
166
283
        self.assertIsNone(get_mtime(nonexistent_file))
167
284
168
285
    def test_get_mtime_returns_mtime(self):
169
286
        existing_file = self.make_file()
170
287
        mtime = os.stat(existing_file).st_mtime - randint(0, 100)
171
288
        os.utime(existing_file, (mtime, mtime))
172
289
        # Some small rounding/representation errors can happen here.
173
290
        # That's just the way of floating-point numbers.  According to
174
291
        # Gavin there's a conversion to fixed-point along the way, which
175
292
        # would raise representability issues.
176
293
        self.assertAlmostEqual(mtime, get_mtime(existing_file), delta=0.00001)
177
294
178
295
    def test_get_mtime_passes_on_other_error(self):
179
296
        forbidden_file = self.make_file()
180
297
        self.patch(os, 'stat', FakeMethod(failure=OSError("Forbidden file")))
181
298
        self.assertRaises(OSError, get_mtime, forbidden_file)
182
299
183
300
184
301
class TestPickNewMTime(MAASTestCase):
185
302
    """Test `pick_new_mtime`."""
186
303
187
304
    def test_pick_new_mtime_applies_starting_age_to_new_file(self):
188
305
        before = time.time()
189
306
        starting_age = randint(0, 5)
190
307
        recommended_age = pick_new_mtime(None, starting_age=starting_age)
191
308
        now = time.time()
192
309
        self.assertAlmostEqual(
193
310
            now - starting_age,
194
311
            recommended_age,
195
312
            delta=(now - before))
196
313
197
314
    def test_pick_new_mtime_increments_mtime_if_possible(self):
198
315
        past = time.time() - 2
199
316
        self.assertEqual(past + 1, pick_new_mtime(past))
200
317
201
318
    def test_pick_new_mtime_refuses_to_move_mtime_into_the_future(self):
202
319
        # Race condition: this will fail if the test gets held up for
203
320
        # a second between readings of the clock.
204
321
        now = time.time()
205
322
        self.assertEqual(now, pick_new_mtime(now))
206
323
207
324
208
325
class TestGetMAASProvisionCommand(MAASTestCase):
287
class TestGetMAASProvisionCommand(MAASTestCase):
209
326
288
210
327
    def test__returns_just_command_for_production(self):
289
    def test__returns_just_command_for_production(self):
Reviewer	Review Type	Date Requested	Status
Mike Pontillo (community)		2017-02-03	Approve on 2017-02-04
Review via email: mp+316384@code.launchpad.net