← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/state/backups/restore_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/state/backups/restore_test.go
 
1
// Copyright 2014 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
// +build !windows
 
5
 
 
6
package backups
 
7
 
 
8
import (
 
9
        "fmt"
 
10
        "io"
 
11
        "net"
 
12
        "os"
 
13
        "path"
 
14
        "strconv"
 
15
        "strings"
 
16
 
 
17
        "github.com/juju/replicaset"
 
18
        gitjujutesting "github.com/juju/testing"
 
19
        jc "github.com/juju/testing/checkers"
 
20
        "github.com/juju/utils/ssh"
 
21
        gc "gopkg.in/check.v1"
 
22
        "gopkg.in/juju/names.v2"
 
23
        "gopkg.in/mgo.v2/bson"
 
24
 
 
25
        "github.com/juju/juju/agent"
 
26
        "github.com/juju/juju/apiserver/params"
 
27
        "github.com/juju/juju/environs"
 
28
        "github.com/juju/juju/mongo/mongotest"
 
29
        "github.com/juju/juju/state"
 
30
        statetesting "github.com/juju/juju/state/testing"
 
31
        coretesting "github.com/juju/juju/testing"
 
32
        jujuversion "github.com/juju/juju/version"
 
33
)
 
34
 
 
35
var _ = gc.Suite(&RestoreSuite{})
 
36
 
 
37
type RestoreSuite struct {
 
38
        coretesting.BaseSuite
 
39
        cwd       string
 
40
        testFiles []string
 
41
}
 
42
 
 
43
func (r *RestoreSuite) SetUpSuite(c *gc.C) {
 
44
        r.BaseSuite.SetUpSuite(c)
 
45
}
 
46
 
 
47
func (r *RestoreSuite) SetUpTest(c *gc.C) {
 
48
        r.cwd = c.MkDir()
 
49
        r.BaseSuite.SetUpTest(c)
 
50
}
 
51
 
 
52
func (r *RestoreSuite) createTestFiles(c *gc.C) {
 
53
        tarDirE := path.Join(r.cwd, "TarDirectoryEmpty")
 
54
        err := os.Mkdir(tarDirE, os.FileMode(0755))
 
55
        c.Check(err, jc.ErrorIsNil)
 
56
 
 
57
        tarDirP := path.Join(r.cwd, "TarDirectoryPopulated")
 
58
        err = os.Mkdir(tarDirP, os.FileMode(0755))
 
59
        c.Check(err, jc.ErrorIsNil)
 
60
 
 
61
        tarSubFile1 := path.Join(tarDirP, "TarSubFile1")
 
62
        tarSubFile1Handle, err := os.Create(tarSubFile1)
 
63
        c.Check(err, jc.ErrorIsNil)
 
64
        tarSubFile1Handle.WriteString("TarSubFile1")
 
65
        tarSubFile1Handle.Close()
 
66
 
 
67
        tarSubDir := path.Join(tarDirP, "TarDirectoryPopulatedSubDirectory")
 
68
        err = os.Mkdir(tarSubDir, os.FileMode(0755))
 
69
        c.Check(err, jc.ErrorIsNil)
 
70
 
 
71
        tarFile1 := path.Join(r.cwd, "TarFile1")
 
72
        tarFile1Handle, err := os.Create(tarFile1)
 
73
        c.Check(err, jc.ErrorIsNil)
 
74
        tarFile1Handle.WriteString("TarFile1")
 
75
        tarFile1Handle.Close()
 
76
 
 
77
        tarFile2 := path.Join(r.cwd, "TarFile2")
 
78
        tarFile2Handle, err := os.Create(tarFile2)
 
79
        c.Check(err, jc.ErrorIsNil)
 
80
        tarFile2Handle.WriteString("TarFile2")
 
81
        tarFile2Handle.Close()
 
82
        r.testFiles = []string{tarDirE, tarDirP, tarFile1, tarFile2}
 
83
}
 
84
 
 
85
func (r *RestoreSuite) TestReplicasetIsReset(c *gc.C) {
 
86
        server := &gitjujutesting.MgoInstance{Params: []string{"--replSet", "juju"}}
 
87
        err := server.Start(coretesting.Certs)
 
88
        c.Assert(err, jc.ErrorIsNil)
 
89
        defer server.DestroyWithLog()
 
90
        mgoAddr := server.Addr()
 
91
        dialInfo := server.DialInfo()
 
92
 
 
93
        var cfg *replicaset.Config
 
94
        dialInfo = server.DialInfo()
 
95
        dialInfo.Addrs = []string{mgoAddr}
 
96
        err = resetReplicaSet(dialInfo, mgoAddr)
 
97
 
 
98
        session, err := server.Dial()
 
99
        c.Assert(err, jc.ErrorIsNil)
 
100
        defer session.Close()
 
101
        cfg, err = replicaset.CurrentConfig(session)
 
102
        c.Assert(err, jc.ErrorIsNil)
 
103
        c.Assert(cfg.Members, gc.HasLen, 1)
 
104
        c.Assert(cfg.Members[0].Address, gc.Equals, mgoAddr)
 
105
}
 
106
 
 
107
type backupConfigTests struct {
 
108
        yamlFile      io.Reader
 
109
        expectedError error
 
110
        message       string
 
111
}
 
112
 
 
113
func (r *RestoreSuite) TestSetAgentAddressScript(c *gc.C) {
 
114
        testServerAddresses := []string{
 
115
                "FirstNewControllerAddress:30303",
 
116
                "SecondNewControllerAddress:30304",
 
117
                "ThirdNewControllerAddress:30305",
 
118
                "FourthNewControllerAddress:30306",
 
119
                "FiftNewControllerAddress:30307",
 
120
                "SixtNewControllerAddress:30308",
 
121
        }
 
122
        for _, address := range testServerAddresses {
 
123
                template := setAgentAddressScript(address)
 
124
                expectedString := fmt.Sprintf("\t\ts/- .*(:[0-9]+)/- %s\\1/\n", address)
 
125
                logger.Infof(fmt.Sprintf("Testing with address %q", address))
 
126
                c.Assert(strings.Contains(template, expectedString), gc.Equals, true)
 
127
        }
 
128
}
 
129
 
 
130
var caCertPEM = `
 
131
-----BEGIN CERTIFICATE-----
 
132
MIIBnTCCAUmgAwIBAgIBADALBgkqhkiG9w0BAQUwJjENMAsGA1UEChMEanVqdTEV
 
133
MBMGA1UEAxMManVqdSB0ZXN0aW5nMB4XDTEyMTExNDE0Mzg1NFoXDTIyMTExNDE0
 
134
NDM1NFowJjENMAsGA1UEChMEanVqdTEVMBMGA1UEAxMManVqdSB0ZXN0aW5nMFow
 
135
CwYJKoZIhvcNAQEBA0sAMEgCQQCCOOpn9aWKcKr2GQGtygwD7PdfNe1I9BYiPAqa
 
136
2I33F5+6PqFdfujUKvoyTJI6XG4Qo/CECaaN9smhyq9DxzMhAgMBAAGjZjBkMA4G
 
137
A1UdDwEB/wQEAwIABDASBgNVHRMBAf8ECDAGAQH/AgEBMB0GA1UdDgQWBBQQDswP
 
138
FQGeGMeTzPbHW62EZbbTJzAfBgNVHSMEGDAWgBQQDswPFQGeGMeTzPbHW62EZbbT
 
139
JzALBgkqhkiG9w0BAQUDQQAqZzN0DqUyEfR8zIanozyD2pp10m9le+ODaKZDDNfH
 
140
8cB2x26F1iZ8ccq5IC2LtQf1IKJnpTcYlLuDvW6yB96g
 
141
-----END CERTIFICATE-----
 
142
`
 
143
 
 
144
func (r *RestoreSuite) TestNewDialInfo(c *gc.C) {
 
145
 
 
146
        cases := []struct {
 
147
                machineTag       string
 
148
                apiPassword      string
 
149
                oldPassword      string
 
150
                expectedPassword string
 
151
                expectedUser     string
 
152
                expectedError    string
 
153
        }{
 
154
                {"machine-0",
 
155
                        "",
 
156
                        "123456",
 
157
                        "123456",
 
158
                        "admin",
 
159
                        "",
 
160
                },
 
161
                {"machine-1",
 
162
                        "123123",
 
163
                        "",
 
164
                        "123123",
 
165
                        "machine-1",
 
166
                        "",
 
167
                },
 
168
        }
 
169
 
 
170
        dataDir := path.Join(r.cwd, "dataDir")
 
171
        err := os.Mkdir(dataDir, os.FileMode(0755))
 
172
        c.Assert(err, jc.ErrorIsNil)
 
173
 
 
174
        logDir := path.Join(r.cwd, "logDir")
 
175
        err = os.Mkdir(logDir, os.FileMode(0755))
 
176
        c.Assert(err, jc.ErrorIsNil)
 
177
        for _, testCase := range cases {
 
178
                machineTag, err := names.ParseTag(testCase.machineTag)
 
179
                c.Assert(err, jc.ErrorIsNil)
 
180
 
 
181
                configParams := agent.AgentConfigParams{
 
182
                        Paths: agent.Paths{
 
183
                                DataDir: dataDir,
 
184
                                LogDir:  logDir,
 
185
                        },
 
186
                        UpgradedToVersion: jujuversion.Current,
 
187
                        Tag:               machineTag,
 
188
                        Model:             coretesting.ModelTag,
 
189
                        Password:          "placeholder",
 
190
                        Nonce:             "dummyNonce",
 
191
                        StateAddresses:    []string{"fakeStateAddress:1234"},
 
192
                        APIAddresses:      []string{"fakeAPIAddress:12345"},
 
193
                        CACert:            caCertPEM,
 
194
                }
 
195
                statePort := 12345
 
196
                privateAddress := "dummyPrivateAddress"
 
197
                servingInfo := params.StateServingInfo{
 
198
                        APIPort:        1234,
 
199
                        StatePort:      statePort,
 
200
                        Cert:           caCertPEM,
 
201
                        CAPrivateKey:   "a ca key",
 
202
                        PrivateKey:     "a key",
 
203
                        SharedSecret:   "a secret",
 
204
                        SystemIdentity: "an identity",
 
205
                }
 
206
 
 
207
                conf, err := agent.NewStateMachineConfig(configParams, servingInfo)
 
208
                c.Assert(err, jc.ErrorIsNil)
 
209
                conf.SetOldPassword(testCase.oldPassword)
 
210
                conf.SetPassword(testCase.apiPassword)
 
211
 
 
212
                dialInfo, err := newDialInfo(privateAddress, conf)
 
213
                if testCase.expectedError != "" {
 
214
                        c.Assert(err, gc.ErrorMatches, testCase.expectedError)
 
215
                } else {
 
216
                        c.Assert(err, jc.ErrorIsNil)
 
217
                        c.Assert(dialInfo.Username, gc.Equals, testCase.expectedUser)
 
218
                        c.Assert(dialInfo.Password, gc.Equals, testCase.expectedPassword)
 
219
                        c.Assert(dialInfo.Direct, gc.Equals, true)
 
220
                        c.Assert(dialInfo.Addrs, gc.DeepEquals, []string{net.JoinHostPort(privateAddress, strconv.Itoa(statePort))})
 
221
                }
 
222
        }
 
223
}
 
224
 
 
225
// TestUpdateMongoEntries has all the testing for this function to avoid creating multiple
 
226
// mongo instances.
 
227
func (r *RestoreSuite) TestUpdateMongoEntries(c *gc.C) {
 
228
        server := &gitjujutesting.MgoInstance{}
 
229
        err := server.Start(coretesting.Certs)
 
230
        c.Assert(err, jc.ErrorIsNil)
 
231
        defer server.DestroyWithLog()
 
232
        dialInfo := server.DialInfo()
 
233
        mgoAddr := server.Addr()
 
234
        dialInfo.Addrs = []string{mgoAddr}
 
235
        err = updateMongoEntries("1234", "0", "0", dialInfo)
 
236
        c.Assert(err, gc.ErrorMatches, "cannot update machine 0 instance information: not found")
 
237
 
 
238
        session, err := server.Dial()
 
239
        c.Assert(err, jc.ErrorIsNil)
 
240
        defer session.Close()
 
241
 
 
242
        err = session.DB("juju").C("machines").Insert(bson.M{"machineid": "0", "instanceid": "0"})
 
243
        c.Assert(err, jc.ErrorIsNil)
 
244
 
 
245
        query := session.DB("juju").C("machines").Find(bson.M{"machineid": "0", "instanceid": "1234"})
 
246
        n, err := query.Count()
 
247
        c.Assert(err, jc.ErrorIsNil)
 
248
        c.Assert(n, gc.Equals, 0)
 
249
 
 
250
        err = updateMongoEntries("1234", "0", "0", dialInfo)
 
251
        c.Assert(err, jc.ErrorIsNil)
 
252
 
 
253
        query = session.DB("juju").C("machines").Find(bson.M{"machineid": "0", "instanceid": "1234"})
 
254
        n, err = query.Count()
 
255
        c.Assert(err, jc.ErrorIsNil)
 
256
        c.Assert(n, gc.Equals, 1)
 
257
}
 
258
 
 
259
func (r *RestoreSuite) TestNewConnection(c *gc.C) {
 
260
        server := &gitjujutesting.MgoInstance{}
 
261
        err := server.Start(coretesting.Certs)
 
262
        c.Assert(err, jc.ErrorIsNil)
 
263
        defer server.DestroyWithLog()
 
264
 
 
265
        st := statetesting.Initialize(c, names.NewLocalUserTag("test-admin"), nil, nil, nil)
 
266
        c.Assert(st.Close(), jc.ErrorIsNil)
 
267
 
 
268
        r.PatchValue(&mongoDefaultDialOpts, mongotest.DialOpts)
 
269
        r.PatchValue(&environsGetNewPolicyFunc, func(
 
270
                func(*state.State) (environs.Environ, error),
 
271
        ) state.NewPolicyFunc {
 
272
                return nil
 
273
        })
 
274
        st, err = newStateConnection(st.ModelTag(), statetesting.NewMongoInfo())
 
275
        c.Assert(err, jc.ErrorIsNil)
 
276
        c.Assert(st.Close(), jc.ErrorIsNil)
 
277
}
 
278
 
 
279
func (r *RestoreSuite) TestRunViaSSH(c *gc.C) {
 
280
        var (
 
281
                passedAddress string
 
282
                passedArgs    []string
 
283
        )
 
284
        fakeSSHCommand := func(address string, args []string, options *ssh.Options) *ssh.Cmd {
 
285
                passedAddress = address
 
286
                passedArgs = args
 
287
                return ssh.Command("", []string{"ls"}, &ssh.Options{})
 
288
        }
 
289
 
 
290
        r.PatchValue(&sshCommand, fakeSSHCommand)
 
291
        runViaSSH("invalidAddress", "invalidScript")
 
292
        c.Assert(passedAddress, gc.Equals, "ubuntu@invalidAddress")
 
293
        c.Assert(passedArgs, gc.DeepEquals, []string{"sudo", "-n", "bash", "-c 'invalidScript'"})
 
294
}