/mandos/trunk : revision 408

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

import os

29

7

import signal

30

8

31

import datetime

32

33

9

import urwid.curses_display

34

10

import urwid

35

11

40

16

41

17

import UserList

42

18

43

import locale

44

45

locale.setlocale(locale.LC_ALL, '')

46

47

import logging

48

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

49

50

19

# Some useful constants

51

20

domain = 'se.bsnet.fukt'

52

21

server_interface = domain + '.Mandos'

53

22

client_interface = domain + '.Mandos.Client'

54

version = "1.2.3"

23

version = "1.0.14"

55

24

56

25

# Always run in monochrome mode

57

26

urwid.curses_display.curses.has_colors = lambda : False

61

30

urwid.curses_display.curses.A_UNDERLINE |= (

62

31

urwid.curses_display.curses.A_BLINK)

63

32

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

80

33

class MandosClientPropertyCache(object):

81

34

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

82

35

properties and calls a hook function when any of them are

83

36

changed.

84

37

"""

85

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

38

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

39

**kwargs):

86

40

self.proxy = proxy_object # Mandos Client proxy object

87

41

88

self.properties = dict()

42

if properties is None:

43

self.properties = dict()

44

else:

45

self.properties = properties

89

46

self.proxy.connect_to_signal("PropertyChanged",

90

47

self.property_changed,

91

48

client_interface,

92

49

byte_arrays=True)

93

50

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)

51

if properties is None:

52

self.properties.update(self.proxy.GetAll(client_interface,

53

dbus_interface =

54

dbus.PROPERTIES_IFACE))

55

super(MandosClientPropertyCache, self).__init__(

56

proxy_object=proxy_object,

57

properties=properties, *args, **kwargs)

101

58

102

59

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

103

60

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

112

69

"""

113

70

114

71

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

115

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

72

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

116

73

# Called on update

117

74

self.update_hook = update_hook

118

75

# Called on delete

119

76

self.delete_hook = delete_hook

120

77

# Mandos Server proxy object

121

78

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

128

79

129

80

# The widget shown normally

130

81

self._text_widget = urwid.Text("")

135

86

*args, **kwargs)

136

87

self.update()

137

88

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

256

89

257

90

def selectable(self):

258

91

"""Make this a "selectable" widget.

259

92

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

260

93

return True

261

94

262

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

95

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

263

96

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

264

97

whether we have focus or not.

265

98

This overrides the method from urwid.FlowWidget"""

266

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

99

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

267

100

268

101

def current_widget(self, focus=False):

269

102

if focus or self.opened:

273

106

def update(self):

274

107

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

275

108

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

109

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

110

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

111

u"underline-blink":

112

u"underline-blink-standout",

113

u"bold-underline-blink":

114

u"bold-underline-blink-standout",

282

115

}

283

116

284

117

# 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

118

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

119

% self.properties)

323

120

if not urwid.supports_unicode():

324

121

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

325

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

122

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

326

123

self._text_widget.set_text(textlist)

327

124

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

328

125

text[1])

336

133

if self.update_hook is not None:

337

134

self.update_hook()

338

135

339

def update_timer(self):

340

"called by gobject"

341

self.update()

342

return True # Keep calling this

343

344

136

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

348

137

if self.delete_hook is not None:

349

138

self.delete_hook(self)

350

139

351

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

140

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

352

141

"""Render differently if we have focus.

353

142

This overrides the method from urwid.FlowWidget"""

354

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

143

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

355

144

focus=focus)

356

145

357

def keypress(self, maxcolrow, key):

146

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

358

147

"""Handle keys.

359

148

This overrides the method from urwid.FlowWidget"""

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

149

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

150

self.proxy.Enable()

151

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

152

self.proxy.Disable()

153

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

371

154

self.server_proxy_object.RemoveClient(self.proxy

372

155

.object_path)

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)

156

elif key == u"s":

157

self.proxy.StartChecker()

158

elif key == u"S":

159

self.proxy.StopChecker()

160

elif key == u"C":

161

self.proxy.CheckedOK()

379

162

# xxx

380

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

163

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

381

164

# self.proxy.pause()

382

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

165

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

383

166

# self.proxy.unpause()

384

# elif key == "RET":

167

# elif key == u"RET":

385

168

# self.open()

386

169

else:

387

170

return key

403

186

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

404

187

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

405

188

"""

406

def keypress(self, maxcolrow, key):

407

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

408

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

189

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

190

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

191

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

409

192

return

410

193

return ret

411

194

420

203

self.screen = urwid.curses_display.Screen()

421

204

422

205

self.screen.register_palette((

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

206

(u"normal",

207

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

208

(u"bold",

209

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

210

(u"underline-blink",

211

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

212

(u"standout",

213

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

214

(u"bold-underline-blink",

215

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

216

(u"bold-standout",

217

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

218

(u"underline-blink-standout",

219

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

220

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

221

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

222

u"standout")),

440

223

))

441

224

442

225

if urwid.supports_unicode():

443

self.divider = "─" # \u2500

444

#self.divider = "━" # \u2501

226

self.divider = u"─" # \u2500

227

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

445

228

else:

446

#self.divider = "-" # \u002d

447

self.divider = "_" # \u005f

229

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

230

self.divider = u"_" # \u005f

448

231

449

232

self.screen.start()

450

233

464

247

# This keeps track of whether self.uilist currently has

465

248

# self.logbox in it or not

466

249

self.log_visible = True

467

self.log_wrap = "any"

250

self.log_wrap = u"any"

468

251

469

252

self.rebuild()

470

self.log_message_raw(("bold",

471

"Mandos Monitor version " + version))

472

self.log_message_raw(("bold",

473

"q: Quit ?: Help"))

253

self.log_message((u"bold",

254

u"Mandos Monitor version " + version))

255

self.log_message((u"bold",

256

u"q: Quit ?: Help"))

474

257

475

258

self.busname = domain + '.Mandos'

476

259

self.main_loop = gobject.MainLoop()

477

260

self.bus = dbus.SystemBus()

478

261

mandos_dbus_objc = self.bus.get_object(

479

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

262

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

480

263

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

481

264

dbus_interface

482

265

= server_interface)

496

279

self.add_new_client,

497

280

dbus_interface=server_interface,

498

281

byte_arrays=True))

499

(self.mandos_serv

500

.connect_to_signal("ClientNotFound",

501

self.client_not_found,

502

dbus_interface=server_interface,

503

byte_arrays=True))

504

282

for path, client in mandos_clients.iteritems():

505

283

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

506

284

path)

512

290

update_hook

513

291

=self.refresh,

514

292

delete_hook

515

=self.remove_client,

516

logger

517

=self.log_message),

293

=self.remove_client),

518

294

path=path)

519

295

520

def client_not_found(self, fingerprint, address):

521

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

522

" could not be found" % (address,

523

fingerprint)))

524

525

296

def rebuild(self):

526

297

"""This rebuilds the User Interface.

527

298

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

528

299

self.uilist = []

529

300

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

530

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

531

clients),

301

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

532

302

#header=urwid.Divider(),

533

303

header=None,

534

footer=

535

urwid.Divider(div_char=

536

self.divider)))

304

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

537

305

if self.log_visible:

538

306

self.uilist.append(self.logbox)

539

307

pass

540

308

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

541

309

542

def log_message(self, message):

543

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

544

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

545

546

def log_message_raw(self, markup):

310

def log_message(self, markup):

547

311

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

548

312

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

549

313

if (self.max_log_length

550

314

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

551

315

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

552

316

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

553

coming_from="above")

554

self.refresh()

317

coming_from=u"above")

555

318

556

319

def toggle_log_display(self):

557

320

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

558

321

self.log_visible = not self.log_visible

559

322

self.rebuild()

560

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

561

# + unicode(self.log_visible))

323

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

324

+ unicode(self.log_visible))

562

325

563

326

def change_log_display(self):

564

327

"""Change type of log display.

565

328

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

566

if self.log_wrap == "clip":

567

self.log_wrap = "any"

329

if self.log_wrap == u"clip":

330

self.log_wrap = u"any"

568

331

else:

569

self.log_wrap = "clip"

332

self.log_wrap = u"clip"

570

333

for textwidget in self.log:

571

334

textwidget.set_wrap_mode(self.log_wrap)

572

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

335

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

573

336

574

337

def find_and_remove_client(self, path, name):

575

338

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

583

346

return

584

347

self.remove_client(client, path)

585

348

586

def add_new_client(self, path):

349

def add_new_client(self, path, properties):

587

350

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

588

351

self.add_client(MandosClientWidget(server_proxy_object

589

352

=self.mandos_serv,

590

353

proxy_object

591

354

=client_proxy_object,

355

properties=properties,

592

356

update_hook

593

357

=self.refresh,

594

358

delete_hook

595

=self.remove_client,

596

logger

597

=self.log_message),

359

=self.remove_client),

598

360

path=path)

599

361

600

362

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

602

364

if path is None:

603

365

path = client.proxy.object_path

604

366

self.clients_dict[path] = client

605

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

367

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

606

368

self.refresh()

607

369

608

370

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

639

401

640

402

def process_input(self, source, condition):

641

403

keys = self.screen.get_input()

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

404

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

405

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

406

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

407

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

408

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

409

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

410

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

411

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

412

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

651

413

}

652

414

for key in keys:

653

415

try:

655

417

except KeyError: # :-)

656

418

pass

657

419

658

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

420

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

659

421

self.stop()

660

422

break

661

elif key == "window resize":

423

elif key == u"window resize":

662

424

self.size = self.screen.get_cols_rows()

663

425

self.refresh()

664

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

426

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

665

427

self.refresh()

666

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

428

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

667

429

self.toggle_log_display()

668

430

self.refresh()

669

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

431

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

670

432

self.change_log_display()

671

433

self.refresh()

672

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

434

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

673

435

if not self.log_visible:

674

436

self.log_visible = True

675

437

self.rebuild()

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

438

self.log_message((u"bold",

439

u" ".join((u"q: Quit",

440

u"?: Help",

441

u"l: Log window toggle",

442

u"TAB: Switch window",

443

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

444

self.log_message((u"bold",

445

u" ".join((u"Clients:",

446

u"e: Enable",

447

u"d: Disable",

448

u"r: Remove",

449

u"s: Start new checker",

450

u"S: Stop checker",

451

u"C: Checker OK"))))

694

452

self.refresh()

695

elif key == "tab":

453

elif key == u"tab":

696

454

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

697

455

self.topwidget.set_focus(0)

698

456

else:

699

457

self.topwidget.set_focus(self.logbox)

700

458

self.refresh()

701

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

702

# or key == ">"):

459

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

460

# or key == u">"):

703

461

# pass # xxx end-of-buffer

704

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

705

# or key == "<"):

462

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

463

# or key == u"<"):

706

464

# pass # xxx beginning-of-buffer

707

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

465

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

708

466

# pass # xxx move-end-of-line

709

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

467

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

710

468

# pass # xxx move-beginning-of-line

711

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

469

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

712

470

# pass # xxx left

713

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

471

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

714

472

# pass # xxx right

715

#elif key == "a":

473

#elif key == u"a":

716

474

# pass # scroll up log

717

#elif key == "z":

475

#elif key == u"z":

718

476

# pass # scroll down log

719

477

elif self.topwidget.selectable():

720

478

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

724

482

ui = UserInterface()

725

483

try:

726

484

ui.run()

727

except KeyboardInterrupt:

728

ui.screen.stop()

729

except Exception, e:

730

ui.log_message(unicode(e))

485

except:

731

486

ui.screen.stop()

732

487

raise