state

Documentation

Index

• type ErrorBody
• type ErrorResp
  • func NewErrorResp(e error, c int) *ErrorResp
  • func (e *ErrorResp) Err() error
  • func (e *ErrorResp) Error() string
  • func (e *ErrorResp) StatusCode() int
  • func (e *ErrorResp) String() string
• type Flows
• type FlowsCreateReq
• type FlowsCreateResp
• type FlowsDeleteReq
• type FlowsDeleteResp
• type FlowsGetReq
• type FlowsGetResp
• type FlowsListReq
• type FlowsListResp
• type Namespaces
• type NamespacesCreateReq
• type NamespacesCreateResp
• type NamespacesDeleteReq
• type NamespacesDeleteResp
• type NamespacesGetReq
• type NamespacesGetResp
• type NamespacesListReq
• type NamespacesListResp
• type Runs
• type RunsCreateReq
• type RunsCreateResp
• type RunsDeleteReq
• type RunsDeleteResp
• type RunsGetReq
• type RunsGetResp
• type RunsListReq
• type RunsListResp
• type RunsUpdateReq
• type RunsUpdateResp
• type State
• type Triggers
• type TriggersCreateReq
• type TriggersCreateResp
• type TriggersDeleteReq
• type TriggersDeleteResp
• type TriggersGetReq
• type TriggersGetResp
• type TriggersListReq
• type TriggersListResp

Types

type ErrorBody

type ErrorBody struct {
	Msg  string `json:"message"`
	Code int    `json:"code"`
	// contains filtered or unexported fields
}

type ErrorResp

type ErrorResp struct {
	ErrorBody `json:"error"`
}

func NewErrorResp

func NewErrorResp(e error, c int) *ErrorResp

func (*ErrorResp) Err

func (e *ErrorResp) Err() error

func (*ErrorResp) Error

func (e *ErrorResp) Error() string

func (*ErrorResp) StatusCode

func (e *ErrorResp) StatusCode() int

func (*ErrorResp) String

func (e *ErrorResp) String() string

type Flows

type Flows interface {
	Create(*FlowsCreateReq) (*FlowsCreateResp, *ErrorResp)
	Delete(*FlowsDeleteReq) (*FlowsDeleteResp, *ErrorResp)
	Get(*FlowsGetReq) (*FlowsGetResp, *ErrorResp)
	List(*FlowsListReq) (*FlowsListResp, *ErrorResp)
}

type FlowsCreateReq

type FlowsCreateReq struct {
	Flow *sharedstate.Flow
}

type FlowsCreateResp

type FlowsCreateResp struct {
	Flow *sharedstate.Flow
}

type FlowsDeleteReq

type FlowsDeleteReq struct {
	ID        string
	Namespace string
}

type FlowsDeleteResp

type FlowsDeleteResp struct{}

type FlowsGetReq

type FlowsGetReq struct {
	ID        string
	Namespace string
}

type FlowsGetResp

type FlowsGetResp struct {
	Flow *sharedstate.Flow
}

type FlowsListReq

type FlowsListReq struct {
	Namespace string `json:"namespace"`
}

type FlowsListResp

type FlowsListResp struct {
	Flows []*sharedstate.FlowStub
}

type Namespaces

type Namespaces interface {
	Create(*NamespacesCreateReq) (*NamespacesCreateResp, *ErrorResp)
	Delete(*NamespacesDeleteReq) (*NamespacesDeleteResp, *ErrorResp)
	Get(*NamespacesGetReq) (*NamespacesGetResp, *ErrorResp)
	List(*NamespacesListReq) (*NamespacesListResp, *ErrorResp)
}

type NamespacesCreateReq

type NamespacesCreateReq struct {
	Namespace *sharedstate.Namespace
}

type NamespacesCreateResp

type NamespacesCreateResp struct{}

type NamespacesDeleteReq

type NamespacesDeleteReq struct {
	Name string
}

type NamespacesDeleteResp

type NamespacesDeleteResp struct{}

type NamespacesGetReq

type NamespacesGetReq struct {
	Name string
}

type NamespacesGetResp

type NamespacesGetResp struct {
	Namespace *sharedstate.Namespace
}

type NamespacesListReq

type NamespacesListReq struct{}

type NamespacesListResp

type NamespacesListResp struct {
	Namespaces []*sharedstate.NamespaceStub
}

type Runs

type Runs interface {
	Create(*RunsCreateReq) (*RunsCreateResp, *ErrorResp)
	Delete(*RunsDeleteReq) (*RunsDeleteResp, *ErrorResp)
	Get(*RunsGetReq) (*RunsGetResp, *ErrorResp)
	List(*RunsListReq) (*RunsListResp, *ErrorResp)
	Update(*RunsUpdateReq) (*RunsUpdateResp, *ErrorResp)
}

type RunsCreateReq

type RunsCreateReq struct {
	Run *sharedstate.Run `json:"run"`
}

type RunsCreateResp

type RunsCreateResp struct{}

type RunsDeleteReq

type RunsDeleteReq struct {
	ID        ulid.ULID `json:"id"`
	Namespace string    `json:"namespace"`
}

type RunsDeleteResp

type RunsDeleteResp struct{}

type RunsGetReq

type RunsGetReq struct {
	ID        ulid.ULID `json:"id"`
	Namespace string    `json:"namespace"`
}

type RunsGetResp

type RunsGetResp struct {
	Run *sharedstate.Run `json:"run"`
}

type RunsListReq

type RunsListReq struct {
	Namespace string
}

type RunsListResp

type RunsListResp struct {
	Runs []*sharedstate.RunStub `json:"runs"`
}

type RunsUpdateReq

type RunsUpdateReq struct {
	Run *sharedstate.Run `json:"run"`
}

type RunsUpdateResp

type RunsUpdateResp struct{}

type State

type State interface {
	Flows() Flows
	Namespaces() Namespaces
	Runs() Runs
	Triggers() Triggers
}

type Triggers

type Triggers interface {
	Create(*TriggersCreateReq) (*TriggersCreateResp, *ErrorResp)
	Delete(*TriggersDeleteReq) (*TriggersDeleteResp, *ErrorResp)
	Get(*TriggersGetReq) (*TriggersGetResp, *ErrorResp)
	List(*TriggersListReq) (*TriggersListResp, *ErrorResp)
}

type TriggersCreateReq

type TriggersCreateReq struct {
	Trigger *sharedstate.Trigger
}

type TriggersCreateResp

type TriggersCreateResp struct{}

type TriggersDeleteReq

type TriggersDeleteReq struct {
	ID        string
	Namespace string
}

type TriggersDeleteResp

type TriggersDeleteResp struct{}

type TriggersGetReq

type TriggersGetReq struct {
	ID        string
	Namespace string
}

type TriggersGetResp

type TriggersGetResp struct {
	Trigger *sharedstate.Trigger
}

type TriggersListReq

type TriggersListReq struct {
	Namespace string
}

type TriggersListResp

type TriggersListResp struct {
	Triggers []*sharedstate.TriggerStub
}