1
=== modified file 'juju/charm/config.py'
2
--- juju/charm/config.py	2012-03-07 21:19:46 +0000
3
+++ juju/charm/config.py	2012-06-15 02:00:25 +0000
4
@@ -4,6 +4,7 @@
5
4
4
6
5
import yaml
5
import yaml
7
6
6
8
7
from juju.lib.format import Format2
9
7
from juju.lib.schema import (SchemaError, KeyDict, Dict, String,
8
from juju.lib.schema import (SchemaError, KeyDict, Dict, String,
10
8
                                 Constant, OneOf, Int, Float)
9
                                 Constant, OneOf, Int, Float)
11
9
from juju.charm.errors import (
10
from juju.charm.errors import (
12
@@ -138,8 +139,12 @@
13
138
        value, valid = validator(value, self._data[name])
139
        value, valid = validator(value, self._data[name])
14
139
140
15
140
        if not valid:
141
        if not valid:
16
142
            # Return value such that it roundtrips; this allows us to
17
143
            # report back the boolean false instead of the Python
18
144
            # output format, False
19
141
            raise ServiceConfigValueError(
145
            raise ServiceConfigValueError(
21
142
                "Invalid value for %s: %r" % (name, value))
146
                "Invalid value for %s: %s" % (
22
147
                    name, Format2().format(value)))
23
143
        return value
148
        return value
24
144
149
25
145
    def get_defaults(self):
150
    def get_defaults(self):
26
146
151
27
=== modified file 'juju/charm/metadata.py'
28
--- juju/charm/metadata.py	2012-02-28 01:47:53 +0000
29
+++ juju/charm/metadata.py	2012-06-15 02:00:25 +0000
30
@@ -5,20 +5,17 @@
31
5
5
32
6
from juju.charm.errors import MetaDataError
6
from juju.charm.errors import MetaDataError
33
7
from juju.errors import FileNotFound
7
from juju.errors import FileNotFound
34
8
from juju.lib.format import is_valid_charm_format
35
8
from juju.lib.schema import (
9
from juju.lib.schema import (
36
9
    SchemaError, Bool, Constant, Dict, Int,
10
    SchemaError, Bool, Constant, Dict, Int,
37
10
    KeyDict, OneOf, UnicodeOrString)
11
    KeyDict, OneOf, UnicodeOrString)
38
11
12
39
12
13
40
13
log = logging.getLogger("juju.charm")
14
log = logging.getLogger("juju.charm")
41
14
42
15
43
16
UTF8_SCHEMA = UnicodeOrString("utf-8")
15
UTF8_SCHEMA = UnicodeOrString("utf-8")
44
17
45
18
SCOPE_GLOBAL = "global"
16
SCOPE_GLOBAL = "global"
46
19
SCOPE_CONTAINER = "container"
17
SCOPE_CONTAINER = "container"
47
20
18
48
21
49
22
INTERFACE_SCHEMA = KeyDict({
19
INTERFACE_SCHEMA = KeyDict({
50
23
    "interface": UTF8_SCHEMA,
20
    "interface": UTF8_SCHEMA,
51
24
    "limit": OneOf(Constant(None), Int()),
21
    "limit": OneOf(Constant(None), Int()),
52
@@ -92,11 +89,14 @@
53
92
    "revision": Int(),
89
    "revision": Int(),
54
93
    "summary": UTF8_SCHEMA,
90
    "summary": UTF8_SCHEMA,
55
94
    "description": UTF8_SCHEMA,
91
    "description": UTF8_SCHEMA,
56
92
    "format": Int(),
57
95
    "peers": Dict(UTF8_SCHEMA, InterfaceExpander(limit=1)),
93
    "peers": Dict(UTF8_SCHEMA, InterfaceExpander(limit=1)),
58
96
    "provides": Dict(UTF8_SCHEMA, InterfaceExpander(limit=None)),
94
    "provides": Dict(UTF8_SCHEMA, InterfaceExpander(limit=None)),
59
97
    "requires": Dict(UTF8_SCHEMA, InterfaceExpander(limit=1)),
95
    "requires": Dict(UTF8_SCHEMA, InterfaceExpander(limit=1)),
60
98
    "subordinate": Bool(),
96
    "subordinate": Bool(),
62
99
    }, optional=set(["provides", "requires", "peers", "revision", "subordinate"]))
97
    }, optional=set(
63
98
        ["format", "provides", "requires", "peers", "revision",
64
99
         "subordinate"]))
65
100
100
66
101
101
67
102
class MetaData(object):
102
class MetaData(object):
68
@@ -139,6 +139,11 @@
69
139
        return self._data.get("description")
139
        return self._data.get("description")
70
140
140
71
141
    @property
141
    @property
72
142
    def format(self):
73
143
        """Optional charm format, defaults to 1"""
74
144
        return self._data.get("format", 1)
75
145
76
146
    @property
77
142
    def provides(self):
147
    def provides(self):
78
143
        """The charm provides relations."""
148
        """The charm provides relations."""
79
144
        return self._data.get("provides")
149
        return self._data.get("provides")
80
@@ -211,7 +216,8 @@
81
211
            for rel in self.provides:
216
            for rel in self.provides:
82
212
                if rel.startswith("juju-"):
217
                if rel.startswith("juju-"):
83
213
                    raise MetaDataError(
218
                    raise MetaDataError(
85
214
                        "Charm %s attempting to provide relation in implicit relation namespace: %s" %
219
                        "Charm %s attempting to provide relation in "
86
220
                        "implicit relation namespace: %s" %
87
215
                        (self.name, rel))
221
                        (self.name, rel))
88
216
                interface = self.provides[rel]["interface"]
222
                interface = self.provides[rel]["interface"]
89
217
                if interface.startswith("juju-"):
223
                if interface.startswith("juju-"):
90
@@ -230,6 +236,10 @@
91
230
                    "%s labeled subordinate but lacking scope:container `requires` relation" %
236
                    "%s labeled subordinate but lacking scope:container `requires` relation" %
92
231
                    path)
237
                    path)
93
232
238
94
239
        if not is_valid_charm_format(self.format):
95
240
            raise MetaDataError("Charm %s uses an unknown format: %s" % (
96
241
                    self.name, self.format))
97
242
98
233
    def parse_serialization_data(self, serialization_data, path=None):
243
    def parse_serialization_data(self, serialization_data, path=None):
99
234
        """Parse the unprocessed serialization data and load in this instance.
244
        """Parse the unprocessed serialization data and load in this instance.
100
235
245
101
236
246
102
=== added directory 'juju/charm/tests/repository/series/mysql-format-v2'
103
=== added file 'juju/charm/tests/repository/series/mysql-format-v2/config.yaml'
104
--- juju/charm/tests/repository/series/mysql-format-v2/config.yaml	1970-01-01 00:00:00 +0000
105
+++ juju/charm/tests/repository/series/mysql-format-v2/config.yaml	2012-06-15 02:00:25 +0000
106
@@ -0,0 +1,17 @@
107
1
options:
108
2
    query-cache-size:
109
3
        default: -1
110
4
        type: int
111
5
        description: Override the computed version from dataset-size. Still works if query-cache-type is "OFF" since sessions can override the cache type setting on their own.
112
6
    awesome:
113
7
        default: false
114
8
        type: boolean
115
9
        description: Set true to make this database engine truly awesome
116
10
    tuning-level:
117
11
        default: safest
118
12
        type: string
119
13
        description: Valid values are 'safest', 'fast', and 'unsafe'. If set to safest, all settings are tuned to have maximum safety at the cost of performance. Fast will turn off most controls, but may lose data on crashes. unsafe will turn off all protections.
120
14
    monkey-madness:
121
15
        default: 0.5
122
16
        type: float
123
17
        description: The amount of randomness to be desired in any data that is returned, from 0 (sane) to 1 (monkeys running the asylum).
124
0
18
125
=== added file 'juju/charm/tests/repository/series/mysql-format-v2/metadata.yaml'
126
--- juju/charm/tests/repository/series/mysql-format-v2/metadata.yaml	1970-01-01 00:00:00 +0000
127
+++ juju/charm/tests/repository/series/mysql-format-v2/metadata.yaml	2012-06-15 02:00:25 +0000
128
@@ -0,0 +1,6 @@
129
1
name: mysql-format-v2
130
2
summary: "Database engine"
131
3
description: "A pretty popular database"
132
4
provides:
133
5
  server: mysql
134
6
format: 2
135
0
7
136
=== added file 'juju/charm/tests/repository/series/mysql-format-v2/revision'
137
--- juju/charm/tests/repository/series/mysql-format-v2/revision	1970-01-01 00:00:00 +0000
138
+++ juju/charm/tests/repository/series/mysql-format-v2/revision	2012-06-15 02:00:25 +0000
139
@@ -0,0 +1,1 @@
140
1
1
141
0
\ No newline at end of file
2
\ No newline at end of file
142
1
3
143
=== added file 'juju/charm/tests/repository/series/mysql/config.yaml'
144
--- juju/charm/tests/repository/series/mysql/config.yaml	1970-01-01 00:00:00 +0000
145
+++ juju/charm/tests/repository/series/mysql/config.yaml	2012-06-15 02:00:25 +0000
146
@@ -0,0 +1,17 @@
147
1
options:
148
2
    query-cache-size:
149
3
        default: -1
150
4
        type: int
151
5
        description: Override the computed version from dataset-size. Still works if query-cache-type is "OFF" since sessions can override the cache type setting on their own.
152
6
    awesome:
153
7
        default: false
154
8
        type: boolean
155
9
        description: Set true to make this database engine truly awesome
156
10
    tuning-level:
157
11
        default: safest
158
12
        type: string
159
13
        description: Valid values are 'safest', 'fast', and 'unsafe'. If set to safest, all settings are tuned to have maximum safety at the cost of performance. Fast will turn off most controls, but may lose data on crashes. unsafe will turn off all protections.
160
14
    monkey-madness:
161
15
        default: 0.5
162
16
        type: float
163
17
        description: The amount of randomness to be desired in any data that is returned, from 0 (sane) to 1 (monkeys running the asylum).
164
0
18
165
=== modified file 'juju/charm/tests/repository/series/mysql/metadata.yaml'
166
--- juju/charm/tests/repository/series/mysql/metadata.yaml	2011-10-04 19:13:12 +0000
167
+++ juju/charm/tests/repository/series/mysql/metadata.yaml	2012-06-15 02:00:25 +0000
168
@@ -3,3 +3,4 @@
169
3
description: "A pretty popular database"
3
description: "A pretty popular database"
170
4
provides:
4
provides:
171
5
  server: mysql
5
  server: mysql
172
6
format: 1
173
6
7
174
=== modified file 'juju/charm/tests/test_config.py'
175
--- juju/charm/tests/test_config.py	2012-03-07 21:19:46 +0000
176
+++ juju/charm/tests/test_config.py	2012-06-15 02:00:25 +0000
177
@@ -89,7 +89,7 @@
178
89
                        "type": "string",
89
                        "type": "string",
179
90
                        "default": True}}}))
90
                        "default": True}}}))
180
91
        self.assertEqual(
91
        self.assertEqual(
182
92
            str(e), "Invalid value for foobar: True")
92
            str(e), "Invalid value for foobar: true")
183
93
93
184
94
    def test_as_dict(self):
94
    def test_as_dict(self):
185
95
        # load valid data
95
        # load valid data
186
@@ -160,7 +160,7 @@
187
160
160
188
161
        error = self.assertRaises(ServiceConfigValueError,
161
        error = self.assertRaises(ServiceConfigValueError,
189
162
                                  self.config.validate, {"title": True})
162
                                  self.config.validate, {"title": True})
191
163
        self.assertEquals(str(error), "Invalid value for title: True")
163
        self.assertEquals(str(error), "Invalid value for title: true")
192
164
164
193
165
        data = self.config.validate({"title": u"Good"})
165
        data = self.config.validate({"title": u"Good"})
194
166
        self.assertEqual(data, {"title": u"Good"})
166
        self.assertEqual(data, {"title": u"Good"})
195
@@ -184,7 +184,7 @@
196
184
184
197
185
        error = self.assertRaises(ServiceConfigValueError,
185
        error = self.assertRaises(ServiceConfigValueError,
198
186
                                  self.config.validate, {"skill-level": "NaN"})
186
                                  self.config.validate, {"skill-level": "NaN"})
200
187
        self.assertEquals(str(error), "Invalid value for skill-level: 'NaN'")
187
        self.assertEquals(str(error), "Invalid value for skill-level: NaN")
201
188
188
202
189
        data = self.config.validate({"skill-level": "9001"})
189
        data = self.config.validate({"skill-level": "9001"})
203
190
        # its over 9000!
190
        # its over 9000!
204
191
191
205
=== modified file 'juju/charm/tests/test_metadata.py'
206
--- juju/charm/tests/test_metadata.py	2012-02-28 01:47:53 +0000
207
+++ juju/charm/tests/test_metadata.py	2012-06-15 02:00:25 +0000
208
@@ -60,6 +60,7 @@
209
60
        self.assertEquals(self.metadata.summary, None)
60
        self.assertEquals(self.metadata.summary, None)
210
61
        self.assertEquals(self.metadata.description, None)
61
        self.assertEquals(self.metadata.description, None)
211
62
        self.assertEquals(self.metadata.is_subordinate, False)
62
        self.assertEquals(self.metadata.is_subordinate, False)
212
63
        self.assertEquals(self.metadata.format, 1)
213
63
64
214
64
    def test_parse_and_check_basic_info(self):
65
    def test_parse_and_check_basic_info(self):
215
65
        """
66
        """
216
@@ -238,6 +239,29 @@
217
238
            "Charm dummy attempting to provide interface in implicit namespace: juju-magic (relation: foo-rel)",
239
            "Charm dummy attempting to provide interface in implicit namespace: juju-magic (relation: foo-rel)",
218
239
            str(error))
240
            str(error))
219
240
241
220
242
    def test_format(self):
221
243
        # Defaults to 1
222
244
        self.metadata.parse(self.sample)
223
245
        self.assertEquals(self.metadata.format, 1)
224
246
225
247
        # Explicitly set to 1
226
248
        with self.change_sample() as data:
227
249
            data["format"] = 1
228
250
        self.metadata.parse(self.sample)
229
251
        self.assertEquals(self.metadata.format, 1)
230
252
231
253
        # Explicitly set to 2
232
254
        with self.change_sample() as data:
233
255
            data["format"] = 2
234
256
        self.metadata.parse(self.sample)
235
257
        self.assertEquals(self.metadata.format, 2)
236
258
237
259
        # Explicitly set to 3; however this is an unknown format for Juju
238
260
        with self.change_sample() as data:
239
261
            data["format"] = 3
240
262
        error = self.assertRaises(MetaDataError, self.metadata.parse, self.sample)
241
263
        self.assertIn("Charm dummy uses an unknown format: 3", str(error))
242
264
243
241
265
244
242
class ParseTest(TestCase):
266
class ParseTest(TestCase):
245
243
    """Test the parsing of some well-known sample files"""
267
    """Test the parsing of some well-known sample files"""
246
244
268
247
=== modified file 'juju/control/config_get.py'
248
--- juju/control/config_get.py	2012-01-30 22:20:37 +0000
249
+++ juju/control/config_get.py	2012-06-15 02:00:25 +0000
250
@@ -1,9 +1,9 @@
251
1
import argparse
1
import argparse
252
2
import yaml
253
3
2
254
4
from twisted.internet.defer import inlineCallbacks
3
from twisted.internet.defer import inlineCallbacks
255
5
4
256
6
from juju.control.utils import get_environment
5
from juju.control.utils import get_environment
257
6
from juju.lib.format import Format2
258
7
from juju.state.service import ServiceStateManager
7
from juju.state.service import ServiceStateManager
259
8
8
260
9
9
261
@@ -59,38 +59,37 @@
262
59
    """
59
    """
263
60
    provider = environment.get_machine_provider()
60
    provider = environment.get_machine_provider()
264
61
    client = yield provider.connect()
61
    client = yield provider.connect()
293
62
62
    try:
294
63
    # Get the service
63
        # Get the service
295
64
    service_manager = ServiceStateManager(client)
64
        service_manager = ServiceStateManager(client)
296
65
    service = yield service_manager.get_service_state(service_name)
65
        service = yield service_manager.get_service_state(service_name)
297
66
66
298
67
    # Retrieve schema
67
        # Retrieve schema
299
68
    charm = yield service.get_charm_state()
68
        charm = yield service.get_charm_state()
300
69
    schema = yield charm.get_config()
69
        schema = yield charm.get_config()
301
70
    schema_dict = schema.as_dict()
70
        schema_dict = schema.as_dict()
302
71
    display_dict = {"service": service.service_name,
71
        display_dict = {"service": service.service_name,
303
72
                    "charm": (yield service.get_charm_id()),
72
                        "charm": (yield service.get_charm_id()),
304
73
                    "settings": schema_dict}
73
                        "settings": schema_dict}
305
74
74
306
75
    # Get current settings
75
        # Get current settings
307
76
    settings = yield service.get_config()
76
        settings = yield service.get_config()
308
77
    settings = dict(settings.items())
77
        settings = dict(settings.items())
309
78
78
310
79
    # Merge current settings into schema/display dict
79
        # Merge current settings into schema/display dict
311
80
    for k, v in schema_dict.items():
80
        for k, v in schema_dict.items():
312
81
        # Display defaults for unset values.
81
            # Display defaults for unset values.
313
82
        if k in settings:
82
            if k in settings:
314
83
            v['value'] = settings[k]
83
                v['value'] = settings[k]
287
84
        else:
288
85
            v['value'] = "-Not set-"
289
86
290
87
        if 'default' in v:
291
88
            if v['default'] == settings[k]:
292
89
                v['default'] = True
315
90
            else:
84
            else:
322
91
                del v['default']
85
                v['value'] = "-Not set-"
323
92
86
324
93
    print yaml.safe_dump(
87
            if 'default' in v:
325
94
        display_dict,
88
                if v['default'] == settings[k]:
326
95
        indent=4, default_flow_style=False, width=80, allow_unicode=True)
89
                    v['default'] = True
327
96
    client.close()
90
                else:
328
91
                    del v['default']
329
92
330
93
        print Format2().format(display_dict)
331
94
    finally:
332
95
        yield client.close()
333
97
96
334
=== modified file 'juju/control/config_set.py'
335
--- juju/control/config_set.py	2012-04-04 13:00:13 +0000
336
+++ juju/control/config_set.py	2012-06-15 02:00:25 +0000
337
@@ -6,7 +6,7 @@
338
6
6
339
7
from juju.charm.errors import ServiceConfigValueError
7
from juju.charm.errors import ServiceConfigValueError
340
8
from juju.control.utils import get_environment
8
from juju.control.utils import get_environment
342
9
from juju.hooks.cli import parse_keyvalue_pairs
9
from juju.lib.format import get_charm_formatter
343
10
from juju.state.service import ServiceStateManager
10
from juju.state.service import ServiceStateManager
344
11
11
345
12
12
346
@@ -62,7 +62,7 @@
347
62
62
348
63
        yaml_data = options.config.read()
63
        yaml_data = options.config.read()
349
64
        try:
64
        try:
351
65
            data = yaml.load(yaml_data)
65
            data = yaml.safe_load(yaml_data)
352
66
        except yaml.YAMLError:
66
        except yaml.YAMLError:
353
67
            raise ServiceConfigValueError(
67
            raise ServiceConfigValueError(
354
68
                "Config file %r not valid YAML" % options.config.name)
68
                "Config file %r not valid YAML" % options.config.name)
355
@@ -93,6 +93,8 @@
356
93
    service_manager = ServiceStateManager(client)
93
    service_manager = ServiceStateManager(client)
357
94
    service = yield service_manager.get_service_state(service_name)
94
    service = yield service_manager.get_service_state(service_name)
358
95
    charm = yield service.get_charm_state()
95
    charm = yield service.get_charm_state()
359
96
    charm_format = (yield charm.get_metadata()).format
360
97
    formatter = get_charm_formatter(charm_format)
361
96
98
362
97
    # Use the charm's ConfigOptions instance to validate the
99
    # Use the charm's ConfigOptions instance to validate the
363
98
    # arguments to config_set. Invalid options passed to this method
100
    # arguments to config_set. Invalid options passed to this method
364
@@ -100,7 +102,7 @@
365
100
    if isinstance(service_options, dict):
102
    if isinstance(service_options, dict):
366
101
        options = service_options
103
        options = service_options
367
102
    else:
104
    else:
369
103
        options = parse_keyvalue_pairs(service_options)
105
        options = formatter.parse_keyvalue_pairs(service_options)
370
104
106
371
105
    config = yield charm.get_config()
107
    config = yield charm.get_config()
372
106
    # ignore the output of validate, we run it so it might throw an exception
108
    # ignore the output of validate, we run it so it might throw an exception
373
107
109
374
=== modified file 'juju/control/tests/test_config_set.py'
375
--- juju/control/tests/test_config_set.py	2012-03-27 22:46:44 +0000
376
+++ juju/control/tests/test_config_set.py	2012-06-15 02:00:25 +0000
377
@@ -182,3 +182,137 @@
378
182
        yield state.read()
182
        yield state.read()
379
183
        self.assertEqual(state, {"foo": "new foo",
183
        self.assertEqual(state, {"foo": "new foo",
380
184
                                 "bar": "new bar"})
184
                                 "bar": "new bar"})
381
185
382
186
    @inlineCallbacks
383
187
    def test_boolean_option_invalid_format_v1(self):
384
188
        """Verify not possible to set a boolean option with format v1"""
385
189
        self.service_state = yield self.add_service_from_charm("mysql")
386
190
        finished = self.setup_cli_reactor()
387
191
        self.setup_exit(0)
388
192
        self.mocker.replay()
389
193
        main(["set", "mysql","awesome=true"])
390
194
        yield finished
391
195
        self.assertEqual(
392
196
            self.stderr.getvalue(),
393
197
            "Invalid value for awesome: 'true'\n")
394
198
        state = yield self.service_state.get_config()
395
199
        self.assertEqual(
396
200
            state,
397
201
            {"awesome": False, "monkey-madness": 0.5,
398
202
             "query-cache-size": -1, "tuning-level": "safest"})
399
203
400
204
    @inlineCallbacks
401
205
    def test_int_option_coerced_format_v1(self):
402
206
        """Verify int feasible, but coerced internally to str in format v1"""
403
207
        self.service_state = yield self.add_service_from_charm("mysql")
404
208
        finished = self.setup_cli_reactor()
405
209
        self.setup_exit(0)
406
210
        self.mocker.replay()
407
211
        main(["set", "mysql","query-cache-size=10"])
408
212
        yield finished
409
213
        self.assertEqual(self.stderr.getvalue(), "")
410
214
        state = yield self.service_state.get_config()
411
215
        self.assertEqual(
412
216
            state,
413
217
            {"awesome": False, "monkey-madness": 0.5,
414
218
             "query-cache-size": "10", "tuning-level": "safest"})
415
219
416
220
    @inlineCallbacks
417
221
    def test_float_option_invalid_format_v1(self):
418
222
        """Verify not possible to set a float option with format v1"""
419
223
        self.service_state = yield self.add_service_from_charm("mysql")
420
224
        finished = self.setup_cli_reactor()
421
225
        self.setup_exit(0)
422
226
        self.mocker.replay()
423
227
        main(["set", "mysql","monkey-madness=0.99999999"])
424
228
        yield finished
425
229
        self.assertEqual(
426
230
            self.stderr.getvalue(),
427
231
            "Invalid value for monkey-madness: '0.99999999'\n")
428
232
        state = yield self.service_state.get_config()
429
233
        self.assertEqual(
430
234
            state,
431
235
            {"awesome": False, "monkey-madness": 0.5,
432
236
             "query-cache-size": -1, "tuning-level": "safest"})
433
237
434
238
    @inlineCallbacks
435
239
    def test_valid_options_format_v2(self):
436
240
        """Verify that config settings can be properly parsed and applied"""
437
241
        self.service_state = yield self.add_service_from_charm(
438
242
            "mysql-format-v2")
439
243
        finished = self.setup_cli_reactor()
440
244
        self.setup_exit(0)
441
245
        self.mocker.replay()
442
246
        main(["set",
443
247
              "mysql-format-v2",
444
248
              "query-cache-size=100",
445
249
              "awesome=true",
446
250
              "tuning-level=unsafe",
447
251
              "monkey-madness=0.97"])
448
252
        yield finished
449
253
        self.assertEqual(self.stderr.getvalue(), "")
450
254
        state = yield self.service_state.get_config()
451
255
        self.assertEqual(
452
256
            state,
453
257
            {"awesome": True, "monkey-madness": 0.97,
454
258
             "query-cache-size": 100, "tuning-level": "unsafe"})
455
259
456
260
    @inlineCallbacks
457
261
    def test_invalid_float_option_format_v2(self):
458
262
        """Verify that config settings reject invalid floats"""
459
263
        self.service_state = yield self.add_service_from_charm(
460
264
            "mysql-format-v2")
461
265
        finished = self.setup_cli_reactor()
462
266
        self.setup_exit(0)
463
267
        self.mocker.replay()
464
268
        main(["set", "mysql-format-v2",
465
269
              "monkey-madness='barrels of monkeys'"])
466
270
        yield finished
467
271
        self.assertEqual(
468
272
            self.stderr.getvalue(), 
469
273
            "Invalid value for monkey-madness: barrels of monkeys\n")
470
274
        state = yield self.service_state.get_config()
471
275
        self.assertEqual(
472
276
            state,
473
277
            {"awesome": False, "monkey-madness": 0.5,
474
278
             "query-cache-size": -1, "tuning-level": "safest"})
475
279
476
280
    @inlineCallbacks
477
281
    def test_invalid_int_option_format_v2(self):
478
282
        """Verify that config settings reject invalid ints"""
479
283
        self.service_state = yield self.add_service_from_charm(
480
284
            "mysql-format-v2")
481
285
        finished = self.setup_cli_reactor()
482
286
        self.setup_exit(0)
483
287
        self.mocker.replay()
484
288
        main(["set", "mysql-format-v2", "query-cache-size=big"])
485
289
        yield finished
486
290
        self.assertEqual(
487
291
            self.stderr.getvalue(), 
488
292
            "Invalid value for query-cache-size: big\n")
489
293
        state = yield self.service_state.get_config()
490
294
        self.assertEqual(
491
295
            state,
492
296
            {"awesome": False, "monkey-madness": 0.5,
493
297
             "query-cache-size": -1, "tuning-level": "safest"})
494
298
495
299
    @inlineCallbacks
496
300
    def test_invalid_string_option_format_v2(self):
497
301
        """Verify that config settings reject invalid string"""
498
302
        self.service_state = yield self.add_service_from_charm(
499
303
            "mysql-format-v2")
500
304
        finished = self.setup_cli_reactor()
501
305
        self.setup_exit(0)
502
306
        self.mocker.replay()
503
307
        # YAML does a fair amount of coercion... note that it needs to
504
308
        # be quoted if it looks like a boolean/int/string
505
309
        main(["set", "mysql-format-v2", "tuning-level=FALSE"])
506
310
        yield finished
507
311
        self.assertEqual(
508
312
            self.stderr.getvalue(), 
509
313
            "Invalid value for tuning-level: false\n")
510
314
        state = yield self.service_state.get_config()
511
315
        self.assertEqual(
512
316
            state,
513
317
            {"awesome": False, "monkey-madness": 0.5,
514
318
             "query-cache-size": -1, "tuning-level": "safest"})
515
185
319
516
=== modified file 'juju/hooks/cli.py'
517
--- juju/hooks/cli.py	2012-05-02 00:49:10 +0000
518
+++ juju/hooks/cli.py	2012-06-15 02:00:25 +0000
519
@@ -8,8 +8,9 @@
520
8
from twisted.internet import defer
8
from twisted.internet import defer
521
9
from twisted.internet import protocol
9
from twisted.internet import protocol
522
10
10
523
11
from juju.errors import JujuError
524
12
from juju.hooks.protocol import UnitAgentClient
11
from juju.hooks.protocol import UnitAgentClient
525
12
from juju.lib.format import get_charm_formatter_from_env
526
13
527
13
14
528
14
_marker = object()
15
_marker = object()
529
15
16
530
@@ -37,7 +38,6 @@
531
37
38
532
38
    `require_cid` -- Does the command require the specification of a
39
    `require_cid` -- Does the command require the specification of a
533
39
      client_id. (default: True)
40
      client_id. (default: True)
534
40
535
41
    """
41
    """
536
42
42
537
43
    default_mode = "wb"
43
    default_mode = "wb"
538
@@ -153,7 +153,8 @@
539
153
            stream=self.options.log_file)
153
            stream=self.options.log_file)
540
154
154
541
155
    def parse_kvpairs(self, options):
155
    def parse_kvpairs(self, options):
543
156
        data = parse_keyvalue_pairs(options)
156
        formatter = get_charm_formatter_from_env()
544
157
        data = formatter.parse_keyvalue_pairs(options)
545
157
        # cache
158
        # cache
546
158
        self.options.keyvalue_pairs = data
159
        self.options.keyvalue_pairs = data
547
159
        return data
160
        return data
548
@@ -226,7 +227,8 @@
549
226
227
550
227
    def format_smart(self, result, stream):
228
    def format_smart(self, result, stream):
551
228
        if result is not None:
229
        if result is not None:
553
229
            print >>stream, str(result)
230
            charm_formatter = get_charm_formatter_from_env()
554
231
            print >>stream, charm_formatter.format(result)
555
230
232
556
231
233
557
232
def parse_log_level(level):
234
def parse_log_level(level):
558
@@ -244,31 +246,6 @@
559
244
    return level
246
    return level
560
245
247
561
246
248
562
247
def parse_keyvalue_pairs(options):
563
248
    data = {}
564
249
    for kv in options:
565
250
        if "=" not in kv:
566
251
            raise JujuError(
567
252
                "Expected `option=value`. Found `%s`" % kv)
568
253
569
254
        k, v = kv.split("=", 1)
570
255
        if v.startswith("@"):
571
256
            # handle fileinput per spec
572
257
            # XXX: todo -- sanitize input
573
258
            filename = v[1:]
574
259
            try:
575
260
                with open(filename, "r") as f:
576
261
                    v = f.read()
577
262
            except IOError:
578
263
                raise JujuError(
579
264
                    "No such file or directory: %s (argument:%s)" % (
580
265
                        filename,
581
266
                        k))
582
267
        data[k] = v
583
268
584
269
    return data
585
270
586
271
587
272
def parse_port_protocol(port_protocol_string):
249
def parse_port_protocol(port_protocol_string):
588
273
    """Returns (`port`, `protocol`) by converting `port_protocol_string`.
250
    """Returns (`port`, `protocol`) by converting `port_protocol_string`.
589
274
251
590
275
252
591
=== modified file 'juju/hooks/invoker.py'
592
--- juju/hooks/invoker.py	2012-05-01 00:26:25 +0000
593
+++ juju/hooks/invoker.py	2012-06-15 02:00:25 +0000
594
@@ -148,6 +148,7 @@
595
148
        self._socket_path = socket_path
148
        self._socket_path = socket_path
596
149
        self._unit_path = unit_path
149
        self._unit_path = unit_path
597
150
        self._log = logger
150
        self._log = logger
598
151
        self._charm_format = None
599
151
152
600
152
        # The twisted.internet.process.Process instance.
153
        # The twisted.internet.process.Process instance.
601
153
        self._process = None
154
        self._process = None
602
@@ -187,6 +188,14 @@
603
187
                display_parent_relation_ident,
188
                display_parent_relation_ident,
604
188
                sorted(relation_idents)))
189
                sorted(relation_idents)))
605
189
190
606
191
        service = yield self._context.get_local_service()
607
192
        charm = yield service.get_charm_state()
608
193
        self._charm_format = (yield charm.get_metadata()).format
609
194
610
195
    @property
611
196
    def charm_format(self):
612
197
        return self._charm_format
613
198
614
190
    @property
199
    @property
615
191
    def ended(self):
200
    def ended(self):
616
192
        return self._ended
201
        return self._ended
617
@@ -205,6 +214,7 @@
618
205
        base = dict(JUJU_AGENT_SOCKET=self._socket_path,
214
        base = dict(JUJU_AGENT_SOCKET=self._socket_path,
619
206
                    JUJU_CLIENT_ID=self._client_id,
215
                    JUJU_CLIENT_ID=self._client_id,
620
207
                    CHARM_DIR=os.path.join(self._unit_path, "charm"),
216
                    CHARM_DIR=os.path.join(self._unit_path, "charm"),
621
217
                    _JUJU_CHARM_FORMAT=str(self.charm_format),
622
208
                    JUJU_UNIT_NAME=os.environ["JUJU_UNIT_NAME"],
218
                    JUJU_UNIT_NAME=os.environ["JUJU_UNIT_NAME"],
623
209
                    DEBIAN_FRONTEND="noninteractive",
219
                    DEBIAN_FRONTEND="noninteractive",
624
210
                    APT_LISTCHANGES_FRONTEND="none",
220
                    APT_LISTCHANGES_FRONTEND="none",
625
211
221
626
=== modified file 'juju/hooks/protocol.py'
627
--- juju/hooks/protocol.py	2012-04-06 20:29:41 +0000
628
+++ juju/hooks/protocol.py	2012-06-15 02:00:25 +0000
629
@@ -42,14 +42,16 @@
630
42
42
631
43
43
632
44
"""
44
"""
634
45
import json
45
635
46
import logging
46
import logging
636
47
47
637
48
from twisted.internet import defer
48
from twisted.internet import defer
638
49
from twisted.internet import protocol
49
from twisted.internet import protocol
639
50
from twisted.protocols import amp
50
from twisted.protocols import amp
640
51
import yaml
641
51
52
642
52
from juju.errors import JujuError
53
from juju.errors import JujuError
643
54
from juju.lib.format import get_charm_formatter, get_charm_formatter_from_env
644
53
from juju.state.errors import UnitRelationStateNotFound
55
from juju.state.errors import UnitRelationStateNotFound
645
54
from juju.state.hook import RelationHookContext
56
from juju.state.hook import RelationHookContext
646
55
57
647
@@ -96,14 +98,15 @@
648
96
                 ("relation_id", amp.String()),
98
                 ("relation_id", amp.String()),
649
97
                 ("unit_name", amp.String()),
99
                 ("unit_name", amp.String()),
650
98
                 ("setting_name", amp.String())]
100
                 ("setting_name", amp.String())]
652
99
    response = [("data", amp.String())]
101
    response = [("data", amp.String()),
653
102
                ("charm_format", amp.Integer())]
654
100
103
655
101
104
656
102
class RelationSetCommand(BaseCommand):
105
class RelationSetCommand(BaseCommand):
657
103
    commandName = "relation_set"
106
    commandName = "relation_set"
658
104
    arguments = [("client_id", amp.String()),
107
    arguments = [("client_id", amp.String()),
659
105
                 ("relation_id", amp.String()),
108
                 ("relation_id", amp.String()),
661
106
                 ("json_blob", amp.String())]
109
                 ("blob", amp.String())]
662
107
    response = []
110
    response = []
663
108
111
664
109
112
665
@@ -184,7 +187,8 @@
666
184
187
667
185
    @RelationGetCommand.responder
188
    @RelationGetCommand.responder
668
186
    @defer.inlineCallbacks
189
    @defer.inlineCallbacks
670
187
    def relation_get(self, client_id, relation_id, unit_name, setting_name):
190
    def relation_get(self,
671
191
                     client_id, relation_id, unit_name, setting_name):
672
188
        """Get settings from a state.hook.RelationHookContext
192
        """Get settings from a state.hook.RelationHookContext
673
189
193
674
190
        :param settings_name: optional setting_name (str) indicating that
194
        :param settings_name: optional setting_name (str) indicating that
675
@@ -192,11 +196,11 @@
676
192
196
677
193
        """
197
        """
678
194
        context = self.factory.get_context(client_id)
198
        context = self.factory.get_context(client_id)
679
199
        invoker = self.factory.get_invoker(client_id)
680
195
        if relation_id:
200
        if relation_id:
681
196
            yield self.factory.log(
201
            yield self.factory.log(
682
197
                logging.DEBUG, "Getting relation %s" % relation_id)
202
                logging.DEBUG, "Getting relation %s" % relation_id)
685
198
            context = yield self.factory.get_invoker(client_id).\
203
            context = yield invoker.get_relation_hook_context(relation_id)
684
199
                get_relation_hook_context(relation_id)
686
200
        require_relation_context(context)
204
        require_relation_context(context)
687
201
205
688
202
        try:
206
        try:
689
@@ -207,26 +211,32 @@
690
207
        except UnitRelationStateNotFound, e:
211
        except UnitRelationStateNotFound, e:
691
208
            raise NoSuchUnit(str(e))
212
            raise NoSuchUnit(str(e))
692
209
213
694
210
        defer.returnValue(dict(data=json.dumps(data)))
214
        formatter = get_charm_formatter(invoker.charm_format)
695
215
        defer.returnValue(dict(
696
216
                charm_format=invoker.charm_format,
697
217
                data=formatter.dump(data)))
698
211
218
699
212
    @RelationSetCommand.responder
219
    @RelationSetCommand.responder
700
213
    @defer.inlineCallbacks
220
    @defer.inlineCallbacks
702
214
    def relation_set(self, client_id, relation_id, json_blob):
221
    def relation_set(self, client_id, relation_id, blob):
703
215
        """Set values into state.hook.RelationHookContext.
222
        """Set values into state.hook.RelationHookContext.
704
216
223
706
217
        :param json_blob: a JSON serialized string of a dict that will
224
        :param blob: a YAML or JSON dumped string of a dict that will
707
218
        contain the delta of settings to be applied to a unit_name.
225
        contain the delta of settings to be applied to a unit_name.
708
219
        """
226
        """
709
220
        data = json.loads(json_blob)
710
221
        context = yield self.factory.get_context(client_id)
227
        context = yield self.factory.get_context(client_id)
711
228
        invoker = self.factory.get_invoker(client_id)
712
229
        formatter = get_charm_formatter(invoker.charm_format)
713
230
        data = formatter.load(blob)
714
231
715
222
        if relation_id:
232
        if relation_id:
716
223
            yield self.factory.log(
233
            yield self.factory.log(
717
224
                logging.DEBUG, "Setting relation %s" % relation_id)
234
                logging.DEBUG, "Setting relation %s" % relation_id)
720
225
            context = yield self.factory.get_invoker(client_id).\
235
            context = yield invoker.get_relation_hook_context(relation_id)
719
226
                get_relation_hook_context(relation_id)
721
227
        require_relation_context(context)
236
        require_relation_context(context)
722
237
723
228
        for k, v in data.items():
238
        for k, v in data.items():
725
229
            if not v.strip():
239
            if formatter.should_delete(v):
726
230
                yield context.delete_value(k)
240
                yield context.delete_value(k)
727
231
            else:
241
            else:
728
232
                yield context.set_value(k, v)
242
                yield context.set_value(k, v)
729
@@ -298,7 +308,9 @@
730
298
        else:
308
        else:
731
299
            options = dict(options)
309
            options = dict(options)
732
300
310
734
301
        defer.returnValue(dict(data=json.dumps(options)))
311
        # NOTE: no need to consider charm format for blob here, this
735
312
        # blob has always been in YAML format
736
313
        defer.returnValue(dict(data=yaml.safe_dump(options)))
737
302
314
738
303
    @OpenPortCommand.responder
315
    @OpenPortCommand.responder
739
304
    @defer.inlineCallbacks
316
    @defer.inlineCallbacks
740
@@ -380,7 +392,8 @@
741
380
                                       relation_id=relation_id,
392
                                       relation_id=relation_id,
742
381
                                       unit_name=unit_name,
393
                                       unit_name=unit_name,
743
382
                                       setting_name=setting_name)
394
                                       setting_name=setting_name)
745
383
        defer.returnValue(json.loads(result["data"]))
395
        formatter = get_charm_formatter(result["charm_format"])
746
396
        defer.returnValue(formatter.load(result["data"]))
747
384
397
748
385
    @defer.inlineCallbacks
398
    @defer.inlineCallbacks
749
386
    def relation_set(self, client_id, relation_id, data):
399
    def relation_set(self, client_id, relation_id, data):
750
@@ -389,11 +402,12 @@
751
389
        :param data: Python dict applied as a delta hook settings
402
        :param data: Python dict applied as a delta hook settings
752
390
403
753
391
        """
404
        """
755
392
        json_blob = json.dumps(data)
405
        formatter = get_charm_formatter_from_env()
756
406
        blob = formatter.dump(data)
757
393
        yield self.callRemote(RelationSetCommand,
407
        yield self.callRemote(RelationSetCommand,
758
394
                              client_id=client_id,
408
                              client_id=client_id,
759
395
                              relation_id=relation_id,
409
                              relation_id=relation_id,
761
396
                              json_blob=json_blob)
410
                              blob=blob)
762
397
        defer.returnValue(None)
411
        defer.returnValue(None)
763
398
412
764
399
    @defer.inlineCallbacks
413
    @defer.inlineCallbacks
765
@@ -429,7 +443,7 @@
766
429
                                       client_id=client_id,
443
                                       client_id=client_id,
767
430
                                       option_name=option_name)
444
                                       option_name=option_name)
768
431
        # Unbundle and deserialize
445
        # Unbundle and deserialize
770
432
        result = json.loads(result["data"])
446
        result = yaml.safe_load(result["data"])
771
433
        defer.returnValue(result)
447
        defer.returnValue(result)
772
434
448
773
435
    @defer.inlineCallbacks
449
    @defer.inlineCallbacks
774
436
450
775
=== modified file 'juju/hooks/tests/test_cli.py'
776
--- juju/hooks/tests/test_cli.py	2012-03-27 01:04:50 +0000
777
+++ juju/hooks/tests/test_cli.py	2012-06-15 02:00:25 +0000
778
@@ -1,15 +1,17 @@
779
1
# -*- encoding: utf-8 -*-
780
2
781
1
import json
3
import json
782
2
import logging
4
import logging
783
3
import os
5
import os
784
4
import StringIO
6
import StringIO
785
5
from argparse import ArgumentTypeError
7
from argparse import ArgumentTypeError
786
8
from contextlib import closing
787
6
9
788
7
from twisted.internet.defer import inlineCallbacks, returnValue
10
from twisted.internet.defer import inlineCallbacks, returnValue
789
11
import yaml
790
8
12
791
9
from juju.errors import JujuError
792
10
from juju.hooks.cli import (
13
from juju.hooks.cli import (
795
11
    CommandLineClient, parse_keyvalue_pairs, parse_log_level,
14
    CommandLineClient, parse_log_level, parse_port_protocol)
794
12
    parse_port_protocol)
796
13
from juju.lib.testing import TestCase
15
from juju.lib.testing import TestCase
797
14
16
798
15
17
799
@@ -322,30 +324,6 @@
800
322
        self.assertEquals(parse_log_level(logging.INFO), logging.INFO)
324
        self.assertEquals(parse_log_level(logging.INFO), logging.INFO)
801
323
        self.assertEquals(parse_log_level(logging.ERROR), logging.ERROR)
325
        self.assertEquals(parse_log_level(logging.ERROR), logging.ERROR)
802
324
326
803
325
    def test_parse_keyvalue_pairs(self):
804
326
        sample = self.makeFile("INPUT DATA")
805
327
806
328
        # test various styles of options being read
807
329
        options = ["alpha=beta",
808
330
                   "content=@%s" % sample]
809
331
810
332
        data = parse_keyvalue_pairs(options)
811
333
        self.assertEquals(data["alpha"], "beta")
812
334
        self.assertEquals(data["content"], "INPUT DATA")
813
335
814
336
        # and check an error condition
815
337
        options = ["content=@missing"]
816
338
        error = self.assertRaises(JujuError, parse_keyvalue_pairs, options)
817
339
        self.assertEquals(
818
340
            str(error),
819
341
            "No such file or directory: missing (argument:content)")
820
342
821
343
        # and check when fed non-kvpairs the error makes sense
822
344
        options = ["foobar"]
823
345
        error = self.assertRaises(JujuError, parse_keyvalue_pairs, options)
824
346
        self.assertEquals(
825
347
            str(error), "Expected `option=value`. Found `foobar`")
826
348
827
349
    def test_parse_port_protocol(self):
327
    def test_parse_port_protocol(self):
828
350
        self.assertEqual(parse_port_protocol("80"), (80, "tcp"))
328
        self.assertEqual(parse_port_protocol("80"), (80, "tcp"))
829
351
        self.assertEqual(parse_port_protocol("443/tcp"), (443, "tcp"))
329
        self.assertEqual(parse_port_protocol("443/tcp"), (443, "tcp"))
830
@@ -388,33 +366,96 @@
831
388
            "Invalid protocol, must be 'tcp' or 'udp', "
366
            "Invalid protocol, must be 'tcp' or 'udp', "
832
389
            "got 'not-a-valid-protocol'")
367
            "got 'not-a-valid-protocol'")
833
390
368
864
391
    def test_format_smart(self):
369
    def assert_smart_output_v1(self, sample, formatted=object()):
865
392
        cli = CommandLineClient()
370
        """Verifies output serialization"""
866
393
371
        # No roundtripping is verified because str(obj) is in general
867
394
        output = StringIO.StringIO()
372
        # not roundtrippable
868
395
        cli.format_smart(str('Basic string'), output)
373
        cli = CommandLineClient()
869
396
        self.assertEqual(output.getvalue(), "Basic string\n")
374
        with closing(StringIO.StringIO()) as output:
870
397
        output.close()
375
            cli.format_smart(sample, output)
871
398
376
            self.assertEqual(output.getvalue(), formatted)
872
399
        output = StringIO.StringIO()
377
873
400
        cli.format_smart(float(1.0), output)
378
    def assert_format_smart_v1(self):
874
401
        self.assertEqual(output.getvalue(), "1.0\n")
379
        """Verifies legacy smart format v1 which uses Python str encoding"""
875
402
        output.close()
380
        self.assert_smart_output_v1(None, "")  # No \n in output for None
876
403
381
        self.assert_smart_output_v1("", "\n")
877
404
        output = StringIO.StringIO()
382
        self.assert_smart_output_v1("A string", "A string\n")
878
405
        cli.format_smart(int(1), output)
383
        self.assert_smart_output_v1(
879
406
        self.assertEqual(output.getvalue(), "1\n")
384
            "High bytes: \xca\xfe", "High bytes: \xca\xfe\n")
880
407
        output.close()
385
        self.assert_smart_output_v1(u"", "\n")
881
408
386
        self.assert_smart_output_v1(
882
409
        # LP bug # 900517 - smart format renders int(0) as an empty
387
            u"A unicode string (but really ascii)",
883
410
        # string
388
            "A unicode string (but really ascii)\n")
884
411
        output = StringIO.StringIO()
389
        # Maintain LP bug #901495, fixed in v2 format; this happens because
885
412
        cli.format_smart(int(0), output)
390
        # str(obj) is used
886
413
        self.assertEqual(output.getvalue(), "0\n")
391
        e = self.assertRaises(
887
414
        output.close()
392
            UnicodeEncodeError,
888
415
393
            self.assert_smart_output_v1, u"中文")
889
416
        # None does not even print the \n
394
        self.assertEqual(
890
417
        output = StringIO.StringIO()
395
            str(e),
891
418
        cli.format_smart(None, output)
396
            ("'ascii' codec can't encode characters in position 0-1: "
892
419
        self.assertEqual(output.getvalue(), "")
397
             "ordinal not in range(128)"))
893
420
        output.close()
398
        self.assert_smart_output_v1({}, "{}\n")
894
399
        self.assert_smart_output_v1(
895
400
            {u"public-address": u"ec2-1-2-3-4.compute-1.amazonaws.com"},
896
401
            "{u'public-address': u'ec2-1-2-3-4.compute-1.amazonaws.com'}\n")
897
402
        self.assert_smart_output_v1(False, "False\n")
898
403
        self.assert_smart_output_v1(True, "True\n")
899
404
        self.assert_smart_output_v1(0.0, "0.0\n")
900
405
        self.assert_smart_output_v1(3.14159, "3.14159\n")
901
406
        self.assert_smart_output_v1(6.02214178e23, "6.02214178e+23\n")
902
407
        self.assert_smart_output_v1(0, "0\n")
903
408
        self.assert_smart_output_v1(42, "42\n")
904
409
905
410
    def test_format_smart_v1_implied(self):
906
411
        """Smart format v1 is implied if _JUJU_CHARM_FORMAT is not defined"""
907
412
        # Double check env setup
908
413
        self.assertNotIn("_JUJU_CHARM_FORMAT", os.environ)
909
414
        self.assert_format_smart_v1()
910
415
911
416
    def test_format_smart_v1(self):
912
417
        """Verify legacy format v1 works"""
913
418
        self.change_environment(_JUJU_CHARM_FORMAT="1")
914
419
        self.assert_format_smart_v1()
915
420
916
421
    def assert_smart_output(self, sample, formatted):
917
422
        cli = CommandLineClient()
918
423
        with closing(StringIO.StringIO()) as output:
919
424
            cli.format_smart(sample, output)
920
425
            self.assertEqual(output.getvalue(), formatted)
921
426
            self.assertEqual(sample, yaml.safe_load(output.getvalue()))
922
427
923
428
    def test_format_smart_v2(self):
924
429
        """Verifies smart format v2 writes correct YAML"""
925
430
        self.change_environment(_JUJU_CHARM_FORMAT="2")
926
431
927
432
        # For each case, verify actual output serialization along with
928
433
        # roundtripping through YAML
929
434
        self.assert_smart_output(None, "")  # No newline in output for None
930
435
        self.assert_smart_output("", "''\n")
931
436
        self.assert_smart_output("A string", "A string\n")
932
437
        # Note: YAML uses b64 encoding for byte strings tagged by !!binary
933
438
        self.assert_smart_output(
934
439
            "High bytes: \xCA\xFE",
935
440
            "!!binary |\n    SGlnaCBieXRlczogyv4=\n")
936
441
        self.assert_smart_output(u"", "''\n")
937
442
        self.assert_smart_output(
938
443
            u"A unicode string (but really ascii)",
939
444
            "A unicode string (but really ascii)\n")
940
445
        # Any non-ascii Unicode will use UTF-8 encoding
941
446
        self.assert_smart_output(u"中文", "\xe4\xb8\xad\xe6\x96\x87\n")
942
447
        self.assert_smart_output({}, "{}\n")
943
448
        self.assert_smart_output(
944
449
            {u"public-address": u"ec2-1-2-3-4.compute-1.amazonaws.com",
945
450
             u"foo": u"bar",
946
451
             u"configured": True},
947
452
            ("configured: true\n"
948
453
             "foo: bar\n"
949
454
             "public-address: ec2-1-2-3-4.compute-1.amazonaws.com\n"))
950
455
        self.assert_smart_output(False, "false\n")
951
456
        self.assert_smart_output(True, "true\n")
952
457
        self.assert_smart_output(0.0, "0.0\n")
953
458
        self.assert_smart_output(3.14159, "3.14159\n")
954
459
        self.assert_smart_output(6.02214178e23, "6.02214178e+23\n")
955
460
        self.assert_smart_output(0, "0\n")
956
461
        self.assert_smart_output(42, "42\n")
957
421
462
958
=== modified file 'juju/hooks/tests/test_communications.py'
959
--- juju/hooks/tests/test_communications.py	2012-04-06 20:29:41 +0000
960
+++ juju/hooks/tests/test_communications.py	2012-06-15 02:00:25 +0000
961
@@ -76,6 +76,12 @@
962
76
        return MockServiceUnitState
76
        return MockServiceUnitState
963
77
77
964
78
78
965
79
class MockInvoker(object):
966
80
967
81
    def __init__(self, charm_format):
968
82
        self.charm_format = charm_format
969
83
970
84
971
79
class UnitSettingsFactoryLocal(UnitSettingsFactory):
85
class UnitSettingsFactoryLocal(UnitSettingsFactory):
972
80
    """
86
    """
973
81
    For testing a UnitSettingsFactory with local storage. Loosely
87
    For testing a UnitSettingsFactory with local storage. Loosely
974
@@ -91,6 +97,7 @@
975
91
        self.members = []
97
        self.members = []
976
92
        self.relation_idents = []
98
        self.relation_idents = []
977
93
        self._agent_io = StringIO()
99
        self._agent_io = StringIO()
978
100
        self._invoker = MockInvoker(charm_format=1)
979
94
101
980
95
        # hook context and a logger to the settings factory
102
        # hook context and a logger to the settings factory
981
96
        logger = logging.getLogger("unit-settings-fact-test")
103
        logger = logging.getLogger("unit-settings-fact-test")
982
@@ -104,7 +111,7 @@
983
104
        return self
111
        return self
984
105
112
985
106
    def invoker(self, client_id):
113
    def invoker(self, client_id):
987
107
        return "mock invoker"
114
        return self._invoker
988
108
115
989
109
    def get_value(self, unit_name, setting_name):
116
    def get_value(self, unit_name, setting_name):
990
110
        return self.data[unit_name][setting_name]
117
        return self.data[unit_name][setting_name]
991
@@ -310,7 +317,7 @@
992
310
        error = MustSpecifyRelationName()
317
        error = MustSpecifyRelationName()
993
311
        self.assertTrue(isinstance(error, JujuError))
318
        self.assertTrue(isinstance(error, JujuError))
994
312
        self.assertEquals(
319
        self.assertEquals(
996
313
            str(error), 
320
            str(error),
997
314
            "Relation name must be specified")
321
            "Relation name must be specified")
998
315
322
999
316
    @defer.inlineCallbacks
323
    @defer.inlineCallbacks
1000
317
324
1001
=== modified file 'juju/hooks/tests/test_invoker.py'
1002
--- juju/hooks/tests/test_invoker.py	2012-05-04 03:36:36 +0000
1003
+++ juju/hooks/tests/test_invoker.py	2012-06-15 02:00:25 +0000
1004
@@ -1,3 +1,5 @@
1005
1
# -*- encoding: utf-8 -*-
1006
2
1007
1
from StringIO import StringIO
3
from StringIO import StringIO
1008
2
import json
4
import json
1009
3
import logging
5
import logging
1010
@@ -471,6 +473,7 @@
1011
471
473
1012
472
class InvokerTest(RelationInvokerTestBase):
474
class InvokerTest(RelationInvokerTestBase):
1013
473
475
1014
476
    @defer.inlineCallbacks
1015
474
    def test_environment(self):
477
    def test_environment(self):
1016
475
        """Test various way to manipulate the calling environment.
478
        """Test various way to manipulate the calling environment.
1017
476
        """
479
        """
1018
@@ -494,11 +497,18 @@
1019
494
        self.assertEqual(env["DEBIAN_FRONTEND"], "noninteractive")
497
        self.assertEqual(env["DEBIAN_FRONTEND"], "noninteractive")
1020
495
        self.assertEqual(env["APT_LISTCHANGES_FRONTEND"], "none")
498
        self.assertEqual(env["APT_LISTCHANGES_FRONTEND"], "none")
1021
496
499
1022
500
        # Specific to the charm that is running, in this case it's the
1023
501
        # dummy charm (this is the default charm used when the
1024
502
        # add_service method is use)
1025
503
        self.assertEqual(env["_JUJU_CHARM_FORMAT"], "1")
1026
504
1027
505
    @defer.inlineCallbacks
1028
497
    def test_missing_hook(self):
506
    def test_missing_hook(self):
1029
498
        exe = yield self.ua.get_invoker(
507
        exe = yield self.ua.get_invoker(
1030
499
            "database:42", "add", "mysql/0", self.relation)
508
            "database:42", "add", "mysql/0", self.relation)
1031
500
        self.failUnlessRaises(errors.FileNotFound, exe, "hook-missing")
509
        self.failUnlessRaises(errors.FileNotFound, exe, "hook-missing")
1032
501
510
1033
511
    @defer.inlineCallbacks
1034
502
    def test_noexec_hook(self):
512
    def test_noexec_hook(self):
1035
503
        exe = yield self.ua.get_invoker(
513
        exe = yield self.ua.get_invoker(
1036
504
            "database:42", "add", "mysql/0", self.relation)
514
            "database:42", "add", "mysql/0", self.relation)
1037
@@ -1080,10 +1090,10 @@
1038
1080
                u"b": u"xyz",
1090
                u"b": u"xyz",
1039
1081
                "private-address": "mysql-0.example.com"})
1091
                "private-address": "mysql-0.example.com"})
1040
1082
        yield self.assert_zk_data(db1, {
1092
        yield self.assert_zk_data(db1, {
1042
1083
                u"c": u"21",
1093
                u"c": "21",
1043
1084
                "private-address": "mysql-0.example.com"})
1094
                "private-address": "mysql-0.example.com"})
1044
1085
        yield self.assert_zk_data(db2, {
1095
        yield self.assert_zk_data(db2, {
1046
1086
                u"d": u"99",
1096
                u"d": "99",
1047
1087
                "private-address": "mysql-0.example.com"})
1097
                "private-address": "mysql-0.example.com"})
1048
1088
        self.assertLogLines(
1098
        self.assertLogLines(
1049
1089
            self.log.getvalue(),
1099
            self.log.getvalue(),
1050
@@ -1502,3 +1512,166 @@
1051
1502
        self.assertIn("mysql/1", self.log.getvalue())
1512
        self.assertIn("mysql/1", self.log.getvalue())
1052
1503
        # we don't see units in the other container
1513
        # we don't see units in the other container
1053
1504
        self.assertNotIn("mysql/0", self.log.getvalue())
1514
        self.assertNotIn("mysql/0", self.log.getvalue())
1054
1515
1055
1516
1056
1517
def capture_separate_log(name, level):
1057
1518
    """Support the separate capture of logging at different log levels.
1058
1519
1059
1520
    TestCase.capture_logging only allows one level to be captured at
1060
1521
    any given time. Given that the hook log captures both data AND
1061
1522
    traditional logging, it's useful to separate.
1062
1523
    """
1063
1524
    logger = logging.getLogger(name)
1064
1525
    output = StringIO()
1065
1526
    handler = logging.StreamHandler(output)
1066
1527
    handler.setLevel(level)
1067
1528
    logger.addHandler(handler)
1068
1529
    return output
1069
1530
1070
1531
1071
1532
class TestCharmFormatV1(RelationInvokerTestBase):
1072
1533
1073
1534
    @defer.inlineCallbacks
1074
1535
    def _default_relations(self):
1075
1536
        """Intercept mysql/wordpress setup to ensure v1 charm format"""
1076
1537
        # The mysql charm in the test repository has no format defined
1077
1538
        yield self.add_service_from_charm("mysql", charm_name="mysql")
1078
1539
        yield super(TestCharmFormatV1, self)._default_relations()
1079
1540
1080
1541
    @defer.inlineCallbacks
1081
1542
    def test_environment(self):
1082
1543
        """Ensure that an implicit setting of format: 1 works properly"""
1083
1544
        exe = yield self.ua.get_invoker(
1084
1545
            "database:42", "add", "mysql/0", self.relation)
1085
1546
        env = exe.get_environment()
1086
1547
        self.assertEqual(env["_JUJU_CHARM_FORMAT"], "1")
1087
1548
1088
1549
    @defer.inlineCallbacks
1089
1550
    def test_output(self):
1090
1551
        """Verify roundtripping"""
1091
1552
        hook_debug_log = capture_separate_log("hook", level=logging.DEBUG)
1092
1553
        hook_log = capture_separate_log("hook", level=logging.INFO)
1093
1554
        exe = yield self.ua.get_invoker(
1094
1555
            "database:42", "add", "mysql/0", self.relation,
1095
1556
            client_id="client_id")
1096
1557
        set_hook = self.create_hook(
1097
1558
            "relation-set",
1098
1559
            "b=true i=42 f=1.23 s=ascii u=中文")
1099
1560
        yield exe(set_hook)
1100
1561
        result = yield exe(self.create_hook("relation-get", "- mysql/0"))
1101
1562
        self.assertEqual(result, 0)
1102
1563
1103
1564
        # No guarantee on output ordering, so keep to this test stable,
1104
1565
        # first a little parsing work:
1105
1566
        output = hook_log.getvalue()
1106
1567
        self.assertEqual(output[0], "{")
1107
1568
        self.assertEqual(output[-3:-1], "}\n")
1108
1569
        self.assertEqual(
1109
1570
            set(output[1:-3].split(", ")),
1110
1571
            set(["u'b': u'true'",
1111
1572
                 "u'f': u'1.23'",
1112
1573
                 "u'i': u'42'",
1113
1574
                 "u'private-address': u'mysql-0.example.com'",
1114
1575
                 "u's': u'ascii'",
1115
1576
                 "u'u': u'\\u4e2d\\u6587'"]))
1116
1577
1117
1578
        self.assertLogLines(
1118
1579
            hook_debug_log.getvalue(),
1119
1580
            ["Flushed values for hook %r on 'database:42'" % (
1120
1581
                    os.path.basename(set_hook),),
1121
1582
             "    Setting changed: u'b'=u'true' (was unset)",
1122
1583
             "    Setting changed: u'f'=u'1.23' (was unset)",
1123
1584
             "    Setting changed: u'i'=u'42' (was unset)",
1124
1585
             "    Setting changed: u's'=u'ascii' (was unset)",
1125
1586
             "    Setting changed: u'u'=u'\\u4e2d\\u6587' (was unset)"])
1126
1587
1127
1588
        # Unlike v2 formatting, this will only fail on output
1128
1589
        hook_log.truncate()
1129
1590
        data_file = self.makeFile("But when I do drink, I prefer \xCA\xFE")
1130
1591
        yield exe(self.create_hook(
1131
1592
                "relation-set", "d=@%s" % data_file))
1132
1593
        result = yield exe(self.create_hook("relation-get", "d mysql/0"))
1133
1594
        self.assertIn(
1134
1595
            "Error: \'utf8\' codec can\'t decode byte 0xca in position 30: "
1135
1596
            "invalid continuation byte",
1136
1597
            hook_log.getvalue())
1137
1598
1138
1599
1139
1600
class TestCharmFormatV2(RelationInvokerTestBase):
1140
1601
1141
1602
    @defer.inlineCallbacks
1142
1603
    def _default_relations(self):
1143
1604
        """Intercept mysql/wordpress setup to ensure v2 charm format"""
1144
1605
        # The mysql-format-v2 charm defines format:2  in its metadata
1145
1606
        yield self.add_service_from_charm(
1146
1607
            "mysql", charm_name="mysql-format-v2")
1147
1608
        yield super(TestCharmFormatV2, self)._default_relations()
1148
1609
1149
1610
    @defer.inlineCallbacks
1150
1611
    def test_environment(self):
1151
1612
        """Ensure that an explicit setting of format: 2 works properly"""
1152
1613
        exe = yield self.ua.get_invoker(
1153
1614
            "database:42", "add", "mysql/0", self.relation)
1154
1615
        env = exe.get_environment()
1155
1616
        self.assertEqual(env["_JUJU_CHARM_FORMAT"], "2")
1156
1617
1157
1618
    @defer.inlineCallbacks
1158
1619
    def test_output(self):
1159
1620
        """Verify roundtripping"""
1160
1621
        hook_debug_log = capture_separate_log("hook", level=logging.DEBUG)
1161
1622
        hook_log = capture_separate_log("hook", level=logging.INFO)
1162
1623
        exe = yield self.ua.get_invoker(
1163
1624
            "database:42", "add", "mysql/0", self.relation,
1164
1625
            client_id="client_id")
1165
1626
1166
1627
        # Byte strings are also supported by staying completely in
1167
1628
        # YAML, so test that corner case. This also means users need
1168
1629
        # to present valid YAML for any input:
1169
1630
        data_file = self.makeFile(
1170
1631
            yaml.safe_dump("But when I do drink, I prefer \xCA\xFE"))
1171
1632
        set_hook = self.create_hook(
1172
1633
            "relation-set",
1173
1634
            "b=true i=42 f=1.23 s=ascii u=中文 d=@%s" % data_file)
1174
1635
        yield exe(set_hook)
1175
1636
        result = yield exe(self.create_hook("relation-get", "- mysql/0"))
1176
1637
        self.assertEqual(result, 0)
1177
1638
1178
1639
        # YAML guarantees that the keys will be sorted
1179
1640
        # lexicographically; note that we output UTF-8 for Unicode
1180
1641
        # when dumping YAML, so our source text (with this test file
1181
1642
        # in UTF-8 itself) matches the output text, as seen in the
1182
1643
        # characters for "zhongwen" (Chinese language).
1183
1644
        self.assertEqual(
1184
1645
            hook_log.getvalue(),
1185
1646
            "b: true\n"
1186
1647
            "d: !!binary |\n    QnV0IHdoZW4gSSBkbyBkcmluaywgSSBwcmVmZXIgyv4=\n"
1187
1648
            "f: 1.23\n"
1188
1649
            "i: 42\n"
1189
1650
            "private-address: mysql-0.example.com\n"
1190
1651
            "s: ascii\n"
1191
1652
            "u: 中文\n\n")
1192
1653
1193
1654
        # Log lines are not simply converted into Unicode, as in v1 format
1194
1655
        self.assertLogLines(
1195
1656
            hook_debug_log.getvalue(),
1196
1657
            ["Flushed values for hook %r on 'database:42'" % (
1197
1658
                    os.path.basename(set_hook),),
1198
1659
             "    Setting changed: 'b'=True (was unset)",
1199
1660
             "    Setting changed: 'd'='But when I do drink, "
1200
1661
             "I prefer \\xca\\xfe' (was unset)",
1201
1662
             "    Setting changed: 'f'=1.23 (was unset)",
1202
1663
             "    Setting changed: 'i'=42 (was unset)",
1203
1664
             "    Setting changed: 's'='ascii' (was unset)",
1204
1665
             "    Setting changed: 'u'=u'\\u4e2d\\u6587' (was unset)"])
1205
1666
1206
1667
        # Also ensure that invalid YAML is rejected; unlike earlier,
1207
1668
        # this was not encoded with yaml.safe_dump
1208
1669
        data_file = self.makeFile(
1209
1670
            "But when I do drink, I prefer \xCA\xFE")
1210
1671
        hook = self.create_hook("relation-set", "d=@%s" % data_file)
1211
1672
        e = yield self.assertFailure(exe(hook), errors.CharmInvocationError)
1212
1673
        self.assertEqual(str(e), "Error processing %r: exit code 1." % hook)
1213
1674
        self.assertIn(
1214
1675
            "yaml.reader.ReaderError: \'utf8\' codec can\'t decode byte #xca: "
1215
1676
            "invalid continuation byte\n  in \"<string>\", position 30",
1216
1677
            hook_log.getvalue())
1217
1505
1678
1218
=== added file 'juju/lib/format.py'
1219
--- juju/lib/format.py	1970-01-01 00:00:00 +0000
1220
+++ juju/lib/format.py	2012-06-15 02:00:25 +0000
1221
@@ -0,0 +1,144 @@
1222
1
"""Utility functions and constants to support uniform i/o formatting."""
1223
2
1224
3
import json
1225
4
import os
1226
5
1227
6
import yaml
1228
7
1229
8
from juju.errors import JujuError
1230
9
1231
10
1232
11
class BaseFormat(object):
1233
12
    """Maintains parallel code paths for input and output formatting
1234
13
    through the subclasses Format1 (Python str formatting with JSON
1235
14
    encoding) and Format2 (YAML format).
1236
15
    """
1237
16
1238
17
    def parse_keyvalue_pairs(self, pairs):
1239
18
        """Parses key value pairs, using `_parse_value` for specific format"""
1240
19
        data = {}
1241
20
        for kv in pairs:
1242
21
            if "=" not in kv:
1243
22
                raise JujuError(
1244
23
                    "Expected `option=value`. Found `%s`" % kv)
1245
24
1246
25
            k, v = kv.split("=", 1)
1247
26
            if v.startswith("@"):
1248
27
                # Handle file input, any parsing/sanitization is done next
1249
28
                # with respect to charm format
1250
29
                filename = v[1:]
1251
30
                try:
1252
31
                    with open(filename, "r") as f:
1253
32
                        v = f.read()
1254
33
                except IOError:
1255
34
                    raise JujuError(
1256
35
                        "No such file or directory: %s (argument:%s)" % (
1257
36
                            filename,
1258
37
                            k))
1259
38
                except Exception, e:
1260
39
                    raise JujuError("Bad file %s" % e)
1261
40
1262
41
            data[k] = self._parse_value(k, v)
1263
42
1264
43
        return data
1265
44
1266
45
1267
46
class Format1(BaseFormat):
1268
47
    """Supports backwards compatibility through str and JSON encoding."""
1269
48
1270
49
    charm_format = 1
1271
50
1272
51
    def format(self, data):
1273
52
        """Formats `data` using Python str encoding"""
1274
53
        return str(data)
1275
54
1276
55
    def _parse_value(self, key, value):
1277
56
        """Interprets value as a str"""
1278
57
        return value
1279
58
1280
59
    # For the old format: 1, using JSON serialization introduces some
1281
60
    # subtle issues around Unicode conversion that then later results
1282
61
    # in bugginess. For compatibility reasons, we keep these old bugs
1283
62
    # around, by dumping and loading into JSON at appropriate points.
1284
63
1285
64
    def dump(self, data):
1286
65
        """Dumps using JSON serialization"""
1287
66
        return json.dumps(data)
1288
67
1289
68
    def load(self, data):
1290
69
        """Loads data, but also converts str to Unicode"""
1291
70
        return json.loads(data)
1292
71
1293
72
    def should_delete(self, value):
1294
73
        """Whether `value` implies corresponding key should be deleted"""
1295
74
        # In format: 1, all values are strings, but possibly with
1296
75
        # spaces. The strip reduces strings consisting only of spaces,
1297
76
        # or otherwise empty, to an empty string.
1298
77
        return not value.strip()
1299
78
1300
79
1301
80
class Format2(BaseFormat):
1302
81
    """New format that uses YAML, so no unexpected encoding issues"""
1303
82
1304
83
    charm_format = 2
1305
84
1306
85
    def format(self, data):
1307
86
        """Formats `data` in Juju's preferred YAML format"""
1308
87
        # Return value such that it roundtrips; this allows us to
1309
88
        # report back the boolean false instead of the Python
1310
89
        # output format, False
1311
90
        if data is None:
1312
91
            return ""
1313
92
        serialized = yaml.safe_dump(
1314
93
            data, indent=4, default_flow_style=False, width=80,
1315
94
            allow_unicode=True)
1316
95
        if serialized.endswith("\n...\n"):
1317
96
            # Remove explicit doc end sentinel, still valid yaml
1318
97
            serialized = serialized[0:-5]
1319
98
        # Also remove any extra \n, will still be valid yaml
1320
99
        return serialized.rstrip("\n")
1321
100
1322
101
    def _parse_value(self, key, value):
1323
102
        # Ensure roundtripping to/from yaml if format: 2; in
1324
103
        # particular this ensures that true/false work as desired
1325
104
        try:
1326
105
            return yaml.safe_load(value)
1327
106
        except Exception:
1328
107
            raise JujuError("Invalid YAML value (argument:%s)" % key)
1329
108
1330
109
    # Use the same format for dump
1331
110
    dump = format
1332
111
1333
112
    def load(self, data):
1334
113
        """Loads data safely, ensuring no Python specific type info leaks"""
1335
114
        return yaml.safe_load(data)
1336
115
1337
116
    def should_delete(self, value):
1338
117
        """Whether `value` implies corresponding key should be deleted"""
1339
118
        # In format: 2, values were already parsed by yaml.safe_load;
1340
119
        # in particular, a string consisting only of whitespace is
1341
120
        # parsed as None.
1342
121
        return value is None
1343
122
1344
123
1345
124
def is_valid_charm_format(charm_format):
1346
125
    """True if `charm_format` is a valid format"""
1347
126
    return charm_format in (Format1.charm_format, Format2.charm_format)
1348
127
1349
128
1350
129
def get_charm_formatter(charm_format):
1351
130
    """Map `charm_format` to the implementing strategy for that format"""
1352
131
    if charm_format == Format1.charm_format:
1353
132
        return Format1()
1354
133
    elif charm_format == Format2.charm_format:
1355
134
        return Format2()
1356
135
    else:
1357
136
        raise JujuError(
1358
137
            "Expected charm format to be either 1 or 2, got %s" % (
1359
138
                charm_format,))
1360
139
1361
140
1362
141
def get_charm_formatter_from_env():
1363
142
    """Return the formatter specified by $_JUJU_CHARM_FORMAT"""
1364
143
    return get_charm_formatter(int(
1365
144
            os.environ.get("_JUJU_CHARM_FORMAT", "1")))
1366
0
145
1367
=== added file 'juju/lib/tests/test_format.py'
1368
--- juju/lib/tests/test_format.py	1970-01-01 00:00:00 +0000
1369
+++ juju/lib/tests/test_format.py	2012-06-15 02:00:25 +0000
1370
@@ -0,0 +1,330 @@
1371
1
# -*- encoding: utf-8 -*-
1372
2
1373
3
import json
1374
4
1375
5
import yaml
1376
6
1377
7
from juju.errors import JujuError
1378
8
from juju.lib.testing import TestCase
1379
9
from juju.lib.format import (
1380
10
    Format1, Format2, is_valid_charm_format, get_charm_formatter,
1381
11
    get_charm_formatter_from_env)
1382
12
1383
13
1384
14
class TestFormatLookup(TestCase):
1385
15
1386
16
    def test_is_valid_charm_format(self):
1387
17
        """Verify currently valid charm formats"""
1388
18
        self.assertFalse(is_valid_charm_format(0))
1389
19
        self.assertTrue(is_valid_charm_format(1))
1390
20
        self.assertTrue(is_valid_charm_format(2))
1391
21
        self.assertFalse(is_valid_charm_format(3))
1392
22
1393
23
    def test_get_charm_formatter(self):
1394
24
        self.assertInstance(get_charm_formatter(1), Format1)
1395
25
        self.assertInstance(get_charm_formatter(2), Format2)
1396
26
        e = self.assertRaises(JujuError, get_charm_formatter, 0)
1397
27
        self.assertEqual(
1398
28
            str(e),
1399
29
            "Expected charm format to be either 1 or 2, got 0")
1400
30
1401
31
    def test_get_charm_formatter_from_env(self):
1402
32
        """Verifies _JUJU_CHARM_FORMAT can be mapped to valid formatters"""
1403
33
1404
34
        self.change_environment(_JUJU_CHARM_FORMAT="0")
1405
35
        e = self.assertRaises(JujuError, get_charm_formatter_from_env)
1406
36
        self.assertEqual(
1407
37
            str(e),
1408
38
            "Expected charm format to be either 1 or 2, got 0")
1409
39
1410
40
        self.change_environment(_JUJU_CHARM_FORMAT="1")
1411
41
        self.assertInstance(get_charm_formatter_from_env(), Format1)
1412
42
1413
43
        self.change_environment(_JUJU_CHARM_FORMAT="2")
1414
44
        self.assertInstance(get_charm_formatter_from_env(), Format2)
1415
45
1416
46
        self.change_environment(_JUJU_CHARM_FORMAT="3")
1417
47
        e = self.assertRaises(JujuError, get_charm_formatter_from_env)
1418
48
        self.assertEqual(
1419
49
            str(e),
1420
50
            "Expected charm format to be either 1 or 2, got 3")
1421
51
1422
52
1423
53
class TestFormat1(TestCase):
1424
54
1425
55
    def assert_format(self, data, expected):
1426
56
        """Verify str output serialization; no roundtripping is supported."""
1427
57
        formatted = Format1().format(data)
1428
58
        self.assertEqual(formatted, expected)
1429
59
1430
60
    def test_format(self):
1431
61
        """Verifies Python str formatting of data"""
1432
62
        self.assert_format(None, "None")
1433
63
        self.assert_format("", "")
1434
64
        self.assert_format("A string", "A string")
1435
65
        self.assert_format(
1436
66
            "High bytes: \xCA\xFE",
1437
67
            "High bytes: \xca\xfe")
1438
68
        self.assert_format(u"", "")
1439
69
        self.assert_format(
1440
70
            u"A unicode string (but really ascii)",
1441
71
            "A unicode string (but really ascii)")
1442
72
        e = self.assertRaises(UnicodeEncodeError, Format1().format, u"中文")
1443
73
        self.assertEqual(
1444
74
                str(e),
1445
75
                ("'ascii' codec can't encode characters in position 0-1: "
1446
76
                "ordinal not in range(128)"))
1447
77
        self.assert_format({}, "{}")
1448
78
        self.assert_format(
1449
79
            {u"public-address": u"ec2-1-2-3-4.compute-1.amazonaws.com",
1450
80
             u"foo": u"bar",
1451
81
             u"configured": True},
1452
82
            ("{u'public-address': u'ec2-1-2-3-4.compute-1.amazonaws.com', "
1453
83
             "u'foo': u'bar', u'configured': True}"))
1454
84
        self.assert_format(False, "False")
1455
85
        self.assert_format(True, "True")
1456
86
        self.assert_format(0.0, "0.0")
1457
87
        self.assert_format(3.14159, "3.14159")
1458
88
        self.assert_format(6.02214178e23, "6.02214178e+23")
1459
89
        self.assert_format(0, "0")
1460
90
        self.assert_format(42, "42")
1461
91
1462
92
    def test_parse_keyvalue_pairs(self):
1463
93
        """Verify reads in values as strings"""
1464
94
        sample = self.makeFile("INPUT DATA")
1465
95
1466
96
        # test various styles of options being read
1467
97
        options = ["alpha=beta",
1468
98
                   "content=@%s" % sample]
1469
99
1470
100
        formatter = Format1()
1471
101
        data = formatter.parse_keyvalue_pairs(options)
1472
102
        self.assertEquals(data["alpha"], "beta")
1473
103
        self.assertEquals(data["content"], "INPUT DATA")
1474
104
1475
105
        # and check an error condition
1476
106
        options = ["content=@missing"]
1477
107
        error = self.assertRaises(
1478
108
            JujuError, formatter.parse_keyvalue_pairs, options)
1479
109
        self.assertEquals(
1480
110
            str(error),
1481
111
            "No such file or directory: missing (argument:content)")
1482
112
1483
113
        # and check when fed non-kvpairs the error makes sense
1484
114
        options = ["foobar"]
1485
115
        error = self.assertRaises(
1486
116
            JujuError, formatter.parse_keyvalue_pairs, options)
1487
117
        self.assertEquals(
1488
118
            str(error), "Expected `option=value`. Found `foobar`")
1489
119
1490
120
    def assert_dump_load(self, data, expected):
1491
121
        """Asserts expected formatting and roundtrip through dump/load"""
1492
122
        formatter = Format1()
1493
123
        dumped = formatter.dump({"data": data})
1494
124
        loaded = formatter.load(dumped)["data"]
1495
125
        self.assertEqual(dumped, expected)
1496
126
        self.assertEqual(dumped, json.dumps({"data": data}))
1497
127
        self.assertEqual(data, loaded)
1498
128
        if isinstance(data, str):
1499
129
            # Verify promotion of str to unicode
1500
130
            self.assertInstance(loaded, unicode)
1501
131
1502
132
    def test_dump_load(self):
1503
133
        """Verify JSON roundtrip semantics"""
1504
134
        self.assert_dump_load(None, '{"data": null}')
1505
135
        self.assert_dump_load("", '{"data": ""}')
1506
136
        self.assert_dump_load("A string", '{"data": "A string"}')
1507
137
        e = self.assertRaises(
1508
138
            UnicodeDecodeError,
1509
139
            Format1().dump, "High bytes: \xCA\xFE")
1510
140
        self.assertEqual(
1511
141
            str(e), 
1512
142
            "'utf8' codec can't decode byte 0xca in position 12: "
1513
143
            "invalid continuation byte")
1514
144
        self.assert_dump_load(u"", '{"data": ""}')
1515
145
        self.assert_dump_load(
1516
146
            u"A unicode string (but really ascii)",
1517
147
            '{"data": "A unicode string (but really ascii)"}')
1518
148
        e = self.assertRaises(UnicodeEncodeError, Format1().format, u"中文")
1519
149
        self.assertEqual(
1520
150
                str(e),
1521
151
                ("'ascii' codec can't encode characters in position 0-1: "
1522
152
                "ordinal not in range(128)"))
1523
153
        self.assert_dump_load({}, '{"data": {}}')
1524
154
        self.assert_dump_load(
1525
155
            {u"public-address": u"ec2-1-2-3-4.compute-1.amazonaws.com",
1526
156
             u"foo": u"bar",
1527
157
             u"configured": True},
1528
158
            ('{"data": {"public-address": '
1529
159
             '"ec2-1-2-3-4.compute-1.amazonaws.com", "foo": "bar", '
1530
160
             '"configured": true}}'))
1531
161
        self.assert_dump_load(False, '{"data": false}')
1532
162
        self.assert_dump_load(True, '{"data": true}')
1533
163
        self.assert_dump_load(0.0, '{"data": 0.0}')
1534
164
        self.assert_dump_load(3.14159, '{"data": 3.14159}')
1535
165
        self.assert_dump_load(6.02214178e23, '{"data": 6.02214178e+23}')
1536
166
        self.assert_dump_load(0, '{"data": 0}')
1537
167
        self.assert_dump_load(42, '{"data": 42}')
1538
168
1539
169
    def test_should_delete(self):
1540
170
        """Verify empty or whitespace only strings indicate deletion"""
1541
171
        formatter = Format1()
1542
172
        self.assertFalse(formatter.should_delete("0"))
1543
173
        self.assertFalse(formatter.should_delete("something"))
1544
174
        self.assertTrue(formatter.should_delete(""))
1545
175
        self.assertTrue(formatter.should_delete("   "))
1546
176
1547
177
        # Verify that format: 1 can only work with str values
1548
178
        e = self.assertRaises(AttributeError, formatter.should_delete, 42)
1549
179
        self.assertEqual(str(e), "'int' object has no attribute 'strip'")
1550
180
        e = self.assertRaises(AttributeError, formatter.should_delete, None)
1551
181
        self.assertEqual(str(e), "'NoneType' object has no attribute 'strip'")
1552
182
1553
183
1554
184
class TestFormat2(TestCase):
1555
185
1556
186
    def assert_format(self, data, expected):
1557
187
        """Verify actual output serialization and roundtripping through YAML"""
1558
188
        formatted = Format2().format(data)
1559
189
        self.assertEqual(formatted, expected)
1560
190
        self.assertEqual(data, yaml.safe_load(formatted))
1561
191
1562
192
    def test_format(self):
1563
193
        """Verifies standard formatting of data into valid YAML"""
1564
194
        self.assert_format(None, "")
1565
195
        self.assert_format("", "''")
1566
196
        self.assert_format("A string", "A string")
1567
197
        # Note: YAML uses b64 encoding for byte strings tagged by !!binary
1568
198
        self.assert_format(
1569
199
            "High bytes: \xCA\xFE",
1570
200
            "!!binary |\n    SGlnaCBieXRlczogyv4=")
1571
201
        self.assert_format(u"", "''")
1572
202
        self.assert_format(
1573
203
            u"A unicode string (but really ascii)",
1574
204
            "A unicode string (but really ascii)")
1575
205
        # Any non-ascii Unicode will use UTF-8 encoding
1576
206
        self.assert_format(u"中文", "\xe4\xb8\xad\xe6\x96\x87")
1577
207
        self.assert_format({}, "{}")
1578
208
        self.assert_format(
1579
209
            {u"public-address": u"ec2-1-2-3-4.compute-1.amazonaws.com",
1580
210
             u"foo": u"bar",
1581
211
             u"configured": True},
1582
212
            ("configured: true\n"
1583
213
             "foo: bar\n"
1584
214
             "public-address: ec2-1-2-3-4.compute-1.amazonaws.com"))
1585
215
        self.assert_format(False, "false")
1586
216
        self.assert_format(True, "true")
1587
217
        self.assert_format(0.0, "0.0")
1588
218
        self.assert_format(3.14159, "3.14159")
1589
219
        self.assert_format(6.02214178e23, "6.02214178e+23")
1590
220
        self.assert_format(0, "0")
1591
221
        self.assert_format(42, "42")
1592
222
1593
223
    def assert_parse(self, data):
1594
224
        """Verify input parses as expected, including from a data file"""
1595
225
        formatter = Format2()
1596
226
        formatted = formatter.format(data)
1597
227
        data_file = self.makeFile(formatted)
1598
228
        kvs = ["formatted=%s" % formatted,
1599
229
               "file=@%s" % data_file]
1600
230
        parsed = formatter.parse_keyvalue_pairs(kvs)
1601
231
        self.assertEqual(parsed["formatted"], data)
1602
232
        self.assertEqual(parsed["file"], data)
1603
233
1604
234
    def test_parse_keyvalue_pairs(self):
1605
235
        """Verify key value pairs parse for a wide range of YAML inputs."""
1606
236
        formatter = Format2()
1607
237
        self.assert_parse(None)
1608
238
        self.assert_parse("")
1609
239
        self.assert_parse("A string")
1610
240
        self.assert_parse("High bytes: \xCA\xFE")
1611
241
        self.assert_parse(u"")
1612
242
        self.assert_parse(u"A unicode string (but really ascii)")
1613
243
        self.assert_parse(u"中文")
1614
244
        self.assert_parse({})
1615
245
        self.assert_parse(
1616
246
            {u"public-address": u"ec2-1-2-3-4.compute-1.amazonaws.com",
1617
247
             u"foo": u"bar",
1618
248
             u"configured": True})
1619
249
        self.assert_parse([])
1620
250
        self.assert_parse(["abc", "xyz", 42, True])
1621
251
        self.assert_parse(False)
1622
252
        self.assert_parse(True)
1623
253
        self.assert_parse(0.0)
1624
254
        self.assert_parse(3.14159)
1625
255
        self.assert_parse(6.02214178e23)
1626
256
        self.assert_parse(0)
1627
257
        self.assert_parse(42)
1628
258
1629
259
        # Raises an error if no such file
1630
260
        e = self.assertRaises(
1631
261
            JujuError,
1632
262
            formatter.parse_keyvalue_pairs, ["content=@missing"])
1633
263
        self.assertEquals(
1634
264
            str(e),
1635
265
            "No such file or directory: missing (argument:content)")
1636
266
1637
267
        # Raises an error if not of the form K=V or K=
1638
268
        e = self.assertRaises(
1639
269
            JujuError,
1640
270
            formatter.parse_keyvalue_pairs, ["foobar"])
1641
271
        self.assertEquals(
1642
272
            str(e), "Expected `option=value`. Found `foobar`")
1643
273
1644
274
        # Raises an error if the value is invalid YAML
1645
275
        e = self.assertRaises(
1646
276
            JujuError,
1647
277
            formatter.parse_keyvalue_pairs, ["content=\xCA\FE"])
1648
278
        self.assertEquals(
1649
279
            str(e),
1650
280
            "Invalid YAML value (argument:content)")
1651
281
1652
282
    def assert_dump_load(self, data, expected):
1653
283
        """Asserts expected formatting and roundtrip through dump/load"""
1654
284
        formatter = Format2()
1655
285
        dumped = formatter.dump({"data": data})
1656
286
        loaded = formatter.load(dumped)["data"]
1657
287
        self.assertEqual(dumped, expected)
1658
288
        self.assertEqual(data, loaded)
1659
289
        if isinstance(data, str):
1660
290
            # Verify that no promotion to unicode occurs for str values
1661
291
            self.assertInstance(loaded, str)
1662
292
1663
293
    def test_dump_load(self):
1664
294
        """Verify JSON roundtrip semantics"""
1665
295
        self.assert_dump_load(None, "data: null")
1666
296
        self.assert_dump_load("", "data: ''")
1667
297
        self.assert_dump_load("A string", "data: A string")
1668
298
        self.assert_dump_load("High bytes: \xCA\xFE",
1669
299
                              "data: !!binary |\n    SGlnaCBieXRlczogyv4=")
1670
300
        self.assert_dump_load(u"", "data: ''")
1671
301
        self.assert_dump_load(
1672
302
            u"A unicode string (but really ascii)",
1673
303
            "data: A unicode string (but really ascii)")
1674
304
        self.assert_dump_load(u"中文", "data: \xe4\xb8\xad\xe6\x96\x87")
1675
305
        self.assert_dump_load({}, "data: {}")
1676
306
        self.assert_dump_load(
1677
307
            {u"public-address": u"ec2-1-2-3-4.compute-1.amazonaws.com",
1678
308
             u"foo": u"bar",
1679
309
             u"configured": True},
1680
310
            ("data:\n"
1681
311
             "    configured: true\n"
1682
312
             "    foo: bar\n"
1683
313
             "    public-address: ec2-1-2-3-4.compute-1.amazonaws.com"))
1684
314
        self.assert_dump_load(False, "data: false")
1685
315
        self.assert_dump_load(True, "data: true")
1686
316
        self.assert_dump_load(0.0, "data: 0.0")
1687
317
        self.assert_dump_load(3.14159, "data: 3.14159")
1688
318
        self.assert_dump_load(6.02214178e23, "data: 6.02214178e+23")
1689
319
        self.assert_dump_load(0, "data: 0")
1690
320
        self.assert_dump_load(42, "data: 42")
1691
321
1692
322
    def test_should_delete(self):
1693
323
        """Verify only `None` values (as YAML loaded) indicate deletion"""
1694
324
        formatter = Format2()
1695
325
        self.assertFalse(formatter.should_delete("0"))
1696
326
        self.assertFalse(formatter.should_delete("something"))
1697
327
        self.assertFalse(formatter.should_delete(""))
1698
328
        self.assertFalse(formatter.should_delete("   "))
1699
329
        self.assertFalse(formatter.should_delete(0))
1700
330
        self.assertTrue(formatter.should_delete(None))
1701
0
331
1702
=== modified file 'juju/state/tests/test_relation.py'
1703
--- juju/state/tests/test_relation.py	2012-05-15 19:07:47 +0000
1704
+++ juju/state/tests/test_relation.py	2012-06-15 02:00:25 +0000
1705
@@ -12,6 +12,7 @@
1706
12
from juju.charm.directory import CharmDirectory
12
from juju.charm.directory import CharmDirectory
1707
13
from juju.charm.tests import local_charm_id
13
from juju.charm.tests import local_charm_id
1708
14
from juju.machine.tests.test_constraints import dummy_constraints
14
from juju.machine.tests.test_constraints import dummy_constraints
1709
15
from juju.charm.tests.test_metadata import test_repository_path
1710
15
from juju.charm.tests.test_repository import unbundled_repository
16
from juju.charm.tests.test_repository import unbundled_repository
1711
16
from juju.lib.pick import pick_attr
17
from juju.lib.pick import pick_attr
1712
17
from juju.state.charm import CharmStateManager
18
from juju.state.charm import CharmStateManager
1713
@@ -52,6 +53,26 @@
1714
52
        returnValue(service_state)
53
        returnValue(service_state)
1715
53
54
1716
54
    @inlineCallbacks
55
    @inlineCallbacks
1717
56
    def add_service_from_charm(
1718
57
                    self, service_name, charm_id=None, constraints=None,
1719
58
                    charm_dir=None, charm_name=None):
1720
59
        """Add a service from a charm.
1721
60
        """
1722
61
        if not charm_id and charm_dir is None:
1723
62
            charm_name = charm_name or service_name
1724
63
            charm_dir = CharmDirectory(os.path.join(
1725
64
                    test_repository_path, "series", charm_name))
1726
65
        if charm_id is None:
1727
66
            charm_state = yield self.charm_manager.add_charm_state(
1728
67
                    local_charm_id(charm_dir), charm_dir, "")
1729
68
        else:
1730
69
            charm_state = yield self.charm_manager.get_charm_state(
1731
70
                    charm_id)
1732
71
        service_state = yield self.service_manager.add_service_state(
1733
72
                service_name, charm_state, constraints or dummy_constraints)
1734
73
        returnValue(service_state)
1735
74
1736
75
    @inlineCallbacks
1737
55
    def add_relation(self, relation_type, *services):
76
    def add_relation(self, relation_type, *services):
1738
56
        """Support older tests that don't use `RelationEndpoint`s"""
77
        """Support older tests that don't use `RelationEndpoint`s"""
1739
57
        endpoints = []
78
        endpoints = []
1740
@@ -471,8 +492,9 @@
1741
471
            "logging", "juju-info", "juju-info", "client", "container")
492
            "logging", "juju-info", "juju-info", "client", "container")
1742
472
        yield self.add_service("mysql")
493
        yield self.add_service("mysql")
1743
473
        yield self.add_service("logging")
494
        yield self.add_service("logging")
1746
474
        relation_state, service_states = yield self.relation_manager.add_relation_state(
495
        relation_state, service_states = \
1747
475
            mysql_ep, logging_ep)
496
            yield self.relation_manager.add_relation_state(mysql_ep,
1748
497
                                                           logging_ep)
1749
476
498
1750
477
        # verify that the relation state instances are both marked
499
        # verify that the relation state instances are both marked
1751
478
        # with the live scope (container). This happens even though
500
        # with the live scope (container). This happens even though
1752
@@ -488,8 +510,9 @@
1753
488
            "logging", "juju-info", "juju-info", "client", "container")
510
            "logging", "juju-info", "juju-info", "client", "container")
1754
489
        yield self.add_service("mysql")
511
        yield self.add_service("mysql")
1755
490
        yield self.add_service("logging")
512
        yield self.add_service("logging")
1758
491
        relation_state, service_states = yield self.relation_manager.add_relation_state(
513
        relation_state, service_states = \
1759
492
            mysql_ep, logging_ep)
514
            yield self.relation_manager.add_relation_state(mysql_ep,
1760
515
                                                           logging_ep)
1761
493
516
1762
494
        for service_state in service_states:
517
        for service_state in service_states:
1763
495
            self.assertEqual(service_state.relation_scope, "container")
518
            self.assertEqual(service_state.relation_scope, "container")
1764
@@ -502,8 +525,9 @@
1765
502
            "logging", "juju-info", "juju-info", "client", "global")
525
            "logging", "juju-info", "juju-info", "client", "global")
1766
503
        yield self.add_service("mysql")
526
        yield self.add_service("mysql")
1767
504
        yield self.add_service("logging")
527
        yield self.add_service("logging")
1770
505
        relation_state, service_states = yield self.relation_manager.add_relation_state(
528
        relation_state, service_states = \
1771
506
            mysql_ep, logging_ep)
529
            yield self.relation_manager.add_relation_state(mysql_ep,
1772
530
                                                           logging_ep)
1773
507
531
1774
508
        for service_state in service_states:
532
        for service_state in service_states:
1775
509
            self.assertEqual(service_state.relation_scope, "container")
533
            self.assertEqual(service_state.relation_scope, "container")
1776
@@ -693,7 +717,8 @@
1777
693
        id = "relation-0000000000"
717
        id = "relation-0000000000"
1778
694
        self.assertEqual(
718
        self.assertEqual(
1779
695
            repr(self.service1_relation),
719
            repr(self.service1_relation),
1781
696
            "<ServiceRelationState name:dev-connect role:prod id:%s scope:global>" % id)
720
            "<ServiceRelationState name:dev-connect "
1782
721
            "role:prod id:%s scope:global>" % id)
1783
697
722
1784
698
    def test_property_relation_name(self):
723
    def test_property_relation_name(self):
1785
699
        """
724
        """
Reviewer	Review Type	Date Requested	Status
Juju Engineering		2012-06-05	Pending
Review via email: mp+108831@code.launchpad.net