~abentley/juju-ci-tools/client-from-config-4 : revision 1477

104

return wrapper

105

106

107

class AdminOperation(Exception):

107

class ControllerOperation(Exception):

108

109

def __init__(self, operation):

110

super(AdminOperation, self).__init__(

111

'Operation "{}" can only be performed on admin models.'.format(

110

super(ControllerOperation, self).__init__(

111

'Operation "{}" is only valid on controller models.'.format(

112

operation))

113

114

135

state.controller.state = 'created'

136

return state

137

138

def require_admin(self, operation, name):

139

if name != self.admin_model.name:

140

raise AdminOperation(operation)

138

def require_controller(self, operation, name):

139

if name != self.controller_model.name:

140

raise ControllerOperation(operation)

141

142

def bootstrap(self, model_name, config, separate_admin):

142

def bootstrap(self, model_name, config, separate_controller):

143

default_model = self.add_model(model_name)

144

default_model.name = model_name

145

if separate_admin:

146

admin_model = default_model.controller.add_model('controller')

145

if separate_controller:

146

controller_model = default_model.controller.add_model('controller')

147

else:

148

admin_model = default_model

149

self.admin_model = admin_model

150

admin_model.state_servers.append(admin_model.add_machine())

148

controller_model = default_model

149

self.controller_model = controller_model

150

controller_model.state_servers.append(controller_model.add_machine())

151

self.state = 'bootstrapped'

152

default_model.model_config = copy.deepcopy(config)

153

self.models[default_model.name] = default_model

235

self.controller.state = 'model-destroyed'

236

237

def restore_backup(self):

238

self.controller.require_admin('restore', self.name)

238

self.controller.require_controller('restore', self.name)

239

if len(self.state_servers) > 0:

240

exc = subprocess.CalledProcessError('Operation not permitted', 1,

241

2)

243

raise exc

244

245

def enable_ha(self):

246

self.controller.require_admin('enable-ha', self.name)

246

self.controller.require_controller('enable-ha', self.name)

247

for n in range(2):

248

self.state_servers.append(self.add_machine())

249

421

for x in range(parsed.count):

422

model_state.add_machine()

423

424

def get_admin_model_name(self):

425

return self.controller_state.admin_model.name

424

def get_controller_model_name(self):

425

return self.controller_state.controller_model.name

426

427

def make_controller_dict(self, controller_name):

428

admin_model = self.controller_state.admin_model

429

server_id = list(admin_model.state_servers)[0]

430

server_hostname = admin_model.machine_host_names[server_id]

428

controller_model = self.controller_state.controller_model

429

server_id = list(controller_model.state_servers)[0]

430

server_hostname = controller_model.machine_host_names[server_id]

431

api_endpoint = '{}:23'.format(server_hostname)

432

return {controller_name: {'details': {'api-endpoints': [

433

api_endpoint]}}}

580

# subset of YAML, so emit JSON.

581

return json.dumps(status_dict)

582

if command == 'create-backup':

583

self.controller_state.require_admin('backup', model)

583

self.controller_state.require_controller('backup', model)

584

return 'juju-backup-0.tar.gz'

585

return ''

586

659

660

class FakeJujuClientOptionalJES(EnvJujuClient):

661

662

def get_admin_model_name(self):

663

return self._backend.controller_state.admin_model.name

662

def get_controller_model_name(self):

663

return self._backend.controller_state.controller_model.name

664

665

666

class TestErroredUnit(TestCase):

1334

full = client._full_args('bar', True, ('baz', 'qux'))

1335

self.assertEqual((

1336

'bin', '--show-log', 'bar', '-m', 'foo:foo', 'baz', 'qux'), full)

1337

full = client._full_args('bar', True, ('baz', 'qux'), admin=True)

1337

full = client._full_args('bar', True, ('baz', 'qux'), controller=True)

1338

self.assertEqual(

1339

('bin', '--show-log', 'bar', '-m', 'foo:controller', 'baz', 'qux'),

1340

full)

1358

'baz', 'qux'),

1359

full)

1360

1361

def test_full_args_admin(self):

1361

def test_full_args_controller(self):

1362

env = JujuData('foo')

1363

client = EnvJujuClient(env, None, 'my/juju/bin')

1364

with patch.object(client, 'get_admin_model_name',

1364

with patch.object(client, 'get_controller_model_name',

1365

return_value='controller') as gamn_mock:

1366

full = client._full_args('bar', False, ('baz', 'qux'), admin=True)

1366

full = client._full_args('bar', False, ('baz', 'qux'),

1367

controller=True)

1367

1368

self.assertEqual((

1368

1369

'bin', '--show-log', 'bar', '-m', 'foo:controller', 'baz', 'qux'),

1369

1370

full)

1699

1700

return_value=output_text) as gjo_mock:

1700

1701

result = client.get_status()

1701

1702

gjo_mock.assert_called_once_with(

1702

'show-status', '--format', 'yaml', admin=False)

1703

'show-status', '--format', 'yaml', controller=False)

1703

1704

self.assertEqual(Status, type(result))

1704

1705

self.assertEqual(['a', 'b', 'c'], result.status)

1705

1706

2333

2334

self.assertIs(client, model_clients[0])

2334

2335

self.assertEqual('bar', model_clients[1].env.environment)

2335

2336

def test_get_admin_model_name(self):

2337

def test_get_controller_model_name(self):

2337

2338

models = {

2338

2339

'models': [

2339

2340

{'name': 'controller', 'model-uuid': 'aaaa'},

2343

2344

client = EnvJujuClient(JujuData('foo'), None, None)

2344

2345

with patch.object(client, 'get_models',

2345

2346

return_value=models) as gm_mock:

2346

admin_name = client.get_admin_model_name()

2347

controller_name = client.get_controller_model_name()

2347

2348

self.assertEqual(0, gm_mock.call_count)

2348

self.assertEqual('controller', admin_name)

2349

self.assertEqual('controller', controller_name)

2349

2350

def test_get_admin_model_name_without_admin(self):

2351

def test_get_controller_model_name_without_controller(self):

2351

2352

models = {

2352

2353

'models': [

2353

2354

{'name': 'bar', 'model-uuid': 'aaaa'},

2356

2357

}

2357

2358

client = EnvJujuClient(JujuData('foo'), None, None)

2358

2359

with patch.object(client, 'get_models', return_value=models):

2359

admin_name = client.get_admin_model_name()

2360

self.assertEqual('controller', admin_name)

2360

controller_name = client.get_controller_model_name()

2361

self.assertEqual('controller', controller_name)

2361

2362

def test_get_admin_model_name_no_models(self):

2363

def test_get_controller_model_name_no_models(self):

2363

2364

client = EnvJujuClient(JujuData('foo'), None, None)

2364

2365

with patch.object(client, 'get_models', return_value={}):

2365

admin_name = client.get_admin_model_name()

2366

self.assertEqual('controller', admin_name)

2366

controller_name = client.get_controller_model_name()

2367

self.assertEqual('controller', controller_name)

2367

2368

def test_get_admin_client(self):

2369

def test_get_controller_client(self):

2369

2370

client = EnvJujuClient(

2370

2371

JujuData('foo', {'bar': 'baz'}, 'myhome'), None, None)

2371

admin_client = client.get_admin_client()

2372

admin_env = admin_client.env

2373

self.assertEqual('controller', admin_env.environment)

2372

controller_client = client.get_controller_client()

2373

controller_env = controller_client.env

2374

self.assertEqual('controller', controller_env.environment)

2374

2375

self.assertEqual(

2375

{'bar': 'baz', 'name': 'controller'}, admin_env.config)

2376

{'bar': 'baz', 'name': 'controller'}, controller_env.config)

2376

2377

2378

def test_list_controllers(self):

2378

2379

client = EnvJujuClient(JujuData('foo'), None, None)

2415

2416

api-endpoints: ['[::1]:17070', '[fe80::216:3eff:0:9dc7]:17070']

2416

2417

"""

2417

2418

client = EnvJujuClient(JujuData('foo', {}), None, None)

2418

admin_client = client.get_admin_client()

2419

controller_client = client.get_controller_client()

2419

2420

client.env.controller.name = 'bar'

2420

with patch.object(admin_client, 'get_juju_output',

2421

with patch.object(controller_client, 'get_juju_output',

2421

2422

return_value=data) as gjo:

2422

endpoint = admin_client.get_controller_endpoint()

2423

endpoint = controller_client.get_controller_endpoint()

2423

2424

gjo.assert_called_once_with('show-controller', 'bar',

2424

2425

include_e=False)

2425

2426

self.assertEqual('::1', endpoint)

2426

2427

2428

def test_get_controller_members(self):

2428

2429

status = Status.from_text("""\

2429

model: admin

2430

model: controller

2430

2431

machines:

2431

2432

"0":

2432

2433

dns-name: 10.0.0.0

2476

2477

2478

def test_get_controller_members_one(self):

2478

2479

status = Status.from_text("""\

2479

model: admin

2480

model: controller

2480

2481

machines:

2481

2482

"0":

2482

2483

dns-name: 10.0.0.0

2524

2525

return_value=value) as gjo_mock:

2525

2526

client.wait_for_ha()

2526

2527

gjo_mock.assert_called_once_with(

2527

'show-status', '--format', 'yaml', admin=True)

2528

'show-status', '--format', 'yaml', controller=True)

2528

2529

2530

def test_wait_for_ha_no_has_vote(self):

2530

2531

value = yaml.safe_dump({

3372

3373

3374

class TestEnvJujuClient2B7(ClientTest):

3374

3375

def test_get_admin_model_name(self):

3376

def test_get_controller_model_name(self):

3376

3377

models = {

3377

3378

'models': [

3378

3379

{'name': 'admin', 'model-uuid': 'aaaa'},

3382

3383

client = EnvJujuClient2B7(JujuData('foo'), None, None)

3383

3384

with patch.object(client, 'get_models',

3384

3385

return_value=models) as gm_mock:

3385

admin_name = client.get_admin_model_name()

3386

controller_name = client.get_controller_model_name()

3386

3387

self.assertEqual(0, gm_mock.call_count)

3387

self.assertEqual('admin', admin_name)

3388

self.assertEqual('admin', controller_name)

3388

3389

def test_get_admin_model_name_without_admin(self):

3390

def test_get_controller_model_name_without_controller(self):

3390

3391

models = {

3391

3392

'models': [

3392

3393

{'name': 'bar', 'model-uuid': 'aaaa'},

3395

3396

}

3396

3397

client = EnvJujuClient2B7(JujuData('foo'), None, None)

3397

3398

with patch.object(client, 'get_models', return_value=models):

3398

admin_name = client.get_admin_model_name()

3399

self.assertEqual('admin', admin_name)

3399

controller_name = client.get_controller_model_name()

3400

self.assertEqual('admin', controller_name)

3400

3401

def test_get_admin_model_name_no_models(self):

3402

def test_get_controller_model_name_no_models(self):

3402

3403

client = EnvJujuClient2B7(JujuData('foo'), None, None)

3403

3404

with patch.object(client, 'get_models', return_value={}):

3404

admin_name = client.get_admin_model_name()

3405

self.assertEqual('admin', admin_name)

3405

controller_name = client.get_controller_model_name()

3406

self.assertEqual('admin', controller_name)

3406

3407

def test_get_admin_client(self):

3408

def test_get_controller_client(self):

3408

3409

client = EnvJujuClient2B7(

3409

3410

JujuData('foo', {'bar': 'baz'}, 'myhome'), None, None)

3410

admin_client = client.get_admin_client()

3411

admin_env = admin_client.env

3412

self.assertEqual('admin', admin_env.environment)

3413

self.assertEqual({'bar': 'baz', 'name': 'admin'}, admin_env.config)

3411

controller_client = client.get_controller_client()

3412

controller_env = controller_client.env

3413

self.assertEqual('admin', controller_env.environment)

3414

self.assertEqual({'bar': 'baz', 'name': 'admin'},

3415

controller_env.config)

3414

3416

3415

3417

3416

3418

class TestEnvJujuClient2B3(ClientTest):

3537

3539

config = yaml.safe_load(config_file)

3538

3540

self.assertEqual({'test-mode': True}, config)

3539

3541

3540

def test_get_admin_model_name(self):

3542

def test_get_controller_model_name(self):

3541

3543

models = {

3542

3544

'models': [

3543

3545

{'name': 'admin', 'model-uuid': 'aaaa'},

3547

3549

client = EnvJujuClient2B2(JujuData('foo'), None, None)

3548

3550

with patch.object(client, 'get_models',

3549

3551

return_value=models) as gm_mock:

3550

admin_name = client.get_admin_model_name()

3552

controller_name = client.get_controller_model_name()

3551

3553

gm_mock.assert_called_once_with()

3552

self.assertEqual('admin', admin_name)

3554

self.assertEqual('admin', controller_name)

3553

3555

3554

def test_get_admin_model_name_without_admin(self):

3556

def test_get_controller_model_name_without_controller(self):

3555

3557

models = {

3556

3558

'models': [

3557

3559

{'name': 'bar', 'model-uuid': 'aaaa'},

3560

3562

}

3561

3563

client = EnvJujuClient2B2(JujuData('foo'), None, None)

3562

3564

with patch.object(client, 'get_models', return_value=models):

3563

admin_name = client.get_admin_model_name()

3564

self.assertEqual('foo', admin_name)

3565

controller_name = client.get_controller_model_name()

3566

self.assertEqual('foo', controller_name)

3565

3567

3566

def test_get_admin_model_name_no_models(self):

3568

def test_get_controller_model_name_no_models(self):

3567

3569

client = EnvJujuClient2B2(JujuData('foo'), None, None)

3568

3570

with patch.object(client, 'get_models', return_value={}):

3569

admin_name = client.get_admin_model_name()

3570

self.assertEqual('foo', admin_name)

3571

controller_name = client.get_controller_model_name()

3572

self.assertEqual('foo', controller_name)

3571

3573

3572

3574

3573

3575

class TestEnvJujuClient2A2(TestCase):

3796

3798

self.assertEqual((

3797

3799

'bin', '--debug', 'bar', '-e', 'foo', 'baz', 'qux'), full)

3798

3800

3799

def test_full_args_admin(self):

3801

def test_full_args_controller(self):

3800

3802

env = SimpleEnvironment('foo')

3801

3803

client = EnvJujuClient1X(env, None, 'my/juju/bin')

3802

full = client._full_args('bar', False, ('baz', 'qux'), admin=True)

3804

full = client._full_args('bar', False, ('baz', 'qux'), controller=True)

3803

3805

self.assertEqual((

3804

3806

'bin', '--show-log', 'bar', '-e', 'foo', 'baz', 'qux'), full)

3805

3807

4093

4095

return_value=output_text) as gjo_mock:

4094

4096

result = client.get_status()

4095

4097

gjo_mock.assert_called_once_with(

4096

'status', '--format', 'yaml', admin=False)

4098

'status', '--format', 'yaml', controller=False)

4097

4099

self.assertEqual(ServiceStatus, type(result))

4098

4100

self.assertEqual(['a', 'b', 'c'], result.status)

4099

4101

4135

4137

client.get_status(500)

4136

4138

mock_ut.assert_called_with(500)

4137

4139

4138

def test_get_status_admin(self):

4140

def test_get_status_controller(self):

4139

4141

output_text = """\

4140

4142

- a

4141

4143

- b

4145

4147

client = EnvJujuClient1X(env, None, None)

4146

4148

with patch.object(client, 'get_juju_output',

4147

4149

return_value=output_text) as gjo_mock:

4148

client.get_status(admin=True)

4150

client.get_status(controller=True)

4149

4151

gjo_mock.assert_called_once_with(

4150

'status', '--format', 'yaml', admin=True)

4152

'status', '--format', 'yaml', controller=True)

4151

4153

4152

4154

@staticmethod

4153

4155

def make_status_yaml(key, machine_value, unit_value):

5157

5159

self.assertIs(client, model_clients[0])

5158

5160

self.assertEqual('bar', model_clients[1].env.environment)

5159

5161

5160

def test_get_admin_model_name_no_models(self):

5162

def test_get_controller_model_name_no_models(self):

5161

5163

env = SimpleEnvironment('foo', {'type': 'local'})

5162

5164

client = EnvJujuClient1X(env, '1.23-series-arch', None)

5163

5165

with patch.object(client, 'get_models', return_value={}):

5164

admin_name = client.get_admin_model_name()

5165

self.assertEqual('foo', admin_name)

5166

controller_name = client.get_controller_model_name()

5167

self.assertEqual('foo', controller_name)

5166

5168

5167

def test_get_admin_client(self):

5169

def test_get_controller_client(self):

5168

5170

client = EnvJujuClient1X(SimpleEnvironment('foo'), {'bar': 'baz'},

5169

5171

'myhome')

5170

admin_client = client.get_admin_client()

5171

self.assertIs(client, admin_client)

5172

controller_client = client.get_controller_client()

5173

self.assertIs(client, controller_client)

5172

5174

5173

5175

def test_list_controllers(self):

5174

5176

env = SimpleEnvironment('foo', {'type': 'local'})