astisync

Documentation

Index

• Constants
• type Chan
  • func NewChan(o ChanOptions) *Chan
  • func (c *Chan) Add(fn func())
  • func (c *Chan) Reset()
  • func (c *Chan) Start(ctx context.Context)
  • func (c *Chan) Stop()
• type ChanOptions
• type CtxQueue
  • func NewCtxQueue() *CtxQueue
  • func (q *CtxQueue) AddStats(s *astistat.Stater)
  • func (q *CtxQueue) HandleCtx(ctx context.Context)
  • func (q *CtxQueue) Send(p interface{})
  • func (q *CtxQueue) Start(fn func(p interface{}))
  • func (q *CtxQueue) Stop()
• type RWMutex
  • func NewRWMutex(name string, log bool) *RWMutex
  • func (m *RWMutex) IsDeadlocked(timeout time.Duration) (o bool, c string)
  • func (m *RWMutex) Lock()
  • func (m *RWMutex) RLock()
  • func (m *RWMutex) RUnlock()
  • func (m *RWMutex) Unlock()

Constants

const (
	FIFOOrder = "fifo"
	FILOOrder = "filo"
)

Orders

Types

type Chan

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

Chan is an object capable of doing stuff in a specific order without blocking when adding new items in the @

func NewChan

func NewChan(o ChanOptions) *Chan

NewChan creates a new Chan

func (*Chan) Add

func (c *Chan) Add(fn func())

Add adds a new item to the chan

func (*Chan) Reset

func (c *Chan) Reset()

Reset resets the chan

func (*Chan) Start

func (c *Chan) Start(ctx context.Context)

Start starts the chan by looping through functions in the buffer and executing them if any, or waiting for a new one otherwise

func (*Chan) Stop

func (c *Chan) Stop()

Stop stops the chan

type ChanOptions

type ChanOptions struct {
	Order string
	// By default the funcs not yet processed when the context is cancelled will be dropped. However if TaskFunc is not
	// nil all funcs will be processed even after the context has been cancelled.
	TaskFunc astiworker.TaskFunc
}

ChanOptions are Chan options

type CtxQueue

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

CtxQueue is a queue that can - handle a context without dropping any messages sent before the context is cancelled - ensure that sending a message is not blocking if

• the queue has not been started
• the context has been cancelled

func NewCtxQueue

func NewCtxQueue() *CtxQueue

NewCtxQueue creates a new ctx queue

func (*CtxQueue) AddStats

func (q *CtxQueue) AddStats(s *astistat.Stater)

AddStats adds queue stats

func (*CtxQueue) HandleCtx

func (q *CtxQueue) HandleCtx(ctx context.Context)

HandleCtx handles the ctx

func (*CtxQueue) Send

func (q *CtxQueue) Send(p interface{})

Send sends a message in the queue and blocks until the message has been fully processed Block indicates whether to block until the message has been fully processed

func (*CtxQueue) Start

func (q *CtxQueue) Start(fn func(p interface{}))

Start starts the queue

func (*CtxQueue) Stop

func (q *CtxQueue) Stop()

Stop stops the queue properly

type RWMutex

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

RWMutex represents a RWMutex capable of logging its actions to ease deadlock debugging

func NewRWMutex

func NewRWMutex(name string, log bool) *RWMutex

NewRWMutex creates a new RWMutex

func (*RWMutex) IsDeadlocked

func (m *RWMutex) IsDeadlocked(timeout time.Duration) (o bool, c string)

IsDeadlocked checks whether the mutex is deadlocked with a given timeout and returns the last caller

func (*RWMutex) Lock

func (m *RWMutex) Lock()

Lock write locks the mutex

func (*RWMutex) RLock

func (m *RWMutex) RLock()

RLock read locks the mutex

func (*RWMutex) RUnlock

func (m *RWMutex) RUnlock()

RUnlock read unlocks the mutex

func (*RWMutex) Unlock

func (m *RWMutex) Unlock()

Unlock write unlocks the mutex