/mandos/release : revision 24.1.181

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,

26

unicode_literals)

5

27

6

28

import sys

7

29

import os

21

43

22

44

import locale

23

45

24

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

46

locale.setlocale(locale.LC_ALL, '')

25

47

26

48

import logging

27

49

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

30

52

domain = 'se.bsnet.fukt'

31

53

server_interface = domain + '.Mandos'

32

54

client_interface = domain + '.Mandos.Client'

33

version = "1.0.15"

55

version = "1.3.1"

34

56

35

57

# Always run in monochrome mode

36

58

urwid.curses_display.curses.has_colors = lambda : False

44

66

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

45

67

if not iso:

46

68

return None

47

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

48

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

49

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

69

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

70

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

71

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

50

72

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

51

73

return datetime.datetime(int(year),

52

74

int(month),

65

87

self.proxy = proxy_object # Mandos Client proxy object

66

88

67

89

self.properties = dict()

68

self.proxy.connect_to_signal(u"PropertyChanged",

69

self.property_changed,

70

client_interface,

71

byte_arrays=True)

90

self.property_changed_match = (

91

self.proxy.connect_to_signal("PropertyChanged",

92

self.property_changed,

93

client_interface,

94

byte_arrays=True))

72

95

73

96

self.properties.update(

74

97

self.proxy.GetAll(client_interface,

75

98

dbus_interface = dbus.PROPERTIES_IFACE))

76

99

77

#XXX This break good super behaviour!

100

#XXX This breaks good super behaviour

78

101

# super(MandosClientPropertyCache, self).__init__(

79

102

# *args, **kwargs)

80

103

84

107

"""

85

108

# Update properties dict with new value

86

109

self.properties[property] = value

110

111

def delete(self, *args, **kwargs):

112

self.property_changed_match.remove()

113

super(MandosClientPropertyCache, self).__init__(

114

*args, **kwargs)

87

115

88

116

89

117

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

102

130

self.logger = logger

103

131

104

132

self._update_timer_callback_tag = None

133

self._update_timer_callback_lock = 0

105

134

self.last_checker_failed = False

106

135

107

136

# The widget shown normally

108

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

137

self._text_widget = urwid.Text("")

109

138

# The widget shown when we have focus

110

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

139

self._focus_text_widget = urwid.Text("")

111

140

super(MandosClientWidget, self).__init__(

112

141

update_hook=update_hook, delete_hook=delete_hook,

113

142

*args, **kwargs)

114

143

self.update()

115

144

self.opened = False

116

self.proxy.connect_to_signal(u"CheckerCompleted",

117

self.checker_completed,

118

client_interface,

119

byte_arrays=True)

120

self.proxy.connect_to_signal(u"CheckerStarted",

121

self.checker_started,

122

client_interface,

123

byte_arrays=True)

124

self.proxy.connect_to_signal(u"GotSecret",

125

self.got_secret,

126

client_interface,

127

byte_arrays=True)

128

self.proxy.connect_to_signal(u"NeedApproval",

129

self.need_approval,

130

client_interface,

131

byte_arrays=True)

132

self.proxy.connect_to_signal(u"Rejected",

133

self.rejected,

134

client_interface,

135

byte_arrays=True)

145

136

146

last_checked_ok = isoformat_to_datetime(self.properties

137

["last_checked_ok"])

147

["LastCheckedOK"])

138

148

if last_checked_ok is None:

139

149

self.last_checker_failed = True

140

150

else:

142

152

- last_checked_ok)

143

153

> datetime.timedelta

144

154

(milliseconds=

145

self.properties["interval"]))

155

self.properties

156

["Interval"]))

157

146

158

if self.last_checker_failed:

159

self.using_timer(True)

160

161

if self.need_approval:

162

self.using_timer(True)

163

164

self.match_objects = (

165

self.proxy.connect_to_signal("CheckerCompleted",

166

self.checker_completed,

167

client_interface,

168

byte_arrays=True),

169

self.proxy.connect_to_signal("CheckerStarted",

170

self.checker_started,

171

client_interface,

172

byte_arrays=True),

173

self.proxy.connect_to_signal("GotSecret",

174

self.got_secret,

175

client_interface,

176

byte_arrays=True),

177

self.proxy.connect_to_signal("NeedApproval",

178

self.need_approval,

179

client_interface,

180

byte_arrays=True),

181

self.proxy.connect_to_signal("Rejected",

182

self.rejected,

183

client_interface,

184

byte_arrays=True))

185

#self.logger('Created client %s' % (self.properties["Name"]))

186

187

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

188

super(self, MandosClientWidget).property_changed(property,

189

value)

190

if property == "ApprovalPending":

191

using_timer(bool(value))

192

193

def using_timer(self, flag):

194

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

195

activated or deactivated.

196

"""

197

old = self._update_timer_callback_lock

198

if flag:

199

self._update_timer_callback_lock += 1

200

else:

201

self._update_timer_callback_lock -= 1

202

if old == 0 and self._update_timer_callback_lock:

203

# Will update the shown timer value every second

147

204

self._update_timer_callback_tag = (gobject.timeout_add

148

205

(1000,

149

206

self.update_timer))

207

elif old and self._update_timer_callback_lock == 0:

208

gobject.source_remove(self._update_timer_callback_tag)

209

self._update_timer_callback_tag = None

150

210

151

211

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

152

212

if exitstatus == 0:

153

213

if self.last_checker_failed:

154

214

self.last_checker_failed = False

155

gobject.source_remove(self._update_timer_callback_tag)

156

self._update_timer_callback_tag = None

157

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

158

u' was successful'

159

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

215

self.using_timer(False)

216

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

217

# ' was successful'

218

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

160

219

self.update()

161

220

return

162

221

# Checker failed

163

222

if not self.last_checker_failed:

164

223

self.last_checker_failed = True

165

self._update_timer_callback_tag = (gobject.timeout_add

166

(1000,

167

self.update_timer))

224

self.using_timer(True)

168

225

if os.WIFEXITED(condition):

169

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

170

u' failed with exit code %s'

171

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

226

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

227

' failed with exit code %s'

228

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

172

229

os.WEXITSTATUS(condition)))

173

230

elif os.WIFSIGNALED(condition):

174

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

175

u' was killed by signal %s'

176

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

231

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

232

' was killed by signal %s'

233

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

177

234

os.WTERMSIG(condition)))

178

235

elif os.WCOREDUMP(condition):

179

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

180

u' dumped core'

181

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

236

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

237

' dumped core'

238

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

182

239

else:

183

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

240

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

241

' mysteriously')

184

242

self.update()

185

243

186

244

def checker_started(self, command):

187

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

188

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

245

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

246

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

189

247

pass

190

248

191

249

def got_secret(self):

192

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

193

% self.properties[u"name"])

250

self.last_checker_failed = False

251

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

252

% self.properties["Name"])

194

253

195

254

def need_approval(self, timeout, default):

196

255

if not default:

197

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

256

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

198

257

else:

199

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

258

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

200

259

self.logger(message

201

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

260

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

261

self.using_timer(True)

202

262

203

263

def rejected(self, reason):

204

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

205

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

264

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

265

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

206

266

207

267

def selectable(self):

208

268

"""Make this a "selectable" widget.

209

269

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

210

270

return True

211

271

212

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

272

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

213

273

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

214

274

whether we have focus or not.

215

275

This overrides the method from urwid.FlowWidget"""

216

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

276

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

217

277

218

278

def current_widget(self, focus=False):

219

279

if focus or self.opened:

223

283

def update(self):

224

284

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

225

285

# How to add standout mode to a style

226

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

227

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

228

u"underline-blink":

229

u"underline-blink-standout",

230

u"bold-underline-blink":

231

u"bold-underline-blink-standout",

286

with_standout = { "normal": "standout",

287

"bold": "bold-standout",

288

"underline-blink":

289

"underline-blink-standout",

290

"bold-underline-blink":

291

"bold-underline-blink-standout",

232

292

}

233

293

234

294

# Rebuild focus and non-focus widgets using current properties

235

295

236

296

# Base part of a client. Name!

237

base = (u'%(name)s: '

238

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

239

if not self.properties[u"enabled"]:

240

message = u"DISABLED"

297

base = ('%(name)s: '

298

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

299

if not self.properties["Enabled"]:

300

message = "DISABLED"

301

elif self.properties["ApprovalPending"]:

302

timeout = datetime.timedelta(milliseconds

303

= self.properties

304

["ApprovalDelay"])

305

last_approval_request = isoformat_to_datetime(

306

self.properties["LastApprovalRequest"])

307

if last_approval_request is not None:

308

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

309

- last_approval_request)

310

else:

311

timer = datetime.timedelta()

312

if self.properties["ApprovedByDefault"]:

313

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

314

else:

315

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

316

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

241

317

elif self.last_checker_failed:

242

timeout = datetime.timedelta(milliseconds

243

= self.properties[u"timeout"])

244

last_ok = isoformat_to_datetime(

245

max((self.properties["last_checked_ok"]

246

or self.properties["created"]),

247

self.properties[u"last_enabled"]))

248

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

249

250

message = (u'A checker has failed! Time until client gets diabled: %s'

251

% unicode(timer))

252

elif self.properties[u"approved_pending"]:

253

if self.properties[u"approved_by_default"]:

254

message = u"Connection established to client. (d)eny?"

318

# When checker has failed, print a timer until client expires

319

expires = self.properties["Expires"]

320

if expires == "":

321

timer = datetime.timedelta(0)

255

322

else:

256

message = u"Seeks approval to send secret. (a)pprove?"

323

expires = datetime.datetime.strptime(expires,

324

'%Y-%m-%dT%H:%M:%S.%f')

325

timer = expires - datetime.datetime.utcnow()

326

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

327

' gets disabled: %s'

328

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

257

329

else:

258

message = u"enabled"

330

message = "enabled"

259

331

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

260

332

261

333

if not urwid.supports_unicode():

262

334

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

263

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

335

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

264

336

self._text_widget.set_text(textlist)

265

337

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

266

338

text[1])

275

347

self.update_hook()

276

348

277

349

def update_timer(self):

278

"called by gobject"

350

"""called by gobject. Will indefinitely loop until

351

gobject.source_remove() on tag is called"""

279

352

self.update()

280

353

return True # Keep calling this

281

354

282

def delete(self):

355

def delete(self, *args, **kwargs):

283

356

if self._update_timer_callback_tag is not None:

284

357

gobject.source_remove(self._update_timer_callback_tag)

285

358

self._update_timer_callback_tag = None

359

for match in self.match_objects:

360

match.remove()

361

self.match_objects = ()

286

362

if self.delete_hook is not None:

287

363

self.delete_hook(self)

364

return super(MandosClientWidget, self).delete(*args, **kwargs)

288

365

289

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

366

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

290

367

"""Render differently if we have focus.

291

368

This overrides the method from urwid.FlowWidget"""

292

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

369

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

293

370

focus=focus)

294

371

295

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

372

def keypress(self, maxcolrow, key):

296

373

"""Handle keys.

297

374

This overrides the method from urwid.FlowWidget"""

298

if key == u"+":

299

self.proxy.Enable(dbus_interface = client_interface)

300

elif key == u"-":

301

self.proxy.Disable(dbus_interface = client_interface)

302

elif key == u"a":

375

if key == "+":

376

self.proxy.Enable(dbus_interface = client_interface,

377

ignore_reply=True)

378

elif key == "-":

379

self.proxy.Disable(dbus_interface = client_interface,

380

ignore_reply=True)

381

elif key == "a":

303

382

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

304

dbus_interface = client_interface)

305

elif key == u"d":

383

dbus_interface = client_interface,

384

ignore_reply=True)

385

elif key == "d":

306

386

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

307

dbus_interface = client_interface)

308

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

387

dbus_interface = client_interface,

388

ignore_reply=True)

389

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

309

390

self.server_proxy_object.RemoveClient(self.proxy

310

.object_path)

311

elif key == u"s":

312

self.proxy.StartChecker(dbus_interface = client_interface)

313

elif key == u"S":

314

self.proxy.StopChecker(dbus_interface = client_interface)

315

elif key == u"C":

316

self.proxy.CheckedOK(dbus_interface = client_interface)

391

.object_path,

392

ignore_reply=True)

393

elif key == "s":

394

self.proxy.StartChecker(dbus_interface = client_interface,

395

ignore_reply=True)

396

elif key == "S":

397

self.proxy.StopChecker(dbus_interface = client_interface,

398

ignore_reply=True)

399

elif key == "C":

400

self.proxy.CheckedOK(dbus_interface = client_interface,

401

ignore_reply=True)

317

402

# xxx

318

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

403

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

319

404

# self.proxy.pause()

320

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

405

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

321

406

# self.proxy.unpause()

322

# elif key == u"RET":

407

# elif key == "RET":

323

408

# self.open()

324

# elif key == u"+":

325

# self.proxy.Approve(True)

326

# elif key == u"-":

327

# self.proxy.Approve(False)

328

409

else:

329

410

return key

330

411

345

426

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

346

427

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

347

428

"""

348

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

349

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

350

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

429

def keypress(self, maxcolrow, key):

430

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

431

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

351

432

return

352

433

return ret

353

434

362

443

self.screen = urwid.curses_display.Screen()

363

444

364

445

self.screen.register_palette((

365

(u"normal",

366

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

367

(u"bold",

368

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

369

(u"underline-blink",

370

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

371

(u"standout",

372

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

373

(u"bold-underline-blink",

374

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

375

(u"bold-standout",

376

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

377

(u"underline-blink-standout",

378

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

379

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

380

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

381

u"standout")),

446

("normal",

447

"default", "default", None),

448

("bold",

449

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

450

("underline-blink",

451

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

452

("standout",

453

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

454

("bold-underline-blink",

455

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

456

("bold-standout",

457

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

458

("underline-blink-standout",

459

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

460

("bold-underline-blink-standout",

461

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

462

"standout")),

382

463

))

383

464

384

465

if urwid.supports_unicode():

385

self.divider = u"─" # \u2500

386

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

466

self.divider = "─" # \u2500

467

#self.divider = "━" # \u2501

387

468

else:

388

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

389

self.divider = u"_" # \u005f

469

#self.divider = "-" # \u002d

470

self.divider = "_" # \u005f

390

471

391

472

self.screen.start()

392

473

406

487

# This keeps track of whether self.uilist currently has

407

488

# self.logbox in it or not

408

489

self.log_visible = True

409

self.log_wrap = u"any"

490

self.log_wrap = "any"

410

491

411

492

self.rebuild()

412

self.log_message_raw((u"bold",

413

u"Mandos Monitor version " + version))

414

self.log_message_raw((u"bold",

415

u"q: Quit ?: Help"))

493

self.log_message_raw(("bold",

494

"Mandos Monitor version " + version))

495

self.log_message_raw(("bold",

496

"q: Quit ?: Help"))

416

497

417

498

self.busname = domain + '.Mandos'

418

499

self.main_loop = gobject.MainLoop()

419

500

self.bus = dbus.SystemBus()

420

501

mandos_dbus_objc = self.bus.get_object(

421

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

502

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

422

503

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

423

504

dbus_interface

424

505

= server_interface)

429

510

mandos_clients = dbus.Dictionary()

430

511

431

512

(self.mandos_serv

432

.connect_to_signal(u"ClientRemoved",

513

.connect_to_signal("ClientRemoved",

433

514

self.find_and_remove_client,

434

515

dbus_interface=server_interface,

435

516

byte_arrays=True))

436

517

(self.mandos_serv

437

.connect_to_signal(u"ClientAdded",

518

.connect_to_signal("ClientAdded",

438

519

self.add_new_client,

439

520

dbus_interface=server_interface,

440

521

byte_arrays=True))

441

522

(self.mandos_serv

442

.connect_to_signal(u"ClientNotFound",

523

.connect_to_signal("ClientNotFound",

443

524

self.client_not_found,

444

525

dbus_interface=server_interface,

445

526

byte_arrays=True))

460

541

path=path)

461

542

462

543

def client_not_found(self, fingerprint, address):

463

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

464

u" could not be found" % (address,

544

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

545

" could not be found" % (address,

465

546

fingerprint)))

466

547

467

548

def rebuild(self):

469

550

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

470

551

self.uilist = []

471

552

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

472

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

553

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

554

clients),

473

555

#header=urwid.Divider(),

474

556

header=None,

475

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

557

footer=

558

urwid.Divider(div_char=

559

self.divider)))

476

560

if self.log_visible:

477

561

self.uilist.append(self.logbox)

478

562

pass

480

564

481

565

def log_message(self, message):

482

566

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

483

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

567

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

484

568

485

569

def log_message_raw(self, markup):

486

570

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

489

573

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

490

574

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

491

575

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

492

coming_from=u"above")

576

coming_from="above")

493

577

self.refresh()

494

578

495

579

def toggle_log_display(self):

496

580

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

497

581

self.log_visible = not self.log_visible

498

582

self.rebuild()

499

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

500

+ unicode(self.log_visible))

583

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

584

# + unicode(self.log_visible))

501

585

502

586

def change_log_display(self):

503

587

"""Change type of log display.

504

588

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

505

if self.log_wrap == u"clip":

506

self.log_wrap = u"any"

589

if self.log_wrap == "clip":

590

self.log_wrap = "any"

507

591

else:

508

self.log_wrap = u"clip"

592

self.log_wrap = "clip"

509

593

for textwidget in self.log:

510

594

textwidget.set_wrap_mode(self.log_wrap)

511

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

595

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

512

596

513

597

def find_and_remove_client(self, path, name):

514

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

598

"""Find a client by its object path and remove it.

515

599

516

600

This is connected to the ClientRemoved signal from the

517

601

Mandos server object."""

519

603

client = self.clients_dict[path]

520

604

except KeyError:

521

605

# not found?

606

self.log_message("Unknown client %r (%r) removed", name,

607

path)

522

608

return

523

self.remove_client(client, path)

609

client.delete()

524

610

525

611

def add_new_client(self, path):

526

612

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

541

627

if path is None:

542

628

path = client.proxy.object_path

543

629

self.clients_dict[path] = client

544

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

630

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

545

631

self.refresh()

546

632

547

633

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

578

664

579

665

def process_input(self, source, condition):

580

666

keys = self.screen.get_input()

581

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

582

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

583

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

584

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

585

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

586

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

587

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

588

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

589

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

667

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

668

"ctrl p": "up", # Emacs

669

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

670

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

671

" ": "page down", # less

672

"f": "page down", # less

673

"b": "page up", # less

674

"j": "down", # vi

675

"k": "up", # vi

590

676

}

591

677

for key in keys:

592

678

try:

594

680

except KeyError: # :-)

595

681

pass

596

682

597

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

683

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

598

684

self.stop()

599

685

break

600

elif key == u"window resize":

686

elif key == "window resize":

601

687

self.size = self.screen.get_cols_rows()

602

688

self.refresh()

603

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

689

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

604

690

self.refresh()

605

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

691

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

606

692

self.toggle_log_display()

607

693

self.refresh()

608

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

694

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

609

695

self.change_log_display()

610

696

self.refresh()

611

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

697

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

612

698

if not self.log_visible:

613

699

self.log_visible = True

614

700

self.rebuild()

615

self.log_message_raw((u"bold",

616

u" ".

617

join((u"q: Quit",

618

u"?: Help",

619

u"l: Log window toggle",

620

u"TAB: Switch window",

621

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

622

self.log_message_raw((u"bold",

623

u" "

624

.join((u"Clients:",

625

u"+: Enable",

626

u"-: Disable",

627

u"r: Remove",

628

u"s: Start new checker",

629

u"S: Stop checker",

630

u"C: Checker OK",

631

u"a: Approve",

632

u"d: Deny"))))

701

self.log_message_raw(("bold",

702

" ".

703

join(("q: Quit",

704

"?: Help",

705

"l: Log window toggle",

706

"TAB: Switch window",

707

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

708

self.log_message_raw(("bold",

709

" "

710

.join(("Clients:",

711

"+: Enable",

712

"-: Disable",

713

"R: Remove",

714

"s: Start new checker",

715

"S: Stop checker",

716

"C: Checker OK",

717

"a: Approve",

718

"d: Deny"))))

633

719

self.refresh()

634

elif key == u"tab":

720

elif key == "tab":

635

721

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

636

722

self.topwidget.set_focus(0)

637

723

else:

638

724

self.topwidget.set_focus(self.logbox)

639

725

self.refresh()

640

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

641

# or key == u">"):

726

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

727

# or key == ">"):

642

728

# pass # xxx end-of-buffer

643

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

644

# or key == u"<"):

729

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

730

# or key == "<"):

645

731

# pass # xxx beginning-of-buffer

646

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

732

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

647

733

# pass # xxx move-end-of-line

648

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

734

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

649

735

# pass # xxx move-beginning-of-line

650

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

736

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

651

737

# pass # xxx left

652

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

738

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

653

739

# pass # xxx right

654

#elif key == u"a":

740

#elif key == "a":

655

741

# pass # scroll up log

656

#elif key == u"z":

742

#elif key == "z":

657

743

# pass # scroll down log

658

744

elif self.topwidget.selectable():

659

745

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

663

749

ui = UserInterface()

664

750

try:

665

751

ui.run()

752

except KeyboardInterrupt:

753

ui.screen.stop()

666

754

except Exception, e:

667

755

ui.log_message(unicode(e))

668

756

ui.screen.stop()