← Back to branch summary

~andrewjbeach/juju-ci-tools/make-local-patcher

« back to all changes in this revision

Viewing changes to assess_jes_deploy.py

  • Committer: Aaron Bentley
  • Date: 2015-09-02 17:46:47 UTC
  • mto: This revision was merged to the branch mainline in revision 1082.
  • Revision ID: aaron.bentley@canonical.com-20150902174647-06vmnsooo6yzd46t
Stop supplying env to subprocess calls.

Show diffs side-by-side

added added

removed removed

Lines of Context:
assess_jes_deploy.py
5
5
import logging
6
6
import sys
7
7
from tempfile import NamedTemporaryFile
8
 
import os
9
8
 
10
9
import yaml
11
10
 
14
13
    check_token,
15
14
    configure_logging,
16
15
    deploy_dummy_stack,
17
 
    dump_env_logs,
18
16
    get_random_string,
19
 
    safe_print_status,
20
17
    )
21
18
from jujupy import (
22
19
    EnvJujuClient,
25
22
    )
26
23
from utility import (
27
24
    add_basic_testing_arguments,
28
 
    ensure_dir,
29
25
    print_now,
30
26
)
31
27
 
32
28
 
33
29
def make_hosted_env_client(client, suffix):
34
30
    env_name = '{}-{}'.format(client.env.environment, suffix)
35
 
    hosted_environment = SimpleEnvironment(env_name, dict(client.env.config),
36
 
                                           client.env.juju_home)
37
 
    hosted_env_client = client.clone(hosted_environment)
 
31
    hosted_environment = SimpleEnvironment(env_name, dict(client.env.config))
 
32
    hosted_env_client = EnvJujuClient.by_version(
 
33
        hosted_environment, client.full_path, client.debug,
 
34
    )
 
35
    hosted_env_client.juju_home = client.juju_home
 
36
    hosted_env_client.enable_jes()
38
37
    return hosted_env_client
39
38
 
40
39
 
41
 
def test_jes_deploy(client, charm_series, log_dir, base_env):
 
40
def test_jes_deploy(client, charm_prefix, base_env):
42
41
    """Deploy the dummy stack in two hosted environments."""
43
42
    # deploy into system env
44
 
    deploy_dummy_stack(client, charm_series)
 
43
    deploy_dummy_stack(client, charm_prefix)
45
44
 
46
45
    # deploy into hosted envs
47
 
    with hosted_environment(client, log_dir, 'env1') as env1_client:
48
 
        deploy_dummy_stack(env1_client, charm_series)
49
 
        with hosted_environment(client, log_dir, 'env2') as env2_client:
50
 
            deploy_dummy_stack(env2_client, charm_series)
 
46
    with hosted_environment(client, 'env1') as env1_client:
 
47
        deploy_dummy_stack(env1_client, charm_prefix)
 
48
        with hosted_environment(client, 'env2') as env2_client:
 
49
            deploy_dummy_stack(env2_client, charm_prefix)
51
50
            # check all the services can talk
52
51
            check_services(client)
53
52
            check_services(env1_client)
67
66
    series = args.series
68
67
    if series is None:
69
68
        series = 'precise'
70
 
    charm_series = series
 
69
    charm_prefix = 'local:{}/'.format(series)
71
70
    client = EnvJujuClient.by_version(
72
71
        SimpleEnvironment.from_config(base_env), args.juju_bin, args.debug,
73
72
    )
74
 
    if not client.is_jes_enabled():
75
 
        client.enable_jes()
 
73
    client.enable_jes()
76
74
    with boot_context(
77
75
            args.temp_env_name,
78
76
            client,
82
80
            args.agent_url,
83
81
            args.agent_stream,
84
82
            args.logs, args.keep_env,
85
 
            upload_tools=False,
86
 
            region=args.region,
 
83
            False,
 
84
            permanent=True,
87
85
            ):
88
 
        yield client, charm_series, base_env
 
86
        if args.machine is not None:
 
87
            client.add_ssh_machines(args.machine)
 
88
        yield client, charm_prefix, base_env
89
89
 
90
90
 
91
91
def env_token(env_name):
93
93
 
94
94
 
95
95
@contextmanager
96
 
def hosted_environment(system_client, log_dir, suffix):
 
96
def hosted_environment(system_client, suffix):
97
97
    client = make_hosted_env_client(system_client, suffix)
98
98
    try:
99
99
        with NamedTemporaryFile() as config_file:
100
100
            config = make_safe_config(client)
101
101
            yaml.dump(config, config_file)
102
102
            config_file.flush()
103
 
            client.create_environment(system_client, config_file.name)
 
103
            client.juju(
 
104
                "system create-environment", (
 
105
                    '-s', system_client.env.environment,
 
106
                    client.env.environment, '--config', config_file.name),
 
107
                include_e=False)
104
108
        yield client
105
109
    except:
106
110
        logging.exception(
108
112
                client.env.environment))
109
113
        sys.exit(1)
110
114
    finally:
111
 
        safe_print_status(client)
112
 
        hosted_log_dir = os.path.join(log_dir, suffix)
113
 
        ensure_dir(hosted_log_dir)
114
 
        dump_env_logs(client, None, hosted_log_dir)
115
 
        client.destroy_model()
 
115
        # TODO(gz): May want to gather logs from hosted env here.
 
116
        client.destroy_environment(force=False)
116
117
 
117
118
 
118
119
def check_services(client):
119
120
    token = env_token(client.env.environment)
120
 
    client.set_config('dummy-source', {'token':  token})
 
121
    client.juju('set', ('dummy-source', 'token=%s' % token))
121
122
    print_now("checking services in " + client.env.environment)
122
123
    check_token(client, token)
123
124
 
126
127
    parser = ArgumentParser()
127
128
    add_basic_testing_arguments(parser, using_jes=True)
128
129
    args = parser.parse_args()
129
 
    with jes_setup(args) as (client, charm_series, base_env):
130
 
        test_jes_deploy(client, charm_series, args.logs, base_env)
 
130
    with jes_setup(args) as (client, charm_prefix, base_env):
 
131
        test_jes_deploy(client, charm_prefix, base_env)
131
132
 
132
133
 
133
134
if __name__ == '__main__':