many: expose installing components while refreshing

client/snap_op.go

@@ -162,12 +162,12 @@ func (client *Client) RemoveMany(names []string, components map[string][]string,
 
 // Refresh refreshes the snap with the given name (switching it to track
 // the given channel if given).
-func (client *Client) Refresh(name string, options *SnapOptions) (changeID string, err error) {
-	return client.doSnapAction("refresh", name, nil, options)
+func (client *Client) Refresh(name string, components []string, options *SnapOptions) (changeID string, err error) {
+	return client.doSnapAction("refresh", name, components, options)
 }
 
-func (client *Client) RefreshMany(names []string, options *SnapOptions) (changeID string, err error) {
-	return client.doMultiSnapAction("refresh", names, nil, options)
+func (client *Client) RefreshMany(names []string, components map[string][]string, options *SnapOptions) (changeID string, err error) {
+	return client.doMultiSnapAction("refresh", names, components, options)
 }
 
 func (client *Client) HoldRefreshes(name string, options *SnapOptions) (changeID string, err error) {

client/snap_op_test.go

@@ -48,7 +48,12 @@ var ops = []struct {
 		},
 		action: "install",
 	},
-	{(*client.Client).Refresh, "refresh"},
+	{
+		op: func(c *client.Client, name string, options *client.SnapOptions) (string, error) {
+			return c.Refresh(name, nil, options)
+		},
+		action: "refresh",
+	},
 	{
 		op: func(c *client.Client, name string, options *client.SnapOptions) (string, error) {
 			return c.Remove(name, nil, options)
@@ -67,7 +72,12 @@ var multiOps = []struct {
 	op     func(*client.Client, []string, *client.SnapOptions) (string, error)
 	action string
 }{
-	{(*client.Client).RefreshMany, "refresh"},
+	{
+		op: func(c *client.Client, names []string, options *client.SnapOptions) (string, error) {
+			return c.RefreshMany(names, nil, options)
+		},
+		action: "refresh",
+	},
 	{
 		op: func(c *client.Client, names []string, options *client.SnapOptions) (string, error) {
 			return c.InstallMany(names, nil, options)
@@ -874,7 +884,7 @@ func (cs *clientSuite) TestClientRefreshWithValidationSets(c *check.C) {
 	}`
 
 	sets := []string{"foo/bar=2", "foo/baz"}
-	chgID, err := cs.cli.RefreshMany(nil, &client.SnapOptions{
+	chgID, err := cs.cli.RefreshMany(nil, nil, &client.SnapOptions{
 		ValidationSets: sets,
 	})
 	c.Assert(err, check.IsNil)
@@ -957,6 +967,10 @@ func (cs *clientSuite) TestClientOpInstallWithComponents(c *check.C) {
 	cs.testClientOpWithComponents(c, cs.cli.Install)
 }
 
+func (cs *clientSuite) TestClientOpRefreshWithComponents(c *check.C) {
+	cs.testClientOpWithComponents(c, cs.cli.Refresh)
+}
+
 func (cs *clientSuite) TestClientOpRemoveWithComponents(c *check.C) {
 	cs.testClientOpWithComponents(c, cs.cli.Remove)
 }
@@ -991,6 +1005,10 @@ func (cs *clientSuite) TestClientOpInstallManyWithComponents(c *check.C) {
 	cs.testClientOpManyWithComponents(c, cs.cli.InstallMany)
 }
 
+func (cs *clientSuite) TestClientOpRefreshManyWithComponents(c *check.C) {
+	cs.testClientOpManyWithComponents(c, cs.cli.RefreshMany)
+}
+
 func (cs *clientSuite) TestClientOpRemoveManyWithComponents(c *check.C) {
 	cs.testClientOpManyWithComponents(c, cs.cli.RemoveMany)
 }

cmd/snap/cmd_snap_op.go

@@ -929,7 +929,13 @@
 }
 
 func (x *cmdRefresh) refreshMany(snaps []string, opts *client.SnapOptions) error {
-	changeID, err := x.client.RefreshMany(snaps, opts)
+	const forInstall = true
+	names, compsBySnap, err := snapInstancesAndComponentsFromNames(snaps, forInstall)
+	if err != nil {
+		return err
+	}
+
+	changeID, err := x.client.RefreshMany(names, compsBySnap, opts)
 	if err != nil {
 		return err
 	}
@@ -958,9 +964,14 @@
 }
 
 func (x *cmdRefresh) refreshOne(name string, opts *client.SnapOptions) error {
-	changeID, err := x.client.Refresh(name, opts)
+	snapName, comps := snap.SplitSnapInstanceAndComponents(name)
+	if name == "" {
+		return errors.New(i18n.G("no snap for the component(s) was specified"))
+	}
+
+	changeID, err := x.client.Refresh(snapName, comps, opts)
 	if err != nil {
-		msg, err := errorToCmdMessage(name, "refresh", err, opts)
+		msg, err := errorToCmdMessage(snapName, "refresh", err, opts)
 		if err != nil {
 			return err
 		}
@@ -978,7 +989,7 @@
 
 	// TODO: this doesn't really tell about all the things you
 	// could set while refreshing (something switch does)
-	return showDone(x.client, chg, &changedSnapsData{names: []string{name}, comps: nil}, "refresh", opts, x.getEscapes())
+	return showDone(x.client, chg, &changedSnapsData{names: []string{snapName}, comps: nil}, "refresh", opts, x.getEscapes())
 }
 
 func parseSysinfoTime(s string) time.Time {

cmd/snap/cmd_snap_op_test.go

@@ -144,6 +144,83 @@ func (t *snapOpTestServer) handle(w http.ResponseWriter, r *http.Request) {
 	t.n++
 }
 
+func multiHandler(c *check.C, snaps []string, snapToComps map[string][]string, checker func(*http.Request), calls int) http.HandlerFunc {
+	var n int
+	return func(w http.ResponseWriter, r *http.Request) {
+		switch n {
+		case 0:
+			checker(r)
+			method := "POST"
+			c.Check(r.Method, check.Equals, method)
+			w.WriteHeader(202)
+			fmt.Fprintln(w, `{"type":"async", "change": "42", "status-code": 202}`)
+		case 1:
+			c.Check(r.Method, check.Equals, "GET")
+			c.Check(r.URL.Path, check.Equals, "/v2/changes/42")
+			fmt.Fprintln(w, `{"type": "sync", "result": {"status": "Doing"}}`)
+		case 2:
+			c.Check(r.Method, check.Equals, "GET")
+			c.Check(r.URL.Path, check.Equals, "/v2/changes/42")
+			var data struct {
+				SnapNames  []string            `json:"snap-names,omitempty"`
+				Components map[string][]string `json:"components,omitempty"`
+			}
+
+			data.Components = snapToComps
+			data.SnapNames = snaps
+
+			encoded, err := json.Marshal(data)
+			c.Assert(err, check.IsNil)
+
+			fmt.Fprintf(w, `{"type": "sync", "result": {"ready": true, "status": "Done", "data": %s}}\n`, string(encoded))
+		case 3:
+			c.Check(r.Method, check.Equals, "GET")
+			c.Check(r.URL.Path, check.Equals, "/v2/snaps")
+
+			var results []interface{}
+			for _, snap := range snaps {
+				result := map[string]interface{}{
+					"name":      snap,
+					"status":    "active",
+					"version":   "1.0",
+					"developer": "bar",
+					"publisher": map[string]interface{}{
+						"id":           "bar-id",
+						"username":     "bar",
+						"display-name": "Bar",
+						"validation":   "unproven",
+					},
+					"revision":         42,
+					"channel":          "latest/stable",
+					"tracking-channel": "latest/stable",
+					"confinement":      "strict",
+				}
+
+				comps := make([]map[string]string, 0, len(snapToComps[snap]))
+				for _, comp := range snapToComps[snap] {
+					comps = append(comps, map[string]string{"name": comp, "version": "3.2"})
+				}
+
+				if len(comps) > 0 {
+					result["components"] = comps
+				}
+
+				results = append(results, result)
+			}
+
+			err := json.NewEncoder(w).Encode(map[string]interface{}{
+				"type":   "sync",
+				"result": results,
+			})
+			c.Assert(err, check.IsNil)
+		default:
+			c.Fatalf("expected to get %d requests, now on %d", calls, n+1)
+		}
+
+		n++
+	}
+}
+
 type SnapOpSuite struct {
 	BaseSnapSuite
 
@@ -2260,7 +2337,51 @@ func (s *SnapOpSuite) TestRefreshOne(c *check.C) {
 	_, err := snap.Parser(snap.Client()).ParseArgs([]string{"refresh", "foo"})
 	c.Assert(err, check.IsNil)
 	c.Check(s.Stdout(), check.Matches, `(?sm).*foo 1.0 from Bar refreshed`)
+}
+
+func (s *SnapOpSuite) TestRefreshOneAdditionalComponents(c *check.C) {
+	s.RedirectClientToTestServer(s.srv.handle)
+	s.srv.checker = func(r *http.Request) {
+		c.Check(r.Method, check.Equals, "POST")
+		c.Check(r.URL.Path, check.Equals, "/v2/snaps/foo")
+		c.Check(DecodedRequestBody(c, r), check.DeepEquals, map[string]interface{}{
+			"action":      "refresh",
+			"transaction": string(client.TransactionPerSnap),
+			"components":  []interface{}{"comp1", "comp2"},
+		})
+	}
+	_, err := snap.Parser(snap.Client()).ParseArgs([]string{"refresh", "foo+comp1+comp2"})
+	c.Assert(err, check.IsNil)
+	c.Check(s.Stdout(), check.Matches, `(?sm).*foo 1.0 from Bar refreshed`)
+}
+
+func (s *SnapOpSuite) TestRefreshManyAdditionalComponents(c *check.C) {
+	checker := func(r *http.Request) {
+		c.Check(r.Method, check.Equals, "POST")
+		c.Check(r.URL.Path, check.Equals, "/v2/snaps")
+		c.Check(DecodedRequestBody(c, r), check.DeepEquals, map[string]interface{}{
+			"action":      "refresh",
+			"transaction": string(client.TransactionPerSnap),
+			"snaps":       []interface{}{"foo", "bar"},
+			"components": map[string]interface{}{
+				"foo": []interface{}{"comp1", "comp2"},
+				"bar": []interface{}{"comp3", "comp4"},
+			},
+		})
+	}
 
+	s.RedirectClientToTestServer(multiHandler(c, []string{"foo", "bar"}, map[string][]string{
+		"foo": {"comp1", "comp2"},
+		"bar": {"comp3", "comp4"},
+	}, checker, 3))
+	_, err := snap.Parser(snap.Client()).ParseArgs([]string{"refresh", "foo+comp1+comp2", "bar+comp3+comp4"})
+	c.Assert(err, check.IsNil)
+	c.Check(s.Stdout(), check.Matches, `(?sm).*foo 1.0 from Bar refreshed`)
+	c.Check(s.Stdout(), check.Matches, `(?sm).*bar 1.0 from Bar refreshed`)
+	c.Check(s.Stdout(), check.Matches, `(?sm).*component comp1 3.2 for foo 1.0 refreshed`)
+	c.Check(s.Stdout(), check.Matches, `(?sm).*component comp2 3.2 for foo 1.0 refreshed`)
+	c.Check(s.Stdout(), check.Matches, `(?sm).*component comp3 3.2 for bar 1.0 refreshed`)
+	c.Check(s.Stdout(), check.Matches, `(?sm).*component comp4 3.2 for bar 1.0 refreshed`)
 }
 
 func (s *SnapOpSuite) TestRefreshOneSwitchChannel(c *check.C) {

cmd/snap/cmd_validate.go

@@ -126,7 +126,7 @@ func (cmd *cmdValidate) Execute(args []string) error {
 		}
 
 		if cmd.Refresh {
-			changeID, err := cmd.client.RefreshMany(nil, &client.SnapOptions{
+			changeID, err := cmd.client.RefreshMany(nil, nil, &client.SnapOptions{
 				ValidationSets: []string{cmd.Positional.ValidationSet},
 			})
 			if err != nil {

daemon/api.go

@@ -150,8 +150,9 @@ var (
 	snapstateInstallComponents              = snapstate.InstallComponents
 	snapstateRefreshCandidates              = snapstate.RefreshCandidates
 	snapstateTryPath                        = snapstate.TryPath
-	snapstateUpdate                         = snapstate.Update
-	snapstateUpdateMany                     = snapstate.UpdateMany
+	snapstateStoreUpdateGoal                = snapstate.StoreUpdateGoal
+	snapstateUpdateWithGoal                 = snapstate.UpdateWithGoal
+	snapstateUpdateOne                      = snapstate.UpdateOne
 	snapstateRemove                         = snapstate.Remove
 	snapstateRemoveMany                     = snapstate.RemoveMany
 	snapstateResolveValSetsEnforcementError = snapstate.ResolveValidationSetsEnforcementError

daemon/api_base_test.go

@@ -259,6 +259,7 @@ func (s *apiBaseSuite) SetUpTest(c *check.C) {
 	}))
 
 	s.AddCleanup(daemon.MockSnapstateStoreInstallGoal(newStoreInstallGoalRecorder))
+	s.AddCleanup(daemon.MockSnapstateStoreUpdateGoal(newStoreUpdateGoalRecorder))
 }
 
 type storeInstallGoalRecorder struct {
@@ -273,6 +274,26 @@ func newStoreInstallGoalRecorder(snaps ...snapstate.StoreSnap) snapstate.Install
 	}
 }
 
+type storeUpdateGoalRecorder struct {
+	snapstate.UpdateGoal
+	snaps []snapstate.StoreUpdate
+}
+
+func (s *storeUpdateGoalRecorder) names() []string {
+	names := make([]string, 0, len(s.snaps))
+	for _, snap := range s.snaps {
+		names = append(names, snap.InstanceName)
+	}
+	return names
+}
+
+func newStoreUpdateGoalRecorder(snaps ...snapstate.StoreUpdate) snapstate.UpdateGoal {
+	return &storeUpdateGoalRecorder{
+		snaps:      snaps,
+		UpdateGoal: snapstate.StoreUpdateGoal(snaps...),
+	}
+}
+
 func (s *apiBaseSuite) mockModel(st *state.State, model *asserts.Model) {
 	// realistic model setup
 	if model == nil {
@@ -402,6 +423,9 @@ func newFakeSnapManager(st *state.State, runner *state.TaskRunner) *fakeSnapMana
 	runner.AddHandler("fake-install-snap-error", func(t *state.Task, _ *tomb.Tomb) error {
 		return fmt.Errorf("fake-install-snap-error errored")
 	}, nil)
+	runner.AddHandler("fake-refresh-snap", func(t *state.Task, _ *tomb.Tomb) error {
+		return nil
+	}, nil)
 
 	return &fakeSnapManager{}
 }