/mandos/release : revision 328

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

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

13

11

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

14

12

# (at your option) any later version.

15

13

#

16

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

17

# WITHOUT ANY WARRANTY; without even the implied warranty of

14

# This program is distributed in the hope that it will be useful,

15

# but WITHOUT ANY WARRANTY; without even the implied warranty of

18

16

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

19

17

# GNU General Public License for more details.

20

#

18

#

21

19

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

22

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

23

#

20

# along with this program. If not, see

21

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

22

#

24

23

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

25

#

24

#

26

25

27

26

from __future__ import (division, absolute_import, print_function,

28

27

unicode_literals)

40

39

import urwid

41

40

42

41

from dbus.mainloop.glib import DBusGMainLoop

43

from gi.repository import GLib

42

try:

43

import gobject

44

except ImportError:

45

from gi.repository import GObject as gobject

44

46

45

47

import dbus

46

48

47

49

import locale

48

50

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

56

57

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

57

58

59

# Some useful constants

59

60

domain = 'se.recompile'

60

61

server_interface = domain + '.Mandos'

61

62

client_interface = domain + '.Mandos.Client'

62

version = "1.7.16"

63

version = "1.7.1"

63

64

65

try:

65

66

dbus.OBJECT_MANAGER_IFACE

66

67

except AttributeError:

67

68

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

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

85

83

int(second), # Whole seconds

84

int(fraction*1000000)) # Microseconds

86

85

87

86

class MandosClientPropertyCache(object):

88

87

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

90

89

changed.

91

90

"""

92

91

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

93

self.proxy = proxy_object # Mandos Client proxy object

92

self.proxy = proxy_object # Mandos Client proxy object

94

93

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

95

94

self.property_changed_match = (

96

95

self.proxy.connect_to_signal("PropertiesChanged",

97

96

self.properties_changed,

98

97

dbus.PROPERTIES_IFACE,

99

98

byte_arrays=True))

100

99

101

100

if properties is None:

102

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

103

client_interface,

104

dbus_interface=dbus.PROPERTIES_IFACE))

105

101

self.properties.update(

102

self.proxy.GetAll(client_interface,

103

dbus_interface

104

= 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 = (GLib.timeout_add

175

self._update_timer_callback_tag = (gobject.timeout_add

176

(1000,

177

self.update_timer))

178

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

179

GLib.source_remove(self._update_timer_callback_tag)

179

gobject.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(

260

milliseconds=self.properties["ApprovalDelay"])

259

timeout = datetime.timedelta(milliseconds

260

= self.properties

261

["ApprovalDelay"])

261

262

last_approval_request = isoformat_to_datetime(

262

263

self.properties["LastApprovalRequest"])

263

264

if last_approval_request is not None:

290

291

message = "enabled"

291

292

self.using_timer(False)

292

293

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

293

294

295

if not urwid.supports_unicode():

295

296

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

296

297

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

306

307

# Run update hook, if any

307

308

if self.update_hook is not None:

308

309

self.update_hook()

309

310

311

def update_timer(self):

311

"""called by GLib. Will indefinitely loop until

312

GLib.source_remove() on tag is called

313

"""

312

"""called by gobject. Will indefinitely loop until

313

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

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

GLib.source_remove(self._update_timer_callback_tag)

319

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

397

.keypress(*args, **kwargs))

396

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

398

397

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

399

398

return

400

399

return ret

406

405

"""

407

406

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

408

407

DBusGMainLoop(set_as_default=True)

409

408

410

409

self.screen = urwid.curses_display.Screen()

411

410

412

411

self.screen.register_palette((

413

412

("normal",

414

413

"default", "default", None),

419

418

("standout",

420

419

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

421

420

("bold-underline-blink",

422

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

423

"bold,underline,blink"),

421

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

424

422

("bold-standout",

425

423

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

426

424

("underline-blink-standout",

430

428

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

431

429

"bold,underline,blink,standout"),

432

430

))

433

431

434

432

if urwid.supports_unicode():

435

self.divider = "─" # \u2500

433

self.divider = "─" # \u2500

434

#self.divider = "━" # \u2501

436

435

else:

437

self.divider = "_" # \u005f

438

436

#self.divider = "-" # \u002d

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 = GLib.MainLoop()

469

468

self.main_loop = gobject.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=urwid.Divider(

485

div_char=self.divider)))

484

footer=

485

urwid.Divider(div_char=

486

self.divider)))

486

487

if self.log_visible:

487

488

self.uilist.append(self.logbox)

488

489

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

489

490

491

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

491

492

"""Log message formatted with timestamp"""

492

493

if level < self.log_level:

494

495

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

495

496

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

496

497

level=level)

497

498

499

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

499

500

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

500

501

if level < self.log_level:

501

502

return

502

503

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

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]

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]

506

507

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

507

508

coming_from="above")

508

509

self.refresh()

509

510

511

def toggle_log_display(self):

511

512

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

512

513

self.log_visible = not self.log_visible

513

514

self.rebuild()

514

515

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

515

516

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

516

517

518

def change_log_display(self):

518

519

"""Change type of log display.

519

520

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

525

526

textwidget.set_wrap_mode(self.log_wrap)

526

527

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

527

528

level=0)

528

529

530

def find_and_remove_client(self, path, interfaces):

530

531

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

531

532

533

This is connected to the InterfacesRemoved signal from the

533

534

Mandos server object."""

534

535

if client_interface not in interfaces:

542

543

.format(path))

543

544

return

544

545

client.delete()

545

546

547

def add_new_client(self, path, ifs_and_props):

547

548

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

548

549

550

This is connected to the InterfacesAdded signal from the

550

551

Mandos server object.

551

552

"""

553

554

# Not a Mandos client object; ignore

554

555

return

555

556

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

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

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

563

570

path=path)

564

571

565

572

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

566

573

self.clients.append(client)

567

574

if path is None:

569

576

self.clients_dict[path] = client

570

577

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

571

578

self.refresh()

572

579

573

580

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

574

581

self.clients.remove(client)

575

582

if path is None:

576

583

path = client.proxy.object_path

577

584

del self.clients_dict[path]

578

585

self.refresh()

579

586

580

587

def refresh(self):

581

588

"""Redraw the screen"""

582

589

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

583

590

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

584

591

585

592

def run(self):

586

593

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

587

594

self.bus = dbus.SystemBus()

588

595

mandos_dbus_objc = self.bus.get_object(

589

596

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

590

self.mandos_serv = dbus.Interface(

591

mandos_dbus_objc, dbus_interface=server_interface)

597

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

598

dbus_interface

599

= server_interface)

592

600

try:

593

601

mandos_clients = (self.mandos_serv

594

602

.GetAllClientsWithProperties())

595

603

if not mandos_clients:

596

self.log_message_raw(("bold",

597

"Note: Server has no clients."))

604

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

598

605

except dbus.exceptions.DBusException:

599

self.log_message_raw(("bold",

600

"Note: No Mandos server running."))

606

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

601

607

mandos_clients = dbus.Dictionary()

602

608

603

609

(self.mandos_serv

604

610

.connect_to_signal("InterfacesRemoved",

605

611

self.find_and_remove_client,

606

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

612

dbus_interface

613

= dbus.OBJECT_MANAGER_IFACE,

607

614

byte_arrays=True))

608

615

(self.mandos_serv

609

616

.connect_to_signal("InterfacesAdded",

610

617

self.add_new_client,

611

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

618

dbus_interface

619

= dbus.OBJECT_MANAGER_IFACE,

612

620

byte_arrays=True))

613

621

(self.mandos_serv

614

622

.connect_to_signal("ClientNotFound",

618

626

for path, client in mandos_clients.items():

619

627

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

620

628

path)

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

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

628

640

path=path)

629

641

630

642

self.refresh()

631

self._input_callback_tag = (GLib.io_add_watch

643

self._input_callback_tag = (gobject.io_add_watch

632

644

(sys.stdin.fileno(),

633

GLib.IO_IN,

645

gobject.IO_IN,

634

646

self.process_input))

635

647

self.main_loop.run()

636

648

# Main loop has finished, we should close everything now

637

GLib.source_remove(self._input_callback_tag)

649

gobject.source_remove(self._input_callback_tag)

638

650

self.screen.stop()

639

651

640

652

def stop(self):

641

653

self.main_loop.quit()

642

654

643

655

def process_input(self, source, condition):

644

656

keys = self.screen.get_input()

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

}

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

}

655

667

for key in keys:

656

668

try:

657

669

key = translations[key]

658

670

except KeyError: # :-)

659

671

pass

660

672

661

673

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

662

674

self.stop()

663

675

break

711

723

else:

712

724

self.log_level = 0

713

725

self.log_message("Verbose mode: On")

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

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

732

744

elif self.topwidget.selectable():

733

745

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

734

746

self.refresh()

735

747

return True

736

748

737

738

749

ui = UserInterface()

739

750

try:

740

751

ui.run()