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))
}
