Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

ctrl

package module

Go to main page

Versions in this module

v1

v1.1.1

Dec 4, 2024

v1.1.0

Nov 15, 2024

v1.0.0

Nov 12, 2024

v0

v0.3.0

Nov 4, 2024

v0.2.9

Sep 16, 2024

v0.2.8

Sep 12, 2024

v0.2.7

Sep 6, 2024

v0.2.6

Aug 27, 2024

v0.2.5

Aug 27, 2024

v0.2.4

Aug 23, 2024

v0.2.3

Aug 22, 2024

v0.2.2

Aug 19, 2024

v0.2.1

Aug 8, 2024

Changes in this version

+ var ErrEmptyResponse = errors.New("empty response with error")

+ var ErrHandlerInit = errors.New("error initializing handler")

+ var ErrNoCondition = errors.New("no condition available")

+ type HTTPController struct

+ func NewHTTPController(facilityCode string, serverID uuid.UUID, conditionKind condition.Kind, ...) (*HTTPController, error)

+ func (n *HTTPController) Run(ctx context.Context, handler TaskHandler) error

+ type MockConditionStatusPublisher struct

+ func NewMockConditionStatusPublisher(t interface{ ... }) *MockConditionStatusPublisher

+ func (_m *MockConditionStatusPublisher) EXPECT() *MockConditionStatusPublisher_Expecter

+ func (_m *MockConditionStatusPublisher) Publish(ctx context.Context, serverID string, state condition.State, ...) error

+ type MockConditionStatusPublisher_Expecter struct

+ func (_e *MockConditionStatusPublisher_Expecter) Publish(ctx interface{}, serverID interface{}, state interface{}, status interface{}, ...) *MockConditionStatusPublisher_Publish_Call

+ type MockConditionStatusPublisher_Publish_Call struct

+ func (_c *MockConditionStatusPublisher_Publish_Call) Return(_a0 error) *MockConditionStatusPublisher_Publish_Call

+ func (_c *MockConditionStatusPublisher_Publish_Call) Run(run func(ctx context.Context, serverID string, state condition.State, ...)) *MockConditionStatusPublisher_Publish_Call

+ func (_c *MockConditionStatusPublisher_Publish_Call) RunAndReturn(...) *MockConditionStatusPublisher_Publish_Call

+ type OptionHTTPController func(*HTTPController)

+ func WithNATSHTTPLogger(logger *logrus.Logger) OptionHTTPController

+ func WithOrchestratorClient(c orc.Queryor) OptionHTTPController

+ type OrchestratorAPIConfig struct

+ AuthDisabled bool

+ AuthToken string

+ Endpoint string

+ OidcAudienceEndpoint string

+ OidcClientID string

+ OidcClientScopes []string

+ OidcClientSecret string

+ OidcIssuerEndpoint string

v0.2.0

Jul 29, 2024

v0.1.0

Jul 26, 2024

Changes in this version

+ const LivenessStaleThreshold

+ const StatusStaleThreshold

+ var ErrRetryHandler = errors.New("retry callback")

+ type ConditionHandlerFactory func() TaskHandler

+ type ConditionState int

+ type ConditionStatusPublisher interface

+ Publish func(ctx context.Context, serverID string, state condition.State, ...) error

+ func NewHTTPConditionStatusPublisher(serverID, conditionID uuid.UUID, conditionKind condition.Kind, ...) ConditionStatusPublisher

+ func NewNatsConditionStatusPublisher(appName, conditionID, facilityCode string, conditionKind condition.Kind, ...) (ConditionStatusPublisher, error)

+ type ConditionStatusQueryor interface

+ ConditionState func(conditionID string) ConditionState

+ type ConditionTaskRepository interface

+ Publish func(ctx context.Context, task *condition.Task[any, any], tsUpdateOnly bool) error

+ Query func(ctx context.Context) (*condition.Task[any, any], error)

+ func NewHTTPTaskRepository(serverID, conditionID uuid.UUID, conditionKind condition.Kind, ...) ConditionTaskRepository

+ func NewNatsConditionTaskRepository(conditionID, serverID, facilityCode string, conditionKind condition.Kind, ...) (ConditionTaskRepository, error)

+ type HTTPConditionStatusPublisher struct

+ func (s *HTTPConditionStatusPublisher) Publish(ctx context.Context, serverID string, state condition.State, ...) error

+ type HTTPTaskRepository struct

+ func (h *HTTPTaskRepository) Publish(ctx context.Context, task *condition.Task[any, any], tsUpdateOnly bool) error

+ func (h *HTTPTaskRepository) Query(ctx context.Context) (*condition.Task[any, any], error)

+ type LivenessCheckin interface

+ ControllerID func() registry.ControllerID

+ StartLivenessCheckin func(ctx context.Context)

+ func NewNatsLiveness(cfg events.NatsOptions, stream events.Stream, l *logrus.Logger, ...) LivenessCheckin

+ type MockConditionStatusQueryor struct

+ func NewMockConditionStatusQueryor(t interface{ ... }) *MockConditionStatusQueryor

+ func (_m *MockConditionStatusQueryor) ConditionState(conditionID string) ConditionState

+ func (_m *MockConditionStatusQueryor) EXPECT() *MockConditionStatusQueryor_Expecter

+ type MockConditionStatusQueryor_ConditionState_Call struct

+ func (_c *MockConditionStatusQueryor_ConditionState_Call) Return(_a0 ConditionState) *MockConditionStatusQueryor_ConditionState_Call

+ func (_c *MockConditionStatusQueryor_ConditionState_Call) Run(run func(conditionID string)) *MockConditionStatusQueryor_ConditionState_Call

+ func (_c *MockConditionStatusQueryor_ConditionState_Call) RunAndReturn(run func(string) ConditionState) *MockConditionStatusQueryor_ConditionState_Call

+ type MockConditionStatusQueryor_Expecter struct

+ func (_e *MockConditionStatusQueryor_Expecter) ConditionState(conditionID interface{}) *MockConditionStatusQueryor_ConditionState_Call

+ type MockLivenessCheckin struct

+ func NewMockLivenessCheckin(t interface{ ... }) *MockLivenessCheckin

+ func (_m *MockLivenessCheckin) ControllerID() registry.ControllerID

+ func (_m *MockLivenessCheckin) EXPECT() *MockLivenessCheckin_Expecter

+ func (_m *MockLivenessCheckin) StartLivenessCheckin(ctx context.Context)

+ type MockLivenessCheckin_ControllerID_Call struct

+ func (_c *MockLivenessCheckin_ControllerID_Call) Return(_a0 registry.ControllerID) *MockLivenessCheckin_ControllerID_Call

+ func (_c *MockLivenessCheckin_ControllerID_Call) Run(run func()) *MockLivenessCheckin_ControllerID_Call

+ func (_c *MockLivenessCheckin_ControllerID_Call) RunAndReturn(run func() registry.ControllerID) *MockLivenessCheckin_ControllerID_Call

+ type MockLivenessCheckin_Expecter struct

+ func (_e *MockLivenessCheckin_Expecter) ControllerID() *MockLivenessCheckin_ControllerID_Call

+ func (_e *MockLivenessCheckin_Expecter) StartLivenessCheckin(ctx interface{}) *MockLivenessCheckin_StartLivenessCheckin_Call

+ type MockLivenessCheckin_StartLivenessCheckin_Call struct

+ func (_c *MockLivenessCheckin_StartLivenessCheckin_Call) Return() *MockLivenessCheckin_StartLivenessCheckin_Call

+ func (_c *MockLivenessCheckin_StartLivenessCheckin_Call) Run(run func(ctx context.Context)) *MockLivenessCheckin_StartLivenessCheckin_Call

+ func (_c *MockLivenessCheckin_StartLivenessCheckin_Call) RunAndReturn(run func(context.Context)) *MockLivenessCheckin_StartLivenessCheckin_Call

+ type MockPublisher struct

+ func NewMockPublisher(t interface{ ... }) *MockPublisher

+ func (_m *MockPublisher) EXPECT() *MockPublisher_Expecter

+ func (_m *MockPublisher) Publish(ctx context.Context, task *condition.Task[interface{}, interface{}], ...) error

+ type MockPublisher_Expecter struct

+ func (_e *MockPublisher_Expecter) Publish(ctx interface{}, task interface{}, tsUpdate interface{}) *MockPublisher_Publish_Call

+ type MockPublisher_Publish_Call struct

+ func (_c *MockPublisher_Publish_Call) Return(_a0 error) *MockPublisher_Publish_Call

+ func (_c *MockPublisher_Publish_Call) Run(...) *MockPublisher_Publish_Call

+ func (_c *MockPublisher_Publish_Call) RunAndReturn(...) *MockPublisher_Publish_Call

+ type MockTaskHandler struct

+ func NewMockTaskHandler(t interface{ ... }) *MockTaskHandler

+ func (_m *MockTaskHandler) EXPECT() *MockTaskHandler_Expecter

+ func (_m *MockTaskHandler) HandleTask(ctx context.Context, task *condition.Task[interface{}, interface{}], ...) error

+ type MockTaskHandler_Expecter struct

+ func (_e *MockTaskHandler_Expecter) HandleTask(ctx interface{}, task interface{}, statusPublisher interface{}) *MockTaskHandler_HandleTask_Call

+ type MockTaskHandler_HandleTask_Call struct

+ func (_c *MockTaskHandler_HandleTask_Call) Return(_a0 error) *MockTaskHandler_HandleTask_Call

+ func (_c *MockTaskHandler_HandleTask_Call) Run(...) *MockTaskHandler_HandleTask_Call

+ func (_c *MockTaskHandler_HandleTask_Call) RunAndReturn(...) *MockTaskHandler_HandleTask_Call

+ type MockeventStatusAcknowleger struct

+ func NewMockeventStatusAcknowleger(t interface{ ... }) *MockeventStatusAcknowleger

+ func (_m *MockeventStatusAcknowleger) EXPECT() *MockeventStatusAcknowleger_Expecter

+ type MockeventStatusAcknowleger_Expecter struct

+ type MockeventStatusAcknowleger_complete_Call struct

+ func (_c *MockeventStatusAcknowleger_complete_Call) Return() *MockeventStatusAcknowleger_complete_Call

+ func (_c *MockeventStatusAcknowleger_complete_Call) Run(run func()) *MockeventStatusAcknowleger_complete_Call

+ func (_c *MockeventStatusAcknowleger_complete_Call) RunAndReturn(run func()) *MockeventStatusAcknowleger_complete_Call

+ type MockeventStatusAcknowleger_inProgress_Call struct

+ func (_c *MockeventStatusAcknowleger_inProgress_Call) Return() *MockeventStatusAcknowleger_inProgress_Call

+ func (_c *MockeventStatusAcknowleger_inProgress_Call) Run(run func()) *MockeventStatusAcknowleger_inProgress_Call

+ func (_c *MockeventStatusAcknowleger_inProgress_Call) RunAndReturn(run func()) *MockeventStatusAcknowleger_inProgress_Call

+ type MockeventStatusAcknowleger_nak_Call struct

+ func (_c *MockeventStatusAcknowleger_nak_Call) Return() *MockeventStatusAcknowleger_nak_Call

+ func (_c *MockeventStatusAcknowleger_nak_Call) Run(run func()) *MockeventStatusAcknowleger_nak_Call

+ func (_c *MockeventStatusAcknowleger_nak_Call) RunAndReturn(run func()) *MockeventStatusAcknowleger_nak_Call

+ type NatsConditionStatusPublisher struct

+ func (s *NatsConditionStatusPublisher) Publish(ctx context.Context, serverID string, state condition.State, ...) error

+ type NatsConditionStatusQueryor struct

+ func (p *NatsConditionStatusQueryor) ConditionState(conditionID string) ConditionState

+ type NatsConditionTaskRepository struct

+ func (n *NatsConditionTaskRepository) Publish(ctx context.Context, task *condition.Task[any, any], tsUpdateOnly bool) error

+ func (n *NatsConditionTaskRepository) Query(ctx context.Context) (*condition.Task[any, any], error)

+ type NatsController struct

+ func NewNatsController(appName, facilityCode, subjectSuffix, natsURL, credsFile string, ...) *NatsController

+ func (n *NatsController) Connect(ctx context.Context) error

+ func (n *NatsController) FacilityCode() string

+ func (n *NatsController) ID() string

+ func (n *NatsController) ListenEvents(ctx context.Context, chf ConditionHandlerFactory) error

+ func (n *NatsController) NewNatsConditionStatusQueryor() (*NatsConditionStatusQueryor, error)

+ type NatsLiveness struct

+ func (n *NatsLiveness) ControllerID() registry.ControllerID

+ func (n *NatsLiveness) StartLivenessCheckin(ctx context.Context)

+ type Option func(*NatsController)

+ func WithConcurrency(c int) Option

+ func WithConnectionTimeout(t time.Duration) Option

+ func WithHandlerTimeout(t time.Duration) Option

+ func WithKVReplicas(c int) Option

+ func WithLogger(logger *logrus.Logger) Option

+ type Publisher interface

+ Publish func(ctx context.Context, task *condition.Task[any, any], tsUpdate bool) error

+ func NewHTTPPublisher(serverID, conditionID uuid.UUID, conditionKind condition.Kind, ...) Publisher

+ func NewNatsPublisher(appName, conditionID, serverID, facilityCode string, ...) (Publisher, error)

+ type PublisherHTTP struct

+ func (p *PublisherHTTP) Publish(ctx context.Context, task *condition.Task[any, any], tsUpdate bool) error

+ type PublisherNATS struct

+ func (p *PublisherNATS) Publish(ctx context.Context, task *condition.Task[any, any], tsUpdate bool) error

+ type QueryError struct

+ func (a *QueryError) Error() string

+ type TaskHandler interface

+ HandleTask func(ctx context.Context, task *condition.Task[any, any], statusPublisher Publisher) error