func ExampleDataPipeline_ReportTaskRunnerHeartbeat() {
svc := datapipeline.New(nil)
params := &datapipeline.ReportTaskRunnerHeartbeatInput{
TaskrunnerId: aws.String("id"), // Required
Hostname: aws.String("id"),
WorkerGroup: aws.String("string"),
}
resp, err := svc.ReportTaskRunnerHeartbeat(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 ExampleDataPipeline_CreatePipeline() {
svc := datapipeline.New(nil)
params := &datapipeline.CreatePipelineInput{
Name: aws.String("id"), // Required
UniqueId: aws.String("id"), // Required
Description: aws.String("string"),
Tags: []*datapipeline.Tag{
{ // Required
Key: aws.String("tagKey"), // Required
Value: aws.String("tagValue"), // Required
},
// More values...
},
}
resp, err := svc.CreatePipeline(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 ExampleDataPipeline_SetTaskStatus() {
svc := datapipeline.New(nil)
params := &datapipeline.SetTaskStatusInput{
TaskId: aws.String("taskId"), // Required
TaskStatus: aws.String("TaskStatus"), // Required
ErrorId: aws.String("string"),
ErrorMessage: aws.String("errorMessage"),
ErrorStackTrace: aws.String("string"),
}
resp, err := svc.SetTaskStatus(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 ExampleDataPipeline_ReportTaskProgress() {
svc := datapipeline.New(nil)
params := &datapipeline.ReportTaskProgressInput{
TaskId: aws.String("taskId"), // Required
Fields: []*datapipeline.Field{
{ // Required
Key: aws.String("fieldNameString"), // Required
RefValue: aws.String("fieldNameString"),
StringValue: aws.String("fieldStringValue"),
},
// More values...
},
}
resp, err := svc.ReportTaskProgress(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 ExampleDataPipeline_EvaluateExpression() {
svc := datapipeline.New(nil)
params := &datapipeline.EvaluateExpressionInput{
Expression: aws.String("longString"), // Required
ObjectId: aws.String("id"), // Required
PipelineId: aws.String("id"), // Required
}
resp, err := svc.EvaluateExpression(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 ExampleDataPipeline_ActivatePipeline() {
svc := datapipeline.New(nil)
params := &datapipeline.ActivatePipelineInput{
PipelineId: aws.String("id"), // Required
ParameterValues: []*datapipeline.ParameterValue{
{ // Required
Id: aws.String("fieldNameString"), // Required
StringValue: aws.String("fieldStringValue"), // Required
},
// More values...
},
StartTimestamp: aws.Time(time.Now()),
}
resp, err := svc.ActivatePipeline(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 ExampleDataPipeline_QueryObjects() {
svc := datapipeline.New(nil)
params := &datapipeline.QueryObjectsInput{
PipelineId: aws.String("id"), // Required
Sphere: aws.String("string"), // Required
Limit: aws.Int64(1),
Marker: aws.String("string"),
Query: &datapipeline.Query{
Selectors: []*datapipeline.Selector{
{ // Required
FieldName: aws.String("string"),
Operator: &datapipeline.Operator{
Type: aws.String("OperatorType"),
Values: []*string{
aws.String("string"), // Required
// More values...
},
},
},
// More values...
},
},
}
resp, err := svc.QueryObjects(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 TestInterface(t *testing.T) {
assert.Implements(t, (*datapipelineiface.DataPipelineAPI)(nil), datapipeline.New(nil))
}
func ExampleDataPipeline_ValidatePipelineDefinition() {
svc := datapipeline.New(nil)
params := &datapipeline.ValidatePipelineDefinitionInput{
PipelineId: aws.String("id"), // Required
PipelineObjects: []*datapipeline.PipelineObject{ // Required
{ // Required
Fields: []*datapipeline.Field{ // Required
{ // Required
Key: aws.String("fieldNameString"), // Required
RefValue: aws.String("fieldNameString"),
StringValue: aws.String("fieldStringValue"),
},
// More values...
},
Id: aws.String("id"), // Required
Name: aws.String("id"), // Required
},
// More values...
},
ParameterObjects: []*datapipeline.ParameterObject{
{ // Required
Attributes: []*datapipeline.ParameterAttribute{ // Required
{ // Required
Key: aws.String("attributeNameString"), // Required
StringValue: aws.String("attributeValueString"), // Required
},
// More values...
},
Id: aws.String("fieldNameString"), // Required
},
// More values...
},
ParameterValues: []*datapipeline.ParameterValue{
{ // Required
Id: aws.String("fieldNameString"), // Required
StringValue: aws.String("fieldStringValue"), // Required
},
// More values...
},
}
resp, err := svc.ValidatePipelineDefinition(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 init() {
Before("@datapipeline", func() {
World["client"] = datapipeline.New(nil)
})
}