/mandos/trunk : revision 1078

1

#!/usr/bin/python

2

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

3

#

2

# -*- mode: python; coding: utf-8; after-save-hook: (lambda () (let ((command (if (and (boundp 'tramp-file-name-structure) (string-match (car tramp-file-name-structure) (buffer-file-name))) (tramp-file-name-localname (tramp-dissect-file-name (buffer-file-name))) (buffer-file-name)))) (if (= (shell-command (format "%s --check" (shell-quote-argument command)) "*Test*") 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w)) (kill-buffer "*Test*")) (display-buffer "*Test*")))); -*-

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)

28

29

from future_builtins import *

30

try:

31

from future_builtins import *

32

except ImportError:

33

pass

30

34

31

35

import sys

32

import dbus

33

36

import argparse

34

37

import locale

35

38

import datetime

36

39

import re

37

40

import os

41

import collections

42

import json

43

import unittest

44

import logging

45

import io

46

import tempfile

47

import contextlib

48

49

import dbus

50

51

# Show warnings by default

52

if not sys.warnoptions:

53

import warnings

54

warnings.simplefilter("default")

55

56

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

57

logging.basicConfig(level="INFO", # Show info level messages

58

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

59

60

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

61

62

if sys.version_info.major == 2:

63

str = unicode

38

64

39

65

locale.setlocale(locale.LC_ALL, "")

40

66

41

tablewords = {

42

"Name": "Name",

43

"Enabled": "Enabled",

44

"Timeout": "Timeout",

45

"LastCheckedOK": "Last Successful Check",

46

"LastApprovalRequest": "Last Approval Request",

47

"Created": "Created",

48

"Interval": "Interval",

49

"Host": "Host",

50

"Fingerprint": "Fingerprint",

51

"CheckerRunning": "Check Is Running",

52

"LastEnabled": "Last Enabled",

53

"ApprovalPending": "Approval Is Pending",

54

"ApprovedByDefault": "Approved By Default",

55

"ApprovalDelay": "Approval Delay",

56

"ApprovalDuration": "Approval Duration",

57

"Checker": "Checker",

58

"ExtendedTimeout" : "Extended Timeout"

59

}

60

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

61

domain = "se.recompile"

62

busname = domain + ".Mandos"

63

server_path = "/"

64

server_interface = domain + ".Mandos"

65

client_interface = domain + ".Mandos.Client"

66

version = "1.5.4"

67

68

def timedelta_to_milliseconds(td):

69

"""Convert a datetime.timedelta object to milliseconds"""

70

return ((td.days * 24 * 60 * 60 * 1000)

71

+ (td.seconds * 1000)

72

+ (td.microseconds // 1000))

73

74

def milliseconds_to_string(ms):

75

td = datetime.timedelta(0, 0, 0, ms)

76

return ("{days}{hours:02}:{minutes:02}:{seconds:02}"

77

.format(days = "{0}T".format(td.days) if td.days else "",

78

hours = td.seconds // 3600,

79

minutes = (td.seconds % 3600) // 60,

80

seconds = td.seconds % 60,

81

))

82

83

def string_to_delta(interval):

84

"""Parse a string and return a datetime.timedelta

85

86

>>> string_to_delta("7d")

87

datetime.timedelta(7)

88

>>> string_to_delta("60s")

89

datetime.timedelta(0, 60)

90

>>> string_to_delta("60m")

91

datetime.timedelta(0, 3600)

92

>>> string_to_delta("24h")

93

datetime.timedelta(1)

94

>>> string_to_delta("1w")

95

datetime.timedelta(7)

96

>>> string_to_delta("5m 30s")

97

datetime.timedelta(0, 330)

98

"""

99

value = datetime.timedelta(0)

100

regexp = re.compile("(\d+)([dsmhw]?)")

101

102

for num, suffix in regexp.findall(interval):

103

if suffix == "d":

104

value += datetime.timedelta(int(num))

105

elif suffix == "s":

106

value += datetime.timedelta(0, int(num))

107

elif suffix == "m":

108

value += datetime.timedelta(0, 0, 0, 0, int(num))

109

elif suffix == "h":

110

value += datetime.timedelta(0, 0, 0, 0, 0, int(num))

111

elif suffix == "w":

112

value += datetime.timedelta(0, 0, 0, 0, 0, 0, int(num))

113

elif suffix == "":

114

value += datetime.timedelta(0, 0, 0, int(num))

115

return value

116

117

def print_clients(clients, keywords):

118

def valuetostring(value, keyword):

119

if type(value) is dbus.Boolean:

120

return "Yes" if value else "No"

121

if keyword in ("Timeout", "Interval", "ApprovalDelay",

122

"ApprovalDuration", "ExtendedTimeout"):

123

return milliseconds_to_string(value)

124

return unicode(value)

125

126

# Create format string to print table rows

127

format_string = " ".join("{{{key}:{width}}}".format(

128

width = max(len(tablewords[key]),

129

max(len(valuetostring(client[key],

130

key))

131

for client in

132

clients)),

133

key = key) for key in keywords)

134

# Print header line

135

print(format_string.format(**tablewords))

136

for client in clients:

137

print(format_string.format(**dict((key,

138

valuetostring(client[key],

139

key))

140

for key in keywords)))

141

142

def has_actions(options):

143

return any((options.enable,

144

options.disable,

145

options.bump_timeout,

146

options.start_checker,

147

options.stop_checker,

148

options.is_enabled,

149

options.remove,

150

options.checker is not None,

151

options.timeout is not None,

152

options.extended_timeout is not None,

153

options.interval is not None,

154

options.approved_by_default is not None,

155

options.approval_delay is not None,

156

options.approval_duration is not None,

157

options.host is not None,

158

options.secret is not None,

159

options.approve,

160

options.deny))

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

73

version = "1.8.3"

74

75

76

try:

77

dbus.OBJECT_MANAGER_IFACE

78

except AttributeError:

79

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

80

161

81

162

82

def main():

163

83

parser = argparse.ArgumentParser()

84

85

add_command_line_options(parser)

86

87

options = parser.parse_args()

88

89

check_option_syntax(parser, options)

90

91

clientnames = options.client

92

93

if options.debug:

94

log.setLevel(logging.DEBUG)

95

96

bus = dbus.SystemBus()

97

98

mandos_dbus_object = get_mandos_dbus_object(bus)

99

100

mandos_serv = dbus.Interface(

101

mandos_dbus_object, dbus_interface=server_dbus_interface)

102

mandos_serv_object_manager = dbus.Interface(

103

mandos_dbus_object, dbus_interface=dbus.OBJECT_MANAGER_IFACE)

104

105

managed_objects = get_managed_objects(mandos_serv_object_manager)

106

107

all_clients = {}

108

for path, ifs_and_props in managed_objects.items():

109

try:

110

all_clients[path] = ifs_and_props[client_dbus_interface]

111

except KeyError:

112

pass

113

114

# Compile dict of (clientpath: properties) to process

115

if not clientnames:

116

clients = all_clients

117

else:

118

clients = {}

119

for name in clientnames:

120

for objpath, properties in all_clients.items():

121

if properties["Name"] == name:

122

clients[objpath] = properties

123

break

124

else:

125

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

126

sys.exit(1)

127

128

commands = commands_from_options(options)

129

130

for command in commands:

131

command.run(clients, bus, mandos_serv)

132

133

134

def add_command_line_options(parser):

164

135

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

165

version = "%(prog)s {0}".format(version),

136

version="%(prog)s {}".format(version),

166

137

help="show version number and exit")

167

138

parser.add_argument("-a", "--all", action="store_true",

168

139

help="Select all clients")

169

140

parser.add_argument("-v", "--verbose", action="store_true",

170

141

help="Print all fields")

171

parser.add_argument("-e", "--enable", action="store_true",

172

help="Enable client")

173

parser.add_argument("-d", "--disable", action="store_true",

174

help="disable client")

142

parser.add_argument("-j", "--dump-json", action="store_true",

143

help="Dump client data in JSON format")

144

enable_disable = parser.add_mutually_exclusive_group()

145

enable_disable.add_argument("-e", "--enable", action="store_true",

146

help="Enable client")

147

enable_disable.add_argument("-d", "--disable",

148

action="store_true",

149

help="disable client")

175

150

parser.add_argument("-b", "--bump-timeout", action="store_true",

176

151

help="Bump timeout for client")

177

parser.add_argument("--start-checker", action="store_true",

178

help="Start checker for client")

179

parser.add_argument("--stop-checker", action="store_true",

180

help="Stop checker for client")

152

start_stop_checker = parser.add_mutually_exclusive_group()

153

start_stop_checker.add_argument("--start-checker",

154

action="store_true",

155

help="Start checker for client")

156

start_stop_checker.add_argument("--stop-checker",

157

action="store_true",

158

help="Stop checker for client")

181

159

parser.add_argument("-V", "--is-enabled", action="store_true",

182

160

help="Check if client is enabled")

183

161

parser.add_argument("-r", "--remove", action="store_true",

184

162

help="Remove client")

185

163

parser.add_argument("-c", "--checker",

186

164

help="Set checker command for client")

187

parser.add_argument("-t", "--timeout",

165

parser.add_argument("-t", "--timeout", type=string_to_delta,

188

166

help="Set timeout for client")

189

parser.add_argument("--extended-timeout",

167

parser.add_argument("--extended-timeout", type=string_to_delta,

190

168

help="Set extended timeout for client")

191

parser.add_argument("-i", "--interval",

169

parser.add_argument("-i", "--interval", type=string_to_delta,

192

170

help="Set checker interval for client")

193

parser.add_argument("--approve-by-default", action="store_true",

194

default=None, dest="approved_by_default",

195

help="Set client to be approved by default")

196

parser.add_argument("--deny-by-default", action="store_false",

197

dest="approved_by_default",

198

help="Set client to be denied by default")

199

parser.add_argument("--approval-delay",

171

approve_deny_default = parser.add_mutually_exclusive_group()

172

approve_deny_default.add_argument(

173

"--approve-by-default", action="store_true",

174

default=None, dest="approved_by_default",

175

help="Set client to be approved by default")

176

approve_deny_default.add_argument(

177

"--deny-by-default", action="store_false",

178

dest="approved_by_default",

179

help="Set client to be denied by default")

180

parser.add_argument("--approval-delay", type=string_to_delta,

200

181

help="Set delay before client approve/deny")

201

parser.add_argument("--approval-duration",

182

parser.add_argument("--approval-duration", type=string_to_delta,

202

183

help="Set duration of one client approval")

203

184

parser.add_argument("-H", "--host", help="Set host for client")

204

parser.add_argument("-s", "--secret", type=file,

185

parser.add_argument("-s", "--secret",

186

type=argparse.FileType(mode="rb"),

205

187

help="Set password blob (file) for client")

206

parser.add_argument("-A", "--approve", action="store_true",

207

help="Approve any current client request")

208

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

209

help="Deny any current client request")

188

approve_deny = parser.add_mutually_exclusive_group()

189

approve_deny.add_argument(

190

"-A", "--approve", action="store_true",

191

help="Approve any current client request")

192

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

193

help="Deny any current client request")

194

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

195

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

196

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

197

help="Run self-test")

210

198

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

211

options = parser.parse_args()

212

199

200

201

def string_to_delta(interval):

202

"""Parse a string and return a datetime.timedelta"""

203

204

try:

205

return rfc3339_duration_to_delta(interval)

206

except ValueError as e:

207

log.warning("%s - Parsing as pre-1.6.1 interval instead",

208

' '.join(e.args))

209

return parse_pre_1_6_1_interval(interval)

210

211

212

def rfc3339_duration_to_delta(duration):

213

"""Parse an RFC 3339 "duration" and return a datetime.timedelta

214

215

>>> rfc3339_duration_to_delta("P7D")

216

datetime.timedelta(7)

217

>>> rfc3339_duration_to_delta("PT60S")

218

datetime.timedelta(0, 60)

219

>>> rfc3339_duration_to_delta("PT60M")

220

datetime.timedelta(0, 3600)

221

>>> rfc3339_duration_to_delta("P60M")

222

datetime.timedelta(1680)

223

>>> rfc3339_duration_to_delta("PT24H")

224

datetime.timedelta(1)

225

>>> rfc3339_duration_to_delta("P1W")

226

datetime.timedelta(7)

227

>>> rfc3339_duration_to_delta("PT5M30S")

228

datetime.timedelta(0, 330)

229

>>> rfc3339_duration_to_delta("P1DT3M20S")

230

datetime.timedelta(1, 200)

231

>>> # Can not be empty:

232

>>> rfc3339_duration_to_delta("")

233

Traceback (most recent call last):

234

...

235

ValueError: Invalid RFC 3339 duration: ""

236

>>> # Must start with "P":

237

>>> rfc3339_duration_to_delta("1D")

238

Traceback (most recent call last):

239

...

240

ValueError: Invalid RFC 3339 duration: "1D"

241

>>> # Must use correct order

242

>>> rfc3339_duration_to_delta("PT1S2M")

243

Traceback (most recent call last):

244

...

245

ValueError: Invalid RFC 3339 duration: "PT1S2M"

246

>>> # Time needs time marker

247

>>> rfc3339_duration_to_delta("P1H2S")

248

Traceback (most recent call last):

249

...

250

ValueError: Invalid RFC 3339 duration: "P1H2S"

251

>>> # Weeks can not be combined with anything else

252

>>> rfc3339_duration_to_delta("P1D2W")

253

Traceback (most recent call last):

254

...

255

ValueError: Invalid RFC 3339 duration: "P1D2W"

256

>>> rfc3339_duration_to_delta("P2W2H")

257

Traceback (most recent call last):

258

...

259

ValueError: Invalid RFC 3339 duration: "P2W2H"

260

"""

261

262

# Parsing an RFC 3339 duration with regular expressions is not

263

# possible - there would have to be multiple places for the same

264

# values, like seconds. The current code, while more esoteric, is

265

# cleaner without depending on a parsing library. If Python had a

266

# built-in library for parsing we would use it, but we'd like to

267

# avoid excessive use of external libraries.

268

269

# New type for defining tokens, syntax, and semantics all-in-one

270

Token = collections.namedtuple("Token", (

271

"regexp", # To match token; if "value" is not None, must have

272

# a "group" containing digits

273

"value", # datetime.timedelta or None

274

"followers")) # Tokens valid after this token

275

# RFC 3339 "duration" tokens, syntax, and semantics; taken from

276

# the "duration" ABNF definition in RFC 3339, Appendix A.

277

token_end = Token(re.compile(r"$"), None, frozenset())

278

token_second = Token(re.compile(r"(\d+)S"),

279

datetime.timedelta(seconds=1),

280

frozenset((token_end, )))

281

token_minute = Token(re.compile(r"(\d+)M"),

282

datetime.timedelta(minutes=1),

283

frozenset((token_second, token_end)))

284

token_hour = Token(re.compile(r"(\d+)H"),

285

datetime.timedelta(hours=1),

286

frozenset((token_minute, token_end)))

287

token_time = Token(re.compile(r"T"),

288

None,

289

frozenset((token_hour, token_minute,

290

token_second)))

291

token_day = Token(re.compile(r"(\d+)D"),

292

datetime.timedelta(days=1),

293

frozenset((token_time, token_end)))

294

token_month = Token(re.compile(r"(\d+)M"),

295

datetime.timedelta(weeks=4),

296

frozenset((token_day, token_end)))

297

token_year = Token(re.compile(r"(\d+)Y"),

298

datetime.timedelta(weeks=52),

299

frozenset((token_month, token_end)))

300

token_week = Token(re.compile(r"(\d+)W"),

301

datetime.timedelta(weeks=1),

302

frozenset((token_end, )))

303

token_duration = Token(re.compile(r"P"), None,

304

frozenset((token_year, token_month,

305

token_day, token_time,

306

token_week)))

307

# Define starting values:

308

# Value so far

309

value = datetime.timedelta()

310

found_token = None

311

# Following valid tokens

312

followers = frozenset((token_duration, ))

313

# String left to parse

314

s = duration

315

# Loop until end token is found

316

while found_token is not token_end:

317

# Search for any currently valid tokens

318

for token in followers:

319

match = token.regexp.match(s)

320

if match is not None:

321

# Token found

322

if token.value is not None:

323

# Value found, parse digits

324

factor = int(match.group(1), 10)

325

# Add to value so far

326

value += factor * token.value

327

# Strip token from string

328

s = token.regexp.sub("", s, 1)

329

# Go to found token

330

found_token = token

331

# Set valid next tokens

332

followers = found_token.followers

333

break

334

else:

335

# No currently valid tokens were found

336

raise ValueError("Invalid RFC 3339 duration: \"{}\""

337

.format(duration))

338

# End token found

339

return value

340

341

342

def parse_pre_1_6_1_interval(interval):

343

"""Parse an interval string as documented by Mandos before 1.6.1,

344

and return a datetime.timedelta

345

346

>>> parse_pre_1_6_1_interval('7d')

347

datetime.timedelta(7)

348

>>> parse_pre_1_6_1_interval('60s')

349

datetime.timedelta(0, 60)

350

>>> parse_pre_1_6_1_interval('60m')

351

datetime.timedelta(0, 3600)

352

>>> parse_pre_1_6_1_interval('24h')

353

datetime.timedelta(1)

354

>>> parse_pre_1_6_1_interval('1w')

355

datetime.timedelta(7)

356

>>> parse_pre_1_6_1_interval('5m 30s')

357

datetime.timedelta(0, 330)

358

>>> parse_pre_1_6_1_interval('')

359

datetime.timedelta(0)

360

>>> # Ignore unknown characters, allow any order and repetitions

361

>>> parse_pre_1_6_1_interval('2dxy7zz11y3m5m')

362

datetime.timedelta(2, 480, 18000)

363

364

"""

365

366

value = datetime.timedelta(0)

367

regexp = re.compile(r"(\d+)([dsmhw]?)")

368

369

for num, suffix in regexp.findall(interval):

370

if suffix == "d":

371

value += datetime.timedelta(int(num))

372

elif suffix == "s":

373

value += datetime.timedelta(0, int(num))

374

elif suffix == "m":

375

value += datetime.timedelta(0, 0, 0, 0, int(num))

376

elif suffix == "h":

377

value += datetime.timedelta(0, 0, 0, 0, 0, int(num))

378

elif suffix == "w":

379

value += datetime.timedelta(0, 0, 0, 0, 0, 0, int(num))

380

elif suffix == "":

381

value += datetime.timedelta(0, 0, 0, int(num))

382

return value

383

384

385

def check_option_syntax(parser, options):

386

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

387

argparse"""

388

389

def has_actions(options):

390

return any((options.enable,

391

options.disable,

392

options.bump_timeout,

393

options.start_checker,

394

options.stop_checker,

395

options.is_enabled,

396

options.remove,

397

options.checker is not None,

398

options.timeout is not None,

399

options.extended_timeout is not None,

400

options.interval is not None,

401

options.approved_by_default is not None,

402

options.approval_delay is not None,

403

options.approval_duration is not None,

404

options.host is not None,

405

options.secret is not None,

406

options.approve,

407

options.deny))

408

213

409

if has_actions(options) and not (options.client or options.all):

214

410

parser.error("Options require clients names or --all.")

215

411

if options.verbose and has_actions(options):

216

parser.error("--verbose can only be used alone or with"

217

" --all.")

412

parser.error("--verbose can only be used alone.")

413

if options.dump_json and (options.verbose

414

or has_actions(options)):

415

parser.error("--dump-json can only be used alone.")

218

416

if options.all and not has_actions(options):

219

417

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

220

418

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

419

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

420

if options.remove:

421

options.remove = False

422

if has_actions(options) and not options.deny:

423

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

424

options.remove = True

425

426

427

def get_mandos_dbus_object(bus):

428

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

429

dbus_busname, server_dbus_path)

430

with if_dbus_exception_log_with_exception_and_exit(

431

"Could not connect to Mandos server: %s"):

432

mandos_dbus_object = bus.get_object(dbus_busname,

433

server_dbus_path)

434

return mandos_dbus_object

435

436

437

@contextlib.contextmanager

438

def if_dbus_exception_log_with_exception_and_exit(*args, **kwargs):

221

439

try:

222

bus = dbus.SystemBus()

223

mandos_dbus_objc = bus.get_object(busname, server_path)

224

except dbus.exceptions.DBusException:

225

print("Could not connect to Mandos server",

226

file=sys.stderr)

440

yield

441

except dbus.exceptions.DBusException as e:

442

log.critical(*(args + (e,)), **kwargs)

227

443

sys.exit(1)

228

229

mandos_serv = dbus.Interface(mandos_dbus_objc,

230

dbus_interface = server_interface)

231

232

#block stderr since dbus library prints to stderr

233

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

234

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

235

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

236

os.close(null)

237

try:

444

445

446

def get_managed_objects(object_manager):

447

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

448

server_dbus_path, dbus.OBJECT_MANAGER_IFACE)

449

with if_dbus_exception_log_with_exception_and_exit(

450

"Failed to access Mandos server through D-Bus:\n%s"):

451

with SilenceLogger("dbus.proxies"):

452

managed_objects = object_manager.GetManagedObjects()

453

return managed_objects

454

455

456

class SilenceLogger(object):

457

"Simple context manager to silence a particular logger"

458

def __init__(self, loggername):

459

self.logger = logging.getLogger(loggername)

460

461

def __enter__(self):

462

self.logger.addFilter(self.nullfilter)

463

return self

464

465

class NullFilter(logging.Filter):

466

def filter(self, record):

467

return False

468

469

nullfilter = NullFilter()

470

471

def __exit__(self, exc_type, exc_val, exc_tb):

472

self.logger.removeFilter(self.nullfilter)

473

474

475

def commands_from_options(options):

476

477

commands = []

478

479

if options.is_enabled:

480

commands.append(command.IsEnabled())

481

482

if options.approve:

483

commands.append(command.Approve())

484

485

if options.deny:

486

commands.append(command.Deny())

487

488

if options.remove:

489

commands.append(command.Remove())

490

491

if options.dump_json:

492

commands.append(command.DumpJSON())

493

494

if options.enable:

495

commands.append(command.Enable())

496

497

if options.disable:

498

commands.append(command.Disable())

499

500

if options.bump_timeout:

501

commands.append(command.BumpTimeout())

502

503

if options.start_checker:

504

commands.append(command.StartChecker())

505

506

if options.stop_checker:

507

commands.append(command.StopChecker())

508

509

if options.approved_by_default is not None:

510

if options.approved_by_default:

511

commands.append(command.ApproveByDefault())

512

else:

513

commands.append(command.DenyByDefault())

514

515

if options.checker is not None:

516

commands.append(command.SetChecker(options.checker))

517

518

if options.host is not None:

519

commands.append(command.SetHost(options.host))

520

521

if options.secret is not None:

522

commands.append(command.SetSecret(options.secret))

523

524

if options.timeout is not None:

525

commands.append(command.SetTimeout(options.timeout))

526

527

if options.extended_timeout:

528

commands.append(

529

command.SetExtendedTimeout(options.extended_timeout))

530

531

if options.interval is not None:

532

commands.append(command.SetInterval(options.interval))

533

534

if options.approval_delay is not None:

535

commands.append(

536

command.SetApprovalDelay(options.approval_delay))

537

538

if options.approval_duration is not None:

539

commands.append(

540

command.SetApprovalDuration(options.approval_duration))

541

542

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

543

# optionally verbosely

544

if not commands:

545

commands.append(command.PrintTable(verbose=options.verbose))

546

547

return commands

548

549

550

class command(object):

551

"""A namespace for command classes"""

552

553

class Base(object):

554

"""Abstract base class for commands"""

555

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

556

"""Normal commands should implement run_on_one_client(),

557

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

558

override this run() method instead.

559

"""

560

self.mandos = mandos

561

for clientpath, properties in clients.items():

562

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

563

dbus_busname, str(clientpath))

564

client = bus.get_object(dbus_busname, clientpath)

565

self.run_on_one_client(client, properties)

566

567

568

class IsEnabled(Base):

569

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

570

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

571

if self.is_enabled(client, properties):

572

sys.exit(0)

573

sys.exit(1)

574

def is_enabled(self, client, properties):

575

return properties["Enabled"]

576

577

578

class Approve(Base):

579

def run_on_one_client(self, client, properties):

580

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

581

client.__dbus_object_path__,

582

client_dbus_interface)

583

client.Approve(dbus.Boolean(True),

584

dbus_interface=client_dbus_interface)

585

586

587

class Deny(Base):

588

def run_on_one_client(self, client, properties):

589

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

590

client.__dbus_object_path__,

591

client_dbus_interface)

592

client.Approve(dbus.Boolean(False),

593

dbus_interface=client_dbus_interface)

594

595

596

class Remove(Base):

597

def run_on_one_client(self, client, properties):

598

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

599

dbus_busname, server_dbus_path,

600

server_dbus_interface,

601

str(client.__dbus_object_path__))

602

self.mandos.RemoveClient(client.__dbus_object_path__)

603

604

605

class Output(Base):

606

"""Abstract class for commands outputting client details"""

607

all_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",

608

"Created", "Interval", "Host", "KeyID",

609

"Fingerprint", "CheckerRunning",

610

"LastEnabled", "ApprovalPending",

611

"ApprovedByDefault", "LastApprovalRequest",

612

"ApprovalDelay", "ApprovalDuration",

613

"Checker", "ExtendedTimeout", "Expires",

614

"LastCheckerStatus")

615

616

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

617

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

618

619

def output(self, clients):

620

raise NotImplementedError()

621

622

623

class DumpJSON(Output):

624

def output(self, clients):

625

data = {client["Name"]:

626

{key: self.dbus_boolean_to_bool(client[key])

627

for key in self.all_keywords}

628

for client in clients}

629

return json.dumps(data, indent=4, separators=(',', ': '))

630

631

@staticmethod

632

def dbus_boolean_to_bool(value):

633

if isinstance(value, dbus.Boolean):

634

value = bool(value)

635

return value

636

637

638

class PrintTable(Output):

639

def __init__(self, verbose=False):

640

self.verbose = verbose

641

642

def output(self, clients):

643

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

644

"LastCheckedOK")

645

keywords = default_keywords

646

if self.verbose:

647

keywords = self.all_keywords

648

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

649

650

class TableOfClients(object):

651

tableheaders = {

652

"Name": "Name",

653

"Enabled": "Enabled",

654

"Timeout": "Timeout",

655

"LastCheckedOK": "Last Successful Check",

656

"LastApprovalRequest": "Last Approval Request",

657

"Created": "Created",

658

"Interval": "Interval",

659

"Host": "Host",

660

"Fingerprint": "Fingerprint",

661

"KeyID": "Key ID",

662

"CheckerRunning": "Check Is Running",

663

"LastEnabled": "Last Enabled",

664

"ApprovalPending": "Approval Is Pending",

665

"ApprovedByDefault": "Approved By Default",

666

"ApprovalDelay": "Approval Delay",

667

"ApprovalDuration": "Approval Duration",

668

"Checker": "Checker",

669

"ExtendedTimeout": "Extended Timeout",

670

"Expires": "Expires",

671

"LastCheckerStatus": "Last Checker Status",

672

}

673

674

def __init__(self, clients, keywords):

675

self.clients = clients

676

self.keywords = keywords

677

678

def __str__(self):

679

return "\n".join(self.rows())

680

681

if sys.version_info.major == 2:

682

__unicode__ = __str__

683

def __str__(self):

684

return str(self).encode(

685

locale.getpreferredencoding())

686

687

def rows(self):

688

format_string = self.row_formatting_string()

689

rows = [self.header_line(format_string)]

690

rows.extend(self.client_line(client, format_string)

691

for client in self.clients)

692

return rows

693

694

def row_formatting_string(self):

695

"Format string used to format table rows"

696

return " ".join("{{{key}:{width}}}".format(

697

width=max(len(self.tableheaders[key]),

698

*(len(self.string_from_client(client,

699

key))

700

for client in self.clients)),

701

key=key)

702

for key in self.keywords)

703

704

def string_from_client(self, client, key):

705

return self.valuetostring(client[key], key)

706

707

@classmethod

708

def valuetostring(cls, value, keyword):

709

if isinstance(value, dbus.Boolean):

710

return "Yes" if value else "No"

711

if keyword in ("Timeout", "Interval", "ApprovalDelay",

712

"ApprovalDuration", "ExtendedTimeout"):

713

return cls.milliseconds_to_string(value)

714

return str(value)

715

716

def header_line(self, format_string):

717

return format_string.format(**self.tableheaders)

718

719

def client_line(self, client, format_string):

720

return format_string.format(

721

**{key: self.string_from_client(client, key)

722

for key in self.keywords})

723

724

@staticmethod

725

def milliseconds_to_string(ms):

726

td = datetime.timedelta(0, 0, 0, ms)

727

return ("{days}{hours:02}:{minutes:02}:{seconds:02}"

728

.format(days="{}T".format(td.days)

729

if td.days else "",

730

hours=td.seconds // 3600,

731

minutes=(td.seconds % 3600) // 60,

732

seconds=td.seconds % 60))

733

734

735

class Property(Base):

736

"Abstract class for Actions for setting one client property"

737

738

def run_on_one_client(self, client, properties):

739

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

740

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

741

client.__dbus_object_path__,

742

dbus.PROPERTIES_IFACE, client_dbus_interface,

743

self.propname, self.value_to_set

744

if not isinstance(self.value_to_set,

745

dbus.Boolean)

746

else bool(self.value_to_set))

747

client.Set(client_dbus_interface, self.propname,

748

self.value_to_set,

749

dbus_interface=dbus.PROPERTIES_IFACE)

750

751

@property

752

def propname(self):

753

raise NotImplementedError()

754

755

756

class Enable(Property):

757

propname = "Enabled"

758

value_to_set = dbus.Boolean(True)

759

760

761

class Disable(Property):

762

propname = "Enabled"

763

value_to_set = dbus.Boolean(False)

764

765

766

class BumpTimeout(Property):

767

propname = "LastCheckedOK"

768

value_to_set = ""

769

770

771

class StartChecker(Property):

772

propname = "CheckerRunning"

773

value_to_set = dbus.Boolean(True)

774

775

776

class StopChecker(Property):

777

propname = "CheckerRunning"

778

value_to_set = dbus.Boolean(False)

779

780

781

class ApproveByDefault(Property):

782

propname = "ApprovedByDefault"

783

value_to_set = dbus.Boolean(True)

784

785

786

class DenyByDefault(Property):

787

propname = "ApprovedByDefault"

788

value_to_set = dbus.Boolean(False)

789

790

791

class PropertyValue(Property):

792

"Abstract class for Property recieving a value as argument"

793

def __init__(self, value):

794

self.value_to_set = value

795

796

797

class SetChecker(PropertyValue):

798

propname = "Checker"

799

800

801

class SetHost(PropertyValue):

802

propname = "Host"

803

804

805

class SetSecret(PropertyValue):

806

propname = "Secret"

807

808

@property

809

def value_to_set(self):

810

return self._vts

811

812

@value_to_set.setter

813

def value_to_set(self, value):

814

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

815

self._vts = value.read()

816

value.close()

817

818

819

class MillisecondsPropertyValueArgument(PropertyValue):

820

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

821

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

822

823

@property

824

def value_to_set(self):

825

return self._vts

826

827

@value_to_set.setter

828

def value_to_set(self, value):

829

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

830

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

831

832

833

class SetTimeout(MillisecondsPropertyValueArgument):

834

propname = "Timeout"

835

836

837

class SetExtendedTimeout(MillisecondsPropertyValueArgument):

838

propname = "ExtendedTimeout"

839

840

841

class SetInterval(MillisecondsPropertyValueArgument):

842

propname = "Interval"

843

844

845

class SetApprovalDelay(MillisecondsPropertyValueArgument):

846

propname = "ApprovalDelay"

847

848

849

class SetApprovalDuration(MillisecondsPropertyValueArgument):

850

propname = "ApprovalDuration"

851

852

853

854

class TestCaseWithAssertLogs(unittest.TestCase):

855

"""unittest.TestCase.assertLogs only exists in Python 3.4"""

856

857

if not hasattr(unittest.TestCase, "assertLogs"):

858

@contextlib.contextmanager

859

def assertLogs(self, logger, level=logging.INFO):

860

capturing_handler = self.CapturingLevelHandler(level)

861

old_level = logger.level

862

old_propagate = logger.propagate

863

logger.addHandler(capturing_handler)

864

logger.setLevel(level)

865

logger.propagate = False

866

try:

867

yield capturing_handler.watcher

868

finally:

869

logger.propagate = old_propagate

870

logger.removeHandler(capturing_handler)

871

logger.setLevel(old_level)

872

self.assertGreater(len(capturing_handler.watcher.records),

873

0)

874

875

class CapturingLevelHandler(logging.Handler):

876

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

877

logging.Handler.__init__(self, *args, **kwargs)

878

self.watcher = self.LoggingWatcher([], [])

879

def emit(self, record):

880

self.watcher.records.append(record)

881

self.watcher.output.append(self.format(record))

882

883

LoggingWatcher = collections.namedtuple("LoggingWatcher",

884

("records",

885

"output"))

886

887

888

class Test_string_to_delta(TestCaseWithAssertLogs):

889

def test_handles_basic_rfc3339(self):

890

self.assertEqual(string_to_delta("PT0S"),

891

datetime.timedelta())

892

self.assertEqual(string_to_delta("P0D"),

893

datetime.timedelta())

894

self.assertEqual(string_to_delta("PT1S"),

895

datetime.timedelta(0, 1))

896

self.assertEqual(string_to_delta("PT2H"),

897

datetime.timedelta(0, 7200))

898

899

def test_falls_back_to_pre_1_6_1_with_warning(self):

900

with self.assertLogs(log, logging.WARNING):

901

value = string_to_delta("2h")

902

self.assertEqual(value, datetime.timedelta(0, 7200))

903

904

905

class Test_check_option_syntax(unittest.TestCase):

906

def setUp(self):

907

self.parser = argparse.ArgumentParser()

908

add_command_line_options(self.parser)

909

910

def test_actions_requires_client_or_all(self):

911

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

912

options = self.parser.parse_args()

913

setattr(options, action, value)

914

with self.assertParseError():

915

self.check_option_syntax(options)

916

917

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

918

# check_option_syntax()

919

actions = {

920

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

921

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

922

# never used

923

"enable": True,

924

"disable": True,

925

"bump_timeout": True,

926

"start_checker": True,

927

"stop_checker": True,

928

"is_enabled": True,

929

"remove": True,

930

"checker": "x",

931

"timeout": datetime.timedelta(),

932

"extended_timeout": datetime.timedelta(),

933

"interval": datetime.timedelta(),

934

"approved_by_default": True,

935

"approval_delay": datetime.timedelta(),

936

"approval_duration": datetime.timedelta(),

937

"host": "x",

938

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

939

"approve": True,

940

"deny": True,

941

}

942

943

@contextlib.contextmanager

944

def assertParseError(self):

945

with self.assertRaises(SystemExit) as e:

946

with self.redirect_stderr_to_devnull():

947

yield

948

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

949

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

950

# /argparse.html#exiting-methods

951

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

952

953

@staticmethod

954

@contextlib.contextmanager

955

def redirect_stderr_to_devnull():

956

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

957

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

958

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

959

os.close(null)

238

960

try:

239

mandos_clients = mandos_serv.GetAllClientsWithProperties()

961

yield

240

962

finally:

241

#restore stderr

963

# restore stderr

242

964

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

243

965

os.close(stderrcopy)

244

except dbus.exceptions.DBusException:

245

print("Access denied: Accessing mandos server through dbus.",

246

file=sys.stderr)

247

sys.exit(1)

248

249

# Compile dict of (clients: properties) to process

250

clients={}

251

252

if options.all or not options.client:

253

clients = dict((bus.get_object(busname, path), properties)

254

for path, properties in

255

mandos_clients.iteritems())

256

else:

257

for name in options.client:

258

for path, client in mandos_clients.iteritems():

259

if client["Name"] == name:

260

client_objc = bus.get_object(busname, path)

261

clients[client_objc] = client

262

break

263

else:

264

print("Client not found on server: {0!r}"

265

.format(name), file=sys.stderr)

266

sys.exit(1)

267

268

if not has_actions(options) and clients:

269

if options.verbose:

270

keywords = ("Name", "Enabled", "Timeout",

271

"LastCheckedOK", "Created", "Interval",

272

"Host", "Fingerprint", "CheckerRunning",

273

"LastEnabled", "ApprovalPending",

274

"ApprovedByDefault",

275

"LastApprovalRequest", "ApprovalDelay",

276

"ApprovalDuration", "Checker",

277

"ExtendedTimeout")

278

else:

279

keywords = defaultkeywords

280

281

print_clients(clients.values(), keywords)

282

else:

283

# Process each client in the list by all selected options

284

for client in clients:

285

def set_client_prop(prop, value):

286

"""Set a Client D-Bus property"""

287

client.Set(client_interface, prop, value,

288

dbus_interface=dbus.PROPERTIES_IFACE)

289

def set_client_prop_ms(prop, value):

290

"""Set a Client D-Bus property, converted

291

from a string to milliseconds."""

292

set_client_prop(prop,

293

timedelta_to_milliseconds

294

(string_to_delta(value)))

295

if options.remove:

296

mandos_serv.RemoveClient(client.__dbus_object_path__)

297

if options.enable:

298

set_client_prop("Enabled", dbus.Boolean(True))

299

if options.disable:

300

set_client_prop("Enabled", dbus.Boolean(False))

301

if options.bump_timeout:

302

set_client_prop("LastCheckedOK", "")

303

if options.start_checker:

304

set_client_prop("CheckerRunning", dbus.Boolean(True))

305

if options.stop_checker:

306

set_client_prop("CheckerRunning", dbus.Boolean(False))

307

if options.is_enabled:

308

sys.exit(0 if client.Get(client_interface,

309

"Enabled",

310

dbus_interface=

311

dbus.PROPERTIES_IFACE)

312

else 1)

313

if options.checker is not None:

314

set_client_prop("Checker", options.checker)

315

if options.host is not None:

316

set_client_prop("Host", options.host)

317

if options.interval is not None:

318

set_client_prop_ms("Interval", options.interval)

319

if options.approval_delay is not None:

320

set_client_prop_ms("ApprovalDelay",

321

options.approval_delay)

322

if options.approval_duration is not None:

323

set_client_prop_ms("ApprovalDuration",

324

options.approval_duration)

325

if options.timeout is not None:

326

set_client_prop_ms("Timeout", options.timeout)

327

if options.extended_timeout is not None:

328

set_client_prop_ms("ExtendedTimeout",

329

options.extended_timeout)

330

if options.secret is not None:

331

set_client_prop("Secret",

332

dbus.ByteArray(options.secret.read()))

333

if options.approved_by_default is not None:

334

set_client_prop("ApprovedByDefault",

335

dbus.Boolean(options

336

.approved_by_default))

337

if options.approve:

338

client.Approve(dbus.Boolean(True),

339

dbus_interface=client_interface)

340

elif options.deny:

341

client.Approve(dbus.Boolean(False),

342

dbus_interface=client_interface)

966

967

def check_option_syntax(self, options):

968

check_option_syntax(self.parser, options)

969

970

def test_actions_all_conflicts_with_verbose(self):

971

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

972

options = self.parser.parse_args()

973

setattr(options, action, value)

974

options.all = True

975

options.verbose = True

976

with self.assertParseError():

977

self.check_option_syntax(options)

978

979

def test_actions_with_client_conflicts_with_verbose(self):

980

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

981

options = self.parser.parse_args()

982

setattr(options, action, value)

983

options.verbose = True

984

options.client = ["foo"]

985

with self.assertParseError():

986

self.check_option_syntax(options)

987

988

def test_dump_json_conflicts_with_verbose(self):

989

options = self.parser.parse_args()

990

options.dump_json = True

991

options.verbose = True

992

with self.assertParseError():

993

self.check_option_syntax(options)

994

995

def test_dump_json_conflicts_with_action(self):

996

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

997

options = self.parser.parse_args()

998

setattr(options, action, value)

999

options.dump_json = True

1000

with self.assertParseError():

1001

self.check_option_syntax(options)

1002

1003

def test_all_can_not_be_alone(self):

1004

options = self.parser.parse_args()

1005

options.all = True

1006

with self.assertParseError():

1007

self.check_option_syntax(options)

1008

1009

def test_all_is_ok_with_any_action(self):

1010

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

1011

options = self.parser.parse_args()

1012

setattr(options, action, value)

1013

options.all = True

1014

self.check_option_syntax(options)

1015

1016

def test_any_action_is_ok_with_one_client(self):

1017

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

1018

options = self.parser.parse_args()

1019

setattr(options, action, value)

1020

options.client = ["foo"]

1021

self.check_option_syntax(options)

1022

1023

def test_one_client_with_all_actions_except_is_enabled(self):

1024

options = self.parser.parse_args()

1025

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

1026

if action == "is_enabled":

1027

continue

1028

setattr(options, action, value)

1029

options.client = ["foo"]

1030

self.check_option_syntax(options)

1031

1032

def test_two_clients_with_all_actions_except_is_enabled(self):

1033

options = self.parser.parse_args()

1034

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

1035

if action == "is_enabled":

1036

continue

1037

setattr(options, action, value)

1038

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

1039

self.check_option_syntax(options)

1040

1041

def test_two_clients_are_ok_with_actions_except_is_enabled(self):

1042

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

1043

if action == "is_enabled":

1044

continue

1045

options = self.parser.parse_args()

1046

setattr(options, action, value)

1047

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

1048

self.check_option_syntax(options)

1049

1050

def test_is_enabled_fails_without_client(self):

1051

options = self.parser.parse_args()

1052

options.is_enabled = True

1053

with self.assertParseError():

1054

self.check_option_syntax(options)

1055

1056

def test_is_enabled_fails_with_two_clients(self):

1057

options = self.parser.parse_args()

1058

options.is_enabled = True

1059

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

1060

with self.assertParseError():

1061

self.check_option_syntax(options)

1062

1063

def test_remove_can_only_be_combined_with_action_deny(self):

1064

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

1065

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

1066

continue

1067

options = self.parser.parse_args()

1068

setattr(options, action, value)

1069

options.all = True

1070

options.remove = True

1071

with self.assertParseError():

1072

self.check_option_syntax(options)

1073

1074

1075

class Test_get_mandos_dbus_object(TestCaseWithAssertLogs):

1076

def test_calls_and_returns_get_object_on_bus(self):

1077

class MockBus(object):

1078

called = False

1079

def get_object(mockbus_self, busname, dbus_path):

1080

# Note that "self" is still the testcase instance,

1081

# this MockBus instance is in "mockbus_self".

1082

self.assertEqual(busname, dbus_busname)

1083

self.assertEqual(dbus_path, server_dbus_path)

1084

mockbus_self.called = True

1085

return mockbus_self

1086

1087

mockbus = get_mandos_dbus_object(bus=MockBus())

1088

self.assertIsInstance(mockbus, MockBus)

1089

self.assertTrue(mockbus.called)

1090

1091

def test_logs_and_exits_on_dbus_error(self):

1092

class MockBusFailing(object):

1093

def get_object(self, busname, dbus_path):

1094

raise dbus.exceptions.DBusException("Test")

1095

1096

with self.assertLogs(log, logging.CRITICAL):

1097

with self.assertRaises(SystemExit) as e:

1098

bus = get_mandos_dbus_object(bus=MockBusFailing())

1099

1100

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

1101

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

1102

else:

1103

self.assertIsNotNone(e.exception.code)

1104

1105

1106

class Test_get_managed_objects(TestCaseWithAssertLogs):

1107

def test_calls_and_returns_GetManagedObjects(self):

1108

managed_objects = {"/clients/foo": { "Name": "foo"}}

1109

class MockObjectManager(object):

1110

def GetManagedObjects(self):

1111

return managed_objects

1112

retval = get_managed_objects(MockObjectManager())

1113

self.assertDictEqual(managed_objects, retval)

1114

1115

def test_logs_and_exits_on_dbus_error(self):

1116

dbus_logger = logging.getLogger("dbus.proxies")

1117

1118

class MockObjectManagerFailing(object):

1119

def GetManagedObjects(self):

1120

dbus_logger.error("Test")

1121

raise dbus.exceptions.DBusException("Test")

1122

1123

class CountingHandler(logging.Handler):

1124

count = 0

1125

def emit(self, record):

1126

self.count += 1

1127

1128

counting_handler = CountingHandler()

1129

1130

dbus_logger.addHandler(counting_handler)

1131

1132

try:

1133

with self.assertLogs(log, logging.CRITICAL) as watcher:

1134

with self.assertRaises(SystemExit) as e:

1135

get_managed_objects(MockObjectManagerFailing())

1136

finally:

1137

dbus_logger.removeFilter(counting_handler)

1138

1139

# Make sure the dbus logger was suppressed

1140

self.assertEqual(counting_handler.count, 0)

1141

1142

# Test that the dbus_logger still works

1143

with self.assertLogs(dbus_logger, logging.ERROR):

1144

dbus_logger.error("Test")

1145

1146

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

1147

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

1148

else:

1149

self.assertIsNotNone(e.exception.code)

1150

1151

1152

class Test_commands_from_options(unittest.TestCase):

1153

def setUp(self):

1154

self.parser = argparse.ArgumentParser()

1155

add_command_line_options(self.parser)

1156

1157

def test_is_enabled(self):

1158

self.assert_command_from_args(["--is-enabled", "foo"],

1159

command.IsEnabled)

1160

1161

def assert_command_from_args(self, args, command_cls,

1162

**cmd_attrs):

1163

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

1164

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

1165

options = self.parser.parse_args(args)

1166

check_option_syntax(self.parser, options)

1167

commands = commands_from_options(options)

1168

self.assertEqual(len(commands), 1)

1169

command = commands[0]

1170

self.assertIsInstance(command, command_cls)

1171

for key, value in cmd_attrs.items():

1172

self.assertEqual(getattr(command, key), value)

1173

1174

def test_is_enabled_short(self):

1175

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

1176

command.IsEnabled)

1177

1178

def test_approve(self):

1179

self.assert_command_from_args(["--approve", "foo"],

1180

command.Approve)

1181

1182

def test_approve_short(self):

1183

self.assert_command_from_args(["-A", "foo"], command.Approve)

1184

1185

def test_deny(self):

1186

self.assert_command_from_args(["--deny", "foo"], command.Deny)

1187

1188

def test_deny_short(self):

1189

self.assert_command_from_args(["-D", "foo"], command.Deny)

1190

1191

def test_remove(self):

1192

self.assert_command_from_args(["--remove", "foo"],

1193

command.Remove)

1194

1195

def test_deny_before_remove(self):

1196

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

1197

"foo"])

1198

check_option_syntax(self.parser, options)

1199

commands = commands_from_options(options)

1200

self.assertEqual(len(commands), 2)

1201

self.assertIsInstance(commands[0], command.Deny)

1202

self.assertIsInstance(commands[1], command.Remove)

1203

1204

def test_deny_before_remove_reversed(self):

1205

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

1206

"--all"])

1207

check_option_syntax(self.parser, options)

1208

commands = commands_from_options(options)

1209

self.assertEqual(len(commands), 2)

1210

self.assertIsInstance(commands[0], command.Deny)

1211

self.assertIsInstance(commands[1], command.Remove)

1212

1213

def test_remove_short(self):

1214

self.assert_command_from_args(["-r", "foo"], command.Remove)

1215

1216

def test_dump_json(self):

1217

self.assert_command_from_args(["--dump-json"],

1218

command.DumpJSON)

1219

1220

def test_enable(self):

1221

self.assert_command_from_args(["--enable", "foo"],

1222

command.Enable)

1223

1224

def test_enable_short(self):

1225

self.assert_command_from_args(["-e", "foo"], command.Enable)

1226

1227

def test_disable(self):

1228

self.assert_command_from_args(["--disable", "foo"],

1229

command.Disable)

1230

1231

def test_disable_short(self):

1232

self.assert_command_from_args(["-d", "foo"], command.Disable)

1233

1234

def test_bump_timeout(self):

1235

self.assert_command_from_args(["--bump-timeout", "foo"],

1236

command.BumpTimeout)

1237

1238

def test_bump_timeout_short(self):

1239

self.assert_command_from_args(["-b", "foo"],

1240

command.BumpTimeout)

1241

1242

def test_start_checker(self):

1243

self.assert_command_from_args(["--start-checker", "foo"],

1244

command.StartChecker)

1245

1246

def test_stop_checker(self):

1247

self.assert_command_from_args(["--stop-checker", "foo"],

1248

command.StopChecker)

1249

1250

def test_approve_by_default(self):

1251

self.assert_command_from_args(["--approve-by-default", "foo"],

1252

command.ApproveByDefault)

1253

1254

def test_deny_by_default(self):

1255

self.assert_command_from_args(["--deny-by-default", "foo"],

1256

command.DenyByDefault)

1257

1258

def test_checker(self):

1259

self.assert_command_from_args(["--checker", ":", "foo"],

1260

command.SetChecker,

1261

value_to_set=":")

1262

1263

def test_checker_empty(self):

1264

self.assert_command_from_args(["--checker", "", "foo"],

1265

command.SetChecker,

1266

value_to_set="")

1267

1268

def test_checker_short(self):

1269

self.assert_command_from_args(["-c", ":", "foo"],

1270

command.SetChecker,

1271

value_to_set=":")

1272

1273

def test_host(self):

1274

self.assert_command_from_args(["--host", "foo.example.org",

1275

"foo"], command.SetHost,

1276

value_to_set="foo.example.org")

1277

1278

def test_host_short(self):

1279

self.assert_command_from_args(["-H", "foo.example.org",

1280

"foo"], command.SetHost,

1281

value_to_set="foo.example.org")

1282

1283

def test_secret_devnull(self):

1284

self.assert_command_from_args(["--secret", os.path.devnull,

1285

"foo"], command.SetSecret,

1286

value_to_set=b"")

1287

1288

def test_secret_tempfile(self):

1289

with tempfile.NamedTemporaryFile(mode="r+b") as f:

1290

value = b"secret\0xyzzy\nbar"

1291

f.write(value)

1292

f.seek(0)

1293

self.assert_command_from_args(["--secret", f.name,

1294

"foo"], command.SetSecret,

1295

value_to_set=value)

1296

1297

def test_secret_devnull_short(self):

1298

self.assert_command_from_args(["-s", os.path.devnull, "foo"],

1299

command.SetSecret,

1300

value_to_set=b"")

1301

1302

def test_secret_tempfile_short(self):

1303

with tempfile.NamedTemporaryFile(mode="r+b") as f:

1304

value = b"secret\0xyzzy\nbar"

1305

f.write(value)

1306

f.seek(0)

1307

self.assert_command_from_args(["-s", f.name, "foo"],

1308

command.SetSecret,

1309

value_to_set=value)

1310

1311

def test_timeout(self):

1312

self.assert_command_from_args(["--timeout", "PT5M", "foo"],

1313

command.SetTimeout,

1314

value_to_set=300000)

1315

1316

def test_timeout_short(self):

1317

self.assert_command_from_args(["-t", "PT5M", "foo"],

1318

command.SetTimeout,

1319

value_to_set=300000)

1320

1321

def test_extended_timeout(self):

1322

self.assert_command_from_args(["--extended-timeout", "PT15M",

1323

"foo"],

1324

command.SetExtendedTimeout,

1325

value_to_set=900000)

1326

1327

def test_interval(self):

1328

self.assert_command_from_args(["--interval", "PT2M", "foo"],

1329

command.SetInterval,

1330

value_to_set=120000)

1331

1332

def test_interval_short(self):

1333

self.assert_command_from_args(["-i", "PT2M", "foo"],

1334

command.SetInterval,

1335

value_to_set=120000)

1336

1337

def test_approval_delay(self):

1338

self.assert_command_from_args(["--approval-delay", "PT30S",

1339

"foo"],

1340

command.SetApprovalDelay,

1341

value_to_set=30000)

1342

1343

def test_approval_duration(self):

1344

self.assert_command_from_args(["--approval-duration", "PT1S",

1345

"foo"],

1346

command.SetApprovalDuration,

1347

value_to_set=1000)

1348

1349

def test_print_table(self):

1350

self.assert_command_from_args([], command.PrintTable,

1351

verbose=False)

1352

1353

def test_print_table_verbose(self):

1354

self.assert_command_from_args(["--verbose"],

1355

command.PrintTable,

1356

verbose=True)

1357

1358

def test_print_table_verbose_short(self):

1359

self.assert_command_from_args(["-v"], command.PrintTable,

1360

verbose=True)

1361

1362

1363

class TestCommand(unittest.TestCase):

1364

"""Abstract class for tests of command classes"""

1365

1366

def setUp(self):

1367

testcase = self

1368

class MockClient(object):

1369

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

1370

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

1371

self.attributes = attributes

1372

self.attributes["Name"] = name

1373

self.calls = []

1374

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

1375

testcase.assertEqual(interface, client_dbus_interface)

1376

testcase.assertEqual(dbus_interface,

1377

dbus.PROPERTIES_IFACE)

1378

self.attributes[propname] = value

1379

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

1380

testcase.assertEqual(interface, client_dbus_interface)

1381

testcase.assertEqual(dbus_interface,

1382

dbus.PROPERTIES_IFACE)

1383

return self.attributes[propname]

1384

def Approve(self, approve, dbus_interface):

1385

testcase.assertEqual(dbus_interface,

1386

client_dbus_interface)

1387

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

1388

dbus_interface)))

1389

self.client = MockClient(

1390

"foo",

1391

KeyID=("92ed150794387c03ce684574b1139a65"

1392

"94a34f895daaaf09fd8ea90a27cddb12"),

1393

Secret=b"secret",

1394

Host="foo.example.org",

1395

Enabled=dbus.Boolean(True),

1396

Timeout=300000,

1397

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

1398

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

1399

Interval=120000,

1400

Fingerprint=("778827225BA7DE539C5A"

1401

"7CFA59CFF7CDBD9A5920"),

1402

CheckerRunning=dbus.Boolean(False),

1403

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

1404

ApprovalPending=dbus.Boolean(False),

1405

ApprovedByDefault=dbus.Boolean(True),

1406

LastApprovalRequest="",

1407

ApprovalDelay=0,

1408

ApprovalDuration=1000,

1409

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

1410

ExtendedTimeout=900000,

1411

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

1412

LastCheckerStatus=0)

1413

self.other_client = MockClient(

1414

"barbar",

1415

KeyID=("0558568eedd67d622f5c83b35a115f79"

1416

"6ab612cff5ad227247e46c2b020f441c"),

1417

Secret=b"secretbar",

1418

Host="192.0.2.3",

1419

Enabled=dbus.Boolean(True),

1420

Timeout=300000,

1421

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

1422

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

1423

Interval=120000,

1424

Fingerprint=("3E393AEAEFB84C7E89E2"

1425

"F547B3A107558FCA3A27"),

1426

CheckerRunning=dbus.Boolean(True),

1427

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

1428

ApprovalPending=dbus.Boolean(False),

1429

ApprovedByDefault=dbus.Boolean(False),

1430

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

1431

ApprovalDelay=30000,

1432

ApprovalDuration=93785000,

1433

Checker=":",

1434

ExtendedTimeout=900000,

1435

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

1436

LastCheckerStatus=-2)

1437

self.clients = collections.OrderedDict(

1438

[

1439

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

1440

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

1441

])

1442

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

1443

1444

@property

1445

def bus(self):

1446

class Bus(object):

1447

@staticmethod

1448

def get_object(client_bus_name, path):

1449

self.assertEqual(client_bus_name, dbus_busname)

1450

return {

1451

# Note: "self" here is the TestCmd instance, not

1452

# the Bus instance, since this is a static method!

1453

"/clients/foo": self.client,

1454

"/clients/barbar": self.other_client,

1455

}[path]

1456

return Bus()

1457

1458

1459

class TestBaseCommands(TestCommand):

1460

1461

def test_is_enabled(self):

1462

self.assertTrue(all(command.IsEnabled().is_enabled(client,

1463

properties)

1464

for client, properties

1465

in self.clients.items()))

1466

1467

def test_is_enabled_run_exits_successfully(self):

1468

with self.assertRaises(SystemExit) as e:

1469

command.IsEnabled().run(self.one_client)

1470

if e.exception.code is not None:

1471

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

1472

else:

1473

self.assertIsNone(e.exception.code)

1474

1475

def test_is_enabled_run_exits_with_failure(self):

1476

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

1477

with self.assertRaises(SystemExit) as e:

1478

command.IsEnabled().run(self.one_client)

1479

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

1480

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

1481

else:

1482

self.assertIsNotNone(e.exception.code)

1483

1484

def test_approve(self):

1485

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

1486

for clientpath in self.clients:

1487

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

1488

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

1489

client.calls)

1490

1491

def test_deny(self):

1492

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

1493

for clientpath in self.clients:

1494

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

1495

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

1496

client.calls)

1497

1498

def test_remove(self):

1499

class MockMandos(object):

1500

def __init__(self):

1501

self.calls = []

1502

def RemoveClient(self, dbus_path):

1503

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

1504

mandos = MockMandos()

1505

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

1506

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

1507

for clientpath in self.clients:

1508

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

1509

mandos.calls)

1510

1511

expected_json = {

1512

"foo": {

1513

"Name": "foo",

1514

"KeyID": ("92ed150794387c03ce684574b1139a65"

1515

"94a34f895daaaf09fd8ea90a27cddb12"),

1516

"Host": "foo.example.org",

1517

"Enabled": True,

1518

"Timeout": 300000,

1519

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

1520

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

1521

"Interval": 120000,

1522

"Fingerprint": ("778827225BA7DE539C5A"

1523

"7CFA59CFF7CDBD9A5920"),

1524

"CheckerRunning": False,

1525

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

1526

"ApprovalPending": False,

1527

"ApprovedByDefault": True,

1528

"LastApprovalRequest": "",

1529

"ApprovalDelay": 0,

1530

"ApprovalDuration": 1000,

1531

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

1532

"ExtendedTimeout": 900000,

1533

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

1534

"LastCheckerStatus": 0,

1535

},

1536

"barbar": {

1537

"Name": "barbar",

1538

"KeyID": ("0558568eedd67d622f5c83b35a115f79"

1539

"6ab612cff5ad227247e46c2b020f441c"),

1540

"Host": "192.0.2.3",

1541

"Enabled": True,

1542

"Timeout": 300000,

1543

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

1544

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

1545

"Interval": 120000,

1546

"Fingerprint": ("3E393AEAEFB84C7E89E2"

1547

"F547B3A107558FCA3A27"),

1548

"CheckerRunning": True,

1549

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

1550

"ApprovalPending": False,

1551

"ApprovedByDefault": False,

1552

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

1553

"ApprovalDelay": 30000,

1554

"ApprovalDuration": 93785000,

1555

"Checker": ":",

1556

"ExtendedTimeout": 900000,

1557

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

1558

"LastCheckerStatus": -2,

1559

},

1560

}

1561

1562

def test_DumpJSON_normal(self):

1563

output = command.DumpJSON().output(self.clients.values())

1564

json_data = json.loads(output)

1565

self.assertDictEqual(json_data, self.expected_json)

1566

1567

def test_DumpJSON_one_client(self):

1568

output = command.DumpJSON().output(self.one_client.values())

1569

json_data = json.loads(output)

1570

expected_json = {"foo": self.expected_json["foo"]}

1571

self.assertDictEqual(json_data, expected_json)

1572

1573

def test_PrintTable_normal(self):

1574

output = command.PrintTable().output(self.clients.values())

1575

expected_output = "\n".join((

1576

"Name Enabled Timeout Last Successful Check",

1577

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

1578

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

1579

))

1580

self.assertEqual(output, expected_output)

1581

1582

def test_PrintTable_verbose(self):

1583

output = command.PrintTable(verbose=True).output(

1584

self.clients.values())

1585

columns = (

1586

(

1587

"Name ",

1588

"foo ",

1589

"barbar ",

1590

),(

1591

"Enabled ",

1592

"Yes ",

1593

"Yes ",

1594

),(

1595

"Timeout ",

1596

"00:05:00 ",

1597

"00:05:00 ",

1598

),(

1599

"Last Successful Check ",

1600

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

1601

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

1602

),(

1603

"Created ",

1604

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

1605

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

1606

),(

1607

"Interval ",

1608

"00:02:00 ",

1609

"00:02:00 ",

1610

),(

1611

"Host ",

1612

"foo.example.org ",

1613

"192.0.2.3 ",

1614

),(

1615

("Key ID "

1616

" "),

1617

("92ed150794387c03ce684574b1139a6594a34f895daaaf09fd8"

1618

"ea90a27cddb12 "),

1619

("0558568eedd67d622f5c83b35a115f796ab612cff5ad227247e"

1620

"46c2b020f441c "),

1621

),(

1622

"Fingerprint ",

1623

"778827225BA7DE539C5A7CFA59CFF7CDBD9A5920 ",

1624

"3E393AEAEFB84C7E89E2F547B3A107558FCA3A27 ",

1625

),(

1626

"Check Is Running ",

1627

"No ",

1628

"Yes ",

1629

),(

1630

"Last Enabled ",

1631

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

1632

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

1633

),(

1634

"Approval Is Pending ",

1635

"No ",

1636

"No ",

1637

),(

1638

"Approved By Default ",

1639

"Yes ",

1640

"No ",

1641

),(

1642

"Last Approval Request ",

1643

" ",

1644

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

1645

),(

1646

"Approval Delay ",

1647

"00:00:00 ",

1648

"00:00:30 ",

1649

),(

1650

"Approval Duration ",

1651

"00:00:01 ",

1652

"1T02:03:05 ",

1653

),(

1654

"Checker ",

1655

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

1656

": ",

1657

),(

1658

"Extended Timeout ",

1659

"00:15:00 ",

1660

"00:15:00 ",

1661

),(

1662

"Expires ",

1663

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

1664

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

1665

),(

1666

"Last Checker Status",

1667

"0 ",

1668

"-2 ",

1669

)

1670

)

1671

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

1672

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

1673

for rows in columns)

1674

for line in range(num_lines))

1675

self.assertEqual(output, expected_output)

1676

1677

def test_PrintTable_one_client(self):

1678

output = command.PrintTable().output(self.one_client.values())

1679

expected_output = "\n".join((

1680

"Name Enabled Timeout Last Successful Check",

1681

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

1682

))

1683

self.assertEqual(output, expected_output)

1684

1685

1686

class TestPropertyCmd(TestCommand):

1687

"""Abstract class for tests of command.Property classes"""

1688

def runTest(self):

1689

if not hasattr(self, "command"):

1690

return

1691

values_to_get = getattr(self, "values_to_get",

1692

self.values_to_set)

1693

for value_to_set, value_to_get in zip(self.values_to_set,

1694

values_to_get):

1695

for clientpath in self.clients:

1696

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

1697

old_value = client.attributes[self.propname]

1698

self.assertNotIsInstance(old_value, self.Unique)

1699

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

1700

self.run_command(value_to_set, self.clients)

1701

for clientpath in self.clients:

1702

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

1703

value = client.attributes[self.propname]

1704

self.assertNotIsInstance(value, self.Unique)

1705

self.assertEqual(value, value_to_get)

1706

1707

class Unique(object):

1708

"""Class for objects which exist only to be unique objects,

1709

since unittest.mock.sentinel only exists in Python 3.3"""

1710

1711

def run_command(self, value, clients):

1712

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

1713

1714

1715

class TestEnableCmd(TestPropertyCmd):

1716

command = command.Enable

1717

propname = "Enabled"

1718

values_to_set = [dbus.Boolean(True)]

1719

1720

1721

class TestDisableCmd(TestPropertyCmd):

1722

command = command.Disable

1723

propname = "Enabled"

1724

values_to_set = [dbus.Boolean(False)]

1725

1726

1727

class TestBumpTimeoutCmd(TestPropertyCmd):

1728

command = command.BumpTimeout

1729

propname = "LastCheckedOK"

1730

values_to_set = [""]

1731

1732

1733

class TestStartCheckerCmd(TestPropertyCmd):

1734

command = command.StartChecker

1735

propname = "CheckerRunning"

1736

values_to_set = [dbus.Boolean(True)]

1737

1738

1739

class TestStopCheckerCmd(TestPropertyCmd):

1740

command = command.StopChecker

1741

propname = "CheckerRunning"

1742

values_to_set = [dbus.Boolean(False)]

1743

1744

1745

class TestApproveByDefaultCmd(TestPropertyCmd):

1746

command = command.ApproveByDefault

1747

propname = "ApprovedByDefault"

1748

values_to_set = [dbus.Boolean(True)]

1749

1750

1751

class TestDenyByDefaultCmd(TestPropertyCmd):

1752

command = command.DenyByDefault

1753

propname = "ApprovedByDefault"

1754

values_to_set = [dbus.Boolean(False)]

1755

1756

1757

class TestPropertyValueCmd(TestPropertyCmd):

1758

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

1759

1760

def runTest(self):

1761

if type(self) is TestPropertyValueCmd:

1762

return

1763

return super(TestPropertyValueCmd, self).runTest()

1764

1765

def run_command(self, value, clients):

1766

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

1767

1768

1769

class TestSetCheckerCmd(TestPropertyValueCmd):

1770

command = command.SetChecker

1771

propname = "Checker"

1772

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

1773

1774

1775

class TestSetHostCmd(TestPropertyValueCmd):

1776

command = command.SetHost

1777

propname = "Host"

1778

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

1779

1780

1781

class TestSetSecretCmd(TestPropertyValueCmd):

1782

command = command.SetSecret

1783

propname = "Secret"

1784

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

1785

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

1786

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

1787

1788

1789

class TestSetTimeoutCmd(TestPropertyValueCmd):

1790

command = command.SetTimeout

1791

propname = "Timeout"

1792

values_to_set = [datetime.timedelta(),

1793

datetime.timedelta(minutes=5),

1794

datetime.timedelta(seconds=1),

1795

datetime.timedelta(weeks=1),

1796

datetime.timedelta(weeks=52)]

1797

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

1798

1799

1800

class TestSetExtendedTimeoutCmd(TestPropertyValueCmd):

1801

command = command.SetExtendedTimeout

1802

propname = "ExtendedTimeout"

1803

values_to_set = [datetime.timedelta(),

1804

datetime.timedelta(minutes=5),

1805

datetime.timedelta(seconds=1),

1806

datetime.timedelta(weeks=1),

1807

datetime.timedelta(weeks=52)]

1808

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

1809

1810

1811

class TestSetIntervalCmd(TestPropertyValueCmd):

1812

command = command.SetInterval

1813

propname = "Interval"

1814

values_to_set = [datetime.timedelta(),

1815

datetime.timedelta(minutes=5),

1816

datetime.timedelta(seconds=1),

1817

datetime.timedelta(weeks=1),

1818

datetime.timedelta(weeks=52)]

1819

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

1820

1821

1822

class TestSetApprovalDelayCmd(TestPropertyValueCmd):

1823

command = command.SetApprovalDelay

1824

propname = "ApprovalDelay"

1825

values_to_set = [datetime.timedelta(),

1826

datetime.timedelta(minutes=5),

1827

datetime.timedelta(seconds=1),

1828

datetime.timedelta(weeks=1),

1829

datetime.timedelta(weeks=52)]

1830

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

1831

1832

1833

class TestSetApprovalDurationCmd(TestPropertyValueCmd):

1834

command = command.SetApprovalDuration

1835

propname = "ApprovalDuration"

1836

values_to_set = [datetime.timedelta(),

1837

datetime.timedelta(minutes=5),

1838

datetime.timedelta(seconds=1),

1839

datetime.timedelta(weeks=1),

1840

datetime.timedelta(weeks=52)]

1841

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

1842

1843

1844

1845

def should_only_run_tests():

1846

parser = argparse.ArgumentParser(add_help=False)

1847

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

1848

args, unknown_args = parser.parse_known_args()

1849

run_tests = args.check

1850

if run_tests:

1851

# Remove --check argument from sys.argv

1852

sys.argv[1:] = unknown_args

1853

return run_tests

1854

1855

# Add all tests from doctest strings

1856

def load_tests(loader, tests, none):

1857

import doctest

1858

tests.addTests(doctest.DocTestSuite())

1859

return tests

343

1860

344

1861

if __name__ == "__main__":

345

main()

1862

try:

1863

if should_only_run_tests():

1864

# Call using ./tdd-python-script --check [--verbose]

1865

unittest.main()

1866

else:

1867

main()

1868

finally:

1869

logging.shutdown()