/mandos/trunk : revision 487

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

5

26

6

27

import sys

28

import os

7

29

import signal

8

30

31

import datetime

32

9

33

import urwid.curses_display

10

34

import urwid

11

35

16

40

17

41

import UserList

18

42

43

import locale

44

45

locale.setlocale(locale.LC_ALL, '')

46

47

import logging

48

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

49

19

50

# Some useful constants

20

51

domain = 'se.bsnet.fukt'

21

52

server_interface = domain + '.Mandos'

22

53

client_interface = domain + '.Mandos.Client'

23

version = "1.0.14"

54

version = "1.3.0"

24

55

25

56

# Always run in monochrome mode

26

57

urwid.curses_display.curses.has_colors = lambda : False

30

61

urwid.curses_display.curses.A_UNDERLINE |= (

31

62

urwid.curses_display.curses.A_BLINK)

32

63

64

def isoformat_to_datetime(iso):

65

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

66

if not iso:

67

return None

68

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

69

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

70

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

71

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

72

return datetime.datetime(int(year),

73

int(month),

74

int(day),

75

int(hour),

76

int(minute),

77

int(second), # Whole seconds

78

int(fraction*1000000)) # Microseconds

79

33

80

class MandosClientPropertyCache(object):

34

81

"""This wraps a Mandos Client D-Bus proxy object, caches the

35

82

properties and calls a hook function when any of them are

36

83

changed.

37

84

"""

38

def __init__(self, proxy_object=None, properties=None, *args,

39

**kwargs):

40

# Type conversion mapping

41

self.type_map = {

42

dbus.ObjectPath: unicode,

43

dbus.ByteArray: str,

44

dbus.Signature: unicode,

45

dbus.Byte: chr,

46

dbus.Int16: int,

47

dbus.UInt16: int,

48

dbus.Int32: int,

49

dbus.UInt32: int,

50

dbus.Int64: int,

51

dbus.UInt64: int,

52

dbus.Dictionary: dict,

53

dbus.Array: list,

54

dbus.String: unicode,

55

dbus.Boolean: bool,

56

dbus.Double: float,

57

dbus.Struct: tuple,

58

}

85

def __init__(self, proxy_object=None, *args, **kwargs):

59

86

self.proxy = proxy_object # Mandos Client proxy object

60

87

61

if properties is None:

62

self.properties = dict()

63

else:

64

self.properties = dict(self.convert_property(prop, val)

65

for prop, val in

66

properties.iteritems())

88

self.properties = dict()

67

89

self.proxy.connect_to_signal("PropertyChanged",

68

90

self.property_changed,

69

91

client_interface,

70

92

byte_arrays=True)

71

93

72

if properties is None:

73

self.properties.update(

74

self.convert_property(prop, val)

75

for prop, val in

76

self.proxy.GetAll(client_interface,

77

dbus_interface =

78

dbus.PROPERTIES_IFACE).iteritems())

79

super(MandosClientPropertyCache, self).__init__(

80

proxy_object=proxy_object,

81

properties=properties, *args, **kwargs)

94

self.properties.update(

95

self.proxy.GetAll(client_interface,

96

dbus_interface = dbus.PROPERTIES_IFACE))

97

98

#XXX This break good super behaviour!

99

# super(MandosClientPropertyCache, self).__init__(

100

# *args, **kwargs)

82

101

83

def convert_property(self, property, value):

84

"""This converts the arguments from a D-Bus signal, which are

85

D-Bus types, into normal Python types, using a conversion

86

function from "self.type_map".

87

"""

88

property_name = unicode(property) # Always a dbus.String

89

if isinstance(value, dbus.UTF8String):

90

# Should not happen, but prepare for it anyway

91

value = dbus.String(str(value).decode("utf-8"))

92

try:

93

convfunc = self.type_map[type(value)]

94

except KeyError:

95

# Unknown type, return unmodified

96

return property_name, value

97

return property_name, convfunc(value)

98

102

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

99

103

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

100

104

It updates the changed property in the "properties" dict.

101

105

"""

102

# Convert name and value

103

property_name, cvalue = self.convert_property(property, value)

104

106

# Update properties dict with new value

105

self.properties[property_name] = cvalue

107

self.properties[property] = value

106

108

107

109

108

110

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

110

112

"""

111

113

112

114

def __init__(self, server_proxy_object=None, update_hook=None,

113

delete_hook=None, *args, **kwargs):

115

delete_hook=None, logger=None, *args, **kwargs):

114

116

# Called on update

115

117

self.update_hook = update_hook

116

118

# Called on delete

117

119

self.delete_hook = delete_hook

118

120

# Mandos Server proxy object

119

121

self.server_proxy_object = server_proxy_object

122

# Logger

123

self.logger = logger

124

125

self._update_timer_callback_tag = None

126

self._update_timer_callback_lock = 0

127

self.last_checker_failed = False

120

128

121

129

# The widget shown normally

122

130

self._text_widget = urwid.Text("")

127

135

*args, **kwargs)

128

136

self.update()

129

137

self.opened = False

138

139

last_checked_ok = isoformat_to_datetime(self.properties

140

["LastCheckedOK"])

141

if last_checked_ok is None:

142

self.last_checker_failed = True

143

else:

144

self.last_checker_failed = ((datetime.datetime.utcnow()

145

- last_checked_ok)

146

> datetime.timedelta

147

(milliseconds=

148

self.properties

149

["Interval"]))

150

151

if self.last_checker_failed:

152

self.using_timer(True)

153

154

if self.need_approval:

155

self.using_timer(True)

156

157

self.proxy.connect_to_signal("CheckerCompleted",

158

self.checker_completed,

159

client_interface,

160

byte_arrays=True)

161

self.proxy.connect_to_signal("CheckerStarted",

162

self.checker_started,

163

client_interface,

164

byte_arrays=True)

165

self.proxy.connect_to_signal("GotSecret",

166

self.got_secret,

167

client_interface,

168

byte_arrays=True)

169

self.proxy.connect_to_signal("NeedApproval",

170

self.need_approval,

171

client_interface,

172

byte_arrays=True)

173

self.proxy.connect_to_signal("Rejected",

174

self.rejected,

175

client_interface,

176

byte_arrays=True)

177

178

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

179

super(self, MandosClientWidget).property_changed(property,

180

value)

181

if property == "ApprovalPending":

182

using_timer(bool(value))

183

184

def using_timer(self, flag):

185

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

186

activated or deactivated.

187

"""

188

old = self._update_timer_callback_lock

189

if flag:

190

self._update_timer_callback_lock += 1

191

else:

192

self._update_timer_callback_lock -= 1

193

if old == 0 and self._update_timer_callback_lock:

194

self._update_timer_callback_tag = (gobject.timeout_add

195

(1000,

196

self.update_timer))

197

elif old and self._update_timer_callback_lock == 0:

198

gobject.source_remove(self._update_timer_callback_tag)

199

self._update_timer_callback_tag = None

200

201

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

202

if exitstatus == 0:

203

if self.last_checker_failed:

204

self.last_checker_failed = False

205

self.using_timer(False)

206

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

207

# ' was successful'

208

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

209

self.update()

210

return

211

# Checker failed

212

if not self.last_checker_failed:

213

self.last_checker_failed = True

214

self.using_timer(True)

215

if os.WIFEXITED(condition):

216

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

217

' failed with exit code %s'

218

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

219

os.WEXITSTATUS(condition)))

220

elif os.WIFSIGNALED(condition):

221

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

222

' was killed by signal %s'

223

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

224

os.WTERMSIG(condition)))

225

elif os.WCOREDUMP(condition):

226

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

227

' dumped core'

228

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

229

else:

230

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

231

' mysteriously')

232

self.update()

233

234

def checker_started(self, command):

235

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

236

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

237

pass

238

239

def got_secret(self):

240

self.last_checker_failed = False

241

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

242

% self.properties["Name"])

243

244

def need_approval(self, timeout, default):

245

if not default:

246

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

247

else:

248

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

249

self.logger(message

250

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

251

self.using_timer(True)

252

253

def rejected(self, reason):

254

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

255

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

130

256

131

257

def selectable(self):

132

258

"""Make this a "selectable" widget.

133

259

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

134

260

return True

135

261

136

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

262

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

137

263

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

138

264

whether we have focus or not.

139

265

This overrides the method from urwid.FlowWidget"""

140

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

266

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

141

267

142

268

def current_widget(self, focus=False):

143

269

if focus or self.opened:

147

273

def update(self):

148

274

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

149

275

# How to add standout mode to a style

150

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

151

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

152

u"underline-blink":

153

u"underline-blink-standout",

154

u"bold-underline-blink":

155

u"bold-underline-blink-standout",

276

with_standout = { "normal": "standout",

277

"bold": "bold-standout",

278

"underline-blink":

279

"underline-blink-standout",

280

"bold-underline-blink":

281

"bold-underline-blink-standout",

156

282

}

157

283

158

284

# Rebuild focus and non-focus widgets using current properties

159

self._text = (u'name="%(name)s", enabled=%(enabled)s'

160

% self.properties)

285

286

# Base part of a client. Name!

287

base = ('%(name)s: '

288

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

289

if not self.properties["Enabled"]:

290

message = "DISABLED"

291

elif self.properties["ApprovalPending"]:

292

timeout = datetime.timedelta(milliseconds

293

= self.properties

294

["ApprovalDelay"])

295

last_approval_request = isoformat_to_datetime(

296

self.properties["LastApprovalRequest"])

297

if last_approval_request is not None:

298

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

299

- last_approval_request)

300

else:

301

timer = datetime.timedelta()

302

if self.properties["ApprovedByDefault"]:

303

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

304

else:

305

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

306

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

307

elif self.last_checker_failed:

308

timeout = datetime.timedelta(milliseconds

309

= self.properties

310

["Timeout"])

311

last_ok = isoformat_to_datetime(

312

max((self.properties["LastCheckedOK"]

313

or self.properties["Created"]),

314

self.properties["LastEnabled"]))

315

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

316

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

317

' gets disabled: %s'

318

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

319

else:

320

message = "enabled"

321

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

322

161

323

if not urwid.supports_unicode():

162

324

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

163

textlist = [(u"normal", u"BLÄRGH: "), (u"bold", self._text)]

325

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

164

326

self._text_widget.set_text(textlist)

165

327

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

166

328

text[1])

174

336

if self.update_hook is not None:

175

337

self.update_hook()

176

338

339

def update_timer(self):

340

"called by gobject"

341

self.update()

342

return True # Keep calling this

343

177

344

def delete(self):

345

if self._update_timer_callback_tag is not None:

346

gobject.source_remove(self._update_timer_callback_tag)

347

self._update_timer_callback_tag = None

178

348

if self.delete_hook is not None:

179

349

self.delete_hook(self)

180

350

181

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

351

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

182

352

"""Render differently if we have focus.

183

353

This overrides the method from urwid.FlowWidget"""

184

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

354

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

185

355

focus=focus)

186

356

187

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

357

def keypress(self, maxcolrow, key):

188

358

"""Handle keys.

189

359

This overrides the method from urwid.FlowWidget"""

190

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

191

self.proxy.Enable()

192

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

193

self.proxy.Disable()

194

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

360

if key == "+":

361

self.proxy.Enable(dbus_interface = client_interface,

362

ignore_reply=True)

363

elif key == "-":

364

self.proxy.Disable(dbus_interface = client_interface,

365

ignore_reply=True)

366

elif key == "a":

367

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

368

dbus_interface = client_interface,

369

ignore_reply=True)

370

elif key == "d":

371

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

372

dbus_interface = client_interface,

373

ignore_reply=True)

374

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

195

375

self.server_proxy_object.RemoveClient(self.proxy

196

.object_path)

197

elif key == u"s":

198

self.proxy.StartChecker()

199

elif key == u"c":

200

self.proxy.StopChecker()

201

elif key == u"S":

202

self.proxy.CheckedOK()

376

.object_path,

377

ignore_reply=True)

378

elif key == "s":

379

self.proxy.StartChecker(dbus_interface = client_interface,

380

ignore_reply=True)

381

elif key == "S":

382

self.proxy.StopChecker(dbus_interface = client_interface,

383

ignore_reply=True)

384

elif key == "C":

385

self.proxy.CheckedOK(dbus_interface = client_interface,

386

ignore_reply=True)

203

387

# xxx

204

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

388

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

205

389

# self.proxy.pause()

206

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

390

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

207

391

# self.proxy.unpause()

208

# elif key == u"RET":

392

# elif key == "RET":

209

393

# self.open()

210

394

else:

211

395

return key

222

406

self.update()

223

407

224

408

409

class ConstrainedListBox(urwid.ListBox):

410

"""Like a normal urwid.ListBox, but will consume all "up" or

411

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

412

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

413

"""

414

def keypress(self, maxcolrow, key):

415

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

416

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

417

return

418

return ret

419

420

225

421

class UserInterface(object):

226

422

"""This is the entire user interface - the whole screen

227

423

with boxes, lists of client widgets, etc.

228

424

"""

229

def __init__(self):

230

DBusGMainLoop(set_as_default=True )

425

def __init__(self, max_log_length=1000):

426

DBusGMainLoop(set_as_default=True)

231

427

232

428

self.screen = urwid.curses_display.Screen()

233

429

234

430

self.screen.register_palette((

235

(u"normal",

236

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

237

(u"bold",

238

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

239

(u"underline-blink",

240

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

241

(u"standout",

242

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

243

(u"bold-underline-blink",

244

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

245

(u"bold-standout",

246

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

247

(u"underline-blink-standout",

248

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

249

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

250

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

251

u"standout")),

431

("normal",

432

"default", "default", None),

433

("bold",

434

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

435

("underline-blink",

436

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

437

("standout",

438

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

439

("bold-underline-blink",

440

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

441

("bold-standout",

442

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

443

("underline-blink-standout",

444

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

445

("bold-underline-blink-standout",

446

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

447

"standout")),

252

448

))

253

449

450

if urwid.supports_unicode():

451

self.divider = "─" # \u2500

452

#self.divider = "━" # \u2501

453

else:

454

#self.divider = "-" # \u002d

455

self.divider = "_" # \u005f

456

254

457

self.screen.start()

255

458

256

459

self.size = self.screen.get_cols_rows()

257

460

258

461

self.clients = urwid.SimpleListWalker([])

259

462

self.clients_dict = {}

260

self.topwidget = urwid.LineBox(urwid.ListBox(self.clients))

261

#self.topwidget = urwid.ListBox(clients)

463

464

# We will add Text widgets to this list

465

self.log = []

466

self.max_log_length = max_log_length

467

468

# We keep a reference to the log widget so we can remove it

469

# from the ListWalker without it getting destroyed

470

self.logbox = ConstrainedListBox(self.log)

471

472

# This keeps track of whether self.uilist currently has

473

# self.logbox in it or not

474

self.log_visible = True

475

self.log_wrap = "any"

476

477

self.rebuild()

478

self.log_message_raw(("bold",

479

"Mandos Monitor version " + version))

480

self.log_message_raw(("bold",

481

"q: Quit ?: Help"))

262

482

263

483

self.busname = domain + '.Mandos'

264

484

self.main_loop = gobject.MainLoop()

265

485

self.bus = dbus.SystemBus()

266

486

mandos_dbus_objc = self.bus.get_object(

267

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

487

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

268

488

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

269

489

dbus_interface

270

490

= server_interface)

284

504

self.add_new_client,

285

505

dbus_interface=server_interface,

286

506

byte_arrays=True))

287

for path, client in (mandos_clients.iteritems()):

507

(self.mandos_serv

508

.connect_to_signal("ClientNotFound",

509

self.client_not_found,

510

dbus_interface=server_interface,

511

byte_arrays=True))

512

for path, client in mandos_clients.iteritems():

288

513

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

289

514

path)

290

515

self.add_client(MandosClientWidget(server_proxy_object

295

520

update_hook

296

521

=self.refresh,

297

522

delete_hook

298

=self.remove_client),

523

=self.remove_client,

524

logger

525

=self.log_message),

299

526

path=path)

300

527

528

def client_not_found(self, fingerprint, address):

529

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

530

" could not be found" % (address,

531

fingerprint)))

532

533

def rebuild(self):

534

"""This rebuilds the User Interface.

535

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

536

self.uilist = []

537

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

538

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

539

clients),

540

#header=urwid.Divider(),

541

header=None,

542

footer=

543

urwid.Divider(div_char=

544

self.divider)))

545

if self.log_visible:

546

self.uilist.append(self.logbox)

547

pass

548

self.topwidget = urwid.Pile(self.uilist)

549

550

def log_message(self, message):

551

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

552

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

553

554

def log_message_raw(self, markup):

555

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

556

self.log.append(urwid.Text(markup, wrap=self.log_wrap))

557

if (self.max_log_length

558

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

559

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

560

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

561

coming_from="above")

562

self.refresh()

563

564

def toggle_log_display(self):

565

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

566

self.log_visible = not self.log_visible

567

self.rebuild()

568

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

569

# + unicode(self.log_visible))

570

571

def change_log_display(self):

572

"""Change type of log display.

573

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

574

if self.log_wrap == "clip":

575

self.log_wrap = "any"

576

else:

577

self.log_wrap = "clip"

578

for textwidget in self.log:

579

textwidget.set_wrap_mode(self.log_wrap)

580

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

581

301

582

def find_and_remove_client(self, path, name):

302

583

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

303

584

310

591

return

311

592

self.remove_client(client, path)

312

593

313

def add_new_client(self, path, properties):

594

def add_new_client(self, path):

314

595

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

315

596

self.add_client(MandosClientWidget(server_proxy_object

316

597

=self.mandos_serv,

317

598

proxy_object

318

599

=client_proxy_object,

319

properties=properties,

320

600

update_hook

321

601

=self.refresh,

322

602

delete_hook

323

=self.remove_client),

603

=self.remove_client,

604

logger

605

=self.log_message),

324

606

path=path)

325

607

326

608

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

328

610

if path is None:

329

611

path = client.proxy.object_path

330

612

self.clients_dict[path] = client

331

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

613

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

332

614

self.refresh()

333

615

334

616

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

336

618

if path is None:

337

619

path = client.proxy.object_path

338

620

del self.clients_dict[path]

621

if not self.clients_dict:

622

# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker

623

# is completely emptied, we need to recreate it.

624

self.clients = urwid.SimpleListWalker([])

625

self.rebuild()

339

626

self.refresh()

340

627

341

628

def refresh(self):

360

647

361

648

def process_input(self, source, condition):

362

649

keys = self.screen.get_input()

363

translations = { u"j": u"down",

364

u"k": u"up",

650

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

651

"ctrl p": "up", # Emacs

652

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

653

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

654

" ": "page down", # less

655

"f": "page down", # less

656

"b": "page up", # less

657

"j": "down", # vi

658

"k": "up", # vi

365

659

}

366

660

for key in keys:

367

661

try:

369

663

except KeyError: # :-)

370

664

pass

371

665

372

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

666

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

373

667

self.stop()

374

668

break

375

elif key == u"window resize":

669

elif key == "window resize":

376

670

self.size = self.screen.get_cols_rows()

377

671

self.refresh()

378

elif key == "":

379

self.refresh()

672

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

673

self.refresh()

674

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

675

self.toggle_log_display()

676

self.refresh()

677

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

678

self.change_log_display()

679

self.refresh()

680

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

681

if not self.log_visible:

682

self.log_visible = True

683

self.rebuild()

684

self.log_message_raw(("bold",

685

" ".

686

join(("q: Quit",

687

"?: Help",

688

"l: Log window toggle",

689

"TAB: Switch window",

690

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

691

self.log_message_raw(("bold",

692

" "

693

.join(("Clients:",

694

"+: Enable",

695

"-: Disable",

696

"R: Remove",

697

"s: Start new checker",

698

"S: Stop checker",

699

"C: Checker OK",

700

"a: Approve",

701

"d: Deny"))))

702

self.refresh()

703

elif key == "tab":

704

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

705

self.topwidget.set_focus(0)

706

else:

707

self.topwidget.set_focus(self.logbox)

708

self.refresh()

709

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

710

# or key == ">"):

711

# pass # xxx end-of-buffer

712

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

713

# or key == "<"):

714

# pass # xxx beginning-of-buffer

715

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

716

# pass # xxx move-end-of-line

717

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

718

# pass # xxx move-beginning-of-line

719

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

720

# pass # xxx left

721

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

722

# pass # xxx right

723

#elif key == "a":

724

# pass # scroll up log

725

#elif key == "z":

726

# pass # scroll down log

380

727

elif self.topwidget.selectable():

381

728

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

382

729

self.refresh()

385

732

ui = UserInterface()

386

733

try:

387

734

ui.run()

388

except:

735

except KeyboardInterrupt:

736

ui.screen.stop()

737

except Exception, e:

738

ui.log_message(unicode(e))

389

739

ui.screen.stop()

390

740

raise