overlord/snapstate: warn of refresh/postpone events

overlord/snapstate/autorefresh.go

@@ -482,12 +482,19 @@ func getTime(st *state.State, timeKey string) (time.Time, error) {
 // that period the refresh will go ahead despite application activity.
 func inhibitRefresh(st *state.State, snapst *SnapState, info *snap.Info, checker func(*snap.Info) error) error {
 	if err := checker(info); err != nil {
+		days := int(maxInhibition.Truncate(time.Hour).Hours() / 24)
 		now := time.Now()
 		if snapst.RefreshInhibitedTime == nil {
 			// Store the instant when the snap was first inhibited.
 			// This is reset to nil on successful refresh.
 			snapst.RefreshInhibitedTime = &now
 			Set(st, info.InstanceName(), snapst)
+			if _, ok := err.(*BusySnapError); ok {
+				st.Warnf(i18n.NG(
+					"snap %q is currently in use. Its refresh will be postponed for up to %d day to wait for the snap to no longer be in use.",
+					"snap %q is currently in use. Its refresh will be postponed for up to %d days to wait for the snap to no longer be in use.", days),
+					info.SnapName(), days)
+			}
 			return err
 		}
 
@@ -496,6 +503,12 @@ func inhibitRefresh(st *state.State, snapst *SnapState, info *snap.Info, checker
 			// the error but don't change the snap state again.
 			return err
 		}
+		if _, ok := err.(*BusySnapError); ok {
+			st.Warnf(i18n.NG(
+				"snap %q has been running for the maximum allowable %d day since its refresh was postponed. It will now be refreshed.",
+				"snap %q has been running for the maximum allowable %d days since its refresh was postponed. It will now be refreshed.", days),
+				info.SnapName(), days)
+		}
 	}
 	return nil
 }

overlord/snapstate/autorefresh_test.go

@@ -652,3 +652,47 @@ func (s *autoRefreshTestSuite) TestRefreshOnMeteredConnNotMetered(c *C) {
 	c.Check(err, IsNil)
 	c.Check(s.store.ops, DeepEquals, []string{"list-refresh"})
 }
+
+func (s *autoRefreshTestSuite) TestInhibitRefreshWithinInhibitWindow(c *C) {
+	s.state.Lock()
+	defer s.state.Unlock()
+
+	si := &snap.SideInfo{RealName: "pkg", Revision: snap.R(1)}
+	info := &snap.Info{SideInfo: *si}
+	snapst := &snapstate.SnapState{
+		Sequence: []*snap.SideInfo{si},
+		Current:  si.Revision,
+	}
+	err := snapstate.InhibitRefresh(s.state, snapst, info, func(si *snap.Info) error {
+		return &snapstate.BusySnapError{SnapName: "pkg"}
+	})
+	c.Assert(err, ErrorMatches, `snap "pkg" has running apps or hooks`)
+
+	pending, _ := s.state.PendingWarnings()
+	c.Assert(pending, HasLen, 1)
+	c.Check(pending[0].String(), Equals, `snap "pkg" is currently in use. Its refresh will be postponed for up to 7 days to wait for the snap to no longer be in use.`)
+}
+
+func (s *autoRefreshTestSuite) TestInhibitRefreshWarnsAndRefreshesWhenOverdue(c *C) {
+	s.state.Lock()
+	defer s.state.Unlock()
+
+	instant := time.Now()
+	pastInstant := instant.Add(-snapstate.MaxInhibition * 2)
+
+	si := &snap.SideInfo{RealName: "pkg", Revision: snap.R(1)}
+	info := &snap.Info{SideInfo: *si}
+	snapst := &snapstate.SnapState{
+		Sequence:             []*snap.SideInfo{si},
+		Current:              si.Revision,
+		RefreshInhibitedTime: &pastInstant,
+	}
+	err := snapstate.InhibitRefresh(s.state, snapst, info, func(si *snap.Info) error {
+		return &snapstate.BusySnapError{SnapName: "pkg"}
+	})
+	c.Assert(err, IsNil)
+
+	pending, _ := s.state.PendingWarnings()
+	c.Assert(pending, HasLen, 1)
+	c.Check(pending[0].String(), Equals, `snap "pkg" has been running for the maximum allowable 7 days since its refresh was postponed. It will now be refreshed.`)
+}

overlord/snapstate/export_test.go

@@ -224,3 +224,9 @@ var (
 func (m *SnapManager) MaybeUndoRemodelBootChanges(t *state.Task) error {
 	return m.maybeUndoRemodelBootChanges(t)
 }
+
+// autorefresh
+var (
+	InhibitRefresh = inhibitRefresh
+	MaxInhibition  = maxInhibition
+)

overlord/snapstate/refresh.go

@@ -93,7 +93,7 @@ func genericRefreshCheck(info *snap.Info, canAppRunDuringRefresh func(app *snap.
 	sort.Strings(busyHookNames)
 	sort.Ints(busyPIDs)
 	return &BusySnapError{
-		snapName:      info.SnapName(),
+		SnapName:      info.SnapName(),
 		busyAppNames:  busyAppNames,
 		busyHookNames: busyHookNames,
 		pids:          busyPIDs,
@@ -137,7 +137,7 @@ func HardNothingRunningRefreshCheck(info *snap.Info) error {
 
 // BusySnapError indicates that snap has apps or hooks running and cannot refresh.
 type BusySnapError struct {
-	snapName      string
+	SnapName      string
 	pids          []int
 	busyAppNames  []string
 	busyHookNames []string
@@ -148,15 +148,15 @@ func (err *BusySnapError) Error() string {
 	switch {
 	case len(err.busyAppNames) > 0 && len(err.busyHookNames) > 0:
 		return fmt.Sprintf("snap %q has running apps (%s) and hooks (%s)",
-			err.snapName, strings.Join(err.busyAppNames, ", "), strings.Join(err.busyHookNames, ", "))
+			err.SnapName, strings.Join(err.busyAppNames, ", "), strings.Join(err.busyHookNames, ", "))
 	case len(err.busyAppNames) > 0:
 		return fmt.Sprintf("snap %q has running apps (%s)",
-			err.snapName, strings.Join(err.busyAppNames, ", "))
+			err.SnapName, strings.Join(err.busyAppNames, ", "))
 	case len(err.busyHookNames) > 0:
 		return fmt.Sprintf("snap %q has running hooks (%s)",
-			err.snapName, strings.Join(err.busyHookNames, ", "))
+			err.SnapName, strings.Join(err.busyHookNames, ", "))
 	default:
-		return fmt.Sprintf("snap %q has running apps or hooks", err.snapName)
+		return fmt.Sprintf("snap %q has running apps or hooks", err.SnapName)
 	}
 }