Delete the push and the declaration: the send stub and node holds, link declare and its order, the sent readers, and the sweep judged by compositions (release 6, issue 1945 B8)

internal/link/serve.go

@@ -292,26 +292,6 @@ func (s *Server) giveUpAfter() time.Duration {
 	return s.giveUp
 }
 
-// outstanding is the digest of the declaration the mesh last sent a node.
-//
-// Nothing is guessed when it cannot be answered: a listener that keeps no record of what was sent
-// gives a report nothing to be stale against, and a store that cannot be read will hold the report
-// anyway, so there is nothing for the check to decide.
-func (s *Server) outstanding(ctx context.Context, node string) string {
-	if node == "" {
-		return ""
-	}
-	asks, ok := s.listener.(Outstanding)
-	if !ok {
-		return ""
-	}
-	digest, err := asks.Outstanding(ctx, node)
-	if err != nil {
-		return ""
-	}
-	return digest
-}
-
 // toolsHeartbeat records that a machine's node tools were heard from (novox/hq to-be 45 S11), and
 // nothing else: in this process's memory, for the watchdog — the next one is a minute away.
 func (s *Server) toolsHeartbeat(m Control) {
@@ -343,25 +323,8 @@ func (s *Server) reported(ctx context.Context, m Control) {
 	what := fmt.Sprintf("%s's report of declaration %s", report.Node, report.Declared)
 
 	if s.listener != nil {
-		// **Asked before the store, not after** (design 25 §3). A report about a declaration the
-		// mesh has moved past would otherwise wait out a restarting store to be written and then
-		// overwrite what the node is doing now — and on the bus being built, where the holding is
-		// the server's, it comes back after the newer was applied whatever the controller does.
-		outstanding := s.outstanding(ctx, report.Node)
-		declaredIn := staleAgainst(report)
-		if report.Ordered() {
-			// Kept by its order, not by the digest the mesh last sent (novox/hq to-be 45 §6): the
-			// listener refuses an older account under the one rule, whatever it is about.
-			declaredIn = ""
-		}
-		if Superseded(declaredIn, outstanding) {
-			s.log.Printf("set aside %s: the mesh has moved past that declaration", what)
-			_ = m.Took()
-			return
-		}
-
 		news, err := s.listener.Heard(context.Background(), report)
-		switch s.decide(ctx, m, what, declaredIn, outstanding, err) {
+		switch s.decide(ctx, m, what, "", "", err) {
 		case Hold:
 			// Held, not settled, while the store cannot take it: the node reports an apply once,
 			// and a report lost here is a node the mesh never hears from again — the store
@@ -396,27 +359,6 @@ func (s *Server) reported(ctx context.Context, m Control) {
 	_ = m.Took()
 }
 
-// staleAgainst is the declaration a report may be judged stale against, and it is empty for a
-// report that is not only an account of an apply.
-//
-// **A report carries two different things, and only one of them is about a declaration.** What the
-// node applied is; what the machine *is* — the tunnel it took over, the ports its own bundle holds,
-// what an adopted node found and is keeping, a node moving its overlay key — is not. Those reach
-// the mesh on a report because a report is the message a node sends, and nowhere else: a rekey
-// dropped as stale is a node whose overlay key never moves, and no retry is coming, because the
-// node said it once.
-//
-// So staleness is asked only of a report that is purely an apply's account. The rest is acted on
-// whenever it arrives, which is the behaviour the mesh has had all along.
-func staleAgainst(report Report) string {
-	if report.Rekey != nil || report.Tunnel != nil || len(report.Held) > 0 ||
-		report.Firewall != "" || len(report.Reachable) > 0 || len(report.Carried) > 0 ||
-		len(report.Outward) > 0 {
-		return ""
-	}
-	return report.Declared
-}
-
 func (s *Server) enrolling(ctx context.Context, m Control) {
 	reply := EnrolReply{Refusal: "that token cannot be used"}