/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

7

28

import os

21

42

22

43

import locale

23

44

24

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

45

locale.setlocale(locale.LC_ALL, '')

46

47

import logging

48

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

25

49

26

50

# Some useful constants

27

51

domain = 'se.bsnet.fukt'

28

52

server_interface = domain + '.Mandos'

29

53

client_interface = domain + '.Mandos.Client'

30

version = "1.0.14"

54

version = "1.3.0"

31

55

32

56

# Always run in monochrome mode

33

57

urwid.curses_display.curses.has_colors = lambda : False

41

65

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

42

66

if not iso:

43

67

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)

68

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

69

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

70

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

47

71

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

48

72

return datetime.datetime(int(year),

49

73

int(month),

62

86

self.proxy = proxy_object # Mandos Client proxy object

63

87

64

88

self.properties = dict()

65

self.proxy.connect_to_signal(u"PropertyChanged",

89

self.proxy.connect_to_signal("PropertyChanged",

66

90

self.property_changed,

67

91

client_interface,

68

92

byte_arrays=True)

70

94

self.properties.update(

71

95

self.proxy.GetAll(client_interface,

72

96

dbus_interface = dbus.PROPERTIES_IFACE))

73

super(MandosClientPropertyCache, self).__init__(

74

proxy_object=proxy_object, *args, **kwargs)

97

98

#XXX This break good super behaviour!

99

# super(MandosClientPropertyCache, self).__init__(

100

# *args, **kwargs)

75

101

76

102

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

77

103

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

97

123

self.logger = logger

98

124

99

125

self._update_timer_callback_tag = None

126

self._update_timer_callback_lock = 0

100

127

self.last_checker_failed = False

101

128

102

129

# The widget shown normally

103

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

130

self._text_widget = urwid.Text("")

104

131

# The widget shown when we have focus

105

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

132

self._focus_text_widget = urwid.Text("")

106

133

super(MandosClientWidget, self).__init__(

107

134

update_hook=update_hook, delete_hook=delete_hook,

108

135

*args, **kwargs)

109

136

self.update()

110

137

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)

138

127

139

last_checked_ok = isoformat_to_datetime(self.properties

128

["last_checked_ok"])

140

["LastCheckedOK"])

129

141

if last_checked_ok is None:

130

142

self.last_checker_failed = True

131

143

else:

133

145

- last_checked_ok)

134

146

> datetime.timedelta

135

147

(milliseconds=

136

self.properties["interval"]))

148

self.properties

149

["Interval"]))

150

137

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:

138

194

self._update_timer_callback_tag = (gobject.timeout_add

139

195

(1000,

140

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

141

200

142

201

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

143

202

if exitstatus == 0:

144

203

if self.last_checker_failed:

145

204

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

205

self.using_timer(False)

206

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

207

# ' was successful'

208

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

151

209

self.update()

152

210

return

153

211

# Checker failed

154

212

if not self.last_checker_failed:

155

213

self.last_checker_failed = True

156

self._update_timer_callback_tag = (gobject.timeout_add

157

(1000,

158

self.update_timer))

214

self.using_timer(True)

159

215

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,

216

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

217

' failed with exit code %s'

218

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

163

219

os.WEXITSTATUS(condition)))

164

220

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,

221

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

222

' was killed by signal %s'

223

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

168

224

os.WTERMSIG(condition)))

169

225

elif os.WCOREDUMP(condition):

170

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

171

u' dumped core'

172

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

226

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

227

' dumped core'

228

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

173

229

else:

174

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

230

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

231

' mysteriously')

175

232

self.update()

176

233

177

234

def checker_started(self, command):

178

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

179

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

235

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

236

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

237

pass

180

238

181

239

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

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

188

256

189

257

def selectable(self):

190

258

"""Make this a "selectable" widget.

191

259

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

192

260

return True

193

261

194

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

262

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

195

263

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

196

264

whether we have focus or not.

197

265

This overrides the method from urwid.FlowWidget"""

198

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

266

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

199

267

200

268

def current_widget(self, focus=False):

201

269

if focus or self.opened:

205

273

def update(self):

206

274

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

207

275

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

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

214

282

}

215

283

216

284

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

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

240

323

if not urwid.supports_unicode():

241

324

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

242

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

325

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

243

326

self._text_widget.set_text(textlist)

244

327

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

245

328

text[1])

265

348

if self.delete_hook is not None:

266

349

self.delete_hook(self)

267

350

268

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

351

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

269

352

"""Render differently if we have focus.

270

353

This overrides the method from urwid.FlowWidget"""

271

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

354

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

272

355

focus=focus)

273

356

274

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

357

def keypress(self, maxcolrow, key):

275

358

"""Handle keys.

276

359

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

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

282

375

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

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)

290

387

# xxx

291

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

388

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

292

389

# self.proxy.pause()

293

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

390

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

294

391

# self.proxy.unpause()

295

# elif key == u"RET":

392

# elif key == "RET":

296

393

# self.open()

297

394

else:

298

395

return key

314

411

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

315

412

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

316

413

"""

317

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

318

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

319

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

414

def keypress(self, maxcolrow, key):

415

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

416

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

320

417

return

321

418

return ret

322

419

331

428

self.screen = urwid.curses_display.Screen()

332

429

333

430

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

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

351

448

))

352

449

353

450

if urwid.supports_unicode():

354

self.divider = u"─" # \u2500

355

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

451

self.divider = "─" # \u2500

452

#self.divider = "━" # \u2501

356

453

else:

357

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

358

self.divider = u"_" # \u005f

454

#self.divider = "-" # \u002d

455

self.divider = "_" # \u005f

359

456

360

457

self.screen.start()

361

458

375

472

# This keeps track of whether self.uilist currently has

376

473

# self.logbox in it or not

377

474

self.log_visible = True

378

self.log_wrap = u"any"

475

self.log_wrap = "any"

379

476

380

477

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

478

self.log_message_raw(("bold",

479

"Mandos Monitor version " + version))

480

self.log_message_raw(("bold",

481

"q: Quit ?: Help"))

385

482

386

483

self.busname = domain + '.Mandos'

387

484

self.main_loop = gobject.MainLoop()

388

485

self.bus = dbus.SystemBus()

389

486

mandos_dbus_objc = self.bus.get_object(

390

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

487

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

391

488

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

392

489

dbus_interface

393

490

= server_interface)

398

495

mandos_clients = dbus.Dictionary()

399

496

400

497

(self.mandos_serv

401

.connect_to_signal(u"ClientRemoved",

498

.connect_to_signal("ClientRemoved",

402

499

self.find_and_remove_client,

403

500

dbus_interface=server_interface,

404

501

byte_arrays=True))

405

502

(self.mandos_serv

406

.connect_to_signal(u"ClientAdded",

503

.connect_to_signal("ClientAdded",

407

504

self.add_new_client,

408

505

dbus_interface=server_interface,

409

506

byte_arrays=True))

410

507

(self.mandos_serv

411

.connect_to_signal(u"ClientNotFound",

508

.connect_to_signal("ClientNotFound",

412

509

self.client_not_found,

413

510

dbus_interface=server_interface,

414

511

byte_arrays=True))

429

526

path=path)

430

527

431

528

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,

529

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

530

" could not be found" % (address,

434

531

fingerprint)))

435

532

436

533

def rebuild(self):

438

535

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

439

536

self.uilist = []

440

537

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

441

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

538

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

539

clients),

442

540

#header=urwid.Divider(),

443

541

header=None,

444

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

542

footer=

543

urwid.Divider(div_char=

544

self.divider)))

445

545

if self.log_visible:

446

546

self.uilist.append(self.logbox)

447

547

pass

449

549

450

550

def log_message(self, message):

451

551

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

452

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

552

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

453

553

454

554

def log_message_raw(self, markup):

455

555

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

458

558

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

459

559

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

460

560

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

461

coming_from=u"above")

561

coming_from="above")

462

562

self.refresh()

463

563

464

564

def toggle_log_display(self):

465

565

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

466

566

self.log_visible = not self.log_visible

467

567

self.rebuild()

468

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

469

+ unicode(self.log_visible))

568

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

569

# + unicode(self.log_visible))

470

570

471

571

def change_log_display(self):

472

572

"""Change type of log display.

473

573

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

474

if self.log_wrap == u"clip":

475

self.log_wrap = u"any"

574

if self.log_wrap == "clip":

575

self.log_wrap = "any"

476

576

else:

477

self.log_wrap = u"clip"

577

self.log_wrap = "clip"

478

578

for textwidget in self.log:

479

579

textwidget.set_wrap_mode(self.log_wrap)

480

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

580

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

481

581

482

582

def find_and_remove_client(self, path, name):

483

583

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

510

610

if path is None:

511

611

path = client.proxy.object_path

512

612

self.clients_dict[path] = client

513

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

613

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

514

614

self.refresh()

515

615

516

616

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

547

647

548

648

def process_input(self, source, condition):

549

649

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

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

559

659

}

560

660

for key in keys:

561

661

try:

563

663

except KeyError: # :-)

564

664

pass

565

665

566

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

666

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

567

667

self.stop()

568

668

break

569

elif key == u"window resize":

669

elif key == "window resize":

570

670

self.size = self.screen.get_cols_rows()

571

671

self.refresh()

572

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

672

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

573

673

self.refresh()

574

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

674

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

575

675

self.toggle_log_display()

576

676

self.refresh()

577

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

677

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

578

678

self.change_log_display()

579

679

self.refresh()

580

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

680

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

581

681

if not self.log_visible:

582

682

self.log_visible = True

583

683

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

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

600

702

self.refresh()

601

elif key == u"tab":

703

elif key == "tab":

602

704

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

603

705

self.topwidget.set_focus(0)

604

706

else:

605

707

self.topwidget.set_focus(self.logbox)

606

708

self.refresh()

607

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

608

# or key == u">"):

709

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

710

# or key == ">"):

609

711

# pass # xxx end-of-buffer

610

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

611

# or key == u"<"):

712

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

713

# or key == "<"):

612

714

# pass # xxx beginning-of-buffer

613

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

715

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

614

716

# pass # xxx move-end-of-line

615

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

717

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

616

718

# pass # xxx move-beginning-of-line

617

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

719

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

618

720

# pass # xxx left

619

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

721

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

620

722

# pass # xxx right

621

#elif key == u"a":

723

#elif key == "a":

622

724

# pass # scroll up log

623

#elif key == u"z":

725

#elif key == "z":

624

726

# pass # scroll down log

625

727

elif self.topwidget.selectable():

626

728

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

630

732

ui = UserInterface()

631

733

try:

632

734

ui.run()

735

except KeyboardInterrupt:

736

ui.screen.stop()

633

737

except Exception, e:

634

738

ui.log_message(unicode(e))

635

739

ui.screen.stop()