1
=== modified file 'charm/repo.go'
2
--- charm/repo.go	2014-01-22 16:48:19 +0000
3
+++ charm/repo.go	2014-01-30 14:23:21 +0000
4
@@ -4,8 +4,6 @@
5
4
package charm
4
package charm
6
5
5
7
6
import (
6
import (
8
7
	"crypto/sha256"
9
8
	"encoding/hex"
10
9
	"encoding/json"
7
	"encoding/json"
11
10
	"fmt"
8
	"fmt"
12
11
	"io"
9
	"io"
13
@@ -299,16 +297,11 @@
14
299
// verify returns an error unless a file exists at path with a hex-encoded
297
// verify returns an error unless a file exists at path with a hex-encoded
15
300
// SHA256 matching digest.
298
// SHA256 matching digest.
16
301
func verify(path, digest string) error {
299
func verify(path, digest string) error {
18
302
	f, err := os.Open(path)
300
	hash, _, err := utils.ReadFileSHA256(path)
19
303
	if err != nil {
301
	if err != nil {
20
304
		return err
302
		return err
21
305
	}
303
	}
28
306
	defer f.Close()
304
	if hash != digest {
23
307
	h := sha256.New()
24
308
	if _, err := io.Copy(h, f); err != nil {
25
309
		return err
26
310
	}
27
311
	if hex.EncodeToString(h.Sum(nil)) != digest {
29
312
		return fmt.Errorf("bad SHA256 of %q", path)
305
		return fmt.Errorf("bad SHA256 of %q", path)
30
313
	}
306
	}
31
314
	return nil
307
	return nil
32
315
308
33
=== modified file 'charm/testing/mockstore.go'
34
--- charm/testing/mockstore.go	2014-01-28 04:58:43 +0000
35
+++ charm/testing/mockstore.go	2014-01-30 14:23:21 +0000
36
@@ -4,12 +4,12 @@
37
4
package testing
4
package testing
38
5
5
39
6
import (
6
import (
42
7
	"crypto/sha256"
7
	"bytes"
41
8
	"encoding/hex"
43
9
	"encoding/json"
8
	"encoding/json"
45
10
	"io/ioutil"
9
	"io"
46
11
	"net"
10
	"net"
47
12
	"net/http"
11
	"net/http"
48
12
	"os"
49
13
	"strconv"
13
	"strconv"
50
14
	"strings"
14
	"strings"
51
15
15
52
@@ -18,6 +18,7 @@
53
18
18
54
19
	"launchpad.net/juju-core/charm"
19
	"launchpad.net/juju-core/charm"
55
20
	"launchpad.net/juju-core/testing"
20
	"launchpad.net/juju-core/testing"
56
21
	"launchpad.net/juju-core/utils"
57
21
)
22
)
58
22
23
59
23
var logger = loggo.GetLogger("juju.charm.testing.mockstore")
24
var logger = loggo.GetLogger("juju.charm.testing.mockstore")
60
@@ -38,12 +39,14 @@
61
38
// NewMockStore creates a mock charm store containing the specified charms.
39
// NewMockStore creates a mock charm store containing the specified charms.
62
39
func NewMockStore(c *gc.C, charms map[string]int) *MockStore {
40
func NewMockStore(c *gc.C, charms map[string]int) *MockStore {
63
40
	s := &MockStore{charms: charms}
41
	s := &MockStore{charms: charms}
70
41
	bytes, err := ioutil.ReadFile(testing.Charms.BundlePath(c.MkDir(), "dummy"))
42
	f, err := os.Open(testing.Charms.BundlePath(c.MkDir(), "dummy"))
71
42
	c.Assert(err, gc.IsNil)
43
	c.Assert(err, gc.IsNil)
72
43
	s.bundleBytes = bytes
44
	defer f.Close()
73
44
	h := sha256.New()
45
	buf := &bytes.Buffer{}
74
45
	h.Write(bytes)
46
	s.bundleSha256, _, err = utils.ReadSHA256(io.TeeReader(f, buf))
75
46
	s.bundleSha256 = hex.EncodeToString(h.Sum(nil))
47
	c.Assert(err, gc.IsNil)
76
48
	s.bundleBytes = buf.Bytes()
77
49
	c.Assert(err, gc.IsNil)
78
47
	s.mux = http.NewServeMux()
50
	s.mux = http.NewServeMux()
79
48
	s.mux.HandleFunc("/charm-info", s.serveInfo)
51
	s.mux.HandleFunc("/charm-info", s.serveInfo)
80
49
	s.mux.HandleFunc("/charm-event", s.serveEvent)
52
	s.mux.HandleFunc("/charm-event", s.serveEvent)
81
50
53
82
=== modified file 'environs/sync/sync.go'
83
--- environs/sync/sync.go	2014-01-30 06:21:03 +0000
84
+++ environs/sync/sync.go	2014-01-30 14:23:21 +0000
85
@@ -5,7 +5,6 @@
86
5
5
87
6
import (
6
import (
88
7
	"bytes"
7
	"bytes"
89
8
	"crypto/sha256"
90
9
	"fmt"
8
	"fmt"
91
10
	"io"
9
	"io"
92
11
	"io/ioutil"
10
	"io/ioutil"
93
@@ -166,22 +165,17 @@
94
166
	if err != nil {
165
	if err != nil {
95
167
		return err
166
		return err
96
168
	}
167
	}
97
168
	buf := &bytes.Buffer{}
98
169
	srcFile := resp.Body
169
	srcFile := resp.Body
99
170
	defer srcFile.Close()
170
	defer srcFile.Close()
104
171
	// We have to buffer the content, because Put requires the content
171
	tool.SHA256, tool.Size, err = utils.ReadSHA256(io.TeeReader(srcFile, buf))
101
172
	// length, but Get only returns us a ReadCloser
102
173
	buf := &bytes.Buffer{}
103
174
	nBytes, err := io.Copy(buf, srcFile)
105
175
	if err != nil {
172
	if err != nil {
106
176
		return err
173
		return err
107
177
	}
174
	}
115
178
	logger.Infof("downloaded %v (%dkB), uploading", toolsName, (nBytes+512)/1024)
175
	sizeInKB := (tool.Size + 512) / 1024
116
179
	logger.Infof("download %dkB, uploading", (nBytes+512)/1024)
176
	logger.Infof("downloaded %v (%dkB), uploading", toolsName, sizeInKB)
117
180
	sha256hash := sha256.New()
177
	logger.Infof("download %dkB, uploading", sizeInKB)
118
181
	sha256hash.Write(buf.Bytes())
178
	return dest.Put(toolsName, buf, tool.Size)
112
182
	tool.SHA256 = fmt.Sprintf("%x", sha256hash.Sum(nil))
113
183
	tool.Size = nBytes
114
184
	return dest.Put(toolsName, buf, nBytes)
119
185
}
179
}
120
186
180
121
187
// UploadFunc is the type of Upload, which may be
181
// UploadFunc is the type of Upload, which may be
122
188
182
123
=== modified file 'environs/testing/storage.go'
124
--- environs/testing/storage.go	2014-01-14 06:37:55 +0000
125
+++ environs/testing/storage.go	2014-01-30 14:23:21 +0000
126
@@ -4,13 +4,16 @@
127
4
package testing
4
package testing
128
5
5
129
6
import (
6
import (
130
7
	"fmt"
131
7
	"io"
8
	"io"
132
8
9
133
9
	gc "launchpad.net/gocheck"
10
	gc "launchpad.net/gocheck"
134
10
11
135
12
	"launchpad.net/juju-core/environs"
136
11
	"launchpad.net/juju-core/environs/filestorage"
13
	"launchpad.net/juju-core/environs/filestorage"
137
12
	"launchpad.net/juju-core/environs/httpstorage"
14
	"launchpad.net/juju-core/environs/httpstorage"
138
13
	"launchpad.net/juju-core/environs/storage"
15
	"launchpad.net/juju-core/environs/storage"
139
16
	"launchpad.net/juju-core/state"
140
14
)
17
)
141
15
18
142
16
// CreateLocalTestStorage returns the listener, which needs to be closed, and
19
// CreateLocalTestStorage returns the listener, which needs to be closed, and
143
@@ -26,3 +29,17 @@
144
26
	closer = listener
29
	closer = listener
145
27
	return
30
	return
146
28
}
31
}
147
32
148
33
// GetEnvironStorage creates an Environ from the config in state and
149
34
// returns its storage interface.
150
35
func GetEnvironStorage(st *state.State) (storage.Storage, error) {
151
36
	envConfig, err := st.EnvironConfig()
152
37
	if err != nil {
153
38
		return nil, fmt.Errorf("cannot get environment config: %v", err)
154
39
	}
155
40
	env, err := environs.New(envConfig)
156
41
	if err != nil {
157
42
		return nil, fmt.Errorf("cannot access environment: %v", err)
158
43
	}
159
44
	return env.Storage(), nil
160
45
}
161
29
46
162
=== modified file 'environs/tools/testing/testing.go'
163
--- environs/tools/testing/testing.go	2014-01-30 06:21:03 +0000
164
+++ environs/tools/testing/testing.go	2014-01-30 14:23:21 +0000
165
@@ -4,9 +4,7 @@
166
4
package testing
4
package testing
167
5
5
168
6
import (
6
import (
169
7
	"crypto/sha256"
170
8
	"fmt"
7
	"fmt"
171
9
	"io"
172
10
	"io/ioutil"
8
	"io/ioutil"
173
11
	"os"
9
	"os"
174
12
	"path"
10
	"path"
175
@@ -22,6 +20,7 @@
176
22
	"launchpad.net/juju-core/environs/tools"
20
	"launchpad.net/juju-core/environs/tools"
177
23
	jc "launchpad.net/juju-core/testing/checkers"
21
	jc "launchpad.net/juju-core/testing/checkers"
178
24
	coretools "launchpad.net/juju-core/tools"
22
	coretools "launchpad.net/juju-core/tools"
179
23
	"launchpad.net/juju-core/utils"
180
25
	"launchpad.net/juju-core/utils/set"
24
	"launchpad.net/juju-core/utils/set"
181
26
	"launchpad.net/juju-core/version"
25
	"launchpad.net/juju-core/version"
182
27
)
26
)
183
@@ -70,13 +69,9 @@
184
70
	if strings.HasPrefix(path, "file://") {
69
	if strings.HasPrefix(path, "file://") {
185
71
		path = path[len("file://"):]
70
		path = path[len("file://"):]
186
72
	}
71
	}
194
73
	f, err := os.Open(path)
72
	hash, size, err := utils.ReadFileSHA256(path)
195
74
	c.Assert(err, gc.IsNil)
73
	c.Assert(err, gc.IsNil)
196
75
	defer f.Close()
74
	return size, hash
190
76
	hash := sha256.New()
191
77
	size, err := io.Copy(hash, f)
192
78
	c.Assert(err, gc.IsNil)
193
79
	return size, fmt.Sprintf("%x", hash.Sum(nil))
197
80
}
75
}
198
81
76
199
82
// ParseMetadataFromDir loads ToolsMetadata from the specified directory.
77
// ParseMetadataFromDir loads ToolsMetadata from the specified directory.
200
83
78
201
=== modified file 'juju/conn.go'
202
--- juju/conn.go	2014-01-22 22:48:54 +0000
203
+++ juju/conn.go	2014-01-30 14:23:21 +0000
204
@@ -4,11 +4,8 @@
205
4
package juju
4
package juju
206
5
5
207
6
import (
6
import (
208
7
	"crypto/sha256"
209
8
	"encoding/hex"
210
9
	stderrors "errors"
7
	stderrors "errors"
211
10
	"fmt"
8
	"fmt"
212
11
	"io"
213
12
	"io/ioutil"
9
	"io/ioutil"
214
13
	"net/url"
10
	"net/url"
215
14
	"os"
11
	"os"
216
@@ -223,12 +220,10 @@
217
223
	default:
220
	default:
218
224
		return nil, fmt.Errorf("unknown charm type %T", ch)
221
		return nil, fmt.Errorf("unknown charm type %T", ch)
219
225
	}
222
	}
222
226
	h := sha256.New()
223
	digest, size, err := utils.ReadSHA256(f)
221
227
	size, err := io.Copy(h, f)
223
228
	if err != nil {
224
	if err != nil {
224
229
		return nil, err
225
		return nil, err
225
230
	}
226
	}
226
231
	digest := hex.EncodeToString(h.Sum(nil))
227
232
	if _, err := f.Seek(0, 0); err != nil {
227
	if _, err := f.Seek(0, 0); err != nil {
228
233
		return nil, err
228
		return nil, err
229
234
	}
229
	}
230
235
230
231
=== modified file 'juju/conn_test.go'
232
--- juju/conn_test.go	2014-01-24 12:39:48 +0000
233
+++ juju/conn_test.go	2014-01-30 14:23:21 +0000
234
@@ -453,7 +453,7 @@
235
453
453
236
454
func (s *DeployLocalSuite) SetUpSuite(c *gc.C) {
454
func (s *DeployLocalSuite) SetUpSuite(c *gc.C) {
237
455
	s.JujuConnSuite.SetUpSuite(c)
455
	s.JujuConnSuite.SetUpSuite(c)
239
456
	s.repo = &charm.LocalRepository{Path: coretesting.Charms.Path}
456
	s.repo = &charm.LocalRepository{Path: coretesting.Charms.Path()}
240
457
	s.oldCacheDir, charm.CacheDir = charm.CacheDir, c.MkDir()
457
	s.oldCacheDir, charm.CacheDir = charm.CacheDir, c.MkDir()
241
458
}
458
}
242
459
459
243
460
460
244
=== modified file 'juju/testing/conn.go'
245
--- juju/testing/conn.go	2014-01-24 12:39:48 +0000
246
+++ juju/testing/conn.go	2014-01-30 14:23:21 +0000
247
@@ -280,7 +280,7 @@
248
280
	ch := testing.Charms.Dir(name)
280
	ch := testing.Charms.Dir(name)
249
281
	ident := fmt.Sprintf("%s-%d", ch.Meta().Name, ch.Revision())
281
	ident := fmt.Sprintf("%s-%d", ch.Meta().Name, ch.Revision())
250
282
	curl := charm.MustParseURL("local:quantal/" + ident)
282
	curl := charm.MustParseURL("local:quantal/" + ident)
252
283
	repo, err := charm.InferRepository(curl, testing.Charms.Path)
283
	repo, err := charm.InferRepository(curl, testing.Charms.Path())
253
284
	c.Assert(err, gc.IsNil)
284
	c.Assert(err, gc.IsNil)
254
285
	sch, err := s.Conn.PutCharm(curl, repo, false)
285
	sch, err := s.Conn.PutCharm(curl, repo, false)
255
286
	c.Assert(err, gc.IsNil)
286
	c.Assert(err, gc.IsNil)
256
287
287
257
=== modified file 'juju/testing/repo.go'
258
--- juju/testing/repo.go	2013-12-19 12:39:49 +0000
259
+++ juju/testing/repo.go	2014-01-30 14:23:21 +0000
260
@@ -1,9 +1,6 @@
261
1
package testing
1
package testing
262
2
2
263
3
import (
3
import (
264
4
	"crypto/sha256"
265
5
	"encoding/hex"
266
6
	"io/ioutil"
267
7
	"net/http"
4
	"net/http"
268
8
	"os"
5
	"os"
269
9
	"path/filepath"
6
	"path/filepath"
270
@@ -13,6 +10,7 @@
271
13
10
272
14
	"launchpad.net/juju-core/charm"
11
	"launchpad.net/juju-core/charm"
273
15
	"launchpad.net/juju-core/state"
12
	"launchpad.net/juju-core/state"
274
13
	"launchpad.net/juju-core/utils"
275
16
)
14
)
276
17
15
277
18
// RepoSuite acts as a JujuConnSuite but also sets up
16
// RepoSuite acts as a JujuConnSuite but also sets up
278
@@ -77,11 +75,8 @@
279
77
	resp, err := http.Get(url.String())
75
	resp, err := http.Get(url.String())
280
78
	c.Assert(err, gc.IsNil)
76
	c.Assert(err, gc.IsNil)
281
79
	defer resp.Body.Close()
77
	defer resp.Body.Close()
283
80
	body, err := ioutil.ReadAll(resp.Body)
78
	digest, _, err := utils.ReadSHA256(resp.Body)
284
81
	c.Assert(err, gc.IsNil)
79
	c.Assert(err, gc.IsNil)
285
82
	h := sha256.New()
286
83
	h.Write(body)
287
84
	digest := hex.EncodeToString(h.Sum(nil))
288
85
	c.Assert(ch.BundleSha256(), gc.Equals, digest)
80
	c.Assert(ch.BundleSha256(), gc.Equals, digest)
289
86
}
81
}
290
87
82
291
88
83
292
=== modified file 'state/apiserver/charms.go'
293
--- state/apiserver/charms.go	2013-12-17 09:49:11 +0000
294
+++ state/apiserver/charms.go	2014-01-30 14:23:21 +0000
295
@@ -18,8 +18,7 @@
296
18
	"strings"
18
	"strings"
297
19
19
298
20
	"launchpad.net/juju-core/charm"
20
	"launchpad.net/juju-core/charm"
301
21
	"launchpad.net/juju-core/environs"
21
	envtesting "launchpad.net/juju-core/environs/testing"
300
22
	"launchpad.net/juju-core/environs/storage"
302
23
	"launchpad.net/juju-core/names"
22
	"launchpad.net/juju-core/names"
303
24
	"launchpad.net/juju-core/state"
23
	"launchpad.net/juju-core/state"
304
25
	"launchpad.net/juju-core/state/api/params"
24
	"launchpad.net/juju-core/state/api/params"
305
@@ -199,7 +198,7 @@
306
199
	}
198
	}
307
200
199
308
201
	// Now upload to provider storage.
200
	// Now upload to provider storage.
310
202
	storage, err := getEnvironStorage(h.state)
201
	storage, err := envtesting.GetEnvironStorage(h.state)
311
203
	if err != nil {
202
	if err != nil {
312
204
		return fmt.Errorf("cannot access provider storage: %v", err)
203
		return fmt.Errorf("cannot access provider storage: %v", err)
313
205
	}
204
	}
314
@@ -223,17 +222,3 @@
315
223
	}
222
	}
316
224
	return nil
223
	return nil
317
225
}
224
}
318
226
319
227
// getEnvironStorage creates an Environ from the config in state and
320
228
// returns its storage interface.
321
229
func getEnvironStorage(st *state.State) (storage.Storage, error) {
322
230
	envConfig, err := st.EnvironConfig()
323
231
	if err != nil {
324
232
		return nil, fmt.Errorf("cannot get environment config: %v", err)
325
233
	}
326
234
	env, err := environs.New(envConfig)
327
235
	if err != nil {
328
236
		return nil, fmt.Errorf("cannot access environment: %v", err)
329
237
	}
330
238
	return env.Storage(), nil
331
239
}
332
240
225
333
=== modified file 'state/apiserver/charms_test.go'
334
--- state/apiserver/charms_test.go	2013-12-17 09:49:11 +0000
335
+++ state/apiserver/charms_test.go	2014-01-30 14:23:21 +0000
336
@@ -4,8 +4,6 @@
337
4
package apiserver_test
4
package apiserver_test
338
5
5
339
6
import (
6
import (
340
7
	"crypto/sha256"
341
8
	"encoding/hex"
342
9
	"encoding/json"
7
	"encoding/json"
343
10
	"fmt"
8
	"fmt"
344
11
	"io"
9
	"io"
345
@@ -17,10 +15,10 @@
346
17
	gc "launchpad.net/gocheck"
15
	gc "launchpad.net/gocheck"
347
18
16
348
19
	"launchpad.net/juju-core/charm"
17
	"launchpad.net/juju-core/charm"
349
18
	envtesting "launchpad.net/juju-core/environs/testing"
350
20
	jujutesting "launchpad.net/juju-core/juju/testing"
19
	jujutesting "launchpad.net/juju-core/juju/testing"
351
21
	"launchpad.net/juju-core/state"
20
	"launchpad.net/juju-core/state"
352
22
	"launchpad.net/juju-core/state/api/params"
21
	"launchpad.net/juju-core/state/api/params"
353
23
	"launchpad.net/juju-core/state/apiserver"
354
24
	coretesting "launchpad.net/juju-core/testing"
22
	coretesting "launchpad.net/juju-core/testing"
355
25
	jc "launchpad.net/juju-core/testing/checkers"
23
	jc "launchpad.net/juju-core/testing/checkers"
356
26
	"launchpad.net/juju-core/utils"
24
	"launchpad.net/juju-core/utils"
357
@@ -131,7 +129,7 @@
358
131
	c.Assert(sch.Revision(), gc.Equals, 2)
129
	c.Assert(sch.Revision(), gc.Equals, 2)
359
132
	c.Assert(sch.IsUploaded(), jc.IsTrue)
130
	c.Assert(sch.IsUploaded(), jc.IsTrue)
360
133
	// No more checks for these two here, because they
131
	// No more checks for these two here, because they
362
134
	// are verified in TestUploadRequiresSingleUploadedFile.
132
	// are verified in TestUploadRespectsLocalRevision.
363
135
	c.Assert(sch.BundleURL(), gc.Not(gc.Equals), "")
133
	c.Assert(sch.BundleURL(), gc.Not(gc.Equals), "")
364
136
	c.Assert(sch.BundleSha256(), gc.Not(gc.Equals), "")
134
	c.Assert(sch.BundleSha256(), gc.Not(gc.Equals), "")
365
137
}
135
}
366
@@ -164,16 +162,23 @@
367
164
	c.Assert(err, gc.IsNil)
162
	c.Assert(err, gc.IsNil)
368
165
163
369
166
	// Finally, verify the SHA256 and uploaded URL.
164
	// Finally, verify the SHA256 and uploaded URL.
371
167
	expectedSHA256, _, err := getSHA256(tempFile)
165
	expectedSHA256, _, err := utils.ReadSHA256(tempFile)
372
168
	c.Assert(err, gc.IsNil)
166
	c.Assert(err, gc.IsNil)
373
169
	name := charm.Quote(expectedURL.String())
167
	name := charm.Quote(expectedURL.String())
375
170
	storage, err := apiserver.GetEnvironStorage(s.State)
168
	storage, err := envtesting.GetEnvironStorage(s.State)
376
171
	c.Assert(err, gc.IsNil)
169
	c.Assert(err, gc.IsNil)
377
172
	expectedUploadURL, err := storage.URL(name)
170
	expectedUploadURL, err := storage.URL(name)
378
173
	c.Assert(err, gc.IsNil)
171
	c.Assert(err, gc.IsNil)
379
174
172
380
175
	c.Assert(sch.BundleURL().String(), gc.Equals, expectedUploadURL)
173
	c.Assert(sch.BundleURL().String(), gc.Equals, expectedUploadURL)
381
176
	c.Assert(sch.BundleSha256(), gc.Equals, expectedSHA256)
174
	c.Assert(sch.BundleSha256(), gc.Equals, expectedSHA256)
382
175
383
176
	reader, err := storage.Get(name)
384
177
	c.Assert(err, gc.IsNil)
385
178
	defer reader.Close()
386
179
	downloadedSHA256, _, err := utils.ReadSHA256(reader)
387
180
	c.Assert(err, gc.IsNil)
388
181
	c.Assert(downloadedSHA256, gc.Equals, expectedSHA256)
389
177
}
182
}
390
178
183
391
179
func (s *charmsSuite) charmsURI(c *gc.C, query string) string {
184
func (s *charmsSuite) charmsURI(c *gc.C, query string) string {
392
@@ -230,13 +235,3 @@
393
230
	}
235
	}
394
231
	c.Check(resp.StatusCode, gc.Equals, expCode)
236
	c.Check(resp.StatusCode, gc.Equals, expCode)
395
232
}
237
}
396
233
397
234
func getSHA256(source io.ReadSeeker) (string, int64, error) {
398
235
	hash := sha256.New()
399
236
	size, err := io.Copy(hash, source)
400
237
	if err != nil {
401
238
		return "", 0, err
402
239
	}
403
240
	digest := hex.EncodeToString(hash.Sum(nil))
404
241
	return digest, size, nil
405
242
}
406
243
238
407
=== modified file 'state/apiserver/client/client.go'
408
--- state/apiserver/client/client.go	2014-01-30 02:20:09 +0000
409
+++ state/apiserver/client/client.go	2014-01-30 14:23:21 +0000
410
@@ -4,10 +4,7 @@
411
4
package client
4
package client
412
5
5
413
6
import (
6
import (
414
7
	"crypto/sha256"
415
8
	"encoding/hex"
416
9
	"fmt"
7
	"fmt"
417
10
	"io"
418
11
	"net/url"
8
	"net/url"
419
12
	"os"
9
	"os"
420
13
	"strings"
10
	"strings"
421
@@ -29,6 +26,7 @@
422
29
	"launchpad.net/juju-core/state/api/params"
26
	"launchpad.net/juju-core/state/api/params"
423
30
	"launchpad.net/juju-core/state/apiserver/common"
27
	"launchpad.net/juju-core/state/apiserver/common"
424
31
	"launchpad.net/juju-core/state/statecmd"
28
	"launchpad.net/juju-core/state/statecmd"
425
29
	"launchpad.net/juju-core/utils"
426
32
)
30
)
427
33
31
428
34
var logger = loggo.GetLogger("juju.state.apiserver.client")
32
var logger = loggo.GetLogger("juju.state.apiserver.client")
429
@@ -836,9 +834,13 @@
430
836
		return fmt.Errorf("charm URL must include revision")
834
		return fmt.Errorf("charm URL must include revision")
431
837
	}
835
	}
432
838
836
435
839
	// First check the charm is not already in state.
837
	// First, check if a pending or a real charm exists in state.
436
840
	if _, err := c.api.state.Charm(charmURL); err == nil {
838
	stateCharm, err := c.api.state.PrepareStoreCharmUpload(charmURL)
437
839
	if err == nil && stateCharm.IsUploaded() {
438
840
		// Charm already in state (it was uploaded already).
439
841
		return nil
841
		return nil
440
842
	} else if err != nil {
441
843
		return err
442
842
	}
844
	}
443
843
845
444
844
	// Get the charm and its information from the store.
846
	// Get the charm and its information from the store.
445
@@ -862,12 +864,10 @@
446
862
		return fmt.Errorf("cannot read downloaded charm: %v", err)
864
		return fmt.Errorf("cannot read downloaded charm: %v", err)
447
863
	}
865
	}
448
864
	defer archive.Close()
866
	defer archive.Close()
451
865
	hash := sha256.New()
867
	bundleSHA256, size, err := utils.ReadSHA256(archive)
450
866
	size, err := io.Copy(hash, archive)
452
867
	if err != nil {
868
	if err != nil {
453
868
		return fmt.Errorf("cannot calculate SHA256 hash of charm: %v", err)
869
		return fmt.Errorf("cannot calculate SHA256 hash of charm: %v", err)
454
869
	}
870
	}
455
870
	bundleSHA256 := hex.EncodeToString(hash.Sum(nil))
456
871
	if _, err := archive.Seek(0, 0); err != nil {
871
	if _, err := archive.Seek(0, 0); err != nil {
457
872
		return fmt.Errorf("cannot rewind charm archive: %v", err)
872
		return fmt.Errorf("cannot rewind charm archive: %v", err)
458
873
	}
873
	}
459
@@ -878,12 +878,14 @@
460
878
		return fmt.Errorf("cannot access environment: %v", err)
878
		return fmt.Errorf("cannot access environment: %v", err)
461
879
	}
879
	}
462
880
	storage := env.Storage()
880
	storage := env.Storage()
465
881
	name := charm.Quote(charmURL.String())
881
	archiveName, err := CharmArchiveName(charmURL.Name, charmURL.Revision)
464
882
	err = storage.Put(name, archive, size)
466
883
	if err != nil {
882
	if err != nil {
467
883
		return fmt.Errorf("cannot generate charm archive name: %v", err)
468
884
	}
469
885
	if err := storage.Put(archiveName, archive, size); err != nil {
470
884
		return fmt.Errorf("cannot upload charm to provider storage: %v", err)
886
		return fmt.Errorf("cannot upload charm to provider storage: %v", err)
471
885
	}
887
	}
473
886
	storageURL, err := storage.URL(name)
888
	storageURL, err := storage.URL(archiveName)
474
887
	if err != nil {
889
	if err != nil {
475
888
		return fmt.Errorf("cannot get storage URL for charm: %v", err)
890
		return fmt.Errorf("cannot get storage URL for charm: %v", err)
476
889
	}
891
	}
477
@@ -892,7 +894,29 @@
478
892
		return fmt.Errorf("cannot parse storage URL: %v", err)
894
		return fmt.Errorf("cannot parse storage URL: %v", err)
479
893
	}
895
	}
480
894
896
483
895
	// Finally, add the charm to state.
897
	// Finally, update the charm data in state and mark it as no longer pending.
484
896
	_, err = c.api.state.AddCharm(downloadedCharm, charmURL, bundleURL, bundleSHA256)
898
	_, err = c.api.state.UpdateUploadedCharm(downloadedCharm, charmURL, bundleURL, bundleSHA256)
485
899
	if err == state.ErrCharmRevisionAlreadyModified ||
486
900
		state.IsCharmAlreadyUploadedError(err) {
487
901
		// This is not an error, it just signifies somebody else
488
902
		// managed to upload and update the charm in state before
489
903
		// us. This means we have to delete what we just uploaded
490
904
		// to storage.
491
905
		if err := storage.Remove(archiveName); err != nil {
492
906
			logger.Errorf("cannot remove duplicated charm from storage: %v", err)
493
907
		}
494
908
		return nil
495
909
	}
496
897
	return err
910
	return err
497
898
}
911
}
498
912
499
913
// CharmArchiveName returns a string that is suitable as a file name
500
914
// in a storage URL. It is constructed from the charm name, revision
501
915
// and a random UUID string.
502
916
func CharmArchiveName(name string, revision int) (string, error) {
503
917
	uuid, err := utils.NewUUID()
504
918
	if err != nil {
505
919
		return "", err
506
920
	}
507
921
	return charm.Quote(fmt.Sprintf("%s-%d-%s", name, revision, uuid)), nil
508
922
}
509
899
923
510
=== modified file 'state/apiserver/client/client_test.go'
511
--- state/apiserver/client/client_test.go	2014-01-30 03:30:30 +0000
512
+++ state/apiserver/client/client_test.go	2014-01-30 14:23:21 +0000
513
@@ -8,6 +8,8 @@
514
8
	"net/url"
8
	"net/url"
515
9
	"strconv"
9
	"strconv"
516
10
	"strings"
10
	"strings"
517
11
	"sync"
518
12
	"time"
519
11
13
520
12
	gc "launchpad.net/gocheck"
14
	gc "launchpad.net/gocheck"
521
13
15
522
@@ -17,8 +19,11 @@
523
17
	"launchpad.net/juju-core/constraints"
19
	"launchpad.net/juju-core/constraints"
524
18
	"launchpad.net/juju-core/environs/cloudinit"
20
	"launchpad.net/juju-core/environs/cloudinit"
525
19
	"launchpad.net/juju-core/environs/config"
21
	"launchpad.net/juju-core/environs/config"
526
22
	"launchpad.net/juju-core/environs/storage"
527
23
	envtesting "launchpad.net/juju-core/environs/testing"
528
20
	"launchpad.net/juju-core/errors"
24
	"launchpad.net/juju-core/errors"
529
21
	"launchpad.net/juju-core/instance"
25
	"launchpad.net/juju-core/instance"
530
26
	"launchpad.net/juju-core/provider/dummy"
531
22
	"launchpad.net/juju-core/state"
27
	"launchpad.net/juju-core/state"
532
23
	"launchpad.net/juju-core/state/api"
28
	"launchpad.net/juju-core/state/api"
533
24
	"launchpad.net/juju-core/state/api/params"
29
	"launchpad.net/juju-core/state/api/params"
534
@@ -26,6 +31,7 @@
535
26
	"launchpad.net/juju-core/state/statecmd"
31
	"launchpad.net/juju-core/state/statecmd"
536
27
	coretesting "launchpad.net/juju-core/testing"
32
	coretesting "launchpad.net/juju-core/testing"
537
28
	jc "launchpad.net/juju-core/testing/checkers"
33
	jc "launchpad.net/juju-core/testing/checkers"
538
34
	"launchpad.net/juju-core/utils"
539
29
	"launchpad.net/juju-core/version"
35
	"launchpad.net/juju-core/version"
540
30
)
36
)
541
31
37
542
@@ -1787,6 +1793,7 @@
543
1787
	bundleURL, err := url.Parse("http://bundles.testing.invalid/" + ident)
1793
	bundleURL, err := url.Parse("http://bundles.testing.invalid/" + ident)
544
1788
	c.Assert(err, gc.IsNil)
1794
	c.Assert(err, gc.IsNil)
545
1789
	sch, err := s.State.AddCharm(charmDir, curl, bundleURL, ident+"-sha256")
1795
	sch, err := s.State.AddCharm(charmDir, curl, bundleURL, ident+"-sha256")
546
1796
	c.Assert(err, gc.IsNil)
547
1790
1797
548
1791
	name := charm.Quote(sch.URL().String())
1798
	name := charm.Quote(sch.URL().String())
549
1792
	storage := s.Conn.Environ.Storage()
1799
	storage := s.Conn.Environ.Storage()
550
@@ -1804,20 +1811,127 @@
551
1804
	err = client.AddCharm(curl)
1811
	err = client.AddCharm(curl)
552
1805
	c.Assert(err, gc.IsNil)
1812
	c.Assert(err, gc.IsNil)
553
1806
1813
555
1807
	// Verify it's in state.
1814
	// Verify it's in state and it got uploaded.
556
1808
	sch, err = s.State.Charm(curl)
1815
	sch, err = s.State.Charm(curl)
557
1809
	c.Assert(err, gc.IsNil)
1816
	c.Assert(err, gc.IsNil)
571
1810
1817
	s.assertUploaded(c, storage, sch.BundleURL(), sch.BundleSha256())
572
1811
	name = charm.Quote(curl.String())
1818
}
573
1812
	storageURL, err := storage.URL(name)
1819
574
1813
	c.Assert(err, gc.IsNil)
1820
func (s *clientSuite) TestAddCharmConcurrently(c *gc.C) {
575
1814
1821
	store, restore := makeMockCharmStore()
576
1815
	c.Assert(sch.BundleURL().String(), gc.Equals, storageURL)
1822
	defer restore()
577
1816
	// We don't care about the exact value of the hash here, just that
1823
578
1817
	// it's set.
1824
	client := s.APIState.Client()
579
1818
	c.Assert(sch.BundleSha256(), gc.Not(gc.Equals), "")
1825
	curl, _ := addCharm(c, store, "wordpress")
580
1819
1826
581
1820
	// Verify it's added to storage.
1827
	// Expect storage Put() to be called once for each goroutine
582
1821
	_, err = storage.Get(name)
1828
	// below.
583
1822
	c.Assert(err, gc.IsNil)
1829
	ops := make(chan dummy.Operation, 500)
584
1830
	dummy.Listen(ops)
585
1831
	go s.assertPutCalled(c, ops, 10)
586
1832
587
1833
	// Try adding the same charm concurrently from multiple goroutines
588
1834
	// to test no "duplicate key errors" are reported (see lp bug
589
1835
	// #1067979) and also at the end only one charm document is
590
1836
	// created.
591
1837
592
1838
	var wg sync.WaitGroup
593
1839
	for i := 0; i < 10; i++ {
594
1840
		wg.Add(1)
595
1841
		go func(index int) {
596
1842
			defer wg.Done()
597
1843
598
1844
			c.Assert(client.AddCharm(curl), gc.IsNil, gc.Commentf("goroutine %d", index))
599
1845
			sch, err := s.State.Charm(curl)
600
1846
			c.Assert(err, gc.IsNil, gc.Commentf("goroutine %d", index))
601
1847
			c.Assert(sch.URL(), jc.DeepEquals, curl, gc.Commentf("goroutine %d", index))
602
1848
			expectedName := fmt.Sprintf("%s-%d-[0-9a-f-]+", curl.Name, curl.Revision)
603
1849
			c.Assert(getArchiveName(sch.BundleURL()), gc.Matches, expectedName)
604
1850
		}(i)
605
1851
	}
606
1852
	wg.Wait()
607
1853
	close(ops)
608
1854
609
1855
	// Verify there is only a single uploaded charm remains and it
610
1856
	// contains the correct data.
611
1857
	sch, err := s.State.Charm(curl)
612
1858
	c.Assert(err, gc.IsNil)
613
1859
	storage, err := envtesting.GetEnvironStorage(s.State)
614
1860
	c.Assert(err, gc.IsNil)
615
1861
	uploads, err := storage.List(fmt.Sprintf("%s-%d-", curl.Name, curl.Revision))
616
1862
	c.Assert(err, gc.IsNil)
617
1863
	c.Assert(uploads, gc.HasLen, 1)
618
1864
	c.Assert(getArchiveName(sch.BundleURL()), gc.Equals, uploads[0])
619
1865
	s.assertUploaded(c, storage, sch.BundleURL(), sch.BundleSha256())
620
1866
}
621
1867
622
1868
func (s *clientSuite) TestAddCharmOverwritesPlaceholders(c *gc.C) {
623
1869
	store, restore := makeMockCharmStore()
624
1870
	defer restore()
625
1871
626
1872
	client := s.APIState.Client()
627
1873
	curl, _ := addCharm(c, store, "wordpress")
628
1874
629
1875
	// Add a placeholder with the same charm URL.
630
1876
	err := s.State.AddStoreCharmPlaceholder(curl)
631
1877
	c.Assert(err, gc.IsNil)
632
1878
	_, err = s.State.Charm(curl)
633
1879
	c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
634
1880
635
1881
	// Now try to add the charm, which will convert the placeholder to
636
1882
	// a pending charm.
637
1883
	err = client.AddCharm(curl)
638
1884
	c.Assert(err, gc.IsNil)
639
1885
640
1886
	// Make sure the document's flags were reset as expected.
641
1887
	sch, err := s.State.Charm(curl)
642
1888
	c.Assert(err, gc.IsNil)
643
1889
	c.Assert(sch.URL(), jc.DeepEquals, curl)
644
1890
	c.Assert(sch.IsPlaceholder(), jc.IsFalse)
645
1891
	c.Assert(sch.IsUploaded(), jc.IsTrue)
646
1892
}
647
1893
648
1894
func (s *clientSuite) TestCharmArchiveName(c *gc.C) {
649
1895
	for rev, name := range []string{"Foo", "bar", "wordpress", "mysql"} {
650
1896
		archiveFormat := fmt.Sprintf("%s-%d-[0-9a-f-]+", name, rev)
651
1897
		archiveName, err := client.CharmArchiveName(name, rev)
652
1898
		c.Check(err, gc.IsNil)
653
1899
		c.Check(archiveName, gc.Matches, archiveFormat)
654
1900
	}
655
1901
}
656
1902
657
1903
func (s *clientSuite) assertPutCalled(c *gc.C, ops chan dummy.Operation, numCalls int) {
658
1904
	calls := 0
659
1905
	select {
660
1906
	case op, ok := <-ops:
661
1907
		if !ok {
662
1908
			return
663
1909
		}
664
1910
		if op, ok := op.(dummy.OpPutFile); ok {
665
1911
			calls++
666
1912
			if calls > numCalls {
667
1913
				c.Fatalf("storage Put() called %d times, expected %d times", calls, numCalls)
668
1914
				return
669
1915
			}
670
1916
			nameFormat := "[0-9a-z-]+-[0-9]+-[0-9a-f-]+"
671
1917
			c.Assert(op.FileName, gc.Matches, nameFormat)
672
1918
		}
673
1919
	case <-time.After(coretesting.LongWait):
674
1920
		c.Fatalf("timed out while waiting for a storage Put() calls")
675
1921
		return
676
1922
	}
677
1923
}
678
1924
679
1925
func (s *clientSuite) assertUploaded(c *gc.C, storage storage.Storage, bundleURL *url.URL, expectedSHA256 string) {
680
1926
	archiveName := getArchiveName(bundleURL)
681
1927
	reader, err := storage.Get(archiveName)
682
1928
	c.Assert(err, gc.IsNil)
683
1929
	defer reader.Close()
684
1930
	downloadedSHA256, _, err := utils.ReadSHA256(reader)
685
1931
	c.Assert(err, gc.IsNil)
686
1932
	c.Assert(downloadedSHA256, gc.Equals, expectedSHA256)
687
1933
}
688
1934
689
1935
func getArchiveName(bundleURL *url.URL) string {
690
1936
	return strings.TrimPrefix(bundleURL.RequestURI(), "/dummyenv/private/")
691
1823
}
1937
}
692
1824
1938
693
=== modified file 'state/apiserver/export_test.go'
694
--- state/apiserver/export_test.go	2014-01-17 19:33:42 +0000
695
+++ state/apiserver/export_test.go	2014-01-30 14:23:21 +0000
696
@@ -6,8 +6,7 @@
697
6
import "reflect"
6
import "reflect"
698
7
7
699
8
var (
8
var (
704
9
	RootType          = reflect.TypeOf(&srvRoot{})
9
	RootType        = reflect.TypeOf(&srvRoot{})
705
10
	NewPingTimeout    = newPingTimeout
10
	NewPingTimeout  = newPingTimeout
706
11
	GetEnvironStorage = getEnvironStorage
11
	MaxPingInterval = &maxPingInterval
703
12
	MaxPingInterval   = &maxPingInterval
707
13
)
12
)
708
14
13
709
=== modified file 'state/state.go'
710
--- state/state.go	2014-01-28 04:58:43 +0000
711
+++ state/state.go	2014-01-30 14:23:21 +0000
712
@@ -445,12 +445,13 @@
713
445
	return coll, id, nil
445
	return coll, id, nil
714
446
}
446
}
715
447
447
719
448
// AddCharm adds the ch charm with curl to the state.  bundleUrl must be
448
// AddCharm adds the ch charm with curl to the state. bundleURL must
720
449
// set to a URL where the bundle for ch may be downloaded from.
449
// be set to a URL where the bundle for ch may be downloaded from. On
721
450
// On success the newly added charm state is returned.
450
// success the newly added charm state is returned.
722
451
func (st *State) AddCharm(ch charm.Charm, curl *charm.URL, bundleURL *url.URL, bundleSha256 string) (stch *Charm, err error) {
451
func (st *State) AddCharm(ch charm.Charm, curl *charm.URL, bundleURL *url.URL, bundleSha256 string) (stch *Charm, err error) {
725
452
	// The charm may already exist in state as a placeholder, so we check for that situation and update the
452
	// The charm may already exist in state as a placeholder, so we
726
453
	// existing charm record if necessary, otherwise add a new record.
453
	// check for that situation and update the existing charm record
727
454
	// if necessary, otherwise add a new record.
728
454
	var existing charmDoc
455
	var existing charmDoc
729
455
	err = st.charms.Find(D{{"_id", curl.String()}, {"placeholder", true}}).One(&existing)
456
	err = st.charms.Find(D{{"_id", curl.String()}, {"placeholder", true}}).One(&existing)
730
456
	if err == mgo.ErrNotFound {
457
	if err == mgo.ErrNotFound {
731
@@ -469,13 +470,19 @@
732
469
	} else if err != nil {
470
	} else if err != nil {
733
470
		return nil, err
471
		return nil, err
734
471
	}
472
	}
736
472
	return st.updateCharmDoc(ch, curl, bundleURL, bundleSha256, StillPlaceholder)
473
	return st.updateCharmDoc(ch, curl, bundleURL, bundleSha256, stillPlaceholder)
737
473
}
474
}
738
474
475
740
475
// Charm returns the charm with the given URL.
476
// Charm returns the charm with the given URL. Charms pending upload
741
477
// to storage and placeholders are never returned.
742
476
func (st *State) Charm(curl *charm.URL) (*Charm, error) {
478
func (st *State) Charm(curl *charm.URL) (*Charm, error) {
743
477
	cdoc := &charmDoc{}
479
	cdoc := &charmDoc{}
745
478
	err := st.charms.Find(D{{"_id", curl}, {"pendingupload", false}, {"placeholder", false}}).One(cdoc)
480
	what := D{
746
481
		{"_id", curl},
747
482
		{"placeholder", D{{"$ne", true}}},
748
483
		{"pendingupload", D{{"$ne", true}}},
749
484
	}
750
485
	err := st.charms.Find(what).One(&cdoc)
751
479
	if err == mgo.ErrNotFound {
486
	if err == mgo.ErrNotFound {
752
480
		return nil, errors.NotFoundf("charm %q", curl)
487
		return nil, errors.NotFoundf("charm %q", curl)
753
481
	}
488
	}
754
@@ -488,7 +495,8 @@
755
488
	return newCharm(st, cdoc)
495
	return newCharm(st, cdoc)
756
489
}
496
}
757
490
497
759
491
// LatestPlaceholderCharm returns the latest charm described by the given URL but which is not yet deployed.
498
// LatestPlaceholderCharm returns the latest charm described by the
760
499
// given URL but which is not yet deployed.
761
492
func (st *State) LatestPlaceholderCharm(curl *charm.URL) (*Charm, error) {
500
func (st *State) LatestPlaceholderCharm(curl *charm.URL) (*Charm, error) {
762
493
	noRevURL := curl.WithRevision(-1)
501
	noRevURL := curl.WithRevision(-1)
763
494
	curlRegex := "^" + regexp.QuoteMeta(noRevURL.String())
502
	curlRegex := "^" + regexp.QuoteMeta(noRevURL.String())
764
@@ -510,10 +518,10 @@
765
510
	return newCharm(st, &latest)
518
	return newCharm(st, &latest)
766
511
}
519
}
767
512
520
772
513
// PrepareLocalCharmUpload must be called before a charm is uploaded
521
// PrepareLocalCharmUpload must be called before a local charm is
773
514
// to the provider storage in order to create a charm document in
522
// uploaded to the provider storage in order to create a charm
774
515
// state. It returns a new Charm with no metadata and a unique
523
// document in state. It returns the chosen unique charm URL reserved
775
516
// revision number.
524
// in state for the charm.
776
517
//
525
//
777
518
// The url's schema must be "local" and it must include a revision.
526
// The url's schema must be "local" and it must include a revision.
778
519
func (st *State) PrepareLocalCharmUpload(curl *charm.URL) (chosenUrl *charm.URL, err error) {
527
func (st *State) PrepareLocalCharmUpload(curl *charm.URL) (chosenUrl *charm.URL, err error) {
779
@@ -575,8 +583,95 @@
780
575
	return chosenUrl, nil
583
	return chosenUrl, nil
781
576
}
584
}
782
577
585
785
578
var StillPending = D{{"pendingupload", true}}
586
// PrepareStoreCharmUpload must be called before a charm store charm
786
579
var StillPlaceholder = D{{"placeholder", true}}
587
// is uploaded to the provider storage in order to create a charm
787
588
// document in state. If a charm with the same URL is already in
788
589
// state, it will be returned as a *state.Charm (is can be still
789
590
// pending or already uploaded). Otherwise, a new charm document is
790
591
// added in state with just the given charm URL and
791
592
// PendingUpload=true, which is then returned as a *state.Charm.
792
593
//
793
594
// The url's schema must be "cs" and it must include a revision.
794
595
func (st *State) PrepareStoreCharmUpload(curl *charm.URL) (*Charm, error) {
795
596
	// Perform a few sanity checks first.
796
597
	if curl.Schema != "cs" {
797
598
		return nil, fmt.Errorf("expected charm URL with cs schema, got %q", curl)
798
599
	}
799
600
	if curl.Revision < 0 {
800
601
		return nil, fmt.Errorf("expected charm URL with revision, got %q", curl)
801
602
	}
802
603
803
604
	var (
804
605
		uploadedCharm charmDoc
805
606
		err           error
806
607
	)
807
608
	for attempt := 0; attempt < 3; attempt++ {
808
609
		// Find an uploaded or pending charm with the given exact curl.
809
610
		err = st.charms.FindId(curl).One(&uploadedCharm)
810
611
		if err != nil && err != mgo.ErrNotFound {
811
612
			return nil, err
812
613
		} else if err == nil && !uploadedCharm.Placeholder {
813
614
			// The charm exists and it's either uploaded or still
814
615
			// pending, but it's not a placeholder. In any case, we
815
616
			// just return what we got.
816
617
			return newCharm(st, &uploadedCharm)
817
618
		} else if err == mgo.ErrNotFound {
818
619
			// Prepare the pending charm document for insertion.
819
620
			uploadedCharm = charmDoc{
820
621
				URL:           curl,
821
622
				PendingUpload: true,
822
623
				Placeholder:   false,
823
624
			}
824
625
		}
825
626
826
627
		var ops []txn.Op
827
628
		if uploadedCharm.Placeholder {
828
629
			// Convert the placeholder to a pending charm, while
829
630
			// asserting the fields updated after an upload have not
830
631
			// changed yet.
831
632
			ops = []txn.Op{{
832
633
				C:  st.charms.Name,
833
634
				Id: curl,
834
635
				Assert: D{
835
636
					{"bundlesha256", ""},
836
637
					{"pendingupload", false},
837
638
					{"placeholder", true},
838
639
				},
839
640
				Update: D{{"$set", D{
840
641
					{"pendingupload", true},
841
642
					{"placeholder", false},
842
643
				}}},
843
644
			}}
844
645
			// Update the fields of the document we're returning.
845
646
			uploadedCharm.PendingUpload = true
846
647
			uploadedCharm.Placeholder = false
847
648
		} else {
848
649
			// No charm document with this curl yet, insert it.
849
650
			ops = []txn.Op{{
850
651
				C:      st.charms.Name,
851
652
				Id:     curl,
852
653
				Assert: txn.DocMissing,
853
654
				Insert: uploadedCharm,
854
655
			}}
855
656
		}
856
657
857
658
		// Run the transaction, and retry on abort.
858
659
		err = st.runTransaction(ops)
859
660
		if err == txn.ErrAborted {
860
661
			continue
861
662
		} else if err != nil {
862
663
			return nil, err
863
664
		} else if err == nil {
864
665
			return newCharm(st, &uploadedCharm)
865
666
		}
866
667
	}
867
668
	return nil, ErrExcessiveContention
868
669
}
869
670
870
671
var (
871
672
	stillPending     = D{{"pendingupload", true}}
872
673
	stillPlaceholder = D{{"placeholder", true}}
873
674
)
874
580
675
875
581
// AddStoreCharmPlaceholder creates a charm document in state for the given charm URL which
676
// AddStoreCharmPlaceholder creates a charm document in state for the given charm URL which
876
582
// must reference a charm from the store. The charm document is marked as a placeholder which
677
// must reference a charm from the store. The charm document is marked as a placeholder which
877
@@ -653,13 +748,39 @@
878
653
		ops = append(ops, txn.Op{
748
		ops = append(ops, txn.Op{
879
654
			C:      st.charms.Name,
749
			C:      st.charms.Name,
880
655
			Id:     doc.URL.String(),
750
			Id:     doc.URL.String(),
882
656
			Assert: StillPlaceholder,
751
			Assert: stillPlaceholder,
883
657
			Remove: true,
752
			Remove: true,
884
658
		})
753
		})
885
659
	}
754
	}
886
660
	return ops, nil
755
	return ops, nil
887
661
}
756
}
888
662
757
889
758
// ErrCharmAlreadyUploaded is returned by UpdateUploadedCharm() when
890
759
// the given charm is already uploaded and marked as not pending in
891
760
// state.
892
761
type ErrCharmAlreadyUploaded struct {
893
762
	curl *charm.URL
894
763
}
895
764
896
765
func (e *ErrCharmAlreadyUploaded) Error() string {
897
766
	return fmt.Sprintf("charm %q already uploaded", e.curl)
898
767
}
899
768
900
769
// IsCharmAlreadyUploadedError returns if the given error is
901
770
// ErrCharmAlreadyUploaded.
902
771
func IsCharmAlreadyUploadedError(err interface{}) bool {
903
772
	if err == nil {
904
773
		return false
905
774
	}
906
775
	_, ok := err.(*ErrCharmAlreadyUploaded)
907
776
	return ok
908
777
}
909
778
910
779
// ErrCharmRevisionAlreadyModified is returned when a pending or
911
780
// placeholder charm is no longer pending or a placeholder, signaling
912
781
// the charm is available in state with its full information.
913
782
var ErrCharmRevisionAlreadyModified = fmt.Errorf("charm revision already modified")
914
783
915
663
// UpdateUploadedCharm marks the given charm URL as uploaded and
784
// UpdateUploadedCharm marks the given charm URL as uploaded and
916
664
// updates the rest of its data, returning it as *state.Charm.
785
// updates the rest of its data, returning it as *state.Charm.
917
665
func (st *State) UpdateUploadedCharm(ch charm.Charm, curl *charm.URL, bundleURL *url.URL, bundleSha256 string) (*Charm, error) {
786
func (st *State) UpdateUploadedCharm(ch charm.Charm, curl *charm.URL, bundleURL *url.URL, bundleSha256 string) (*Charm, error) {
918
@@ -672,14 +793,16 @@
919
672
		return nil, err
793
		return nil, err
920
673
	}
794
	}
921
674
	if !doc.PendingUpload {
795
	if !doc.PendingUpload {
923
675
		return nil, fmt.Errorf("charm %q already uploaded", curl)
796
		return nil, &ErrCharmAlreadyUploaded{curl}
924
676
	}
797
	}
925
677
798
927
678
	return st.updateCharmDoc(ch, curl, bundleURL, bundleSha256, StillPending)
799
	return st.updateCharmDoc(ch, curl, bundleURL, bundleSha256, stillPending)
928
679
}
800
}
929
680
801
932
681
// updateCharmDoc updates the charm with specified URL with the given data, and resets the placeholder
802
// updateCharmDoc updates the charm with specified URL with the given
933
682
// and pendingupdate flags.
803
// data, and resets the placeholder and pendingupdate flags.  If the
934
804
// charm is no longer a placeholder or pending (depending on preReq),
935
805
// it returns ErrCharmRevisionAlreadyModified.
936
683
func (st *State) updateCharmDoc(
806
func (st *State) updateCharmDoc(
937
684
	ch charm.Charm, curl *charm.URL, bundleURL *url.URL, bundleSha256 string, preReq interface{}) (*Charm, error) {
807
	ch charm.Charm, curl *charm.URL, bundleURL *url.URL, bundleSha256 string, preReq interface{}) (*Charm, error) {
938
685
808
939
@@ -698,7 +821,7 @@
940
698
		Update: updateFields,
821
		Update: updateFields,
941
699
	}}
822
	}}
942
700
	if err := st.runTransaction(ops); err != nil {
823
	if err := st.runTransaction(ops); err != nil {
944
701
		return nil, onAbort(err, fmt.Errorf("charm revision already modified"))
824
		return nil, onAbort(err, ErrCharmRevisionAlreadyModified)
945
702
	}
825
	}
946
703
	return st.Charm(curl)
826
	return st.Charm(curl)
947
704
}
827
}
948
705
828
949
=== modified file 'state/state_test.go'
950
--- state/state_test.go	2014-01-25 11:45:42 +0000
951
+++ state/state_test.go	2014-01-30 14:23:21 +0000
952
@@ -129,15 +129,26 @@
953
129
	c.Assert(err2, jc.Satisfies, errors.IsNotFoundError)
129
	c.Assert(err2, jc.Satisfies, errors.IsNotFoundError)
954
130
}
130
}
955
131
131
956
132
func (s *StateSuite) dummyCharm(c *gc.C, curlOverride string) (ch charm.Charm, curl *charm.URL, bundleURL *url.URL, bundleSHA256 string) {
957
133
	var err error
958
134
	ch = testing.Charms.Dir("dummy")
959
135
	if curlOverride != "" {
960
136
		curl = charm.MustParseURL(curlOverride)
961
137
	} else {
962
138
		curl = charm.MustParseURL(
963
139
			fmt.Sprintf("local:quantal/%s-%d", ch.Meta().Name, ch.Revision()),
964
140
		)
965
141
	}
966
142
	bundleURL, err = url.Parse("http://bundles.testing.invalid/dummy-1")
967
143
	c.Assert(err, gc.IsNil)
968
144
	bundleSHA256 = "dummy-1-sha256"
969
145
	return ch, curl, bundleURL, bundleSHA256
970
146
}
971
147
972
132
func (s *StateSuite) TestAddCharm(c *gc.C) {
148
func (s *StateSuite) TestAddCharm(c *gc.C) {
973
133
	// Check that adding charms from scratch works correctly.
149
	// Check that adding charms from scratch works correctly.
981
134
	ch := testing.Charms.Dir("dummy")
150
	ch, curl, bundleURL, bundleSHA256 := s.dummyCharm(c, "")
982
135
	curl := charm.MustParseURL(
151
	dummy, err := s.State.AddCharm(ch, curl, bundleURL, bundleSHA256)
976
136
		fmt.Sprintf("local:quantal/%s-%d", ch.Meta().Name, ch.Revision()),
977
137
	)
978
138
	bundleURL, err := url.Parse("http://bundles.testing.invalid/dummy-1")
979
139
	c.Assert(err, gc.IsNil)
980
140
	dummy, err := s.State.AddCharm(ch, curl, bundleURL, "dummy-1-sha256")
983
141
	c.Assert(err, gc.IsNil)
152
	c.Assert(err, gc.IsNil)
984
142
	c.Assert(dummy.URL().String(), gc.Equals, curl.String())
153
	c.Assert(dummy.URL().String(), gc.Equals, curl.String())
985
143
154
986
@@ -161,7 +172,8 @@
987
161
	// Add a deployed charm.
172
	// Add a deployed charm.
988
162
	bundleURL, err := url.Parse("http://bundles.testing.invalid/dummy-1")
173
	bundleURL, err := url.Parse("http://bundles.testing.invalid/dummy-1")
989
163
	c.Assert(err, gc.IsNil)
174
	c.Assert(err, gc.IsNil)
991
164
	dummy, err := s.State.AddCharm(ch, curl, bundleURL, "dummy-1-sha256")
175
	bundleSHA256 := "dummy-1-sha256"
992
176
	dummy, err := s.State.AddCharm(ch, curl, bundleURL, bundleSHA256)
993
165
	c.Assert(err, gc.IsNil)
177
	c.Assert(err, gc.IsNil)
994
166
	c.Assert(dummy.URL().String(), gc.Equals, curl.String())
178
	c.Assert(dummy.URL().String(), gc.Equals, curl.String())
995
167
179
996
@@ -231,18 +243,78 @@
997
231
	c.Assert(curl.Revision, gc.Equals, 1234)
243
	c.Assert(curl.Revision, gc.Equals, 1234)
998
232
}
244
}
999
233
245
1000
246
func (s *StateSuite) TestPrepareStoreCharmUpload(c *gc.C) {
1001
247
	// First test the sanity checks.
1002
248
	sch, err := s.State.PrepareStoreCharmUpload(charm.MustParseURL("cs:quantal/dummy"))
1003
249
	c.Assert(err, gc.ErrorMatches, "expected charm URL with revision, got .*")
1004
250
	c.Assert(sch, gc.IsNil)
1005
251
	sch, err = s.State.PrepareStoreCharmUpload(charm.MustParseURL("local:quantal/dummy"))
1006
252
	c.Assert(err, gc.ErrorMatches, "expected charm URL with cs schema, got .*")
1007
253
	c.Assert(sch, gc.IsNil)
1008
254
1009
255
	// No charm in state, so the call should respect given revision.
1010
256
	testCurl := charm.MustParseURL("cs:quantal/missing-123")
1011
257
	sch, err = s.State.PrepareStoreCharmUpload(testCurl)
1012
258
	c.Assert(err, gc.IsNil)
1013
259
	c.Assert(sch.URL(), gc.DeepEquals, testCurl)
1014
260
	c.Assert(sch.IsUploaded(), jc.IsFalse)
1015
261
1016
262
	s.assertPendingCharmExists(c, sch.URL())
1017
263
1018
264
	// Try adding it again with the same revision and ensure we get the same document.
1019
265
	schCopy, err := s.State.PrepareStoreCharmUpload(testCurl)
1020
266
	c.Assert(err, gc.IsNil)
1021
267
	c.Assert(sch, jc.DeepEquals, schCopy)
1022
268
1023
269
	// Now add a charm and try again - we should get the same result
1024
270
	// as with AddCharm.
1025
271
	ch, curl, bundleURL, bundleSHA256 := s.dummyCharm(c, "cs:precise/dummy-2")
1026
272
	sch, err = s.State.AddCharm(ch, curl, bundleURL, bundleSHA256)
1027
273
	c.Assert(err, gc.IsNil)
1028
274
	schCopy, err = s.State.PrepareStoreCharmUpload(curl)
1029
275
	c.Assert(err, gc.IsNil)
1030
276
	c.Assert(sch, jc.DeepEquals, schCopy)
1031
277
1032
278
	// Finally, try poking around the state with a placeholder and
1033
279
	// bundlesha256 to make sure we do the right thing.
1034
280
	curl = curl.WithRevision(999)
1035
281
	first := state.TransactionHook{
1036
282
		Before: func() {
1037
283
			err := s.State.AddStoreCharmPlaceholder(curl)
1038
284
			c.Assert(err, gc.IsNil)
1039
285
		},
1040
286
		After: func() {
1041
287
			err := s.charms.RemoveId(curl)
1042
288
			c.Assert(err, gc.IsNil)
1043
289
		},
1044
290
	}
1045
291
	second := state.TransactionHook{
1046
292
		Before: func() {
1047
293
			err := s.State.AddStoreCharmPlaceholder(curl)
1048
294
			c.Assert(err, gc.IsNil)
1049
295
		},
1050
296
		After: func() {
1051
297
			err := s.charms.UpdateId(curl, D{{"$set", D{
1052
298
				{"bundlesha256", "fake"}},
1053
299
			}})
1054
300
			c.Assert(err, gc.IsNil)
1055
301
		},
1056
302
	}
1057
303
	defer state.SetTransactionHooks(
1058
304
		c, s.State, first, second, first,
1059
305
	).Check()
1060
306
1061
307
	_, err = s.State.PrepareStoreCharmUpload(curl)
1062
308
	c.Assert(err, gc.Equals, state.ErrExcessiveContention)
1063
309
}
1064
310
1065
234
func (s *StateSuite) TestUpdateUploadedCharm(c *gc.C) {
311
func (s *StateSuite) TestUpdateUploadedCharm(c *gc.C) {
1073
235
	ch := testing.Charms.Dir("dummy")
312
	ch, curl, bundleURL, bundleSHA256 := s.dummyCharm(c, "")
1074
236
	curl := charm.MustParseURL(
313
	_, err := s.State.AddCharm(ch, curl, bundleURL, bundleSHA256)
1068
237
		fmt.Sprintf("local:quantal/%s-%d", ch.Meta().Name, ch.Revision()),
1069
238
	)
1070
239
	bundleURL, err := url.Parse("http://bundles.testing.invalid/dummy-1")
1071
240
	c.Assert(err, gc.IsNil)
1072
241
	_, err = s.State.AddCharm(ch, curl, bundleURL, "dummy-1-sha256")
1075
242
	c.Assert(err, gc.IsNil)
314
	c.Assert(err, gc.IsNil)
1076
243
315
1079
244
	// First test with already uploaded and a missing charms.
316
	// Test with already uploaded and a missing charms.
1080
245
	sch, err := s.State.UpdateUploadedCharm(ch, curl, bundleURL, "dummy-1-sha256")
317
	sch, err := s.State.UpdateUploadedCharm(ch, curl, bundleURL, bundleSHA256)
1081
246
	c.Assert(err, gc.ErrorMatches, fmt.Sprintf("charm %q already uploaded", curl))
318
	c.Assert(err, gc.ErrorMatches, fmt.Sprintf("charm %q already uploaded", curl))
1082
247
	c.Assert(sch, gc.IsNil)
319
	c.Assert(sch, gc.IsNil)
1083
248
	missingCurl := charm.MustParseURL("local:quantal/missing-1")
320
	missingCurl := charm.MustParseURL("local:quantal/missing-1")
1084
@@ -250,7 +322,7 @@
1085
250
	c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
322
	c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
1086
251
	c.Assert(sch, gc.IsNil)
323
	c.Assert(sch, gc.IsNil)
1087
252
324
1089
253
	// Now try with an uploaded charm.
325
	// Test with with an uploaded local charm.
1090
254
	_, err = s.State.PrepareLocalCharmUpload(missingCurl)
326
	_, err = s.State.PrepareLocalCharmUpload(missingCurl)
1091
255
	c.Assert(err, gc.IsNil)
327
	c.Assert(err, gc.IsNil)
1092
256
	sch, err = s.State.UpdateUploadedCharm(ch, missingCurl, bundleURL, "missing")
328
	sch, err = s.State.UpdateUploadedCharm(ch, missingCurl, bundleURL, "missing")
1093
@@ -258,6 +330,7 @@
1094
258
	c.Assert(sch.URL(), gc.DeepEquals, missingCurl)
330
	c.Assert(sch.URL(), gc.DeepEquals, missingCurl)
1095
259
	c.Assert(sch.Revision(), gc.Equals, missingCurl.Revision)
331
	c.Assert(sch.Revision(), gc.Equals, missingCurl.Revision)
1096
260
	c.Assert(sch.IsUploaded(), jc.IsTrue)
332
	c.Assert(sch.IsUploaded(), jc.IsTrue)
1097
333
	c.Assert(sch.IsPlaceholder(), jc.IsFalse)
1098
261
	c.Assert(sch.Meta(), gc.DeepEquals, ch.Meta())
334
	c.Assert(sch.Meta(), gc.DeepEquals, ch.Meta())
1099
262
	c.Assert(sch.Config(), gc.DeepEquals, ch.Config())
335
	c.Assert(sch.Config(), gc.DeepEquals, ch.Config())
1100
263
	c.Assert(sch.BundleURL(), gc.DeepEquals, bundleURL)
336
	c.Assert(sch.BundleURL(), gc.DeepEquals, bundleURL)
1101
@@ -285,11 +358,8 @@
1102
285
358
1103
286
func (s *StateSuite) TestLatestPlaceholderCharm(c *gc.C) {
359
func (s *StateSuite) TestLatestPlaceholderCharm(c *gc.C) {
1104
287
	// Add a deployed charm
360
	// Add a deployed charm
1110
288
	ch := testing.Charms.Dir("dummy")
361
	ch, curl, bundleURL, bundleSHA256 := s.dummyCharm(c, "cs:quantal/dummy-1")
1111
289
	curl := charm.MustParseURL("cs:quantal/dummy-1")
362
	_, err := s.State.AddCharm(ch, curl, bundleURL, bundleSHA256)
1107
290
	bundleURL, err := url.Parse("http://bundles.testing.invalid/dummy-1")
1108
291
	c.Assert(err, gc.IsNil)
1109
292
	_, err = s.State.AddCharm(ch, curl, bundleURL, "dummy-1-sha256")
1112
293
	c.Assert(err, gc.IsNil)
363
	c.Assert(err, gc.IsNil)
1113
294
364
1114
295
	// Deployed charm not found.
365
	// Deployed charm not found.
1115
@@ -341,11 +411,8 @@
1116
341
411
1117
342
func (s *StateSuite) assertAddStoreCharmPlaceholder(c *gc.C) (*charm.URL, *charm.URL, *state.Charm) {
412
func (s *StateSuite) assertAddStoreCharmPlaceholder(c *gc.C) (*charm.URL, *charm.URL, *state.Charm) {
1118
343
	// Add a deployed charm
413
	// Add a deployed charm
1124
344
	ch := testing.Charms.Dir("dummy")
414
	ch, curl, bundleURL, bundleSHA256 := s.dummyCharm(c, "cs:quantal/dummy-1")
1125
345
	curl := charm.MustParseURL("cs:quantal/dummy-1")
415
	dummy, err := s.State.AddCharm(ch, curl, bundleURL, bundleSHA256)
1121
346
	bundleURL, err := url.Parse("http://bundles.testing.invalid/dummy-1")
1122
347
	c.Assert(err, gc.IsNil)
1123
348
	dummy, err := s.State.AddCharm(ch, curl, bundleURL, "dummy-1-sha256")
1126
349
	c.Assert(err, gc.IsNil)
416
	c.Assert(err, gc.IsNil)
1127
350
417
1128
351
	// Add a charm placeholder
418
	// Add a charm placeholder
1129
352
419
1130
=== modified file 'testing/charm.go'
1131
--- testing/charm.go	2014-01-09 04:04:54 +0000
1132
+++ testing/charm.go	2014-01-30 14:23:21 +0000
1133
@@ -9,16 +9,11 @@
1134
9
	"os"
9
	"os"
1135
10
	"os/exec"
10
	"os/exec"
1136
11
	"path/filepath"
11
	"path/filepath"
1137
12
	"sync"
1138
12
13
1139
13
	"launchpad.net/juju-core/charm"
14
	"launchpad.net/juju-core/charm"
1140
14
)
15
)
1141
15
16
1142
16
func init() {
1143
17
	p, err := build.Import("launchpad.net/juju-core/testing", "", build.FindOnly)
1144
18
	check(err)
1145
19
	Charms = &Repo{Path: filepath.Join(p.Dir, "repo")}
1146
20
}
1147
21
1148
22
func check(err error) {
17
func check(err error) {
1149
23
	if err != nil {
18
	if err != nil {
1150
24
		panic(err)
19
		panic(err)
1151
@@ -27,12 +22,27 @@
1152
27
22
1153
28
// Repo represents a charm repository used for testing.
23
// Repo represents a charm repository used for testing.
1154
29
type Repo struct {
24
type Repo struct {
1156
30
	Path string
25
	once sync.Once
1157
26
	path string
1158
27
}
1159
28
1160
29
func (r *Repo) Path() string {
1161
30
	r.once.Do(r.init)
1162
31
	return r.path
1163
32
}
1164
33
1165
34
// init is called once when r.Path() is called for the first time, and
1166
35
// it initializes r.path to the location of the local testing
1167
36
// repository.
1168
37
func (r *Repo) init() {
1169
38
	p, err := build.Import("launchpad.net/juju-core/testing", "", build.FindOnly)
1170
39
	check(err)
1171
40
	r.path = filepath.Join(p.Dir, "repo")
1172
31
}
41
}
1173
32
42
1174
33
// Charms represents the specific charm repository stored in this package and
43
// Charms represents the specific charm repository stored in this package and
1175
34
// used by the Juju unit tests. The series name is "quantal".
44
// used by the Juju unit tests. The series name is "quantal".
1177
35
var Charms *Repo
45
var Charms = &Repo{}
1178
36
46
1179
37
func clone(dst, src string) string {
47
func clone(dst, src string) string {
1180
38
	check(exec.Command("cp", "-r", src, dst).Run())
48
	check(exec.Command("cp", "-r", src, dst).Run())
1181
@@ -42,7 +52,7 @@
1182
42
// DirPath returns the path to a charm directory with the given name in the
52
// DirPath returns the path to a charm directory with the given name in the
1183
43
// default series
53
// default series
1184
44
func (r *Repo) DirPath(name string) string {
54
func (r *Repo) DirPath(name string) string {
1186
45
	return filepath.Join(r.Path, "quantal", name)
55
	return filepath.Join(r.Path(), "quantal", name)
1187
46
}
56
}
1188
47
57
1189
48
// Dir returns the actual charm.Dir named name.
58
// Dir returns the actual charm.Dir named name.
1190
49
59
1191
=== modified file 'utils/trivial.go'
1192
--- utils/trivial.go	2014-01-14 06:49:14 +0000
1193
+++ utils/trivial.go	2014-01-30 14:23:21 +0000
1194
@@ -6,8 +6,11 @@
1195
6
import (
6
import (
1196
7
	"bytes"
7
	"bytes"
1197
8
	"compress/gzip"
8
	"compress/gzip"
1198
9
	"crypto/sha256"
1199
10
	"encoding/hex"
1200
9
	"errors"
11
	"errors"
1201
10
	"fmt"
12
	"fmt"
1202
13
	"io"
1203
11
	"io/ioutil"
14
	"io/ioutil"
1204
12
	"os"
15
	"os"
1205
13
	"strings"
16
	"strings"
1206
@@ -118,3 +121,26 @@
1207
118
	}
121
	}
1208
119
	return ioutil.ReadAll(r)
122
	return ioutil.ReadAll(r)
1209
120
}
123
}
1210
124
1211
125
// ReadSHA256 returns the SHA256 hash of the contents read from source
1212
126
// (hex encoded) and the size of the source in bytes.
1213
127
func ReadSHA256(source io.Reader) (string, int64, error) {
1214
128
	hash := sha256.New()
1215
129
	size, err := io.Copy(hash, source)
1216
130
	if err != nil {
1217
131
		return "", 0, err
1218
132
	}
1219
133
	digest := hex.EncodeToString(hash.Sum(nil))
1220
134
	return digest, size, nil
1221
135
}
1222
136
1223
137
// ReadFileSHA256 is like ReadSHA256 but reads the contents of the
1224
138
// given file.
1225
139
func ReadFileSHA256(filename string) (string, int64, error) {
1226
140
	f, err := os.Open(filename)
1227
141
	if err != nil {
1228
142
		return "", 0, err
1229
143
	}
1230
144
	defer f.Close()
1231
145
	return ReadSHA256(f)
1232
146
}
1233
121
147
1234
=== modified file 'utils/trivial_test.go'
1235
--- utils/trivial_test.go	2014-01-17 02:35:28 +0000
1236
+++ utils/trivial_test.go	2014-01-30 14:23:21 +0000
1237
@@ -4,6 +4,10 @@
1238
4
package utils_test
4
package utils_test
1239
5
5
1240
6
import (
6
import (
1241
7
	"bytes"
1242
8
	"fmt"
1243
9
	"io/ioutil"
1244
10
	"path/filepath"
1245
7
	"strings"
11
	"strings"
1246
8
	"testing"
12
	"testing"
1247
9
13
1248
@@ -36,7 +40,7 @@
1249
36
	}
40
	}
1250
37
)
41
)
1251
38
42
1253
39
func (utilsSuite) TestCompression(c *gc.C) {
43
func (*utilsSuite) TestCompression(c *gc.C) {
1254
40
	cdata := utils.Gzip(data)
44
	cdata := utils.Gzip(data)
1255
41
	c.Assert(len(cdata) < len(data), gc.Equals, true)
45
	c.Assert(len(cdata) < len(data), gc.Equals, true)
1256
42
	data1, err := utils.Gunzip(cdata)
46
	data1, err := utils.Gunzip(cdata)
1257
@@ -48,7 +52,7 @@
1258
48
	c.Assert(data1, gc.DeepEquals, data)
52
	c.Assert(data1, gc.DeepEquals, data)
1259
49
}
53
}
1260
50
54
1262
51
func (utilsSuite) TestCommandString(c *gc.C) {
55
func (*utilsSuite) TestCommandString(c *gc.C) {
1263
52
	type test struct {
56
	type test struct {
1264
53
		args     []string
57
		args     []string
1265
54
		expected string
58
		expected string
1266
@@ -71,3 +75,43 @@
1267
71
		c.Assert(result, gc.Equals, test.expected)
75
		c.Assert(result, gc.Equals, test.expected)
1268
72
	}
76
	}
1269
73
}
77
}
1270
78
1271
79
func (*utilsSuite) TestReadSHA256AndReadFileSHA256(c *gc.C) {
1272
80
	sha256Tests := []struct {
1273
81
		content string
1274
82
		sha256  string
1275
83
	}{{
1276
84
		content: "",
1277
85
		sha256:  "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
1278
86
	}, {
1279
87
		content: "some content",
1280
88
		sha256:  "290f493c44f5d63d06b374d0a5abd292fae38b92cab2fae5efefe1b0e9347f56",
1281
89
	}, {
1282
90
		content: "foo",
1283
91
		sha256:  "2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae",
1284
92
	}, {
1285
93
		content: "Foo",
1286
94
		sha256:  "1cbec737f863e4922cee63cc2ebbfaafcd1cff8b790d8cfd2e6a5d550b648afa",
1287
95
	}, {
1288
96
		content: "multi\nline\ntext\nhere",
1289
97
		sha256:  "c384f11c0294280792a44d9d6abb81f9fd991904cb7eb851a88311b04114231e",
1290
98
	}}
1291
99
1292
100
	tempDir := c.MkDir()
1293
101
	for i, test := range sha256Tests {
1294
102
		c.Logf("test %d: %q -> %q", i, test.content, test.sha256)
1295
103
		buf := bytes.NewBufferString(test.content)
1296
104
		hash, size, err := utils.ReadSHA256(buf)
1297
105
		c.Check(err, gc.IsNil)
1298
106
		c.Check(hash, gc.Equals, test.sha256)
1299
107
		c.Check(int(size), gc.Equals, len(test.content))
1300
108
1301
109
		tempFileName := filepath.Join(tempDir, fmt.Sprintf("sha256-%d", i))
1302
110
		err = ioutil.WriteFile(tempFileName, []byte(test.content), 0644)
1303
111
		c.Check(err, gc.IsNil)
1304
112
		fileHash, fileSize, err := utils.ReadFileSHA256(tempFileName)
1305
113
		c.Check(err, gc.IsNil)
1306
114
		c.Check(fileHash, gc.Equals, hash)
1307
115
		c.Check(fileSize, gc.Equals, size)
1308
116
	}
1309
117
}
1310
74
118
1311
=== modified file 'worker/uniter/charm/charm.go'
1312
--- worker/uniter/charm/charm.go	2013-10-03 13:13:25 +0000
1313
+++ worker/uniter/charm/charm.go	2014-01-30 14:23:21 +0000
1314
@@ -4,10 +4,7 @@
1315
4
package charm
4
package charm
1316
5
5
1317
6
import (
6
import (
1318
7
	"crypto/sha256"
1319
8
	"encoding/hex"
1320
9
	"fmt"
7
	"fmt"
1321
10
	"io"
1322
11
	"os"
8
	"os"
1323
12
	"path"
9
	"path"
1324
13
10
1325
@@ -75,11 +72,10 @@
1326
75
			}
72
			}
1327
76
			log.Infof("worker/uniter/charm: download complete")
73
			log.Infof("worker/uniter/charm: download complete")
1328
77
			defer st.File.Close()
74
			defer st.File.Close()
1331
78
			hash := sha256.New()
75
			actualSha256, _, err := utils.ReadSHA256(st.File)
1332
79
			if _, err = io.Copy(hash, st.File); err != nil {
76
			if err != nil {
1333
80
				return err
77
				return err
1334
81
			}
78
			}
1335
82
			actualSha256 := hex.EncodeToString(hash.Sum(nil))
1336
83
			archiveSha256, err := sch.ArchiveSha256()
79
			archiveSha256, err := sch.ArchiveSha256()
1337
84
			if err != nil {
80
			if err != nil {
1338
85
				return err
81
				return err
1339
86
82
1340
=== modified file 'worker/uniter/uniter_test.go'
1341
--- worker/uniter/uniter_test.go	2014-01-28 03:53:50 +0000
1342
+++ worker/uniter/uniter_test.go	2014-01-30 14:23:21 +0000
1343
@@ -5,10 +5,7 @@
1344
5
5
1345
6
import (
6
import (
1346
7
	"bytes"
7
	"bytes"
1347
8
	"crypto/sha256"
1348
9
	"encoding/hex"
1349
10
	"fmt"
8
	"fmt"
1350
11
	"io"
1351
12
	"io/ioutil"
9
	"io/ioutil"
1352
13
	"net/rpc"
10
	"net/rpc"
1353
14
	"net/url"
11
	"net/url"
1354
@@ -1199,10 +1196,8 @@
1355
1199
	err := s.dir.BundleTo(&buf)
1196
	err := s.dir.BundleTo(&buf)
1356
1200
	c.Assert(err, gc.IsNil)
1197
	c.Assert(err, gc.IsNil)
1357
1201
	body := buf.Bytes()
1198
	body := buf.Bytes()
1360
1202
	hasher := sha256.New()
1199
	hash, _, err := utils.ReadSHA256(&buf)
1359
1203
	_, err = io.Copy(hasher, &buf)
1361
1204
	c.Assert(err, gc.IsNil)
1200
	c.Assert(err, gc.IsNil)
1362
1205
	hash := hex.EncodeToString(hasher.Sum(nil))
1363
1206
	key := fmt.Sprintf("/charms/%s/%d", s.dir.Meta().Name, s.dir.Revision())
1201
	key := fmt.Sprintf("/charms/%s/%d", s.dir.Meta().Name, s.dir.Revision())
1364
1207
	hurl, err := url.Parse(coretesting.Server.URL + key)
1202
	hurl, err := url.Parse(coretesting.Server.URL + key)
1365
1208
	c.Assert(err, gc.IsNil)
1203
	c.Assert(err, gc.IsNil)
Reviewer	Review Type	Date Requested	Status
Dimiter Naydenov (community)			Approve on 2014-01-30
Review via email: mp+203291@code.launchpad.net