func ExampleSWF_PollForDecisionTask() {
svc := swf.New(nil)
params := &swf.PollForDecisionTaskInput{
Domain: aws.String("DomainName"), // Required
TaskList: &swf.TaskList{ // Required
Name: aws.String("Name"), // Required
},
Identity: aws.String("Identity"),
MaximumPageSize: aws.Long(1),
NextPageToken: aws.String("PageToken"),
ReverseOrder: aws.Boolean(true),
}
resp, err := svc.PollForDecisionTask(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS Error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, The SDK should alwsy return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
func ExampleSWF_DescribeActivityType() {
svc := swf.New(nil)
params := &swf.DescribeActivityTypeInput{
ActivityType: &swf.ActivityType{ // Required
Name: aws.String("Name"), // Required
Version: aws.String("Version"), // Required
},
Domain: aws.String("DomainName"), // Required
}
resp, err := svc.DescribeActivityType(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS Error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, The SDK should alwsy return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
func ExampleSWF_RequestCancelWorkflowExecution() {
svc := swf.New(nil)
params := &swf.RequestCancelWorkflowExecutionInput{
Domain: aws.String("DomainName"), // Required
WorkflowID: aws.String("WorkflowId"), // Required
RunID: aws.String("RunIdOptional"),
}
resp, err := svc.RequestCancelWorkflowExecution(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS Error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, The SDK should alwsy return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
func ExampleSWF_RespondActivityTaskFailed() {
svc := swf.New(nil)
params := &swf.RespondActivityTaskFailedInput{
TaskToken: aws.String("TaskToken"), // Required
Details: aws.String("Data"),
Reason: aws.String("FailureReason"),
}
resp, err := svc.RespondActivityTaskFailed(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS Error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, The SDK should alwsy return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
func ExampleSWF_GetWorkflowExecutionHistory() {
svc := swf.New(nil)
params := &swf.GetWorkflowExecutionHistoryInput{
Domain: aws.String("DomainName"), // Required
Execution: &swf.WorkflowExecution{ // Required
RunID: aws.String("RunId"), // Required
WorkflowID: aws.String("WorkflowId"), // Required
},
MaximumPageSize: aws.Long(1),
NextPageToken: aws.String("PageToken"),
ReverseOrder: aws.Boolean(true),
}
resp, err := svc.GetWorkflowExecutionHistory(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS Error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, The SDK should alwsy return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
func ExampleSWF_ListClosedWorkflowExecutions() {
svc := swf.New(nil)
params := &swf.ListClosedWorkflowExecutionsInput{
Domain: aws.String("DomainName"), // Required
CloseStatusFilter: &swf.CloseStatusFilter{
Status: aws.String("CloseStatus"), // Required
},
CloseTimeFilter: &swf.ExecutionTimeFilter{
OldestDate: aws.Time(time.Now()), // Required
LatestDate: aws.Time(time.Now()),
},
ExecutionFilter: &swf.WorkflowExecutionFilter{
WorkflowID: aws.String("WorkflowId"), // Required
},
MaximumPageSize: aws.Long(1),
NextPageToken: aws.String("PageToken"),
ReverseOrder: aws.Boolean(true),
StartTimeFilter: &swf.ExecutionTimeFilter{
OldestDate: aws.Time(time.Now()), // Required
LatestDate: aws.Time(time.Now()),
},
TagFilter: &swf.TagFilter{
Tag: aws.String("Tag"), // Required
},
TypeFilter: &swf.WorkflowTypeFilter{
Name: aws.String("Name"), // Required
Version: aws.String("VersionOptional"),
},
}
resp, err := svc.ListClosedWorkflowExecutions(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS Error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, The SDK should alwsy return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
func TestMigrateWorkflowTypes(t *testing.T) {
if os.Getenv("AWS_ACCESS_KEY_ID") == "" || os.Getenv("AWS_SECRET_ACCESS_KEY") == "" {
log.Printf("WARNING: NO AWS CREDS SPECIFIED, SKIPPING MIGRATIONS TEST")
return
}
createDomain()
config := &aws.Config{
Credentials: credentials.NewEnvCredentials(),
Region: "us-east-1",
}
client := swf.New(config)
workflow := fmt.Sprintf("test-workflow-%d", time.Now().UnixNano())
version := fmt.Sprintf("test-workflow-version-%d", time.Now().UnixNano())
req := swf.RegisterWorkflowTypeInput{
Name: &workflow,
Description: aws.String("test workflow migration"),
Version: &version,
Domain: aws.String(testDomain),
}
w := WorkflowTypeMigrator{
RegisteredWorkflowTypes: []swf.RegisterWorkflowTypeInput{req},
Client: client,
}
w.Migrate()
w.Migrate()
dep := swf.DeprecateWorkflowTypeInput{
WorkflowType: &swf.WorkflowType{
Name: aws.String(workflow),
Version: aws.String(version),
},
Domain: aws.String(testDomain),
}
wd := WorkflowTypeMigrator{
DeprecatedWorkflowTypes: []swf.DeprecateWorkflowTypeInput{dep},
Client: client,
}
wd.Migrate()
wd.Migrate()
}
func TestMigrateActivityTypes(t *testing.T) {
if os.Getenv("AWS_ACCESS_KEY_ID") == "" || os.Getenv("AWS_SECRET_ACCESS_KEY") == "" {
log.Printf("WARNING: NO AWS CREDS SPECIFIED, SKIPPING MIGRATIONS TEST")
return
}
createDomain()
config := &aws.Config{
Credentials: credentials.NewEnvCredentials(),
Region: "us-east-1",
}
client := swf.New(config)
activity := fmt.Sprintf("test-activity-%d", time.Now().UnixNano())
version := fmt.Sprintf("test-activity-version-%d", time.Now().UnixNano())
req := swf.RegisterActivityTypeInput{
Name: &activity,
Description: aws.String("test activity migration"),
Version: &version,
Domain: aws.String(testDomain),
}
a := ActivityTypeMigrator{
RegisteredActivityTypes: []swf.RegisterActivityTypeInput{req},
Client: client,
}
a.Migrate()
a.Migrate()
dep := swf.DeprecateActivityTypeInput{
ActivityType: &swf.ActivityType{
Name: &activity,
Version: &version,
},
Domain: aws.String(testDomain),
}
ad := ActivityTypeMigrator{
DeprecatedActivityTypes: []swf.DeprecateActivityTypeInput{dep},
Client: client,
}
ad.Migrate()
ad.Migrate()
}
func createDomain() {
config := &aws.Config{
Credentials: credentials.NewEnvCredentials(),
Region: "us-east-1",
}
client := swf.New(config)
req := swf.RegisterDomainInput{
Name: aws.String(testDomain),
Description: aws.String("test domain"),
WorkflowExecutionRetentionPeriodInDays: aws.String("30"),
}
w := DomainMigrator{
RegisteredDomains: []swf.RegisterDomainInput{req},
Client: client,
}
w.Migrate()
}
func ExampleSWF_StartWorkflowExecution() {
svc := swf.New(nil)
params := &swf.StartWorkflowExecutionInput{
Domain: aws.String("DomainName"), // Required
WorkflowID: aws.String("WorkflowId"), // Required
WorkflowType: &swf.WorkflowType{ // Required
Name: aws.String("Name"), // Required
Version: aws.String("Version"), // Required
},
ChildPolicy: aws.String("ChildPolicy"),
ExecutionStartToCloseTimeout: aws.String("DurationInSecondsOptional"),
Input: aws.String("Data"),
TagList: []*string{
aws.String("Tag"), // Required
// More values...
},
TaskList: &swf.TaskList{
Name: aws.String("Name"), // Required
},
TaskPriority: aws.String("TaskPriority"),
TaskStartToCloseTimeout: aws.String("DurationInSecondsOptional"),
}
resp, err := svc.StartWorkflowExecution(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS Error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, The SDK should alwsy return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
func TestMigrateDomains(t *testing.T) {
if os.Getenv("AWS_ACCESS_KEY_ID") == "" || os.Getenv("AWS_SECRET_ACCESS_KEY") == "" {
log.Printf("WARNING: NO AWS CREDS SPECIFIED, SKIPPING MIGRATIONS TEST")
return
}
config := &aws.Config{
Credentials: credentials.NewEnvCredentials(),
Region: "us-east-1",
}
client := swf.New(config)
domain := fmt.Sprintf("test-domain-%d", time.Now().UnixNano()) //dont use the testDomain since we deprecate this one
req := swf.RegisterDomainInput{
Name: aws.String(domain),
Description: aws.String("test domain"),
WorkflowExecutionRetentionPeriodInDays: aws.String("30"),
}
d := DomainMigrator{
RegisteredDomains: []swf.RegisterDomainInput{req},
Client: client,
}
d.Migrate()
d.Migrate()
dep := swf.DeprecateDomainInput{
Name: aws.String(domain),
}
dd := DomainMigrator{
DeprecatedDomains: []swf.DeprecateDomainInput{dep},
Client: client,
}
dd.Migrate()
dd.Migrate()
}
func ExampleSWF_RegisterActivityType() {
svc := swf.New(nil)
params := &swf.RegisterActivityTypeInput{
Domain: aws.String("DomainName"), // Required
Name: aws.String("Name"), // Required
Version: aws.String("Version"), // Required
DefaultTaskHeartbeatTimeout: aws.String("DurationInSecondsOptional"),
DefaultTaskList: &swf.TaskList{
Name: aws.String("Name"), // Required
},
DefaultTaskPriority: aws.String("TaskPriority"),
DefaultTaskScheduleToCloseTimeout: aws.String("DurationInSecondsOptional"),
DefaultTaskScheduleToStartTimeout: aws.String("DurationInSecondsOptional"),
DefaultTaskStartToCloseTimeout: aws.String("DurationInSecondsOptional"),
Description: aws.String("Description"),
}
resp, err := svc.RegisterActivityType(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS Error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, The SDK should alwsy return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
func init() {
Before("@swf", func() {
World["client"] = swf.New(nil)
})
}
func TestClient(t *testing.T) {
if os.Getenv("AWS_ACCESS_KEY_ID") == "" || os.Getenv("AWS_SECRET_ACCESS_KEY") == "" {
log.Printf("WARNING: NO AWS CREDS SPECIFIED, SKIPPING MIGRATIONS TEST")
return
}
config := &aws.Config{
Credentials: credentials.NewEnvCredentials(),
Region: "us-east-1",
}
client := swf.New(config)
req := swf.RegisterDomainInput{
Name: aws.String("client-test"),
Description: aws.String("test domain"),
WorkflowExecutionRetentionPeriodInDays: aws.String("30"),
}
d := migrator.DomainMigrator{
RegisteredDomains: []swf.RegisterDomainInput{req},
Client: client,
}
d.Migrate()
wreq := swf.RegisterWorkflowTypeInput{
Name: aws.String("client-test"),
Description: aws.String("test workflow migration"),
Version: aws.String("1"),
Domain: aws.String("client-test"),
}
w := migrator.WorkflowTypeMigrator{
RegisteredWorkflowTypes: []swf.RegisterWorkflowTypeInput{wreq},
Client: client,
}
w.Migrate()
fsm := &FSM{
Domain: "client-test",
Name: "client-test",
DataType: TestData{},
Serializer: JSONStateSerializer{},
systemSerializer: JSONStateSerializer{},
allowPanics: false,
}
fsm.AddInitialState(&FSMState{Name: "initial",
Decider: func(ctx *FSMContext, h *swf.HistoryEvent, data interface{}) Outcome {
if *h.EventType == enums.EventTypeWorkflowExecutionSignaled {
d := data.(*TestData)
d.States = append(d.States, *h.WorkflowExecutionSignaledEventAttributes.SignalName)
}
return ctx.Stay(data, ctx.EmptyDecisions())
},
})
fsmClient := NewFSMClient(fsm, client)
workflow := uuid.New()
testData := uuid.New()
startTemplate := swf.StartWorkflowExecutionInput{
WorkflowType: &swf.WorkflowType{Name: aws.String("client-test"), Version: aws.String("1")},
ExecutionStartToCloseTimeout: aws.String("120"),
TaskStartToCloseTimeout: aws.String("120"),
ChildPolicy: aws.String("ABANDON"),
TaskList: &swf.TaskList{Name: aws.String("task-list")},
}
_, err := fsmClient.Start(startTemplate, workflow, &TestData{States: []string{testData}})
if err != nil {
t.Fatal(err)
}
state, data, err := fsmClient.GetState(workflow)
if err != nil {
t.Fatal(err)
}
if data.(*TestData).States[0] != testData {
t.Fatal(data)
}
if state != "initial" {
t.Fatal("not in initial")
}
found := false
err = fsmClient.WalkOpenWorkflowInfos(&swf.ListOpenWorkflowExecutionsInput{}, func(infos *swf.WorkflowExecutionInfos) error {
for _, info := range infos.ExecutionInfos {
if *info.Execution.WorkflowID == workflow {
found = true
return StopWalking()
}
}
return nil
})
if err != nil {
t.Fatal(err)
}
if !found {
t.Fatalf("%s not found", workflow)
}
snapshots, err := fsmClient.GetSnapshots(workflow)
if err != nil {
t.Fatal(err)
}
if length := len(snapshots); length != 1 {
t.Fatalf("snapshots length: %d", length)
}
if name := snapshots[0].Event.Name; name != "start" {
t.Fatalf("snapshots[0].Event.Name: %s ", name)
}
if Type := snapshots[0].Event.Type; Type != enums.EventTypeWorkflowExecutionStarted {
t.Fatalf("snapshots[0].Event.Type: %s ", Type)
}
if name := snapshots[0].State.Name; name != "initial" {
t.Fatalf("snapshots[0].State.Name: %s ", name)
}
if version := snapshots[0].State.Version; version != 0 {
t.Fatalf("snapshots[0].State.Version: %d ", version)
}
if id := snapshots[0].State.ID; id != 1 {
t.Fatalf("snapshots[0].State.ID: %d ", id)
}
}
func TestInterface(t *testing.T) {
assert.Implements(t, (*swfiface.SWFAPI)(nil), swf.New(nil))
}
func ExampleSWF_RespondDecisionTaskCompleted() {
svc := swf.New(nil)
params := &swf.RespondDecisionTaskCompletedInput{
TaskToken: aws.String("TaskToken"), // Required
Decisions: []*swf.Decision{
&swf.Decision{ // Required
DecisionType: aws.String("DecisionType"), // Required
CancelTimerDecisionAttributes: &swf.CancelTimerDecisionAttributes{
TimerID: aws.String("TimerId"), // Required
},
CancelWorkflowExecutionDecisionAttributes: &swf.CancelWorkflowExecutionDecisionAttributes{
Details: aws.String("Data"),
},
CompleteWorkflowExecutionDecisionAttributes: &swf.CompleteWorkflowExecutionDecisionAttributes{
Result: aws.String("Data"),
},
ContinueAsNewWorkflowExecutionDecisionAttributes: &swf.ContinueAsNewWorkflowExecutionDecisionAttributes{
ChildPolicy: aws.String("ChildPolicy"),
ExecutionStartToCloseTimeout: aws.String("DurationInSecondsOptional"),
Input: aws.String("Data"),
TagList: []*string{
aws.String("Tag"), // Required
// More values...
},
TaskList: &swf.TaskList{
Name: aws.String("Name"), // Required
},
TaskPriority: aws.String("TaskPriority"),
TaskStartToCloseTimeout: aws.String("DurationInSecondsOptional"),
WorkflowTypeVersion: aws.String("Version"),
},
FailWorkflowExecutionDecisionAttributes: &swf.FailWorkflowExecutionDecisionAttributes{
Details: aws.String("Data"),
Reason: aws.String("FailureReason"),
},
RecordMarkerDecisionAttributes: &swf.RecordMarkerDecisionAttributes{
MarkerName: aws.String("MarkerName"), // Required
Details: aws.String("Data"),
},
RequestCancelActivityTaskDecisionAttributes: &swf.RequestCancelActivityTaskDecisionAttributes{
ActivityID: aws.String("ActivityId"), // Required
},
RequestCancelExternalWorkflowExecutionDecisionAttributes: &swf.RequestCancelExternalWorkflowExecutionDecisionAttributes{
WorkflowID: aws.String("WorkflowId"), // Required
Control: aws.String("Data"),
RunID: aws.String("RunIdOptional"),
},
ScheduleActivityTaskDecisionAttributes: &swf.ScheduleActivityTaskDecisionAttributes{
ActivityID: aws.String("ActivityId"), // Required
ActivityType: &swf.ActivityType{ // Required
Name: aws.String("Name"), // Required
Version: aws.String("Version"), // Required
},
Control: aws.String("Data"),
HeartbeatTimeout: aws.String("DurationInSecondsOptional"),
Input: aws.String("Data"),
ScheduleToCloseTimeout: aws.String("DurationInSecondsOptional"),
ScheduleToStartTimeout: aws.String("DurationInSecondsOptional"),
StartToCloseTimeout: aws.String("DurationInSecondsOptional"),
TaskList: &swf.TaskList{
Name: aws.String("Name"), // Required
},
TaskPriority: aws.String("TaskPriority"),
},
SignalExternalWorkflowExecutionDecisionAttributes: &swf.SignalExternalWorkflowExecutionDecisionAttributes{
SignalName: aws.String("SignalName"), // Required
WorkflowID: aws.String("WorkflowId"), // Required
Control: aws.String("Data"),
Input: aws.String("Data"),
RunID: aws.String("RunIdOptional"),
},
StartChildWorkflowExecutionDecisionAttributes: &swf.StartChildWorkflowExecutionDecisionAttributes{
WorkflowID: aws.String("WorkflowId"), // Required
WorkflowType: &swf.WorkflowType{ // Required
Name: aws.String("Name"), // Required
Version: aws.String("Version"), // Required
},
ChildPolicy: aws.String("ChildPolicy"),
Control: aws.String("Data"),
ExecutionStartToCloseTimeout: aws.String("DurationInSecondsOptional"),
Input: aws.String("Data"),
TagList: []*string{
aws.String("Tag"), // Required
// More values...
},
TaskList: &swf.TaskList{
Name: aws.String("Name"), // Required
},
TaskPriority: aws.String("TaskPriority"),
TaskStartToCloseTimeout: aws.String("DurationInSecondsOptional"),
},
StartTimerDecisionAttributes: &swf.StartTimerDecisionAttributes{
StartToFireTimeout: aws.String("DurationInSeconds"), // Required
TimerID: aws.String("TimerId"), // Required
Control: aws.String("Data"),
},
},
// More values...
},
ExecutionContext: aws.String("Data"),
}
resp, err := svc.RespondDecisionTaskCompleted(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS Error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, The SDK should alwsy return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
func TestTypedActivityWorker(t *testing.T) {
if os.Getenv("AWS_ACCESS_KEY_ID") == "" || os.Getenv("AWS_SECRET_ACCESS_KEY") == "" {
log.Printf("WARNING: NO AWS CREDS SPECIFIED, SKIPPING MIGRATIONS TEST")
return
}
config := &aws.Config{
Credentials: credentials.NewEnvCredentials(),
Region: "us-east-1",
}
client := swf.New(config)
domain := "worker-test-domain"
req := swf.RegisterDomainInput{
Name: aws.String(domain),
Description: aws.String("test domain"),
WorkflowExecutionRetentionPeriodInDays: aws.String("30"),
}
d := migrator.DomainMigrator{
RegisteredDomains: []swf.RegisterDomainInput{req},
Client: client,
}
d.Migrate()
workflow := "worker-test-workflow"
version := "worker-test-workflow-version"
wreq := swf.RegisterWorkflowTypeInput{
Name: &workflow,
Description: aws.String("test workflow migration"),
Version: &version,
Domain: aws.String(domain),
DefaultTaskList: &swf.TaskList{Name: S("worker-fsm")},
}
w := migrator.WorkflowTypeMigrator{
RegisteredWorkflowTypes: []swf.RegisterWorkflowTypeInput{wreq},
Client: client,
}
w.Migrate()
one := swf.RegisterActivityTypeInput{
Name: aws.String("one"),
Description: aws.String("worker test activity 1"),
Version: aws.String("one"),
Domain: aws.String(domain),
}
two := swf.RegisterActivityTypeInput{
Name: aws.String("two"),
Description: aws.String("worker test activity 2"),
Version: aws.String("two"),
Domain: aws.String(domain),
}
a := migrator.ActivityTypeMigrator{
RegisteredActivityTypes: []swf.RegisterActivityTypeInput{one, two},
Client: client,
}
a.Migrate()
taskList := "aTaskListSharedBetweenTaskOneAndTwo"
worker := &ActivityWorker{
Domain: domain,
Serializer: fsm.JSONStateSerializer{},
TaskList: taskList,
SWF: client,
Identity: "test-activity-worker",
}
//This is where the actual worker config code is
var activities Activities
activities = MockActivities{}
worker.AddHandler(NewActivityHandler("one", activities.Task1))
worker.AddHandler(NewActivityHandler("two", activities.Task2))
go worker.Start()
//yep thats all the worker config code
done := make(chan struct{})
go NewWorkerFSM(client, done).Start()
_, err := client.StartWorkflowExecution(&swf.StartWorkflowExecutionInput{
Domain: S(domain),
WorkflowID: S("worker-test"),
WorkflowType: &swf.WorkflowType{Name: S(workflow), Version: S(version)},
Input: S("{}"),
ExecutionStartToCloseTimeout: S("90"),
TaskStartToCloseTimeout: S("10"),
ChildPolicy: S("ABANDON"),
})
if err != nil {
t.Fatal(err)
}
select {
case <-done:
case <-time.After(1 * time.Minute):
t.Fatal("One Minute Elapsed, not done with workflow")
}
}