/mandos/trunk : revision 419

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

4

from __future__ import division, absolute_import, with_statement

26

5

27

6

import sys

28

7

import os

42

21

43

22

import locale

44

23

45

locale.setlocale(locale.LC_ALL, '')

46

47

import logging

48

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

24

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

49

25

50

26

# Some useful constants

51

27

domain = 'se.bsnet.fukt'

52

28

server_interface = domain + '.Mandos'

53

29

client_interface = domain + '.Mandos.Client'

54

version = "1.3.0"

30

version = "1.0.14"

55

31

56

32

# Always run in monochrome mode

57

33

urwid.curses_display.curses.has_colors = lambda : False

65

41

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

66

42

if not iso:

67

43

return None

68

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

69

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

70

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)

71

47

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

72

48

return datetime.datetime(int(year),

73

49

int(month),

86

62

self.proxy = proxy_object # Mandos Client proxy object

87

63

88

64

self.properties = dict()

89

self.proxy.connect_to_signal("PropertyChanged",

65

self.proxy.connect_to_signal(u"PropertyChanged",

90

66

self.property_changed,

91

67

client_interface,

92

68

byte_arrays=True)

94

70

self.properties.update(

95

71

self.proxy.GetAll(client_interface,

96

72

dbus_interface = dbus.PROPERTIES_IFACE))

97

98

#XXX This break good super behaviour!

99

# super(MandosClientPropertyCache, self).__init__(

100

# *args, **kwargs)

73

super(MandosClientPropertyCache, self).__init__(

74

proxy_object=proxy_object, *args, **kwargs)

101

75

102

76

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

103

77

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

123

97

self.logger = logger

124

98

125

99

self._update_timer_callback_tag = None

126

self._update_timer_callback_lock = 0

127

100

self.last_checker_failed = False

128

101

129

102

# The widget shown normally

130

self._text_widget = urwid.Text("")

103

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

131

104

# The widget shown when we have focus

132

self._focus_text_widget = urwid.Text("")

105

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

133

106

super(MandosClientWidget, self).__init__(

134

107

update_hook=update_hook, delete_hook=delete_hook,

135

108

*args, **kwargs)

136

109

self.update()

137

110

self.opened = False

138

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)

139

127

last_checked_ok = isoformat_to_datetime(self.properties

140

["LastCheckedOK"])

128

["last_checked_ok"])

141

129

if last_checked_ok is None:

142

130

self.last_checker_failed = True

143

131

else:

145

133

- last_checked_ok)

146

134

> datetime.timedelta

147

135

(milliseconds=

148

self.properties

149

["Interval"]))

150

136

self.properties["interval"]))

151

137

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

138

self._update_timer_callback_tag = (gobject.timeout_add

195

139

(1000,

196

140

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

141

201

142

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

202

143

if exitstatus == 0:

203

144

if self.last_checker_failed:

204

145

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

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

209

151

self.update()

210

152

return

211

153

# Checker failed

212

154

if not self.last_checker_failed:

213

155

self.last_checker_failed = True

214

self.using_timer(True)

156

self._update_timer_callback_tag = (gobject.timeout_add

157

(1000,

158

self.update_timer))

215

159

if os.WIFEXITED(condition):

216

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

217

' failed with exit code %s'

218

% (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,

219

163

os.WEXITSTATUS(condition)))

220

164

elif os.WIFSIGNALED(condition):

221

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

222

' was killed by signal %s'

223

% (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,

224

168

os.WTERMSIG(condition)))

225

169

elif os.WCOREDUMP(condition):

226

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

227

' dumped core'

228

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

170

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

171

u' dumped core'

172

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

229

173

else:

230

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

231

' mysteriously')

174

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

232

175

self.update()

233

176

234

177

def checker_started(self, command):

235

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

236

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

237

pass

178

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

179

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

238

180

239

181

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

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

256

188

257

189

def selectable(self):

258

190

"""Make this a "selectable" widget.

259

191

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

260

192

return True

261

193

262

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

194

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

263

195

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

264

196

whether we have focus or not.

265

197

This overrides the method from urwid.FlowWidget"""

266

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

198

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

267

199

268

200

def current_widget(self, focus=False):

269

201

if focus or self.opened:

273

205

def update(self):

274

206

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

275

207

# How to add standout mode to a style

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

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

282

214

}

283

215

284

216

# Rebuild focus and non-focus widgets using current 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

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

323

240

if not urwid.supports_unicode():

324

241

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

325

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

242

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

326

243

self._text_widget.set_text(textlist)

327

244

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

328

245

text[1])

348

265

if self.delete_hook is not None:

349

266

self.delete_hook(self)

350

267

351

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

268

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

352

269

"""Render differently if we have focus.

353

270

This overrides the method from urwid.FlowWidget"""

354

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

271

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

355

272

focus=focus)

356

273

357

def keypress(self, maxcolrow, key):

274

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

358

275

"""Handle keys.

359

276

This overrides the method from urwid.FlowWidget"""

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

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

375

282

self.server_proxy_object.RemoveClient(self.proxy

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)

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

387

290

# xxx

388

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

291

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

389

292

# self.proxy.pause()

390

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

293

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

391

294

# self.proxy.unpause()

392

# elif key == "RET":

295

# elif key == u"RET":

393

296

# self.open()

394

297

else:

395

298

return key

411

314

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

412

315

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

413

316

"""

414

def keypress(self, maxcolrow, key):

415

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

416

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

417

320

return

418

321

return ret

419

322

428

331

self.screen = urwid.curses_display.Screen()

429

332

430

333

self.screen.register_palette((

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

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

448

351

))

449

352

450

353

if urwid.supports_unicode():

451

self.divider = "─" # \u2500

452

#self.divider = "━" # \u2501

354

self.divider = u"─" # \u2500

355

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

453

356

else:

454

#self.divider = "-" # \u002d

455

self.divider = "_" # \u005f

357

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

358

self.divider = u"_" # \u005f

456

359

457

360

self.screen.start()

458

361

472

375

# This keeps track of whether self.uilist currently has

473

376

# self.logbox in it or not

474

377

self.log_visible = True

475

self.log_wrap = "any"

378

self.log_wrap = u"any"

476

379

477

380

self.rebuild()

478

self.log_message_raw(("bold",

479

"Mandos Monitor version " + version))

480

self.log_message_raw(("bold",

481

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

482

385

483

386

self.busname = domain + '.Mandos'

484

387

self.main_loop = gobject.MainLoop()

485

388

self.bus = dbus.SystemBus()

486

389

mandos_dbus_objc = self.bus.get_object(

487

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

390

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

488

391

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

489

392

dbus_interface

490

393

= server_interface)

495

398

mandos_clients = dbus.Dictionary()

496

399

497

400

(self.mandos_serv

498

.connect_to_signal("ClientRemoved",

401

.connect_to_signal(u"ClientRemoved",

499

402

self.find_and_remove_client,

500

403

dbus_interface=server_interface,

501

404

byte_arrays=True))

502

405

(self.mandos_serv

503

.connect_to_signal("ClientAdded",

406

.connect_to_signal(u"ClientAdded",

504

407

self.add_new_client,

505

408

dbus_interface=server_interface,

506

409

byte_arrays=True))

507

410

(self.mandos_serv

508

.connect_to_signal("ClientNotFound",

411

.connect_to_signal(u"ClientNotFound",

509

412

self.client_not_found,

510

413

dbus_interface=server_interface,

511

414

byte_arrays=True))

526

429

path=path)

527

430

528

431

def client_not_found(self, fingerprint, address):

529

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

530

" could not be found" % (address,

432

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

433

u" could not be found" % (address,

531

434

fingerprint)))

532

435

533

436

def rebuild(self):

535

438

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

536

439

self.uilist = []

537

440

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

538

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

539

clients),

441

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

540

442

#header=urwid.Divider(),

541

443

header=None,

542

footer=

543

urwid.Divider(div_char=

544

self.divider)))

444

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

545

445

if self.log_visible:

546

446

self.uilist.append(self.logbox)

547

447

pass

549

449

550

450

def log_message(self, message):

551

451

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

552

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

452

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

553

453

554

454

def log_message_raw(self, markup):

555

455

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

558

458

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

559

459

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

560

460

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

561

coming_from="above")

461

coming_from=u"above")

562

462

self.refresh()

563

463

564

464

def toggle_log_display(self):

565

465

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

566

466

self.log_visible = not self.log_visible

567

467

self.rebuild()

568

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

569

# + unicode(self.log_visible))

468

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

469

+ unicode(self.log_visible))

570

470

571

471

def change_log_display(self):

572

472

"""Change type of log display.

573

473

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

574

if self.log_wrap == "clip":

575

self.log_wrap = "any"

474

if self.log_wrap == u"clip":

475

self.log_wrap = u"any"

576

476

else:

577

self.log_wrap = "clip"

477

self.log_wrap = u"clip"

578

478

for textwidget in self.log:

579

479

textwidget.set_wrap_mode(self.log_wrap)

580

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

480

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

581

481

582

482

def find_and_remove_client(self, path, name):

583

483

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

610

510

if path is None:

611

511

path = client.proxy.object_path

612

512

self.clients_dict[path] = client

613

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

513

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

614

514

self.refresh()

615

515

616

516

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

647

547

648

548

def process_input(self, source, condition):

649

549

keys = self.screen.get_input()

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

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

659

559

}

660

560

for key in keys:

661

561

try:

663

563

except KeyError: # :-)

664

564

pass

665

565

666

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

566

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

667

567

self.stop()

668

568

break

669

elif key == "window resize":

569

elif key == u"window resize":

670

570

self.size = self.screen.get_cols_rows()

671

571

self.refresh()

672

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

572

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

673

573

self.refresh()

674

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

574

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

675

575

self.toggle_log_display()

676

576

self.refresh()

677

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

577

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

678

578

self.change_log_display()

679

579

self.refresh()

680

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

580

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

681

581

if not self.log_visible:

682

582

self.log_visible = True

683

583

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

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

702

600

self.refresh()

703

elif key == "tab":

601

elif key == u"tab":

704

602

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

705

603

self.topwidget.set_focus(0)

706

604

else:

707

605

self.topwidget.set_focus(self.logbox)

708

606

self.refresh()

709

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

710

# or key == ">"):

607

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

608

# or key == u">"):

711

609

# pass # xxx end-of-buffer

712

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

713

# or key == "<"):

610

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

611

# or key == u"<"):

714

612

# pass # xxx beginning-of-buffer

715

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

613

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

716

614

# pass # xxx move-end-of-line

717

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

615

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

718

616

# pass # xxx move-beginning-of-line

719

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

617

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

720

618

# pass # xxx left

721

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

619

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

722

620

# pass # xxx right

723

#elif key == "a":

621

#elif key == u"a":

724

622

# pass # scroll up log

725

#elif key == "z":

623

#elif key == u"z":

726

624

# pass # scroll down log

727

625

elif self.topwidget.selectable():

728

626

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

732

630

ui = UserInterface()

733

631

try:

734

632

ui.run()

735

except KeyboardInterrupt:

736

ui.screen.stop()

737

633

except Exception, e:

738

634

ui.log_message(unicode(e))

739

635

ui.screen.stop()