/mandos/release : revision 367

1

#!/usr/bin/python

2

# -*- mode: python; coding: utf-8 -*-

3

#

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

5

#

6

7

8

#

9

# This file is part of Mandos.

10

#

11

# Mandos is free software: you can redistribute it and/or modify it

12

# under the terms of the GNU General Public License as published by

11

13

# the Free Software Foundation, either version 3 of the License, or

12

14

# (at your option) any later version.

13

15

#

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

# Mandos is distributed in the hope that it will be useful, but

17

# WITHOUT ANY WARRANTY; without even the implied warranty of

16

18

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

17

19

# GNU General Public License for more details.

18

#

20

#

19

21

# You should have received a copy of the GNU General Public License

20

# along with this program. If not, see

21

# <http://www.gnu.org/licenses/>.

22

#

22

# along with Mandos. If not, see <http://www.gnu.org/licenses/>.

23

#

23

24

# Contact the authors at <mandos@recompile.se>.

24

#

25

#

25

26

27

from __future__ import (division, absolute_import, print_function,

27

28

unicode_literals)

39

40

import urwid

40

41

42

from dbus.mainloop.glib import DBusGMainLoop

42

try:

43

import gobject

44

except ImportError:

45

from gi.repository import GObject as gobject

43

from gi.repository import GLib

46

44

47

45

import dbus

48

46

49

47

import locale

50

48

49

import logging

50

51

if sys.version_info.major == 2:

52

str = unicode

53

54

locale.setlocale(locale.LC_ALL, '')

55

56

import logging

57

56

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

58

57

59

58

# Some useful constants

60

59

domain = 'se.recompile'

61

60

server_interface = domain + '.Mandos'

62

61

client_interface = domain + '.Mandos.Client'

63

version = "1.7.3"

62

version = "1.7.19"

64

63

65

64

try:

66

65

dbus.OBJECT_MANAGER_IFACE

67

66

except AttributeError:

68

67

dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"

69

68

69

70

def isoformat_to_datetime(iso):

71

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

72

if not iso:

80

int(day),

81

int(hour),

82

int(minute),

83

int(second), # Whole seconds

84

int(fraction*1000000)) # Microseconds

83

int(second), # Whole seconds

84

int(fraction*1000000)) # Microseconds

85

86

87

class MandosClientPropertyCache(object):

87

88

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

89

90

changed.

90

91

"""

91

92

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

92

self.proxy = proxy_object # Mandos Client proxy object

93

self.proxy = proxy_object # Mandos Client proxy object

93

94

self.properties = dict() if properties is None else properties

94

95

self.property_changed_match = (

95

96

self.proxy.connect_to_signal("PropertiesChanged",

96

97

self.properties_changed,

97

98

dbus.PROPERTIES_IFACE,

98

99

byte_arrays=True))

99

100

101

if properties is None:

101

self.properties.update(

102

self.proxy.GetAll(client_interface,

103

dbus_interface

104

= dbus.PROPERTIES_IFACE))

105

102

self.properties.update(self.proxy.GetAll(

103

client_interface,

104

dbus_interface=dbus.PROPERTIES_IFACE))

105

106

super(MandosClientPropertyCache, self).__init__(**kwargs)

107

108

def properties_changed(self, interface, properties, invalidated):

109

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

110

It updates the changed properties in the "properties" dict.

112

# Update properties dict with new value

113

if interface == client_interface:

114

self.properties.update(properties)

115

116

def delete(self):

117

self.property_changed_match.remove()

118

120

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

121

"""A Mandos Client which is visible on the screen.

122

"""

123

124

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

125

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

126

# Called on update

131

self.server_proxy_object = server_proxy_object

132

# Logger

133

self.logger = logger

134

135

self._update_timer_callback_tag = None

136

137

# The widget shown normally

138

self._text_widget = urwid.Text("")

139

# The widget shown when we have focus

141

super(MandosClientWidget, self).__init__(**kwargs)

142

self.update()

143

self.opened = False

144

145

self.match_objects = (

146

self.proxy.connect_to_signal("CheckerCompleted",

147

self.checker_completed,

165

byte_arrays=True))

166

self.logger('Created client {}'

167

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

168

169

def using_timer(self, flag):

170

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

171

activated or deactivated.

172

"""

173

if flag and self._update_timer_callback_tag is None:

174

# Will update the shown timer value every second

175

self._update_timer_callback_tag = (gobject.timeout_add

175

self._update_timer_callback_tag = (GLib.timeout_add

176

(1000,

177

self.update_timer))

178

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

179

gobject.source_remove(self._update_timer_callback_tag)

179

GLib.source_remove(self._update_timer_callback_tag)

180

self._update_timer_callback_tag = None

181

182

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

183

if exitstatus == 0:

184

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

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

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

205

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

206

command), level=0)

207

208

def got_secret(self):

209

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

210

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

211

212

def need_approval(self, timeout, default):

213

if not default:

214

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

216

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

217

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

218

timeout/1000))

219

220

def rejected(self, reason):

221

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

222

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

223

224

def selectable(self):

225

"""Make this a "selectable" widget.

226

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

227

return True

228

229

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

230

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

231

whether we have focus or not.

232

This overrides the method from urwid.FlowWidget"""

233

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

234

235

def current_widget(self, focus=False):

236

if focus or self.opened:

237

return self._focus_widget

238

return self._widget

239

240

def update(self):

241

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

242

# How to add standout mode to a style

243

with_standout = { "normal": "standout",

244

"bold": "bold-standout",

245

"underline-blink":

246

"underline-blink-standout",

247

"bold-underline-blink":

248

"bold-underline-blink-standout",

249

}

250

243

with_standout = {"normal": "standout",

244

"bold": "bold-standout",

245

"underline-blink":

246

"underline-blink-standout",

247

"bold-underline-blink":

248

"bold-underline-blink-standout",

249

}

250

251

# Rebuild focus and non-focus widgets using current properties

252

253

# Base part of a client. Name!

254

base = '{name}: '.format(name=self.properties["Name"])

255

if not self.properties["Enabled"]:

256

message = "DISABLED"

257

self.using_timer(False)

258

elif self.properties["ApprovalPending"]:

259

timeout = datetime.timedelta(milliseconds

260

= self.properties

261

["ApprovalDelay"])

259

timeout = datetime.timedelta(

260

milliseconds=self.properties["ApprovalDelay"])

262

261

last_approval_request = isoformat_to_datetime(

263

262

self.properties["LastApprovalRequest"])

264

263

if last_approval_request is not None:

291

290

message = "enabled"

292

291

self.using_timer(False)

293

292

self._text = "{}{}".format(base, message)

294

293

295

294

if not urwid.supports_unicode():

296

295

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

297

296

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

307

306

# Run update hook, if any

308

307

if self.update_hook is not None:

309

308

self.update_hook()

310

309

311

310

def update_timer(self):

312

"""called by gobject. Will indefinitely loop until

313

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

311

"""called by GLib. Will indefinitely loop until

312

GLib.source_remove() on tag is called

313

"""

314

self.update()

315

return True # Keep calling this

316

317

def delete(self, **kwargs):

318

if self._update_timer_callback_tag is not None:

319

gobject.source_remove(self._update_timer_callback_tag)

319

GLib.source_remove(self._update_timer_callback_tag)

320

self._update_timer_callback_tag = None

321

for match in self.match_objects:

322

match.remove()

324

if self.delete_hook is not None:

325

self.delete_hook(self)

326

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

327

328

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

329

"""Render differently if we have focus.

330

This overrides the method from urwid.FlowWidget"""

331

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

332

focus=focus)

333

334

def keypress(self, maxcolrow, key):

335

"""Handle keys.

336

This overrides the method from urwid.FlowWidget"""

337

if key == "+":

338

self.proxy.Set(client_interface, "Enabled",

339

dbus.Boolean(True), ignore_reply = True,

340

dbus_interface = dbus.PROPERTIES_IFACE)

339

dbus.Boolean(True), ignore_reply=True,

340

dbus_interface=dbus.PROPERTIES_IFACE)

341

elif key == "-":

342

self.proxy.Set(client_interface, "Enabled", False,

343

ignore_reply = True,

344

dbus_interface = dbus.PROPERTIES_IFACE)

343

ignore_reply=True,

344

dbus_interface=dbus.PROPERTIES_IFACE)

345

elif key == "a":

346

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

347

dbus_interface = client_interface,

347

dbus_interface=client_interface,

348

ignore_reply=True)

349

elif key == "d":

350

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

351

dbus_interface = client_interface,

351

dbus_interface=client_interface,

352

ignore_reply=True)

353

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

354

self.server_proxy_object.RemoveClient(self.proxy

356

ignore_reply=True)

357

elif key == "s":

358

self.proxy.Set(client_interface, "CheckerRunning",

359

dbus.Boolean(True), ignore_reply = True,

360

dbus_interface = dbus.PROPERTIES_IFACE)

359

dbus.Boolean(True), ignore_reply=True,

360

dbus_interface=dbus.PROPERTIES_IFACE)

361

elif key == "S":

362

self.proxy.Set(client_interface, "CheckerRunning",

363

dbus.Boolean(False), ignore_reply = True,

364

dbus_interface = dbus.PROPERTIES_IFACE)

363

dbus.Boolean(False), ignore_reply=True,

364

dbus_interface=dbus.PROPERTIES_IFACE)

365

elif key == "C":

366

self.proxy.CheckedOK(dbus_interface = client_interface,

366

self.proxy.CheckedOK(dbus_interface=client_interface,

367

ignore_reply=True)

368

# xxx

369

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

374

# self.open()

375

else:

376

return key

377

378

def properties_changed(self, interface, properties, invalidated):

379

"""Call self.update() if any properties changed.

380

This overrides the method from MandosClientPropertyCache"""

381

old_values = { key: self.properties.get(key)

382

for key in properties.keys() }

381

old_values = {key: self.properties.get(key)

382

for key in properties.keys()}

383

super(MandosClientWidget, self).properties_changed(

384

interface, properties, invalidated)

385

if any(old_values[key] != self.properties.get(key)

393

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

394

"""

395

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

396

ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)

396

ret = (super(ConstrainedListBox, self)

397

.keypress(*args, **kwargs))

397

398

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

398

399

return

399

400

return ret

405

406

"""

406

407

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

407

408

DBusGMainLoop(set_as_default=True)

408

409

410

self.screen = urwid.curses_display.Screen()

410

411

412

self.screen.register_palette((

412

413

("normal",

413

414

"default", "default", None),

418

419

("standout",

419

420

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

420

421

("bold-underline-blink",

421

"bold,underline,blink", "default", "bold,underline,blink"),

422

"bold,underline,blink", "default",

423

"bold,underline,blink"),

422

424

("bold-standout",

423

425

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

424

426

("underline-blink-standout",

428

430

"bold,underline,blink,standout", "default",

429

431

"bold,underline,blink,standout"),

430

432

))

431

433

432

434

if urwid.supports_unicode():

433

self.divider = "─" # \u2500

434

#self.divider = "━" # \u2501

435

self.divider = "─" # \u2500

435

436

else:

436

#self.divider = "-" # \u002d

437

self.divider = "_" # \u005f

438

437

self.divider = "_" # \u005f

438

439

self.screen.start()

440

441

self.size = self.screen.get_cols_rows()

442

443

self.clients = urwid.SimpleListWalker([])

444

self.clients_dict = {}

445

446

# We will add Text widgets to this list

447

self.log = []

448

self.max_log_length = max_log_length

449

450

self.log_level = log_level

451

452

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

453

# from the ListWalker without it getting destroyed

454

self.logbox = ConstrainedListBox(self.log)

455

456

# This keeps track of whether self.uilist currently has

457

# self.logbox in it or not

458

self.log_visible = True

459

self.log_wrap = "any"

460

461

self.rebuild()

462

self.log_message_raw(("bold",

463

"Mandos Monitor version " + version))

464

self.log_message_raw(("bold",

465

"q: Quit ?: Help"))

466

467

self.busname = domain + '.Mandos'

468

self.main_loop = gobject.MainLoop()

469

468

self.main_loop = GLib.MainLoop()

469

470

def client_not_found(self, fingerprint, address):

471

self.log_message("Client with address {} and fingerprint {}"

472

" could not be found"

473

.format(address, fingerprint))

474

475

def rebuild(self):

476

"""This rebuilds the User Interface.

477

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

478

self.uilist = []

479

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

479

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

480

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

481

clients),

482

#header=urwid.Divider(),

482

# header=urwid.Divider(),

483

header=None,

484

footer=

485

urwid.Divider(div_char=

486

self.divider)))

484

footer=urwid.Divider(

485

div_char=self.divider)))

487

486

if self.log_visible:

488

487

self.uilist.append(self.logbox)

489

488

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

490

489

491

490

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

492

491

"""Log message formatted with timestamp"""

493

492

if level < self.log_level:

495

494

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

496

495

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

497

496

level=level)

498

497

499

498

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

500

499

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

501

500

if level < self.log_level:

502

501

return

503

502

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

504

if (self.max_log_length

505

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

506

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

503

if self.max_log_length:

504

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

505

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

507

506

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

508

507

coming_from="above")

509

508

self.refresh()

510

509

511

510

def toggle_log_display(self):

512

511

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

513

512

self.log_visible = not self.log_visible

514

513

self.rebuild()

515

514

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

516

515

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

517

516

518

517

def change_log_display(self):

519

518

"""Change type of log display.

520

519

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

526

525

textwidget.set_wrap_mode(self.log_wrap)

527

526

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

528

527

level=0)

529

528

530

529

def find_and_remove_client(self, path, interfaces):

531

530

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

532

531

533

532

This is connected to the InterfacesRemoved signal from the

534

533

Mandos server object."""

535

534

if client_interface not in interfaces:

543

542

.format(path))

544

543

return

545

544

client.delete()

546

545

547

546

def add_new_client(self, path, ifs_and_props):

548

547

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

549

548

550

549

This is connected to the InterfacesAdded signal from the

551

550

Mandos server object.

552

551

"""

554

553

# Not a Mandos client object; ignore

555

554

return

556

555

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

557

self.add_client(MandosClientWidget(server_proxy_object

558

=self.mandos_serv,

559

proxy_object

560

=client_proxy_object,

561

update_hook

562

=self.refresh,

563

delete_hook

564

=self.remove_client,

565

logger

566

=self.log_message,

567

properties

568

= dict(ifs_and_props[

569

client_interface])),

556

self.add_client(MandosClientWidget(

557

server_proxy_object=self.mandos_serv,

558

proxy_object=client_proxy_object,

559

update_hook=self.refresh,

560

delete_hook=self.remove_client,

561

logger=self.log_message,

562

properties=dict(ifs_and_props[client_interface])),

570

563

path=path)

571

564

572

565

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

573

566

self.clients.append(client)

574

567

if path is None:

576

569

self.clients_dict[path] = client

577

570

self.clients.sort(key=lambda c: c.properties["Name"])

578

571

self.refresh()

579

572

580

573

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

581

574

self.clients.remove(client)

582

575

if path is None:

583

576

path = client.proxy.object_path

584

577

del self.clients_dict[path]

585

578

self.refresh()

586

579

587

580

def refresh(self):

588

581

"""Redraw the screen"""

589

582

canvas = self.topwidget.render(self.size, focus=True)

590

583

self.screen.draw_screen(self.size, canvas)

591

584

592

585

def run(self):

593

586

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

594

587

self.bus = dbus.SystemBus()

595

588

mandos_dbus_objc = self.bus.get_object(

596

589

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

597

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

598

dbus_interface

599

= server_interface)

590

self.mandos_serv = dbus.Interface(

591

mandos_dbus_objc, dbus_interface=server_interface)

600

592

try:

601

593

mandos_clients = (self.mandos_serv

602

594

.GetAllClientsWithProperties())

603

595

if not mandos_clients:

604

self.log_message_raw(("bold", "Note: Server has no clients."))

596

self.log_message_raw(("bold",

597

"Note: Server has no clients."))

605

598

except dbus.exceptions.DBusException:

606

self.log_message_raw(("bold", "Note: No Mandos server running."))

599

self.log_message_raw(("bold",

600

"Note: No Mandos server running."))

607

601

mandos_clients = dbus.Dictionary()

608

602

609

603

(self.mandos_serv

610

604

.connect_to_signal("InterfacesRemoved",

611

605

self.find_and_remove_client,

612

dbus_interface

613

= dbus.OBJECT_MANAGER_IFACE,

606

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

614

607

byte_arrays=True))

615

608

(self.mandos_serv

616

609

.connect_to_signal("InterfacesAdded",

617

610

self.add_new_client,

618

dbus_interface

619

= dbus.OBJECT_MANAGER_IFACE,

611

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

620

612

byte_arrays=True))

621

613

(self.mandos_serv

622

614

.connect_to_signal("ClientNotFound",

626

618

for path, client in mandos_clients.items():

627

619

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

628

620

path)

629

self.add_client(MandosClientWidget(server_proxy_object

630

=self.mandos_serv,

631

proxy_object

632

=client_proxy_object,

633

properties=client,

634

update_hook

635

=self.refresh,

636

delete_hook

637

=self.remove_client,

638

logger

639

=self.log_message),

621

self.add_client(MandosClientWidget(

622

server_proxy_object=self.mandos_serv,

623

proxy_object=client_proxy_object,

624

properties=client,

625

update_hook=self.refresh,

626

delete_hook=self.remove_client,

627

logger=self.log_message),

640

628

path=path)

641

629

642

630

self.refresh()

643

self._input_callback_tag = (gobject.io_add_watch

631

self._input_callback_tag = (GLib.io_add_watch

644

632

(sys.stdin.fileno(),

645

gobject.IO_IN,

633

GLib.IO_IN,

646

634

self.process_input))

647

635

self.main_loop.run()

648

636

# Main loop has finished, we should close everything now

649

gobject.source_remove(self._input_callback_tag)

637

GLib.source_remove(self._input_callback_tag)

650

638

self.screen.stop()

651

639

652

640

def stop(self):

653

641

self.main_loop.quit()

654

642

655

643

def process_input(self, source, condition):

656

644

keys = self.screen.get_input()

657

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

658

"ctrl p": "up", # Emacs

659

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

660

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

661

" ": "page down", # less

662

"f": "page down", # less

663

"b": "page up", # less

664

"j": "down", # vi

665

"k": "up", # vi

666

}

645

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

646

"ctrl p": "up", # Emacs

647

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

648

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

649

" ": "page down", # less

650

"f": "page down", # less

651

"b": "page up", # less

652

"j": "down", # vi

653

"k": "up", # vi

654

}

667

655

for key in keys:

668

656

try:

669

657

key = translations[key]

670

658

except KeyError: # :-)

671

659

pass

672

660

673

661

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

674

662

self.stop()

675

663

break

723

711

else:

724

712

self.log_level = 0

725

713

self.log_message("Verbose mode: On")

726

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

727

# or key == ">"):

728

# pass # xxx end-of-buffer

729

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

730

# or key == "<"):

731

# pass # xxx beginning-of-buffer

732

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

733

# pass # xxx move-end-of-line

734

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

735

# pass # xxx move-beginning-of-line

736

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

737

# pass # xxx left

738

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

739

# pass # xxx right

740

#elif key == "a":

741

# pass # scroll up log

742

#elif key == "z":

743

# pass # scroll down log

714

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

715

# or key == ">"):

716

# pass # xxx end-of-buffer

717

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

718

# or key == "<"):

719

# pass # xxx beginning-of-buffer

720

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

721

# pass # xxx move-end-of-line

722

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

723

# pass # xxx move-beginning-of-line

724

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

725

# pass # xxx left

726

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

727

# pass # xxx right

728

# elif key == "a":

729

# pass # scroll up log

730

# elif key == "z":

731

# pass # scroll down log

744

732

elif self.topwidget.selectable():

745

733

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

746

734

self.refresh()

747

735

return True

748

736

737

749

738

ui = UserInterface()

750

739

try:

751

740

ui.run()