/mandos/release : revision 237.7.43

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

47

48

import logging

49

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

25

50

26

51

# Some useful constants

27

52

domain = 'se.bsnet.fukt'

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:

138

203

self._update_timer_callback_tag = (gobject.timeout_add

139

204

(1000,

140

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

141

209

142

210

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

143

211

if exitstatus == 0:

144

212

if self.last_checker_failed:

145

213

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

214

self.using_timer(False)

215

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

216

# ' was successful'

217

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

151

218

self.update()

152

219

return

153

220

# Checker failed

154

221

if not self.last_checker_failed:

155

222

self.last_checker_failed = True

156

self._update_timer_callback_tag = (gobject.timeout_add

157

(1000,

158

self.update_timer))

223

self.using_timer(True)

159

224

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,

225

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

226

' failed with exit code %s'

227

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

163

228

os.WEXITSTATUS(condition)))

164

229

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,

230

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

231

' was killed by signal %s'

232

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

168

233

os.WTERMSIG(condition)))

169

234

elif os.WCOREDUMP(condition):

170

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

171

u' dumped core'

172

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

235

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

236

' dumped core'

237

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

173

238

else:

174

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

239

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

240

' mysteriously')

175

241

self.update()

176

242

177

243

def checker_started(self, command):

178

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

179

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

244

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

245

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

246

pass

180

247

181

248

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

249

self.last_checker_failed = False

250

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

251

% self.properties["Name"])

252

253

def need_approval(self, timeout, default):

254

if not default:

255

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

256

else:

257

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

258

self.logger(message

259

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

260

self.using_timer(True)

261

262

def rejected(self, reason):

263

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

264

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

188

265

189

266

def selectable(self):

190

267

"""Make this a "selectable" widget.

191

268

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

192

269

return True

193

270

194

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

271

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

195

272

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

196

273

whether we have focus or not.

197

274

This overrides the method from urwid.FlowWidget"""

198

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

275

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

199

276

200

277

def current_widget(self, focus=False):

201

278

if focus or self.opened:

205

282

def update(self):

206

283

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

207

284

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

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

214

291

}

215

292

216

293

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

294

295

# Base part of a client. Name!

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]

316

elif self.last_checker_failed:

317

timeout = datetime.timedelta(milliseconds

318

= self.properties

319

["Timeout"])

320

last_ok = isoformat_to_datetime(

321

max((self.properties["LastCheckedOK"]

322

or self.properties["Created"]),

323

self.properties["LastEnabled"]))

324

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

325

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

326

' gets disabled: %s'

327

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

328

else:

329

message = "enabled"

330

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

331

240

332

if not urwid.supports_unicode():

241

333

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

242

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

334

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

243

335

self._text_widget.set_text(textlist)

244

336

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

245

337

text[1])

258

350

self.update()

259

351

return True # Keep calling this

260

352

261

def delete(self):

353

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

262

354

if self._update_timer_callback_tag is not None:

263

355

gobject.source_remove(self._update_timer_callback_tag)

264

356

self._update_timer_callback_tag = None

357

for match in self.match_objects:

358

match.remove()

359

self.match_objects = ()

265

360

if self.delete_hook is not None:

266

361

self.delete_hook(self)

362

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

267

363

268

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

364

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

269

365

"""Render differently if we have focus.

270

366

This overrides the method from urwid.FlowWidget"""

271

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

367

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

272

368

focus=focus)

273

369

274

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

370

def keypress(self, maxcolrow, key):

275

371

"""Handle keys.

276

372

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

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

380

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

381

dbus_interface = client_interface,

382

ignore_reply=True)

383

elif key == "d":

384

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

385

dbus_interface = client_interface,

386

ignore_reply=True)

387

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

282

388

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

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)

290

400

# xxx

291

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

401

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

292

402

# self.proxy.pause()

293

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

403

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

294

404

# self.proxy.unpause()

295

# elif key == u"RET":

405

# elif key == "RET":

296

406

# self.open()

297

407

else:

298

408

return key

314

424

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

315

425

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

316

426

"""

317

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

318

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

319

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

320

430

return

321

431

return ret

322

432

331

441

self.screen = urwid.curses_display.Screen()

332

442

333

443

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

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

351

461

))

352

462

353

463

if urwid.supports_unicode():

354

self.divider = u"─" # \u2500

355

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

464

self.divider = "─" # \u2500

465

#self.divider = "━" # \u2501

356

466

else:

357

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

358

self.divider = u"_" # \u005f

467

#self.divider = "-" # \u002d

468

self.divider = "_" # \u005f

359

469

360

470

self.screen.start()

361

471

375

485

# This keeps track of whether self.uilist currently has

376

486

# self.logbox in it or not

377

487

self.log_visible = True

378

self.log_wrap = u"any"

488

self.log_wrap = "any"

379

489

380

490

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

491

self.log_message_raw(("bold",

492

"Mandos Monitor version " + version))

493

self.log_message_raw(("bold",

494

"q: Quit ?: Help"))

385

495

386

496

self.busname = domain + '.Mandos'

387

497

self.main_loop = gobject.MainLoop()

388

498

self.bus = dbus.SystemBus()

389

499

mandos_dbus_objc = self.bus.get_object(

390

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

500

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

391

501

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

392

502

dbus_interface

393

503

= server_interface)

398

508

mandos_clients = dbus.Dictionary()

399

509

400

510

(self.mandos_serv

401

.connect_to_signal(u"ClientRemoved",

511

.connect_to_signal("ClientRemoved",

402

512

self.find_and_remove_client,

403

513

dbus_interface=server_interface,

404

514

byte_arrays=True))

405

515

(self.mandos_serv

406

.connect_to_signal(u"ClientAdded",

516

.connect_to_signal("ClientAdded",

407

517

self.add_new_client,

408

518

dbus_interface=server_interface,

409

519

byte_arrays=True))

410

520

(self.mandos_serv

411

.connect_to_signal(u"ClientNotFound",

521

.connect_to_signal("ClientNotFound",

412

522

self.client_not_found,

413

523

dbus_interface=server_interface,

414

524

byte_arrays=True))

429

539

path=path)

430

540

431

541

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,

542

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

543

" could not be found" % (address,

434

544

fingerprint)))

435

545

436

546

def rebuild(self):

438

548

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

439

549

self.uilist = []

440

550

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

441

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

551

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

552

clients),

442

553

#header=urwid.Divider(),

443

554

header=None,

444

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

555

footer=

556

urwid.Divider(div_char=

557

self.divider)))

445

558

if self.log_visible:

446

559

self.uilist.append(self.logbox)

447

560

pass

449

562

450

563

def log_message(self, message):

451

564

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

452

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

565

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

453

566

454

567

def log_message_raw(self, markup):

455

568

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

458

571

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

459

572

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

460

573

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

461

coming_from=u"above")

574

coming_from="above")

462

575

self.refresh()

463

576

464

577

def toggle_log_display(self):

465

578

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

466

579

self.log_visible = not self.log_visible

467

580

self.rebuild()

468

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

469

+ unicode(self.log_visible))

581

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

582

# + unicode(self.log_visible))

470

583

471

584

def change_log_display(self):

472

585

"""Change type of log display.

473

586

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

474

if self.log_wrap == u"clip":

475

self.log_wrap = u"any"

587

if self.log_wrap == "clip":

588

self.log_wrap = "any"

476

589

else:

477

self.log_wrap = u"clip"

590

self.log_wrap = "clip"

478

591

for textwidget in self.log:

479

592

textwidget.set_wrap_mode(self.log_wrap)

480

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

593

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

481

594

482

595

def find_and_remove_client(self, path, name):

483

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

596

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

484

597

485

598

This is connected to the ClientRemoved signal from the

486

599

Mandos server object."""

488

601

client = self.clients_dict[path]

489

602

except KeyError:

490

603

# not found?

604

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

605

path)

491

606

return

492

self.remove_client(client, path)

607

client.delete()

493

608

494

609

def add_new_client(self, path):

495

610

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

510

625

if path is None:

511

626

path = client.proxy.object_path

512

627

self.clients_dict[path] = client

513

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

628

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

514

629

self.refresh()

515

630

516

631

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

547

662

548

663

def process_input(self, source, condition):

549

664

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

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

559

674

}

560

675

for key in keys:

561

676

try:

563

678

except KeyError: # :-)

564

679

pass

565

680

566

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

681

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

567

682

self.stop()

568

683

break

569

elif key == u"window resize":

684

elif key == "window resize":

570

685

self.size = self.screen.get_cols_rows()

571

686

self.refresh()

572

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

687

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

573

688

self.refresh()

574

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

689

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

575

690

self.toggle_log_display()

576

691

self.refresh()

577

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

692

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

578

693

self.change_log_display()

579

694

self.refresh()

580

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

695

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

581

696

if not self.log_visible:

582

697

self.log_visible = True

583

698

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

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

600

717

self.refresh()

601

elif key == u"tab":

718

elif key == "tab":

602

719

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

603

720

self.topwidget.set_focus(0)

604

721

else:

605

722

self.topwidget.set_focus(self.logbox)

606

723

self.refresh()

607

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

608

# or key == u">"):

724

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

725

# or key == ">"):

609

726

# pass # xxx end-of-buffer

610

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

611

# or key == u"<"):

727

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

728

# or key == "<"):

612

729

# pass # xxx beginning-of-buffer

613

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

730

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

614

731

# pass # xxx move-end-of-line

615

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

732

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

616

733

# pass # xxx move-beginning-of-line

617

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

734

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

618

735

# pass # xxx left

619

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

736

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

620

737

# pass # xxx right

621

#elif key == u"a":

738

#elif key == "a":

622

739

# pass # scroll up log

623

#elif key == u"z":

740

#elif key == "z":

624

741

# pass # scroll down log

625

742

elif self.topwidget.selectable():

626

743

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

630

747

ui = UserInterface()

631

748

try:

632

749

ui.run()

750

except KeyboardInterrupt:

751

ui.screen.stop()

633

752

except Exception, e:

634

753

ui.log_message(unicode(e))

635

754

ui.screen.stop()