/mandos/release : revision 237.7.42

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@fukt.bsnet.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, '')

25

47

26

48

import logging

27

49

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

30

52

domain = 'se.bsnet.fukt'

31

53

server_interface = domain + '.Mandos'

32

54

client_interface = domain + '.Mandos.Client'

33

version = "1.0.15"

55

version = "1.3.1"

34

56

35

57

# Always run in monochrome mode

36

58

urwid.curses_display.curses.has_colors = lambda : False

44

66

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

45

67

if not iso:

46

68

return None

47

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

48

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

49

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)

50

72

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

51

73

return datetime.datetime(int(year),

52

74

int(month),

65

87

self.proxy = proxy_object # Mandos Client proxy object

66

88

67

89

self.properties = dict()

68

self.proxy.connect_to_signal(u"PropertyChanged",

69

self.property_changed,

70

client_interface,

71

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

72

95

73

96

self.properties.update(

74

97

self.proxy.GetAll(client_interface,

75

98

dbus_interface = dbus.PROPERTIES_IFACE))

76

99

77

#XXX This break good super behaviour!

100

#XXX This breaks good super behaviour

78

101

# super(MandosClientPropertyCache, self).__init__(

79

102

# *args, **kwargs)

80

103

84

107

"""

85

108

# Update properties dict with new value

86

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)

87

115

88

116

89

117

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

102

130

self.logger = logger

103

131

104

132

self._update_timer_callback_tag = None

133

self._update_timer_callback_lock = 0

105

134

self.last_checker_failed = False

106

135

107

136

# The widget shown normally

108

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

137

self._text_widget = urwid.Text("")

109

138

# The widget shown when we have focus

110

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

139

self._focus_text_widget = urwid.Text("")

111

140

super(MandosClientWidget, self).__init__(

112

141

update_hook=update_hook, delete_hook=delete_hook,

113

142

*args, **kwargs)

114

143

self.update()

115

144

self.opened = False

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)

145

136

146

last_checked_ok = isoformat_to_datetime(self.properties

137

["last_checked_ok"])

147

["LastCheckedOK"])

138

148

if last_checked_ok is None:

139

149

self.last_checker_failed = True

140

150

else:

142

152

- last_checked_ok)

143

153

> datetime.timedelta

144

154

(milliseconds=

145

self.properties["interval"]))

155

self.properties

156

["Interval"]))

157

146

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:

147

203

self._update_timer_callback_tag = (gobject.timeout_add

148

204

(1000,

149

205

self.update_timer))

206

elif old and self._update_timer_callback_lock == 0:

207

gobject.source_remove(self._update_timer_callback_tag)

208

self._update_timer_callback_tag = None

150

209

151

210

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

152

211

if exitstatus == 0:

153

212

if self.last_checker_failed:

154

213

self.last_checker_failed = False

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

214

self.using_timer(False)

215

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

216

# ' was successful'

217

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

160

218

self.update()

161

219

return

162

220

# Checker failed

163

221

if not self.last_checker_failed:

164

222

self.last_checker_failed = True

165

self._update_timer_callback_tag = (gobject.timeout_add

166

(1000,

167

self.update_timer))

223

self.using_timer(True)

168

224

if os.WIFEXITED(condition):

169

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

170

u' failed with exit code %s'

171

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

225

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

226

' failed with exit code %s'

227

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

172

228

os.WEXITSTATUS(condition)))

173

229

elif os.WIFSIGNALED(condition):

174

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

175

u' was killed by signal %s'

176

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

230

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

231

' was killed by signal %s'

232

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

177

233

os.WTERMSIG(condition)))

178

234

elif os.WCOREDUMP(condition):

179

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

180

u' dumped core'

181

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

235

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

236

' dumped core'

237

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

182

238

else:

183

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

239

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

240

' mysteriously')

184

241

self.update()

185

242

186

243

def checker_started(self, command):

187

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

188

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

244

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

245

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

189

246

pass

190

247

191

248

def got_secret(self):

192

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

193

% self.properties[u"name"])

249

self.last_checker_failed = False

250

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

251

% self.properties["Name"])

194

252

195

253

def need_approval(self, timeout, default):

196

254

if not default:

197

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

255

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

198

256

else:

199

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

257

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

200

258

self.logger(message

201

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

259

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

260

self.using_timer(True)

202

261

203

262

def rejected(self, reason):

204

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

205

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

263

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

264

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

206

265

207

266

def selectable(self):

208

267

"""Make this a "selectable" widget.

209

268

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

210

269

return True

211

270

212

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

271

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

213

272

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

214

273

whether we have focus or not.

215

274

This overrides the method from urwid.FlowWidget"""

216

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

275

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

217

276

218

277

def current_widget(self, focus=False):

219

278

if focus or self.opened:

223

282

def update(self):

224

283

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

225

284

# How to add standout mode to a style

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

285

with_standout = { "normal": "standout",

286

"bold": "bold-standout",

287

"underline-blink":

288

"underline-blink-standout",

289

"bold-underline-blink":

290

"bold-underline-blink-standout",

232

291

}

233

292

234

293

# Rebuild focus and non-focus widgets using current properties

235

294

236

295

# Base part of a client. Name!

237

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

238

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

239

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

240

message = u"DISABLED"

296

base = ('%(name)s: '

297

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

298

if not self.properties["Enabled"]:

299

message = "DISABLED"

300

elif self.properties["ApprovalPending"]:

301

timeout = datetime.timedelta(milliseconds

302

= self.properties

303

["ApprovalDelay"])

304

last_approval_request = isoformat_to_datetime(

305

self.properties["LastApprovalRequest"])

306

if last_approval_request is not None:

307

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

308

- last_approval_request)

309

else:

310

timer = datetime.timedelta()

311

if self.properties["ApprovedByDefault"]:

312

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

313

else:

314

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

315

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

241

316

elif self.last_checker_failed:

242

317

timeout = datetime.timedelta(milliseconds

243

= self.properties[u"timeout"])

318

= self.properties

319

["Timeout"])

244

320

last_ok = isoformat_to_datetime(

245

max((self.properties["last_checked_ok"]

246

or self.properties["created"]),

247

self.properties[u"last_enabled"]))

321

max((self.properties["LastCheckedOK"]

322

or self.properties["Created"]),

323

self.properties["LastEnabled"]))

248

324

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

249

250

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

251

% unicode(timer))

252

elif self.properties[u"approved_pending"]:

253

if self.properties[u"approved_by_default"]:

254

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

255

else:

256

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

325

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

326

' gets disabled: %s'

327

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

257

328

else:

258

message = u"enabled"

329

message = "enabled"

259

330

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

260

331

261

332

if not urwid.supports_unicode():

262

333

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

263

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

334

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

264

335

self._text_widget.set_text(textlist)

265

336

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

266

337

text[1])

279

350

self.update()

280

351

return True # Keep calling this

281

352

282

def delete(self):

353

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

283

354

if self._update_timer_callback_tag is not None:

284

355

gobject.source_remove(self._update_timer_callback_tag)

285

356

self._update_timer_callback_tag = None

357

for match in self.match_objects:

358

match.remove()

359

self.match_objects = ()

286

360

if self.delete_hook is not None:

287

361

self.delete_hook(self)

362

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

288

363

289

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

364

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

290

365

"""Render differently if we have focus.

291

366

This overrides the method from urwid.FlowWidget"""

292

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

367

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

293

368

focus=focus)

294

369

295

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

370

def keypress(self, maxcolrow, key):

296

371

"""Handle keys.

297

372

This overrides the method from urwid.FlowWidget"""

298

if key == u"+":

299

self.proxy.Enable(dbus_interface = client_interface)

300

elif key == u"-":

301

self.proxy.Disable(dbus_interface = client_interface)

302

elif key == u"a":

373

if key == "+":

374

self.proxy.Enable(dbus_interface = client_interface,

375

ignore_reply=True)

376

elif key == "-":

377

self.proxy.Disable(dbus_interface = client_interface,

378

ignore_reply=True)

379

elif key == "a":

303

380

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

304

dbus_interface = client_interface)

305

elif key == u"d":

381

dbus_interface = client_interface,

382

ignore_reply=True)

383

elif key == "d":

306

384

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

307

dbus_interface = client_interface)

308

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

385

dbus_interface = client_interface,

386

ignore_reply=True)

387

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

309

388

self.server_proxy_object.RemoveClient(self.proxy

310

.object_path)

311

elif key == u"s":

312

self.proxy.StartChecker(dbus_interface = client_interface)

313

elif key == u"S":

314

self.proxy.StopChecker(dbus_interface = client_interface)

315

elif key == u"C":

316

self.proxy.CheckedOK(dbus_interface = client_interface)

389

.object_path,

390

ignore_reply=True)

391

elif key == "s":

392

self.proxy.StartChecker(dbus_interface = client_interface,

393

ignore_reply=True)

394

elif key == "S":

395

self.proxy.StopChecker(dbus_interface = client_interface,

396

ignore_reply=True)

397

elif key == "C":

398

self.proxy.CheckedOK(dbus_interface = client_interface,

399

ignore_reply=True)

317

400

# xxx

318

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

401

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

319

402

# self.proxy.pause()

320

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

403

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

321

404

# self.proxy.unpause()

322

# elif key == u"RET":

405

# elif key == "RET":

323

406

# self.open()

324

# elif key == u"+":

325

# self.proxy.Approve(True)

326

# elif key == u"-":

327

# self.proxy.Approve(False)

328

407

else:

329

408

return key

330

409

345

424

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

346

425

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

347

426

"""

348

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

349

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

350

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

427

def keypress(self, maxcolrow, key):

428

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

429

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

351

430

return

352

431

return ret

353

432

362

441

self.screen = urwid.curses_display.Screen()

363

442

364

443

self.screen.register_palette((

365

(u"normal",

366

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

367

(u"bold",

368

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

369

(u"underline-blink",

370

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

371

(u"standout",

372

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

373

(u"bold-underline-blink",

374

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

375

(u"bold-standout",

376

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

377

(u"underline-blink-standout",

378

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

379

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

380

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

381

u"standout")),

444

("normal",

445

"default", "default", None),

446

("bold",

447

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

448

("underline-blink",

449

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

450

("standout",

451

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

452

("bold-underline-blink",

453

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

454

("bold-standout",

455

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

456

("underline-blink-standout",

457

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

458

("bold-underline-blink-standout",

459

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

460

"standout")),

382

461

))

383

462

384

463

if urwid.supports_unicode():

385

self.divider = u"─" # \u2500

386

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

464

self.divider = "─" # \u2500

465

#self.divider = "━" # \u2501

387

466

else:

388

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

389

self.divider = u"_" # \u005f

467

#self.divider = "-" # \u002d

468

self.divider = "_" # \u005f

390

469

391

470

self.screen.start()

392

471

406

485

# This keeps track of whether self.uilist currently has

407

486

# self.logbox in it or not

408

487

self.log_visible = True

409

self.log_wrap = u"any"

488

self.log_wrap = "any"

410

489

411

490

self.rebuild()

412

self.log_message_raw((u"bold",

413

u"Mandos Monitor version " + version))

414

self.log_message_raw((u"bold",

415

u"q: Quit ?: Help"))

491

self.log_message_raw(("bold",

492

"Mandos Monitor version " + version))

493

self.log_message_raw(("bold",

494

"q: Quit ?: Help"))

416

495

417

496

self.busname = domain + '.Mandos'

418

497

self.main_loop = gobject.MainLoop()

419

498

self.bus = dbus.SystemBus()

420

499

mandos_dbus_objc = self.bus.get_object(

421

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

500

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

422

501

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

423

502

dbus_interface

424

503

= server_interface)

429

508

mandos_clients = dbus.Dictionary()

430

509

431

510

(self.mandos_serv

432

.connect_to_signal(u"ClientRemoved",

511

.connect_to_signal("ClientRemoved",

433

512

self.find_and_remove_client,

434

513

dbus_interface=server_interface,

435

514

byte_arrays=True))

436

515

(self.mandos_serv

437

.connect_to_signal(u"ClientAdded",

516

.connect_to_signal("ClientAdded",

438

517

self.add_new_client,

439

518

dbus_interface=server_interface,

440

519

byte_arrays=True))

441

520

(self.mandos_serv

442

.connect_to_signal(u"ClientNotFound",

521

.connect_to_signal("ClientNotFound",

443

522

self.client_not_found,

444

523

dbus_interface=server_interface,

445

524

byte_arrays=True))

460

539

path=path)

461

540

462

541

def client_not_found(self, fingerprint, address):

463

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

464

u" could not be found" % (address,

542

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

543

" could not be found" % (address,

465

544

fingerprint)))

466

545

467

546

def rebuild(self):

469

548

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

470

549

self.uilist = []

471

550

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

472

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

551

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

552

clients),

473

553

#header=urwid.Divider(),

474

554

header=None,

475

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

555

footer=

556

urwid.Divider(div_char=

557

self.divider)))

476

558

if self.log_visible:

477

559

self.uilist.append(self.logbox)

478

560

pass

480

562

481

563

def log_message(self, message):

482

564

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

483

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

565

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

484

566

485

567

def log_message_raw(self, markup):

486

568

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

489

571

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

490

572

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

491

573

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

492

coming_from=u"above")

574

coming_from="above")

493

575

self.refresh()

494

576

495

577

def toggle_log_display(self):

496

578

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

497

579

self.log_visible = not self.log_visible

498

580

self.rebuild()

499

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

500

+ unicode(self.log_visible))

581

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

582

# + unicode(self.log_visible))

501

583

502

584

def change_log_display(self):

503

585

"""Change type of log display.

504

586

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

505

if self.log_wrap == u"clip":

506

self.log_wrap = u"any"

587

if self.log_wrap == "clip":

588

self.log_wrap = "any"

507

589

else:

508

self.log_wrap = u"clip"

590

self.log_wrap = "clip"

509

591

for textwidget in self.log:

510

592

textwidget.set_wrap_mode(self.log_wrap)

511

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

593

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

512

594

513

595

def find_and_remove_client(self, path, name):

514

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

596

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

515

597

516

598

This is connected to the ClientRemoved signal from the

517

599

Mandos server object."""

519

601

client = self.clients_dict[path]

520

602

except KeyError:

521

603

# not found?

604

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

605

path)

522

606

return

523

self.remove_client(client, path)

607

client.delete()

524

608

525

609

def add_new_client(self, path):

526

610

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

541

625

if path is None:

542

626

path = client.proxy.object_path

543

627

self.clients_dict[path] = client

544

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

628

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

545

629

self.refresh()

546

630

547

631

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

578

662

579

663

def process_input(self, source, condition):

580

664

keys = self.screen.get_input()

581

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

582

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

583

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

584

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

585

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

586

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

587

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

588

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

589

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

665

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

666

"ctrl p": "up", # Emacs

667

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

668

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

669

" ": "page down", # less

670

"f": "page down", # less

671

"b": "page up", # less

672

"j": "down", # vi

673

"k": "up", # vi

590

674

}

591

675

for key in keys:

592

676

try:

594

678

except KeyError: # :-)

595

679

pass

596

680

597

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

681

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

598

682

self.stop()

599

683

break

600

elif key == u"window resize":

684

elif key == "window resize":

601

685

self.size = self.screen.get_cols_rows()

602

686

self.refresh()

603

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

687

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

604

688

self.refresh()

605

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

689

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

606

690

self.toggle_log_display()

607

691

self.refresh()

608

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

692

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

609

693

self.change_log_display()

610

694

self.refresh()

611

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

695

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

612

696

if not self.log_visible:

613

697

self.log_visible = True

614

698

self.rebuild()

615

self.log_message_raw((u"bold",

616

u" ".

617

join((u"q: Quit",

618

u"?: Help",

619

u"l: Log window toggle",

620

u"TAB: Switch window",

621

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

622

self.log_message_raw((u"bold",

623

u" "

624

.join((u"Clients:",

625

u"+: Enable",

626

u"-: Disable",

627

u"r: Remove",

628

u"s: Start new checker",

629

u"S: Stop checker",

630

u"C: Checker OK",

631

u"a: Approve",

632

u"d: Deny"))))

699

self.log_message_raw(("bold",

700

" ".

701

join(("q: Quit",

702

"?: Help",

703

"l: Log window toggle",

704

"TAB: Switch window",

705

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

706

self.log_message_raw(("bold",

707

" "

708

.join(("Clients:",

709

"+: Enable",

710

"-: Disable",

711

"R: Remove",

712

"s: Start new checker",

713

"S: Stop checker",

714

"C: Checker OK",

715

"a: Approve",

716

"d: Deny"))))

633

717

self.refresh()

634

elif key == u"tab":

718

elif key == "tab":

635

719

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

636

720

self.topwidget.set_focus(0)

637

721

else:

638

722

self.topwidget.set_focus(self.logbox)

639

723

self.refresh()

640

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

641

# or key == u">"):

724

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

725

# or key == ">"):

642

726

# pass # xxx end-of-buffer

643

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

644

# or key == u"<"):

727

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

728

# or key == "<"):

645

729

# pass # xxx beginning-of-buffer

646

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

730

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

647

731

# pass # xxx move-end-of-line

648

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

732

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

649

733

# pass # xxx move-beginning-of-line

650

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

734

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

651

735

# pass # xxx left

652

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

736

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

653

737

# pass # xxx right

654

#elif key == u"a":

738

#elif key == "a":

655

739

# pass # scroll up log

656

#elif key == u"z":

740

#elif key == "z":

657

741

# pass # scroll down log

658

742

elif self.topwidget.selectable():

659

743

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

663

747

ui = UserInterface()

664

748

try:

665

749

ui.run()

750

except KeyboardInterrupt:

751

ui.screen.stop()

666

752

except Exception, e:

667

753

ui.log_message(unicode(e))

668

754

ui.screen.stop()