func (s *MongoSuite) TestInstallSuccessMongodCentOS(c *gc.C) {
type installs struct {
series string
pkg string
}
test := installs{
"centos7", "mongodb*",
}
testing.PatchExecutableAsEchoArgs(c, s, "yum")
testing.PatchExecutableAsEchoArgs(c, s, "chcon")
testing.PatchExecutableAsEchoArgs(c, s, "semanage")
dataDir := c.MkDir()
s.patchSeries(test.series)
err := mongo.EnsureServer(makeEnsureServerParams(dataDir))
c.Assert(err, jc.ErrorIsNil)
expected := append(expectedArgs.YumBase, "epel-release")
testing.AssertEchoArgs(c, "yum", expected...)
testing.AssertEchoArgs(c, "chcon", expectedArgs.Chcon...)
testing.AssertEchoArgs(c, "semanage", expectedArgs.Semanage...)
}
func (s *lxcBrokerSuite) TestSetupRoutesAndIPTablesAddsRuleIfMissing(c *gc.C) {
// Isolate the test from the host machine. Because PatchExecutable
// does not allow us to assert on subsequent executions of the
// same binary, we need to replace the iptables commands with
// separate ones. The check returns code=1 to trigger calling
// add.
fakeptablesRules := map[string]provisioner.IptablesRule{
"IPTablesSNAT": {
"nat",
"POSTROUTING",
"{{.HostIF}} {{.HostIP}}",
},
}
s.PatchValue(provisioner.IptablesRules, fakeptablesRules)
gitjujutesting.PatchExecutableAsEchoArgs(c, s, "iptables", 1, 0)
gitjujutesting.PatchExecutableAsEchoArgs(c, s, "ip")
ifaceInfo := []network.InterfaceInfo{{
Address: network.NewAddress("0.1.2.3"),
}}
addr := network.NewAddress("0.1.2.1")
err := provisioner.SetupRoutesAndIPTables("nic", addr, "bridge", ifaceInfo, false)
c.Assert(err, jc.ErrorIsNil)
// Now verify the expected commands - since check returns 1, add
// will be called before ip route add.
gitjujutesting.AssertEchoArgs(c, "iptables", "-t", "nat", "-C", "POSTROUTING", "nic", "0.1.2.1")
gitjujutesting.AssertEchoArgs(c, "iptables", "-t", "nat", "-I", "POSTROUTING", "1", "nic", "0.1.2.1")
gitjujutesting.AssertEchoArgs(c, "ip", "route", "add", "0.1.2.3", "dev", "bridge")
}
func (s *MongoSuite) TestAddPPAInQuantal(c *gc.C) {
testing.PatchExecutableAsEchoArgs(c, s, "apt-get")
testing.PatchExecutableAsEchoArgs(c, s, "add-apt-repository")
s.patchSeries("quantal")
dataDir := c.MkDir()
err := mongo.EnsureServer(makeEnsureServerParams(dataDir))
c.Assert(err, jc.ErrorIsNil)
pack := [][]string{
{
"install",
"python-software-properties",
}, {
"install",
"--target-release",
"mongodb-server",
},
}
noCommand := len(expectedArgs.AptGetBase) - 1
for k := range pack {
cmd := append(expectedArgs.AptGetBase[:noCommand], pack[k]...)
testing.AssertEchoArgs(c, "apt-get", cmd...)
}
match := []string{
"--yes",
"\"ppa:juju/stable\"",
}
testing.AssertEchoArgs(c, "add-apt-repository", match...)
}
// Test that the call to SyncImages utilizes the defined source
func (s *LibVertSuite) TestSyncImagesUtilizesSimpleStreamsSource(c *gc.C) {
const simpStreamsBinName = "uvt-simplestreams-libvirt"
testing.PatchExecutableAsEchoArgs(c, s, simpStreamsBinName)
const (
series = "mocked-series"
arch = "mocked-arch"
source = "mocked-url"
)
err := kvm.SyncImages(series, arch, source)
c.Assert(err, jc.ErrorIsNil)
expectedArgs := strings.Split(
fmt.Sprintf(
"sync arch=%s release=%s --source=%s",
arch,
series,
source,
),
" ",
)
testing.AssertEchoArgs(c, simpStreamsBinName, expectedArgs...)
}
func (s *cmdSuite) TestPatchExecutableNoArgs(c *gc.C) {
s.EnsureArgFileRemoved(testFunc)
testing.PatchExecutableAsEchoArgs(c, s, testFunc)
output := runCommand(c, testFunc)
c.Assert(output, gc.Equals, testFunc+"\n")
testing.AssertEchoArgs(c, testFunc)
}
func (s *KVMSuite) TestStartContainerUtilizesSimpleStream(c *gc.C) {
const libvirtBinName = "uvt-simplestreams-libvirt"
testing.PatchExecutableAsEchoArgs(c, s, libvirtBinName)
startParams := kvm.StartParams{
Series: "mocked-series",
Arch: "mocked-arch",
ImageDownloadUrl: "mocked-url",
}
mockedContainer := kvm.NewEmptyKvmContainer()
mockedContainer.Start(startParams)
expectedArgs := strings.Split(
fmt.Sprintf(
"sync arch=%s release=%s --source=%s",
startParams.Arch,
startParams.Series,
startParams.ImageDownloadUrl,
),
" ",
)
testing.AssertEchoArgs(c, libvirtBinName, expectedArgs...)
}
func (s *KVMSuite) TestCreateMachineUsesTemplate(c *gc.C) {
const uvtKvmBinName = "uvt-kvm"
testing.PatchExecutableAsEchoArgs(c, s, uvtKvmBinName)
tempDir := c.MkDir()
params := kvm.CreateMachineParams{
Hostname: "foo-bar",
NetworkBridge: "br0",
Interfaces: []network.InterfaceInfo{
{MACAddress: "00:16:3e:20:b0:11"},
},
UserDataFile: filepath.Join(tempDir, "something"),
}
err := kvm.CreateMachine(params)
c.Assert(err, jc.ErrorIsNil)
expectedArgs := []string{
"create",
"--log-console-output",
"--user-data",
filepath.Join(tempDir, "something"),
"--template",
filepath.Join(tempDir, "kvm-template.xml"),
"foo-bar",
}
testing.AssertEchoArgs(c, uvtKvmBinName, expectedArgs...)
}
func (s *MongoSuite) TestInstallMongod(c *gc.C) {
type installs struct {
series string
cmd [][]string
}
tests := []installs{
{"precise", [][]string{{"--target-release", "precise-updates/cloud-tools", "mongodb-server"}}},
{"quantal", [][]string{{"python-software-properties"}, {"--target-release", "mongodb-server"}}},
{"raring", [][]string{{"--target-release", "mongodb-server"}}},
{"saucy", [][]string{{"--target-release", "mongodb-server"}}},
{"trusty", [][]string{{"juju-mongodb"}}},
{"u-series", [][]string{{"juju-mongodb"}}},
}
testing.PatchExecutableAsEchoArgs(c, s, "add-apt-repository")
testing.PatchExecutableAsEchoArgs(c, s, "apt-get")
for _, test := range tests {
dataDir := c.MkDir()
namespace := "namespace" + test.series
s.patchSeries(test.series)
err := mongo.EnsureServer(makeEnsureServerParams(dataDir, namespace))
c.Assert(err, jc.ErrorIsNil)
for _, cmd := range test.cmd {
match := append(expectedArgs.AptGetBase, cmd...)
testing.AssertEchoArgs(c, "apt-get", match...)
}
}
}
func (s *MongoSuite) TestInstallMongod(c *gc.C) {
type installs struct {
series string
cmd [][]string
}
tests := []installs{
{"precise", [][]string{{"--target-release", "precise-updates/cloud-tools", "mongodb-server"}}},
{"trusty", [][]string{{"juju-mongodb3.2"}, {"juju-mongo-tools3.2"}}},
{"wily", [][]string{{"juju-mongodb3.2"}, {"juju-mongo-tools3.2"}}},
{"xenial", [][]string{{"juju-mongodb3.2"}, {"juju-mongo-tools3.2"}}},
}
testing.PatchExecutableAsEchoArgs(c, s, "add-apt-repository")
testing.PatchExecutableAsEchoArgs(c, s, "apt-get")
for _, test := range tests {
c.Logf("install for series %v", test.series)
dataDir := c.MkDir()
s.patchSeries(test.series)
err := mongo.EnsureServer(makeEnsureServerParams(dataDir))
c.Assert(err, jc.ErrorIsNil)
for _, cmd := range test.cmd {
match := append(expectedArgs.AptGetBase, cmd...)
testing.AssertEchoArgs(c, "apt-get", match...)
}
}
}
func (s *cmdSuite) TestPatchExecutableWithArgs(c *gc.C) {
s.EnsureArgFileRemoved(testFunc)
testing.PatchExecutableAsEchoArgs(c, s, testFunc)
output := runCommand(c, testFunc, "foo", "bar baz")
c.Assert(output, gc.Equals, testFunc+" \"foo\" \"bar baz\"\n")
testing.AssertEchoArgs(c, testFunc, "foo", "bar baz")
}
func (s *RebootSuite) TestShutdownNoContainers(c *gc.C) {
w, err := reboot.NewRebootWaiter(s.st, s.acfg)
c.Assert(err, jc.ErrorIsNil)
expectedShutdownParams := s.shutdownCommandParams(c)
err = w.ExecuteReboot(params.ShouldShutdown)
c.Assert(err, jc.ErrorIsNil)
testing.AssertEchoArgs(c, rebootBin, expectedShutdownParams...)
}
func (s *RebootSuite) TestRebootNoContainers(c *gc.C) {
w, err := reboot.NewRebootWaiter(s.st, s.acfg)
c.Assert(err, jc.ErrorIsNil)
expectedRebootParams := s.rebootCommandParams(c)
err = w.ExecuteReboot(params.ShouldReboot)
c.Assert(err, jc.ErrorIsNil)
testing.AssertEchoArgs(c, rebootBin, expectedRebootParams...)
ft.File{s.rebootScriptName, expectedRebootScript, 0755}.Check(c, s.tmpDir)
}
func (s *cmdSuite) TestPatchExecutableWithArgs(c *gc.C) {
s.EnsureArgFileRemoved(testFunc)
testing.PatchExecutableAsEchoArgs(c, s, testFunc)
output := runCommand(c, testFunc, "foo", "bar baz")
output = strings.TrimRight(output, "\r\n")
c.Assert(output, gc.DeepEquals, testFunc+" 'foo' 'bar baz'")
testing.AssertEchoArgs(c, testFunc, "foo", "bar baz")
}
func (s *cmdSuite) TestPatchExecutableWithArgs(c *gc.C) {
s.EnsureArgFileRemoved(testFunc)
testing.PatchExecutableAsEchoArgs(c, s, testFunc)
output := runCommand(c, testFunc, "foo", "bar baz")
switch runtime.GOOS {
case "windows":
c.Assert(output, gc.Equals, testFunc+" \"foo\" \"bar baz\"\r\n")
default:
c.Assert(output, gc.Equals, testFunc+" \"foo\" \"bar baz\"\n")
}
testing.AssertEchoArgs(c, testFunc, "foo", "bar baz")
}
func (s *MongoSuite) TestAddEpelInCentOS(c *gc.C) {
testing.PatchExecutableAsEchoArgs(c, s, "yum")
s.patchSeries("centos7")
testing.PatchExecutableAsEchoArgs(c, s, "chcon")
testing.PatchExecutableAsEchoArgs(c, s, "semanage")
dataDir := c.MkDir()
err := mongo.EnsureServer(makeEnsureServerParams(dataDir, ""))
c.Assert(err, jc.ErrorIsNil)
expectedEpelRelease := append(expectedArgs.YumBase, "epel-release")
testing.AssertEchoArgs(c, "yum", expectedEpelRelease...)
expectedMongodbServer := append(expectedArgs.YumBase, "mongodb-server")
testing.AssertEchoArgs(c, "yum", expectedMongodbServer...)
testing.AssertEchoArgs(c, "chcon", expectedArgs.Chcon...)
testing.AssertEchoArgs(c, "semanage", expectedArgs.Semanage...)
}
func (s *adminSuite) TestEnsureAdminUser(c *gc.C) {
inst := &gitjujutesting.MgoInstance{}
err := inst.Start(coretesting.Certs)
c.Assert(err, gc.IsNil)
defer inst.DestroyWithLog()
dialInfo := inst.DialInfo()
// Mock out mongod, so the --noauth execution doesn't
// do anything nasty. Also mock out the Signal method.
gitjujutesting.PatchExecutableAsEchoArgs(c, s, "mongod")
mongodDir := filepath.SplitList(os.Getenv("PATH"))[0]
s.PatchValue(&mongo.JujuMongodPath, filepath.Join(mongodDir, "mongod"))
s.PatchValue(mongo.ProcessSignal, func(*os.Process, os.Signal) error {
return nil
})
// First call succeeds, as there are no users yet.
added, err := s.ensureAdminUser(c, dialInfo, "whomever", "whatever")
c.Assert(err, gc.IsNil)
c.Assert(added, jc.IsTrue)
// EnsureAdminUser should have stopped the mongo service,
// started a new mongod with --noauth, and then finally
// started the service back up.
c.Assert(s.serviceStarts, gc.Equals, 1)
c.Assert(s.serviceStops, gc.Equals, 1)
_, portString, err := net.SplitHostPort(dialInfo.Addrs[0])
c.Assert(err, gc.IsNil)
gitjujutesting.AssertEchoArgs(c, "mongod",
"--noauth",
"--dbpath", "db",
"--sslOnNormalPorts",
"--sslPEMKeyFile", "server.pem",
"--sslPEMKeyPassword", "ignored",
"--bind_ip", "127.0.0.1",
"--port", portString,
"--noprealloc",
"--syslog",
"--smallfiles",
"--journal",
)
// Second call succeeds, as the admin user is already there.
added, err = s.ensureAdminUser(c, dialInfo, "whomever", "whatever")
c.Assert(err, gc.IsNil)
c.Assert(added, jc.IsFalse)
// There should have been no additional start/stop.
c.Assert(s.serviceStarts, gc.Equals, 1)
c.Assert(s.serviceStops, gc.Equals, 1)
}
func (s *InitialiserSuite) TestLXDInitZFS(c *gc.C) {
// Patch df so it always returns 100GB
df100 := func(path string) (uint64, error) {
return 100 * 1024 * 1024 * 1024, nil
}
s.PatchValue(&df, df100)
container := NewContainerInitialiser("xenial")
err := container.Initialise()
c.Assert(err, jc.ErrorIsNil)
testing.AssertEchoArgs(c, "lxd", "init", "--auto", "--storage-backend",
"zfs", "--storage-pool", "lxd", "--storage-create-loop", "90")
}
func (s *RebootSuite) TestRebootWithContainers(c *gc.C) {
testing.PatchExecutable(c, s, "lxc-ls", lxcLsScript)
testing.PatchExecutable(c, s, "lxc-info", lxcInfoScript)
expectedRebootParams := s.rebootCommandParams(c)
s.PatchValue(reboot.Timeout, time.Duration(5*time.Second))
w, err := reboot.NewRebootWaiter(s.st, s.acfg)
c.Assert(err, jc.ErrorIsNil)
err = w.ExecuteReboot(params.ShouldReboot)
c.Assert(err, jc.ErrorIsNil)
testing.AssertEchoArgs(c, rebootBin, expectedRebootParams...)
ft.File{s.rebootScriptName, expectedRebootScript, 0755}.Check(c, s.tmpDir)
}
func (s *SetIPAndARPForwardingSuite) TestSuccess(c *gc.C) {
// NOTE: Because PatchExecutableAsEchoArgs does not allow us to
// assert on earlier invocations of the same binary (each run
// overwrites the last args used), we only check sysctl was called
// for the second key (arpProxySysctlKey). We do check the config
// contains both though.
fakeConfig := filepath.Join(c.MkDir(), "sysctl.conf")
testing.PatchExecutableAsEchoArgs(c, s, "sysctl")
s.PatchValue(provisioner.SysctlConfig, fakeConfig)
err := provisioner.SetIPAndARPForwarding(true)
c.Assert(err, jc.ErrorIsNil)
expectConf := fmt.Sprintf(
"%s=1\n%s=1",
provisioner.IPForwardSysctlKey,
provisioner.ARPProxySysctlKey,
)
AssertFileContains(c, fakeConfig, expectConf)
expectKeyVal := fmt.Sprintf("%s=1", provisioner.IPForwardSysctlKey)
testing.AssertEchoArgs(c, "sysctl", "-w", expectKeyVal)
expectKeyVal = fmt.Sprintf("%s=1", provisioner.ARPProxySysctlKey)
testing.AssertEchoArgs(c, "sysctl", "-w", expectKeyVal)
err = provisioner.SetIPAndARPForwarding(false)
c.Assert(err, jc.ErrorIsNil)
expectConf = fmt.Sprintf(
"%s=0\n%s=0",
provisioner.IPForwardSysctlKey,
provisioner.ARPProxySysctlKey,
)
AssertFileContains(c, fakeConfig, expectConf)
expectKeyVal = fmt.Sprintf("%s=0", provisioner.IPForwardSysctlKey)
testing.AssertEchoArgs(c, "sysctl", "-w", expectKeyVal)
expectKeyVal = fmt.Sprintf("%s=0", provisioner.ARPProxySysctlKey)
testing.AssertEchoArgs(c, "sysctl", "-w", expectKeyVal)
}