func (*metadataHelperSuite) TestResolveMetadata(c *gc.C) {
var versionStrings = []string{"1.2.3-precise-amd64"}
dir := c.MkDir()
toolstesting.MakeTools(c, dir, "released", versionStrings)
toolsList := coretools.List{{
Version: version.MustParseBinary(versionStrings[0]),
Size: 123,
SHA256: "abc",
}}
stor, err := filestorage.NewFileStorageReader(dir)
c.Assert(err, jc.ErrorIsNil)
err = tools.ResolveMetadata(stor, "released", nil)
c.Assert(err, jc.ErrorIsNil)
// We already have size/sha256, so ensure that storage isn't consulted.
countingStorage := &countingStorage{StorageReader: stor}
metadata := tools.MetadataFromTools(toolsList, "released")
err = tools.ResolveMetadata(countingStorage, "released", metadata)
c.Assert(err, jc.ErrorIsNil)
c.Assert(countingStorage.counter, gc.Equals, 0)
// Now clear size/sha256, and check that it is called, and
// the size/sha256 sum are updated.
metadata[0].Size = 0
metadata[0].SHA256 = ""
err = tools.ResolveMetadata(countingStorage, "released", metadata)
c.Assert(err, jc.ErrorIsNil)
c.Assert(countingStorage.counter, gc.Equals, 1)
c.Assert(metadata[0].Size, gc.Not(gc.Equals), 0)
c.Assert(metadata[0].SHA256, gc.Not(gc.Equals), "")
}
func (s *PathsSuite) TestOther(c *gc.C) {
s.PatchValue(&os.HostOS, func() os.OSType { return os.Unknown })
dataDir := c.MkDir()
unitTag := names.NewUnitTag("some-service/323")
paths := uniter.NewPaths(dataDir, unitTag)
relData := relPathFunc(dataDir)
relAgent := relPathFunc(relData("agents", "unit-some-service-323"))
c.Assert(paths, jc.DeepEquals, uniter.Paths{
ToolsDir: relData("tools/unit-some-service-323"),
Runtime: uniter.RuntimePaths{
JujuRunSocket: relAgent("run.socket"),
JujucServerSocket: "@" + relAgent("agent.socket"),
},
State: uniter.StatePaths{
BaseDir: relAgent(),
CharmDir: relAgent("charm"),
OperationsFile: relAgent("state", "uniter"),
RelationsDir: relAgent("state", "relations"),
BundlesDir: relAgent("state", "bundles"),
DeployerDir: relAgent("state", "deployer"),
StorageDir: relAgent("state", "storage"),
MetricsSpoolDir: relAgent("state", "spool", "metrics"),
},
})
}
func (s *charmsSuite) TestGetReturnsFileContents(c *gc.C) {
// Add the dummy charm.
ch := testcharms.Repo.CharmArchive(c.MkDir(), "dummy")
_, err := s.uploadRequest(
c, s.charmsURI(c, "?series=quantal"), true, ch.Path)
c.Assert(err, jc.ErrorIsNil)
// Ensure the file contents are properly returned.
for i, t := range []struct {
summary string
file string
response string
}{{
summary: "relative path",
file: "revision",
response: "1",
}, {
summary: "exotic path",
file: "./hooks/../revision",
response: "1",
}, {
summary: "sub-directory path",
file: "hooks/install",
response: "#!/bin/bash\necho \"Done!\"\n",
},
} {
c.Logf("test %d: %s", i, t.summary)
uri := s.charmsURI(c, "?url=local:quantal/dummy-1&file="+t.file)
resp, err := s.authRequest(c, "GET", uri, "", nil)
c.Assert(err, jc.ErrorIsNil)
s.assertGetFileResponse(c, resp, t.response, "text/plain; charset=utf-8")
}
}
func (*SymlinkSuite) TestReplace(c *gc.C) {
target, err := symlink.GetLongPathAsString(c.MkDir())
c.Assert(err, gc.IsNil)
target_second, err := symlink.GetLongPathAsString(c.MkDir())
c.Assert(err, gc.IsNil)
link := filepath.Join(target, "link")
_, err = os.Stat(target)
c.Assert(err, gc.IsNil)
_, err = os.Stat(target_second)
c.Assert(err, gc.IsNil)
err = symlink.New(target, link)
c.Assert(err, gc.IsNil)
link_target, err := symlink.Read(link)
c.Assert(err, gc.IsNil)
c.Assert(link_target, gc.Equals, filepath.FromSlash(target))
err = symlink.Replace(link, target_second)
c.Assert(err, gc.IsNil)
link_target, err = symlink.Read(link)
c.Assert(err, gc.IsNil)
c.Assert(link_target, gc.Equals, filepath.FromSlash(target_second))
}
func (s *ToolsMetadataSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.AddCleanup(dummy.Reset)
cfg, err := config.New(config.UseDefaults, map[string]interface{}{
"name": "erewhemos",
"type": "dummy",
"uuid": coretesting.ModelTag.Id(),
"controller-uuid": coretesting.ControllerTag.Id(),
"conroller": true,
})
c.Assert(err, jc.ErrorIsNil)
env, err := bootstrap.Prepare(
modelcmd.BootstrapContextNoVerify(coretesting.Context(c)),
jujuclienttesting.NewMemStore(),
bootstrap.PrepareParams{
ControllerConfig: coretesting.FakeControllerConfig(),
ControllerName: cfg.Name(),
ModelConfig: cfg.AllAttrs(),
Cloud: dummy.SampleCloudSpec(),
AdminSecret: "admin-secret",
},
)
c.Assert(err, jc.ErrorIsNil)
s.env = env
loggo.GetLogger("").SetLogLevel(loggo.INFO)
// Switch the default tools location.
s.publicStorageDir = c.MkDir()
s.PatchValue(&tools.DefaultBaseURL, s.publicStorageDir)
}
func (s createCharm) step(c *gc.C, ctx *context) {
base := testcharms.Repo.ClonedDirPath(c.MkDir(), "wordpress")
allCharmHooks := baseCharmHooks
allCharmHooks = append(allCharmHooks, leaderCharmHooks...)
allCharmHooks = append(allCharmHooks, storageCharmHooks...)
for _, name := range allCharmHooks {
path := filepath.Join(base, "hooks", name)
good := true
for _, bad := range s.badHooks {
if name == bad {
good = false
}
}
ctx.writeHook(c, path, good)
}
if s.customize != nil {
s.customize(c, ctx, base)
}
dir, err := corecharm.ReadCharmDir(base)
c.Assert(err, jc.ErrorIsNil)
err = dir.SetDiskRevision(s.revision)
c.Assert(err, jc.ErrorIsNil)
step(c, ctx, addCharm{dir, curl(s.revision)})
}
func (s *NewAPIClientSuite) bootstrapEnv(c *gc.C, envName string, store configstore.Storage) {
if store == nil {
store = configstore.NewMem()
}
ctx := envtesting.BootstrapContext(c)
c.Logf("env name: %s", envName)
env, err := environs.PrepareFromName(envName, ctx, store)
c.Assert(err, jc.ErrorIsNil)
storageDir := c.MkDir()
s.PatchValue(&envtools.DefaultBaseURL, storageDir)
stor, err := filestorage.NewFileStorageWriter(storageDir)
c.Assert(err, jc.ErrorIsNil)
envtesting.UploadFakeTools(c, stor, "released", "released")
err = bootstrap.Bootstrap(ctx, env, bootstrap.BootstrapParams{})
c.Assert(err, jc.ErrorIsNil)
info, err := store.ReadInfo(envName)
c.Assert(err, jc.ErrorIsNil)
creds := info.APICredentials()
creds.User = dummy.AdminUserTag().Name()
c.Logf("set creds: %#v", creds)
info.SetAPICredentials(creds)
err = info.Write()
c.Assert(err, jc.ErrorIsNil)
c.Logf("creds: %#v", info.APICredentials())
info, err = store.ReadInfo(envName)
c.Assert(err, jc.ErrorIsNil)
c.Logf("read creds: %#v", info.APICredentials())
c.Logf("store: %#v", store)
}
func (fix *SimpleToolsFixture) SetUp(c *gc.C, dataDir string) {
fix.dataDir = dataDir
fix.logDir = c.MkDir()
current := version.Binary{
Number: version.Current,
Arch: arch.HostArch(),
Series: series.HostSeries(),
}
toolsDir := tools.SharedToolsDir(fix.dataDir, current)
err := os.MkdirAll(toolsDir, 0755)
c.Assert(err, jc.ErrorIsNil)
jujudPath := filepath.Join(toolsDir, "jujud")
err = ioutil.WriteFile(jujudPath, []byte(fakeJujud), 0755)
c.Assert(err, jc.ErrorIsNil)
toolsPath := filepath.Join(toolsDir, "downloaded-tools.txt")
testTools := coretools.Tools{Version: current, URL: "http://testing.invalid/tools"}
data, err := json.Marshal(testTools)
c.Assert(err, jc.ErrorIsNil)
err = ioutil.WriteFile(toolsPath, data, 0644)
c.Assert(err, jc.ErrorIsNil)
fix.binDir = c.MkDir()
fix.origPath = os.Getenv("PATH")
os.Setenv("PATH", fix.binDir+":"+fix.origPath)
fix.makeBin(c, "status", `echo "blah stop/waiting"`)
fix.makeBin(c, "stopped-status", `echo "blah stop/waiting"`)
fix.makeBin(c, "started-status", `echo "blah start/running, process 666"`)
fix.makeBin(c, "start", "cp $(which started-status) $(which status)")
fix.makeBin(c, "stop", "cp $(which stopped-status) $(which status)")
fix.data = svctesting.NewFakeServiceData()
}
func (s *CharmSuite) SetUpTest(c *gc.C) {
s.Server = charmstoretesting.OpenServer(c, s.jcSuite.Session, charmstore.ServerParams{
AuthUsername: "******",
AuthPassword: "******",
})
urls := []string{
"~who/quantal/mysql-23",
"~who/quantal/dummy-24",
"~who/quantal/riak-25",
"~who/quantal/wordpress-26",
"~who/quantal/logging-27",
}
for _, url := range urls {
id := charm.MustParseReference(url)
ch := testcharms.Repo.CharmArchive(c.MkDir(), id.Name)
s.Server.UploadCharm(c, ch, id, true)
}
s.jcSuite.PatchValue(&charmrepo.CacheDir, c.MkDir())
// Patch the charm repo initializer function: it is replaced with a charm
// store repo pointing to the testing server.
s.jcSuite.PatchValue(&charmrevisionupdater.NewCharmStore, func(p charmrepo.NewCharmStoreParams) charmrepo.Interface {
p.URL = s.Server.URL()
return charmrepo.NewCharmStore(p)
})
s.charms = make(map[string]*state.Charm)
}
func (s *UpgradeJujuSuite) setUpEnvAndTools(c *gc.C, currentVersion string, agentVersion string, tools []string) {
current := version.MustParseBinary(currentVersion)
s.PatchValue(&jujuversion.Current, current.Number)
s.PatchValue(&arch.HostArch, func() string { return current.Arch })
s.PatchValue(&series.HostSeries, func() string { return current.Series })
toolsDir := c.MkDir()
updateAttrs := map[string]interface{}{
"agent-version": agentVersion,
"agent-metadata-url": "file://" + toolsDir + "/tools",
}
err := s.State.UpdateModelConfig(updateAttrs, nil, nil)
c.Assert(err, jc.ErrorIsNil)
versions := make([]version.Binary, len(tools))
for i, v := range tools {
versions[i], err = version.ParseBinary(v)
if err != nil {
c.Assert(err, jc.Satisfies, series.IsUnknownOSForSeriesError)
}
}
if len(versions) > 0 {
stor, err := filestorage.NewFileStorageWriter(toolsDir)
c.Assert(err, jc.ErrorIsNil)
envtesting.MustUploadFakeToolsVersions(stor, s.Environ.Config().AgentStream(), versions...)
}
}
func (s *cmdControllerSuite) TestControllerLoginCommand(c *gc.C) {
user := s.Factory.MakeUser(c, &factory.UserParams{
NoEnvUser: true,
Password: "******",
})
apiInfo := s.APIInfo(c)
serverFile := envcmd.ServerFile{
Addresses: apiInfo.Addrs,
CACert: apiInfo.CACert,
Username: user.Name(),
Password: "******",
}
serverFilePath := filepath.Join(c.MkDir(), "server.yaml")
content, err := goyaml.Marshal(serverFile)
c.Assert(err, jc.ErrorIsNil)
err = ioutil.WriteFile(serverFilePath, []byte(content), 0644)
c.Assert(err, jc.ErrorIsNil)
s.run(c, "login", "--server", serverFilePath, "just-a-controller")
// Make sure that the saved server details are sufficient to connect
// to the api server.
api, err := juju.NewAPIFromName("just-a-controller", nil)
c.Assert(err, jc.ErrorIsNil)
api.Close()
}
func (s *metadataHelperSuite) TestReadWriteMetadataUnchanged(c *gc.C) {
metadata := map[string][]*tools.ToolsMetadata{
"released": {{
Release: "precise",
Version: "1.2.3",
Arch: "amd64",
Path: "path1",
}, {
Release: "raring",
Version: "1.2.3",
Arch: "amd64",
Path: "path2",
}},
}
stor, err := filestorage.NewFileStorageWriter(c.MkDir())
c.Assert(err, jc.ErrorIsNil)
err = tools.WriteMetadata(stor, metadata, []string{"released"}, tools.DoNotWriteMirrors)
c.Assert(err, jc.ErrorIsNil)
s.PatchValue(tools.WriteMetadataFiles, func(stor storage.Storage, metadataInfo []tools.MetadataFile) error {
// The product data is the same, we only write the indices.
c.Assert(metadataInfo, gc.HasLen, 2)
c.Assert(metadataInfo[0].Path, gc.Equals, "streams/v1/index2.json")
c.Assert(metadataInfo[1].Path, gc.Equals, "streams/v1/index.json")
return nil
})
err = tools.WriteMetadata(stor, metadata, []string{"released"}, tools.DoNotWriteMirrors)
c.Assert(err, jc.ErrorIsNil)
}
func (*metadataHelperSuite) writeMetadataMultipleStream(c *gc.C) (storage.StorageReader, map[string][]*tools.ToolsMetadata) {
metadata := map[string][]*tools.ToolsMetadata{
"released": {{
Release: "precise",
Version: "1.2.3",
Arch: "amd64",
Path: "path1",
}},
"proposed": {{
Release: "raring",
Version: "1.2.3",
Arch: "amd64",
Path: "path2",
}},
}
stor, err := filestorage.NewFileStorageWriter(c.MkDir())
c.Assert(err, jc.ErrorIsNil)
out, err := tools.ReadAllMetadata(stor)
c.Assert(out, gc.HasLen, 0)
c.Assert(err, jc.ErrorIsNil) // non-existence is not an error
err = tools.WriteMetadata(stor, metadata, []string{"released", "proposed"}, tools.DoNotWriteMirrors)
c.Assert(err, jc.ErrorIsNil)
return stor, metadata
}
func (*metadataHelperSuite) TestReadWriteMetadataSingleStream(c *gc.C) {
metadata := map[string][]*tools.ToolsMetadata{
"released": {{
Release: "precise",
Version: "1.2.3",
Arch: "amd64",
Path: "path1",
}, {
Release: "raring",
Version: "1.2.3",
Arch: "amd64",
Path: "path2",
}},
}
stor, err := filestorage.NewFileStorageWriter(c.MkDir())
c.Assert(err, jc.ErrorIsNil)
out, err := tools.ReadAllMetadata(stor)
c.Assert(err, jc.ErrorIsNil) // non-existence is not an error
c.Assert(out, gc.HasLen, 0)
err = tools.WriteMetadata(stor, metadata, []string{"released"}, tools.DoNotWriteMirrors)
c.Assert(err, jc.ErrorIsNil)
// Read back what was just written.
out, err = tools.ReadAllMetadata(stor)
c.Assert(err, jc.ErrorIsNil)
for _, outMetadata := range out {
for _, md := range outMetadata {
// FullPath is set by ReadAllMetadata.
c.Assert(md.FullPath, gc.Not(gc.Equals), "")
md.FullPath = ""
}
}
c.Assert(out, jc.DeepEquals, metadata)
}
func (s *charmsSuite) TestUploadBumpsRevision(c *gc.C) {
// Add the dummy charm with revision 1.
ch := testcharms.Repo.CharmArchive(c.MkDir(), "dummy")
curl := charm.MustParseURL(
fmt.Sprintf("local:quantal/%s-%d", ch.Meta().Name, ch.Revision()),
)
info := state.CharmInfo{
Charm: ch,
ID: curl,
StoragePath: "dummy-storage-path",
SHA256: "dummy-1-sha256",
}
_, err := s.State.AddCharm(info)
c.Assert(err, jc.ErrorIsNil)
// Now try uploading the same revision and verify it gets bumped,
// and the BundleSha256 is calculated.
resp := s.uploadRequest(c, s.charmsURI(c, "?series=quantal"), "application/zip", ch.Path)
expectedURL := charm.MustParseURL("local:quantal/dummy-2")
s.assertUploadResponse(c, resp, expectedURL.String())
sch, err := s.State.Charm(expectedURL)
c.Assert(err, jc.ErrorIsNil)
c.Assert(sch.URL(), gc.DeepEquals, expectedURL)
c.Assert(sch.Revision(), gc.Equals, 2)
c.Assert(sch.IsUploaded(), jc.IsTrue)
// No more checks for the hash here, because it is
// verified in TestUploadRespectsLocalRevision.
c.Assert(sch.BundleSha256(), gc.Not(gc.Equals), "")
}
// PatchExecutable creates an executable called 'execName' in a new test
// directory and that directory is added to the path.
func PatchExecutable(c *gc.C, patcher CleanupPatcher, execName, script string, exitCodes ...int) {
dir := c.MkDir()
patcher.PatchEnvironment("PATH", joinPathLists(dir, os.Getenv("PATH")))
var filename string
switch runtime.GOOS {
case "windows":
filename = filepath.Join(dir, execName+".bat")
default:
filename = filepath.Join(dir, execName)
}
os.Remove(filename + ".out")
err := ioutil.WriteFile(filename, []byte(script), 0755)
c.Assert(err, gc.IsNil)
if len(exitCodes) > 0 {
filename = execName + ".exitcodes"
codes := make([]string, len(exitCodes))
for i, code := range exitCodes {
codes[i] = strconv.Itoa(code)
}
s := strings.Join(codes, ";") + ";"
err = ioutil.WriteFile(filename, []byte(s), 0644)
c.Assert(err, gc.IsNil)
patcher.AddCleanup(func(*gc.C) {
os.Remove(filename)
})
}
}
func (s *charmsSuite) TestGetWorksForControllerMachines(c *gc.C) {
// Make a controller machine.
const nonce = "noncey"
m, password := s.Factory.MakeMachineReturningPassword(c, &factory.MachineParams{
Jobs: []state.MachineJob{state.JobManageModel},
Nonce: nonce,
})
// Create a hosted model and upload a charm for it.
envState := s.setupOtherModel(c)
ch := testcharms.Repo.CharmArchive(c.MkDir(), "dummy")
s.uploadRequest(c, s.charmsURI(c, "?series=quantal"), "application/zip", ch.Path)
// Controller machine should be able to download the charm from
// the hosted model. This is required for controller workers which
// are acting on behalf of a particular hosted model.
url := s.charmsURL(c, "url=local:quantal/dummy-1&file=revision")
url.Path = fmt.Sprintf("/model/%s/charms", envState.ModelUUID())
params := httpRequestParams{
method: "GET",
url: url.String(),
tag: m.Tag().String(),
password: password,
nonce: nonce,
}
resp := s.sendRequest(c, params)
s.assertGetFileResponse(c, resp, "1", "text/plain; charset=utf-8")
}
func (s *lxcBrokerSuite) startInstancePopulatesNetworkInfo(c *gc.C) (*environs.StartInstanceResult, error) {
s.PatchValue(provisioner.InterfaceAddrs, func(i *net.Interface) ([]net.Addr, error) {
return []net.Addr{&fakeAddr{"0.1.2.1/24"}}, nil
})
fakeResolvConf := filepath.Join(c.MkDir(), "resolv.conf")
err := ioutil.WriteFile(fakeResolvConf, []byte("nameserver ns1.dummy\nnameserver ns2.dummy\nsearch dummy\n"), 0644)
c.Assert(err, jc.ErrorIsNil)
s.PatchValue(provisioner.ResolvConf, fakeResolvConf)
instanceConfig := s.instanceConfig(c, "42")
possibleTools := coretools.List{&coretools.Tools{
Version: version.MustParseBinary("2.3.4-quantal-amd64"),
URL: "http://tools.testing.invalid/2.3.4-quantal-amd64.tgz",
}}
callback := func(settableStatus status.Status, info string, data map[string]interface{}) error {
return nil
}
return s.broker.StartInstance(environs.StartInstanceParams{
Constraints: constraints.Value{},
Tools: possibleTools,
InstanceConfig: instanceConfig,
StatusCallback: callback,
})
}
func (s *tmpfsSuite) SetUpTest(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("Tests relevant only on *nix systems")
}
s.BaseSuite.SetUpTest(c)
s.storageDir = c.MkDir()
}
func (s *lxcBrokerSuite) TestLocalDNSServers(c *gc.C) {
fakeConf := filepath.Join(c.MkDir(), "resolv.conf")
s.PatchValue(provisioner.ResolvConf, fakeConf)
// If config is missing, that's OK.
dnses, dnsSearch, err := provisioner.LocalDNSServers()
c.Assert(err, jc.ErrorIsNil)
c.Assert(dnses, gc.HasLen, 0)
c.Assert(dnsSearch, gc.Equals, "")
// Enter some data in fakeConf.
data := `
anything else is ignored
# comments are ignored
nameserver 0.1.2.3 # that's parsed
search foo.baz # comment ignored
# nameserver 42.42.42.42 - ignored as well
nameserver 8.8.8.8
nameserver example.com # comment after is ok
`
err = ioutil.WriteFile(fakeConf, []byte(data), 0644)
c.Assert(err, jc.ErrorIsNil)
dnses, dnsSearch, err = provisioner.LocalDNSServers()
c.Assert(err, jc.ErrorIsNil)
c.Assert(dnses, jc.DeepEquals, network.NewAddresses(
"0.1.2.3", "8.8.8.8", "example.com",
))
c.Assert(dnsSearch, gc.Equals, "foo.baz")
}
func (cs *NewAPIStateSuite) TestNewAPIState(c *gc.C) {
cfg, err := config.New(config.NoDefaults, dummy.SampleConfig())
c.Assert(err, jc.ErrorIsNil)
ctx := envtesting.BootstrapContext(c)
env, err := environs.Prepare(cfg, ctx, configstore.NewMem())
c.Assert(err, jc.ErrorIsNil)
storageDir := c.MkDir()
cs.PatchValue(&envtools.DefaultBaseURL, storageDir)
stor, err := filestorage.NewFileStorageWriter(storageDir)
c.Assert(err, jc.ErrorIsNil)
envtesting.UploadFakeTools(c, stor, "released", "released")
err = bootstrap.Bootstrap(ctx, env, bootstrap.BootstrapParams{})
c.Assert(err, jc.ErrorIsNil)
cfg = env.Config()
cfg, err = cfg.Apply(map[string]interface{}{
"secret": "fnord",
})
c.Assert(err, jc.ErrorIsNil)
err = env.SetConfig(cfg)
c.Assert(err, jc.ErrorIsNil)
st, err := juju.NewAPIState(dummy.AdminUserTag(), env, api.DialOpts{})
c.Assert(st, gc.NotNil)
// the secrets will not be updated, as they already exist
attrs, err := st.Client().EnvironmentGet()
c.Assert(attrs["secret"], gc.Equals, "pork")
c.Assert(st.Close(), gc.IsNil)
}
func (s *lxcBrokerSuite) SetUpTest(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("Skipping lxc tests on windows")
}
s.lxcSuite.SetUpTest(c)
var err error
s.agentConfig, err = agent.NewAgentConfig(
agent.AgentConfigParams{
Paths: agent.NewPathsWithDefaults(agent.Paths{DataDir: "/not/used/here"}),
Tag: names.NewMachineTag("1"),
UpgradedToVersion: jujuversion.Current,
Password: "******",
Nonce: "nonce",
APIAddresses: []string{"10.0.0.1:1234"},
CACert: coretesting.CACert,
Model: coretesting.ModelTag,
})
c.Assert(err, jc.ErrorIsNil)
managerConfig := container.ManagerConfig{
container.ConfigName: "juju",
"log-dir": c.MkDir(),
"use-clone": "false",
}
s.api = NewFakeAPI()
s.broker, err = provisioner.NewLxcBroker(s.api, s.agentConfig, managerConfig, nil, false, 0)
c.Assert(err, jc.ErrorIsNil)
}
func (s *ToolsMetadataSuite) TestGenerateWithMirrors(c *gc.C) {
metadataDir := c.MkDir()
toolstesting.MakeTools(c, metadataDir, "released", versionStrings)
ctx := coretesting.Context(c)
code := cmd.Main(newToolsMetadataCommand(), ctx, []string{"--public", "-d", metadataDir, "--stream", "released"})
c.Assert(code, gc.Equals, 0)
output := ctx.Stdout.(*bytes.Buffer).String()
mirrosTmpl := expectedOutputCommon + `
.*Writing tools/streams/v1/index2\.json
.*Writing tools/streams/v1/index\.json
.*Writing tools/streams/v1/com\.ubuntu\.juju-{{.Stream}}-tools\.json
.*Writing tools/streams/v1/mirrors\.json
`
expectedOutput := makeExpectedOutput(mirrosTmpl, "released", "released")
c.Check(output, gc.Matches, expectedOutput)
metadata := toolstesting.ParseMetadataFromDir(c, metadataDir, "released", true)
c.Check(metadata, gc.HasLen, len(versionStrings))
obtainedVersionStrings := make([]string, len(versionStrings))
for i, metadata := range metadata {
s := fmt.Sprintf("%s-%s-%s", metadata.Version, metadata.Release, metadata.Arch)
obtainedVersionStrings[i] = s
}
c.Assert(obtainedVersionStrings, gc.DeepEquals, versionStrings)
}
func (s *stateSuite) TestCommitHook(c *gc.C) {
dir := c.MkDir()
state, err := storage.ReadStateFile(dir, names.NewStorageTag("data/0"))
c.Assert(err, jc.ErrorIsNil)
c.Assert(state, gc.NotNil)
stateFile := filepath.Join(dir, "data-0")
// CommitHook must be idempotent, so test each operation
// twice in a row.
for i := 0; i < 2; i++ {
err := state.CommitHook(hook.Info{
Kind: hooks.StorageAttached,
StorageId: "data-0",
})
c.Assert(err, jc.ErrorIsNil)
c.Assert(stateFile, jc.IsNonEmptyFile)
}
for i := 0; i < 2; i++ {
err := state.CommitHook(hook.Info{
Kind: hooks.StorageDetaching,
StorageId: "data-0",
})
c.Assert(err, jc.ErrorIsNil)
c.Assert(stateFile, jc.DoesNotExist)
}
}
func (s *PathsSuite) TestWorkerPathsWindows(c *gc.C) {
s.PatchValue(&os.HostOS, func() os.OSType { return os.Windows })
dataDir := c.MkDir()
unitTag := names.NewUnitTag("some-service/323")
worker := "some-worker"
paths := uniter.NewWorkerPaths(dataDir, unitTag, worker)
relData := relPathFunc(dataDir)
relAgent := relPathFunc(relData("agents", "unit-some-service-323"))
c.Assert(paths, jc.DeepEquals, uniter.Paths{
ToolsDir: relData("tools/unit-some-service-323"),
Runtime: uniter.RuntimePaths{
JujuRunSocket: `\\.\pipe\unit-some-service-323-some-worker-run`,
JujucServerSocket: `\\.\pipe\unit-some-service-323-some-worker-agent`,
},
State: uniter.StatePaths{
BaseDir: relAgent(),
CharmDir: relAgent("charm"),
OperationsFile: relAgent("state", "uniter"),
RelationsDir: relAgent("state", "relations"),
BundlesDir: relAgent("state", "bundles"),
DeployerDir: relAgent("state", "deployer"),
StorageDir: relAgent("state", "storage"),
MetricsSpoolDir: relAgent("state", "spool", "metrics"),
},
})
}
func (s *stateSuite) TestReadAllStateFilesOneBadApple(c *gc.C) {
dir := c.MkDir()
writeFile(c, filepath.Join(dir, "data-0"), "rubbish")
_, err := storage.ReadAllStateFiles(dir)
c.Assert(err, gc.ErrorMatches, `cannot load storage state from ".*": cannot load storage "data/0" state from ".*": invalid storage state file ".*": yaml: unmarshal errors:
`+" line 1: cannot unmarshal !!str `rubbish` into storage.diskInfo")
}
func (s *DirectorySuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
s.containerDir = c.MkDir()
s.PatchValue(&container.ContainerDir, s.containerDir)
s.removedDir = c.MkDir()
s.PatchValue(&container.RemovedContainerDir, s.removedDir)
}
func (s *metadataSuite) TestBuildMetadata(c *gc.C) {
archive, err := os.Create(filepath.Join(c.MkDir(), "juju-backup.tgz"))
c.Assert(err, jc.ErrorIsNil)
_, err = archive.Write([]byte("<compressed data>"))
c.Assert(err, jc.ErrorIsNil)
fi, err := archive.Stat()
c.Assert(err, jc.ErrorIsNil)
finished := backups.FileTimestamp(fi).Unix()
meta, err := backups.BuildMetadata(archive)
c.Assert(err, jc.ErrorIsNil)
c.Check(meta.ID(), gc.Equals, "")
c.Check(meta.Checksum(), gc.Equals, "2jmj7l5rSw0yVb/vlWAYkK/YBwk=")
c.Check(meta.ChecksumFormat(), gc.Equals, "SHA-1, base64 encoded")
c.Check(meta.Size(), gc.Equals, int64(17))
c.Check(meta.Stored(), gc.IsNil)
c.Check(meta.Started.Unix(), gc.Equals, int64(time.Time{}.Unix()))
c.Check(meta.Finished.Unix(), gc.Equals, finished)
c.Check(meta.Notes, gc.Equals, "")
c.Check(meta.Origin.Environment, gc.Equals, backups.UnknownString)
c.Check(meta.Origin.Machine, gc.Equals, backups.UnknownString)
c.Check(meta.Origin.Hostname, gc.Equals, backups.UnknownString)
c.Check(meta.Origin.Version.String(), gc.Equals, backups.UnknownVersion.String())
}
func (s *charmsSuite) TestGetUsesCache(c *gc.C) {
// Add a fake charm archive in the cache directory.
cacheDir := filepath.Join(s.DataDir(), "charm-get-cache")
err := os.MkdirAll(cacheDir, 0755)
c.Assert(err, jc.ErrorIsNil)
// Create and save a bundle in it.
charmDir := testcharms.Repo.ClonedDir(c.MkDir(), "dummy")
testPath := filepath.Join(charmDir.Path, "utils.js")
contents := "// blah blah"
err = ioutil.WriteFile(testPath, []byte(contents), 0755)
c.Assert(err, jc.ErrorIsNil)
var buffer bytes.Buffer
err = charmDir.ArchiveTo(&buffer)
c.Assert(err, jc.ErrorIsNil)
charmArchivePath := filepath.Join(
cacheDir, charm.Quote("local:trusty/django-42")+".zip")
err = ioutil.WriteFile(charmArchivePath, buffer.Bytes(), 0644)
c.Assert(err, jc.ErrorIsNil)
// Ensure the cached contents are properly retrieved.
uri := s.charmsURI(c, "?url=local:trusty/django-42&file=utils.js")
resp, err := s.authRequest(c, "GET", uri, "", nil)
c.Assert(err, jc.ErrorIsNil)
s.assertGetFileResponse(c, resp, contents, "application/javascript")
}
func (s *simplestreamsSuite) assertWriteMetadata(c *gc.C, withMirrors bool) {
var versionStrings = []string{
"1.2.3-precise-amd64",
"2.0.1-raring-amd64",
}
dir := c.MkDir()
toolstesting.MakeTools(c, dir, "proposed", versionStrings)
toolsList := coretools.List{
{
// If sha256/size is already known, do not recalculate
Version: version.MustParseBinary("1.2.3-precise-amd64"),
Size: 123,
SHA256: "abcd",
}, {
Version: version.MustParseBinary("2.0.1-raring-amd64"),
// The URL is not used for generating metadata.
URL: "bogus://",
},
}
writer, err := filestorage.NewFileStorageWriter(dir)
c.Assert(err, jc.ErrorIsNil)
writeMirrors := tools.DoNotWriteMirrors
if withMirrors {
writeMirrors = tools.WriteMirrors
}
err = tools.MergeAndWriteMetadata(writer, "proposed", "proposed", toolsList, writeMirrors)
c.Assert(err, jc.ErrorIsNil)
metadata := toolstesting.ParseMetadataFromDir(c, dir, "proposed", withMirrors)
assertMetadataMatches(c, dir, "proposed", toolsList, metadata)
// No release stream generated so there will not be a legacy index file created.
_, err = writer.Get("tools/streams/v1/index.json")
c.Assert(err, gc.NotNil)
}