1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
|
#!/usr/bin/env python
from argparse import ArgumentParser
from contextlib import contextmanager
import logging
from textwrap import dedent
from subprocess import CalledProcessError
import sys
from fakejuju import (
fake_juju_client,
)
from jujucharm import (
local_charm_path,
)
from jujupy import (
client_from_config,
EnvJujuClient1X,
IncompatibleConfigClass,
SimpleEnvironment,
until_timeout,
)
from deploy_stack import (
BootstrapManager,
check_token,
get_random_string,
)
from jujuci import add_credential_args
from utility import (
configure_logging,
)
def prepare_dummy_env(client):
"""Use a client to prepare a dummy environment."""
charm_source = local_charm_path(
charm='dummy-source', juju_ver=client.version)
client.deploy(charm_source)
charm_sink = local_charm_path(charm='dummy-sink', juju_ver=client.version)
client.deploy(charm_sink)
token = get_random_string()
client.set_config('dummy-source', {'token': token})
client.juju('add-relation', ('dummy-source', 'dummy-sink'))
client.juju('expose', ('dummy-sink',))
return token
def get_clients(initial, other, base_env, debug, agent_url):
"""Return the clients to use for testing."""
if initial == 'FAKE':
environment = SimpleEnvironment.from_config(base_env)
client = fake_juju_client(env=environment)
return client, client, client
else:
initial_client = client_from_config(base_env, initial, debug=debug)
environment = initial_client.env
if agent_url is None:
environment.discard_option('tools-metadata-url')
other_client = initial_client.clone_path_cls(other)
# System juju is assumed to be released and the best choice for tearing
# down environments reliably. (For example, 1.18.x cannot tear down
# environments with alpha agent-versions.)
try:
released_client = initial_client.clone_path_cls(None)
except IncompatibleConfigClass:
# If initial_client's config class is incompatible with the system
# juju, use initial client for teardown.
released_client = initial_client
# If released_client is a different major version, it cannot tear down
# initial client, so use initial client for teardown.
if (
isinstance(released_client, EnvJujuClient1X) !=
isinstance(initial_client, EnvJujuClient1X)
):
released_client = initial_client
else:
# If system juju is used, ensure it has identical env to
# initial_client.
released_client.env = initial_client.env
return initial_client, other_client, released_client
def assess_heterogeneous(initial, other, base_env, environment_name, log_dir,
upload_tools, debug, agent_url, agent_stream, series):
"""Top level function that prepares the clients and environment.
initial and other are paths to the binary used initially, and a binary
used later. base_env is the name of the environment to base the
environment on and environment_name is the new name for the environment.
"""
initial_client, other_client, teardown_client = get_clients(
initial, other, base_env, debug, agent_url)
jes_enabled = initial_client.is_jes_enabled()
bs_manager = BootstrapManager(
environment_name, initial_client, teardown_client,
bootstrap_host=None, machines=[], series=series, agent_url=agent_url,
agent_stream=agent_stream, region=None, log_dir=log_dir,
keep_env=False, permanent=jes_enabled, jes_enabled=jes_enabled)
test_control_heterogeneous(bs_manager, other_client, upload_tools)
@contextmanager
def run_context(bs_manager, other, upload_tools):
try:
bs_manager.keep_env = True
with bs_manager.booted_context(upload_tools):
if other.env.juju_home != bs_manager.client.env.juju_home:
raise AssertionError('Juju home out of sync')
yield
# Test clean shutdown of an environment.
callback_with_fallback(other, bs_manager.tear_down_client,
nice_tear_down)
except:
bs_manager.tear_down()
raise
def test_control_heterogeneous(bs_manager, other, upload_tools):
"""Test if one binary can control an environment set up by the other."""
initial = bs_manager.client
released = bs_manager.tear_down_client
with run_context(bs_manager, other, upload_tools):
token = prepare_dummy_env(initial)
initial.wait_for_started()
if sys.platform != "win32":
# Currently, juju ssh is not working on Windows.
check_token(initial, token)
check_series(other)
other.juju('run', ('--all', 'uname -a'))
other.get_config('dummy-source')
other.get_model_config()
other.juju('remove-relation', ('dummy-source', 'dummy-sink'))
status = other.get_status()
other.juju('unexpose', ('dummy-sink',))
status = other.get_status()
if status.get_applications()['dummy-sink']['exposed']:
raise AssertionError('dummy-sink is still exposed')
status = other.get_status()
charm_path = local_charm_path(
charm='dummy-sink', juju_ver=other.version)
juju_with_fallback(other, released, 'deploy',
(charm_path, 'sink2'))
other.wait_for_started()
other.juju('add-relation', ('dummy-source', 'sink2'))
status = other.get_status()
other.juju('expose', ('sink2',))
status = other.get_status()
if 'sink2' not in status.get_applications():
raise AssertionError('Sink2 missing')
other.remove_service('sink2')
for ignored in until_timeout(30):
status = other.get_status()
if 'sink2' not in status.get_applications():
break
else:
raise AssertionError('Sink2 not destroyed')
other.juju('add-relation', ('dummy-source', 'dummy-sink'))
status = other.get_status()
relations = status.get_applications()['dummy-sink']['relations']
if not relations['source'] == ['dummy-source']:
raise AssertionError('source is not dummy-source.')
other.juju('expose', ('dummy-sink',))
status = other.get_status()
if not status.get_applications()['dummy-sink']['exposed']:
raise AssertionError('dummy-sink is not exposed')
other.juju('add-unit', ('dummy-sink',))
if not has_agent(other, 'dummy-sink/1'):
raise AssertionError('dummy-sink/1 was not added.')
other.juju('remove-unit', ('dummy-sink/1',))
status = other.get_status()
if has_agent(other, 'dummy-sink/1'):
raise AssertionError('dummy-sink/1 was not removed.')
container_type = other.preferred_container()
other.juju('add-machine', (container_type,))
status = other.get_status()
container_machine, = set(k for k, v in status.agent_items() if
k.endswith('/{}/0'.format(container_type)))
container_holder = container_machine.split('/')[0]
other.juju('remove-machine', (container_machine,))
wait_until_removed(other, container_machine)
other.juju('remove-machine', (container_holder,))
wait_until_removed(other, container_holder)
# suppress nosetests
test_control_heterogeneous.__test__ = False
def juju_with_fallback(other, released, command, args, include_e=True):
"""Fallback to released juju when 1.18 fails.
Get as much test coverage of 1.18 as we can, by falling back to a released
juju for commands that we expect to fail (due to unsupported agent version
format).
"""
def call_juju(client):
client.juju(command, args, include_e=include_e)
return callback_with_fallback(other, released, call_juju)
def callback_with_fallback(other, released, callback):
for client in [other, released]:
try:
callback(client)
except CalledProcessError:
if not client.version.startswith('1.18.'):
raise
else:
break
def nice_tear_down(client):
if client.is_jes_enabled():
client.kill_controller()
else:
if client.destroy_environment(force=False) != 0:
raise CalledProcessError(1, 'juju destroy-environment')
def has_agent(client, agent_id):
return bool(agent_id in dict(client.get_status().agent_items()))
def wait_until_removed(client, agent_id):
"""Wait for an agent to be removed from the environment."""
for ignored in until_timeout(240):
if not has_agent(client, agent_id):
return
else:
raise AssertionError('Machine not destroyed: {}.'.format(agent_id))
def check_series(client, machine='0', series=None):
"""Use 'juju ssh' to check that the deployed series meets expectations."""
result = client.get_juju_output('ssh', machine, 'lsb_release', '-c')
label, codename = result.rstrip().split('\t')
if label != 'Codename:':
raise AssertionError()
if series:
expected_codename = series
else:
expected_codename = client.env.get_option('default-series')
if codename != expected_codename:
raise AssertionError(
'Series is {}, not {}'.format(codename, expected_codename))
def parse_args(argv=None):
parser = ArgumentParser(description=dedent("""\
Determine whether one juju version can control an environment created
by another version.
"""))
parser.add_argument('initial', help='The initial juju binary.')
parser.add_argument('other', help='A different juju binary.')
parser.add_argument('base_environment', help='The environment to base on.')
parser.add_argument('environment_name', help='The new environment name.')
parser.add_argument('log_dir', help='The directory to dump logs to.')
parser.add_argument(
'--upload-tools', action='store_true', default=False,
help='Upload local version of tools before bootstrapping.')
parser.add_argument('--debug', help='Run juju with --debug',
action='store_true', default=False)
parser.add_argument('--agent-url', default=None)
parser.add_argument('--agent-stream', action='store',
help='URL for retrieving agent binaries.')
parser.add_argument('--series', action='store',
help='Name of the Ubuntu series to use.')
add_credential_args(parser)
return parser.parse_args(argv)
def main():
args = parse_args()
configure_logging(logging.INFO)
assess_heterogeneous(args.initial, args.other, args.base_environment,
args.environment_name, args.log_dir,
args.upload_tools, args.debug, args.agent_url,
args.agent_stream, args.series)
if __name__ == '__main__':
main()
|