cadence

package module

Go to main page

Versions in this module

v0

v0.6.0

Mar 9, 2018

v0.5.1

Mar 9, 2018

Changes in this version

+ var ErrNoData = internal.ErrNoData

+ func IsCanceledError(err error) bool

+ func IsCustomError(err error) bool

+ func IsGenericError(err error) bool

+ func IsPanicError(err error) bool

+ func IsTerminatedError(err error) bool

+ func IsTimeoutError(err error) bool

v0.5.0

Jan 17, 2018

v0.4.1

Dec 5, 2017

Changes in this version

type Client

+ CompleteActivityByID func(ctx context.Context, domainID, workflowID, runID, activityID string, ...) error

+ DescribeWorkflowExecution func(ctx context.Context, workflowID, runID string) (*s.DescribeWorkflowExecutionResponse, error)

+ type HistoryIterator interface

+ GetNextPage func() (*s.History, error)

+ HasNextPage func() bool

+ Reset func()

type WorkerOptions

+ DisableStickyExecution bool

+ StickyScheduleToStartTimeout time.Duration

v0.4.0

Oct 3, 2017

v0.3.2

Oct 3, 2017

Changes in this version

+ const QueryTypeStackTrace

+ func SetQueryHandler(ctx Context, queryType string, handler interface{}) error

type Client

+ QueryWorkflow func(ctx context.Context, workflowID string, runID string, queryType string, ...) (EncodedValue, error)

type TestActivityEnvironment

+ func (t *TestActivityEnvironment) SetWorkerOptions(options WorkerOptions) *TestActivityEnvironment

type TestWorkflowEnvironment

+ func (t *TestWorkflowEnvironment) QueryWorkflow(queryType string, args ...interface{}) (EncodedValue, error)

+ func (t *TestWorkflowEnvironment) SetWorkerOptions(options WorkerOptions) *TestWorkflowEnvironment

type WorkerOptions

+ MaxActivityExecutionPerSecond float64

v0.3.1

Aug 9, 2017

Changes in this version

+ const LibraryVersion

+ var ErrActivityResultPending = errors.New("not error: do not autocomplete, using Client.CompleteActivity() to complete")

+ var ErrCanceled = NewCanceledError()

+ var ErrDeadlineExceeded = NewTimeoutError(shared.TimeoutType_SCHEDULE_TO_CLOSE)

+ func AddActivityRegistrationInterceptor(i func(name string, activity interface{}) (string, interface{}))

+ func AddWorkflowRegistrationInterceptor(i func(name string, workflow interface{}) (string, interface{}))

+ func DeserializeFnResults(result []byte, to interface{}) error

+ func EnableVerboseLogging(enable bool)

+ func GetActivityLogger(ctx context.Context) *zap.Logger

+ func GetActivityMetricsScope(ctx context.Context) tally.Scope

+ func GetLogger(ctx Context) *zap.Logger

+ func GetMetricsScope(ctx Context) tally.Scope

+ func GetWorkflowStackTrace(h *s.History) (string, error)

+ func Go(ctx Context, f func(ctx Context))

+ func GoNamed(ctx Context, name string, f func(ctx Context))

+ func NewFuture(ctx Context) (Future, Settable)

+ func Now(ctx Context) time.Time

+ func RecordActivityHeartbeat(ctx context.Context, details ...interface{})

+ func RegisterActivity(activityFunc interface{})

+ func RegisterActivityWithOptions(activityFunc interface{}, opts RegisterActivityOptions)

+ func RegisterWorkflow(workflowFunc interface{})

+ func RegisterWorkflowWithOptions(workflowFunc interface{}, opts RegisterWorkflowOptions)

+ func RequestCancelWorkflow(ctx Context, workflowID, runID string) error

+ func SerializeFnArgs(args ...interface{}) ([]byte, error)

+ func Sleep(ctx Context, d time.Duration) (err error)

+ func WithActivityTask(ctx context.Context, task *shared.PollForActivityTaskResponse, ...) context.Context

+ func WithCancel(parent Context) (ctx Context, cancel CancelFunc)

+ func WithTestTags(ctx context.Context, testTags map[string]map[string]string) context.Context

+ type ActivityInfo struct

+ ActivityID string

+ ActivityType ActivityType

+ TaskToken []byte

+ WorkflowExecution WorkflowExecution

+ func GetActivityInfo(ctx context.Context) ActivityInfo

+ type ActivityOptions struct

+ ActivityID string

+ HeartbeatTimeout time.Duration

+ ScheduleToCloseTimeout time.Duration

+ ScheduleToStartTimeout time.Duration

+ StartToCloseTimeout time.Duration

+ TaskList string

+ WaitForCancellation bool

+ type ActivityTaskHandler interface

+ Execute func(task *s.PollForActivityTaskResponse) (interface{}, error)

+ func NewActivityTaskHandler(service m.TChanWorkflowService, identity string, logger *zap.Logger) ActivityTaskHandler

+ type ActivityType struct

+ Name string

+ type CancelFunc func()

+ type CanceledError struct

+ func NewCanceledError(details ...interface{}) *CanceledError

+ func (e *CanceledError) Details(d ...interface{})

+ func (e *CanceledError) Error() string

+ type Channel interface

+ Close func()

+ Receive func(ctx Context, valuePtr interface{}) (more bool)

+ ReceiveAsync func(valuePtr interface{}) (ok bool)

+ ReceiveAsyncWithMoreFlag func(valuePtr interface{}) (ok bool, more bool)

+ Send func(ctx Context, v interface{})

+ SendAsync func(v interface{}) (ok bool)

+ func GetSignalChannel(ctx Context, signalName string) Channel

+ func NewBufferedChannel(ctx Context, size int) Channel

+ func NewChannel(ctx Context) Channel

+ func NewNamedBufferedChannel(ctx Context, name string, size int) Channel

+ func NewNamedChannel(ctx Context, name string) Channel

+ type ChildWorkflowFuture interface

+ GetChildWorkflowExecution func() Future

+ func ExecuteChildWorkflow(ctx Context, f interface{}, args ...interface{}) ChildWorkflowFuture

+ type ChildWorkflowOptions struct

+ ChildPolicy ChildWorkflowPolicy

+ Domain string

+ ExecutionStartToCloseTimeout time.Duration

+ TaskList string

+ TaskStartToCloseTimeout time.Duration

+ WaitForCancellation bool

+ WorkflowID string

+ type ChildWorkflowPolicy int32

+ const ChildWorkflowPolicyAbandon

+ const ChildWorkflowPolicyRequestCancel

+ const ChildWorkflowPolicyTerminate

+ type Client interface

+ CancelWorkflow func(workflowID string, runID string) error

+ CompleteActivity func(taskToken []byte, result interface{}, err error) error

+ GetWorkflowHistory func(workflowID string, runID string) (*s.History, error)

+ GetWorkflowStackTrace func(workflowID string, runID string, atDecisionTaskCompletedEventID int64) (string, error)

+ ListClosedWorkflow func(request *s.ListClosedWorkflowExecutionsRequest) (*s.ListClosedWorkflowExecutionsResponse, error)

+ ListOpenWorkflow func(request *s.ListOpenWorkflowExecutionsRequest) (*s.ListOpenWorkflowExecutionsResponse, error)

+ RecordActivityHeartbeat func(taskToken []byte, details ...interface{}) error

+ SignalWorkflow func(workflowID string, runID string, signalName string, arg interface{}) error

+ StartWorkflow func(options StartWorkflowOptions, workflow interface{}, args ...interface{}) (*WorkflowExecution, error)

+ TerminateWorkflow func(workflowID string, runID string, reason string, details []byte) error

+ func NewClient(service m.TChanWorkflowService, domain string, options *ClientOptions) Client

+ type ClientOptions struct

+ Identity string

+ MetricsScope tally.Scope

+ type Context interface

+ Deadline func() (deadline time.Time, ok bool)

+ Done func() Channel

+ Err func() error

+ Value func(key interface{}) interface{}

+ func WithActivityOptions(ctx Context, options ActivityOptions) Context

+ func WithChildPolicy(ctx Context, childPolicy ChildWorkflowPolicy) Context

+ func WithChildWorkflowOptions(ctx Context, cwo ChildWorkflowOptions) Context

+ func WithExecutionStartToCloseTimeout(ctx Context, d time.Duration) Context

+ func WithHeartbeatTimeout(ctx Context, d time.Duration) Context

+ func WithScheduleToCloseTimeout(ctx Context, d time.Duration) Context

+ func WithScheduleToStartTimeout(ctx Context, d time.Duration) Context

+ func WithStartToCloseTimeout(ctx Context, d time.Duration) Context

+ func WithTaskList(ctx Context, name string) Context

+ func WithValue(parent Context, key interface{}, val interface{}) Context

+ func WithWaitForCancellation(ctx Context, wait bool) Context

+ func WithWorkflowDomain(ctx Context, name string) Context

+ func WithWorkflowID(ctx Context, workflowID string) Context

+ func WithWorkflowTaskList(ctx Context, name string) Context

+ func WithWorkflowTaskStartToCloseTimeout(ctx Context, d time.Duration) Context

+ type ContinueAsNewError struct

+ func NewContinueAsNewError(ctx Context, wfn interface{}, args ...interface{}) *ContinueAsNewError

+ func (e *ContinueAsNewError) Error() string

+ type CustomError struct

+ func NewCustomError(reason string, details ...interface{}) *CustomError

+ func (e *CustomError) Details(d ...interface{})

+ func (e *CustomError) Error() string

+ func (e *CustomError) Reason() string

+ type DomainClient interface

+ Describe func(name string) (*s.DomainInfo, *s.DomainConfiguration, error)

+ Register func(request *s.RegisterDomainRequest) error

+ Update func(name string, domainInfo *s.UpdateDomainInfo, ...) error

+ func NewDomainClient(service m.TChanWorkflowService, options *ClientOptions) DomainClient

+ type EncodedValue []byte

+ func SideEffect(ctx Context, f func(ctx Context) interface{}) EncodedValue

+ func (b EncodedValue) Get(valuePtr interface{}) error

+ type EncodedValues []byte

+ func (b EncodedValues) Get(valuePtr ...interface{}) error

+ type Future interface

+ Get func(ctx Context, valuePtr interface{}) error

+ IsReady func() bool

+ func ExecuteActivity(ctx Context, f interface{}, args ...interface{}) Future

+ func NewTimer(ctx Context, d time.Duration) Future

+ type GenericError struct

+ func (e *GenericError) Error() string

+ type GetHistoryPage func(nextToken []byte) (*s.History, []byte, error)

+ type MockCallWrapper struct

+ func (c *MockCallWrapper) After(d time.Duration) *MockCallWrapper

+ func (c *MockCallWrapper) Once() *MockCallWrapper

+ func (c *MockCallWrapper) Return(returnArguments ...interface{}) *MockCallWrapper

+ func (c *MockCallWrapper) Run(fn func(args mock.Arguments)) *MockCallWrapper

+ func (c *MockCallWrapper) Times(i int) *MockCallWrapper

+ func (c *MockCallWrapper) Twice() *MockCallWrapper

+ type PanicError struct

+ func (e *PanicError) Error() string

+ func (e *PanicError) StackTrace() string

+ type RegisterActivityOptions struct

+ Name string

+ type RegisterWorkflowOptions struct

+ Name string

+ type Selector interface

+ AddDefault func(f func())

+ AddFuture func(future Future, f func(f Future)) Selector

+ AddReceive func(c Channel, f func(c Channel, more bool)) Selector

+ AddSend func(c Channel, v interface{}, f func()) Selector

+ Select func(ctx Context)

+ func NewNamedSelector(ctx Context, name string) Selector

+ func NewSelector(ctx Context) Selector

+ type ServiceInvoker interface

+ Close func()

+ Heartbeat func(details []byte) error

+ type Settable interface

+ Chain func(future Future)

+ Set func(value interface{}, err error)

+ SetError func(err error)

+ SetValue func(value interface{})

+ type StartWorkflowOptions struct

+ DecisionTaskStartToCloseTimeout time.Duration

+ ExecutionStartToCloseTimeout time.Duration

+ ID string

+ TaskList string

+ type TestActivityEnvironment struct

+ func (t *TestActivityEnvironment) ExecuteActivity(activityFn interface{}, args ...interface{}) (EncodedValue, error)

+ func (t *TestActivityEnvironment) SetWorkerOption(options WorkerOptions) *TestActivityEnvironment

+ type TestWorkflowEnvironment struct

+ func (t *TestWorkflowEnvironment) CancelWorkflow()

+ func (t *TestWorkflowEnvironment) CompleteActivity(taskToken []byte, result interface{}, err error) error

+ func (t *TestWorkflowEnvironment) ExecuteWorkflow(workflowFn interface{}, args ...interface{})

+ func (t *TestWorkflowEnvironment) GetWorkflowError() error

+ func (t *TestWorkflowEnvironment) GetWorkflowResult(valuePtr interface{}) error

+ func (t *TestWorkflowEnvironment) IsWorkflowCompleted() bool

+ func (t *TestWorkflowEnvironment) Now() time.Time

+ func (t *TestWorkflowEnvironment) OnActivity(activity interface{}, args ...interface{}) *MockCallWrapper

+ func (t *TestWorkflowEnvironment) OnWorkflow(workflow interface{}, args ...interface{}) *MockCallWrapper

+ func (t *TestWorkflowEnvironment) RegisterDelayedCallback(callback func(), delayDuration time.Duration)

+ func (t *TestWorkflowEnvironment) SetActivityTaskList(tasklist string, activityFn ...interface{})

+ func (t *TestWorkflowEnvironment) SetOnActivityCanceledListener(listener func(activityInfo *ActivityInfo)) *TestWorkflowEnvironment

+ func (t *TestWorkflowEnvironment) SetOnActivityCompletedListener(listener func(activityInfo *ActivityInfo, result EncodedValue, err error)) *TestWorkflowEnvironment

+ func (t *TestWorkflowEnvironment) SetOnActivityHeartbeatListener(listener func(activityInfo *ActivityInfo, details EncodedValues)) *TestWorkflowEnvironment

+ func (t *TestWorkflowEnvironment) SetOnActivityStartedListener(...) *TestWorkflowEnvironment

+ func (t *TestWorkflowEnvironment) SetOnChildWorkflowCanceledListener(listener func(workflowInfo *WorkflowInfo)) *TestWorkflowEnvironment

+ func (t *TestWorkflowEnvironment) SetOnChildWorkflowCompletedListener(listener func(workflowInfo *WorkflowInfo, result EncodedValue, err error)) *TestWorkflowEnvironment

+ func (t *TestWorkflowEnvironment) SetOnChildWorkflowStartedListener(listener func(workflowInfo *WorkflowInfo, ctx Context, args EncodedValues)) *TestWorkflowEnvironment

+ func (t *TestWorkflowEnvironment) SetOnTimerCancelledListener(listener func(timerID string)) *TestWorkflowEnvironment

+ func (t *TestWorkflowEnvironment) SetOnTimerFiredListener(listener func(timerID string)) *TestWorkflowEnvironment

+ func (t *TestWorkflowEnvironment) SetOnTimerScheduledListener(listener func(timerID string, duration time.Duration)) *TestWorkflowEnvironment

+ func (t *TestWorkflowEnvironment) SetTestTimeout(idleTimeout time.Duration) *TestWorkflowEnvironment

+ func (t *TestWorkflowEnvironment) SetWorkerOption(options WorkerOptions) *TestWorkflowEnvironment

+ func (t *TestWorkflowEnvironment) SignalWorkflow(name string, input interface{})

+ type TimeoutError struct

+ func NewHeartbeatTimeoutError(details ...interface{}) *TimeoutError

+ func NewTimeoutError(timeoutType shared.TimeoutType) *TimeoutError

+ func (e *TimeoutError) Details(d ...interface{})

+ func (e *TimeoutError) Error() string

+ func (e *TimeoutError) TimeoutType() shared.TimeoutType

+ type Version int

+ const DefaultVersion

+ func GetVersion(ctx Context, changeID string, minSupported, maxSupported Version) Version

+ type Worker interface

+ Run func() error

+ Start func() error

+ Stop func()

+ func NewActivityTaskWorker(taskHandler ActivityTaskHandler, service m.TChanWorkflowService, domain string, ...) Worker

+ func NewWorker(service m.TChanWorkflowService, domain string, taskList string, ...) Worker

+ func NewWorkflowTaskWorker(taskHandler WorkflowTaskHandler, service m.TChanWorkflowService, domain string, ...) (worker Worker)

+ type WorkerOptions struct

+ AutoHeartBeat bool

+ BackgroundActivityContext context.Context

+ DisableActivityWorker bool

+ DisableWorkflowWorker bool

+ EnableLoggingInReplay bool

+ Identity string

+ Logger *zap.Logger

+ MaxActivityExecutionRate int

+ MaxActivityExecutionRateRefreshDuration time.Duration

+ MaxConcurrentActivityExecutionSize int

+ MetricsScope tally.Scope

+ type WorkflowExecution struct

+ ID string

+ RunID string

+ type WorkflowInfo struct

+ Domain string

+ ExecutionStartToCloseTimeoutSeconds int32

+ TaskListName string

+ TaskStartToCloseTimeoutSeconds int32

+ WorkflowExecution WorkflowExecution

+ WorkflowType WorkflowType

+ func GetWorkflowInfo(ctx Context) *WorkflowInfo

+ type WorkflowTaskHandler interface

+ ProcessWorkflowTask func(task *s.PollForDecisionTaskResponse, getHistoryPage GetHistoryPage, ...) (response *s.RespondDecisionTaskCompletedRequest, stackTrace string, err error)

+ func NewWorkflowTaskHandler(domain string, identity string, logger *zap.Logger) WorkflowTaskHandler

+ type WorkflowTestSuite struct

+ func (s *WorkflowTestSuite) GetLogger() *zap.Logger

+ func (s *WorkflowTestSuite) NewTestActivityEnvironment() *TestActivityEnvironment

+ func (s *WorkflowTestSuite) NewTestWorkflowEnvironment() *TestWorkflowEnvironment

+ func (s *WorkflowTestSuite) SetLogger(logger *zap.Logger)

+ func (s *WorkflowTestSuite) SetMetricsScope(scope tally.Scope)

+ type WorkflowType struct

+ Name string

v0.3.0-beta

Jun 28, 2017

v0.2.0-beta

Jun 6, 2017

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL