/mandos/release : revision 24.1.158

1

#!/usr/bin/python

2

# -*- mode: python; coding: utf-8 -*-

3

#

4

# Mandos Monitor - Control and monitor the Mandos server

5

#

6

7

8

#

9

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

10

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

11

# the Free Software Foundation, either version 3 of the License, or

12

# (at your option) any later version.

13

#

14

# This program is distributed in the hope that it will be useful,

15

# but WITHOUT ANY WARRANTY; without even the implied warranty of

16

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

17

# GNU General Public License for more details.

18

#

19

# You should have received a copy of the GNU General Public License

20

# along with this program. If not, see <http://www.gnu.org/licenses/>.

21

#

22

# Contact the authors at <mandos@recompile.se>.

23

#

24

3

25

from __future__ import (division, absolute_import, print_function,

26

unicode_literals)

4

from __future__ import division, absolute_import, with_statement

27

5

28

6

import sys

29

7

import os

43

21

44

22

import locale

45

23

46

locale.setlocale(locale.LC_ALL, '')

24

locale.setlocale(locale.LC_ALL, u'')

47

25

48

26

import logging

49

27

logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)

50

28

51

29

# Some useful constants

52

domain = 'se.recompile'

30

domain = 'se.bsnet.fukt'

53

31

server_interface = domain + '.Mandos'

54

32

client_interface = domain + '.Mandos.Client'

55

version = "1.4.1"

33

version = "1.0.15"

56

34

57

35

# Always run in monochrome mode

58

36

urwid.curses_display.curses.has_colors = lambda : False

66

44

"Parse an ISO 8601 date string to a datetime.datetime()"

67

45

if not iso:

68

46

return None

69

d, t = iso.split("T", 1)

70

year, month, day = d.split("-", 2)

71

hour, minute, second = t.split(":", 2)

47

d, t = iso.split(u"T", 1)

48

year, month, day = d.split(u"-", 2)

49

hour, minute, second = t.split(u":", 2)

72

50

second, fraction = divmod(float(second), 1)

73

51

return datetime.datetime(int(year),

74

52

int(month),

87

65

self.proxy = proxy_object # Mandos Client proxy object

88

66

89

67

self.properties = dict()

90

self.property_changed_match = (

91

self.proxy.connect_to_signal("PropertyChanged",

92

self.property_changed,

93

client_interface,

94

byte_arrays=True))

68

self.proxy.connect_to_signal(u"PropertyChanged",

69

self.property_changed,

70

client_interface,

71

byte_arrays=True)

95

72

96

73

self.properties.update(

97

74

self.proxy.GetAll(client_interface,

98

75

dbus_interface = dbus.PROPERTIES_IFACE))

99

76

100

#XXX This breaks good super behaviour

77

#XXX This break good super behaviour!

101

78

# super(MandosClientPropertyCache, self).__init__(

102

79

# *args, **kwargs)

103

80

107

84

"""

108

85

# Update properties dict with new value

109

86

self.properties[property] = value

110

111

def delete(self, *args, **kwargs):

112

self.property_changed_match.remove()

113

super(MandosClientPropertyCache, self).__init__(

114

*args, **kwargs)

115

87

116

88

117

89

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

130

102

self.logger = logger

131

103

132

104

self._update_timer_callback_tag = None

133

self._update_timer_callback_lock = 0

134

105

self.last_checker_failed = False

135

106

136

107

# The widget shown normally

137

self._text_widget = urwid.Text("")

108

self._text_widget = urwid.Text(u"")

138

109

# The widget shown when we have focus

139

self._focus_text_widget = urwid.Text("")

110

self._focus_text_widget = urwid.Text(u"")

140

111

super(MandosClientWidget, self).__init__(

141

112

update_hook=update_hook, delete_hook=delete_hook,

142

113

*args, **kwargs)

143

114

self.update()

144

115

self.opened = False

145

116

self.proxy.connect_to_signal(u"CheckerCompleted",

117

self.checker_completed,

118

client_interface,

119

byte_arrays=True)

120

self.proxy.connect_to_signal(u"CheckerStarted",

121

self.checker_started,

122

client_interface,

123

byte_arrays=True)

124

self.proxy.connect_to_signal(u"GotSecret",

125

self.got_secret,

126

client_interface,

127

byte_arrays=True)

128

self.proxy.connect_to_signal(u"NeedApproval",

129

self.need_approval,

130

client_interface,

131

byte_arrays=True)

132

self.proxy.connect_to_signal(u"Rejected",

133

self.rejected,

134

client_interface,

135

byte_arrays=True)

146

136

last_checked_ok = isoformat_to_datetime(self.properties

147

["LastCheckedOK"])

137

["last_checked_ok"])

148

138

if last_checked_ok is None:

149

139

self.last_checker_failed = True

150

140

else:

152

142

- last_checked_ok)

153

143

> datetime.timedelta

154

144

(milliseconds=

155

self.properties

156

["Interval"]))

157

145

self.properties["interval"]))

158

146

if self.last_checker_failed:

159

self.using_timer(True)

160

161

if self.need_approval:

162

self.using_timer(True)

163

164

self.match_objects = (

165

self.proxy.connect_to_signal("CheckerCompleted",

166

self.checker_completed,

167

client_interface,

168

byte_arrays=True),

169

self.proxy.connect_to_signal("CheckerStarted",

170

self.checker_started,

171

client_interface,

172

byte_arrays=True),

173

self.proxy.connect_to_signal("GotSecret",

174

self.got_secret,

175

client_interface,

176

byte_arrays=True),

177

self.proxy.connect_to_signal("NeedApproval",

178

self.need_approval,

179

client_interface,

180

byte_arrays=True),

181

self.proxy.connect_to_signal("Rejected",

182

self.rejected,

183

client_interface,

184

byte_arrays=True))

185

#self.logger('Created client %s' % (self.properties["Name"]))

186

187

def property_changed(self, property=None, value=None):

188

super(self, MandosClientWidget).property_changed(property,

189

value)

190

if property == "ApprovalPending":

191

using_timer(bool(value))

192

193

def using_timer(self, flag):

194

"""Call this method with True or False when timer should be

195

activated or deactivated.

196

"""

197

old = self._update_timer_callback_lock

198

if flag:

199

self._update_timer_callback_lock += 1

200

else:

201

self._update_timer_callback_lock -= 1

202

if old == 0 and self._update_timer_callback_lock:

203

# Will update the shown timer value every second

204

147

self._update_timer_callback_tag = (gobject.timeout_add

205

148

(1000,

206

149

self.update_timer))

207

elif old and self._update_timer_callback_lock == 0:

208

gobject.source_remove(self._update_timer_callback_tag)

209

self._update_timer_callback_tag = None

210

150

211

151

def checker_completed(self, exitstatus, condition, command):

212

152

if exitstatus == 0:

213

153

if self.last_checker_failed:

214

154

self.last_checker_failed = False

215

self.using_timer(False)

216

#self.logger('Checker for client %s (command "%s")'

217

# ' was successful'

218

# % (self.properties["Name"], command))

155

gobject.source_remove(self._update_timer_callback_tag)

156

self._update_timer_callback_tag = None

157

self.logger(u'Checker for client %s (command "%s")'

158

u' was successful'

159

% (self.properties[u"name"], command))

219

160

self.update()

220

161

return

221

162

# Checker failed

222

163

if not self.last_checker_failed:

223

164

self.last_checker_failed = True

224

self.using_timer(True)

165

self._update_timer_callback_tag = (gobject.timeout_add

166

(1000,

167

self.update_timer))

225

168

if os.WIFEXITED(condition):

226

self.logger('Checker for client %s (command "%s")'

227

' failed with exit code %s'

228

% (self.properties["Name"], command,

169

self.logger(u'Checker for client %s (command "%s")'

170

u' failed with exit code %s'

171

% (self.properties[u"name"], command,

229

172

os.WEXITSTATUS(condition)))

230

173

elif os.WIFSIGNALED(condition):

231

self.logger('Checker for client %s (command "%s")'

232

' was killed by signal %s'

233

% (self.properties["Name"], command,

174

self.logger(u'Checker for client %s (command "%s")'

175

u' was killed by signal %s'

176

% (self.properties[u"name"], command,

234

177

os.WTERMSIG(condition)))

235

178

elif os.WCOREDUMP(condition):

236

self.logger('Checker for client %s (command "%s")'

237

' dumped core'

238

% (self.properties["Name"], command))

179

self.logger(u'Checker for client %s (command "%s")'

180

u' dumped core'

181

% (self.properties[u"name"], command))

239

182

else:

240

self.logger('Checker for client %s completed'

241

' mysteriously')

183

self.logger(u'Checker for client %s completed mysteriously')

242

184

self.update()

243

185

244

186

def checker_started(self, command):

245

#self.logger('Client %s started checker "%s"'

246

# % (self.properties["Name"], unicode(command)))

187

#self.logger(u'Client %s started checker "%s"'

188

# % (self.properties[u"name"], unicode(command)))

247

189

pass

248

190

249

191

def got_secret(self):

250

self.last_checker_failed = False

251

self.logger('Client %s received its secret'

252

% self.properties["Name"])

192

self.logger(u'Client %s received its secret'

193

% self.properties[u"name"])

253

194

254

195

def need_approval(self, timeout, default):

255

196

if not default:

256

message = 'Client %s needs approval within %s seconds'

197

message = u'Client %s needs approval within %s seconds'

257

198

else:

258

message = 'Client %s will get its secret in %s seconds'

199

message = u'Client %s will get its secret in %s seconds'

259

200

self.logger(message

260

% (self.properties["Name"], timeout/1000))

261

self.using_timer(True)

201

% (self.properties[u"name"], timeout/1000))

262

202

263

203

def rejected(self, reason):

264

self.logger('Client %s was rejected; reason: %s'

265

% (self.properties["Name"], reason))

204

self.logger(u'Client %s was rejected; reason: %s'

205

% (self.properties[u"name"], reason))

266

206

267

207

def selectable(self):

268

208

"""Make this a "selectable" widget.

269

209

This overrides the method from urwid.FlowWidget."""

270

210

return True

271

211

272

def rows(self, maxcolrow, focus=False):

212

def rows(self, (maxcol,), focus=False):

273

213

"""How many rows this widget will occupy might depend on

274

214

whether we have focus or not.

275

215

This overrides the method from urwid.FlowWidget"""

276

return self.current_widget(focus).rows(maxcolrow, focus=focus)

216

return self.current_widget(focus).rows((maxcol,), focus=focus)

277

217

278

218

def current_widget(self, focus=False):

279

219

if focus or self.opened:

283

223

def update(self):

284

224

"Called when what is visible on the screen should be updated."

285

225

# How to add standout mode to a style

286

with_standout = { "normal": "standout",

287

"bold": "bold-standout",

288

"underline-blink":

289

"underline-blink-standout",

290

"bold-underline-blink":

291

"bold-underline-blink-standout",

226

with_standout = { u"normal": u"standout",

227

u"bold": u"bold-standout",

228

u"underline-blink":

229

u"underline-blink-standout",

230

u"bold-underline-blink":

231

u"bold-underline-blink-standout",

292

232

}

293

233

294

234

# Rebuild focus and non-focus widgets using current properties

295

235

296

236

# Base part of a client. Name!

297

base = ('%(name)s: '

298

% {"name": self.properties["Name"]})

299

if not self.properties["Enabled"]:

300

message = "DISABLED"

301

elif self.properties["ApprovalPending"]:

237

base = (u'%(name)s: '

238

% {u"name": self.properties[u"name"]})

239

if not self.properties[u"enabled"]:

240

message = u"DISABLED"

241

elif self.last_checker_failed:

302

242

timeout = datetime.timedelta(milliseconds

303

= self.properties

304

["ApprovalDelay"])

305

last_approval_request = isoformat_to_datetime(

306

self.properties["LastApprovalRequest"])

307

if last_approval_request is not None:

308

timer = timeout - (datetime.datetime.utcnow()

309

- last_approval_request)

310

else:

311

timer = datetime.timedelta()

312

if self.properties["ApprovedByDefault"]:

313

message = "Approval in %s. (d)eny?"

314

else:

315

message = "Denial in %s. (a)pprove?"

316

message = message % unicode(timer).rsplit(".", 1)[0]

317

elif self.last_checker_failed:

318

# When checker has failed, print a timer until client expires

319

expires = self.properties["Expires"]

320

if expires == "":

321

timer = datetime.timedelta(0)

322

else:

323

expires = datetime.datetime.strptime(expires,

324

'%Y-%m-%dT%H:%M:%S.%f')

325

timer = expires - datetime.datetime.utcnow()

326

message = ('A checker has failed! Time until client'

327

' gets disabled: %s'

243

= self.properties[u"timeout"])

244

last_ok = isoformat_to_datetime(

245

max((self.properties["last_checked_ok"]

246

or self.properties["created"]),

247

self.properties[u"last_enabled"]))

248

timer = timeout - (datetime.datetime.utcnow() - last_ok)

249

message = (u'A checker has failed! Time until client gets diabled: %s'

328

250

% unicode(timer).rsplit(".", 1)[0])

251

elif self.properties[u"approved_pending"]:

252

if self.properties[u"approved_by_default"]:

253

message = u"Connection established to client. (d)eny?"

254

else:

255

message = u"Seeks approval to send secret. (a)pprove?"

329

256

else:

330

message = "enabled"

257

message = u"enabled"

331

258

self._text = "%s%s" % (base, message)

332

259

333

260

if not urwid.supports_unicode():

334

261

self._text = self._text.encode("ascii", "replace")

335

textlist = [("normal", self._text)]

262

textlist = [(u"normal", self._text)]

336

263

self._text_widget.set_text(textlist)

337

264

self._focus_text_widget.set_text([(with_standout[text[0]],

338

265

text[1])

347

274

self.update_hook()

348

275

349

276

def update_timer(self):

350

"""called by gobject. Will indefinitely loop until

351

gobject.source_remove() on tag is called"""

277

"called by gobject"

352

278

self.update()

353

279

return True # Keep calling this

354

280

355

def delete(self, *args, **kwargs):

281

def delete(self):

356

282

if self._update_timer_callback_tag is not None:

357

283

gobject.source_remove(self._update_timer_callback_tag)

358

284

self._update_timer_callback_tag = None

359

for match in self.match_objects:

360

match.remove()

361

self.match_objects = ()

362

285

if self.delete_hook is not None:

363

286

self.delete_hook(self)

364

return super(MandosClientWidget, self).delete(*args, **kwargs)

365

287

366

def render(self, maxcolrow, focus=False):

288

def render(self, (maxcol,), focus=False):

367

289

"""Render differently if we have focus.

368

290

This overrides the method from urwid.FlowWidget"""

369

return self.current_widget(focus).render(maxcolrow,

291

return self.current_widget(focus).render((maxcol,),

370

292

focus=focus)

371

293

372

def keypress(self, maxcolrow, key):

294

def keypress(self, (maxcol,), key):

373

295

"""Handle keys.

374

296

This overrides the method from urwid.FlowWidget"""

375

if key == "+":

376

self.proxy.Enable(dbus_interface = client_interface,

377

ignore_reply=True)

378

elif key == "-":

379

self.proxy.Disable(dbus_interface = client_interface,

380

ignore_reply=True)

381

elif key == "a":

297

if key == u"+":

298

self.proxy.Enable(dbus_interface = client_interface)

299

elif key == u"-":

300

self.proxy.Disable(dbus_interface = client_interface)

301

elif key == u"a":

382

302

self.proxy.Approve(dbus.Boolean(True, variant_level=1),

383

dbus_interface = client_interface,

384

ignore_reply=True)

385

elif key == "d":

303

dbus_interface = client_interface)

304

elif key == u"d":

386

305

self.proxy.Approve(dbus.Boolean(False, variant_level=1),

387

dbus_interface = client_interface,

388

ignore_reply=True)

389

elif key == "R" or key == "_" or key == "ctrl k":

306

dbus_interface = client_interface)

307

elif key == u"r" or key == u"_" or key == u"ctrl k":

390

308

self.server_proxy_object.RemoveClient(self.proxy

391

.object_path,

392

ignore_reply=True)

393

elif key == "s":

394

self.proxy.StartChecker(dbus_interface = client_interface,

395

ignore_reply=True)

396

elif key == "S":

397

self.proxy.StopChecker(dbus_interface = client_interface,

398

ignore_reply=True)

399

elif key == "C":

400

self.proxy.CheckedOK(dbus_interface = client_interface,

401

ignore_reply=True)

309

.object_path)

310

elif key == u"s":

311

self.proxy.StartChecker(dbus_interface = client_interface)

312

elif key == u"S":

313

self.proxy.StopChecker(dbus_interface = client_interface)

314

elif key == u"C":

315

self.proxy.CheckedOK(dbus_interface = client_interface)

402

316

# xxx

403

# elif key == "p" or key == "=":

317

# elif key == u"p" or key == "=":

404

318

# self.proxy.pause()

405

# elif key == "u" or key == ":":

319

# elif key == u"u" or key == ":":

406

320

# self.proxy.unpause()

407

# elif key == "RET":

321

# elif key == u"RET":

408

322

# self.open()

323

# elif key == u"+":

324

# self.proxy.Approve(True)

325

# elif key == u"-":

326

# self.proxy.Approve(False)

409

327

else:

410

328

return key

411

329

426

344

"down" key presses, thus not allowing any containing widgets to

427

345

use them as an excuse to shift focus away from this widget.

428

346

"""

429

def keypress(self, maxcolrow, key):

430

ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)

431

if ret in ("up", "down"):

347

def keypress(self, (maxcol, maxrow), key):

348

ret = super(ConstrainedListBox, self).keypress((maxcol, maxrow), key)

349

if ret in (u"up", u"down"):

432

350

return

433

351

return ret

434

352

443

361

self.screen = urwid.curses_display.Screen()

444

362

445

363

self.screen.register_palette((

446

("normal",

447

"default", "default", None),

448

("bold",

449

"default", "default", "bold"),

450

("underline-blink",

451

"default", "default", "underline"),

452

("standout",

453

"default", "default", "standout"),

454

("bold-underline-blink",

455

"default", "default", ("bold", "underline")),

456

("bold-standout",

457

"default", "default", ("bold", "standout")),

458

("underline-blink-standout",

459

"default", "default", ("underline", "standout")),

460

("bold-underline-blink-standout",

461

"default", "default", ("bold", "underline",

462

"standout")),

364

(u"normal",

365

u"default", u"default", None),

366

(u"bold",

367

u"default", u"default", u"bold"),

368

(u"underline-blink",

369

u"default", u"default", u"underline"),

370

(u"standout",

371

u"default", u"default", u"standout"),

372

(u"bold-underline-blink",

373

u"default", u"default", (u"bold", u"underline")),

374

(u"bold-standout",

375

u"default", u"default", (u"bold", u"standout")),

376

(u"underline-blink-standout",

377

u"default", u"default", (u"underline", u"standout")),

378

(u"bold-underline-blink-standout",

379

u"default", u"default", (u"bold", u"underline",

380

u"standout")),

463

381

))

464

382

465

383

if urwid.supports_unicode():

466

self.divider = "─" # \u2500

467

#self.divider = "━" # \u2501

384

self.divider = u"─" # \u2500

385

#self.divider = u"━" # \u2501

468

386

else:

469

#self.divider = "-" # \u002d

470

self.divider = "_" # \u005f

387

#self.divider = u"-" # \u002d

388

self.divider = u"_" # \u005f

471

389

472

390

self.screen.start()

473

391

487

405

# This keeps track of whether self.uilist currently has

488

406

# self.logbox in it or not

489

407

self.log_visible = True

490

self.log_wrap = "any"

408

self.log_wrap = u"any"

491

409

492

410

self.rebuild()

493

self.log_message_raw(("bold",

494

"Mandos Monitor version " + version))

495

self.log_message_raw(("bold",

496

"q: Quit ?: Help"))

411

self.log_message_raw((u"bold",

412

u"Mandos Monitor version " + version))

413

self.log_message_raw((u"bold",

414

u"q: Quit ?: Help"))

497

415

498

416

self.busname = domain + '.Mandos'

499

417

self.main_loop = gobject.MainLoop()

500

418

self.bus = dbus.SystemBus()

501

419

mandos_dbus_objc = self.bus.get_object(

502

self.busname, "/", follow_name_owner_changes=True)

420

self.busname, u"/", follow_name_owner_changes=True)

503

421

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

504

422

dbus_interface

505

423

= server_interface)

510

428

mandos_clients = dbus.Dictionary()

511

429

512

430

(self.mandos_serv

513

.connect_to_signal("ClientRemoved",

431

.connect_to_signal(u"ClientRemoved",

514

432

self.find_and_remove_client,

515

433

dbus_interface=server_interface,

516

434

byte_arrays=True))

517

435

(self.mandos_serv

518

.connect_to_signal("ClientAdded",

436

.connect_to_signal(u"ClientAdded",

519

437

self.add_new_client,

520

438

dbus_interface=server_interface,

521

439

byte_arrays=True))

522

440

(self.mandos_serv

523

.connect_to_signal("ClientNotFound",

441

.connect_to_signal(u"ClientNotFound",

524

442

self.client_not_found,

525

443

dbus_interface=server_interface,

526

444

byte_arrays=True))

541

459

path=path)

542

460

543

461

def client_not_found(self, fingerprint, address):

544

self.log_message(("Client with address %s and fingerprint %s"

545

" could not be found" % (address,

462

self.log_message((u"Client with address %s and fingerprint %s"

463

u" could not be found" % (address,

546

464

fingerprint)))

547

465

548

466

def rebuild(self):

550

468

Call this when the widget layout needs to change"""

551

469

self.uilist = []

552

470

#self.uilist.append(urwid.ListBox(self.clients))

553

self.uilist.append(urwid.Frame(ConstrainedListBox(self.

554

clients),

471

self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),

555

472

#header=urwid.Divider(),

556

473

header=None,

557

footer=

558

urwid.Divider(div_char=

559

self.divider)))

474

footer=urwid.Divider(div_char=self.divider)))

560

475

if self.log_visible:

561

476

self.uilist.append(self.logbox)

562

477

pass

564

479

565

480

def log_message(self, message):

566

481

timestamp = datetime.datetime.now().isoformat()

567

self.log_message_raw(timestamp + ": " + message)

482

self.log_message_raw(timestamp + u": " + message)

568

483

569

484

def log_message_raw(self, markup):

570

485

"""Add a log message to the log buffer."""

573

488

and len(self.log) > self.max_log_length):

574

489

del self.log[0:len(self.log)-self.max_log_length-1]

575

490

self.logbox.set_focus(len(self.logbox.body.contents),

576

coming_from="above")

491

coming_from=u"above")

577

492

self.refresh()

578

493

579

494

def toggle_log_display(self):

580

495

"""Toggle visibility of the log buffer."""

581

496

self.log_visible = not self.log_visible

582

497

self.rebuild()

583

#self.log_message("Log visibility changed to: "

584

# + unicode(self.log_visible))

498

self.log_message(u"Log visibility changed to: "

499

+ unicode(self.log_visible))

585

500

586

501

def change_log_display(self):

587

502

"""Change type of log display.

588

503

Currently, this toggles wrapping of text lines."""

589

if self.log_wrap == "clip":

590

self.log_wrap = "any"

504

if self.log_wrap == u"clip":

505

self.log_wrap = u"any"

591

506

else:

592

self.log_wrap = "clip"

507

self.log_wrap = u"clip"

593

508

for textwidget in self.log:

594

509

textwidget.set_wrap_mode(self.log_wrap)

595

#self.log_message("Wrap mode: " + self.log_wrap)

510

self.log_message(u"Wrap mode: " + self.log_wrap)

596

511

597

512

def find_and_remove_client(self, path, name):

598

"""Find a client by its object path and remove it.

513

"""Find an client from its object path and remove it.

599

514

600

515

This is connected to the ClientRemoved signal from the

601

516

Mandos server object."""

603

518

client = self.clients_dict[path]

604

519

except KeyError:

605

520

# not found?

606

self.log_message("Unknown client %r (%r) removed", name,

607

path)

608

521

return

609

client.delete()

522

self.remove_client(client, path)

610

523

611

524

def add_new_client(self, path):

612

525

client_proxy_object = self.bus.get_object(self.busname, path)

627

540

if path is None:

628

541

path = client.proxy.object_path

629

542

self.clients_dict[path] = client

630

self.clients.sort(None, lambda c: c.properties["Name"])

543

self.clients.sort(None, lambda c: c.properties[u"name"])

631

544

self.refresh()

632

545

633

546

def remove_client(self, client, path=None):

664

577

665

578

def process_input(self, source, condition):

666

579

keys = self.screen.get_input()

667

translations = { "ctrl n": "down", # Emacs

668

"ctrl p": "up", # Emacs

669

"ctrl v": "page down", # Emacs

670

"meta v": "page up", # Emacs

671

" ": "page down", # less

672

"f": "page down", # less

673

"b": "page up", # less

674

"j": "down", # vi

675

"k": "up", # vi

580

translations = { u"ctrl n": u"down", # Emacs

581

u"ctrl p": u"up", # Emacs

582

u"ctrl v": u"page down", # Emacs

583

u"meta v": u"page up", # Emacs

584

u" ": u"page down", # less

585

u"f": u"page down", # less

586

u"b": u"page up", # less

587

u"j": u"down", # vi

588

u"k": u"up", # vi

676

589

}

677

590

for key in keys:

678

591

try:

680

593

except KeyError: # :-)

681

594

pass

682

595

683

if key == "q" or key == "Q":

596

if key == u"q" or key == u"Q":

684

597

self.stop()

685

598

break

686

elif key == "window resize":

599

elif key == u"window resize":

687

600

self.size = self.screen.get_cols_rows()

688

601

self.refresh()

689

elif key == "\f": # Ctrl-L

602

elif key == u"\f": # Ctrl-L

690

603

self.refresh()

691

elif key == "l" or key == "D":

604

elif key == u"l" or key == u"D":

692

605

self.toggle_log_display()

693

606

self.refresh()

694

elif key == "w" or key == "i":

607

elif key == u"w" or key == u"i":

695

608

self.change_log_display()

696

609

self.refresh()

697

elif key == "?" or key == "f1" or key == "esc":

610

elif key == u"?" or key == u"f1" or key == u"esc":

698

611

if not self.log_visible:

699

612

self.log_visible = True

700

613

self.rebuild()

701

self.log_message_raw(("bold",

702

" ".

703

join(("q: Quit",

704

"?: Help",

705

"l: Log window toggle",

706

"TAB: Switch window",

707

"w: Wrap (log)"))))

708

self.log_message_raw(("bold",

709

" "

710

.join(("Clients:",

711

"+: Enable",

712

"-: Disable",

713

"R: Remove",

714

"s: Start new checker",

715

"S: Stop checker",

716

"C: Checker OK",

717

"a: Approve",

718

"d: Deny"))))

614

self.log_message_raw((u"bold",

615

u" ".

616

join((u"q: Quit",

617

u"?: Help",

618

u"l: Log window toggle",

619

u"TAB: Switch window",

620

u"w: Wrap (log)"))))

621

self.log_message_raw((u"bold",

622

u" "

623

.join((u"Clients:",

624

u"+: Enable",

625

u"-: Disable",

626

u"r: Remove",

627

u"s: Start new checker",

628

u"S: Stop checker",

629

u"C: Checker OK",

630

u"a: Approve",

631

u"d: Deny"))))

719

632

self.refresh()

720

elif key == "tab":

633

elif key == u"tab":

721

634

if self.topwidget.get_focus() is self.logbox:

722

635

self.topwidget.set_focus(0)

723

636

else:

724

637

self.topwidget.set_focus(self.logbox)

725

638

self.refresh()

726

#elif (key == "end" or key == "meta >" or key == "G"

727

# or key == ">"):

639

#elif (key == u"end" or key == u"meta >" or key == u"G"

640

# or key == u">"):

728

641

# pass # xxx end-of-buffer

729

#elif (key == "home" or key == "meta <" or key == "g"

730

# or key == "<"):

642

#elif (key == u"home" or key == u"meta <" or key == u"g"

643

# or key == u"<"):

731

644

# pass # xxx beginning-of-buffer

732

#elif key == "ctrl e" or key == "$":

645

#elif key == u"ctrl e" or key == u"$":

733

646

# pass # xxx move-end-of-line

734

#elif key == "ctrl a" or key == "^":

647

#elif key == u"ctrl a" or key == u"^":

735

648

# pass # xxx move-beginning-of-line

736

#elif key == "ctrl b" or key == "meta (" or key == "h":

649

#elif key == u"ctrl b" or key == u"meta (" or key == u"h":

737

650

# pass # xxx left

738

#elif key == "ctrl f" or key == "meta )" or key == "l":

651

#elif key == u"ctrl f" or key == u"meta )" or key == u"l":

739

652

# pass # xxx right

740

#elif key == "a":

653

#elif key == u"a":

741

654

# pass # scroll up log

742

#elif key == "z":

655

#elif key == u"z":

743

656

# pass # scroll down log

744

657

elif self.topwidget.selectable():

745

658

self.topwidget.keypress(self.size, key)

749

662

ui = UserInterface()

750

663

try:

751

664

ui.run()

752

except KeyboardInterrupt:

753

ui.screen.stop()

754

665

except Exception, e:

755

666

ui.log_message(unicode(e))

756

667

ui.screen.stop()