/mandos/release : revision 237.2.182

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

#

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

47

48

import logging

49

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

24

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

50

25

51

26

# Some useful constants

52

27

domain = 'se.bsnet.fukt'

53

28

server_interface = domain + '.Mandos'

54

29

client_interface = domain + '.Mandos.Client'

55

version = "1.3.1"

30

version = "1.0.14"

56

31

57

32

# Always run in monochrome mode

58

33

urwid.curses_display.curses.has_colors = lambda : False

66

41

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

67

42

if not iso:

68

43

return None

69

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

70

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

71

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

44

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

45

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

46

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

72

47

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

73

48

return datetime.datetime(int(year),

74

49

int(month),

87

62

self.proxy = proxy_object # Mandos Client proxy object

88

63

89

64

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

65

self.proxy.connect_to_signal(u"PropertyChanged",

66

self.property_changed,

67

client_interface,

68

byte_arrays=True)

95

69

96

70

self.properties.update(

97

71

self.proxy.GetAll(client_interface,

98

72

dbus_interface = dbus.PROPERTIES_IFACE))

99

100

#XXX This breaks good super behaviour

101

# super(MandosClientPropertyCache, self).__init__(

102

# *args, **kwargs)

73

super(MandosClientPropertyCache, self).__init__(

74

proxy_object=proxy_object, *args, **kwargs)

103

75

104

76

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

105

77

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

107

79

"""

108

80

# Update properties dict with new value

109

81

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

82

116

83

117

84

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

130

97

self.logger = logger

131

98

132

99

self._update_timer_callback_tag = None

133

self._update_timer_callback_lock = 0

134

100

self.last_checker_failed = False

135

101

136

102

# The widget shown normally

137

self._text_widget = urwid.Text("")

103

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

138

104

# The widget shown when we have focus

139

self._focus_text_widget = urwid.Text("")

105

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

140

106

super(MandosClientWidget, self).__init__(

141

107

update_hook=update_hook, delete_hook=delete_hook,

142

108

*args, **kwargs)

143

109

self.update()

144

110

self.opened = False

145

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)

146

127

last_checked_ok = isoformat_to_datetime(self.properties

147

["LastCheckedOK"])

128

["last_checked_ok"])

148

129

if last_checked_ok is None:

149

130

self.last_checker_failed = True

150

131

else:

152

133

- last_checked_ok)

153

134

> datetime.timedelta

154

135

(milliseconds=

155

self.properties

156

["Interval"]))

157

136

self.properties["interval"]))

158

137

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

138

self._update_timer_callback_tag = (gobject.timeout_add

204

139

(1000,

205

140

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

209

141

210

142

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

211

143

if exitstatus == 0:

212

144

if self.last_checker_failed:

213

145

self.last_checker_failed = False

214

self.using_timer(False)

215

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

216

# ' was successful'

217

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

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

218

151

self.update()

219

152

return

220

153

# Checker failed

221

154

if not self.last_checker_failed:

222

155

self.last_checker_failed = True

223

self.using_timer(True)

156

self._update_timer_callback_tag = (gobject.timeout_add

157

(1000,

158

self.update_timer))

224

159

if os.WIFEXITED(condition):

225

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

226

' failed with exit code %s'

227

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

160

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

161

u' failed with exit code %s'

162

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

228

163

os.WEXITSTATUS(condition)))

229

164

elif os.WIFSIGNALED(condition):

230

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

231

' was killed by signal %s'

232

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

165

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

166

u' was killed by signal %s'

167

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

233

168

os.WTERMSIG(condition)))

234

169

elif os.WCOREDUMP(condition):

235

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

236

' dumped core'

237

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

170

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

171

u' dumped core'

172

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

238

173

else:

239

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

240

' mysteriously')

174

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

241

175

self.update()

242

176

243

177

def checker_started(self, command):

244

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

245

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

246

pass

178

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

179

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

247

180

248

181

def got_secret(self):

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

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

265

188

266

189

def selectable(self):

267

190

"""Make this a "selectable" widget.

268

191

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

269

192

return True

270

193

271

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

194

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

272

195

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

273

196

whether we have focus or not.

274

197

This overrides the method from urwid.FlowWidget"""

275

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

198

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

276

199

277

200

def current_widget(self, focus=False):

278

201

if focus or self.opened:

282

205

def update(self):

283

206

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

284

207

# How to add standout mode to a style

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

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

291

214

}

292

215

293

216

# Rebuild focus and non-focus widgets using current properties

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

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

332

240

if not urwid.supports_unicode():

333

241

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

334

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

242

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

335

243

self._text_widget.set_text(textlist)

336

244

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

337

245

text[1])

350

258

self.update()

351

259

return True # Keep calling this

352

260

353

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

261

def delete(self):

354

262

if self._update_timer_callback_tag is not None:

355

263

gobject.source_remove(self._update_timer_callback_tag)

356

264

self._update_timer_callback_tag = None

357

for match in self.match_objects:

358

match.remove()

359

self.match_objects = ()

360

265

if self.delete_hook is not None:

361

266

self.delete_hook(self)

362

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

363

267

364

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

268

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

365

269

"""Render differently if we have focus.

366

270

This overrides the method from urwid.FlowWidget"""

367

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

271

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

368

272

focus=focus)

369

273

370

def keypress(self, maxcolrow, key):

274

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

371

275

"""Handle keys.

372

276

This overrides the method from urwid.FlowWidget"""

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

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

388

282

self.server_proxy_object.RemoveClient(self.proxy

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)

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

400

290

# xxx

401

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

291

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

402

292

# self.proxy.pause()

403

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

293

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

404

294

# self.proxy.unpause()

405

# elif key == "RET":

295

# elif key == u"RET":

406

296

# self.open()

407

297

else:

408

298

return key

424

314

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

425

315

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

426

316

"""

427

def keypress(self, maxcolrow, key):

428

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

429

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

317

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

318

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

319

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

430

320

return

431

321

return ret

432

322

441

331

self.screen = urwid.curses_display.Screen()

442

332

443

333

self.screen.register_palette((

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

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

461

351

))

462

352

463

353

if urwid.supports_unicode():

464

self.divider = "─" # \u2500

465

#self.divider = "━" # \u2501

354

self.divider = u"─" # \u2500

355

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

466

356

else:

467

#self.divider = "-" # \u002d

468

self.divider = "_" # \u005f

357

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

358

self.divider = u"_" # \u005f

469

359

470

360

self.screen.start()

471

361

485

375

# This keeps track of whether self.uilist currently has

486

376

# self.logbox in it or not

487

377

self.log_visible = True

488

self.log_wrap = "any"

378

self.log_wrap = u"any"

489

379

490

380

self.rebuild()

491

self.log_message_raw(("bold",

492

"Mandos Monitor version " + version))

493

self.log_message_raw(("bold",

494

"q: Quit ?: Help"))

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

495

385

496

386

self.busname = domain + '.Mandos'

497

387

self.main_loop = gobject.MainLoop()

498

388

self.bus = dbus.SystemBus()

499

389

mandos_dbus_objc = self.bus.get_object(

500

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

390

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

501

391

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

502

392

dbus_interface

503

393

= server_interface)

508

398

mandos_clients = dbus.Dictionary()

509

399

510

400

(self.mandos_serv

511

.connect_to_signal("ClientRemoved",

401

.connect_to_signal(u"ClientRemoved",

512

402

self.find_and_remove_client,

513

403

dbus_interface=server_interface,

514

404

byte_arrays=True))

515

405

(self.mandos_serv

516

.connect_to_signal("ClientAdded",

406

.connect_to_signal(u"ClientAdded",

517

407

self.add_new_client,

518

408

dbus_interface=server_interface,

519

409

byte_arrays=True))

520

410

(self.mandos_serv

521

.connect_to_signal("ClientNotFound",

411

.connect_to_signal(u"ClientNotFound",

522

412

self.client_not_found,

523

413

dbus_interface=server_interface,

524

414

byte_arrays=True))

539

429

path=path)

540

430

541

431

def client_not_found(self, fingerprint, address):

542

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

543

" could not be found" % (address,

432

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

433

u" could not be found" % (address,

544

434

fingerprint)))

545

435

546

436

def rebuild(self):

548

438

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

549

439

self.uilist = []

550

440

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

551

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

552

clients),

441

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

553

442

#header=urwid.Divider(),

554

443

header=None,

555

footer=

556

urwid.Divider(div_char=

557

self.divider)))

444

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

558

445

if self.log_visible:

559

446

self.uilist.append(self.logbox)

560

447

pass

562

449

563

450

def log_message(self, message):

564

451

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

565

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

452

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

566

453

567

454

def log_message_raw(self, markup):

568

455

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

571

458

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

572

459

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

573

460

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

574

coming_from="above")

461

coming_from=u"above")

575

462

self.refresh()

576

463

577

464

def toggle_log_display(self):

578

465

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

579

466

self.log_visible = not self.log_visible

580

467

self.rebuild()

581

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

582

# + unicode(self.log_visible))

468

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

469

+ unicode(self.log_visible))

583

470

584

471

def change_log_display(self):

585

472

"""Change type of log display.

586

473

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

587

if self.log_wrap == "clip":

588

self.log_wrap = "any"

474

if self.log_wrap == u"clip":

475

self.log_wrap = u"any"

589

476

else:

590

self.log_wrap = "clip"

477

self.log_wrap = u"clip"

591

478

for textwidget in self.log:

592

479

textwidget.set_wrap_mode(self.log_wrap)

593

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

480

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

594

481

595

482

def find_and_remove_client(self, path, name):

596

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

483

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

597

484

598

485

This is connected to the ClientRemoved signal from the

599

486

Mandos server object."""

601

488

client = self.clients_dict[path]

602

489

except KeyError:

603

490

# not found?

604

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

605

path)

606

491

return

607

client.delete()

492

self.remove_client(client, path)

608

493

609

494

def add_new_client(self, path):

610

495

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

625

510

if path is None:

626

511

path = client.proxy.object_path

627

512

self.clients_dict[path] = client

628

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

513

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

629

514

self.refresh()

630

515

631

516

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

662

547

663

548

def process_input(self, source, condition):

664

549

keys = self.screen.get_input()

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

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

674

559

}

675

560

for key in keys:

676

561

try:

678

563

except KeyError: # :-)

679

564

pass

680

565

681

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

566

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

682

567

self.stop()

683

568

break

684

elif key == "window resize":

569

elif key == u"window resize":

685

570

self.size = self.screen.get_cols_rows()

686

571

self.refresh()

687

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

572

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

688

573

self.refresh()

689

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

574

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

690

575

self.toggle_log_display()

691

576

self.refresh()

692

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

577

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

693

578

self.change_log_display()

694

579

self.refresh()

695

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

580

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

696

581

if not self.log_visible:

697

582

self.log_visible = True

698

583

self.rebuild()

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

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

717

600

self.refresh()

718

elif key == "tab":

601

elif key == u"tab":

719

602

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

720

603

self.topwidget.set_focus(0)

721

604

else:

722

605

self.topwidget.set_focus(self.logbox)

723

606

self.refresh()

724

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

725

# or key == ">"):

607

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

608

# or key == u">"):

726

609

# pass # xxx end-of-buffer

727

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

728

# or key == "<"):

610

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

611

# or key == u"<"):

729

612

# pass # xxx beginning-of-buffer

730

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

613

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

731

614

# pass # xxx move-end-of-line

732

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

615

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

733

616

# pass # xxx move-beginning-of-line

734

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

617

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

735

618

# pass # xxx left

736

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

619

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

737

620

# pass # xxx right

738

#elif key == "a":

621

#elif key == u"a":

739

622

# pass # scroll up log

740

#elif key == "z":

623

#elif key == u"z":

741

624

# pass # scroll down log

742

625

elif self.topwidget.selectable():

743

626

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

747

630

ui = UserInterface()

748

631

try:

749

632

ui.run()

750

except KeyboardInterrupt:

751

ui.screen.stop()

752

633

except Exception, e:

753

634

ui.log_message(unicode(e))

754

635

ui.screen.stop()