/mandos/trunk : revision 1036

44

import logging

45

import io

46

import tempfile

47

import contextlib

48

47

49

48

import dbus

50

49

64

63

65

64

locale.setlocale(locale.LC_ALL, "")

66

65

67

dbus_busname_domain = "se.recompile"

68

dbus_busname = dbus_busname_domain + ".Mandos"

69

server_dbus_path = "/"

70

server_dbus_interface = dbus_busname_domain + ".Mandos"

71

client_dbus_interface = dbus_busname_domain + ".Mandos.Client"

72

del dbus_busname_domain

66

domain = "se.recompile"

67

busname = domain + ".Mandos"

68

server_path = "/"

69

server_interface = domain + ".Mandos"

70

client_interface = domain + ".Mandos.Client"

73

71

version = "1.8.3"

74

72

75

73

277

275

# Abstract classes first

278

276

class Command(object):

279

277

"""Abstract class for commands"""

280

def run(self, clients, bus=None, mandos=None):

278

def run(self, mandos, clients):

281

279

"""Normal commands should implement run_on_one_client(), but

282

280

commands which want to operate on all clients at the same time

283

281

can override this run() method instead."""

284

282

self.mandos = mandos

285

for clientpath, properties in clients.items():

286

log.debug("D-Bus: Connect to: (busname=%r, path=%r)",

287

dbus_busname, str(clientpath))

288

client = bus.get_object(dbus_busname, clientpath)

283

for client, properties in clients.items():

289

284

self.run_on_one_client(client, properties)

290

285

291

286

class PrintCmd(Command):

297

292

"LastApprovalRequest", "ApprovalDelay",

298

293

"ApprovalDuration", "Checker", "ExtendedTimeout",

299

294

"Expires", "LastCheckerStatus")

300

def run(self, clients, bus=None, mandos=None):

301

print(self.output(clients.values()))

302

def output(self, clients):

303

raise NotImplementedError()

295

def run(self, mandos, clients):

296

print(self.output(clients))

304

297

305

298

class PropertyCmd(Command):

306

299

"""Abstract class for Actions for setting one client property"""

307

300

def run_on_one_client(self, client, properties):

308

301

"""Set the Client's D-Bus property"""

309

log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", dbus_busname,

310

client.__dbus_object_path__,

311

dbus.PROPERTIES_IFACE, client_dbus_interface,

312

self.propname, self.value_to_set

313

if not isinstance(self.value_to_set, dbus.Boolean)

314

else bool(self.value_to_set))

315

client.Set(client_dbus_interface, self.propname,

316

self.value_to_set,

302

client.Set(client_interface, self.property, self.value_to_set,

317

303

dbus_interface=dbus.PROPERTIES_IFACE)

318

@property

319

def propname(self):

320

raise NotImplementedError()

321

304

322

class PropertyValueCmd(PropertyCmd):

323

"""Abstract class for PropertyCmd recieving a value as argument"""

305

class ValueArgumentMixIn(object):

306

"""Mixin class for commands taking a value as argument"""

324

307

def __init__(self, value):

325

308

self.value_to_set = value

326

309

327

class MillisecondsPropertyValueArgumentCmd(PropertyValueCmd):

328

"""Abstract class for PropertyValueCmd taking a value argument as

329

a datetime.timedelta() but should store it as milliseconds."""

310

class MillisecondsValueArgumentMixIn(ValueArgumentMixIn):

311

"""Mixin class for commands taking a value argument as

312

milliseconds."""

330

313

@property

331

314

def value_to_set(self):

332

315

return self._vts

333

316

@value_to_set.setter

334

317

def value_to_set(self, value):

335

"""When setting, convert value from a datetime.timedelta"""

318

"""When setting, convert value to a datetime.timedelta"""

336

319

self._vts = int(round(value.total_seconds() * 1000))

337

320

338

321

# Actual (non-abstract) command classes

342

325

self.verbose = verbose

343

326

344

327

def output(self, clients):

345

default_keywords = ("Name", "Enabled", "Timeout",

346

"LastCheckedOK")

328

default_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")

347

329

keywords = default_keywords

348

330

if self.verbose:

349

331

keywords = self.all_keywords

350

return str(self.TableOfClients(clients, keywords))

332

return str(self.TableOfClients(clients.values(), keywords))

351

333

352

334

class TableOfClients(object):

353

335

tableheaders = {

439

421

return value

440

422

441

423

class IsEnabledCmd(Command):

442

def run(self, clients, bus=None, mandos=None):

443

client, properties = next(iter(clients.items()))

424

def run_on_one_client(self, client, properties):

444

425

if self.is_enabled(client, properties):

445

426

sys.exit(0)

446

427

sys.exit(1)

447

428

def is_enabled(self, client, properties):

448

return properties["Enabled"]

429

return bool(properties["Enabled"])

449

430

450

431

class RemoveCmd(Command):

451

432

def run_on_one_client(self, client, properties):

452

log.debug("D-Bus: %s:%s:%s.RemoveClient(%r)", dbus_busname,

453

server_dbus_path, server_dbus_interface,

454

str(client.__dbus_object_path__))

455

433

self.mandos.RemoveClient(client.__dbus_object_path__)

456

434

457

435

class ApproveCmd(Command):

458

436

def run_on_one_client(self, client, properties):

459

log.debug("D-Bus: %s:%s:%s.Approve(True)", dbus_busname,

460

client.__dbus_object_path__, client_dbus_interface)

461

437

client.Approve(dbus.Boolean(True),

462

dbus_interface=client_dbus_interface)

438

dbus_interface=client_interface)

463

439

464

440

class DenyCmd(Command):

465

441

def run_on_one_client(self, client, properties):

466

log.debug("D-Bus: %s:%s:%s.Approve(False)", dbus_busname,

467

client.__dbus_object_path__, client_dbus_interface)

468

442

client.Approve(dbus.Boolean(False),

469

dbus_interface=client_dbus_interface)

443

dbus_interface=client_interface)

470

444

471

445

class EnableCmd(PropertyCmd):

472

propname = "Enabled"

446

property = "Enabled"

473

447

value_to_set = dbus.Boolean(True)

474

448

475

449

class DisableCmd(PropertyCmd):

476

propname = "Enabled"

450

property = "Enabled"

477

451

value_to_set = dbus.Boolean(False)

478

452

479

453

class BumpTimeoutCmd(PropertyCmd):

480

propname = "LastCheckedOK"

454

property = "LastCheckedOK"

481

455

value_to_set = ""

482

456

483

457

class StartCheckerCmd(PropertyCmd):

484

propname = "CheckerRunning"

458

property = "CheckerRunning"

485

459

value_to_set = dbus.Boolean(True)

486

460

487

461

class StopCheckerCmd(PropertyCmd):

488

propname = "CheckerRunning"

462

property = "CheckerRunning"

489

463

value_to_set = dbus.Boolean(False)

490

464

491

465

class ApproveByDefaultCmd(PropertyCmd):

492

propname = "ApprovedByDefault"

466

property = "ApprovedByDefault"

493

467

value_to_set = dbus.Boolean(True)

494

468

495

469

class DenyByDefaultCmd(PropertyCmd):

496

propname = "ApprovedByDefault"

470

property = "ApprovedByDefault"

497

471

value_to_set = dbus.Boolean(False)

498

472

499

class SetCheckerCmd(PropertyValueCmd):

500

propname = "Checker"

501

502

class SetHostCmd(PropertyValueCmd):

503

propname = "Host"

504

505

class SetSecretCmd(PropertyValueCmd):

506

propname = "Secret"

473

class SetCheckerCmd(PropertyCmd, ValueArgumentMixIn):

474

property = "Checker"

475

476

class SetHostCmd(PropertyCmd, ValueArgumentMixIn):

477

property = "Host"

478

479

class SetSecretCmd(PropertyCmd, ValueArgumentMixIn):

507

480

@property

508

481

def value_to_set(self):

509

482

return self._vts

512

485

"""When setting, read data from supplied file object"""

513

486

self._vts = value.read()

514

487

value.close()

515

516

class SetTimeoutCmd(MillisecondsPropertyValueArgumentCmd):

517

propname = "Timeout"

518

519

class SetExtendedTimeoutCmd(MillisecondsPropertyValueArgumentCmd):

520

propname = "ExtendedTimeout"

521

522

class SetIntervalCmd(MillisecondsPropertyValueArgumentCmd):

523

propname = "Interval"

524

525

class SetApprovalDelayCmd(MillisecondsPropertyValueArgumentCmd):

526

propname = "ApprovalDelay"

527

528

class SetApprovalDurationCmd(MillisecondsPropertyValueArgumentCmd):

529

propname = "ApprovalDuration"

488

property = "Secret"

489

490

class SetTimeoutCmd(PropertyCmd, MillisecondsValueArgumentMixIn):

491

property = "Timeout"

492

493

class SetExtendedTimeoutCmd(PropertyCmd,

494

MillisecondsValueArgumentMixIn):

495

property = "ExtendedTimeout"

496

497

class SetIntervalCmd(PropertyCmd, MillisecondsValueArgumentMixIn):

498

property = "Interval"

499

500

class SetApprovalDelayCmd(PropertyCmd,

501

MillisecondsValueArgumentMixIn):

502

property = "ApprovalDelay"

503

504

class SetApprovalDurationCmd(PropertyCmd,

505

MillisecondsValueArgumentMixIn):

506

property = "ApprovalDuration"

530

507

531

508

def add_command_line_options(parser):

532

509

parser.add_argument("--version", action="version",

588

565

help="Approve any current client request")

589

566

approve_deny.add_argument("-D", "--deny", action="store_true",

590

567

help="Deny any current client request")

591

parser.add_argument("--debug", action="store_true",

592

help="Debug mode (show D-Bus commands)")

593

568

parser.add_argument("--check", action="store_true",

594

569

help="Run self-test")

595

570

parser.add_argument("client", nargs="*", help="Client name")

620

595

if options.is_enabled:

621

596

commands.append(IsEnabledCmd())

622

597

598

if options.remove:

599

commands.append(RemoveCmd())

600

623

601

if options.checker is not None:

624

602

commands.append(SetCheckerCmd(options.checker))

625

603

658

636

if options.deny:

659

637

commands.append(DenyCmd())

660

638

661

if options.remove:

662

commands.append(RemoveCmd())

663

664

639

# If no command option has been given, show table of clients,

665

640

# optionally verbosely

666

641

if not commands:

669

644

return commands

670

645

671

646

672

def check_option_syntax(parser, options):

673

"""Apply additional restrictions on options, not expressible in

674

argparse"""

647

def main():

648

parser = argparse.ArgumentParser()

649

650

add_command_line_options(parser)

651

652

options = parser.parse_args()

675

653

676

654

def has_actions(options):

677

655

return any((options.enable,

704

682

parser.error("--all requires an action.")

705

683

if options.is_enabled and len(options.client) > 1:

706

684

parser.error("--is-enabled requires exactly one client")

707

if options.remove:

708

options.remove = False

709

if has_actions(options) and not options.deny:

710

parser.error("--remove can only be combined with --deny")

711

options.remove = True

712

713

714

def main():

715

parser = argparse.ArgumentParser()

716

717

add_command_line_options(parser)

718

719

options = parser.parse_args()

720

721

check_option_syntax(parser, options)

722

685

723

686

clientnames = options.client

724

687

725

if options.debug:

726

log.setLevel(logging.DEBUG)

727

728

688

try:

729

689

bus = dbus.SystemBus()

730

log.debug("D-Bus: Connect to: (busname=%r, path=%r)",

731

dbus_busname, server_dbus_path)

732

mandos_dbus_objc = bus.get_object(dbus_busname,

733

server_dbus_path)

690

mandos_dbus_objc = bus.get_object(busname, server_path)

734

691

except dbus.exceptions.DBusException:

735

692

log.critical("Could not connect to Mandos server")

736

693

sys.exit(1)

737

694

738

695

mandos_serv = dbus.Interface(mandos_dbus_objc,

739

dbus_interface=server_dbus_interface)

696

dbus_interface=server_interface)

740

697

mandos_serv_object_manager = dbus.Interface(

741

698

mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)

742

699

748

705

dbus_filter = NullFilter()

749

706

try:

750

707

dbus_logger.addFilter(dbus_filter)

751

log.debug("D-Bus: %s:%s:%s.GetManagedObjects()", dbus_busname,

752

server_dbus_path, dbus.OBJECT_MANAGER_IFACE)

753

mandos_clients = {path: ifs_and_props[client_dbus_interface]

708

mandos_clients = {path: ifs_and_props[client_interface]

754

709

for path, ifs_and_props in

755

710

mandos_serv_object_manager

756

711

.GetManagedObjects().items()

757

if client_dbus_interface in ifs_and_props}

712

if client_interface in ifs_and_props}

758

713

except dbus.exceptions.DBusException as e:

759

714

log.critical("Failed to access Mandos server through D-Bus:"

760

715

"\n%s", e)

767

722

clients = {}

768

723

769

724

if not clientnames:

770

clients = {objpath: properties

771

for objpath, properties in mandos_clients.items()}

725

clients = {bus.get_object(busname, path): properties

726

for path, properties in mandos_clients.items()}

772

727

else:

773

728

for name in clientnames:

774

for objpath, properties in mandos_clients.items():

775

if properties["Name"] == name:

776

clients[objpath] = properties

729

for path, client in mandos_clients.items():

730

if client["Name"] == name:

731

client_objc = bus.get_object(busname, path)

732

clients[client_objc] = client

777

733

break

778

734

else:

779

735

log.critical("Client not found on server: %r", name)

782

738

# Run all commands on clients

783

739

commands = commands_from_options(options)

784

740

for command in commands:

785

command.run(clients, bus, mandos_serv)

741

command.run(mandos_serv, clients)

786

742

787

743

788

744

class Test_milliseconds_to_string(unittest.TestCase):

837

793

testcase = self

838

794

class MockClient(object):

839

795

def __init__(self, name, **attributes):

840

self.__dbus_object_path__ = "/clients/{}".format(name)

796

self.__dbus_object_path__ = "objpath_{}".format(name)

841

797

self.attributes = attributes

842

798

self.attributes["Name"] = name

843

799

self.calls = []

844

def Set(self, interface, propname, value, dbus_interface):

845

testcase.assertEqual(interface, client_dbus_interface)

846

testcase.assertEqual(dbus_interface,

847

dbus.PROPERTIES_IFACE)

848

self.attributes[propname] = value

849

def Get(self, interface, propname, dbus_interface):

850

testcase.assertEqual(interface, client_dbus_interface)

851

testcase.assertEqual(dbus_interface,

852

dbus.PROPERTIES_IFACE)

853

return self.attributes[propname]

800

def Set(self, interface, property, value, dbus_interface):

801

testcase.assertEqual(interface, client_interface)

802

testcase.assertEqual(dbus_interface,

803

dbus.PROPERTIES_IFACE)

804

self.attributes[property] = value

805

def Get(self, interface, property, dbus_interface):

806

testcase.assertEqual(interface, client_interface)

807

testcase.assertEqual(dbus_interface,

808

dbus.PROPERTIES_IFACE)

809

return self.attributes[property]

854

810

def Approve(self, approve, dbus_interface):

855

testcase.assertEqual(dbus_interface,

856

client_dbus_interface)

811

testcase.assertEqual(dbus_interface, client_interface)

857

812

self.calls.append(("Approve", (approve,

858

813

dbus_interface)))

859

814

self.client = MockClient(

906

861

LastCheckerStatus=-2)

907

862

self.clients = collections.OrderedDict(

908

863

[

909

("/clients/foo", self.client.attributes),

910

("/clients/barbar", self.other_client.attributes),

864

(self.client, self.client.attributes),

865

(self.other_client, self.other_client.attributes),

911

866

])

912

self.one_client = {"/clients/foo": self.client.attributes}

913

@property

914

def bus(self):

915

class Bus(object):

916

@staticmethod

917

def get_object(client_bus_name, path):

918

self.assertEqual(client_bus_name, dbus_busname)

919

return {

920

"/clients/foo": self.client,

921

"/clients/barbar": self.other_client,

922

}[path]

923

return Bus()

867

self.one_client = {self.client: self.client.attributes}

924

868

925

869

class TestPrintTableCmd(TestCmd):

926

870

def test_normal(self):

927

output = PrintTableCmd().output(self.clients.values())

928

expected_output = "\n".join((

929

"Name Enabled Timeout Last Successful Check",

930

"foo Yes 00:05:00 2019-02-03T00:00:00 ",

931

"barbar Yes 00:05:00 2019-02-04T00:00:00 ",

932

))

871

output = PrintTableCmd().output(self.clients)

872

expected_output = """

873

Name Enabled Timeout Last Successful Check

874

foo Yes 00:05:00 2019-02-03T00:00:00

875

barbar Yes 00:05:00 2019-02-04T00:00:00

876

"""[1:-1]

933

877

self.assertEqual(output, expected_output)

934

878

def test_verbose(self):

935

output = PrintTableCmd(verbose=True).output(

936

self.clients.values())

937

columns = (

938

(

939

"Name ",

940

"foo ",

941

"barbar ",

942

),(

943

"Enabled ",

944

"Yes ",

945

"Yes ",

946

),(

947

"Timeout ",

948

"00:05:00 ",

949

"00:05:00 ",

950

),(

951

"Last Successful Check ",

952

"2019-02-03T00:00:00 ",

953

"2019-02-04T00:00:00 ",

954

),(

955

"Created ",

956

"2019-01-02T00:00:00 ",

957

"2019-01-03T00:00:00 ",

958

),(

959

"Interval ",

960

"00:02:00 ",

961

"00:02:00 ",

962

),(

963

"Host ",

964

"foo.example.org ",

965

"192.0.2.3 ",

966

),(

967

("Key ID "

968

" "),

969

("92ed150794387c03ce684574b1139a6594a34f895daaaf09fd8"

970

"ea90a27cddb12 "),

971

("0558568eedd67d622f5c83b35a115f796ab612cff5ad227247e"

972

"46c2b020f441c "),

973

),(

974

"Fingerprint ",

975

"778827225BA7DE539C5A7CFA59CFF7CDBD9A5920 ",

976

"3E393AEAEFB84C7E89E2F547B3A107558FCA3A27 ",

977

),(

978

"Check Is Running ",

979

"No ",

980

"Yes ",

981

),(

982

"Last Enabled ",

983

"2019-01-03T00:00:00 ",

984

"2019-01-04T00:00:00 ",

985

),(

986

"Approval Is Pending ",

987

"No ",

988

"No ",

989

),(

990

"Approved By Default ",

991

"Yes ",

992

"No ",

993

),(

994

"Last Approval Request ",

995

" ",

996

"2019-01-03T00:00:00 ",

997

),(

998

"Approval Delay ",

999

"00:00:00 ",

1000

"00:00:30 ",

1001

),(

1002

"Approval Duration ",

1003

"00:00:01 ",

1004

"00:00:01 ",

1005

),(

1006

"Checker ",

1007

"fping -q -- %(host)s ",

1008

": ",

1009

),(

1010

"Extended Timeout ",

1011

"00:15:00 ",

1012

"00:15:00 ",

1013

),(

1014

"Expires ",

1015

"2019-02-04T00:00:00 ",

1016

"2019-02-05T00:00:00 ",

1017

),(

1018

"Last Checker Status",

1019

"0 ",

1020

"-2 ",

1021

)

1022

)

1023

num_lines = max(len(rows) for rows in columns)

1024

expected_output = "\n".join("".join(rows[line]

1025

for rows in columns)

1026

for line in range(num_lines))

879

output = PrintTableCmd(verbose=True).output(self.clients)

880

expected_output = """

881

Name Enabled Timeout Last Successful Check Created Interval Host Key ID Fingerprint Check Is Running Last Enabled Approval Is Pending Approved By Default Last Approval Request Approval Delay Approval Duration Checker Extended Timeout Expires Last Checker Status

882

foo Yes 00:05:00 2019-02-03T00:00:00 2019-01-02T00:00:00 00:02:00 foo.example.org 92ed150794387c03ce684574b1139a6594a34f895daaaf09fd8ea90a27cddb12 778827225BA7DE539C5A7CFA59CFF7CDBD9A5920 No 2019-01-03T00:00:00 No Yes 00:00:00 00:00:01 fping -q -- %(host)s 00:15:00 2019-02-04T00:00:00 0

883

barbar Yes 00:05:00 2019-02-04T00:00:00 2019-01-03T00:00:00 00:02:00 192.0.2.3 0558568eedd67d622f5c83b35a115f796ab612cff5ad227247e46c2b020f441c 3E393AEAEFB84C7E89E2F547B3A107558FCA3A27 Yes 2019-01-04T00:00:00 No No 2019-01-03T00:00:00 00:00:30 00:00:01 : 00:15:00 2019-02-05T00:00:00 -2

884

"""[1:-1]

1027

885

self.assertEqual(output, expected_output)

1028

886

def test_one_client(self):

1029

output = PrintTableCmd().output(self.one_client.values())

887

output = PrintTableCmd().output(self.one_client)

1030

888

expected_output = """

1031

889

Name Enabled Timeout Last Successful Check

1032

890

foo Yes 00:05:00 2019-02-03T00:00:00

1097

955

1098

956

class TestIsEnabledCmd(TestCmd):

1099

957

def test_is_enabled(self):

1100

self.assertTrue(all(IsEnabledCmd().is_enabled(client,

1101

properties)

1102

for client, properties

1103

in self.clients.items()))

958

self.assertTrue(all(IsEnabledCmd().is_enabled(client, properties)

959

for client, properties in self.clients.items()))

1104

960

def test_is_enabled_run_exits_successfully(self):

1105

961

with self.assertRaises(SystemExit) as e:

1106

IsEnabledCmd().run(self.one_client)

962

IsEnabledCmd().run(None, self.one_client)

1107

963

if e.exception.code is not None:

1108

964

self.assertEqual(e.exception.code, 0)

1109

965

else:

1111

967

def test_is_enabled_run_exits_with_failure(self):

1112

968

self.client.attributes["Enabled"] = dbus.Boolean(False)

1113

969

with self.assertRaises(SystemExit) as e:

1114

IsEnabledCmd().run(self.one_client)

970

IsEnabledCmd().run(None, self.one_client)

1115

971

if isinstance(e.exception.code, int):

1116

972

self.assertNotEqual(e.exception.code, 0)

1117

973

else:

1126

982

self.calls.append(("RemoveClient", (dbus_path,)))

1127

983

mandos = MockMandos()

1128

984

super(TestRemoveCmd, self).setUp()

1129

RemoveCmd().run(self.clients, self.bus, mandos)

985

RemoveCmd().run(mandos, self.clients)

1130

986

self.assertEqual(len(mandos.calls), 2)

1131

for clientpath in self.clients:

1132

self.assertIn(("RemoveClient", (clientpath,)),

987

for client in self.clients:

988

self.assertIn(("RemoveClient",

989

(client.__dbus_object_path__,)),

1133

990

mandos.calls)

1134

991

1135

992

class TestApproveCmd(TestCmd):

1136

993

def test_approve(self):

1137

ApproveCmd().run(self.clients, self.bus)

1138

for clientpath in self.clients:

1139

client = self.bus.get_object(dbus_busname, clientpath)

1140

self.assertIn(("Approve", (True, client_dbus_interface)),

994

ApproveCmd().run(None, self.clients)

995

for client in self.clients:

996

self.assertIn(("Approve", (True, client_interface)),

1141

997

client.calls)

1142

998

1143

999

class TestDenyCmd(TestCmd):

1144

1000

def test_deny(self):

1145

DenyCmd().run(self.clients, self.bus)

1146

for clientpath in self.clients:

1147

client = self.bus.get_object(dbus_busname, clientpath)

1148

self.assertIn(("Approve", (False, client_dbus_interface)),

1001

DenyCmd().run(None, self.clients)

1002

for client in self.clients:

1003

self.assertIn(("Approve", (False, client_interface)),

1149

1004

client.calls)

1150

1005

1151

1006

class TestEnableCmd(TestCmd):

1152

1007

def test_enable(self):

1153

for clientpath in self.clients:

1154

client = self.bus.get_object(dbus_busname, clientpath)

1008

for client in self.clients:

1155

1009

client.attributes["Enabled"] = False

1156

1010

1157

EnableCmd().run(self.clients, self.bus)

1011

EnableCmd().run(None, self.clients)

1158

1012

1159

for clientpath in self.clients:

1160

client = self.bus.get_object(dbus_busname, clientpath)

1013

for client in self.clients:

1161

1014

self.assertTrue(client.attributes["Enabled"])

1162

1015

1163

1016

class TestDisableCmd(TestCmd):

1164

1017

def test_disable(self):

1165

DisableCmd().run(self.clients, self.bus)

1166

for clientpath in self.clients:

1167

client = self.bus.get_object(dbus_busname, clientpath)

1018

DisableCmd().run(None, self.clients)

1019

1020

for client in self.clients:

1168

1021

self.assertFalse(client.attributes["Enabled"])

1169

1022

1170

1023

class Unique(object):

1180

1033

self.values_to_set)

1181

1034

for value_to_set, value_to_get in zip(self.values_to_set,

1182

1035

values_to_get):

1183

for clientpath in self.clients:

1184

client = self.bus.get_object(dbus_busname, clientpath)

1185

old_value = client.attributes[self.propname]

1036

for client in self.clients:

1037

old_value = client.attributes[self.property]

1186

1038

self.assertNotIsInstance(old_value, Unique)

1187

client.attributes[self.propname] = Unique()

1039

client.attributes[self.property] = Unique()

1188

1040

self.run_command(value_to_set, self.clients)

1189

for clientpath in self.clients:

1190

client = self.bus.get_object(dbus_busname, clientpath)

1191

value = client.attributes[self.propname]

1041

for client in self.clients:

1042

value = client.attributes[self.property]

1192

1043

self.assertNotIsInstance(value, Unique)

1193

1044

self.assertEqual(value, value_to_get)

1194

1045

def run_command(self, value, clients):

1195

self.command().run(clients, self.bus)

1046

self.command().run(None, clients)

1196

1047

1197

1048

class TestBumpTimeoutCmd(TestPropertyCmd):

1198

1049

command = BumpTimeoutCmd

1199

propname = "LastCheckedOK"

1050

property = "LastCheckedOK"

1200

1051

values_to_set = [""]

1201

1052

1202

1053

class TestStartCheckerCmd(TestPropertyCmd):

1203

1054

command = StartCheckerCmd

1204

propname = "CheckerRunning"

1055

property = "CheckerRunning"

1205

1056

values_to_set = [dbus.Boolean(True)]

1206

1057

1207

1058

class TestStopCheckerCmd(TestPropertyCmd):

1208

1059

command = StopCheckerCmd

1209

propname = "CheckerRunning"

1060

property = "CheckerRunning"

1210

1061

values_to_set = [dbus.Boolean(False)]

1211

1062

1212

1063

class TestApproveByDefaultCmd(TestPropertyCmd):

1213

1064

command = ApproveByDefaultCmd

1214

propname = "ApprovedByDefault"

1065

property = "ApprovedByDefault"

1215

1066

values_to_set = [dbus.Boolean(True)]

1216

1067

1217

1068

class TestDenyByDefaultCmd(TestPropertyCmd):

1218

1069

command = DenyByDefaultCmd

1219

propname = "ApprovedByDefault"

1070

property = "ApprovedByDefault"

1220

1071

values_to_set = [dbus.Boolean(False)]

1221

1072

1222

class TestPropertyValueCmd(TestPropertyCmd):

1223

"""Abstract class for tests of PropertyValueCmd classes"""

1073

class TestValueArgumentPropertyCmd(TestPropertyCmd):

1074

"""Abstract class for tests of PropertyCmd classes using the

1075

ValueArgumentMixIn"""

1224

1076

def runTest(self):

1225

if type(self) is TestPropertyValueCmd:

1077

if type(self) is TestValueArgumentPropertyCmd:

1226

1078

return

1227

return super(TestPropertyValueCmd, self).runTest()

1079

return super(TestValueArgumentPropertyCmd, self).runTest()

1228

1080

def run_command(self, value, clients):

1229

self.command(value).run(clients, self.bus)

1081

self.command(value).run(None, clients)

1230

1082

1231

class TestSetCheckerCmd(TestPropertyValueCmd):

1083

class TestSetCheckerCmd(TestValueArgumentPropertyCmd):

1232

1084

command = SetCheckerCmd

1233

propname = "Checker"

1085

property = "Checker"

1234

1086

values_to_set = ["", ":", "fping -q -- %s"]

1235

1087

1236

class TestSetHostCmd(TestPropertyValueCmd):

1088

class TestSetHostCmd(TestValueArgumentPropertyCmd):

1237

1089

command = SetHostCmd

1238

propname = "Host"

1090

property = "Host"

1239

1091

values_to_set = ["192.0.2.3", "foo.example.org"]

1240

1092

1241

class TestSetSecretCmd(TestPropertyValueCmd):

1093

class TestSetSecretCmd(TestValueArgumentPropertyCmd):

1242

1094

command = SetSecretCmd

1243

propname = "Secret"

1244

values_to_set = [io.BytesIO(b""),

1095

property = "Secret"

1096

values_to_set = [open("/dev/null", "rb"),

1245

1097

io.BytesIO(b"secret\0xyzzy\nbar")]

1246

1098

values_to_get = [b"", b"secret\0xyzzy\nbar"]

1247

1099

1248

class TestSetTimeoutCmd(TestPropertyValueCmd):

1100

class TestSetTimeoutCmd(TestValueArgumentPropertyCmd):

1249

1101

command = SetTimeoutCmd

1250

propname = "Timeout"

1102

property = "Timeout"

1251

1103

values_to_set = [datetime.timedelta(),

1252

1104

datetime.timedelta(minutes=5),

1253

1105

datetime.timedelta(seconds=1),

1255

1107

datetime.timedelta(weeks=52)]

1256

1108

values_to_get = [0, 300000, 1000, 604800000, 31449600000]

1257

1109

1258

class TestSetExtendedTimeoutCmd(TestPropertyValueCmd):

1110

class TestSetExtendedTimeoutCmd(TestValueArgumentPropertyCmd):

1259

1111

command = SetExtendedTimeoutCmd

1260

propname = "ExtendedTimeout"

1112

property = "ExtendedTimeout"

1261

1113

values_to_set = [datetime.timedelta(),

1262

1114

datetime.timedelta(minutes=5),

1263

1115

datetime.timedelta(seconds=1),

1265

1117

datetime.timedelta(weeks=52)]

1266

1118

values_to_get = [0, 300000, 1000, 604800000, 31449600000]

1267

1119

1268

class TestSetIntervalCmd(TestPropertyValueCmd):

1120

class TestSetIntervalCmd(TestValueArgumentPropertyCmd):

1269

1121

command = SetIntervalCmd

1270

propname = "Interval"

1122

property = "Interval"

1271

1123

values_to_set = [datetime.timedelta(),

1272

1124

datetime.timedelta(minutes=5),

1273

1125

datetime.timedelta(seconds=1),

1275

1127

datetime.timedelta(weeks=52)]

1276

1128

values_to_get = [0, 300000, 1000, 604800000, 31449600000]

1277

1129

1278

class TestSetApprovalDelayCmd(TestPropertyValueCmd):

1130

class TestSetApprovalDelayCmd(TestValueArgumentPropertyCmd):

1279

1131

command = SetApprovalDelayCmd

1280

propname = "ApprovalDelay"

1132

property = "ApprovalDelay"

1281

1133

values_to_set = [datetime.timedelta(),

1282

1134

datetime.timedelta(minutes=5),

1283

1135

datetime.timedelta(seconds=1),

1285

1137

datetime.timedelta(weeks=52)]

1286

1138

values_to_get = [0, 300000, 1000, 604800000, 31449600000]

1287

1139

1288

class TestSetApprovalDurationCmd(TestPropertyValueCmd):

1140

class TestSetApprovalDurationCmd(TestValueArgumentPropertyCmd):

1289

1141

command = SetApprovalDurationCmd

1290

propname = "ApprovalDuration"

1142

property = "ApprovalDuration"

1291

1143

values_to_set = [datetime.timedelta(),

1292

1144

datetime.timedelta(minutes=5),

1293

1145

datetime.timedelta(seconds=1),

1299

1151

def setUp(self):

1300

1152

self.parser = argparse.ArgumentParser()

1301

1153

add_command_line_options(self.parser)

1302

def assert_command_from_args(self, args, command_cls,

1303

**cmd_attrs):

1154

def assert_command_from_args(self, args, command_cls, **cmd_attrs):

1304

1155

"""Assert that parsing ARGS should result in an instance of

1305

1156

COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""

1306

1157

options = self.parser.parse_args(args)

1307

check_option_syntax(self.parser, options)

1308

1158

commands = commands_from_options(options)

1309

1159

self.assertEqual(len(commands), 1)

1310

1160

command = commands[0]

1474

1324

def test_is_enabled_short(self):

1475

1325

self.assert_command_from_args(["-V", "foo"], IsEnabledCmd)

1476

1326

1477

def test_deny_before_remove(self):

1478

options = self.parser.parse_args(["--deny", "--remove",

1479

"foo"])

1480

check_option_syntax(self.parser, options)

1481

commands = commands_from_options(options)

1482

self.assertEqual(len(commands), 2)

1483

self.assertIsInstance(commands[0], DenyCmd)

1484

self.assertIsInstance(commands[1], RemoveCmd)

1485

1486

def test_deny_before_remove_reversed(self):

1487

options = self.parser.parse_args(["--remove", "--deny",

1488

"--all"])

1489

check_option_syntax(self.parser, options)

1490

commands = commands_from_options(options)

1491

self.assertEqual(len(commands), 2)

1492

self.assertIsInstance(commands[0], DenyCmd)

1493

self.assertIsInstance(commands[1], RemoveCmd)

1494

1495

1496

class Test_check_option_syntax(unittest.TestCase):

1497

# This mostly corresponds to the definition from has_actions() in

1498

# check_option_syntax()

1499

actions = {

1500

# The actual values set here are not that important, but we do

1501

# at least stick to the correct types, even though they are

1502

# never used

1503

"enable": True,

1504

"disable": True,

1505

"bump_timeout": True,

1506

"start_checker": True,

1507

"stop_checker": True,

1508

"is_enabled": True,

1509

"remove": True,

1510

"checker": "x",

1511

"timeout": datetime.timedelta(),

1512

"extended_timeout": datetime.timedelta(),

1513

"interval": datetime.timedelta(),

1514

"approved_by_default": True,

1515

"approval_delay": datetime.timedelta(),

1516

"approval_duration": datetime.timedelta(),

1517

"host": "x",

1518

"secret": io.BytesIO(b"x"),

1519

"approve": True,

1520

"deny": True,

1521

}

1522

1523

def setUp(self):

1524

self.parser = argparse.ArgumentParser()

1525

add_command_line_options(self.parser)

1526

1527

@contextlib.contextmanager

1528

def assertParseError(self):

1529

with self.assertRaises(SystemExit) as e:

1530

with self.temporarily_suppress_stderr():

1531

yield

1532

# Exit code from argparse is guaranteed to be "2". Reference:

1533

# https://docs.python.org/3/library

1534

# /argparse.html#exiting-methods

1535

self.assertEqual(e.exception.code, 2)

1536

1537

@staticmethod

1538

@contextlib.contextmanager

1539

def temporarily_suppress_stderr():

1540

null = os.open(os.path.devnull, os.O_RDWR)

1541

stderrcopy = os.dup(sys.stderr.fileno())

1542

os.dup2(null, sys.stderr.fileno())

1543

os.close(null)

1544

try:

1545

yield

1546

finally:

1547

# restore stderr

1548

os.dup2(stderrcopy, sys.stderr.fileno())

1549

os.close(stderrcopy)

1550

1551

def check_option_syntax(self, options):

1552

check_option_syntax(self.parser, options)

1553

1554

def test_actions_requires_client_or_all(self):

1555

for action, value in self.actions.items():

1556

options = self.parser.parse_args()

1557

setattr(options, action, value)

1558

with self.assertParseError():

1559

self.check_option_syntax(options)

1560

1561

def test_actions_conflicts_with_verbose(self):

1562

for action, value in self.actions.items():

1563

options = self.parser.parse_args()

1564

setattr(options, action, value)

1565

options.verbose = True

1566

with self.assertParseError():

1567

self.check_option_syntax(options)

1568

1569

def test_dump_json_conflicts_with_verbose(self):

1570

options = self.parser.parse_args()

1571

options.dump_json = True

1572

options.verbose = True

1573

with self.assertParseError():

1574

self.check_option_syntax(options)

1575

1576

def test_dump_json_conflicts_with_action(self):

1577

for action, value in self.actions.items():

1578

options = self.parser.parse_args()

1579

setattr(options, action, value)

1580

options.dump_json = True

1581

with self.assertParseError():

1582

self.check_option_syntax(options)

1583

1584

def test_all_can_not_be_alone(self):

1585

options = self.parser.parse_args()

1586

options.all = True

1587

with self.assertParseError():

1588

self.check_option_syntax(options)

1589

1590

def test_all_is_ok_with_any_action(self):

1591

for action, value in self.actions.items():

1592

options = self.parser.parse_args()

1593

setattr(options, action, value)

1594

options.all = True

1595

self.check_option_syntax(options)

1596

1597

def test_is_enabled_fails_without_client(self):

1598

options = self.parser.parse_args()

1599

options.is_enabled = True

1600

with self.assertParseError():

1601

self.check_option_syntax(options)

1602

1603

def test_is_enabled_works_with_one_client(self):

1604

options = self.parser.parse_args()

1605

options.is_enabled = True

1606

options.client = ["foo"]

1607

self.check_option_syntax(options)

1608

1609

def test_is_enabled_fails_with_two_clients(self):

1610

options = self.parser.parse_args()

1611

options.is_enabled = True

1612

options.client = ["foo", "barbar"]

1613

with self.assertParseError():

1614

self.check_option_syntax(options)

1615

1616

def test_remove_can_only_be_combined_with_action_deny(self):

1617

for action, value in self.actions.items():

1618

if action in {"remove", "deny"}:

1619

continue

1620

options = self.parser.parse_args()

1621

setattr(options, action, value)

1622

options.all = True

1623

options.remove = True

1624

with self.assertParseError():

1625

self.check_option_syntax(options)

1626

1627

1327

1628

1328

1629

1329

def should_only_run_tests():