pandora

type AckStatus byte

type ApiError string

type BlobStore interface {
	// PutData take data and returns the key under which that data
	// can be retreived later.
	//
	// If key is large enough to hold the Key, then no allocation is done.
	//
	// Is valid to pass nil as "key"
	PutData(key Key, data []byte) (Key, error)

	// GetData will return the contents under key to the user,
	// if the key isn't found, then nil, nil is returned.
	//
	// If out is large enough to hold the data, no allocation is done,
	// otherwise a new buffer is used.
	//
	// Is valid to pass nil as out
	GetData(out []byte, key Key) ([]byte, error)

	// UpdateRef will change the ref-count of the given key by delta.
	//
	// delta can be positive or negative. If the ref-count becomes 0
	// or less, then the key SHOULD BE collected.
	UpdateRefCount(key Key, delta int) error
}

type Key interface {
	// Bytes should return the contents of the key
	Bytes() []byte
}

type KeyPrinter struct{}

type KeyWriter interface {
	io.Writer
	// Key should return the Key calculated from the data
	// passed via Write.
	Key() Key
}

type Message struct {
	// Mid is the id of the message, calculated based on the
	// body of the message
	Mid Key
	// Lid is the id of the current associated lock
	Lid Key
	// Status holds the ack status of this message
	Status AckStatus
	// LeaseUntil holds the time when the Lid will become invalid
	LeasedUntil time.Time
	// FetchTime holds the time at the server when the message was requested by the client.
	FetchTime time.Time
	// ReceivedAt holds the server time when the message was received
	ReceivedAt time.Time
	// SendWhen is used to store when the message should be delivered. This is the ReceivedAt + Delay
	SendWhen time.Time
	// Delay is the time to wait before sending the message
	Delay time.Duration
	// DeliveryCount count how many times the message were delivered to a client.
	//
	// Only one client can access the message at any given time, but when the client crashes
	// or don't complete the message, then another client might access the message.
	DeliveryCount int
	// Body is a list of urlencoded data
	Body url.Values
	// contains filtered or unexported fields
}

type MessageStore interface {
	// Enqueue will put msg in the outputbox of the receiver
	Enqueue(msg *Message) error

	// FetchAndLockLatest will fetch the next pending queue that is available for delivery, ie,
	// messages that aren't locked and the SendWhen is less than the current time.
	//
	// This also returns the Lid to be used with the message
	FetchAndLockLatest(receiver string, leaseTime time.Duration) (*Message, error)

	// Ack will change the status of the given mid message, only if lid is still valid
	Ack(mid, lid Key, status AckStatus) error

	// FetchHeaders fetch at least len(out) messages that have the given receiver
	// and were received after serverTime.
	//
	// Only pending messages are returned
	FetchHeaders(out []Message, receiver string, serverTime time.Time) (int, error)

	// Reenqueue messages considering now
	Reenqueue(now time.Time) error
}

type SHA1Key [20]byte

type SHA1KeyWriter struct {
	// contains filtered or unexported fields
}

type Server struct {
	BlobStore    BlobStore
	MessageStore MessageStore
}