Fixing mode=single upgrades

Author: ewoutp

service/server.go

@@ -589,6 +589,7 @@ func (s *httpServer) shutdownHandler(w http.ResponseWriter, r *http.Request) {
 func (s *httpServer) databaseAutoUpgradeHandler(w http.ResponseWriter, r *http.Request) {
 	// IsRunningMaster returns if the starter is the running master.
 	isRunningMaster, isRunning, masterURL := s.context.IsRunningMaster()
+	_, _, mode := s.context.ClusterConfig()
 
 	if !isRunning {
 		// We must have reached the running state before we can handle this kind of request
@@ -618,7 +619,15 @@ func (s *httpServer) databaseAutoUpgradeHandler(w http.ResponseWriter, r *http.R
 		// Start the upgrade process
 		force, _ := strconv.ParseBool(r.FormValue("force"))
 
-		if !isRunningMaster {
+		if isRunningMaster || mode.IsSingleMode() {
+			// We're the starter leader, process the request
+			if err := s.context.UpgradeManager().StartDatabaseUpgrade(ctx, force); err != nil {
+				handleError(w, err)
+			} else {
+				w.WriteHeader(http.StatusOK)
+				w.Write([]byte("OK"))
+			}
+		} else {
 			// We're not the starter leader.
 			// Forward the request to the leader.
 			c, err := createMasterClient()
@@ -633,14 +642,6 @@ func (s *httpServer) databaseAutoUpgradeHandler(w http.ResponseWriter, r *http.R
 					w.Write([]byte("OK"))
 				}
 			}
-		} else {
-			// We're the starter leader, process the request
-			if err := s.context.UpgradeManager().StartDatabaseUpgrade(ctx, force); err != nil {
-				handleError(w, err)
-			} else {
-				w.WriteHeader(http.StatusOK)
-				w.Write([]byte("OK"))
-			}
 		}
 	case "PUT":
 		// Retry the upgrade process

service/upgrade_manager.go

@@ -489,6 +489,11 @@ func (m *upgradeManager) AbortDatabaseUpgrade(ctx context.Context) error {
 
 // Status returns the current status of the upgrade process.
 func (m *upgradeManager) Status(ctx context.Context) (client.UpgradeStatus, error) {
+	_, _, mode := m.upgradeManagerContext.ClusterConfig()
+	if !mode.HasAgency() {
+		return client.UpgradeStatus{}, maskAny(client.NewPreconditionFailedError("Mode does not support agency based upgrades"))
+	}
+
 	plan, err := m.readUpgradePlan(ctx)
 	if agency.IsKeyNotFound(err) {
 		// No plan, return not found error
@@ -596,7 +601,7 @@ func (m *upgradeManager) fetchBinaryDatabaseVersions(ctx context.Context) ([]dri
 // fetchRunningDatabaseVersions asks all arangod servers in the deployment for their version.
 // It returns all distinct versions.
 func (m *upgradeManager) fetchRunningDatabaseVersions(ctx context.Context) ([]driver.Version, error) {
-	config, _, _ := m.upgradeManagerContext.ClusterConfig()
+	config, _, mode := m.upgradeManagerContext.ClusterConfig()
 	versionMap := make(map[driver.Version]struct{})
 	var versionList []driver.Version
 
@@ -623,17 +628,23 @@ func (m *upgradeManager) fetchRunningDatabaseVersions(ctx context.Context) ([]dr
 		return nil
 	}
 
-	if err := collect(config.GetAgentEndpoints, ConnectionTypeAgency); err != nil {
-		return nil, maskAny(err)
-	}
-	if err := collect(config.GetCoordinatorEndpoints, ConnectionTypeDatabase); err != nil {
-		return nil, maskAny(err)
+	if mode.HasAgency() {
+		if err := collect(config.GetAgentEndpoints, ConnectionTypeAgency); err != nil {
+			return nil, maskAny(err)
+		}
 	}
-	if err := collect(config.GetDBServerEndpoints, ConnectionTypeDatabase); err != nil {
-		return nil, maskAny(err)
+	if mode.IsClusterMode() {
+		if err := collect(config.GetCoordinatorEndpoints, ConnectionTypeDatabase); err != nil {
+			return nil, maskAny(err)
+		}
+		if err := collect(config.GetDBServerEndpoints, ConnectionTypeDatabase); err != nil {
+			return nil, maskAny(err)
+		}
 	}
-	if err := collect(config.GetAllSingleEndpoints, ConnectionTypeDatabase); err != nil {
-		return nil, maskAny(err)
+	if mode.IsSingleMode() || mode.IsActiveFailoverMode() {
+		if err := collect(config.GetAllSingleEndpoints, ConnectionTypeDatabase); err != nil {
+			return nil, maskAny(err)
+		}
 	}
 
 	return versionList, nil
@@ -722,6 +733,11 @@ func (m *upgradeManager) removeUpgradePlan(ctx context.Context) error {
 // RunWatchUpgradePlan keeps watching the upgrade plan in the agency.
 // Once it detects that this starter has to act, it does.
 func (m *upgradeManager) RunWatchUpgradePlan(ctx context.Context) {
+	_, _, mode := m.upgradeManagerContext.ClusterConfig()
+	if !mode.HasAgency() {
+		// Nothing to do here without an agency
+		return
+	}
 	for {
 		delay := time.Second * 10
 		plan, err := m.readUpgradePlan(ctx)

upgrade.go

@@ -137,6 +137,10 @@ func runUpgrade(starterEndpoint string, force, retry bool) {
 	status, err := c.UpgradeStatus(ctx)
 	if err != nil {
 		log.Info().Msgf("Database automatic upgrade has been %s", action)
+		if client.IsPreconditionFailed(err) {
+			log.Info().Msgf("Look at the Starter log to know when the upgrade has finished")
+			return
+		}
 	} else {
 		fromVersions := make([]string, 0, len(status.FromVersions))
 		for _, v := range status.FromVersions {