wrote revised library skeleton

journal.go

@@ -1 +1,265 @@
 package prism
+
+import (
+	"sync"
+	"time"
+)
+
+// ----------------------------------------------------------------------------
+// Types
+// ----------------------------------------------------------------------------
+
+type JournalAuthor string
+
+const (
+	AuthorEmbassy    JournalAuthor = "prism.embassy"
+	AuthorReqManager JournalAuthor = "prism.req_manager"
+	AuthorStreamReq  JournalAuthor = "prism.stream_req"
+	AuthorQueryReq   JournalAuthor = "prism.query_req"
+)
+
+// JournalCollector
+
+type JournalCollector struct {
+	entries chan JournalEntry
+	mu      sync.Mutex
+	wg      sync.WaitGroup
+	closing bool
+}
+
+// JournalEntry
+
+type JournalEntry interface {
+	PeerID() string
+	SealedAt() time.Time
+	Author() JournalAuthor
+}
+
+type entry struct {
+	peerID   string
+	sealedAt time.Time
+	author   JournalAuthor
+}
+
+func (e *entry) PeerID() string        { return e.peerID }
+func (e *entry) SealedAt() time.Time   { return e.sealedAt }
+func (e *entry) Author() JournalAuthor { return e.author }
+
+// ----------------------------------------------------------------------------
+// Journal Collector
+// ----------------------------------------------------------------------------
+
+func NewJournalCollector() *JournalCollector {
+	return nil
+}
+
+func (c *JournalCollector) Enroll() {}
+
+func (c *JournalCollector) Close() {}
+
+func (c *JournalCollector) Entries() {}
+
+// ----------------------------------------------------------------------------
+// Journal Entries
+// ----------------------------------------------------------------------------
+
+func newEntry(peerID string, author JournalAuthor) *entry {
+	return &entry{
+		peerID:   peerID,
+		author:   author,
+		sealedAt: time.Now(),
+	}
+}
+
+// PeerConnected
+
+type PeerConnectedJournal struct {
+	*entry
+	Data PeerConnectedData
+}
+
+type PeerConnectedData struct {
+	At time.Time
+}
+
+func NewPeerConnectedJournal(
+	peerID string, author JournalAuthor, data PeerConnectedData,
+) PeerConnectedJournal {
+	return PeerConnectedJournal{entry: newEntry(peerID, author), Data: data}
+}
+
+// PeerDisconnected
+
+type PeerDisconnectedJournal struct {
+	*entry
+	Data PeerDisconnectedData
+}
+
+type PeerDisconnectedData struct {
+	At time.Time
+}
+
+func NewPeerDisconnectedJournal(
+	peerID string, author JournalAuthor, data PeerDisconnectedData,
+) PeerDisconnectedJournal {
+	return PeerDisconnectedJournal{entry: newEntry(peerID, author), Data: data}
+}
+
+// ReqQueued
+
+type ReqQueuedJournal struct {
+	*entry
+	Data ReqQueuedData
+}
+
+type ReqQueuedData struct {
+	SubID    string
+	LetterID uint64
+	QueuedAt time.Time
+	Err      error
+}
+
+func NewReqQueuedJournal(
+	peerID string, author JournalAuthor, data ReqQueuedData,
+) ReqQueuedJournal {
+	return ReqQueuedJournal{entry: newEntry(peerID, author), Data: data}
+}
+
+// CloseQueued
+
+type CloseQueuedJournal struct {
+	*entry
+	Data CloseQueuedData
+}
+
+type CloseQueuedData struct {
+	SubID    string
+	LetterID uint64
+	QueuedAt time.Time
+	Err      error
+}
+
+func NewCloseQueuedJournal(
+	peerID string, author JournalAuthor, data CloseQueuedData,
+) CloseQueuedJournal {
+	return CloseQueuedJournal{entry: newEntry(peerID, author), Data: data}
+}
+
+// ReqSendOutcome
+
+type ReqSendOutcomeJournal struct {
+	*entry
+	Data ReqSendOutcomeData
+}
+
+type ReqSendOutcomeData struct {
+	SubID      string
+	LetterID   uint64
+	Outcome    LetterOutcomeKind
+	SentAt     time.Time
+	MissedAt   time.Time
+	RetryCount int
+	Err        error
+}
+
+func NewReqSendOutcomeJournal(
+	peerID string, author JournalAuthor, data ReqSendOutcomeData,
+) ReqSendOutcomeJournal {
+	return ReqSendOutcomeJournal{entry: newEntry(peerID, author), Data: data}
+}
+
+// CloseSendOutcome
+
+type CloseSendOutcomeJournal struct {
+	*entry
+	Data CloseSendOutcomeData
+}
+
+type CloseSendOutcomeData struct {
+	SubID      string
+	LetterID   uint64
+	Outcome    LetterOutcomeKind
+	SentAt     time.Time
+	MissedAt   time.Time
+	RetryCount int
+	Err        error
+}
+
+func NewCloseSendOutcomeJournal(
+	peerID string, author JournalAuthor, data CloseSendOutcomeData,
+) CloseSendOutcomeJournal {
+	return CloseSendOutcomeJournal{entry: newEntry(peerID, author), Data: data}
+}
+
+// ReceivedEOSE
+
+type ReceivedEOSEJournal struct {
+	*entry
+	Data ReceivedEOSEData
+}
+
+type ReceivedEOSEData struct {
+	SubID string
+	At    time.Time
+}
+
+func NewReceivedEOSEJournal(
+	peerID string, author JournalAuthor, data ReceivedEOSEData,
+) ReceivedEOSEJournal {
+	return ReceivedEOSEJournal{entry: newEntry(peerID, author), Data: data}
+}
+
+// MissedEOSE
+
+type MissedEOSEJournal struct {
+	*entry
+	Data MissedEOSEData
+}
+
+type MissedEOSEData struct {
+	SubID string
+	At    time.Time
+}
+
+func NewMissedEOSEJournal(
+	peerID string, author JournalAuthor, data MissedEOSEData,
+) MissedEOSEJournal {
+	return MissedEOSEJournal{entry: newEntry(peerID, author), Data: data}
+}
+
+// ReceivedClosed
+
+type ReceivedClosedJournal struct {
+	*entry
+	Data ReceivedClosedData
+}
+
+type ReceivedClosedData struct {
+	SubID   string
+	At      time.Time
+	Message string
+}
+
+func NewReceivedClosedJournal(
+	peerID string, author JournalAuthor, data ReceivedClosedData,
+) ReceivedClosedJournal {
+	return ReceivedClosedJournal{entry: newEntry(peerID, author), Data: data}
+}
+
+// ReqClosed
+
+type ReqClosedJournal struct {
+	*entry
+	Data ReqClosedData
+}
+
+type ReqClosedData struct {
+	SubID string
+	At    time.Time
+}
+
+func NewReqClosedJournal(
+	peerID string, author JournalAuthor, data ReqClosedData,
+) ReqClosedJournal {
+	return ReqClosedJournal{entry: newEntry(peerID, author), Data: data}
+}