/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/lock.py

• browse files at revision 4501.3.1
• compare with another revision
• download diff
• download tarball
• view history from revision 4501.3.1

• reverse the comparison (4501.3.1 to 5200.3.7)
• stop comparing with revision 5200.3.7

Show diffs side-by-side

added

removed

bzrlib/lock.py

1

 

# Copyright (C) 2005-2010 Canonical Ltd

 

1

# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd

2

2

#

3

3

# This program is free software; you can redistribute it and/or modify

4

4

# it under the terms of the GNU General Public License as published by

37

37

import errno

38

38

import os

39

39

import sys

40

 

import warnings

41

40

 

42

41

from bzrlib import (

43

 

    debug,

44

42

    errors,

45

43

    osutils,

46

44

    trace,

84

82

        return self.lock_url == other.lock_url and self.details == other.details

85

83

 

86

84

    def __repr__(self):

87

 

        return '%s(%s, %s)' % (self.__class__.__name__,

 

85

        return '%s(%s%s)' % (self.__class__.__name__,

88

86

                             self.lock_url, self.details)

89

87

 

90

88

 

91

 

class LogicalLockResult(object):

92

 

    """The result of a lock_read/lock_write/lock_tree_write call on lockables.

93

 

 

94

 

    :ivar unlock: A callable which will unlock the lock.

95

 

    """

96

 

 

97

 

    def __init__(self, unlock):

98

 

        self.unlock = unlock

99

 

 

100

 

    def __repr__(self):

101

 

        return "LogicalLockResult(%s)" % (self.unlock)

102

 

 

103

 

 

104

 

 

105

 

def cant_unlock_not_held(locked_object):

106

 

    """An attempt to unlock failed because the object was not locked.

107

 

 

108

 

    This provides a policy point from which we can generate either a warning 

109

 

    or an exception.

110

 

    """

111

 

    # This is typically masking some other error and called from a finally

112

 

    # block, so it's useful to have the option not to generate a new error

113

 

    # here.  You can use -Werror to make it fatal.  It should possibly also

114

 

    # raise LockNotHeld.

115

 

    if 'unlock' in debug.debug_flags:

116

 

        warnings.warn("%r is already unlocked" % (locked_object,),

117

 

            stacklevel=3)

118

 

    else:

119

 

        raise errors.LockNotHeld(locked_object)

120

 

 

121

 

 

122

89

try:

123

90

    import fcntl

124

91

    have_fcntl = True

204

171

            if self.filename in _fcntl_WriteLock._open_locks:

205

172

                self._clear_f()

206

173

                raise errors.LockContention(self.filename)

207

 

            if self.filename in _fcntl_ReadLock._open_locks:

208

 

                if 'strict_locks' in debug.debug_flags:

209

 

                    self._clear_f()

210

 

                    raise errors.LockContention(self.filename)

211

 

                else:

212

 

                    trace.mutter('Write lock taken w/ an open read lock on: %s'

213

 

                                 % (self.filename,))

214

174

 

215

175

            self._open(self.filename, 'rb+')

216

176

            # reserve a slot for this lock - even if the lockf call fails,

217

 

            # at this point unlock() will be called, because self.f is set.

 

177

            # at thisi point unlock() will be called, because self.f is set.

218

178

            # TODO: make this fully threadsafe, if we decide we care.

219

179

            _fcntl_WriteLock._open_locks.add(self.filename)

220

180

            try:

241

201

        def __init__(self, filename):

242

202

            super(_fcntl_ReadLock, self).__init__()

243

203

            self.filename = osutils.realpath(filename)

244

 

            if self.filename in _fcntl_WriteLock._open_locks:

245

 

                if 'strict_locks' in debug.debug_flags:

246

 

                    # We raise before calling _open so we don't need to

247

 

                    # _clear_f

248

 

                    raise errors.LockContention(self.filename)

249

 

                else:

250

 

                    trace.mutter('Read lock taken w/ an open write lock on: %s'

251

 

                                 % (self.filename,))

252

204

            _fcntl_ReadLock._open_locks.setdefault(self.filename, 0)

253

205

            _fcntl_ReadLock._open_locks[self.filename] += 1

254

206

            self._open(filename, 'rb')

349

301

 

350

302

 

351

303

if have_pywin32 and sys.platform == 'win32':

352

 

    if os.path.supports_unicode_filenames:

353

 

        # for Windows NT/2K/XP/etc

354

 

        win32file_CreateFile = win32file.CreateFileW

355

 

    else:

356

 

        # for Windows 98

357

 

        win32file_CreateFile = win32file.CreateFile

358

304

 

359

305

    class _w32c_FileLock(_OSLock):

360

306

 

361

307

        def _open(self, filename, access, share, cflags, pymode):

362

308

            self.filename = osutils.realpath(filename)

363

309

            try:

364

 

                self._handle = win32file_CreateFile(filename, access, share,

 

310

                self._handle = win32file.CreateFile(filename, access, share,

365

311

                    None, win32file.OPEN_ALWAYS,

366

312

                    win32file.FILE_ATTRIBUTE_NORMAL, None)

367

313

            except pywintypes.error, e:

447

393

            DWORD,                 # dwFlagsAndAttributes

448

394

            HANDLE                 # hTemplateFile

449

395

        )((_function_name, ctypes.windll.kernel32))

450

 

 

 

396

    

451

397

    INVALID_HANDLE_VALUE = -1

452

 

 

 

398

    

453

399

    GENERIC_READ = 0x80000000

454

400

    GENERIC_WRITE = 0x40000000

455

401

    FILE_SHARE_READ = 1

456

402

    OPEN_ALWAYS = 4

457

403

    FILE_ATTRIBUTE_NORMAL = 128

458

 

 

 

404

    

459

405

    ERROR_ACCESS_DENIED = 5

460

406

    ERROR_SHARING_VIOLATION = 32

461

407

 

532

478

# We default to using the first available lock class.

533

479

_lock_type, WriteLock, ReadLock = _lock_classes[0]

534

480

 

535

 

 

536

 

class _RelockDebugMixin(object):

537

 

    """Mixin support for -Drelock flag.

538

 

 

539

 

    Add this as a base class then call self._note_lock with 'r' or 'w' when

540

 

    acquiring a read- or write-lock.  If this object was previously locked (and

541

 

    locked the same way), and -Drelock is set, then this will trace.note a

542

 

    message about it.

543

 

    """

544

 

    

545

 

    _prev_lock = None

546

 

 

547

 

    def _note_lock(self, lock_type):

548

 

        if 'relock' in debug.debug_flags and self._prev_lock == lock_type:

549

 

            if lock_type == 'r':

550

 

                type_name = 'read'

551

 

            else:

552

 

                type_name = 'write'

553

 

            trace.note('%r was %s locked again', self, type_name)

554

 

        self._prev_lock = lock_type

555

 

 

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0