module Network.AWS.DataPipeline.Types
(
DataPipeline
, JSONError
, ParameterObject
, parameterObject
, poAttributes
, poId
, PipelineObject
, pipelineObject
, po1Fields
, po1Id
, po1Name
, Tag
, tag
, tagKey
, tagValue
, Field
, field
, fKey
, fRefValue
, fStringValue
, ParameterValue
, parameterValue
, pvId
, pvStringValue
, Selector
, selector
, sFieldName
, sOperator
, ParameterAttribute
, parameterAttribute
, paKey
, paStringValue
, Operator
, operator
, oType
, oValues
, TaskObject
, taskObject
, toAttemptId
, toObjects
, toPipelineId
, toTaskId
, ValidationError
, validationError
, veErrors
, veId
, PipelineDescription
, pipelineDescription
, pdDescription
, pdFields
, pdName
, pdPipelineId
, pdTags
, InstanceIdentity
, instanceIdentity
, iiDocument
, iiSignature
, Query
, query
, qSelectors
, OperatorType (..)
, PipelineIdName
, pipelineIdName
, pinId
, pinName
, TaskStatus (..)
, ValidationWarning
, validationWarning
, vwId
, vwWarnings
) where
import Network.AWS.Prelude
import Network.AWS.Signing
import qualified GHC.Exts
data DataPipeline
instance AWSService DataPipeline where
type Sg DataPipeline = V4
type Er DataPipeline = JSONError
service = service'
where
service' :: Service DataPipeline
service' = Service
{ _svcAbbrev = "DataPipeline"
, _svcPrefix = "datapipeline"
, _svcVersion = "2012-10-29"
, _svcTargetPrefix = Just "DataPipeline"
, _svcJSONVersion = Just "1.1"
, _svcHandle = handle
, _svcRetry = retry
}
handle :: Status
-> Maybe (LazyByteString -> ServiceError JSONError)
handle = jsonError statusSuccess service'
retry :: Retry DataPipeline
retry = Exponential
{ _retryBase = 0.05
, _retryGrowth = 2
, _retryAttempts = 5
, _retryCheck = check
}
check :: Status
-> JSONError
-> Bool
check (statusCode -> s) (awsErrorCode -> e)
| s == 400 && (Just "Throttling") == e = True
| s == 500 = True
| s == 509 = True
| s == 503 = True
| otherwise = False
data ParameterObject = ParameterObject
{ _poAttributes :: List "attributes" ParameterAttribute
, _poId :: Text
} deriving (Eq, Read, Show)
parameterObject :: Text
-> ParameterObject
parameterObject p1 = ParameterObject
{ _poId = p1
, _poAttributes = mempty
}
poAttributes :: Lens' ParameterObject [ParameterAttribute]
poAttributes = lens _poAttributes (\s a -> s { _poAttributes = a }) . _List
poId :: Lens' ParameterObject Text
poId = lens _poId (\s a -> s { _poId = a })
instance FromJSON ParameterObject where
parseJSON = withObject "ParameterObject" $ \o -> ParameterObject
<$> o .:? "attributes" .!= mempty
<*> o .: "id"
instance ToJSON ParameterObject where
toJSON ParameterObject{..} = object
[ "id" .= _poId
, "attributes" .= _poAttributes
]
data PipelineObject = PipelineObject
{ _po1Fields :: List "fields" Field
, _po1Id :: Text
, _po1Name :: Text
} deriving (Eq, Read, Show)
pipelineObject :: Text
-> Text
-> PipelineObject
pipelineObject p1 p2 = PipelineObject
{ _po1Id = p1
, _po1Name = p2
, _po1Fields = mempty
}
po1Fields :: Lens' PipelineObject [Field]
po1Fields = lens _po1Fields (\s a -> s { _po1Fields = a }) . _List
po1Id :: Lens' PipelineObject Text
po1Id = lens _po1Id (\s a -> s { _po1Id = a })
po1Name :: Lens' PipelineObject Text
po1Name = lens _po1Name (\s a -> s { _po1Name = a })
instance FromJSON PipelineObject where
parseJSON = withObject "PipelineObject" $ \o -> PipelineObject
<$> o .:? "fields" .!= mempty
<*> o .: "id"
<*> o .: "name"
instance ToJSON PipelineObject where
toJSON PipelineObject{..} = object
[ "id" .= _po1Id
, "name" .= _po1Name
, "fields" .= _po1Fields
]
data Tag = Tag
{ _tagKey :: Text
, _tagValue :: Text
} deriving (Eq, Ord, Read, Show)
tag :: Text
-> Text
-> Tag
tag p1 p2 = Tag
{ _tagKey = p1
, _tagValue = p2
}
tagKey :: Lens' Tag Text
tagKey = lens _tagKey (\s a -> s { _tagKey = a })
tagValue :: Lens' Tag Text
tagValue = lens _tagValue (\s a -> s { _tagValue = a })
instance FromJSON Tag where
parseJSON = withObject "Tag" $ \o -> Tag
<$> o .: "key"
<*> o .: "value"
instance ToJSON Tag where
toJSON Tag{..} = object
[ "key" .= _tagKey
, "value" .= _tagValue
]
data Field = Field
{ _fKey :: Text
, _fRefValue :: Maybe Text
, _fStringValue :: Maybe Text
} deriving (Eq, Ord, Read, Show)
field :: Text
-> Field
field p1 = Field
{ _fKey = p1
, _fStringValue = Nothing
, _fRefValue = Nothing
}
fKey :: Lens' Field Text
fKey = lens _fKey (\s a -> s { _fKey = a })
fRefValue :: Lens' Field (Maybe Text)
fRefValue = lens _fRefValue (\s a -> s { _fRefValue = a })
fStringValue :: Lens' Field (Maybe Text)
fStringValue = lens _fStringValue (\s a -> s { _fStringValue = a })
instance FromJSON Field where
parseJSON = withObject "Field" $ \o -> Field
<$> o .: "key"
<*> o .:? "refValue"
<*> o .:? "stringValue"
instance ToJSON Field where
toJSON Field{..} = object
[ "key" .= _fKey
, "stringValue" .= _fStringValue
, "refValue" .= _fRefValue
]
data ParameterValue = ParameterValue
{ _pvId :: Text
, _pvStringValue :: Text
} deriving (Eq, Ord, Read, Show)
parameterValue :: Text
-> Text
-> ParameterValue
parameterValue p1 p2 = ParameterValue
{ _pvId = p1
, _pvStringValue = p2
}
pvId :: Lens' ParameterValue Text
pvId = lens _pvId (\s a -> s { _pvId = a })
pvStringValue :: Lens' ParameterValue Text
pvStringValue = lens _pvStringValue (\s a -> s { _pvStringValue = a })
instance FromJSON ParameterValue where
parseJSON = withObject "ParameterValue" $ \o -> ParameterValue
<$> o .: "id"
<*> o .: "stringValue"
instance ToJSON ParameterValue where
toJSON ParameterValue{..} = object
[ "id" .= _pvId
, "stringValue" .= _pvStringValue
]
data Selector = Selector
{ _sFieldName :: Maybe Text
, _sOperator :: Maybe Operator
} deriving (Eq, Read, Show)
selector :: Selector
selector = Selector
{ _sFieldName = Nothing
, _sOperator = Nothing
}
sFieldName :: Lens' Selector (Maybe Text)
sFieldName = lens _sFieldName (\s a -> s { _sFieldName = a })
sOperator :: Lens' Selector (Maybe Operator)
sOperator = lens _sOperator (\s a -> s { _sOperator = a })
instance FromJSON Selector where
parseJSON = withObject "Selector" $ \o -> Selector
<$> o .:? "fieldName"
<*> o .:? "operator"
instance ToJSON Selector where
toJSON Selector{..} = object
[ "fieldName" .= _sFieldName
, "operator" .= _sOperator
]
data ParameterAttribute = ParameterAttribute
{ _paKey :: Text
, _paStringValue :: Text
} deriving (Eq, Ord, Read, Show)
parameterAttribute :: Text
-> Text
-> ParameterAttribute
parameterAttribute p1 p2 = ParameterAttribute
{ _paKey = p1
, _paStringValue = p2
}
paKey :: Lens' ParameterAttribute Text
paKey = lens _paKey (\s a -> s { _paKey = a })
paStringValue :: Lens' ParameterAttribute Text
paStringValue = lens _paStringValue (\s a -> s { _paStringValue = a })
instance FromJSON ParameterAttribute where
parseJSON = withObject "ParameterAttribute" $ \o -> ParameterAttribute
<$> o .: "key"
<*> o .: "stringValue"
instance ToJSON ParameterAttribute where
toJSON ParameterAttribute{..} = object
[ "key" .= _paKey
, "stringValue" .= _paStringValue
]
data Operator = Operator
{ _oType :: Maybe OperatorType
, _oValues :: List "values" Text
} deriving (Eq, Read, Show)
operator :: Operator
operator = Operator
{ _oType = Nothing
, _oValues = mempty
}
oType :: Lens' Operator (Maybe OperatorType)
oType = lens _oType (\s a -> s { _oType = a })
oValues :: Lens' Operator [Text]
oValues = lens _oValues (\s a -> s { _oValues = a }) . _List
instance FromJSON Operator where
parseJSON = withObject "Operator" $ \o -> Operator
<$> o .:? "type"
<*> o .:? "values" .!= mempty
instance ToJSON Operator where
toJSON Operator{..} = object
[ "type" .= _oType
, "values" .= _oValues
]
data TaskObject = TaskObject
{ _toAttemptId :: Maybe Text
, _toObjects :: Map Text PipelineObject
, _toPipelineId :: Maybe Text
, _toTaskId :: Maybe Text
} deriving (Eq, Read, Show)
taskObject :: TaskObject
taskObject = TaskObject
{ _toTaskId = Nothing
, _toPipelineId = Nothing
, _toAttemptId = Nothing
, _toObjects = mempty
}
toAttemptId :: Lens' TaskObject (Maybe Text)
toAttemptId = lens _toAttemptId (\s a -> s { _toAttemptId = a })
toObjects :: Lens' TaskObject (HashMap Text PipelineObject)
toObjects = lens _toObjects (\s a -> s { _toObjects = a }) . _Map
toPipelineId :: Lens' TaskObject (Maybe Text)
toPipelineId = lens _toPipelineId (\s a -> s { _toPipelineId = a })
toTaskId :: Lens' TaskObject (Maybe Text)
toTaskId = lens _toTaskId (\s a -> s { _toTaskId = a })
instance FromJSON TaskObject where
parseJSON = withObject "TaskObject" $ \o -> TaskObject
<$> o .:? "attemptId"
<*> o .:? "objects" .!= mempty
<*> o .:? "pipelineId"
<*> o .:? "taskId"
instance ToJSON TaskObject where
toJSON TaskObject{..} = object
[ "taskId" .= _toTaskId
, "pipelineId" .= _toPipelineId
, "attemptId" .= _toAttemptId
, "objects" .= _toObjects
]
data ValidationError = ValidationError
{ _veErrors :: List "errors" Text
, _veId :: Maybe Text
} deriving (Eq, Ord, Read, Show)
validationError :: ValidationError
validationError = ValidationError
{ _veId = Nothing
, _veErrors = mempty
}
veErrors :: Lens' ValidationError [Text]
veErrors = lens _veErrors (\s a -> s { _veErrors = a }) . _List
veId :: Lens' ValidationError (Maybe Text)
veId = lens _veId (\s a -> s { _veId = a })
instance FromJSON ValidationError where
parseJSON = withObject "ValidationError" $ \o -> ValidationError
<$> o .:? "errors" .!= mempty
<*> o .:? "id"
instance ToJSON ValidationError where
toJSON ValidationError{..} = object
[ "id" .= _veId
, "errors" .= _veErrors
]
data PipelineDescription = PipelineDescription
{ _pdDescription :: Maybe Text
, _pdFields :: List "fields" Field
, _pdName :: Text
, _pdPipelineId :: Text
, _pdTags :: List "tags" Tag
} deriving (Eq, Read, Show)
pipelineDescription :: Text
-> Text
-> PipelineDescription
pipelineDescription p1 p2 = PipelineDescription
{ _pdPipelineId = p1
, _pdName = p2
, _pdFields = mempty
, _pdDescription = Nothing
, _pdTags = mempty
}
pdDescription :: Lens' PipelineDescription (Maybe Text)
pdDescription = lens _pdDescription (\s a -> s { _pdDescription = a })
pdFields :: Lens' PipelineDescription [Field]
pdFields = lens _pdFields (\s a -> s { _pdFields = a }) . _List
pdName :: Lens' PipelineDescription Text
pdName = lens _pdName (\s a -> s { _pdName = a })
pdPipelineId :: Lens' PipelineDescription Text
pdPipelineId = lens _pdPipelineId (\s a -> s { _pdPipelineId = a })
pdTags :: Lens' PipelineDescription [Tag]
pdTags = lens _pdTags (\s a -> s { _pdTags = a }) . _List
instance FromJSON PipelineDescription where
parseJSON = withObject "PipelineDescription" $ \o -> PipelineDescription
<$> o .:? "description"
<*> o .:? "fields" .!= mempty
<*> o .: "name"
<*> o .: "pipelineId"
<*> o .:? "tags" .!= mempty
instance ToJSON PipelineDescription where
toJSON PipelineDescription{..} = object
[ "pipelineId" .= _pdPipelineId
, "name" .= _pdName
, "fields" .= _pdFields
, "description" .= _pdDescription
, "tags" .= _pdTags
]
data InstanceIdentity = InstanceIdentity
{ _iiDocument :: Maybe Text
, _iiSignature :: Maybe Text
} deriving (Eq, Ord, Read, Show)
instanceIdentity :: InstanceIdentity
instanceIdentity = InstanceIdentity
{ _iiDocument = Nothing
, _iiSignature = Nothing
}
iiDocument :: Lens' InstanceIdentity (Maybe Text)
iiDocument = lens _iiDocument (\s a -> s { _iiDocument = a })
iiSignature :: Lens' InstanceIdentity (Maybe Text)
iiSignature = lens _iiSignature (\s a -> s { _iiSignature = a })
instance FromJSON InstanceIdentity where
parseJSON = withObject "InstanceIdentity" $ \o -> InstanceIdentity
<$> o .:? "document"
<*> o .:? "signature"
instance ToJSON InstanceIdentity where
toJSON InstanceIdentity{..} = object
[ "document" .= _iiDocument
, "signature" .= _iiSignature
]
newtype Query = Query
{ _qSelectors :: List "selectors" Selector
} deriving (Eq, Read, Show, Monoid, Semigroup)
instance GHC.Exts.IsList Query where
type Item Query = Selector
fromList = Query . GHC.Exts.fromList
toList = GHC.Exts.toList . _qSelectors
query :: Query
query = Query
{ _qSelectors = mempty
}
qSelectors :: Lens' Query [Selector]
qSelectors = lens _qSelectors (\s a -> s { _qSelectors = a }) . _List
instance FromJSON Query where
parseJSON = withObject "Query" $ \o -> Query
<$> o .:? "selectors" .!= mempty
instance ToJSON Query where
toJSON Query{..} = object
[ "selectors" .= _qSelectors
]
data OperatorType
= OperatorBetween
| OperatorEq
| OperatorGe
| OperatorLe
| OperatorRefEq
deriving (Eq, Ord, Read, Show, Generic, Enum)
instance Hashable OperatorType
instance FromText OperatorType where
parser = takeLowerText >>= \case
"between" -> pure OperatorBetween
"eq" -> pure OperatorEq
"ge" -> pure OperatorGe
"le" -> pure OperatorLe
"ref_eq" -> pure OperatorRefEq
e -> fail $
"Failure parsing OperatorType from " ++ show e
instance ToText OperatorType where
toText = \case
OperatorBetween -> "BETWEEN"
OperatorEq -> "EQ"
OperatorGe -> "GE"
OperatorLe -> "LE"
OperatorRefEq -> "REF_EQ"
instance ToByteString OperatorType
instance ToHeader OperatorType
instance ToQuery OperatorType
instance FromJSON OperatorType where
parseJSON = parseJSONText "OperatorType"
instance ToJSON OperatorType where
toJSON = toJSONText
data PipelineIdName = PipelineIdName
{ _pinId :: Maybe Text
, _pinName :: Maybe Text
} deriving (Eq, Ord, Read, Show)
pipelineIdName :: PipelineIdName
pipelineIdName = PipelineIdName
{ _pinId = Nothing
, _pinName = Nothing
}
pinId :: Lens' PipelineIdName (Maybe Text)
pinId = lens _pinId (\s a -> s { _pinId = a })
pinName :: Lens' PipelineIdName (Maybe Text)
pinName = lens _pinName (\s a -> s { _pinName = a })
instance FromJSON PipelineIdName where
parseJSON = withObject "PipelineIdName" $ \o -> PipelineIdName
<$> o .:? "id"
<*> o .:? "name"
instance ToJSON PipelineIdName where
toJSON PipelineIdName{..} = object
[ "id" .= _pinId
, "name" .= _pinName
]
data TaskStatus
= Failed
| False'
| Finished
deriving (Eq, Ord, Read, Show, Generic, Enum)
instance Hashable TaskStatus
instance FromText TaskStatus where
parser = takeLowerText >>= \case
"failed" -> pure Failed
"false" -> pure False'
"finished" -> pure Finished
e -> fail $
"Failure parsing TaskStatus from " ++ show e
instance ToText TaskStatus where
toText = \case
Failed -> "FAILED"
False' -> "FALSE"
Finished -> "FINISHED"
instance ToByteString TaskStatus
instance ToHeader TaskStatus
instance ToQuery TaskStatus
instance FromJSON TaskStatus where
parseJSON = parseJSONText "TaskStatus"
instance ToJSON TaskStatus where
toJSON = toJSONText
data ValidationWarning = ValidationWarning
{ _vwId :: Maybe Text
, _vwWarnings :: List "warnings" Text
} deriving (Eq, Ord, Read, Show)
validationWarning :: ValidationWarning
validationWarning = ValidationWarning
{ _vwId = Nothing
, _vwWarnings = mempty
}
vwId :: Lens' ValidationWarning (Maybe Text)
vwId = lens _vwId (\s a -> s { _vwId = a })
vwWarnings :: Lens' ValidationWarning [Text]
vwWarnings = lens _vwWarnings (\s a -> s { _vwWarnings = a }) . _List
instance FromJSON ValidationWarning where
parseJSON = withObject "ValidationWarning" $ \o -> ValidationWarning
<$> o .:? "id"
<*> o .:? "warnings" .!= mempty
instance ToJSON ValidationWarning where
toJSON ValidationWarning{..} = object
[ "id" .= _vwId
, "warnings" .= _vwWarnings
]