/mandos/trunk : revision 505.1.3

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

#

3

24

4

from __future__ import division, absolute_import, with_statement

25

from __future__ import (division, absolute_import, print_function,

26

unicode_literals)

5

27

6

28

import sys

7

29

import os

21

43

22

44

import locale

23

45

24

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

46

locale.setlocale(locale.LC_ALL, '')

47

48

import logging

49

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

25

50

26

51

# Some useful constants

27

domain = 'se.bsnet.fukt'

52

domain = 'se.recompile'

28

53

server_interface = domain + '.Mandos'

29

54

client_interface = domain + '.Mandos.Client'

30

version = "1.0.14"

55

version = "1.3.1"

31

56

32

57

# Always run in monochrome mode

33

58

urwid.curses_display.curses.has_colors = lambda : False

41

66

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

42

67

if not iso:

43

68

return None

44

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

45

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

46

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

69

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

70

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

71

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

47

72

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

48

73

return datetime.datetime(int(year),

49

74

int(month),

62

87

self.proxy = proxy_object # Mandos Client proxy object

63

88

64

89

self.properties = dict()

65

self.proxy.connect_to_signal(u"PropertyChanged",

66

self.property_changed,

67

client_interface,

68

byte_arrays=True)

90

self.property_changed_match = (

91

self.proxy.connect_to_signal("PropertyChanged",

92

self.property_changed,

93

client_interface,

94

byte_arrays=True))

69

95

70

96

self.properties.update(

71

97

self.proxy.GetAll(client_interface,

72

98

dbus_interface = dbus.PROPERTIES_IFACE))

73

super(MandosClientPropertyCache, self).__init__(

74

proxy_object=proxy_object, *args, **kwargs)

99

100

#XXX This breaks good super behaviour

101

# super(MandosClientPropertyCache, self).__init__(

102

# *args, **kwargs)

75

103

76

104

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

77

105

"""This is called whenever we get a PropertyChanged signal

79

107

"""

80

108

# Update properties dict with new value

81

109

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)

82

115

83

116

84

117

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

97

130

self.logger = logger

98

131

99

132

self._update_timer_callback_tag = None

133

self._update_timer_callback_lock = 0

100

134

self.last_checker_failed = False

101

135

102

136

# The widget shown normally

103

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

137

self._text_widget = urwid.Text("")

104

138

# The widget shown when we have focus

105

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

139

self._focus_text_widget = urwid.Text("")

106

140

super(MandosClientWidget, self).__init__(

107

141

update_hook=update_hook, delete_hook=delete_hook,

108

142

*args, **kwargs)

109

143

self.update()

110

144

self.opened = False

111

self.proxy.connect_to_signal(u"CheckerCompleted",

112

self.checker_completed,

113

client_interface,

114

byte_arrays=True)

115

self.proxy.connect_to_signal(u"CheckerStarted",

116

self.checker_started,

117

client_interface,

118

byte_arrays=True)

119

self.proxy.connect_to_signal(u"GotSecret",

120

self.got_secret,

121

client_interface,

122

byte_arrays=True)

123

self.proxy.connect_to_signal(u"Rejected",

124

self.rejected,

125

client_interface,

126

byte_arrays=True)

145

127

146

last_checked_ok = isoformat_to_datetime(self.properties

128

["last_checked_ok"])

147

["LastCheckedOK"])

129

148

if last_checked_ok is None:

130

149

self.last_checker_failed = True

131

150

else:

133

152

- last_checked_ok)

134

153

> datetime.timedelta

135

154

(milliseconds=

136

self.properties["interval"]))

155

self.properties

156

["Interval"]))

157

137

158

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

138

204

self._update_timer_callback_tag = (gobject.timeout_add

139

205

(1000,

140

206

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

141

210

142

211

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

143

212

if exitstatus == 0:

144

213

if self.last_checker_failed:

145

214

self.last_checker_failed = False

146

gobject.source_remove(self._update_timer_callback_tag)

147

self._update_timer_callback_tag = None

148

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

149

u' was successful'

150

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

215

self.using_timer(False)

216

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

217

# ' was successful'

218

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

151

219

self.update()

152

220

return

153

221

# Checker failed

154

222

if not self.last_checker_failed:

155

223

self.last_checker_failed = True

156

self._update_timer_callback_tag = (gobject.timeout_add

157

(1000,

158

self.update_timer))

224

self.using_timer(True)

159

225

if os.WIFEXITED(condition):

160

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

161

u' failed with exit code %s'

162

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

226

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

227

' failed with exit code %s'

228

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

163

229

os.WEXITSTATUS(condition)))

164

230

elif os.WIFSIGNALED(condition):

165

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

166

u' was killed by signal %s'

167

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

231

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

232

' was killed by signal %s'

233

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

168

234

os.WTERMSIG(condition)))

169

235

elif os.WCOREDUMP(condition):

170

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

171

u' dumped core'

172

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

236

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

237

' dumped core'

238

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

173

239

else:

174

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

240

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

241

' mysteriously')

175

242

self.update()

176

243

177

244

def checker_started(self, command):

178

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

179

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

245

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

246

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

247

pass

180

248

181

249

def got_secret(self):

182

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

183

% self.properties[u"name"])

184

185

def rejected(self):

186

self.logger(u'Client %s was rejected'

187

% self.properties[u"name"])

250

self.last_checker_failed = False

251

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

252

% self.properties["Name"])

253

254

def need_approval(self, timeout, default):

255

if not default:

256

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

257

else:

258

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

259

self.logger(message

260

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

261

self.using_timer(True)

262

263

def rejected(self, reason):

264

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

265

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

188

266

189

267

def selectable(self):

190

268

"""Make this a "selectable" widget.

191

269

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

192

270

return True

193

271

194

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

272

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

195

273

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

196

274

whether we have focus or not.

197

275

This overrides the method from urwid.FlowWidget"""

198

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

276

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

199

277

200

278

def current_widget(self, focus=False):

201

279

if focus or self.opened:

205

283

def update(self):

206

284

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

207

285

# How to add standout mode to a style

208

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

209

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

210

u"underline-blink":

211

u"underline-blink-standout",

212

u"bold-underline-blink":

213

u"bold-underline-blink-standout",

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",

214

292

}

215

293

216

294

# Rebuild focus and non-focus widgets using current properties

217

self._text = (u'%(name)s: %(enabled)s%(timer)s'

218

% { u"name": self.properties[u"name"],

219

u"enabled":

220

(u"enabled"

221

if self.properties[u"enabled"]

222

else u"DISABLED"),

223

u"timer": (unicode(datetime.timedelta

224

(milliseconds =

225

self.properties

226

[u"timeout"])

227

- (datetime.datetime

228

.utcnow()

229

- isoformat_to_datetime

230

(max((self.properties

231

["last_checked_ok"]

232

or

233

self.properties

234

["created"]),

235

self.properties[u"last_enabled"]))))

236

if (self.last_checker_failed

237

and self.properties

238

[u"enabled"])

239

else u"")})

295

296

# 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"]:

302

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'

328

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

329

else:

330

message = "enabled"

331

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

332

240

333

if not urwid.supports_unicode():

241

334

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

242

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

335

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

243

336

self._text_widget.set_text(textlist)

244

337

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

245

338

text[1])

254

347

self.update_hook()

255

348

256

349

def update_timer(self):

257

"called by gobject"

350

"""called by gobject. Will indefinitely loop until

351

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

258

352

self.update()

259

353

return True # Keep calling this

260

354

261

def delete(self):

355

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

262

356

if self._update_timer_callback_tag is not None:

263

357

gobject.source_remove(self._update_timer_callback_tag)

264

358

self._update_timer_callback_tag = None

359

for match in self.match_objects:

360

match.remove()

361

self.match_objects = ()

265

362

if self.delete_hook is not None:

266

363

self.delete_hook(self)

364

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

267

365

268

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

366

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

269

367

"""Render differently if we have focus.

270

368

This overrides the method from urwid.FlowWidget"""

271

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

369

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

272

370

focus=focus)

273

371

274

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

372

def keypress(self, maxcolrow, key):

275

373

"""Handle keys.

276

374

This overrides the method from urwid.FlowWidget"""

277

if key == u"e" or key == u"+":

278

self.proxy.Enable()

279

elif key == u"d" or key == u"-":

280

self.proxy.Disable()

281

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

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":

382

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

383

dbus_interface = client_interface,

384

ignore_reply=True)

385

elif key == "d":

386

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":

282

390

self.server_proxy_object.RemoveClient(self.proxy

283

.object_path)

284

elif key == u"s":

285

self.proxy.StartChecker()

286

elif key == u"S":

287

self.proxy.StopChecker()

288

elif key == u"C":

289

self.proxy.CheckedOK()

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)

290

402

# xxx

291

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

403

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

292

404

# self.proxy.pause()

293

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

405

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

294

406

# self.proxy.unpause()

295

# elif key == u"RET":

407

# elif key == "RET":

296

408

# self.open()

297

409

else:

298

410

return key

314

426

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

315

427

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

316

428

"""

317

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

318

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

319

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

429

def keypress(self, maxcolrow, key):

430

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

431

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

320

432

return

321

433

return ret

322

434

331

443

self.screen = urwid.curses_display.Screen()

332

444

333

445

self.screen.register_palette((

334

(u"normal",

335

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

336

(u"bold",

337

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

338

(u"underline-blink",

339

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

340

(u"standout",

341

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

342

(u"bold-underline-blink",

343

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

344

(u"bold-standout",

345

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

346

(u"underline-blink-standout",

347

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

348

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

349

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

350

u"standout")),

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")),

351

463

))

352

464

353

465

if urwid.supports_unicode():

354

self.divider = u"─" # \u2500

355

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

466

self.divider = "─" # \u2500

467

#self.divider = "━" # \u2501

356

468

else:

357

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

358

self.divider = u"_" # \u005f

469

#self.divider = "-" # \u002d

470

self.divider = "_" # \u005f

359

471

360

472

self.screen.start()

361

473

375

487

# This keeps track of whether self.uilist currently has

376

488

# self.logbox in it or not

377

489

self.log_visible = True

378

self.log_wrap = u"any"

490

self.log_wrap = "any"

379

491

380

492

self.rebuild()

381

self.log_message_raw((u"bold",

382

u"Mandos Monitor version " + version))

383

self.log_message_raw((u"bold",

384

u"q: Quit ?: Help"))

493

self.log_message_raw(("bold",

494

"Mandos Monitor version " + version))

495

self.log_message_raw(("bold",

496

"q: Quit ?: Help"))

385

497

386

498

self.busname = domain + '.Mandos'

387

499

self.main_loop = gobject.MainLoop()

388

500

self.bus = dbus.SystemBus()

389

501

mandos_dbus_objc = self.bus.get_object(

390

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

502

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

391

503

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

392

504

dbus_interface

393

505

= server_interface)

398

510

mandos_clients = dbus.Dictionary()

399

511

400

512

(self.mandos_serv

401

.connect_to_signal(u"ClientRemoved",

513

.connect_to_signal("ClientRemoved",

402

514

self.find_and_remove_client,

403

515

dbus_interface=server_interface,

404

516

byte_arrays=True))

405

517

(self.mandos_serv

406

.connect_to_signal(u"ClientAdded",

518

.connect_to_signal("ClientAdded",

407

519

self.add_new_client,

408

520

dbus_interface=server_interface,

409

521

byte_arrays=True))

410

522

(self.mandos_serv

411

.connect_to_signal(u"ClientNotFound",

523

.connect_to_signal("ClientNotFound",

412

524

self.client_not_found,

413

525

dbus_interface=server_interface,

414

526

byte_arrays=True))

429

541

path=path)

430

542

431

543

def client_not_found(self, fingerprint, address):

432

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

433

u" could not be found" % (address,

544

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

545

" could not be found" % (address,

434

546

fingerprint)))

435

547

436

548

def rebuild(self):

438

550

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

439

551

self.uilist = []

440

552

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

441

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

553

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

554

clients),

442

555

#header=urwid.Divider(),

443

556

header=None,

444

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

557

footer=

558

urwid.Divider(div_char=

559

self.divider)))

445

560

if self.log_visible:

446

561

self.uilist.append(self.logbox)

447

562

pass

449

564

450

565

def log_message(self, message):

451

566

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

452

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

567

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

453

568

454

569

def log_message_raw(self, markup):

455

570

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

458

573

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

459

574

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

460

575

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

461

coming_from=u"above")

576

coming_from="above")

462

577

self.refresh()

463

578

464

579

def toggle_log_display(self):

465

580

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

466

581

self.log_visible = not self.log_visible

467

582

self.rebuild()

468

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

469

+ unicode(self.log_visible))

583

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

584

# + unicode(self.log_visible))

470

585

471

586

def change_log_display(self):

472

587

"""Change type of log display.

473

588

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

474

if self.log_wrap == u"clip":

475

self.log_wrap = u"any"

589

if self.log_wrap == "clip":

590

self.log_wrap = "any"

476

591

else:

477

self.log_wrap = u"clip"

592

self.log_wrap = "clip"

478

593

for textwidget in self.log:

479

594

textwidget.set_wrap_mode(self.log_wrap)

480

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

595

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

481

596

482

597

def find_and_remove_client(self, path, name):

483

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

598

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

484

599

485

600

This is connected to the ClientRemoved signal from the

486

601

Mandos server object."""

488

603

client = self.clients_dict[path]

489

604

except KeyError:

490

605

# not found?

606

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

607

path)

491

608

return

492

self.remove_client(client, path)

609

client.delete()

493

610

494

611

def add_new_client(self, path):

495

612

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

510

627

if path is None:

511

628

path = client.proxy.object_path

512

629

self.clients_dict[path] = client

513

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

630

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

514

631

self.refresh()

515

632

516

633

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

547

664

548

665

def process_input(self, source, condition):

549

666

keys = self.screen.get_input()

550

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

551

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

552

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

553

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

554

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

555

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

556

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

557

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

558

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

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

559

676

}

560

677

for key in keys:

561

678

try:

563

680

except KeyError: # :-)

564

681

pass

565

682

566

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

683

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

567

684

self.stop()

568

685

break

569

elif key == u"window resize":

686

elif key == "window resize":

570

687

self.size = self.screen.get_cols_rows()

571

688

self.refresh()

572

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

689

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

573

690

self.refresh()

574

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

691

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

575

692

self.toggle_log_display()

576

693

self.refresh()

577

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

694

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

578

695

self.change_log_display()

579

696

self.refresh()

580

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

697

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

581

698

if not self.log_visible:

582

699

self.log_visible = True

583

700

self.rebuild()

584

self.log_message_raw((u"bold",

585

u" ".

586

join((u"q: Quit",

587

u"?: Help",

588

u"l: Log window toggle",

589

u"TAB: Switch window",

590

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

591

self.log_message_raw((u"bold",

592

u" "

593

.join((u"Clients:",

594

u"e: Enable",

595

u"d: Disable",

596

u"r: Remove",

597

u"s: Start new checker",

598

u"S: Stop checker",

599

u"C: Checker OK"))))

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"))))

600

719

self.refresh()

601

elif key == u"tab":

720

elif key == "tab":

602

721

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

603

722

self.topwidget.set_focus(0)

604

723

else:

605

724

self.topwidget.set_focus(self.logbox)

606

725

self.refresh()

607

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

608

# or key == u">"):

726

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

727

# or key == ">"):

609

728

# pass # xxx end-of-buffer

610

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

611

# or key == u"<"):

729

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

730

# or key == "<"):

612

731

# pass # xxx beginning-of-buffer

613

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

732

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

614

733

# pass # xxx move-end-of-line

615

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

734

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

616

735

# pass # xxx move-beginning-of-line

617

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

736

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

618

737

# pass # xxx left

619

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

738

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

620

739

# pass # xxx right

621

#elif key == u"a":

740

#elif key == "a":

622

741

# pass # scroll up log

623

#elif key == u"z":

742

#elif key == "z":

624

743

# pass # scroll down log

625

744

elif self.topwidget.selectable():

626

745

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

630

749

ui = UserInterface()

631

750

try:

632

751

ui.run()

752

except KeyboardInterrupt:

753

ui.screen.stop()

633

754

except Exception, e:

634

755

ui.log_message(unicode(e))

635

756

ui.screen.stop()