state;apiserver: Fix a race - lp bug #1067979

state/apiserver/client/client_test.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package client_test
 
 import (
         "fmt"
         "net/url"
         "strconv"
         "strings"
@@ skipping 1657 matching lines @@
                 Nonce:      "foo",
                 HardwareCharacteristics: instance.MustParseHardware("arch=amd64"),
         }
         machines, err := s.APIState.Client().AddMachines([]params.AddMachineParams{apiParams})
         c.Assert(err, gc.IsNil)
         c.Assert(len(machines), gc.Equals, 1)
         machineId := machines[0].Machine
         // Call ProvisioningScript. Normally ProvisioningScript and
         // MachineConfig are mutually exclusive; both of them will
         // allocate a state/api password for the machine agent.
-        script, err := s.APIState.Client().ProvisioningScript(machineId, apiParams.Nonce)
+        script, err := s.APIState.Client().ProvisioningScript(params.ProvisioningScriptParams{
+                MachineId: machineId,
+                Nonce:     apiParams.Nonce,
+        })
         c.Assert(err, gc.IsNil)
         mcfg, err := statecmd.MachineConfig(s.State, machineId, apiParams.Nonce, "")
         c.Assert(err, gc.IsNil)
         cloudcfg := coreCloudinit.New()
         err = cloudinit.ConfigureJuju(mcfg, cloudcfg)
         c.Assert(err, gc.IsNil)
         cloudcfg.SetAptUpgrade(false)
         sshinitScript, err := sshinit.ConfigureScript(cloudcfg)
         c.Assert(err, gc.IsNil)
         // ProvisioningScript internally calls MachineConfig,
         // which allocates a new, random password. Everything
         // about the scripts should be the same other than
         // the line containing "oldpassword" from agent.conf.
         scriptLines := strings.Split(script, "\n")
         sshinitScriptLines := strings.Split(sshinitScript, "\n")
         c.Assert(scriptLines, gc.HasLen, len(sshinitScriptLines))
         for i, line := range scriptLines {
                 if strings.Contains(line, "oldpassword") {
                         continue
                 }
                 c.Assert(line, gc.Equals, sshinitScriptLines[i])
         }
 }
 
+func (s *clientSuite) TestProvisioningScriptDisablePackageCommands(c *gc.C) {
+        apiParams := params.AddMachineParams{
+                Jobs:       []params.MachineJob{params.JobHostUnits},
+                InstanceId: instance.Id("1234"),
+                Nonce:      "foo",
+                HardwareCharacteristics: instance.MustParseHardware("arch=amd64"),
+        }
+        machines, err := s.APIState.Client().AddMachines([]params.AddMachineParams{apiParams})
+        c.Assert(err, gc.IsNil)
+        c.Assert(len(machines), gc.Equals, 1)
+        machineId := machines[0].Machine
+        for _, disable := range []bool{false, true} {
+                script, err := s.APIState.Client().ProvisioningScript(params.ProvisioningScriptParams{
+                        MachineId: machineId,
+                        Nonce:     apiParams.Nonce,
+                        DisablePackageCommands: disable,
+                })
+                c.Assert(err, gc.IsNil)
+                var checker gc.Checker = jc.Contains
+                if disable {
+                        // We disabled package commands: there should be no "apt" commands in the script.
+                        checker = gc.Not(checker)
+                }
+                c.Assert(script, checker, "apt-get")
+        }
+}
+
 func (s *clientSuite) TestClientAuthorizeStoreOnDeployServiceSetCharmAndAddCharm(c *gc.C) {
         store, restore := makeMockCharmStore()
         defer restore()
 
         oldConfig, err := s.State.EnvironConfig()
         c.Assert(err, gc.IsNil)
 
         attrs := coretesting.Attrs(oldConfig.AllAttrs())
         attrs = attrs.Merge(coretesting.Attrs{"charm-store-auth": "token=value"})
 
@@ skipping 43 matching lines @@
         c.Assert(err, gc.ErrorMatches, "charm URL must include revision")
 
         // Add a charm, without uploading it to storage, to
         // check that AddCharm does not try to do it.
         charmDir := coretesting.Charms.Dir("dummy")
         ident := fmt.Sprintf("%s-%d", charmDir.Meta().Name, charmDir.Revision())
         curl := charm.MustParseURL("cs:quantal/" + ident)
         bundleURL, err := url.Parse("http://bundles.testing.invalid/" + ident)
         c.Assert(err, gc.IsNil)
         sch, err := s.State.AddCharm(charmDir, curl, bundleURL, ident+"-sha256")
+        c.Assert(err, gc.IsNil)
 
         name := charm.Quote(sch.URL().String())
         storage := s.Conn.Environ.Storage()
         _, err = storage.Get(name)
         c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
 
         // AddCharm should see the charm in state and not upload it.
         err = client.AddCharm(sch.URL())
         c.Assert(err, gc.IsNil)
         _, err = storage.Get(name)
@@ skipping 49 matching lines @@
         // contains the correct data.
         sch, err := s.State.Charm(curl)
         c.Assert(err, gc.IsNil)
         storage, err := envtesting.GetEnvironStorage(s.State)
         c.Assert(err, gc.IsNil)
         uploads, err := storage.List(fmt.Sprintf("%s-%d-", curl.Name, curl.Revision))
         c.Assert(err, gc.IsNil)
         c.Assert(uploads, gc.HasLen, 1)
         c.Assert(getArchiveName(sch.BundleURL()), gc.Equals, uploads[0])
         s.assertUploaded(c, storage, sch.BundleURL(), sch.BundleSha256())
+}
+
+func (s *clientSuite) TestAddCharmOverwritesPlaceholders(c *gc.C) {
+        store, restore := makeMockCharmStore()
+        defer restore()
+
+        client := s.APIState.Client()
+        curl, _ := addCharm(c, store, "wordpress")
+
+        // Add a placeholder with the same charm URL.
+        err := s.State.AddStoreCharmPlaceholder(curl)
+        c.Assert(err, gc.IsNil)
+        _, err = s.State.Charm(curl)
+        c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
+
+        // Now try to add the charm, which will convert the placeholder to
+        // a pending charm.
+        err = client.AddCharm(curl)
+        c.Assert(err, gc.IsNil)
+
+        // Make sure the document's flags were reset as expected.
+        sch, err := s.State.Charm(curl)
+        c.Assert(err, gc.IsNil)
+        c.Assert(sch.URL(), jc.DeepEquals, curl)
+        c.Assert(sch.IsPlaceholder(), jc.IsFalse)
+        c.Assert(sch.IsUploaded(), jc.IsTrue)
+}
+
+func (s *clientSuite) TestCharmArchiveName(c *gc.C) {
+        for rev, name := range []string{"Foo", "bar", "wordpress", "mysql"} {
+                archiveFormat := fmt.Sprintf("%s-%d-[0-9a-f-]+", name, rev)
+                archiveName, err := client.CharmArchiveName(name, rev)
+                c.Check(err, gc.IsNil)
+                c.Check(archiveName, gc.Matches, archiveFormat)
+        }
 }
 
 func (s *clientSuite) assertPutCalled(c *gc.C, ops chan dummy.Operation, numCalls int) {
         calls := 0
         select {
         case op, ok := <-ops:
                 if !ok {
                         return
                 }
                 if op, ok := op.(dummy.OpPutFile); ok {
@@ skipping 17 matching lines @@
         c.Assert(err, gc.IsNil)
         defer reader.Close()
         downloadedSHA256, _, err := utils.ReadSHA256(reader)
         c.Assert(err, gc.IsNil)
         c.Assert(downloadedSHA256, gc.Equals, expectedSHA256)
 }
 
 func getArchiveName(bundleURL *url.URL) string {
         return strings.TrimPrefix(bundleURL.RequestURI(), "/dummyenv/private/")
 }