/mandos/trunk : revision 1177

51

if sys.version_info.major == 2:

52

str = unicode

53

54

log = logging.getLogger(os.path.basename(sys.argv[0]))

55

logging.basicConfig(level="NOTSET", # Show all messages

56

format="%(message)s") # Show basic log messages

57

58

logging.captureWarnings(True) # Show warnings via the logging system

59

60

54

locale.setlocale(locale.LC_ALL, '')

61

55

62

56

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

128

122

"""

129

123

130

124

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

131

delete_hook=None, **kwargs):

125

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

132

126

# Called on update

133

127

self.update_hook = update_hook

134

128

# Called on delete

135

129

self.delete_hook = delete_hook

136

130

# Mandos Server proxy object

137

131

self.server_proxy_object = server_proxy_object

132

# Logger

133

self.logger = logger

138

134

139

135

self._update_timer_callback_tag = None

140

136

167

163

self.rejected,

168

164

client_interface,

169

165

byte_arrays=True))

170

log.debug('Created client %s', self.properties["Name"])

166

self.logger('Created client {}'

167

.format(self.properties["Name"]), level=0)

171

168

172

169

def using_timer(self, flag):

173

170

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

175

172

"""

176

173

if flag and self._update_timer_callback_tag is None:

177

174

# Will update the shown timer value every second

178

self._update_timer_callback_tag = (

179

GLib.timeout_add(1000,

180

glib_safely(self.update_timer)))

175

self._update_timer_callback_tag = (GLib.timeout_add

176

(1000,

177

self.update_timer))

181

178

elif not (flag or self._update_timer_callback_tag is None):

182

179

GLib.source_remove(self._update_timer_callback_tag)

183

180

self._update_timer_callback_tag = None

184

181

185

182

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

186

183

if exitstatus == 0:

187

log.debug('Checker for client %s (command "%s")'

188

' succeeded', self.properties["Name"], command)

184

self.logger('Checker for client {} (command "{}")'

185

' succeeded'.format(self.properties["Name"],

186

command), level=0)

189

187

self.update()

190

188

return

191

189

# Checker failed

192

190

if os.WIFEXITED(condition):

193

log.info('Checker for client %s (command "%s") failed'

194

' with exit code %d', self.properties["Name"],

195

command, os.WEXITSTATUS(condition))

191

self.logger('Checker for client {} (command "{}") failed'

192

' with exit code {}'

193

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

194

os.WEXITSTATUS(condition)))

196

195

elif os.WIFSIGNALED(condition):

197

log.info('Checker for client %s (command "%s") was'

198

' killed by signal %d', self.properties["Name"],

199

command, os.WTERMSIG(condition))

196

self.logger('Checker for client {} (command "{}") was'

197

' killed by signal {}'

198

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

199

os.WTERMSIG(condition)))

200

self.update()

201

202

def checker_started(self, command):

203

"""Server signals that a checker started."""

204

log.debug('Client %s started checker "%s"',

205

self.properties["Name"], command)

204

self.logger('Client {} started checker "{}"'

205

.format(self.properties["Name"],

206

command), level=0)

206

207

208

def got_secret(self):

208

log.info("Client %s received its secret",

209

self.properties["Name"])

209

self.logger('Client {} received its secret'

210

.format(self.properties["Name"]))

210

211

212

def need_approval(self, timeout, default):

212

213

if not default:

213

message = "Client %s needs approval within %f seconds"

214

message = 'Client {} needs approval within {} seconds'

214

215

else:

215

message = "Client %s will get its secret in %f seconds"

216

log.info(message, self.properties["Name"], timeout/1000)

216

message = 'Client {} will get its secret in {} seconds'

217

self.logger(message.format(self.properties["Name"],

218

timeout/1000))

217

219

218

220

def rejected(self, reason):

219

log.info("Client %s was rejected; reason: %s",

220

self.properties["Name"], reason)

221

self.logger('Client {} was rejected; reason: {}'

222

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

221

223

222

224

def selectable(self):

223

225

"""Make this a "selectable" widget.

385

387

self.update()

386

388

387

389

388

def glib_safely(func, retval=True):

389

def safe_func(*args, **kwargs):

390

try:

391

return func(*args, **kwargs)

392

except Exception:

393

log.exception("")

394

return retval

395

return safe_func

396

397

398

390

class ConstrainedListBox(urwid.ListBox):

399

391

"""Like a normal urwid.ListBox, but will consume all "up" or

400

392

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

412

404

"""This is the entire user interface - the whole screen

413

405

with boxes, lists of client widgets, etc.

414

406

"""

415

def __init__(self, max_log_length=1000):

407

def __init__(self, max_log_length=1000, log_level=1):

416

408

DBusGMainLoop(set_as_default=True)

417

409

418

410

self.screen = urwid.curses_display.Screen()

455

447

self.log = urwid.SimpleListWalker([])

456

448

self.max_log_length = max_log_length

457

449

450

self.log_level = log_level

451

458

452

# We keep a reference to the log widget so we can remove it

459

453

# from the ListWalker without it getting destroyed

460

454

self.logbox = ConstrainedListBox(self.log)

464

458

self.log_visible = True

465

459

self.log_wrap = "any"

466

460

467

self.loghandler = UILogHandler(self)

468

469

461

self.rebuild()

470

self.add_log_line(("bold",

471

"Mandos Monitor version " + version))

472

self.add_log_line(("bold", "q: Quit ?: Help"))

462

self.log_message_raw(("bold",

463

"Mandos Monitor version " + version))

464

self.log_message_raw(("bold",

465

"q: Quit ?: Help"))

473

466

474

467

self.busname = domain + '.Mandos'

475

468

self.main_loop = GLib.MainLoop()

476

469

477

470

def client_not_found(self, key_id, address):

478

log.info("Client with address %s and key ID %s could"

479

" not be found", address, key_id)

471

self.log_message("Client with address {} and key ID {} could"

472

" not be found".format(address, key_id))

480

473

481

474

def rebuild(self):

482

475

"""This rebuilds the User Interface.

493

486

self.uilist.append(self.logbox)

494

487

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

495

488

496

def add_log_line(self, markup):

489

def log_message(self, message, level=1):

490

"""Log message formatted with timestamp"""

491

if level < self.log_level:

492

return

493

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

494

self.log_message_raw("{}: {}".format(timestamp, message),

495

level=level)

496

497

def log_message_raw(self, markup, level=1):

498

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

499

if level < self.log_level:

500

return

497

501

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

498

502

if self.max_log_length:

499

503

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

500

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

504

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

501

505

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

502

506

coming_from="above")

503

507

self.refresh()

506

510

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

507

511

self.log_visible = not self.log_visible

508

512

self.rebuild()

509

log.debug("Log visibility changed to: %s", self.log_visible)

513

self.log_message("Log visibility changed to: {}"

514

.format(self.log_visible), level=0)

510

515

511

516

def change_log_display(self):

512

517

"""Change type of log display.

517

522

self.log_wrap = "clip"

518

523

for textwidget in self.log:

519

524

textwidget.set_wrap_mode(self.log_wrap)

520

log.debug("Wrap mode: %s", self.log_wrap)

525

self.log_message("Wrap mode: {}".format(self.log_wrap),

526

level=0)

521

527

522

528

def find_and_remove_client(self, path, interfaces):

523

529

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

531

537

client = self.clients_dict[path]

532

538

except KeyError:

533

539

# not found?

534

log.warning("Unknown client %s removed", path)

540

self.log_message("Unknown client {!r} removed"

541

.format(path))

535

542

return

536

543

client.delete()

537

544

550

557

proxy_object=client_proxy_object,

551

558

update_hook=self.refresh,

552

559

delete_hook=self.remove_client,

560

logger=self.log_message,

553

561

properties=dict(ifs_and_props[client_interface])),

554

562

path=path)

555

563

575

583

576

584

def run(self):

577

585

"""Start the main loop and exit when it's done."""

578

log.addHandler(self.loghandler)

579

self.orig_log_propagate = log.propagate

580

log.propagate = False

581

self.orig_log_level = log.level

582

log.setLevel("INFO")

583

586

self.bus = dbus.SystemBus()

584

587

mandos_dbus_objc = self.bus.get_object(

585

588

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

589

592

mandos_clients = (self.mandos_serv

590

593

.GetAllClientsWithProperties())

591

594

if not mandos_clients:

592

log.warning("Note: Server has no clients.")

595

self.log_message_raw(("bold",

596

"Note: Server has no clients."))

593

597

except dbus.exceptions.DBusException:

594

log.warning("Note: No Mandos server running.")

598

self.log_message_raw(("bold",

599

"Note: No Mandos server running."))

595

600

mandos_clients = dbus.Dictionary()

596

601

597

602

(self.mandos_serv

617

622

proxy_object=client_proxy_object,

618

623

properties=client,

619

624

update_hook=self.refresh,

620

delete_hook=self.remove_client),

625

delete_hook=self.remove_client,

626

logger=self.log_message),

621

627

path=path)

622

628

623

629

self.refresh()

625

631

GLib.io_add_watch(

626

632

GLib.IOChannel.unix_new(sys.stdin.fileno()),

627

633

GLib.PRIORITY_DEFAULT, GLib.IO_IN,

628

glib_safely(self.process_input)))

634

self.process_input))

629

635

self.main_loop.run()

630

636

# Main loop has finished, we should close everything now

631

637

GLib.source_remove(self._input_callback_tag)

635

641

636

642

def stop(self):

637

643

self.main_loop.quit()

638

log.removeHandler(self.loghandler)

639

log.propagate = self.orig_log_propagate

640

644

641

645

def process_input(self, source, condition):

642

646

keys = self.screen.get_input()

675

679

if not self.log_visible:

676

680

self.log_visible = True

677

681

self.rebuild()

678

self.add_log_line(("bold",

679

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

680

"?: Help",

681

"l: Log window toggle",

682

"TAB: Switch window",

683

"w: Wrap (log lines)",

684

"v: Toggle verbose log",

685

))))

686

self.add_log_line(("bold",

687

" ".join(("Clients:",

688

"+: Enable",

689

"-: Disable",

690

"R: Remove",

691

"s: Start new checker",

692

"S: Stop checker",

693

"C: Checker OK",

694

"a: Approve",

695

"d: Deny",

696

))))

682

self.log_message_raw(("bold",

683

" ".

684

join(("q: Quit",

685

"?: Help",

686

"l: Log window toggle",

687

"TAB: Switch window",

688

"w: Wrap (log lines)",

689

"v: Toggle verbose log",

690

))))

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

697

702

self.refresh()

698

703

elif key == "tab":

699

704

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

702

707

self.topwidget.set_focus(self.logbox)

703

708

self.refresh()

704

709

elif key == "v":

705

if log.level < logging.INFO:

706

log.setLevel(logging.INFO)

707

log.info("Verbose mode: Off")

710

if self.log_level == 0:

711

self.log_level = 1

712

self.log_message("Verbose mode: Off")

708

713

else:

709

log.setLevel(logging.NOTSET)

710

log.info("Verbose mode: On")

714

self.log_level = 0

715

self.log_message("Verbose mode: On")

711

716

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

712

717

# or key == ">"):

713

718

# pass # xxx end-of-buffer

732

737

return True

733

738

734

739

735

class UILogHandler(logging.Handler):

736

def __init__(self, ui, *args, **kwargs):

737

self.ui = ui

738

super(UILogHandler, self).__init__(*args, **kwargs)

739

self.setFormatter(

740

logging.Formatter("%(asctime)s: %(message)s"))

741

def emit(self, record):

742

msg = self.format(record)

743

if record.levelno > logging.INFO:

744

msg = ("bold", msg)

745

self.ui.add_log_line(msg)

746

747

748

740

ui = UserInterface()

749

741

try:

750

742

ui.run()

751

743

except KeyboardInterrupt:

752

with warnings.catch_warnings():

753

warnings.filterwarnings("ignore", "", BytesWarning)

754

ui.screen.stop()

755

except Exception:

756

with warnings.catch_warnings():

757

warnings.filterwarnings("ignore", "", BytesWarning)

758

ui.screen.stop()

744

ui.screen.stop()

745

except Exception as e:

746

ui.log_message(str(e))

747

ui.screen.stop()

759

748

raise