internal

package

Go to main page

Versions in this module

v0

v0.7.4

Aug 13, 2018

Changes in this version

type WorkerOptions

+ MaxConcurrentDecisionTaskExecutionSize int

+ WorkerDecisionTasksPerSecond float64

v0.7.3

Jul 30, 2018

v0.7.2

Jul 27, 2018

Changes in this version

type MockCallWrapper

+ func (c *MockCallWrapper) AfterFn(fn func() time.Duration) *MockCallWrapper

type WorkflowExecutionContext

+ Lock func()

+ Unlock func(err error)

v0.7.1

Jul 3, 2018

Changes in this version

+ func ReplayWorkflowHistoryFromJSONFile(logger *zap.Logger, jsonfileName string) error

+ type WorkflowExecutionContext interface

+ CompleteDecisionTask func(waitLocalActivity bool) interface{}

+ GetCurrentDecisionTask func() *s.PollForDecisionTaskResponse

+ GetDecisionTimeout func() time.Duration

+ ProcessLocalActivityResult func(lar *localActivityResult) (interface{}, error)

+ ProcessWorkflowTask func(task *s.PollForDecisionTaskResponse, historyIterator HistoryIterator) (completeRequest interface{}, err error)

+ StackTrace func() string

type WorkflowRun

+ GetID func() string

v0.7.0

May 25, 2018

Changes in this version

+ var ErrMockStartChildWorkflowFailed = fmt.Errorf("start child workflow failed: %v", ...)

+ var ErrTooManyArg = errors.New("too many arguments")

+ func ReplayWorkflowExecution(ctx context.Context, service workflowserviceclient.Interface, ...) error

+ func ReplayWorkflowHistory(logger *zap.Logger, history *shared.History) error

+ func SetStickyWorkflowCacheSize(cacheSize int)

type ClientOptions

+ DataConverter encoded.DataConverter

type Context

+ func WithDataConverter(ctx Context, dc encoded.DataConverter) Context

+ type ErrorDetailsValues []interface

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

+ func (b ErrorDetailsValues) HasValues() bool

+ type NonDeterministicWorkflowPolicy int

+ const NonDeterministicWorkflowPolicyBlockWorkflow

+ const NonDeterministicWorkflowPolicyFailWorkflow

type TestActivityEnvironment

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

type WorkerOptions

+ DataConverter encoded.DataConverter

+ NonDeterministicWorkflowPolicy NonDeterministicWorkflowPolicy

v0.6.1

Apr 17, 2018

Changes in this version

+ func MutableSideEffect(ctx Context, id string, f func(ctx Context) interface{}, ...) encoded.Value

+ func NewValue(data []byte) encoded.Value

+ func NewValues(data []byte) encoded.Values

type Client

+ SignalWithStartWorkflow func(ctx context.Context, workflowID string, signalName string, ...) (*WorkflowExecution, error)

+ type SignalChannel interface

+ ReceiveEncodedValue func(ctx Context) (value encoded.Value, more bool)

+ ReceiveEncodedValueAsync func() (value encoded.Value, ok bool)

+ ReceiveEncodedValueAsyncWithMoreFlag func() (value encoded.Value, ok bool, more bool)

type TestWorkflowEnvironment

+ func (t *TestWorkflowEnvironment) SetStartTime(startTime time.Time)

v0.6.0

Mar 9, 2018

v0.5.1

Mar 9, 2018

Changes in this version

+ var ErrNoData = errors.New("no data available")

+ func IsReplaying(ctx Context) bool

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

type ActivityInfo

+ Deadline time.Time

+ HeartbeatTimeout time.Duration

+ ScheduledTimestamp time.Time

+ StartedTimestamp time.Time

+ TaskList string

type CanceledError

+ func (e *CanceledError) HasDetails() bool

type ChildWorkflowFuture

+ SignalChildWorkflow func(ctx Context, signalName string, data interface{}) Future

type Client

+ RecordActivityHeartbeatByID func(ctx context.Context, domain, workflowID, runID, activityID string, ...) error

type Context

+ func WithLocalActivityOptions(ctx Context, options LocalActivityOptions) Context

type CustomError

+ func (e *CustomError) HasDetails() bool

type EncodedValue

+ func (b EncodedValue) HasValue() bool

type EncodedValues

+ func (b EncodedValues) HasValues() bool

type Future

+ func ExecuteLocalActivity(ctx Context, activity interface{}, args ...interface{}) Future

+ func RequestCancelExternalWorkflow(ctx Context, workflowID, runID string) Future

+ func SignalExternalWorkflow(ctx Context, workflowID, runID, signalName string, arg interface{}) Future

+ type LocalActivityOptions struct

+ ScheduleToCloseTimeout time.Duration

type TestActivityEnvironment

+ func (t *TestActivityEnvironment) ExecuteLocalActivity(activityFn interface{}, args ...interface{}) (encoded.Value, error)

type TestWorkflowEnvironment

+ func (t *TestWorkflowEnvironment) OnRequestCancelExternalWorkflow(domainName, workflowID, runID string) *MockCallWrapper

+ func (t *TestWorkflowEnvironment) OnSignalExternalWorkflow(domainName, workflowID, runID, signalName, arg interface{}) *MockCallWrapper

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

+ func (t *TestWorkflowEnvironment) SetOnLocalActivityCompletedListener(listener func(activityInfo *ActivityInfo, result encoded.Value, err error)) *TestWorkflowEnvironment

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

type TimeoutError

+ func (e *TimeoutError) HasDetails() bool

type WorkerOptions

+ MaxConcurrentLocalActivityExecutionSize int

+ WorkerLocalActivitiesPerSecond float64

v0.5.0

Jan 17, 2018

Changes in this version

+ const FeatureVersion

+ const LibraryVersion

+ const QueryTypeStackTrace

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

+ var ErrCanceled = NewCanceledError()

+ var ErrDeadlineExceeded = NewTimeoutError(shared.TimeoutTypeScheduleToClose)

+ 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 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 SetQueryHandler(ctx Context, queryType string, handler interface{}) error

+ func SideEffect(ctx Context, f func(ctx Context) interface{}) encoded.Value

+ 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 workflowserviceclient.Interface, 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, childWorkflow interface{}, args ...interface{}) ChildWorkflowFuture

+ type ChildWorkflowOptions struct

+ ChildPolicy ChildWorkflowPolicy

+ Domain string

+ ExecutionStartToCloseTimeout time.Duration

+ TaskList string

+ TaskStartToCloseTimeout time.Duration

+ WaitForCancellation bool

+ WorkflowID string

+ WorkflowIDReusePolicy WorkflowIDReusePolicy

+ type ChildWorkflowPolicy int32

+ const ChildWorkflowPolicyAbandon

+ const ChildWorkflowPolicyRequestCancel

+ const ChildWorkflowPolicyTerminate

+ type Client interface

+ CancelWorkflow func(ctx context.Context, workflowID string, runID string) error

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

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

+ DescribeTaskList func(ctx context.Context, tasklist string, tasklistType s.TaskListType) (*s.DescribeTaskListResponse, error)

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

+ ExecuteWorkflow func(ctx context.Context, options StartWorkflowOptions, workflow interface{}, ...) (WorkflowRun, error)

+ GetWorkflowHistory func(ctx context.Context, workflowID string, runID string, isLongPoll bool, ...) HistoryEventIterator

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

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

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

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

+ SignalWorkflow func(ctx context.Context, workflowID string, runID string, signalName string, ...) error

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

+ TerminateWorkflow func(ctx context.Context, workflowID string, runID string, reason string, ...) error

+ func NewClient(service workflowserviceclient.Interface, 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(ctx context.Context, name string) (*s.DomainInfo, *s.DomainConfiguration, error)

+ Register func(ctx context.Context, request *s.RegisterDomainRequest) error

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

+ func NewDomainClient(service workflowserviceclient.Interface, options *ClientOptions) DomainClient

+ type EncodedValue []byte

+ 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, activity interface{}, args ...interface{}) Future

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

+ type GenericError struct

+ func (e *GenericError) Error() string

+ type HistoryEventIterator interface

+ HasNext func() bool

+ Next func() (*s.HistoryEvent, error)

+ type HistoryIterator interface

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

+ HasNextPage func() bool

+ Reset func()

+ 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

+ WorkflowIDReusePolicy WorkflowIDReusePolicy

+ type TerminatedError struct

+ func (e *TerminatedError) Error() string

+ type TestActivityEnvironment struct

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

+ func (t *TestActivityEnvironment) SetWorkerOptions(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) QueryWorkflow(queryType string, args ...interface{}) (encoded.Value, error)

+ 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 encoded.Value, err error)) *TestWorkflowEnvironment

+ func (t *TestWorkflowEnvironment) SetOnActivityHeartbeatListener(listener func(activityInfo *ActivityInfo, details encoded.Values)) *TestWorkflowEnvironment

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

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

+ func (t *TestWorkflowEnvironment) SetOnChildWorkflowCompletedListener(listener func(workflowInfo *WorkflowInfo, result encoded.Value, err error)) *TestWorkflowEnvironment

+ func (t *TestWorkflowEnvironment) SetOnChildWorkflowStartedListener(listener func(workflowInfo *WorkflowInfo, ctx Context, args encoded.Values)) *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) SetWorkerOptions(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 workflowserviceclient.Interface, ...) Worker

+ func NewWorker(service workflowserviceclient.Interface, domain string, taskList string, ...) Worker

+ func NewWorkflowTaskWorker(taskHandler WorkflowTaskHandler, service workflowserviceclient.Interface, ...) (worker Worker)

+ type WorkerOptions struct

+ AutoHeartBeat bool

+ BackgroundActivityContext context.Context

+ DisableActivityWorker bool

+ DisableStickyExecution bool

+ DisableWorkflowWorker bool

+ EnableLoggingInReplay bool

+ Identity string

+ Logger *zap.Logger

+ MaxConcurrentActivityExecutionSize int

+ MetricsScope tally.Scope

+ StickyScheduleToStartTimeout time.Duration

+ TaskListActivitiesPerSecond float64

+ WorkerActivitiesPerSecond float64

+ type WorkflowExecution struct

+ ID string

+ RunID string

+ type WorkflowIDReusePolicy int

+ const WorkflowIDReusePolicyAllowDuplicate

+ const WorkflowIDReusePolicyAllowDuplicateFailedOnly

+ const WorkflowIDReusePolicyRejectDuplicate

+ type WorkflowInfo struct

+ Domain string

+ ExecutionStartToCloseTimeoutSeconds int32

+ TaskListName string

+ TaskStartToCloseTimeoutSeconds int32

+ WorkflowExecution WorkflowExecution

+ WorkflowType WorkflowType

+ func GetWorkflowInfo(ctx Context) *WorkflowInfo

+ type WorkflowRun interface

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

+ GetRunID func() string

+ type WorkflowTaskHandler interface

+ ProcessWorkflowTask func(task *s.PollForDecisionTaskResponse, historyIterator HistoryIterator, ...) (response interface{}, 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

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