summaryrefslogtreecommitdiff
path: root/src/leap/bitmask/platform_init/locks.py
blob: 39b18648515287bf969963032d63e6614c6baee7 (plain)
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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
# -*- coding: utf-8 -*-
# locks.py
# Copyright (C) 2013 LEAP
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
"""
Utilities for handling multi-platform file locking mechanisms
"""
import logging
import errno
import os
import platform

from leap.common.events import signal as signal_event
from leap.common.events import events_pb2 as proto
from leap import platform_init

if platform_init.IS_UNIX:
    from fcntl import flock, LOCK_EX, LOCK_NB
else:  # WINDOWS
    import datetime
    import glob
    import shutil
    import time

    from tempfile import gettempdir

    from leap.util import get_modification_ts, update_modification_ts

logger = logging.getLogger(__name__)

if platform_init.IS_UNIX:

    class UnixLock(object):
        """
        Uses flock to get an exclusive lock over a file.
        See man 2 flock
        """

        def __init__(self, path):
            """
            iniializes t he UnixLock with the path of the
            desired lockfile
            """

            self._fd = None
            self.path = path

        def get_lock(self):
            """
            Tries to get a lock, and writes the running pid there if successful
            """
            gotit, pid = self._get_lock_and_pid()
            return gotit

        def get_pid(self):
            """
            Returns the pid of the locking process
            """
            gotit, pid = self._get_lock_and_pid()
            return pid

        def _get_lock(self):
            """
            Tries to get a lock, returning True if successful

            :rtype: bool
            """
            self._fd = os.open(self.path, os.O_CREAT | os.O_RDWR)

            try:
                flock(self._fd, LOCK_EX | LOCK_NB)
            except IOError as exc:
                # could not get the lock
                #import ipdb; ipdb.set_trace()

                if exc.args[0] in (errno.EDEADLK, errno.EAGAIN):
                    # errno 11 or 35
                    # Resource temporarily unavailable
                    return False
                else:
                    raise
            return True

        @property
        def locked_by_us(self):
            """
            Returns True if the pid in the pidfile
            is ours.

            :rtype: bool
            """
            gotit, pid = self._get_lock_and_pid()
            return pid == os.getpid()

        def _get_lock_and_pid(self):
            """
            Tries to get a lock over the file.
            Returns (locked, pid) tuple.

            :rtype: tuple
            """

            if self._get_lock():
                self._write_to_pidfile()
                return True, None

            return False, self._read_from_pidfile()

        def _read_from_pidfile(self):
            """
            Tries to read pid from the pidfile,
            returns False if no content found.
            """

            pidfile = os.read(
                self._fd, 16)
            if not pidfile:
                return False

            try:
                return int(pidfile.strip())
            except Exception as exc:
                exc.args += (pidfile, self.lock_file)
                raise

        def _write_to_pidfile(self):
            """
            Writes the pid of the running process
            to the pidfile
            """
            fd = self._fd
            os.ftruncate(fd, 0)
            os.write(fd, '%d\n' % os.getpid())
            os.fsync(fd)


if platform_init.IS_WIN:

    # Time to wait (in secs) before assuming a raise window signal has not been
    # ack-ed.

    RAISE_WINDOW_TIMEOUT = 2

    # How many steps to do while checking lockfile ts update.

    RAISE_WINDOW_WAIT_STEPS = 10

    def _release_lock(name):
        """
        Tries to remove a folder path.

        :param name: folder lock to remove
        :type name: str
        """
        try:
            shutil.rmtree(name)
            return True
        except WindowsError as exc:
            if exc.errno in (errno.EPIPE, errno.ENOENT,
                             errno.ESRCH, errno.EACCES):
                logger.warning(
                    'exception while trying to remove the lockfile dir')
                logger.warning('errno %s: %s' % (exc.errno, exc.args[1]))
                # path does not exist
                return False
            else:
                logger.debug('errno = %s' % (exc.errno,))
                # we did not foresee this error, better add it explicitely
                raise

    class WindowsLock(object):
        """
        Creates a lock based on the atomic nature of mkdir on Windows
        system calls.
        """
        LOCKBASE = os.path.join(gettempdir(), "leap-client-lock")

        def __init__(self):
            """
            Initializes the lock.
            Sets the lock name to basename plus the process pid.
            """
            self._fd = None
            pid = os.getpid()
            self.name = "%s-%s" % (self.LOCKBASE, pid)
            self.pid = pid

        def get_lock(self):
            """
            Tries to get a lock, and writes the running pid there if successful
            """
            gotit = self._get_lock()
            return gotit

        def _get_lock(self):
            """
            Tries to write to a file with the current pid as part of the name
            """
            try:
                self._fd = os.makedirs(self.name)
            except OSError as exc:
                # could not create the dir
                if exc.args[0] == 183:
                    logger.debug('cannot create dir')
                    # cannot create dir with existing name
                    return False
                else:
                    raise
            return self._is_one_pidfile()[0]

        def _is_one_pidfile(self):
            """
            Returns True, pid if there is only one pidfile with the expected
            base path

            :rtype: tuple
            """
            pidfiles = glob.glob(self.LOCKBASE + '-*')
            if len(pidfiles) == 1:
                pid = pidfiles[0].split('-')[-1]
                return True, int(pid)
            else:
                return False, None

        def get_pid(self):
            """
            Returns the pid of the locking process.

            :rtype: int
            """
            # XXX assert there is only one?
            _, pid = self._is_one_pidfile()
            return pid

        def get_locking_path(self):
            """
            Returns the pid path of the locking process.

            :rtype: str
            """
            pid = self.get_pid()
            if pid:
                return "%s-%s" % (self.LOCKBASE, pid)

        def release_lock(self, name=None):
            """
            Releases the pidfile dir for this process, by removing it.
            """
            if not name:
                name = self.name
            _release_lock(name)

        @classmethod
        def release_all_locks(self):
            """
            Releases all locks. Used for clean shutdown.
            """
            for lockdir in glob.glob("%s-%s" % (self.LOCKBASE, '*')):
                _release_lock(lockdir)

        @property
        def locked_by_us(self):
            """
            Returns True if the pid in the pidfile
            is ours.

            :rtype: bool
            """
            _, pid = self._is_one_pidfile()
            return pid == self.pid

        def update_ts(self):
            """
            Updates the timestamp of the lock.
            """
            if self.locked_by_us:
                update_modification_ts(self.name)

        def write_port(self, port):
            """
            Writes the port for windows control to the pidfile folder
            Returns True if successful.

            :rtype: bool
            """
            if not self.locked_by_us:
                logger.warning("Tried to write control port to a "
                               "non-unique pidfile folder")
                return False
            port_file = os.path.join(self.name, "port")
            with open(port_file, 'w') as f:
                f.write("%s" % port)
            return True

        def get_control_port(self):
            """
            Reads control port of the main instance from the port file
            in the pidfile dir

            :rtype: int
            """
            pid = self.get_pid()
            port_file = os.path.join(self.LOCKBASE + "-%s" % pid, "port")
            port = None
            try:
                with open(port_file) as f:
                    port_str = f.read()
                    port = int(port_str.strip())
            except IOError as exc:
                if exc.errno == errno.ENOENT:
                    logger.error("Tried to read port from non-existent file")
                else:
                    # we did not know explicitely about this error
                    raise
            return port

    def raise_window_ack():
        """
        This function is called from the windows callback that is registered
        with the raise_window event. It just updates the modification time
        of the lock file so we can signal an ack to the instance that tried
        to raise the window.
        """
        lock = WindowsLock()
        lock.update_ts()


def we_are_the_one_and_only():
    """
    Returns True if we are the only instance running, False otherwise.
    If we came later, send a raise signal to the main instance of the
    application.

    Under windows we are not using flock magic, so we wait during
    RAISE_WINDOW_TIMEOUT time, if not ack is
    received, we assume it was a stalled lock, so we remove it and continue
    with initialization.

    :rtype: bool
    """
    _sys = platform.system()

    if _sys in ("Linux", "Darwin"):
        locker = UnixLock('/tmp/leap-client.lock')
        locker.get_lock()
        we_are_the_one = locker.locked_by_us
        if not we_are_the_one:
            signal_event(proto.RAISE_WINDOW)
        return we_are_the_one

    elif _sys == "Windows":
        locker = WindowsLock()
        locker.get_lock()
        we_are_the_one = locker.locked_by_us

        if not we_are_the_one:
            locker.release_lock()
        lock_path = locker.get_locking_path()
        ts = get_modification_ts(lock_path)

        nowfun = datetime.datetime.now
        t0 = nowfun()
        pause = RAISE_WINDOW_TIMEOUT / float(RAISE_WINDOW_WAIT_STEPS)
        timeout_delta = datetime.timedelta(0, RAISE_WINDOW_TIMEOUT)
        check_interval = lambda: nowfun() - t0 < timeout_delta

        # let's assume it's a stalled lock
        we_are_the_one = True
        signal_event(proto.RAISE_WINDOW)

        while check_interval():
            if get_modification_ts(lock_path) > ts:
                # yay! someone claimed their control over the lock.
                # so the lock is alive
                logger.debug('Raise window ACK-ed')
                we_are_the_one = False
                break
            else:
                time.sleep(pause)

        if we_are_the_one:
            # ok, it really was a stalled lock. let's remove all
            # that is left, and put only ours there.
            WindowsLock.release_all_locks()
            WindowsLock().get_lock()

        return we_are_the_one

    else:
        logger.warning("Multi-instance checker "
                       "not implemented for %s" % (_sys))
        # lies, lies, lies...
        return True