1
=== modified file 'cmd/jujud/bootstrap.go'
2
--- cmd/jujud/bootstrap.go	2013-09-30 19:40:06 +0000
3
+++ cmd/jujud/bootstrap.go	2014-01-31 12:32:29 +0000
4
@@ -96,7 +96,7 @@
5
96
		return fmt.Errorf("cannot read provider-state-url file: %v", err)
96
		return fmt.Errorf("cannot read provider-state-url file: %v", err)
6
97
	}
97
	}
7
98
	stateInfoURL := strings.Split(string(data), "\n")[0]
98
	stateInfoURL := strings.Split(string(data), "\n")[0]
9
99
	bsState, err := common.LoadStateFromURL(stateInfoURL)
99
	bsState, err := common.LoadStateFromURL(stateInfoURL, !cfg.SSLHostnameVerification())
10
100
	if err != nil {
100
	if err != nil {
11
101
		return fmt.Errorf("cannot load state from URL %q (read from %q): %v", stateInfoURL, providerStateURLFile, err)
101
		return fmt.Errorf("cannot load state from URL %q (read from %q): %v", stateInfoURL, providerStateURLFile, err)
12
102
	}
102
	}
13
103
103
14
=== modified file 'environs/httpstorage/storage.go'
15
--- environs/httpstorage/storage.go	2013-10-02 05:46:56 +0000
16
+++ environs/httpstorage/storage.go	2014-01-31 12:32:29 +0000
17
@@ -64,12 +64,15 @@
18
64
}
64
}
19
65
65
20
66
func (s *localStorage) getHTTPSBaseURL() (string, error) {
66
func (s *localStorage) getHTTPSBaseURL() (string, error) {
22
67
	url, _ := s.URL("/") // never fails
67
	url, _ := s.URL("") // never fails
23
68
	resp, err := s.client.Head(url)
68
	resp, err := s.client.Head(url)
24
69
	if err != nil {
69
	if err != nil {
25
70
		return "", err
70
		return "", err
26
71
	}
71
	}
27
72
	resp.Body.Close()
72
	resp.Body.Close()
28
73
	if resp.StatusCode != http.StatusOK {
29
74
		return "", fmt.Errorf("Could not access file storage: %v %s", url, resp.Status)
30
75
	}
31
73
	httpsURL, err := resp.Location()
76
	httpsURL, err := resp.Location()
32
74
	if err != nil {
77
	if err != nil {
33
75
		return "", err
78
		return "", err
34
76
79
35
=== modified file 'provider/common/bootstrap_test.go'
36
--- provider/common/bootstrap_test.go	2013-10-02 00:29:29 +0000
37
+++ provider/common/bootstrap_test.go	2014-01-31 12:32:29 +0000
38
@@ -151,7 +151,7 @@
39
151
	err := common.Bootstrap(env, constraints.Value{}, nil)
151
	err := common.Bootstrap(env, constraints.Value{}, nil)
40
152
	c.Assert(err, gc.IsNil)
152
	c.Assert(err, gc.IsNil)
41
153
153
43
154
	savedState, err := common.LoadStateFromURL(checkURL)
154
	savedState, err := common.LoadStateFromURL(checkURL, false)
44
155
	c.Assert(err, gc.IsNil)
155
	c.Assert(err, gc.IsNil)
45
156
	c.Assert(savedState, gc.DeepEquals, &common.BootstrapState{
156
	c.Assert(savedState, gc.DeepEquals, &common.BootstrapState{
46
157
		StateInstances:  []instance.Id{instance.Id(checkInstanceId)},
157
		StateInstances:  []instance.Id{instance.Id(checkInstanceId)},
47
158
158
48
=== modified file 'provider/common/state.go'
49
--- provider/common/state.go	2013-10-01 12:03:33 +0000
50
+++ provider/common/state.go	2014-01-31 12:32:29 +0000
51
@@ -21,6 +21,7 @@
52
21
	"launchpad.net/juju-core/log"
21
	"launchpad.net/juju-core/log"
53
22
	"launchpad.net/juju-core/state"
22
	"launchpad.net/juju-core/state"
54
23
	"launchpad.net/juju-core/state/api"
23
	"launchpad.net/juju-core/state/api"
55
24
	"launchpad.net/juju-core/utils"
56
24
)
25
)
57
25
26
58
26
// StateFile is the name of the file where the provider's state is stored.
27
// StateFile is the name of the file where the provider's state is stored.
59
@@ -67,11 +68,19 @@
60
67
}
68
}
61
68
69
62
69
// LoadStateFromURL reads state from the given URL.
70
// LoadStateFromURL reads state from the given URL.
65
70
func LoadStateFromURL(url string) (*BootstrapState, error) {
71
func LoadStateFromURL(url string, disableSSLHostnameVerification bool) (*BootstrapState, error) {
66
71
	resp, err := http.Get(url)
72
	client := http.DefaultClient
67
73
	if disableSSLHostnameVerification {
68
74
		logger.Infof("hostname SSL verification disabled")
69
75
		client = utils.GetNonValidatingHTTPClient()
70
76
	}
71
77
	resp, err := client.Get(url)
72
72
	if err != nil {
78
	if err != nil {
73
73
		return nil, err
79
		return nil, err
74
74
	}
80
	}
75
81
	if resp.StatusCode != http.StatusOK {
76
82
		return nil, fmt.Errorf("could not load state from url: %v %s", url, resp.Status)
77
83
	}
78
75
	return loadState(resp.Body)
84
	return loadState(resp.Body)
79
76
}
85
}
80
77
86
81
78
87
82
=== modified file 'provider/common/state_test.go'
83
--- provider/common/state_test.go	2013-10-02 10:39:12 +0000
84
+++ provider/common/state_test.go	2014-01-31 12:32:29 +0000
85
@@ -4,8 +4,10 @@
86
4
package common_test
4
package common_test
87
5
5
88
6
import (
6
import (
89
7
	"bytes"
90
8
	"io/ioutil"
7
	"io/ioutil"
91
8
	"net/http"
92
9
	"net/http/httptest"
93
10
	"path/filepath"
94
9
11
95
10
	gc "launchpad.net/gocheck"
12
	gc "launchpad.net/gocheck"
96
11
	"launchpad.net/goyaml"
13
	"launchpad.net/goyaml"
97
@@ -30,10 +32,26 @@
98
30
	AddCleanup(testbase.CleanupFunc)
32
	AddCleanup(testbase.CleanupFunc)
99
31
}
33
}
100
32
34
103
33
func newStorage(suite cleaner, c *gc.C) storage.Storage {
35
func newStorageWithDataDir(suite cleaner, c *gc.C) (stor storage.Storage, dataDir string) {
104
34
	closer, stor, _ := envtesting.CreateLocalTestStorage(c)
36
	closer, stor, dataDir := envtesting.CreateLocalTestStorage(c)
105
35
	suite.AddCleanup(func(*gc.C) { closer.Close() })
37
	suite.AddCleanup(func(*gc.C) { closer.Close() })
107
36
	return stor
38
	return
108
39
}
109
40
110
41
func newStorage(suite cleaner, c *gc.C) (stor storage.Storage) {
111
42
	stor, _ = newStorageWithDataDir(suite, c)
112
43
	return
113
44
}
114
45
115
46
// testingHTTPServer creates a tempdir backed https server without certs
116
47
func testingHTTPSServer(suite cleaner, c *gc.C) (baseURL string, dataDir string) {
117
48
	dataDir = c.MkDir()
118
49
	mux := http.NewServeMux()
119
50
	mux.Handle("/", http.FileServer(http.Dir(dataDir)))
120
51
	server := httptest.NewTLSServer(mux)
121
52
	suite.AddCleanup(func(*gc.C) { server.Close() })
122
53
	baseURL = server.URL
123
54
	return
124
37
}
55
}
125
38
56
126
39
func (suite *StateSuite) TestCreateStateFileWritesEmptyStateFile(c *gc.C) {
57
func (suite *StateSuite) TestCreateStateFileWritesEmptyStateFile(c *gc.C) {
127
@@ -72,32 +90,49 @@
128
72
	c.Check(content, gc.DeepEquals, marshaledState)
90
	c.Check(content, gc.DeepEquals, marshaledState)
129
73
}
91
}
130
74
92
132
75
func (suite *StateSuite) setUpSavedState(c *gc.C, stor storage.Storage) common.BootstrapState {
93
func (suite *StateSuite) setUpSavedState(c *gc.C, dataDir string) common.BootstrapState {
133
76
	arch := "amd64"
94
	arch := "amd64"
134
77
	state := common.BootstrapState{
95
	state := common.BootstrapState{
135
78
		StateInstances:  []instance.Id{instance.Id("an-instance-id")},
96
		StateInstances:  []instance.Id{instance.Id("an-instance-id")},
136
79
		Characteristics: []instance.HardwareCharacteristics{{Arch: &arch}}}
97
		Characteristics: []instance.HardwareCharacteristics{{Arch: &arch}}}
137
80
	content, err := goyaml.Marshal(state)
98
	content, err := goyaml.Marshal(state)
138
81
	c.Assert(err, gc.IsNil)
99
	c.Assert(err, gc.IsNil)
140
82
	err = stor.Put(common.StateFile, ioutil.NopCloser(bytes.NewReader(content)), int64(len(content)))
100
	err = ioutil.WriteFile(filepath.Join(dataDir, common.StateFile), []byte(content), 0644)
141
83
	c.Assert(err, gc.IsNil)
101
	c.Assert(err, gc.IsNil)
142
84
	return state
102
	return state
143
85
}
103
}
144
86
104
145
87
func (suite *StateSuite) TestLoadStateReadsStateFile(c *gc.C) {
105
func (suite *StateSuite) TestLoadStateReadsStateFile(c *gc.C) {
148
88
	storage := newStorage(suite, c)
106
	storage, dataDir := newStorageWithDataDir(suite, c)
149
89
	state := suite.setUpSavedState(c, storage)
107
	state := suite.setUpSavedState(c, dataDir)
150
90
	storedState, err := common.LoadState(storage)
108
	storedState, err := common.LoadState(storage)
151
91
	c.Assert(err, gc.IsNil)
109
	c.Assert(err, gc.IsNil)
152
92
	c.Check(*storedState, gc.DeepEquals, state)
110
	c.Check(*storedState, gc.DeepEquals, state)
153
93
}
111
}
154
94
112
155
95
func (suite *StateSuite) TestLoadStateFromURLReadsStateFile(c *gc.C) {
113
func (suite *StateSuite) TestLoadStateFromURLReadsStateFile(c *gc.C) {
158
96
	stor := newStorage(suite, c)
114
	stor, dataDir := newStorageWithDataDir(suite, c)
159
97
	state := suite.setUpSavedState(c, stor)
115
	state := suite.setUpSavedState(c, dataDir)
160
98
	url, err := stor.URL(common.StateFile)
116
	url, err := stor.URL(common.StateFile)
161
99
	c.Assert(err, gc.IsNil)
117
	c.Assert(err, gc.IsNil)
163
100
	storedState, err := common.LoadStateFromURL(url)
118
	storedState, err := common.LoadStateFromURL(url, false)
164
119
	c.Assert(err, gc.IsNil)
165
120
	c.Check(*storedState, gc.DeepEquals, state)
166
121
}
167
122
168
123
func (suite *StateSuite) TestLoadStateFromURLBadCert(c *gc.C) {
169
124
	baseURL, _ := testingHTTPSServer(suite, c)
170
125
	url := baseURL + "/" + common.StateFile
171
126
	storedState, err := common.LoadStateFromURL(url, false)
172
127
	c.Assert(err, gc.ErrorMatches, ".*/provider-state:.* certificate signed by unknown authority")
173
128
	c.Assert(storedState, gc.IsNil)
174
129
}
175
130
176
131
func (suite *StateSuite) TestLoadStateFromURLBadCertPermitted(c *gc.C) {
177
132
	baseURL, dataDir := testingHTTPSServer(suite, c)
178
133
	state := suite.setUpSavedState(c, dataDir)
179
134
	url := baseURL + "/" + common.StateFile
180
135
	storedState, err := common.LoadStateFromURL(url, true)
181
101
	c.Assert(err, gc.IsNil)
136
	c.Assert(err, gc.IsNil)
182
102
	c.Check(*storedState, gc.DeepEquals, state)
137
	c.Check(*storedState, gc.DeepEquals, state)
183
103
}
138
}
Reviewer	Review Type	Date Requested	Status
Juju Engineering		2014-01-24	Pending
Review via email: mp+203037@code.launchpad.net