.

go/neo/mastered.go

@@ -28,7 +28,6 @@ import (
 	"time"
 
 	"lab.nexedi.com/kirr/go123/xnet"
-//	"lab.nexedi.com/kirr/go123/xsync"
 
 	"lab.nexedi.com/kirr/neo/go/internal/log"
 	"lab.nexedi.com/kirr/neo/go/internal/task"
@@ -57,8 +56,6 @@ import (
 //
 // This pipeline is operated by TalkMaster.
 // The connection to master is persisted by redial as needed.
-//
-// XXX update after introduction of _MasterLink
 type _MasteredNode struct {
 	*xneo.Node
 
@@ -74,8 +71,7 @@ type _MasteredNode struct {
 	opReady	    chan struct{}     // reinitialized each time state becomes non-operational
 	operational bool              // cache for state.IsOperational()
 
-//	rxm      chan _RxM          // TalkMaster -> RecvM1
-	rxmFlags _MasteredNodeFlags // if e.g. δPartTab messages should be delivered to RecvM1
+	rxmFlags _MasteredNodeFlags // if e.g. δPartTab messages should be delivered to mlink.Recv1
 				    // XXX just use `.myInfo.NodeType == STORAGE` instead?
 }
 
@@ -87,8 +83,8 @@ type _RxM struct {
 
 type _MasteredNodeFlags int
 const (
-	// δPartTabPassThrough tells RecvM1 not to filter out messages related
-	// to partition table changes. When RecvM1 receives such messages there
+	// δPartTabPassThrough tells mlink.Recv1 not to filter out messages related
+	// to partition table changes. When mlink.Recv1 receives such messages there
 	// are already processed internally to update .state.PartTab correspondingly.
 	//
 	// Storage uses this mode to receive δPartTab notifications to know
@@ -110,7 +106,7 @@ func newMasteredNode(typ proto.NodeType, clusterName string, net xnet.Networker,
 // TalkMaster dials master, identifies to it, and receives master notifications and requests.
 //
 // Notifications to node/partition tables and cluster state are automatically
-// handled, while other notifications and requests are passed through to RecvM1.
+// handled, while other notifications and requests are passed through to _MasterLink.Recv1.
 //
 // Master link is persisted by redialing as needed.
 //
@@ -214,49 +210,25 @@ func (node *_MasteredNode) talkMaster1(ctx, ctxPreTalkM context.Context, f func(
 			return err
 		}
 
-/*
-		wg := xsync.NewWorkGroup(ctx)
-		// receive and handle notifications from master
-		// XXX no need to spawn "rx prefilter" - just make MasterLink.Recv1() call mlink.Recv1(), check if message should be prefiltered and call Master.recvMaster1. (-> yes)
-		node.rxm = make(chan _RxM)
-		wg.Go(func(ctx context.Context) error {
-			defer task.Running(&ctx, "rx prefilter")(&err)
-			for {
-				req, err := mlink.Recv1()
-				if err != nil {
-					close(node.rxm)
-					return err
-				}
-				err = node.recvMaster1(ctx, req) // req ownership is passed in
-				if err != nil {
-					return err
-				}
-			}
-		})
-*/
 		// run user code
-//		wg.Go(func(ctx context.Context) error {
-			return f(ctx, &_MasterLink{mlink, node})
-//		})
-
-//		return wg.Wait()
+		return f(ctx, &_MasterLink{mlink, node})
 	})
 }
 
-// _MasterLink represents NodeLink to master with Recv1 filtered through _MasteredNode.
+// _MasterLink represents NodeLink to master with Recv1 filtered through _MasteredNode
+// δstate handler.
 type _MasterLink struct {
 	*neonet.NodeLink
 	node *_MasteredNode
 }
 
-// RecvM1 receives request from master filtered through _MasteredNode δstate handler.
+// Recv1 receives request from master filtered through _MasteredNode δstate handler.
 //
 // Must be called only when master link is established - e.g. from under TalkMaster.
 func (mlink *_MasterLink) Recv1(ctx context.Context) (neonet.Request, error) {
 	for {
 		req, err := mlink.NodeLink.Recv1() // cancel on ctx
 		if err != nil {
-//			close(node.rxm)
 			return neonet.Request{}, err
 		}
 
@@ -291,59 +263,6 @@ func (mlink *_MasterLink) Recv1(ctx context.Context) (neonet.Request, error) {
 	}
 }
 
-/*
-// recvMaster1 handles 1 message from master.
-func (node *_MasteredNode) recvMaster1(ctx context.Context, req neonet.Request) (err error) {
-	// messages for state changes are handled internally
-	δstate := true
-	switch req.Msg.(type) {
-	default: δstate = false
-	case *proto.SendPartitionTable:     // whole partTab
-	case *proto.NotifyPartitionChanges: // δ(partTab)
-	case *proto.NotifyNodeInformation:  // δ(nodeTab)
-	case *proto.NotifyClusterState:
-	}
-
-	if δstate {
-		δpt, err := node.recvδstate(ctx, req.Msg)
-		toRecvM1 := false
-		if δpt && (node.rxmFlags & δPartTabPassThrough != 0) {
-			toRecvM1 = true
-		}
-		if !toRecvM1 {
-			req.Close()
-			return err
-		}
-	}
-
-	// pass request -> recvM1
-	// NOTE req ownership is passed into recvM1 caller who becomes responsible to close it
-	select {
-	case <-ctx.Done():
-		req.Close()
-		return ctx.Err()
-
-	case node.rxm <- _RxM{Req: req}:
-		// ok
-	}
-
-	return nil
-}
-*/
-
-//var errMasterDisconect = errors.New("master disconnected")
-//
-// // recvM1 receives request from master filtered through δstate handler.
-// //
-// // Must be called only when master link is established - e.g. from under TalkMaster.
-// func (node *_MasteredNode) recvM1() (neonet.Request, error) {
-// 	rx, ok := <-node.rxm
-// 	if !ok {
-// 		return neonet.Request{}, errMasterDisconect
-// 	}
-// 	return rx.Req, rx.Err
-// }
-
 //trace:event traceClusterStateChanged(cs *proto.ClusterState)
 
 // recvδstate handles reception of δstate messages.