job

type Basic ¶

type Basic interface {
	RegistryKey() string
	Execute(context.Context, any) (any, error)
}

Basic represents a basic job. Borrowing the terminology from inheritance, we can think of Basic jobs as the Abstract Base Class for all jobs. Basic jobs define execution, but do not define any behaviour around how/when the job is to be executed, and thus cannot be executed on their own.

type BlockHeaderSub ¶

type BlockHeaderSub interface {
	Basic
	Subscribe(ctx context.Context) (ethereum.Subscription, chan *coretypes.Header, error)
	Unsubscribe(ctx context.Context)
}

BlockHeaderSub represents a block watcher job.

type Conditional ¶

type Conditional interface {
	Polling
	Condition(ctx context.Context) bool
}

Conditional represents a conditional job.

type Custom ¶

type Custom interface {
	Basic
	HasProducer
}

Custom Jobs are jobs that defines their own producer function. This is useful for adding custom job types without having to make a change to the core `offchain-sdk`.

type EthSubscribable ¶

type EthSubscribable interface {
	Basic
	Subscribe(ctx context.Context) (ethereum.Subscription, chan coretypes.Log, error)
	Unsubscribe(ctx context.Context)
}

EthSubscribable represents a subscription to an ethereum event.

type HasMetrics ¶

type HasMetrics interface {
	Basic
}

HasMetrics represents a struct that defines metrics for its internal functions.

type HasProducer ¶

type HasProducer interface {
	Basic
	Producer(ctx context.Context, pool WorkerPool) error
}

HasProducer represents a struct that defines a producer.

func WrapConditional(c Conditional) HasProducer

func WrapJob(j Basic) HasProducer

func WrapPolling(c Polling) HasProducer

type HasSetup ¶

type HasSetup interface {
	Basic
	Setup(context.Context) error
}

HasSetup represents a job that has a setup function.

type HasTeardown ¶

type HasTeardown interface {
	Basic
	Teardown() error
}

HasTeardown represents a job that has a teardown function.

type Polling ¶

type Polling interface {
	Basic
	IntervalTime(ctx context.Context) time.Duration
}

Polling represents a polling job. Polling jobs are jobs that are run periodically at a given interval.

type Registry ¶

type Registry struct {
	// mapRegistry is the underlying map registry of job types to
	types.Registry[string, Basic]
}

Registry is a registry of jobtypes to jobs.

func NewRegistry() *Registry

func (r *Registry) Count() uint64

func (r *Registry) RegisterJob(job Basic)

type Subscribable ¶

type Subscribable interface {
	Basic
	Subscribe(ctx context.Context) chan any
}

Subscribable represents a subscribable job.

type WorkerPool ¶

type WorkerPool interface {
	Submit(func())
	SubmitAndWait(func())
}