wrote revised library skeleton

req.go

@@ -0,0 +1,368 @@
+package prism
+
+import (
+	"context"
+	"log/slog"
+	"sync"
+	"time"
+)
+
+// ----------------------------------------------------------------------------
+// Types
+// ----------------------------------------------------------------------------
+
+// Outputs
+
+type ReqEvent struct {
+	PeerID     string
+	ReceivedAt time.Time
+	Event      []byte
+}
+
+type ReqMessage struct {
+	PeerID     string
+	ReceivedAt time.Time
+	Message    string
+}
+
+// Options
+
+const (
+	defaultLabel       = "REQ"
+	defaultEOSETimeout = 30 * time.Second
+)
+
+type reqConfig struct {
+	id          string
+	label       string
+	eoseTimeout time.Duration
+}
+
+type ReqOption func(*reqConfig)
+
+// Request Manager
+
+type ReqManager struct {
+	subs   map[string]*Request
+	byPeer map[string]map[string]struct{} // peerID -> subID set
+
+	postmaster *Postmaster
+	collector  *JournalCollector
+	journals   chan JournalEntry // JournalCollector.Enroll
+
+	isConnected func(peerID string) bool // Adapter.IsConnected
+	poolEvents  <-chan PoolEvent         // Adapter.Subscribe
+	inbox       <-chan InboundLetter     // Clerk.Subscribe
+
+	ctx    context.Context
+	cancel context.CancelFunc
+	mu     sync.RWMutex
+	wg     sync.WaitGroup
+	logger *slog.Logger
+}
+
+type Request interface {
+	command(reqCommand)
+	Peers() []string
+	Close()
+}
+
+// Base Request
+
+type request struct {
+	id  string
+	req Envelope
+
+	cmds    chan reqCommand
+	closing bool
+	done    chan struct{}
+
+	events   chan ReqEvent
+	messages chan ReqMessage
+
+	postmaster  *Postmaster
+	journals    chan<- JournalEntry
+	isConnected func() bool
+	onClose     func()
+
+	sendCtx context.Context
+	wg      sync.WaitGroup
+	logger  *slog.Logger
+}
+
+// Stream Request
+
+type StreamReq struct {
+	*request
+	peers map[string]*streamPeer
+}
+
+type streamPeer struct {
+	closeSent bool
+	closed    bool
+	closeOnce sync.Once
+}
+
+// Query Request
+
+type QueryReq struct {
+	*request
+	peers       map[string]*queryPeer
+	eoseTimeout time.Duration
+}
+
+type queryPeer struct {
+	eoseTimer *time.Timer
+	closeSent bool
+	closed    bool
+	closeOnce sync.Once
+}
+
+// Commands
+
+type reqCommand interface{ reqCommand() } // gates command channel
+
+type cmdRecordReqOutcome struct {
+	peerID  string
+	outcome LetterOutcome
+}
+
+func (cmdRecordReqOutcome) reqCommand() {}
+
+type cmdRecordCloseOutcome struct {
+	peerID  string
+	outcome LetterOutcome
+}
+
+func (cmdRecordCloseOutcome) reqCommand() {}
+
+type cmdReceiveEvent struct {
+	peerID string
+	at     time.Time
+	data   Envelope
+}
+
+func (cmdReceiveEvent) reqCommand() {}
+
+type cmdReceiveEOSE struct {
+	peerID string
+	at     time.Time
+}
+
+func (cmdReceiveEOSE) reqCommand() {}
+
+type cmdReceiveClosed struct {
+	peerID  string
+	at      time.Time
+	message string
+}
+
+func (cmdReceiveClosed) reqCommand() {}
+
+type cmdClosePeer struct{ peerID string }
+
+func (cmdClosePeer) reqCommand() {}
+
+type cmdCloseReq struct{}
+
+func (cmdCloseReq) reqCommand() {}
+
+type cmdHandleReconnect struct{ peerID string }
+
+func (cmdHandleReconnect) reqCommand() {}
+
+type cmdHandleEOSETimeout struct{ peerID string }
+
+func (cmdHandleEOSETimeout) reqCommand() {}
+
+// ----------------------------------------------------------------------------
+// Request Options
+// ----------------------------------------------------------------------------
+
+func newReqConfig(opts ...ReqOption) reqConfig {
+	return reqConfig{}
+}
+
+func WithID(id string) ReqOption {
+	return func(c *reqConfig) {
+		c.id = id
+	}
+}
+
+func WithLabel(label string) ReqOption {
+	return func(c *reqConfig) {
+		c.label = label
+	}
+}
+
+func WithEOSETimeout(timeout time.Duration) ReqOption {
+	return func(c *reqConfig) {
+		c.eoseTimeout = timeout
+	}
+}
+
+// ----------------------------------------------------------------------------
+// Request Manager
+// ----------------------------------------------------------------------------
+
+func NewReqManager() *ReqManager {
+	return nil
+}
+
+func (m *ReqManager) OpenStream() {}
+
+func (m *ReqManager) OpenQuery() {}
+
+func (m *ReqManager) CloseReq() {}
+
+func (m *ReqManager) Close() {}
+
+func (m *ReqManager) makeOnClose() {}
+
+func (m *ReqManager) routeInbox() {}
+
+func (m *ReqManager) routeEvents() {}
+
+// Helpers
+
+func cleanPeers() {}
+
+var encoder struct{}
+
+func generateID() {}
+
+// ----------------------------------------------------------------------------
+// Base Request
+// ----------------------------------------------------------------------------
+
+func (r *request) emit() {}
+
+func (r *request) command() {}
+
+func (r *request) send() {}
+
+// ----------------------------------------------------------------------------
+// Stream Request
+// ----------------------------------------------------------------------------
+
+func NewStreamReq() *StreamReq {
+	return nil
+}
+
+func (r *StreamReq) Peers() []string {
+	return nil
+}
+
+func (r *StreamReq) Close() {}
+
+func (r *StreamReq) sendReq(peerID string) error {
+	return nil
+}
+
+func (r *StreamReq) sendClose(peerID string) error {
+	return nil
+}
+
+func (r *StreamReq) run() {
+	// buffers command queue internally
+	// switches on command type
+}
+
+func (r *StreamReq) applyRecordReqOutcome(cmd cmdRecordReqOutcome) {}
+
+func (r *StreamReq) applyRecordCloseOutcome(cmd cmdRecordCloseOutcome) {}
+
+func (r *StreamReq) applyReceiveEvent(cmd cmdReceiveEvent) {}
+
+func (r *StreamReq) applyReceiveEOSE(cmd cmdReceiveEOSE) {}
+
+func (r *StreamReq) applyReceiveClosed(cmd cmdReceiveClosed) {}
+
+func (r *StreamReq) applyClosePeer(cmd cmdClosePeer) {}
+
+func (r *StreamReq) applyCloseReq(cmd cmdCloseReq) {}
+
+func (r *StreamReq) applyHandleReconnect(cmd cmdHandleReconnect) {}
+
+// ----------------------------------------------------------------------------
+// Query Request
+// ----------------------------------------------------------------------------
+
+func NewQueryReq() *QueryReq {
+	return nil
+}
+
+func (r *QueryReq) Peers() []string {
+	return nil
+}
+
+func (r *QueryReq) Close() {}
+
+func (r *QueryReq) sendReq(peerID string) error {
+	return nil
+}
+
+func (r *QueryReq) sendClose(peerID string) error {
+	return nil
+}
+
+func (r *QueryReq) run() {
+	// buffers command queue internally
+	// switches on command type
+}
+
+func (r *QueryReq) applyRecordReqOutcome(cmd cmdRecordReqOutcome) {}
+
+func (r *QueryReq) applyRecordCloseOutcome(cmd cmdRecordCloseOutcome) {}
+
+func (r *QueryReq) applyReceiveEvent(cmd cmdReceiveEvent) {}
+
+func (r *QueryReq) applyReceiveEOSE(cmd cmdReceiveEOSE) {}
+
+func (r *QueryReq) applyReceiveClosed(cmd cmdReceiveClosed) {}
+
+func (r *QueryReq) applyClosePeer(cmd cmdClosePeer) {}
+
+func (r *QueryReq) applyCloseReq(cmd cmdCloseReq) {}
+
+func (r *QueryReq) applyHandleEOSETimeout(cmd cmdHandleEOSETimeout) {}
+
+// ----------------------------------------------------------------------------
+// Commands
+// ----------------------------------------------------------------------------
+
+func newRecordReqOutcome(peerID string, outcome LetterOutcome) cmdRecordReqOutcome {
+	return cmdRecordReqOutcome{peerID: peerID, outcome: outcome}
+}
+
+func newRecordCloseOutcome(peerID string, outcome LetterOutcome) cmdRecordCloseOutcome {
+	return cmdRecordCloseOutcome{peerID: peerID, outcome: outcome}
+}
+
+func newReceiveEvent(peerID string, at time.Time, data Envelope) cmdReceiveEvent {
+	return cmdReceiveEvent{peerID: peerID, at: at, data: data}
+}
+
+func newReceiveEOSE(peerID string, at time.Time) cmdReceiveEOSE {
+	return cmdReceiveEOSE{peerID: peerID, at: at}
+}
+
+func newReceiveClosed(peerID string, at time.Time, message string) cmdReceiveClosed {
+	return cmdReceiveClosed{peerID: peerID, at: at, message: message}
+}
+
+func newClosePeer(peerID string) cmdClosePeer {
+	return cmdClosePeer{peerID: peerID}
+}
+
+func newCloseReq() cmdCloseReq {
+	return cmdCloseReq{}
+}
+
+func newHandleReconnect(peerID string) cmdHandleReconnect {
+	return cmdHandleReconnect{peerID: peerID}
+}
+
+func newHandleEOSETimeout(peerID string) cmdHandleEOSETimeout {
+	return cmdHandleEOSETimeout{peerID: peerID}
+}