func ExampleSWF_DescribeWorkflowType() { sess, err := session.NewSession() if err != nil { fmt.Println("failed to create session,", err) return } svc := swf.New(sess) params := &swf.DescribeWorkflowTypeInput{ Domain: aws.String("DomainName"), // Required WorkflowType: &swf.WorkflowType{ // Required Name: aws.String("Name"), // Required Version: aws.String("Version"), // Required }, } resp, err := svc.DescribeWorkflowType(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func ExampleSWF_GetWorkflowExecutionHistory() { svc := swf.New(session.New()) params := &swf.GetWorkflowExecutionHistoryInput{ Domain: aws.String("DomainName"), // Required Execution: &swf.WorkflowExecution{ // Required RunId: aws.String("RunId"), // Required WorkflowId: aws.String("WorkflowId"), // Required }, MaximumPageSize: aws.Int64(1), NextPageToken: aws.String("PageToken"), ReverseOrder: aws.Bool(true), } resp, err := svc.GetWorkflowExecutionHistory(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func ExampleSWF_PollForDecisionTask() { svc := swf.New(session.New()) params := &swf.PollForDecisionTaskInput{ Domain: aws.String("DomainName"), // Required TaskList: &swf.TaskList{ // Required Name: aws.String("Name"), // Required }, Identity: aws.String("Identity"), MaximumPageSize: aws.Int64(1), NextPageToken: aws.String("PageToken"), ReverseOrder: aws.Bool(true), } resp, err := svc.PollForDecisionTask(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
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 always 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 always 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_CountPendingDecisionTasks() { svc := swf.New(nil) params := &swf.CountPendingDecisionTasksInput{ Domain: aws.String("DomainName"), // Required TaskList: &swf.TaskList{ // Required Name: aws.String("Name"), // Required }, } resp, err := svc.CountPendingDecisionTasks(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 always return an // error which satisfies the awserr.Error interface. fmt.Println(err.Error()) } } // Pretty-print the response data. fmt.Println(awsutil.Prettify(resp)) }
func ExampleSWF_RegisterDomain() { svc := swf.New(nil) params := &swf.RegisterDomainInput{ Name: aws.String("DomainName"), // Required WorkflowExecutionRetentionPeriodInDays: aws.String("DurationInDays"), // Required Description: aws.String("Description"), } resp, err := svc.RegisterDomain(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 always return an // error which satisfies the awserr.Error interface. fmt.Println(err.Error()) } } // Pretty-print the response data. fmt.Println(awsutil.Prettify(resp)) }
func ExampleSWF_ListOpenWorkflowExecutions() { svc := swf.New(nil) params := &swf.ListOpenWorkflowExecutionsInput{ Domain: aws.String("DomainName"), // Required StartTimeFilter: &swf.ExecutionTimeFilter{ // Required OldestDate: aws.Time(time.Now()), // Required LatestDate: aws.Time(time.Now()), }, ExecutionFilter: &swf.WorkflowExecutionFilter{ WorkflowId: aws.String("WorkflowId"), // Required }, MaximumPageSize: aws.Int64(1), NextPageToken: aws.String("PageToken"), ReverseOrder: aws.Bool(true), TagFilter: &swf.TagFilter{ Tag: aws.String("Tag"), // Required }, TypeFilter: &swf.WorkflowTypeFilter{ Name: aws.String("Name"), // Required Version: aws.String("VersionOptional"), }, } resp, err := svc.ListOpenWorkflowExecutions(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
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 { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func ExampleSWF_RespondActivityTaskFailed() { sess, err := session.NewSession() if err != nil { fmt.Println("failed to create session,", err) return } svc := swf.New(sess) params := &swf.RespondActivityTaskFailedInput{ TaskToken: aws.String("TaskToken"), // Required Details: aws.String("Data"), Reason: aws.String("FailureReason"), } resp, err := svc.RespondActivityTaskFailed(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func ExampleSWF_SignalWorkflowExecution() { sess, err := session.NewSession() if err != nil { fmt.Println("failed to create session,", err) return } svc := swf.New(sess) params := &swf.SignalWorkflowExecutionInput{ Domain: aws.String("DomainName"), // Required SignalName: aws.String("SignalName"), // Required WorkflowId: aws.String("WorkflowId"), // Required Input: aws.String("Data"), RunId: aws.String("RunIdOptional"), } resp, err := svc.SignalWorkflowExecution(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func ExampleSWF_RegisterDomain() { sess, err := session.NewSession() if err != nil { fmt.Println("failed to create session,", err) return } svc := swf.New(sess) params := &swf.RegisterDomainInput{ Name: aws.String("DomainName"), // Required WorkflowExecutionRetentionPeriodInDays: aws.String("DurationInDays"), // Required Description: aws.String("Description"), } resp, err := svc.RegisterDomain(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func ExampleSWF_PollForActivityTask() { sess, err := session.NewSession() if err != nil { fmt.Println("failed to create session,", err) return } svc := swf.New(sess) params := &swf.PollForActivityTaskInput{ Domain: aws.String("DomainName"), // Required TaskList: &swf.TaskList{ // Required Name: aws.String("Name"), // Required }, Identity: aws.String("Identity"), } resp, err := svc.PollForActivityTask(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func ExampleSWF_ListWorkflowTypes() { sess, err := session.NewSession() if err != nil { fmt.Println("failed to create session,", err) return } svc := swf.New(sess) params := &swf.ListWorkflowTypesInput{ Domain: aws.String("DomainName"), // Required RegistrationStatus: aws.String("RegistrationStatus"), // Required MaximumPageSize: aws.Int64(1), Name: aws.String("Name"), NextPageToken: aws.String("PageToken"), ReverseOrder: aws.Bool(true), } resp, err := svc.ListWorkflowTypes(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func ExampleSWF_RegisterWorkflowType() { svc := swf.New(session.New()) params := &swf.RegisterWorkflowTypeInput{ Domain: aws.String("DomainName"), // Required Name: aws.String("Name"), // Required Version: aws.String("Version"), // Required DefaultChildPolicy: aws.String("ChildPolicy"), DefaultExecutionStartToCloseTimeout: aws.String("DurationInSecondsOptional"), DefaultLambdaRole: aws.String("Arn"), DefaultTaskList: &swf.TaskList{ Name: aws.String("Name"), // Required }, DefaultTaskPriority: aws.String("TaskPriority"), DefaultTaskStartToCloseTimeout: aws.String("DurationInSecondsOptional"), Description: aws.String("Description"), } resp, err := svc.RegisterWorkflowType(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(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 always 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 always 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 always 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_ListWorkflowTypes() { svc := swf.New(nil) params := &swf.ListWorkflowTypesInput{ Domain: aws.String("DomainName"), // Required RegistrationStatus: aws.String("RegistrationStatus"), // Required MaximumPageSize: aws.Int64(1), Name: aws.String("Name"), NextPageToken: aws.String("PageToken"), ReverseOrder: aws.Bool(true), } resp, err := svc.ListWorkflowTypes(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 always return an // error which satisfies the awserr.Error interface. fmt.Println(err.Error()) } } // Pretty-print the response data. fmt.Println(awsutil.Prettify(resp)) }
func ExampleSWF_CountOpenWorkflowExecutions() { svc := swf.New(session.New()) params := &swf.CountOpenWorkflowExecutionsInput{ Domain: aws.String("DomainName"), // Required StartTimeFilter: &swf.ExecutionTimeFilter{ // Required OldestDate: aws.Time(time.Now()), // Required LatestDate: aws.Time(time.Now()), }, ExecutionFilter: &swf.WorkflowExecutionFilter{ WorkflowId: aws.String("WorkflowId"), // Required }, TagFilter: &swf.TagFilter{ Tag: aws.String("Tag"), // Required }, TypeFilter: &swf.WorkflowTypeFilter{ Name: aws.String("Name"), // Required Version: aws.String("VersionOptional"), }, } resp, err := svc.CountOpenWorkflowExecutions(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
// NewDecider creates a new decider func NewDecider(taskListName, identity, domain string) Decider { decider := &decider{ swfAPI: swf.New(NewSession()), domain: aws.String(domain), taskList: &swf.TaskList{Name: aws.String(taskListName)}, identity: aws.String(identity), } decider.Logger = logger.Log.New("component", "decider", "domain", *decider.domain, "taskListName", taskListName, "identity", identity) return decider }
func NewSimulationStateManager(taskListName, identity, domain string) SimulationStateManager { simulationStateManager := &simulationStateManager{ swfAPI: swf.New(NewSession()), domain: aws.String(domain), taskList: &swf.TaskList{Name: aws.String(taskListName)}, identity: aws.String(identity), } simulationStateManager.FSM = simulationStateManager.setupFSM() simulationStateManager.Logger = logger.Log.New("component", "decider", "domain", *simulationStateManager.domain, "taskListName", taskListName, "identity", identity) return simulationStateManager }
// NewWorker creates a new worker func NewWorker(taskListName, identity, domain string) Worker { worker := &activity.ActivityWorker{ SWF: swf.New(NewSession()), Domain: domain, TaskList: taskListName, Identity: identity, } taskHandler := &activity.ActivityHandler{Activity: "preproc", HandlerFunc: handleTask} worker.AddHandler(taskHandler) workerLog = logger.Log.New("component", "worker", "domain", domain, "taskListName", taskListName, "identity", identity) return worker }
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 always return an // error which satisfies the awserr.Error interface. fmt.Println(err.Error()) } } // Pretty-print the response data. fmt.Println(awsutil.StringValue(resp)) }
func main() { flag.BoolVar(&stdout, "stdout", false, "Log to stdout") flag.Parse() // initialise logs Info, Error = file.InitLogs(stdout, "/var/rapiddecider", "rapiddecider") Info.Println("Starting rapiddecider =================>") // start workflow swfsvc := swf.New(session.New(), &aws.Config{Region: aws.String("us-east-1")}) params := &swf.PollForDecisionTaskInput{ Domain: aws.String(swfDomain), // TaskList: &swf.TaskList{ // Name: aws.String(swfTasklist), // }, Identity: aws.String(swfIdentity), MaximumPageSize: aws.Int64(100), ReverseOrder: aws.Bool(true), } // loop forever while polling for work for { resp, err := swfsvc.PollForDecisionTask(params) if err != nil { amazon.SESSendEmail("*****@*****.**", helpdesk, swfIdentity+" unable to pole", err.Error()) Error.Printf("error: unable to poll for decision: %v\n", err) //panic("Broken, check logs") } // if we do not receive a task token then 60 second time out occured so try again if resp.TaskToken != nil { if *resp.TaskToken != "" { // Re-initialise logs so we get latest date Info, Error = file.InitLogs(stdout, "/var/rapiddecider", "rapiddecider") d := &decision{ svc: swfsvc, tt: *resp.TaskToken, runid: *resp.WorkflowExecution.RunId, workflowid: *resp.WorkflowExecution.WorkflowId, } // make each decision in a goroutine which means that multiple decisions can be made go d.makeDecision(resp.Events, resp.WorkflowExecution.RunId) } } else { Info.Printf("debug - no decisions required\n") } } }
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: aws.String("us-east-1"), } client := swf.New(session.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: aws.String("us-east-1"), } client := swf.New(session.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: aws.String("us-east-1"), } client := swf.New(session.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_DescribeDomain() { svc := swf.New(session.New()) params := &swf.DescribeDomainInput{ Name: aws.String("DomainName"), // Required } resp, err := svc.DescribeDomain(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
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"), LambdaRole: aws.String("Arn"), 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 always return an // error which satisfies the awserr.Error interface. fmt.Println(err.Error()) } } // Pretty-print the response data. fmt.Println(awsutil.Prettify(resp)) }