~bzr-pqm/bzr/bzr.dev : revision 5970

92

>>> # do something here

93

>>> l.unlock()

94

95

Some classes of stale locks can be predicted by checking: the host name is the

96

same as the local host name; the user name is the same as the local user; the

97

process id no longer exists. The check on user name is not strictly necessary

98

but helps protect against colliding host names.

95

99

"""

96

100

97

101

103

107

# the existing locking code and needs a new format of the containing object.

104

108

# -- robertc, mbp 20070628

105

109

110

import errno

106

111

import os

107

112

import time

108

113

109

114

from bzrlib import (

115

config,

110

116

debug,

111

117

errors,

112

118

lock,

113

119

osutils,

120

ui,

121

urlutils,

114

122

)

115

import bzrlib.config

116

123

from bzrlib.decorators import only_raises

117

124

from bzrlib.errors import (

118

125

DirectoryNotEmpty,

130

137

)

131

138

from bzrlib.trace import mutter, note

132

139

from bzrlib.osutils import format_delta, rand_chars, get_host_name

133

import bzrlib.ui

134

140

135

141

from bzrlib.lazy_import import lazy_import

136

142

lazy_import(globals(), """

162

168

163

169

__INFO_NAME = '/info'

164

170

165

def __init__(self, transport, path, file_modebits=0644, dir_modebits=0755):

171

def __init__(self, transport, path, file_modebits=0644, dir_modebits=0755,

172

extra_holder_info=None):

166

173

"""Create a new LockDir object.

167

174

168

175

The LockDir is initially unlocked - this just creates the object.

171

178

172

179

:param path: Path to the lock within the base directory of the

173

180

transport.

181

182

:param extra_holder_info: If passed, {str:str} dict of extra or

183

updated information to insert into the info file when the lock is

184

taken.

174

185

"""

175

186

self.transport = transport

176

187

self.path = path

181

192

self._held_info_path = self._held_dir + self.__INFO_NAME

182

193

self._file_modebits = file_modebits

183

194

self._dir_modebits = dir_modebits

184

185

195

self._report_function = note

196

self.extra_holder_info = extra_holder_info

197

self._warned_about_lock_holder = None

186

198

187

199

def __repr__(self):

188

200

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

203

215

except (TransportError, PathError), e:

204

216

raise LockFailed(self, e)

205

217

206

207

218

def _attempt_lock(self):

208

219

"""Make the pending directory and attempt to rename into place.

209

220

216

227

217

228

:returns: The nonce of the lock, if it was successfully acquired.

218

229

219

:raises LockContention: If the lock is held by someone else. The exception

220

contains the info of the current holder of the lock.

230

:raises LockContention: If the lock is held by someone else. The

231

exception contains the info of the current holder of the lock.

221

232

"""

222

233

self._trace("lock_write...")

223

234

start_time = time.time()

226

237

except (errors.TransportError, PathError), e:

227

238

self._trace("... failed to create pending dir, %s", e)

228

239

raise LockFailed(self, e)

229

try:

230

self.transport.rename(tmpname, self._held_dir)

231

except (errors.TransportError, PathError, DirectoryNotEmpty,

232

FileExists, ResourceBusy), e:

233

self._trace("... contention, %s", e)

234

self._remove_pending_dir(tmpname)

235

raise LockContention(self)

236

except Exception, e:

237

self._trace("... lock failed, %s", e)

238

self._remove_pending_dir(tmpname)

239

raise

240

while True:

241

try:

242

self.transport.rename(tmpname, self._held_dir)

243

break

244

except (errors.TransportError, PathError, DirectoryNotEmpty,

245

FileExists, ResourceBusy), e:

246

self._trace("... contention, %s", e)

247

other_holder = self.peek()

248

self._trace("other holder is %r" % other_holder)

249

try:

250

self._handle_lock_contention(other_holder)

251

except:

252

self._remove_pending_dir(tmpname)

253

raise

254

except Exception, e:

255

self._trace("... lock failed, %s", e)

256

self._remove_pending_dir(tmpname)

257

raise

240

258

# We must check we really got the lock, because Launchpad's sftp

241

259

# server at one time had a bug were the rename would successfully

242

260

# move the new directory into the existing directory, which was

262

280

(time.time() - start_time) * 1000)

263

281

return self.nonce

264

282

283

def _handle_lock_contention(self, other_holder):

284

"""A lock we want to take is held by someone else.

285

286

This function can: tell the user about it; possibly detect that it's

287

safe or appropriate to steal the lock, or just raise an exception.

288

289

If this function returns (without raising an exception) the lock will

290

be attempted again.

291

292

:param other_holder: A LockHeldInfo for the current holder; note that

293

it might be None if the lock can be seen to be held but the info

294

can't be read.

295

"""

296

if (other_holder is not None):

297

if other_holder.is_lock_holder_known_dead():

298

if self.get_config().get_user_option_as_bool(

299

'locks.steal_dead',

300

default=False):

301

ui.ui_factory.show_user_warning(

302

'locks_steal_dead',

303

lock_url=urlutils.join(self.transport.base, self.path),

304

other_holder_info=unicode(other_holder))

305

self.force_break(other_holder)

306

self._trace("stole lock from dead holder")

307

return

308

raise LockContention(self)

309

265

310

def _remove_pending_dir(self, tmpname):

266

311

"""Remove the pending directory

267

312

287

332

self.create(mode=self._dir_modebits)

288

333

# After creating the lock directory, try again

289

334

self.transport.mkdir(tmpname)

290

self.nonce = rand_chars(20)

291

info_bytes = self._prepare_info()

335

info = LockHeldInfo.for_this_process(self.extra_holder_info)

336

self.nonce = info.get('nonce')

292

337

# We use put_file_non_atomic because we just created a new unique

293

338

# directory so we don't have to worry about files existing there.

294

339

# We'll rename the whole directory into place to get atomic

295

340

# properties

296

341

self.transport.put_bytes_non_atomic(tmpname + self.__INFO_NAME,

297

info_bytes)

342

info.to_bytes())

298

343

return tmpname

299

344

300

345

@only_raises(LockNotHeld, LockBroken)

344

389

def break_lock(self):

345

390

"""Break a lock not held by this instance of LockDir.

346

391

347

This is a UI centric function: it uses the bzrlib.ui.ui_factory to

392

This is a UI centric function: it uses the ui.ui_factory to

348

393

prompt for input if a lock is detected and there is any doubt about

349

it possibly being still active.

394

it possibly being still active. force_break is the non-interactive

395

version.

350

396

351

397

:returns: LockResult for the broken lock.

352

398

"""

355

401

holder_info = self.peek()

356

402

except LockCorrupt, e:

357

403

# The lock info is corrupt.

358

if bzrlib.ui.ui_factory.get_boolean(u"Break (corrupt %r)" % (self,)):

404

if ui.ui_factory.get_boolean(u"Break (corrupt %r)" % (self,)):

359

405

self.force_break_corrupt(e.file_data)

360

406

return

361

407

if holder_info is not None:

362

lock_info = '\n'.join(self._format_lock_info(holder_info))

363

if bzrlib.ui.ui_factory.confirm_action(

364

"Break %(lock_info)s", 'bzrlib.lockdir.break',

365

dict(lock_info=lock_info)):

408

if ui.ui_factory.confirm_action(

409

u"Break %(lock_info)s",

410

'bzrlib.lockdir.break',

411

dict(lock_info=unicode(holder_info))):

366

412

result = self.force_break(holder_info)

367

bzrlib.ui.ui_factory.show_message(

413

ui.ui_factory.show_message(

368

414

"Broke lock %s" % result.lock_url)

369

415

370

416

def force_break(self, dead_holder_info):

374

420

it still thinks it has the lock there will be two concurrent writers.

375

421

In general the user's approval should be sought for lock breaks.

376

422

377

dead_holder_info must be the result of a previous LockDir.peek() call;

378

this is used to check that it's still held by the same process that

379

the user decided was dead. If this is not the current holder,

380

LockBreakMismatch is raised.

381

382

423

After the lock is broken it will not be held by any process.

383

424

It is possible that another process may sneak in and take the

384

425

lock before the breaking process acquires it.

385

426

427

:param dead_holder_info:

428

Must be the result of a previous LockDir.peek() call; this is used

429

to check that it's still held by the same process that the user

430

decided was dead. If this is not the current holder,

431

LockBreakMismatch is raised.

432

386

433

:returns: LockResult for the broken lock.

387

434

"""

388

if not isinstance(dead_holder_info, dict):

435

if not isinstance(dead_holder_info, LockHeldInfo):

389

436

raise ValueError("dead_holder_info: %r" % dead_holder_info)

390

437

self._check_not_locked()

391

438

current_info = self.peek()

413

460

414

461

def force_break_corrupt(self, corrupt_info_lines):

415

462

"""Release a lock that has been corrupted.

416

463

417

464

This is very similar to force_break, it except it doesn't assume that

418

465

self.peek() can work.

419

466

420

467

:param corrupt_info_lines: the lines of the corrupted info file, used

421

468

to check that the lock hasn't changed between reading the (corrupt)

422

469

info file and calling force_break_corrupt.

470

517

471

518

peek() reads the info file of the lock holder, if any.

472

519

"""

473

return self._parse_info(self.transport.get_bytes(path))

520

return LockHeldInfo.from_info_file_bytes(

521

self.transport.get_bytes(path))

474

522

475

523

def peek(self):

476

524

"""Check if the lock is held by anyone.

489

537

def _prepare_info(self):

490

538

"""Write information about a pending lock to a temporary file.

491

539

"""

492

# XXX: is creating this here inefficient?

493

config = bzrlib.config.GlobalConfig()

494

try:

495

user = config.username()

496

except errors.NoWhoami:

497

user = osutils.getuser_unicode()

498

s = rio.Stanza(hostname=get_host_name(),

499

pid=str(os.getpid()),

500

start_time=str(int(time.time())),

501

nonce=self.nonce,

502

user=user,

503

)

504

return s.to_string()

505

506

def _parse_info(self, info_bytes):

507

lines = osutils.split_lines(info_bytes)

508

try:

509

stanza = rio.read_stanza(lines)

510

except ValueError, e:

511

mutter('Corrupt lock info file: %r', lines)

512

raise LockCorrupt("could not parse lock info file: " + str(e),

513

lines)

514

if stanza is None:

515

# see bug 185013; we fairly often end up with the info file being

516

# empty after an interruption; we could log a message here but

517

# there may not be much we can say

518

return {}

519

else:

520

return stanza.as_dict()

521

540

522

541

def attempt_lock(self):

523

542

"""Take the lock; fail if it's already held.

598

617

else:

599

618

start = 'Lock owner changed for'

600

619

last_info = new_info

601

formatted_info = self._format_lock_info(new_info)

620

msg = u'%s lock %s %s.' % (start, lock_url, new_info)

602

621

if deadline_str is None:

603

622

deadline_str = time.strftime('%H:%M:%S',

604

time.localtime(deadline))

605

user, hostname, pid, time_ago = formatted_info

606

msg = ('%s lock %s ' # lock_url

607

'held by ' # start

608

'%s\n' # user

609

'at %s ' # hostname

610

'[process #%s], ' # pid

611

'acquired %s.') # time ago

612

msg_args = [start, lock_url, user, hostname, pid, time_ago]

623

time.localtime(deadline))

613

624

if timeout > 0:

614

625

msg += ('\nWill continue to try until %s, unless '

615

'you press Ctrl-C.')

616

msg_args.append(deadline_str)

626

'you press Ctrl-C.'

627

% deadline_str)

617

628

msg += '\nSee "bzr help break-lock" for more.'

618

self._report_function(msg, *msg_args)

629

self._report_function(msg)

619

630

if (max_attempts is not None) and (attempt_count >= max_attempts):

620

631

self._trace("exceeded %d attempts")

621

632

raise LockContention(self)

676

687

raise LockContention(self)

677

688

self._fake_read_lock = True

678

689

679

def _format_lock_info(self, info):

680

"""Turn the contents of peek() into something for the user"""

681

start_time = info.get('start_time')

682

if start_time is None:

683

time_ago = '(unknown)'

684

else:

685

time_ago = format_delta(time.time() - int(info['start_time']))

686

user = info.get('user', '<unknown>')

687

hostname = info.get('hostname', '<unknown>')

688

pid = info.get('pid', '<unknown>')

689

return [

690

user,

691

hostname,

692

pid,

693

time_ago,

694

]

695

696

690

def validate_token(self, token):

697

691

if token is not None:

698

692

info = self.peek()

710

704

if 'lock' not in debug.debug_flags:

711

705

return

712

706

mutter(str(self) + ": " + (format % args))

707

708

def get_config(self):

709

"""Get the configuration that governs this lockdir."""

710

# XXX: This really should also use the locationconfig at least, but

711

# that seems a bit hard to hook up at the moment. -- mbp 20110329

712

return config.GlobalConfig()

713

714

715

class LockHeldInfo(object):

716

"""The information recorded about a held lock.

717

718

This information is recorded into the lock when it's taken, and it can be

719

read back by any process with access to the lockdir. It can be used, for

720

example, to tell the user who holds the lock, or to try to detect whether

721

the lock holder is still alive.

722

723

Prior to bzr 2.4 a simple dict was used instead of an object.

724

"""

725

726

def __init__(self, info_dict):

727

self.info_dict = info_dict

728

729

def __repr__(self):

730

"""Return a debugging representation of this object."""

731

return "%s(%r)" % (self.__class__.__name__, self.info_dict)

732

733

def __unicode__(self):

734

"""Return a user-oriented description of this object."""

735

d = self.to_readable_dict()

736

return (

737

u'held by %(user)s on %(hostname)s (process #%(pid)s), '

738

u'acquired %(time_ago)s' % d)

739

740

def to_readable_dict(self):

741

"""Turn the holder info into a dict of human-readable attributes.

742

743

For example, the start time is presented relative to the current time,

744

rather than as seconds since the epoch.

745

746

Returns a list of [user, hostname, pid, time_ago] all as readable

747

strings.

748

"""

749

start_time = self.info_dict.get('start_time')

750

if start_time is None:

751

time_ago = '(unknown)'

752

else:

753

time_ago = format_delta(

754

time.time() - int(self.info_dict['start_time']))

755

user = self.info_dict.get('user', '<unknown>')

756

hostname = self.info_dict.get('hostname', '<unknown>')

757

pid = self.info_dict.get('pid', '<unknown>')

758

return dict(

759

user=user,

760

hostname=hostname,

761

pid=pid,

762

time_ago=time_ago)

763

764

def get(self, field_name):

765

"""Return the contents of a field from the lock info, or None."""

766

return self.info_dict.get(field_name)

767

768

@classmethod

769

def for_this_process(cls, extra_holder_info):

770

"""Return a new LockHeldInfo for a lock taken by this process.

771

"""

772

info = dict(

773

hostname=get_host_name(),

774

pid=str(os.getpid()),

775

nonce=rand_chars(20),

776

start_time=str(int(time.time())),

777

user=get_username_for_lock_info(),

778

)

779

if extra_holder_info is not None:

780

info.update(extra_holder_info)

781

return cls(info)

782

783

def to_bytes(self):

784

s = rio.Stanza(**self.info_dict)

785

return s.to_string()

786

787

@classmethod

788

def from_info_file_bytes(cls, info_file_bytes):

789

"""Construct from the contents of the held file."""

790

lines = osutils.split_lines(info_file_bytes)

791

try:

792

stanza = rio.read_stanza(lines)

793

except ValueError, e:

794

mutter('Corrupt lock info file: %r', lines)

795

raise LockCorrupt("could not parse lock info file: " + str(e),

796

lines)

797

if stanza is None:

798

# see bug 185013; we fairly often end up with the info file being

799

# empty after an interruption; we could log a message here but

800

# there may not be much we can say

801

return cls({})

802

else:

803

return cls(stanza.as_dict())

804

805

def __cmp__(self, other):

806

"""Value comparison of lock holders."""

807

return (

808

cmp(type(self), type(other))

809

or cmp(self.info_dict, other.info_dict))

810

811

def is_locked_by_this_process(self):

812

"""True if this process seems to be the current lock holder."""

813

return (

814

self.get('hostname') == get_host_name()

815

and self.get('pid') == str(os.getpid())

816

and self.get('user') == get_username_for_lock_info())

817

818

def is_lock_holder_known_dead(self):

819

"""True if the lock holder process is known to be dead.

820

821

False if it's either known to be still alive, or if we just can't tell.

822

823

We can be fairly sure the lock holder is dead if it declared the same

824

hostname and there is no process with the given pid alive. If people

825

have multiple machines with the same hostname this may cause trouble.

826

827

This doesn't check whether the lock holder is in fact the same process

828

calling this method. (In that case it will return true.)

829

"""

830

if self.get('hostname') != get_host_name():

831

return False

832

if self.get('hostname') == 'localhost':

833

# Too ambiguous.

834

return False

835

if self.get('user') != get_username_for_lock_info():

836

# Could well be another local process by a different user, but

837

# just to be safe we won't conclude about this either.

838

return False

839

pid_str = self.info_dict.get('pid', None)

840

if not pid_str:

841

mutter("no pid recorded in %r" % (self, ))

842

return False

843

try:

844

pid = int(pid_str)

845

except ValueError:

846

mutter("can't parse pid %r from %r"

847

% (pid_str, self))

848

return False

849

return osutils.is_local_pid_dead(pid)

850

851

852

def get_username_for_lock_info():

853

"""Get a username suitable for putting into a lock.

854

855

It's ok if what's written here is not a proper email address as long

856

as it gives some clue who the user is.

857

"""

858

try:

859

return config.GlobalConfig().username()

860

except errors.NoWhoami:

861

return osutils.getuser_unicode()