/mandos/trunk : revision 463.1.8

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

25

46

26

47

import logging

27

48

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

30

51

domain = 'se.bsnet.fukt'

31

52

server_interface = domain + '.Mandos'

32

53

client_interface = domain + '.Mandos.Client'

33

version = "1.0.15"

54

version = "1.2.3"

34

55

35

56

# Always run in monochrome mode

36

57

urwid.curses_display.curses.has_colors = lambda : False

40

61

urwid.curses_display.curses.A_UNDERLINE |= (

41

62

urwid.curses_display.curses.A_BLINK)

42

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

43

80

class MandosClientPropertyCache(object):

44

81

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

45

82

properties and calls a hook function when any of them are

49

86

self.proxy = proxy_object # Mandos Client proxy object

50

87

51

88

self.properties = dict()

52

self.proxy.connect_to_signal(u"PropertyChanged",

89

self.proxy.connect_to_signal("PropertyChanged",

53

90

self.property_changed,

54

91

client_interface,

55

92

byte_arrays=True)

57

94

self.properties.update(

58

95

self.proxy.GetAll(client_interface,

59

96

dbus_interface = dbus.PROPERTIES_IFACE))

60

super(MandosClientPropertyCache, self).__init__(

61

proxy_object=proxy_object, *args, **kwargs)

97

98

#XXX This break good super behaviour!

99

# super(MandosClientPropertyCache, self).__init__(

100

# *args, **kwargs)

62

101

63

102

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

64

103

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

83

122

# Logger

84

123

self.logger = logger

85

124

125

self._update_timer_callback_tag = None

126

self._update_timer_callback_lock = 0

127

self.last_checker_failed = False

128

86

129

# The widget shown normally

87

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

130

self._text_widget = urwid.Text("")

88

131

# The widget shown when we have focus

89

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

132

self._focus_text_widget = urwid.Text("")

90

133

super(MandosClientWidget, self).__init__(

91

134

update_hook=update_hook, delete_hook=delete_hook,

92

135

*args, **kwargs)

93

136

self.update()

94

137

self.opened = False

95

self.proxy.connect_to_signal(u"CheckerCompleted",

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

96

158

self.checker_completed,

97

159

client_interface,

98

160

byte_arrays=True)

99

self.proxy.connect_to_signal(u"CheckerStarted",

161

self.proxy.connect_to_signal("CheckerStarted",

100

162

self.checker_started,

101

163

client_interface,

102

164

byte_arrays=True)

103

self.proxy.connect_to_signal(u"GotSecret",

165

self.proxy.connect_to_signal("GotSecret",

104

166

self.got_secret,

105

167

client_interface,

106

168

byte_arrays=True)

107

self.proxy.connect_to_signal(u"Rejected",

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

108

174

self.rejected,

109

175

client_interface,

110

176

byte_arrays=True)

111

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

112

201

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

113

202

if exitstatus == 0:

114

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

115

u' was successful'

116

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

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

117

210

return

211

# Checker failed

212

if not self.last_checker_failed:

213

self.last_checker_failed = True

214

self.using_timer(True)

118

215

if os.WIFEXITED(condition):

119

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

120

u' failed with exit code %s'

121

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

122

219

os.WEXITSTATUS(condition)))

123

return

124

if os.WIFSIGNALED(condition):

125

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

126

u' was killed by signal %s'

127

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

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,

128

224

os.WTERMSIG(condition)))

129

return

130

if os.WCOREDUMP(condition):

131

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

132

u' dumped core'

133

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

134

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

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

135

233

136

234

def checker_started(self, command):

137

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

138

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

235

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

236

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

237

pass

139

238

140

239

def got_secret(self):

141

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

142

% self.properties[u"name"])

143

144

def rejected(self):

145

self.logger(u'Client %s was rejected'

146

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

147

256

148

257

def selectable(self):

149

258

"""Make this a "selectable" widget.

150

259

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

151

260

return True

152

261

153

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

262

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

154

263

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

155

264

whether we have focus or not.

156

265

This overrides the method from urwid.FlowWidget"""

157

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

266

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

158

267

159

268

def current_widget(self, focus=False):

160

269

if focus or self.opened:

164

273

def update(self):

165

274

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

166

275

# How to add standout mode to a style

167

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

168

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

169

u"underline-blink":

170

u"underline-blink-standout",

171

u"bold-underline-blink":

172

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

173

282

}

174

283

175

284

# Rebuild focus and non-focus widgets using current properties

176

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

177

% { u"name": self.properties[u"name"],

178

u"enabled":

179

(u"enabled"

180

if self.properties[u"enabled"]

181

else u"DISABLED")})

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

182

323

if not urwid.supports_unicode():

183

324

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

184

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

325

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

185

326

self._text_widget.set_text(textlist)

186

327

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

187

328

text[1])

195

336

if self.update_hook is not None:

196

337

self.update_hook()

197

338

339

def update_timer(self):

340

"called by gobject"

341

self.update()

342

return True # Keep calling this

343

198

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

199

348

if self.delete_hook is not None:

200

349

self.delete_hook(self)

201

350

202

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

351

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

203

352

"""Render differently if we have focus.

204

353

This overrides the method from urwid.FlowWidget"""

205

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

354

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

206

355

focus=focus)

207

356

208

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

357

def keypress(self, maxcolrow, key):

209

358

"""Handle keys.

210

359

This overrides the method from urwid.FlowWidget"""

211

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

212

self.proxy.Enable()

213

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

214

self.proxy.Disable()

215

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

360

if key == "+":

361

self.proxy.Enable(dbus_interface = client_interface)

362

elif key == "-":

363

self.proxy.Disable(dbus_interface = client_interface)

364

elif key == "a":

365

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

366

dbus_interface = client_interface)

367

elif key == "d":

368

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

369

dbus_interface = client_interface)

370

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

216

371

self.server_proxy_object.RemoveClient(self.proxy

217

372

.object_path)

218

elif key == u"s":

219

self.proxy.StartChecker()

220

elif key == u"S":

221

self.proxy.StopChecker()

222

elif key == u"C":

223

self.proxy.CheckedOK()

373

elif key == "s":

374

self.proxy.StartChecker(dbus_interface = client_interface)

375

elif key == "S":

376

self.proxy.StopChecker(dbus_interface = client_interface)

377

elif key == "C":

378

self.proxy.CheckedOK(dbus_interface = client_interface)

224

379

# xxx

225

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

380

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

226

381

# self.proxy.pause()

227

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

382

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

228

383

# self.proxy.unpause()

229

# elif key == u"RET":

384

# elif key == "RET":

230

385

# self.open()

231

386

else:

232

387

return key

248

403

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

249

404

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

250

405

"""

251

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

252

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

253

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

406

def keypress(self, maxcolrow, key):

407

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

408

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

254

409

return

255

410

return ret

256

411

265

420

self.screen = urwid.curses_display.Screen()

266

421

267

422

self.screen.register_palette((

268

(u"normal",

269

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

270

(u"bold",

271

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

272

(u"underline-blink",

273

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

274

(u"standout",

275

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

276

(u"bold-underline-blink",

277

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

278

(u"bold-standout",

279

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

280

(u"underline-blink-standout",

281

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

282

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

283

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

284

u"standout")),

423

("normal",

424

"default", "default", None),

425

("bold",

426

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

427

("underline-blink",

428

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

429

("standout",

430

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

431

("bold-underline-blink",

432

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

433

("bold-standout",

434

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

435

("underline-blink-standout",

436

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

437

("bold-underline-blink-standout",

438

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

439

"standout")),

285

440

))

286

441

287

442

if urwid.supports_unicode():

288

self.divider = u"─" # \u2500

289

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

443

self.divider = "─" # \u2500

444

#self.divider = "━" # \u2501

290

445

else:

291

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

292

self.divider = u"_" # \u005f

446

#self.divider = "-" # \u002d

447

self.divider = "_" # \u005f

293

448

294

449

self.screen.start()

295

450

309

464

# This keeps track of whether self.uilist currently has

310

465

# self.logbox in it or not

311

466

self.log_visible = True

312

self.log_wrap = u"any"

467

self.log_wrap = "any"

313

468

314

469

self.rebuild()

315

self.log_message_raw((u"bold",

316

u"Mandos Monitor version " + version))

317

self.log_message_raw((u"bold",

318

u"q: Quit ?: Help"))

470

self.log_message_raw(("bold",

471

"Mandos Monitor version " + version))

472

self.log_message_raw(("bold",

473

"q: Quit ?: Help"))

319

474

320

475

self.busname = domain + '.Mandos'

321

476

self.main_loop = gobject.MainLoop()

322

477

self.bus = dbus.SystemBus()

323

478

mandos_dbus_objc = self.bus.get_object(

324

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

479

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

325

480

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

326

481

dbus_interface

327

482

= server_interface)

332

487

mandos_clients = dbus.Dictionary()

333

488

334

489

(self.mandos_serv

335

.connect_to_signal(u"ClientRemoved",

490

.connect_to_signal("ClientRemoved",

336

491

self.find_and_remove_client,

337

492

dbus_interface=server_interface,

338

493

byte_arrays=True))

339

494

(self.mandos_serv

340

.connect_to_signal(u"ClientAdded",

495

.connect_to_signal("ClientAdded",

341

496

self.add_new_client,

342

497

dbus_interface=server_interface,

343

498

byte_arrays=True))

344

499

(self.mandos_serv

345

.connect_to_signal(u"ClientNotFound",

500

.connect_to_signal("ClientNotFound",

346

501

self.client_not_found,

347

502

dbus_interface=server_interface,

348

503

byte_arrays=True))

363

518

path=path)

364

519

365

520

def client_not_found(self, fingerprint, address):

366

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

367

u" could not be found" % (address,

521

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

522

" could not be found" % (address,

368

523

fingerprint)))

369

524

370

525

def rebuild(self):

372

527

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

373

528

self.uilist = []

374

529

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

375

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

530

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

531

clients),

376

532

#header=urwid.Divider(),

377

533

header=None,

378

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

534

footer=

535

urwid.Divider(div_char=

536

self.divider)))

379

537

if self.log_visible:

380

538

self.uilist.append(self.logbox)

381

539

pass

383

541

384

542

def log_message(self, message):

385

543

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

386

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

544

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

387

545

388

546

def log_message_raw(self, markup):

389

547

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

392

550

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

393

551

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

394

552

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

395

coming_from=u"above")

553

coming_from="above")

396

554

self.refresh()

397

555

398

556

def toggle_log_display(self):

399

557

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

400

558

self.log_visible = not self.log_visible

401

559

self.rebuild()

402

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

403

+ unicode(self.log_visible))

560

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

561

# + unicode(self.log_visible))

404

562

405

563

def change_log_display(self):

406

564

"""Change type of log display.

407

565

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

408

if self.log_wrap == u"clip":

409

self.log_wrap = u"any"

566

if self.log_wrap == "clip":

567

self.log_wrap = "any"

410

568

else:

411

self.log_wrap = u"clip"

569

self.log_wrap = "clip"

412

570

for textwidget in self.log:

413

571

textwidget.set_wrap_mode(self.log_wrap)

414

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

572

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

415

573

416

574

def find_and_remove_client(self, path, name):

417

575

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

444

602

if path is None:

445

603

path = client.proxy.object_path

446

604

self.clients_dict[path] = client

447

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

605

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

448

606

self.refresh()

449

607

450

608

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

481

639

482

640

def process_input(self, source, condition):

483

641

keys = self.screen.get_input()

484

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

485

u"ctrl p": u"up", # Emacs

486

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

487

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

488

u" ": u"page down", # less

489

u"f": u"page down", # less

490

u"b": u"page up", # less

491

u"j": u"down", # vi

492

u"k": u"up", # vi

642

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

643

"ctrl p": "up", # Emacs

644

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

645

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

646

" ": "page down", # less

647

"f": "page down", # less

648

"b": "page up", # less

649

"j": "down", # vi

650

"k": "up", # vi

493

651

}

494

652

for key in keys:

495

653

try:

497

655

except KeyError: # :-)

498

656

pass

499

657

500

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

658

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

501

659

self.stop()

502

660

break

503

elif key == u"window resize":

661

elif key == "window resize":

504

662

self.size = self.screen.get_cols_rows()

505

663

self.refresh()

506

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

664

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

507

665

self.refresh()

508

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

666

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

509

667

self.toggle_log_display()

510

668

self.refresh()

511

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

669

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

512

670

self.change_log_display()

513

671

self.refresh()

514

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

672

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

515

673

if not self.log_visible:

516

674

self.log_visible = True

517

675

self.rebuild()

518

self.log_message_raw((u"bold",

519

u" ".

520

join((u"q: Quit",

521

u"?: Help",

522

u"l: Log window toggle",

523

u"TAB: Switch window",

524

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

525

self.log_message_raw((u"bold",

526

u" "

527

.join((u"Clients:",

528

u"e: Enable",

529

u"d: Disable",

530

u"r: Remove",

531

u"s: Start new checker",

532

u"S: Stop checker",

533

u"C: Checker OK"))))

676

self.log_message_raw(("bold",

677

" ".

678

join(("q: Quit",

679

"?: Help",

680

"l: Log window toggle",

681

"TAB: Switch window",

682

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

683

self.log_message_raw(("bold",

684

" "

685

.join(("Clients:",

686

"+: Enable",

687

"-: Disable",

688

"R: Remove",

689

"s: Start new checker",

690

"S: Stop checker",

691

"C: Checker OK",

692

"a: Approve",

693

"d: Deny"))))

534

694

self.refresh()

535

elif key == u"tab":

695

elif key == "tab":

536

696

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

537

697

self.topwidget.set_focus(0)

538

698

else:

539

699

self.topwidget.set_focus(self.logbox)

540

700

self.refresh()

541

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

542

# or key == u">"):

701

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

702

# or key == ">"):

543

703

# pass # xxx end-of-buffer

544

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

545

# or key == u"<"):

704

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

705

# or key == "<"):

546

706

# pass # xxx beginning-of-buffer

547

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

707

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

548

708

# pass # xxx move-end-of-line

549

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

709

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

550

710

# pass # xxx move-beginning-of-line

551

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

711

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

552

712

# pass # xxx left

553

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

713

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

554

714

# pass # xxx right

555

#elif key == u"a":

715

#elif key == "a":

556

716

# pass # scroll up log

557

#elif key == u"z":

717

#elif key == "z":

558

718

# pass # scroll down log

559

719

elif self.topwidget.selectable():

560

720

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

564

724

ui = UserInterface()

565

725

try:

566

726

ui.run()

727

except KeyboardInterrupt:

728

ui.screen.stop()

567

729

except Exception, e:

568

730

ui.log_message(unicode(e))

569

731

ui.screen.stop()