diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,367 @@ +Mozilla Public License Version 2.0 +================================== + +1. Definitions +-------------- + +1.1. "Contributor" + means each individual or legal entity that creates, contributes to + the creation of, or owns Covered Software. + +1.2. "Contributor Version" + means the combination of the Contributions of others (if any) used + by a Contributor and that particular Contributor's Contribution. + +1.3. "Contribution" + means Covered Software of a particular Contributor. + +1.4. "Covered Software" + means Source Code Form to which the initial Contributor has attached + the notice in Exhibit A, the Executable Form of such Source Code + Form, and Modifications of such Source Code Form, in each case + including portions thereof. + +1.5. "Incompatible With Secondary Licenses" + means + + (a) that the initial Contributor has attached the notice described + in Exhibit B to the Covered Software; or + + (b) that the Covered Software was made available under the terms of + version 1.1 or earlier of the License, but not also under the + terms of a Secondary License. + +1.6. "Executable Form" + means any form of the work other than Source Code Form. + +1.7. "Larger Work" + means a work that combines Covered Software with other material, in + a separate file or files, that is not Covered Software. + +1.8. "License" + means this document. + +1.9. "Licensable" + means having the right to grant, to the maximum extent possible, + whether at the time of the initial grant or subsequently, any and + all of the rights conveyed by this License. + +1.10. "Modifications" + means any of the following: + + (a) any file in Source Code Form that results from an addition to, + deletion from, or modification of the contents of Covered + Software; or + + (b) any new file in Source Code Form that contains any Covered + Software. + +1.11. "Patent Claims" of a Contributor + means any patent claim(s), including without limitation, method, + process, and apparatus claims, in any patent Licensable by such + Contributor that would be infringed, but for the grant of the + License, by the making, using, selling, offering for sale, having + made, import, or transfer of either its Contributions or its + Contributor Version. + +1.12. "Secondary License" + means either the GNU General Public License, Version 2.0, the GNU + Lesser General Public License, Version 2.1, the GNU Affero General + Public License, Version 3.0, or any later versions of those + licenses. + +1.13. "Source Code Form" + means the form of the work preferred for making modifications. + +1.14. "You" (or "Your") + means an individual or a legal entity exercising rights under this + License. For legal entities, "You" includes any entity that + controls, is controlled by, or is under common control with You. For + purposes of this definition, "control" means (a) the power, direct + or indirect, to cause the direction or management of such entity, + whether by contract or otherwise, or (b) ownership of more than + fifty percent (50%) of the outstanding shares or beneficial + ownership of such entity. + +2. License Grants and Conditions +-------------------------------- + +2.1. Grants + +Each Contributor hereby grants You a world-wide, royalty-free, +non-exclusive license: + +(a) under intellectual property rights (other than patent or trademark) + Licensable by such Contributor to use, reproduce, make available, + modify, display, perform, distribute, and otherwise exploit its + Contributions, either on an unmodified basis, with Modifications, or + as part of a Larger Work; and + +(b) under Patent Claims of such Contributor to make, use, sell, offer + for sale, have made, import, and otherwise transfer either its + Contributions or its Contributor Version. + +2.2. Effective Date + +The licenses granted in Section 2.1 with respect to any Contribution +become effective for each Contribution on the date the Contributor first +distributes such Contribution. + +2.3. Limitations on Grant Scope + +The licenses granted in this Section 2 are the only rights granted under +this License. No additional rights or licenses will be implied from the +distribution or licensing of Covered Software under this License. +Notwithstanding Section 2.1(b) above, no patent license is granted by a +Contributor: + +(a) for any code that a Contributor has removed from Covered Software; + or + +(b) for infringements caused by: (i) Your and any other third party's + modifications of Covered Software, or (ii) the combination of its + Contributions with other software (except as part of its Contributor + Version); or + +(c) under Patent Claims infringed by Covered Software in the absence of + its Contributions. + +This License does not grant any rights in the trademarks, service marks, +or logos of any Contributor (except as may be necessary to comply with +the notice requirements in Section 3.4). + +2.4. Subsequent Licenses + +No Contributor makes additional grants as a result of Your choice to +distribute the Covered Software under a subsequent version of this +License (see Section 10.2) or under the terms of a Secondary License (if +permitted under the terms of Section 3.3). + +2.5. Representation + +Each Contributor represents that the Contributor believes its +Contributions are its original creation(s) or it has sufficient rights +to grant the rights to its Contributions conveyed by this License. + +2.6. Fair Use + +This License is not intended to limit any rights You have under +applicable copyright doctrines of fair use, fair dealing, or other +equivalents. + +2.7. Conditions + +Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted +in Section 2.1. + +3. Responsibilities +------------------- + +3.1. Distribution of Source Form + +All distribution of Covered Software in Source Code Form, including any +Modifications that You create or to which You contribute, must be under +the terms of this License. You must inform recipients that the Source +Code Form of the Covered Software is governed by the terms of this +License, and how they can obtain a copy of this License. You may not +attempt to alter or restrict the recipients' rights in the Source Code +Form. + +3.2. Distribution of Executable Form + +If You distribute Covered Software in Executable Form then: + +(a) such Covered Software must also be made available in Source Code + Form, as described in Section 3.1, and You must inform recipients of + the Executable Form how they can obtain a copy of such Source Code + Form by reasonable means in a timely manner, at a charge no more + than the cost of distribution to the recipient; and + +(b) You may distribute such Executable Form under the terms of this + License, or sublicense it under different terms, provided that the + license for the Executable Form does not attempt to limit or alter + the recipients' rights in the Source Code Form under this License. + +3.3. Distribution of a Larger Work + +You may create and distribute a Larger Work under terms of Your choice, +provided that You also comply with the requirements of this License for +the Covered Software. If the Larger Work is a combination of Covered +Software with a work governed by one or more Secondary Licenses, and the +Covered Software is not Incompatible With Secondary Licenses, this +License permits You to additionally distribute such Covered Software +under the terms of such Secondary License(s), so that the recipient of +the Larger Work may, at their option, further distribute the Covered +Software under the terms of either this License or such Secondary +License(s). + +3.4. Notices + +You may not remove or alter the substance of any license notices +(including copyright notices, patent notices, disclaimers of warranty, +or limitations of liability) contained within the Source Code Form of +the Covered Software, except that You may alter any license notices to +the extent required to remedy known factual inaccuracies. + +3.5. Application of Additional Terms + +You may choose to offer, and to charge a fee for, warranty, support, +indemnity or liability obligations to one or more recipients of Covered +Software. However, You may do so only on Your own behalf, and not on +behalf of any Contributor. You must make it absolutely clear that any +such warranty, support, indemnity, or liability obligation is offered by +You alone, and You hereby agree to indemnify every Contributor for any +liability incurred by such Contributor as a result of warranty, support, +indemnity or liability terms You offer. You may include additional +disclaimers of warranty and limitations of liability specific to any +jurisdiction. + +4. Inability to Comply Due to Statute or Regulation +--------------------------------------------------- + +If it is impossible for You to comply with any of the terms of this +License with respect to some or all of the Covered Software due to +statute, judicial order, or regulation then You must: (a) comply with +the terms of this License to the maximum extent possible; and (b) +describe the limitations and the code they affect. Such description must +be placed in a text file included with all distributions of the Covered +Software under this License. Except to the extent prohibited by statute +or regulation, such description must be sufficiently detailed for a +recipient of ordinary skill to be able to understand it. + +5. Termination +-------------- + +5.1. The rights granted under this License will terminate automatically +if You fail to comply with any of its terms. However, if You become +compliant, then the rights granted under this License from a particular +Contributor are reinstated (a) provisionally, unless and until such +Contributor explicitly and finally terminates Your grants, and (b) on an +ongoing basis, if such Contributor fails to notify You of the +non-compliance by some reasonable means prior to 60 days after You have +come back into compliance. Moreover, Your grants from a particular +Contributor are reinstated on an ongoing basis if such Contributor +notifies You of the non-compliance by some reasonable means, this is the +first time You have received notice of non-compliance with this License +from such Contributor, and You become compliant prior to 30 days after +Your receipt of the notice. + +5.2. If You initiate litigation against any entity by asserting a patent +infringement claim (excluding declaratory judgment actions, +counter-claims, and cross-claims) alleging that a Contributor Version +directly or indirectly infringes any patent, then the rights granted to +You by any and all Contributors for the Covered Software under Section +2.1 of this License shall terminate. + +5.3. In the event of termination under Sections 5.1 or 5.2 above, all +end user license agreements (excluding distributors and resellers) which +have been validly granted by You or Your distributors under this License +prior to termination shall survive termination. + +************************************************************************ +* * +* 6. Disclaimer of Warranty * +* ------------------------- * +* * +* Covered Software is provided under this License on an "as is" * +* basis, without warranty of any kind, either expressed, implied, or * +* statutory, including, without limitation, warranties that the * +* Covered Software is free of defects, merchantable, fit for a * +* particular purpose or non-infringing. The entire risk as to the * +* quality and performance of the Covered Software is with You. * +* Should any Covered Software prove defective in any respect, You * +* (not any Contributor) assume the cost of any necessary servicing, * +* repair, or correction. This disclaimer of warranty constitutes an * +* essential part of this License. No use of any Covered Software is * +* authorized under this License except under this disclaimer. * +* * +************************************************************************ + +************************************************************************ +* * +* 7. Limitation of Liability * +* -------------------------- * +* * +* Under no circumstances and under no legal theory, whether tort * +* (including negligence), contract, or otherwise, shall any * +* Contributor, or anyone who distributes Covered Software as * +* permitted above, be liable to You for any direct, indirect, * +* special, incidental, or consequential damages of any character * +* including, without limitation, damages for lost profits, loss of * +* goodwill, work stoppage, computer failure or malfunction, or any * +* and all other commercial damages or losses, even if such party * +* shall have been informed of the possibility of such damages. This * +* limitation of liability shall not apply to liability for death or * +* personal injury resulting from such party's negligence to the * +* extent applicable law prohibits such limitation. Some * +* jurisdictions do not allow the exclusion or limitation of * +* incidental or consequential damages, so this exclusion and * +* limitation may not apply to You. * +* * +************************************************************************ + +8. Litigation +------------- + +Any litigation relating to this License may be brought only in the +courts of a jurisdiction where the defendant maintains its principal +place of business and such litigation shall be governed by laws of that +jurisdiction, without reference to its conflict-of-law provisions. +Nothing in this Section shall prevent a party's ability to bring +cross-claims or counter-claims. + +9. Miscellaneous +---------------- + +This License represents the complete agreement concerning the subject +matter hereof. If any provision of this License is held to be +unenforceable, such provision shall be reformed only to the extent +necessary to make it enforceable. Any law or regulation which provides +that the language of a contract shall be construed against the drafter +shall not be used to construe this License against a Contributor. + +10. Versions of the License +--------------------------- + +10.1. New Versions + +Mozilla Foundation is the license steward. Except as provided in Section +10.3, no one other than the license steward has the right to modify or +publish new versions of this License. Each version will be given a +distinguishing version number. + +10.2. Effect of New Versions + +You may distribute the Covered Software under the terms of the version +of the License under which You originally received the Covered Software, +or under the terms of any subsequent version published by the license +steward. + +10.3. Modified Versions + +If you create software not governed by this License, and you want to +create a new license for such software, you may create and use a +modified version of this License if you rename the license and remove +any references to the name of the license steward (except to note that +such modified license differs from this License). + +10.4. Distributing Source Code Form that is Incompatible With Secondary +Licenses + +If You choose to distribute Source Code Form that is Incompatible With +Secondary Licenses under the terms of this version of the License, the +notice described in Exhibit B of this License must be attached. + +Exhibit A - Source Code Form License Notice +------------------------------------------- + + This Source Code Form is subject to the terms of the Mozilla Public + License, v. 2.0. If a copy of the MPL was not distributed with this + file, You can obtain one at http://mozilla.org/MPL/2.0/. + +If it is not possible or desirable to put the notice in a particular +file, then You may include the notice in a location (such as a LICENSE +file in a relevant directory) where a recipient would be likely to look +for such a notice. + +You may add additional accurate notices of copyright ownership. diff --git a/README.md b/README.md new file mode 100644 --- /dev/null +++ b/README.md @@ -0,0 +1,59 @@ +# Amazon CloudWatch Events SDK + +* [Version](#version) +* [Description](#description) +* [Contribute](#contribute) +* [Licence](#licence) + + +## Version + +`1.4.0` + + +## Description + +Amazon CloudWatch Events helps you to respond to state changes in your +AWS resources. When your resources change state they automatically send +events into an event stream. You can create rules that match selected +events in the stream and route them to targets to take action. You can +also use rules to take action on a pre-determined schedule. For example, +you can configure rules to: + +- Automatically invoke an AWS Lambda function to update DNS entries + when an event notifies you that Amazon EC2 instance enters the + running state. +- Direct specific API records from CloudTrail to an Amazon Kinesis + stream for detailed analysis of potential security or availability + risks. +- Periodically invoke a built-in target to create a snapshot of an + Amazon EBS volume. + +For more information about Amazon CloudWatch Events features, see the +. + +Documentation is available via [Hackage](http://hackage.haskell.org/package/amazonka-cloudwatch-events) +and the [AWS API Reference](https://aws.amazon.com/documentation/). + +The types from this library are intended to be used with [amazonka](http://hackage.haskell.org/package/amazonka), +which provides mechanisms for specifying AuthN/AuthZ information and sending requests. + +Use of lenses is required for constructing and manipulating types. +This is due to the amount of nesting of AWS types and transparency regarding +de/serialisation into more palatable Haskell values. +The provided lenses should be compatible with any of the major lens libraries +[lens](http://hackage.haskell.org/package/lens) or [lens-family-core](http://hackage.haskell.org/package/lens-family-core). + +## Contribute + +For any problems, comments, or feedback please create an issue [here on GitHub](https://github.com/brendanhay/amazonka/issues). + +> _Note:_ this library is an auto-generated Haskell package. Please see `amazonka-gen` for more information. + + +## Licence + +`amazonka-cloudwatch-events` is released under the [Mozilla Public License Version 2.0](http://www.mozilla.org/MPL/). + +Parts of the code are derived from AWS service descriptions, licensed under Apache 2.0. +Source files subject to this contain an additional licensing clause in their header. diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMain diff --git a/amazonka-cloudwatch-events.cabal b/amazonka-cloudwatch-events.cabal new file mode 100644 --- /dev/null +++ b/amazonka-cloudwatch-events.cabal @@ -0,0 +1,110 @@ +name: amazonka-cloudwatch-events +version: 1.4.0 +synopsis: Amazon CloudWatch Events SDK. +homepage: https://github.com/brendanhay/amazonka +bug-reports: https://github.com/brendanhay/amazonka/issues +license: OtherLicense +license-file: LICENSE +author: Brendan Hay +maintainer: Brendan Hay +copyright: Copyright (c) 2013-2016 Brendan Hay +category: Network, AWS, Cloud, Distributed Computing +build-type: Simple +cabal-version: >= 1.10 +extra-source-files: README.md fixture/*.yaml fixture/*.proto +description: + Amazon CloudWatch Events helps you to respond to state changes in your + AWS resources. When your resources change state they automatically send + events into an event stream. You can create rules that match selected + events in the stream and route them to targets to take action. You can + also use rules to take action on a pre-determined schedule. For example, + you can configure rules to: + + - Automatically invoke an AWS Lambda function to update DNS entries + when an event notifies you that Amazon EC2 instance enters the + running state. + - Direct specific API records from CloudTrail to an Amazon Kinesis + stream for detailed analysis of potential security or availability + risks. + - Periodically invoke a built-in target to create a snapshot of an + Amazon EBS volume. + + For more information about Amazon CloudWatch Events features, see the + . + . + The types from this library are intended to be used with + , which provides + mechanisms for specifying AuthN/AuthZ information and sending requests. + . + Use of lenses is required for constructing and manipulating types. + This is due to the amount of nesting of AWS types and transparency regarding + de/serialisation into more palatable Haskell values. + The provided lenses should be compatible with any of the major lens libraries + such as or + . + . + See "Network.AWS.CloudWatchEvents" or + to get started. + +source-repository head + type: git + location: git://github.com/brendanhay/amazonka.git + +library + default-language: Haskell2010 + hs-source-dirs: src gen + + ghc-options: -Wall + + exposed-modules: + Network.AWS.CloudWatchEvents + , Network.AWS.CloudWatchEvents.DeleteRule + , Network.AWS.CloudWatchEvents.DescribeRule + , Network.AWS.CloudWatchEvents.DisableRule + , Network.AWS.CloudWatchEvents.EnableRule + , Network.AWS.CloudWatchEvents.ListRuleNamesByTarget + , Network.AWS.CloudWatchEvents.ListRules + , Network.AWS.CloudWatchEvents.ListTargetsByRule + , Network.AWS.CloudWatchEvents.PutEvents + , Network.AWS.CloudWatchEvents.PutRule + , Network.AWS.CloudWatchEvents.PutTargets + , Network.AWS.CloudWatchEvents.RemoveTargets + , Network.AWS.CloudWatchEvents.TestEventPattern + , Network.AWS.CloudWatchEvents.Types + , Network.AWS.CloudWatchEvents.Waiters + + other-modules: + Network.AWS.CloudWatchEvents.Types.Product + , Network.AWS.CloudWatchEvents.Types.Sum + + build-depends: + amazonka-core == 1.4.0.* + , base >= 4.7 && < 5 + +test-suite amazonka-cloudwatch-events-test + type: exitcode-stdio-1.0 + default-language: Haskell2010 + hs-source-dirs: test + main-is: Main.hs + + ghc-options: -Wall -threaded + + -- This section is encoded by the template and any modules added by + -- hand outside these namespaces will not correctly be added to the + -- distribution package. + other-modules: + Test.AWS.CloudWatchEvents + , Test.AWS.Gen.CloudWatchEvents + , Test.AWS.CloudWatchEvents.Internal + + build-depends: + amazonka-core == 1.4.0.* + , amazonka-test == 1.4.0.* + , amazonka-cloudwatch-events == 1.4.0.* + , base + , bytestring + , tasty + , tasty-hunit + , text + , time + , unordered-containers diff --git a/fixture/DeleteRule.yaml b/fixture/DeleteRule.yaml new file mode 100644 --- /dev/null +++ b/fixture/DeleteRule.yaml diff --git a/fixture/DeleteRuleResponse.proto b/fixture/DeleteRuleResponse.proto new file mode 100644 --- /dev/null +++ b/fixture/DeleteRuleResponse.proto diff --git a/fixture/DescribeRule.yaml b/fixture/DescribeRule.yaml new file mode 100644 --- /dev/null +++ b/fixture/DescribeRule.yaml diff --git a/fixture/DescribeRuleResponse.proto b/fixture/DescribeRuleResponse.proto new file mode 100644 --- /dev/null +++ b/fixture/DescribeRuleResponse.proto diff --git a/fixture/DisableRule.yaml b/fixture/DisableRule.yaml new file mode 100644 --- /dev/null +++ b/fixture/DisableRule.yaml diff --git a/fixture/DisableRuleResponse.proto b/fixture/DisableRuleResponse.proto new file mode 100644 --- /dev/null +++ b/fixture/DisableRuleResponse.proto diff --git a/fixture/EnableRule.yaml b/fixture/EnableRule.yaml new file mode 100644 --- /dev/null +++ b/fixture/EnableRule.yaml diff --git a/fixture/EnableRuleResponse.proto b/fixture/EnableRuleResponse.proto new file mode 100644 --- /dev/null +++ b/fixture/EnableRuleResponse.proto diff --git a/fixture/ListRuleNamesByTarget.yaml b/fixture/ListRuleNamesByTarget.yaml new file mode 100644 --- /dev/null +++ b/fixture/ListRuleNamesByTarget.yaml diff --git a/fixture/ListRuleNamesByTargetResponse.proto b/fixture/ListRuleNamesByTargetResponse.proto new file mode 100644 --- /dev/null +++ b/fixture/ListRuleNamesByTargetResponse.proto diff --git a/fixture/ListRules.yaml b/fixture/ListRules.yaml new file mode 100644 --- /dev/null +++ b/fixture/ListRules.yaml diff --git a/fixture/ListRulesResponse.proto b/fixture/ListRulesResponse.proto new file mode 100644 --- /dev/null +++ b/fixture/ListRulesResponse.proto diff --git a/fixture/ListTargetsByRule.yaml b/fixture/ListTargetsByRule.yaml new file mode 100644 --- /dev/null +++ b/fixture/ListTargetsByRule.yaml diff --git a/fixture/ListTargetsByRuleResponse.proto b/fixture/ListTargetsByRuleResponse.proto new file mode 100644 --- /dev/null +++ b/fixture/ListTargetsByRuleResponse.proto diff --git a/fixture/PutEvents.yaml b/fixture/PutEvents.yaml new file mode 100644 --- /dev/null +++ b/fixture/PutEvents.yaml diff --git a/fixture/PutEventsResponse.proto b/fixture/PutEventsResponse.proto new file mode 100644 --- /dev/null +++ b/fixture/PutEventsResponse.proto diff --git a/fixture/PutRule.yaml b/fixture/PutRule.yaml new file mode 100644 --- /dev/null +++ b/fixture/PutRule.yaml diff --git a/fixture/PutRuleResponse.proto b/fixture/PutRuleResponse.proto new file mode 100644 --- /dev/null +++ b/fixture/PutRuleResponse.proto diff --git a/fixture/PutTargets.yaml b/fixture/PutTargets.yaml new file mode 100644 --- /dev/null +++ b/fixture/PutTargets.yaml diff --git a/fixture/PutTargetsResponse.proto b/fixture/PutTargetsResponse.proto new file mode 100644 --- /dev/null +++ b/fixture/PutTargetsResponse.proto diff --git a/fixture/RemoveTargets.yaml b/fixture/RemoveTargets.yaml new file mode 100644 --- /dev/null +++ b/fixture/RemoveTargets.yaml diff --git a/fixture/RemoveTargetsResponse.proto b/fixture/RemoveTargetsResponse.proto new file mode 100644 --- /dev/null +++ b/fixture/RemoveTargetsResponse.proto diff --git a/fixture/TestEventPattern.yaml b/fixture/TestEventPattern.yaml new file mode 100644 --- /dev/null +++ b/fixture/TestEventPattern.yaml diff --git a/fixture/TestEventPatternResponse.proto b/fixture/TestEventPatternResponse.proto new file mode 100644 --- /dev/null +++ b/fixture/TestEventPatternResponse.proto diff --git a/gen/Network/AWS/CloudWatchEvents.hs b/gen/Network/AWS/CloudWatchEvents.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudWatchEvents.hs @@ -0,0 +1,195 @@ +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-duplicate-exports #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.CloudWatchEvents +-- Copyright : (c) 2013-2016 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Amazon CloudWatch Events helps you to respond to state changes in your +-- AWS resources. When your resources change state they automatically send +-- events into an event stream. You can create rules that match selected +-- events in the stream and route them to targets to take action. You can +-- also use rules to take action on a pre-determined schedule. For example, +-- you can configure rules to: +-- +-- - Automatically invoke an AWS Lambda function to update DNS entries +-- when an event notifies you that Amazon EC2 instance enters the +-- running state. +-- - Direct specific API records from CloudTrail to an Amazon Kinesis +-- stream for detailed analysis of potential security or availability +-- risks. +-- - Periodically invoke a built-in target to create a snapshot of an +-- Amazon EBS volume. +-- +-- For more information about Amazon CloudWatch Events features, see the +-- . +module Network.AWS.CloudWatchEvents + ( + -- * Service Configuration + cloudWatchEvents + + -- * Errors + -- $errors + + -- ** ConcurrentModificationException + , _ConcurrentModificationException + + -- ** InvalidEventPatternException + , _InvalidEventPatternException + + -- ** InternalException + , _InternalException + + -- ** ResourceNotFoundException + , _ResourceNotFoundException + + -- ** LimitExceededException + , _LimitExceededException + + -- * Waiters + -- $waiters + + -- * Operations + -- $operations + + -- ** RemoveTargets + , module Network.AWS.CloudWatchEvents.RemoveTargets + + -- ** DeleteRule + , module Network.AWS.CloudWatchEvents.DeleteRule + + -- ** ListRules + , module Network.AWS.CloudWatchEvents.ListRules + + -- ** PutRule + , module Network.AWS.CloudWatchEvents.PutRule + + -- ** DisableRule + , module Network.AWS.CloudWatchEvents.DisableRule + + -- ** ListTargetsByRule + , module Network.AWS.CloudWatchEvents.ListTargetsByRule + + -- ** DescribeRule + , module Network.AWS.CloudWatchEvents.DescribeRule + + -- ** EnableRule + , module Network.AWS.CloudWatchEvents.EnableRule + + -- ** ListRuleNamesByTarget + , module Network.AWS.CloudWatchEvents.ListRuleNamesByTarget + + -- ** TestEventPattern + , module Network.AWS.CloudWatchEvents.TestEventPattern + + -- ** PutTargets + , module Network.AWS.CloudWatchEvents.PutTargets + + -- ** PutEvents + , module Network.AWS.CloudWatchEvents.PutEvents + + -- * Types + + -- ** RuleState + , RuleState (..) + + -- ** PutEventsRequestEntry + , PutEventsRequestEntry + , putEventsRequestEntry + , pereTime + , pereDetailType + , pereResources + , pereSource + , pereDetail + + -- ** PutEventsResultEntry + , PutEventsResultEntry + , putEventsResultEntry + , pereErrorCode + , pereErrorMessage + , pereEventId + + -- ** PutTargetsResultEntry + , PutTargetsResultEntry + , putTargetsResultEntry + , ptreTargetId + , ptreErrorCode + , ptreErrorMessage + + -- ** RemoveTargetsResultEntry + , RemoveTargetsResultEntry + , removeTargetsResultEntry + , rtreTargetId + , rtreErrorCode + , rtreErrorMessage + + -- ** Rule + , Rule + , rule + , rEventPattern + , rState + , rARN + , rScheduleExpression + , rName + , rDescription + , rRoleARN + + -- ** Target + , Target + , target + , tInput + , tInputPath + , tId + , tARN + ) where + +import Network.AWS.CloudWatchEvents.DeleteRule +import Network.AWS.CloudWatchEvents.DescribeRule +import Network.AWS.CloudWatchEvents.DisableRule +import Network.AWS.CloudWatchEvents.EnableRule +import Network.AWS.CloudWatchEvents.ListRuleNamesByTarget +import Network.AWS.CloudWatchEvents.ListRules +import Network.AWS.CloudWatchEvents.ListTargetsByRule +import Network.AWS.CloudWatchEvents.PutEvents +import Network.AWS.CloudWatchEvents.PutRule +import Network.AWS.CloudWatchEvents.PutTargets +import Network.AWS.CloudWatchEvents.RemoveTargets +import Network.AWS.CloudWatchEvents.TestEventPattern +import Network.AWS.CloudWatchEvents.Types +import Network.AWS.CloudWatchEvents.Waiters + +{- $errors +Error matchers are designed for use with the functions provided by +. +This allows catching (and rethrowing) service specific errors returned +by 'CloudWatchEvents'. +-} + +{- $operations +Some AWS operations return results that are incomplete and require subsequent +requests in order to obtain the entire result set. The process of sending +subsequent requests to continue where a previous request left off is called +pagination. For example, the 'ListObjects' operation of Amazon S3 returns up to +1000 objects at a time, and you must send subsequent requests with the +appropriate Marker in order to retrieve the next page of results. + +Operations that have an 'AWSPager' instance can transparently perform subsequent +requests, correctly setting Markers and other request facets to iterate through +the entire result set of a truncated API operation. Operations which support +this have an additional note in the documentation. + +Many operations have the ability to filter results on the server side. See the +individual operation parameters for details. +-} + +{- $waiters +Waiters poll by repeatedly sending a request until some remote success condition +configured by the 'Wait' specification is fulfilled. The 'Wait' specification +determines how many attempts should be made, in addition to delay and retry strategies. +-} diff --git a/gen/Network/AWS/CloudWatchEvents/DeleteRule.hs b/gen/Network/AWS/CloudWatchEvents/DeleteRule.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudWatchEvents/DeleteRule.hs @@ -0,0 +1,106 @@ +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-matches #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.CloudWatchEvents.DeleteRule +-- Copyright : (c) 2013-2016 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Deletes a rule. You must remove all targets from a rule using +-- < RemoveTargets> before you can delete the rule. +-- +-- __Note:__ When you delete a rule, incoming events might still continue +-- to match to the deleted rule. Please allow a short period of time for +-- changes to take effect. +module Network.AWS.CloudWatchEvents.DeleteRule + ( + -- * Creating a Request + deleteRule + , DeleteRule + -- * Request Lenses + , drName + + -- * Destructuring the Response + , deleteRuleResponse + , DeleteRuleResponse + ) where + +import Network.AWS.CloudWatchEvents.Types +import Network.AWS.CloudWatchEvents.Types.Product +import Network.AWS.Lens +import Network.AWS.Prelude +import Network.AWS.Request +import Network.AWS.Response + +-- | Container for the parameters to the < DeleteRule> operation. +-- +-- /See:/ 'deleteRule' smart constructor. +newtype DeleteRule = DeleteRule' + { _drName :: Text + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'DeleteRule' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'drName' +deleteRule + :: Text -- ^ 'drName' + -> DeleteRule +deleteRule pName_ = + DeleteRule' + { _drName = pName_ + } + +-- | The name of the rule to be deleted. +drName :: Lens' DeleteRule Text +drName = lens _drName (\ s a -> s{_drName = a}); + +instance AWSRequest DeleteRule where + type Rs DeleteRule = DeleteRuleResponse + request = postJSON cloudWatchEvents + response = receiveNull DeleteRuleResponse' + +instance Hashable DeleteRule + +instance ToHeaders DeleteRule where + toHeaders + = const + (mconcat + ["X-Amz-Target" =# + ("AWSEvents.DeleteRule" :: ByteString), + "Content-Type" =# + ("application/x-amz-json-1.1" :: ByteString)]) + +instance ToJSON DeleteRule where + toJSON DeleteRule'{..} + = object (catMaybes [Just ("Name" .= _drName)]) + +instance ToPath DeleteRule where + toPath = const "/" + +instance ToQuery DeleteRule where + toQuery = const mempty + +-- | /See:/ 'deleteRuleResponse' smart constructor. +data DeleteRuleResponse = + DeleteRuleResponse' + deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'DeleteRuleResponse' with the minimum fields required to make a request. +-- +deleteRuleResponse + :: DeleteRuleResponse +deleteRuleResponse = DeleteRuleResponse' diff --git a/gen/Network/AWS/CloudWatchEvents/DescribeRule.hs b/gen/Network/AWS/CloudWatchEvents/DescribeRule.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudWatchEvents/DescribeRule.hs @@ -0,0 +1,190 @@ +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-matches #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.CloudWatchEvents.DescribeRule +-- Copyright : (c) 2013-2016 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Describes the details of the specified rule. +module Network.AWS.CloudWatchEvents.DescribeRule + ( + -- * Creating a Request + describeRule + , DescribeRule + -- * Request Lenses + , desName + + -- * Destructuring the Response + , describeRuleResponse + , DescribeRuleResponse + -- * Response Lenses + , drrsEventPattern + , drrsState + , drrsARN + , drrsScheduleExpression + , drrsName + , drrsDescription + , drrsRoleARN + , drrsResponseStatus + ) where + +import Network.AWS.CloudWatchEvents.Types +import Network.AWS.CloudWatchEvents.Types.Product +import Network.AWS.Lens +import Network.AWS.Prelude +import Network.AWS.Request +import Network.AWS.Response + +-- | Container for the parameters to the < DescribeRule> operation. +-- +-- /See:/ 'describeRule' smart constructor. +newtype DescribeRule = DescribeRule' + { _desName :: Text + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'DescribeRule' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'desName' +describeRule + :: Text -- ^ 'desName' + -> DescribeRule +describeRule pName_ = + DescribeRule' + { _desName = pName_ + } + +-- | The name of the rule you want to describe details for. +desName :: Lens' DescribeRule Text +desName = lens _desName (\ s a -> s{_desName = a}); + +instance AWSRequest DescribeRule where + type Rs DescribeRule = DescribeRuleResponse + request = postJSON cloudWatchEvents + response + = receiveJSON + (\ s h x -> + DescribeRuleResponse' <$> + (x .?> "EventPattern") <*> (x .?> "State") <*> + (x .?> "Arn") + <*> (x .?> "ScheduleExpression") + <*> (x .?> "Name") + <*> (x .?> "Description") + <*> (x .?> "RoleArn") + <*> (pure (fromEnum s))) + +instance Hashable DescribeRule + +instance ToHeaders DescribeRule where + toHeaders + = const + (mconcat + ["X-Amz-Target" =# + ("AWSEvents.DescribeRule" :: ByteString), + "Content-Type" =# + ("application/x-amz-json-1.1" :: ByteString)]) + +instance ToJSON DescribeRule where + toJSON DescribeRule'{..} + = object (catMaybes [Just ("Name" .= _desName)]) + +instance ToPath DescribeRule where + toPath = const "/" + +instance ToQuery DescribeRule where + toQuery = const mempty + +-- | The result of the < DescribeRule> operation. +-- +-- /See:/ 'describeRuleResponse' smart constructor. +data DescribeRuleResponse = DescribeRuleResponse' + { _drrsEventPattern :: !(Maybe Text) + , _drrsState :: !(Maybe RuleState) + , _drrsARN :: !(Maybe Text) + , _drrsScheduleExpression :: !(Maybe Text) + , _drrsName :: !(Maybe Text) + , _drrsDescription :: !(Maybe Text) + , _drrsRoleARN :: !(Maybe Text) + , _drrsResponseStatus :: !Int + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'DescribeRuleResponse' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'drrsEventPattern' +-- +-- * 'drrsState' +-- +-- * 'drrsARN' +-- +-- * 'drrsScheduleExpression' +-- +-- * 'drrsName' +-- +-- * 'drrsDescription' +-- +-- * 'drrsRoleARN' +-- +-- * 'drrsResponseStatus' +describeRuleResponse + :: Int -- ^ 'drrsResponseStatus' + -> DescribeRuleResponse +describeRuleResponse pResponseStatus_ = + DescribeRuleResponse' + { _drrsEventPattern = Nothing + , _drrsState = Nothing + , _drrsARN = Nothing + , _drrsScheduleExpression = Nothing + , _drrsName = Nothing + , _drrsDescription = Nothing + , _drrsRoleARN = Nothing + , _drrsResponseStatus = pResponseStatus_ + } + +-- | The event pattern. +drrsEventPattern :: Lens' DescribeRuleResponse (Maybe Text) +drrsEventPattern = lens _drrsEventPattern (\ s a -> s{_drrsEventPattern = a}); + +-- | Specifies whether the rule is enabled or disabled. +drrsState :: Lens' DescribeRuleResponse (Maybe RuleState) +drrsState = lens _drrsState (\ s a -> s{_drrsState = a}); + +-- | The Amazon Resource Name (ARN) associated with the rule. +drrsARN :: Lens' DescribeRuleResponse (Maybe Text) +drrsARN = lens _drrsARN (\ s a -> s{_drrsARN = a}); + +-- | The scheduling expression. For example, \"cron(0 20 * * ? *)\", \"rate(5 +-- minutes)\". +drrsScheduleExpression :: Lens' DescribeRuleResponse (Maybe Text) +drrsScheduleExpression = lens _drrsScheduleExpression (\ s a -> s{_drrsScheduleExpression = a}); + +-- | The rule\'s name. +drrsName :: Lens' DescribeRuleResponse (Maybe Text) +drrsName = lens _drrsName (\ s a -> s{_drrsName = a}); + +-- | The rule\'s description. +drrsDescription :: Lens' DescribeRuleResponse (Maybe Text) +drrsDescription = lens _drrsDescription (\ s a -> s{_drrsDescription = a}); + +-- | The Amazon Resource Name (ARN) of the IAM role associated with the rule. +drrsRoleARN :: Lens' DescribeRuleResponse (Maybe Text) +drrsRoleARN = lens _drrsRoleARN (\ s a -> s{_drrsRoleARN = a}); + +-- | The response status code. +drrsResponseStatus :: Lens' DescribeRuleResponse Int +drrsResponseStatus = lens _drrsResponseStatus (\ s a -> s{_drrsResponseStatus = a}); diff --git a/gen/Network/AWS/CloudWatchEvents/DisableRule.hs b/gen/Network/AWS/CloudWatchEvents/DisableRule.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudWatchEvents/DisableRule.hs @@ -0,0 +1,106 @@ +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-matches #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.CloudWatchEvents.DisableRule +-- Copyright : (c) 2013-2016 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Disables a rule. A disabled rule won\'t match any events, and won\'t +-- self-trigger if it has a schedule expression. +-- +-- __Note:__ When you disable a rule, incoming events might still continue +-- to match to the disabled rule. Please allow a short period of time for +-- changes to take effect. +module Network.AWS.CloudWatchEvents.DisableRule + ( + -- * Creating a Request + disableRule + , DisableRule + -- * Request Lenses + , dName + + -- * Destructuring the Response + , disableRuleResponse + , DisableRuleResponse + ) where + +import Network.AWS.CloudWatchEvents.Types +import Network.AWS.CloudWatchEvents.Types.Product +import Network.AWS.Lens +import Network.AWS.Prelude +import Network.AWS.Request +import Network.AWS.Response + +-- | Container for the parameters to the < DisableRule> operation. +-- +-- /See:/ 'disableRule' smart constructor. +newtype DisableRule = DisableRule' + { _dName :: Text + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'DisableRule' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'dName' +disableRule + :: Text -- ^ 'dName' + -> DisableRule +disableRule pName_ = + DisableRule' + { _dName = pName_ + } + +-- | The name of the rule you want to disable. +dName :: Lens' DisableRule Text +dName = lens _dName (\ s a -> s{_dName = a}); + +instance AWSRequest DisableRule where + type Rs DisableRule = DisableRuleResponse + request = postJSON cloudWatchEvents + response = receiveNull DisableRuleResponse' + +instance Hashable DisableRule + +instance ToHeaders DisableRule where + toHeaders + = const + (mconcat + ["X-Amz-Target" =# + ("AWSEvents.DisableRule" :: ByteString), + "Content-Type" =# + ("application/x-amz-json-1.1" :: ByteString)]) + +instance ToJSON DisableRule where + toJSON DisableRule'{..} + = object (catMaybes [Just ("Name" .= _dName)]) + +instance ToPath DisableRule where + toPath = const "/" + +instance ToQuery DisableRule where + toQuery = const mempty + +-- | /See:/ 'disableRuleResponse' smart constructor. +data DisableRuleResponse = + DisableRuleResponse' + deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'DisableRuleResponse' with the minimum fields required to make a request. +-- +disableRuleResponse + :: DisableRuleResponse +disableRuleResponse = DisableRuleResponse' diff --git a/gen/Network/AWS/CloudWatchEvents/EnableRule.hs b/gen/Network/AWS/CloudWatchEvents/EnableRule.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudWatchEvents/EnableRule.hs @@ -0,0 +1,105 @@ +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-matches #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.CloudWatchEvents.EnableRule +-- Copyright : (c) 2013-2016 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Enables a rule. If the rule does not exist, the operation fails. +-- +-- __Note:__ When you enable a rule, incoming events might not immediately +-- start matching to a newly enabled rule. Please allow a short period of +-- time for changes to take effect. +module Network.AWS.CloudWatchEvents.EnableRule + ( + -- * Creating a Request + enableRule + , EnableRule + -- * Request Lenses + , erName + + -- * Destructuring the Response + , enableRuleResponse + , EnableRuleResponse + ) where + +import Network.AWS.CloudWatchEvents.Types +import Network.AWS.CloudWatchEvents.Types.Product +import Network.AWS.Lens +import Network.AWS.Prelude +import Network.AWS.Request +import Network.AWS.Response + +-- | Container for the parameters to the < EnableRule> operation. +-- +-- /See:/ 'enableRule' smart constructor. +newtype EnableRule = EnableRule' + { _erName :: Text + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'EnableRule' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'erName' +enableRule + :: Text -- ^ 'erName' + -> EnableRule +enableRule pName_ = + EnableRule' + { _erName = pName_ + } + +-- | The name of the rule that you want to enable. +erName :: Lens' EnableRule Text +erName = lens _erName (\ s a -> s{_erName = a}); + +instance AWSRequest EnableRule where + type Rs EnableRule = EnableRuleResponse + request = postJSON cloudWatchEvents + response = receiveNull EnableRuleResponse' + +instance Hashable EnableRule + +instance ToHeaders EnableRule where + toHeaders + = const + (mconcat + ["X-Amz-Target" =# + ("AWSEvents.EnableRule" :: ByteString), + "Content-Type" =# + ("application/x-amz-json-1.1" :: ByteString)]) + +instance ToJSON EnableRule where + toJSON EnableRule'{..} + = object (catMaybes [Just ("Name" .= _erName)]) + +instance ToPath EnableRule where + toPath = const "/" + +instance ToQuery EnableRule where + toQuery = const mempty + +-- | /See:/ 'enableRuleResponse' smart constructor. +data EnableRuleResponse = + EnableRuleResponse' + deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'EnableRuleResponse' with the minimum fields required to make a request. +-- +enableRuleResponse + :: EnableRuleResponse +enableRuleResponse = EnableRuleResponse' diff --git a/gen/Network/AWS/CloudWatchEvents/ListRuleNamesByTarget.hs b/gen/Network/AWS/CloudWatchEvents/ListRuleNamesByTarget.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudWatchEvents/ListRuleNamesByTarget.hs @@ -0,0 +1,170 @@ +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-matches #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.CloudWatchEvents.ListRuleNamesByTarget +-- Copyright : (c) 2013-2016 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Lists the names of the rules that the given target is put to. You can +-- see which of the rules in Amazon CloudWatch Events can invoke a specific +-- target in your account. If you have more rules in your account than the +-- given limit, the results will be paginated. In that case, use the next +-- token returned in the response and repeat ListRulesByTarget until the +-- NextToken in the response is returned as null. +module Network.AWS.CloudWatchEvents.ListRuleNamesByTarget + ( + -- * Creating a Request + listRuleNamesByTarget + , ListRuleNamesByTarget + -- * Request Lenses + , lrnbtNextToken + , lrnbtLimit + , lrnbtTargetARN + + -- * Destructuring the Response + , listRuleNamesByTargetResponse + , ListRuleNamesByTargetResponse + -- * Response Lenses + , lrnbtrsRuleNames + , lrnbtrsNextToken + , lrnbtrsResponseStatus + ) where + +import Network.AWS.CloudWatchEvents.Types +import Network.AWS.CloudWatchEvents.Types.Product +import Network.AWS.Lens +import Network.AWS.Prelude +import Network.AWS.Request +import Network.AWS.Response + +-- | Container for the parameters to the < ListRuleNamesByTarget> operation. +-- +-- /See:/ 'listRuleNamesByTarget' smart constructor. +data ListRuleNamesByTarget = ListRuleNamesByTarget' + { _lrnbtNextToken :: !(Maybe Text) + , _lrnbtLimit :: !(Maybe Nat) + , _lrnbtTargetARN :: !Text + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'ListRuleNamesByTarget' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'lrnbtNextToken' +-- +-- * 'lrnbtLimit' +-- +-- * 'lrnbtTargetARN' +listRuleNamesByTarget + :: Text -- ^ 'lrnbtTargetARN' + -> ListRuleNamesByTarget +listRuleNamesByTarget pTargetARN_ = + ListRuleNamesByTarget' + { _lrnbtNextToken = Nothing + , _lrnbtLimit = Nothing + , _lrnbtTargetARN = pTargetARN_ + } + +-- | The token returned by a previous call to indicate that there is more +-- data available. +lrnbtNextToken :: Lens' ListRuleNamesByTarget (Maybe Text) +lrnbtNextToken = lens _lrnbtNextToken (\ s a -> s{_lrnbtNextToken = a}); + +-- | The maximum number of results to return. +lrnbtLimit :: Lens' ListRuleNamesByTarget (Maybe Natural) +lrnbtLimit = lens _lrnbtLimit (\ s a -> s{_lrnbtLimit = a}) . mapping _Nat; + +-- | The Amazon Resource Name (ARN) of the target resource that you want to +-- list the rules for. +lrnbtTargetARN :: Lens' ListRuleNamesByTarget Text +lrnbtTargetARN = lens _lrnbtTargetARN (\ s a -> s{_lrnbtTargetARN = a}); + +instance AWSRequest ListRuleNamesByTarget where + type Rs ListRuleNamesByTarget = + ListRuleNamesByTargetResponse + request = postJSON cloudWatchEvents + response + = receiveJSON + (\ s h x -> + ListRuleNamesByTargetResponse' <$> + (x .?> "RuleNames" .!@ mempty) <*> + (x .?> "NextToken") + <*> (pure (fromEnum s))) + +instance Hashable ListRuleNamesByTarget + +instance ToHeaders ListRuleNamesByTarget where + toHeaders + = const + (mconcat + ["X-Amz-Target" =# + ("AWSEvents.ListRuleNamesByTarget" :: ByteString), + "Content-Type" =# + ("application/x-amz-json-1.1" :: ByteString)]) + +instance ToJSON ListRuleNamesByTarget where + toJSON ListRuleNamesByTarget'{..} + = object + (catMaybes + [("NextToken" .=) <$> _lrnbtNextToken, + ("Limit" .=) <$> _lrnbtLimit, + Just ("TargetArn" .= _lrnbtTargetARN)]) + +instance ToPath ListRuleNamesByTarget where + toPath = const "/" + +instance ToQuery ListRuleNamesByTarget where + toQuery = const mempty + +-- | The result of the < ListRuleNamesByTarget> operation. +-- +-- /See:/ 'listRuleNamesByTargetResponse' smart constructor. +data ListRuleNamesByTargetResponse = ListRuleNamesByTargetResponse' + { _lrnbtrsRuleNames :: !(Maybe [Text]) + , _lrnbtrsNextToken :: !(Maybe Text) + , _lrnbtrsResponseStatus :: !Int + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'ListRuleNamesByTargetResponse' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'lrnbtrsRuleNames' +-- +-- * 'lrnbtrsNextToken' +-- +-- * 'lrnbtrsResponseStatus' +listRuleNamesByTargetResponse + :: Int -- ^ 'lrnbtrsResponseStatus' + -> ListRuleNamesByTargetResponse +listRuleNamesByTargetResponse pResponseStatus_ = + ListRuleNamesByTargetResponse' + { _lrnbtrsRuleNames = Nothing + , _lrnbtrsNextToken = Nothing + , _lrnbtrsResponseStatus = pResponseStatus_ + } + +-- | List of rules names that can invoke the given target. +lrnbtrsRuleNames :: Lens' ListRuleNamesByTargetResponse [Text] +lrnbtrsRuleNames = lens _lrnbtrsRuleNames (\ s a -> s{_lrnbtrsRuleNames = a}) . _Default . _Coerce; + +-- | Indicates that there are additional results to retrieve. +lrnbtrsNextToken :: Lens' ListRuleNamesByTargetResponse (Maybe Text) +lrnbtrsNextToken = lens _lrnbtrsNextToken (\ s a -> s{_lrnbtrsNextToken = a}); + +-- | The response status code. +lrnbtrsResponseStatus :: Lens' ListRuleNamesByTargetResponse Int +lrnbtrsResponseStatus = lens _lrnbtrsResponseStatus (\ s a -> s{_lrnbtrsResponseStatus = a}); diff --git a/gen/Network/AWS/CloudWatchEvents/ListRules.hs b/gen/Network/AWS/CloudWatchEvents/ListRules.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudWatchEvents/ListRules.hs @@ -0,0 +1,166 @@ +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-matches #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.CloudWatchEvents.ListRules +-- Copyright : (c) 2013-2016 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Lists the Amazon CloudWatch Events rules in your account. You can either +-- list all the rules or you can provide a prefix to match to the rule +-- names. If you have more rules in your account than the given limit, the +-- results will be paginated. In that case, use the next token returned in +-- the response and repeat ListRules until the NextToken in the response is +-- returned as null. +module Network.AWS.CloudWatchEvents.ListRules + ( + -- * Creating a Request + listRules + , ListRules + -- * Request Lenses + , lrNextToken + , lrNamePrefix + , lrLimit + + -- * Destructuring the Response + , listRulesResponse + , ListRulesResponse + -- * Response Lenses + , lrrsRules + , lrrsNextToken + , lrrsResponseStatus + ) where + +import Network.AWS.CloudWatchEvents.Types +import Network.AWS.CloudWatchEvents.Types.Product +import Network.AWS.Lens +import Network.AWS.Prelude +import Network.AWS.Request +import Network.AWS.Response + +-- | Container for the parameters to the < ListRules> operation. +-- +-- /See:/ 'listRules' smart constructor. +data ListRules = ListRules' + { _lrNextToken :: !(Maybe Text) + , _lrNamePrefix :: !(Maybe Text) + , _lrLimit :: !(Maybe Nat) + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'ListRules' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'lrNextToken' +-- +-- * 'lrNamePrefix' +-- +-- * 'lrLimit' +listRules + :: ListRules +listRules = + ListRules' + { _lrNextToken = Nothing + , _lrNamePrefix = Nothing + , _lrLimit = Nothing + } + +-- | The token returned by a previous call to indicate that there is more +-- data available. +lrNextToken :: Lens' ListRules (Maybe Text) +lrNextToken = lens _lrNextToken (\ s a -> s{_lrNextToken = a}); + +-- | The prefix matching the rule name. +lrNamePrefix :: Lens' ListRules (Maybe Text) +lrNamePrefix = lens _lrNamePrefix (\ s a -> s{_lrNamePrefix = a}); + +-- | The maximum number of results to return. +lrLimit :: Lens' ListRules (Maybe Natural) +lrLimit = lens _lrLimit (\ s a -> s{_lrLimit = a}) . mapping _Nat; + +instance AWSRequest ListRules where + type Rs ListRules = ListRulesResponse + request = postJSON cloudWatchEvents + response + = receiveJSON + (\ s h x -> + ListRulesResponse' <$> + (x .?> "Rules" .!@ mempty) <*> (x .?> "NextToken") + <*> (pure (fromEnum s))) + +instance Hashable ListRules + +instance ToHeaders ListRules where + toHeaders + = const + (mconcat + ["X-Amz-Target" =# + ("AWSEvents.ListRules" :: ByteString), + "Content-Type" =# + ("application/x-amz-json-1.1" :: ByteString)]) + +instance ToJSON ListRules where + toJSON ListRules'{..} + = object + (catMaybes + [("NextToken" .=) <$> _lrNextToken, + ("NamePrefix" .=) <$> _lrNamePrefix, + ("Limit" .=) <$> _lrLimit]) + +instance ToPath ListRules where + toPath = const "/" + +instance ToQuery ListRules where + toQuery = const mempty + +-- | The result of the < ListRules> operation. +-- +-- /See:/ 'listRulesResponse' smart constructor. +data ListRulesResponse = ListRulesResponse' + { _lrrsRules :: !(Maybe [Rule]) + , _lrrsNextToken :: !(Maybe Text) + , _lrrsResponseStatus :: !Int + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'ListRulesResponse' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'lrrsRules' +-- +-- * 'lrrsNextToken' +-- +-- * 'lrrsResponseStatus' +listRulesResponse + :: Int -- ^ 'lrrsResponseStatus' + -> ListRulesResponse +listRulesResponse pResponseStatus_ = + ListRulesResponse' + { _lrrsRules = Nothing + , _lrrsNextToken = Nothing + , _lrrsResponseStatus = pResponseStatus_ + } + +-- | List of rules matching the specified criteria. +lrrsRules :: Lens' ListRulesResponse [Rule] +lrrsRules = lens _lrrsRules (\ s a -> s{_lrrsRules = a}) . _Default . _Coerce; + +-- | Indicates that there are additional results to retrieve. +lrrsNextToken :: Lens' ListRulesResponse (Maybe Text) +lrrsNextToken = lens _lrrsNextToken (\ s a -> s{_lrrsNextToken = a}); + +-- | The response status code. +lrrsResponseStatus :: Lens' ListRulesResponse Int +lrrsResponseStatus = lens _lrrsResponseStatus (\ s a -> s{_lrrsResponseStatus = a}); diff --git a/gen/Network/AWS/CloudWatchEvents/ListTargetsByRule.hs b/gen/Network/AWS/CloudWatchEvents/ListTargetsByRule.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudWatchEvents/ListTargetsByRule.hs @@ -0,0 +1,162 @@ +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-matches #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.CloudWatchEvents.ListTargetsByRule +-- Copyright : (c) 2013-2016 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Lists of targets assigned to the rule. +module Network.AWS.CloudWatchEvents.ListTargetsByRule + ( + -- * Creating a Request + listTargetsByRule + , ListTargetsByRule + -- * Request Lenses + , ltbrNextToken + , ltbrLimit + , ltbrRule + + -- * Destructuring the Response + , listTargetsByRuleResponse + , ListTargetsByRuleResponse + -- * Response Lenses + , ltbrrsNextToken + , ltbrrsTargets + , ltbrrsResponseStatus + ) where + +import Network.AWS.CloudWatchEvents.Types +import Network.AWS.CloudWatchEvents.Types.Product +import Network.AWS.Lens +import Network.AWS.Prelude +import Network.AWS.Request +import Network.AWS.Response + +-- | Container for the parameters to the < ListTargetsByRule> operation. +-- +-- /See:/ 'listTargetsByRule' smart constructor. +data ListTargetsByRule = ListTargetsByRule' + { _ltbrNextToken :: !(Maybe Text) + , _ltbrLimit :: !(Maybe Nat) + , _ltbrRule :: !Text + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'ListTargetsByRule' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'ltbrNextToken' +-- +-- * 'ltbrLimit' +-- +-- * 'ltbrRule' +listTargetsByRule + :: Text -- ^ 'ltbrRule' + -> ListTargetsByRule +listTargetsByRule pRule_ = + ListTargetsByRule' + { _ltbrNextToken = Nothing + , _ltbrLimit = Nothing + , _ltbrRule = pRule_ + } + +-- | The token returned by a previous call to indicate that there is more +-- data available. +ltbrNextToken :: Lens' ListTargetsByRule (Maybe Text) +ltbrNextToken = lens _ltbrNextToken (\ s a -> s{_ltbrNextToken = a}); + +-- | The maximum number of results to return. +ltbrLimit :: Lens' ListTargetsByRule (Maybe Natural) +ltbrLimit = lens _ltbrLimit (\ s a -> s{_ltbrLimit = a}) . mapping _Nat; + +-- | The name of the rule whose targets you want to list. +ltbrRule :: Lens' ListTargetsByRule Text +ltbrRule = lens _ltbrRule (\ s a -> s{_ltbrRule = a}); + +instance AWSRequest ListTargetsByRule where + type Rs ListTargetsByRule = ListTargetsByRuleResponse + request = postJSON cloudWatchEvents + response + = receiveJSON + (\ s h x -> + ListTargetsByRuleResponse' <$> + (x .?> "NextToken") <*> (x .?> "Targets" .!@ mempty) + <*> (pure (fromEnum s))) + +instance Hashable ListTargetsByRule + +instance ToHeaders ListTargetsByRule where + toHeaders + = const + (mconcat + ["X-Amz-Target" =# + ("AWSEvents.ListTargetsByRule" :: ByteString), + "Content-Type" =# + ("application/x-amz-json-1.1" :: ByteString)]) + +instance ToJSON ListTargetsByRule where + toJSON ListTargetsByRule'{..} + = object + (catMaybes + [("NextToken" .=) <$> _ltbrNextToken, + ("Limit" .=) <$> _ltbrLimit, + Just ("Rule" .= _ltbrRule)]) + +instance ToPath ListTargetsByRule where + toPath = const "/" + +instance ToQuery ListTargetsByRule where + toQuery = const mempty + +-- | The result of the < ListTargetsByRule> operation. +-- +-- /See:/ 'listTargetsByRuleResponse' smart constructor. +data ListTargetsByRuleResponse = ListTargetsByRuleResponse' + { _ltbrrsNextToken :: !(Maybe Text) + , _ltbrrsTargets :: !(Maybe [Target]) + , _ltbrrsResponseStatus :: !Int + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'ListTargetsByRuleResponse' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'ltbrrsNextToken' +-- +-- * 'ltbrrsTargets' +-- +-- * 'ltbrrsResponseStatus' +listTargetsByRuleResponse + :: Int -- ^ 'ltbrrsResponseStatus' + -> ListTargetsByRuleResponse +listTargetsByRuleResponse pResponseStatus_ = + ListTargetsByRuleResponse' + { _ltbrrsNextToken = Nothing + , _ltbrrsTargets = Nothing + , _ltbrrsResponseStatus = pResponseStatus_ + } + +-- | Indicates that there are additional results to retrieve. +ltbrrsNextToken :: Lens' ListTargetsByRuleResponse (Maybe Text) +ltbrrsNextToken = lens _ltbrrsNextToken (\ s a -> s{_ltbrrsNextToken = a}); + +-- | Lists the targets assigned to the rule. +ltbrrsTargets :: Lens' ListTargetsByRuleResponse [Target] +ltbrrsTargets = lens _ltbrrsTargets (\ s a -> s{_ltbrrsTargets = a}) . _Default . _Coerce; + +-- | The response status code. +ltbrrsResponseStatus :: Lens' ListTargetsByRuleResponse Int +ltbrrsResponseStatus = lens _ltbrrsResponseStatus (\ s a -> s{_ltbrrsResponseStatus = a}); diff --git a/gen/Network/AWS/CloudWatchEvents/PutEvents.hs b/gen/Network/AWS/CloudWatchEvents/PutEvents.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudWatchEvents/PutEvents.hs @@ -0,0 +1,146 @@ +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-matches #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.CloudWatchEvents.PutEvents +-- Copyright : (c) 2013-2016 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Sends custom events to Amazon CloudWatch Events so that they can be +-- matched to rules. +module Network.AWS.CloudWatchEvents.PutEvents + ( + -- * Creating a Request + putEvents + , PutEvents + -- * Request Lenses + , peEntries + + -- * Destructuring the Response + , putEventsResponse + , PutEventsResponse + -- * Response Lenses + , persFailedEntryCount + , persEntries + , persResponseStatus + ) where + +import Network.AWS.CloudWatchEvents.Types +import Network.AWS.CloudWatchEvents.Types.Product +import Network.AWS.Lens +import Network.AWS.Prelude +import Network.AWS.Request +import Network.AWS.Response + +-- | Container for the parameters to the < PutEvents> operation. +-- +-- /See:/ 'putEvents' smart constructor. +newtype PutEvents = PutEvents' + { _peEntries :: List1 PutEventsRequestEntry + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'PutEvents' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'peEntries' +putEvents + :: NonEmpty PutEventsRequestEntry -- ^ 'peEntries' + -> PutEvents +putEvents pEntries_ = + PutEvents' + { _peEntries = _List1 # pEntries_ + } + +-- | The entry that defines an event in your system. You can specify several +-- parameters for the entry such as the source and type of the event, +-- resources associated with the event, and so on. +peEntries :: Lens' PutEvents (NonEmpty PutEventsRequestEntry) +peEntries = lens _peEntries (\ s a -> s{_peEntries = a}) . _List1; + +instance AWSRequest PutEvents where + type Rs PutEvents = PutEventsResponse + request = postJSON cloudWatchEvents + response + = receiveJSON + (\ s h x -> + PutEventsResponse' <$> + (x .?> "FailedEntryCount") <*> + (x .?> "Entries" .!@ mempty) + <*> (pure (fromEnum s))) + +instance Hashable PutEvents + +instance ToHeaders PutEvents where + toHeaders + = const + (mconcat + ["X-Amz-Target" =# + ("AWSEvents.PutEvents" :: ByteString), + "Content-Type" =# + ("application/x-amz-json-1.1" :: ByteString)]) + +instance ToJSON PutEvents where + toJSON PutEvents'{..} + = object (catMaybes [Just ("Entries" .= _peEntries)]) + +instance ToPath PutEvents where + toPath = const "/" + +instance ToQuery PutEvents where + toQuery = const mempty + +-- | The result of the < PutEvents> operation. +-- +-- /See:/ 'putEventsResponse' smart constructor. +data PutEventsResponse = PutEventsResponse' + { _persFailedEntryCount :: !(Maybe Int) + , _persEntries :: !(Maybe [PutEventsResultEntry]) + , _persResponseStatus :: !Int + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'PutEventsResponse' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'persFailedEntryCount' +-- +-- * 'persEntries' +-- +-- * 'persResponseStatus' +putEventsResponse + :: Int -- ^ 'persResponseStatus' + -> PutEventsResponse +putEventsResponse pResponseStatus_ = + PutEventsResponse' + { _persFailedEntryCount = Nothing + , _persEntries = Nothing + , _persResponseStatus = pResponseStatus_ + } + +-- | The number of failed entries. +persFailedEntryCount :: Lens' PutEventsResponse (Maybe Int) +persFailedEntryCount = lens _persFailedEntryCount (\ s a -> s{_persFailedEntryCount = a}); + +-- | A list of successfully and unsuccessfully ingested events results. If +-- the ingestion was successful, the entry will have the event ID in it. If +-- not, then the ErrorCode and ErrorMessage can be used to identify the +-- problem with the entry. +persEntries :: Lens' PutEventsResponse [PutEventsResultEntry] +persEntries = lens _persEntries (\ s a -> s{_persEntries = a}) . _Default . _Coerce; + +-- | The response status code. +persResponseStatus :: Lens' PutEventsResponse Int +persResponseStatus = lens _persResponseStatus (\ s a -> s{_persResponseStatus = a}); diff --git a/gen/Network/AWS/CloudWatchEvents/PutRule.hs b/gen/Network/AWS/CloudWatchEvents/PutRule.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudWatchEvents/PutRule.hs @@ -0,0 +1,201 @@ +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-matches #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.CloudWatchEvents.PutRule +-- Copyright : (c) 2013-2016 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Creates or updates a rule. Rules are enabled by default, or based on +-- value of the State parameter. You can disable a rule using +-- < DisableRule>. +-- +-- __Note:__ When you create or update a rule, incoming events might not +-- immediately start matching to new or updated rules. Please allow a short +-- period of time for changes to take effect. +-- +-- A rule must contain at least an EventPattern or ScheduleExpression. +-- Rules with EventPatterns are triggered when a matching event is +-- observed. Rules with ScheduleExpressions self-trigger based on the given +-- schedule. A rule can have both an EventPattern and a ScheduleExpression, +-- in which case the rule will trigger on matching events as well as on a +-- schedule. +-- +-- __Note:__ Most services in AWS treat : or \/ as the same character in +-- Amazon Resource Names (ARNs). However, CloudWatch Events uses an exact +-- match in event patterns and rules. Be sure to use the correct ARN +-- characters when creating event patterns so that they match the ARN +-- syntax in the event you want to match. +module Network.AWS.CloudWatchEvents.PutRule + ( + -- * Creating a Request + putRule + , PutRule + -- * Request Lenses + , prEventPattern + , prState + , prScheduleExpression + , prDescription + , prRoleARN + , prName + + -- * Destructuring the Response + , putRuleResponse + , PutRuleResponse + -- * Response Lenses + , prrsRuleARN + , prrsResponseStatus + ) where + +import Network.AWS.CloudWatchEvents.Types +import Network.AWS.CloudWatchEvents.Types.Product +import Network.AWS.Lens +import Network.AWS.Prelude +import Network.AWS.Request +import Network.AWS.Response + +-- | Container for the parameters to the < PutRule> operation. +-- +-- /See:/ 'putRule' smart constructor. +data PutRule = PutRule' + { _prEventPattern :: !(Maybe Text) + , _prState :: !(Maybe RuleState) + , _prScheduleExpression :: !(Maybe Text) + , _prDescription :: !(Maybe Text) + , _prRoleARN :: !(Maybe Text) + , _prName :: !Text + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'PutRule' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'prEventPattern' +-- +-- * 'prState' +-- +-- * 'prScheduleExpression' +-- +-- * 'prDescription' +-- +-- * 'prRoleARN' +-- +-- * 'prName' +putRule + :: Text -- ^ 'prName' + -> PutRule +putRule pName_ = + PutRule' + { _prEventPattern = Nothing + , _prState = Nothing + , _prScheduleExpression = Nothing + , _prDescription = Nothing + , _prRoleARN = Nothing + , _prName = pName_ + } + +-- | The event pattern. +prEventPattern :: Lens' PutRule (Maybe Text) +prEventPattern = lens _prEventPattern (\ s a -> s{_prEventPattern = a}); + +-- | Indicates whether the rule is enabled or disabled. +prState :: Lens' PutRule (Maybe RuleState) +prState = lens _prState (\ s a -> s{_prState = a}); + +-- | The scheduling expression. For example, \"cron(0 20 * * ? *)\", \"rate(5 +-- minutes)\". +prScheduleExpression :: Lens' PutRule (Maybe Text) +prScheduleExpression = lens _prScheduleExpression (\ s a -> s{_prScheduleExpression = a}); + +-- | A description of the rule. +prDescription :: Lens' PutRule (Maybe Text) +prDescription = lens _prDescription (\ s a -> s{_prDescription = a}); + +-- | The Amazon Resource Name (ARN) of the IAM role associated with the rule. +prRoleARN :: Lens' PutRule (Maybe Text) +prRoleARN = lens _prRoleARN (\ s a -> s{_prRoleARN = a}); + +-- | The name of the rule that you are creating or updating. +prName :: Lens' PutRule Text +prName = lens _prName (\ s a -> s{_prName = a}); + +instance AWSRequest PutRule where + type Rs PutRule = PutRuleResponse + request = postJSON cloudWatchEvents + response + = receiveJSON + (\ s h x -> + PutRuleResponse' <$> + (x .?> "RuleArn") <*> (pure (fromEnum s))) + +instance Hashable PutRule + +instance ToHeaders PutRule where + toHeaders + = const + (mconcat + ["X-Amz-Target" =# + ("AWSEvents.PutRule" :: ByteString), + "Content-Type" =# + ("application/x-amz-json-1.1" :: ByteString)]) + +instance ToJSON PutRule where + toJSON PutRule'{..} + = object + (catMaybes + [("EventPattern" .=) <$> _prEventPattern, + ("State" .=) <$> _prState, + ("ScheduleExpression" .=) <$> _prScheduleExpression, + ("Description" .=) <$> _prDescription, + ("RoleArn" .=) <$> _prRoleARN, + Just ("Name" .= _prName)]) + +instance ToPath PutRule where + toPath = const "/" + +instance ToQuery PutRule where + toQuery = const mempty + +-- | The result of the < PutRule> operation. +-- +-- /See:/ 'putRuleResponse' smart constructor. +data PutRuleResponse = PutRuleResponse' + { _prrsRuleARN :: !(Maybe Text) + , _prrsResponseStatus :: !Int + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'PutRuleResponse' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'prrsRuleARN' +-- +-- * 'prrsResponseStatus' +putRuleResponse + :: Int -- ^ 'prrsResponseStatus' + -> PutRuleResponse +putRuleResponse pResponseStatus_ = + PutRuleResponse' + { _prrsRuleARN = Nothing + , _prrsResponseStatus = pResponseStatus_ + } + +-- | The Amazon Resource Name (ARN) that identifies the rule. +prrsRuleARN :: Lens' PutRuleResponse (Maybe Text) +prrsRuleARN = lens _prrsRuleARN (\ s a -> s{_prrsRuleARN = a}); + +-- | The response status code. +prrsResponseStatus :: Lens' PutRuleResponse Int +prrsResponseStatus = lens _prrsResponseStatus (\ s a -> s{_prrsResponseStatus = a}); diff --git a/gen/Network/AWS/CloudWatchEvents/PutTargets.hs b/gen/Network/AWS/CloudWatchEvents/PutTargets.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudWatchEvents/PutTargets.hs @@ -0,0 +1,182 @@ +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-matches #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.CloudWatchEvents.PutTargets +-- Copyright : (c) 2013-2016 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Adds target(s) to a rule. Targets are the resources that can be invoked +-- when a rule is triggered. For example, AWS Lambda functions, Amazon +-- Kinesis streams, and built-in targets. Updates the target(s) if they are +-- already associated with the role. In other words, if there is already a +-- target with the given target ID, then the target associated with that ID +-- is updated. +-- +-- In order to be able to make API calls against the resources you own, +-- Amazon CloudWatch Events needs the appropriate permissions. For AWS +-- Lambda and Amazon SNS resources, CloudWatch Events relies on +-- resource-based policies. For Amazon Kinesis streams, CloudWatch Events +-- relies on IAM roles. For more information, see +-- +-- in the __/Amazon CloudWatch Developer Guide/__. +-- +-- __Input__ and __InputPath__ are mutually-exclusive and optional +-- parameters of a target. When a rule is triggered due to a matched event, +-- if for a target: +-- +-- - Neither __Input__ nor __InputPath__ is specified, then the entire +-- event is passed to the target in JSON form. +-- - __InputPath__ is specified in the form of JSONPath (e.g. +-- __$.detail__), then only the part of the event specified in the path +-- is passed to the target (e.g. only the detail part of the event is +-- passed). +-- - __Input__ is specified in the form of a valid JSON, then the matched +-- event is overridden with this constant. +-- +-- __Note:__ When you add targets to a rule, when the associated rule +-- triggers, new or updated targets might not be immediately invoked. +-- Please allow a short period of time for changes to take effect. +module Network.AWS.CloudWatchEvents.PutTargets + ( + -- * Creating a Request + putTargets + , PutTargets + -- * Request Lenses + , ptRule + , ptTargets + + -- * Destructuring the Response + , putTargetsResponse + , PutTargetsResponse + -- * Response Lenses + , ptrsFailedEntryCount + , ptrsFailedEntries + , ptrsResponseStatus + ) where + +import Network.AWS.CloudWatchEvents.Types +import Network.AWS.CloudWatchEvents.Types.Product +import Network.AWS.Lens +import Network.AWS.Prelude +import Network.AWS.Request +import Network.AWS.Response + +-- | Container for the parameters to the < PutTargets> operation. +-- +-- /See:/ 'putTargets' smart constructor. +data PutTargets = PutTargets' + { _ptRule :: !Text + , _ptTargets :: ![Target] + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'PutTargets' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'ptRule' +-- +-- * 'ptTargets' +putTargets + :: Text -- ^ 'ptRule' + -> PutTargets +putTargets pRule_ = + PutTargets' + { _ptRule = pRule_ + , _ptTargets = mempty + } + +-- | The name of the rule you want to add targets to. +ptRule :: Lens' PutTargets Text +ptRule = lens _ptRule (\ s a -> s{_ptRule = a}); + +-- | List of targets you want to update or add to the rule. +ptTargets :: Lens' PutTargets [Target] +ptTargets = lens _ptTargets (\ s a -> s{_ptTargets = a}) . _Coerce; + +instance AWSRequest PutTargets where + type Rs PutTargets = PutTargetsResponse + request = postJSON cloudWatchEvents + response + = receiveJSON + (\ s h x -> + PutTargetsResponse' <$> + (x .?> "FailedEntryCount") <*> + (x .?> "FailedEntries" .!@ mempty) + <*> (pure (fromEnum s))) + +instance Hashable PutTargets + +instance ToHeaders PutTargets where + toHeaders + = const + (mconcat + ["X-Amz-Target" =# + ("AWSEvents.PutTargets" :: ByteString), + "Content-Type" =# + ("application/x-amz-json-1.1" :: ByteString)]) + +instance ToJSON PutTargets where + toJSON PutTargets'{..} + = object + (catMaybes + [Just ("Rule" .= _ptRule), + Just ("Targets" .= _ptTargets)]) + +instance ToPath PutTargets where + toPath = const "/" + +instance ToQuery PutTargets where + toQuery = const mempty + +-- | The result of the < PutTargets> operation. +-- +-- /See:/ 'putTargetsResponse' smart constructor. +data PutTargetsResponse = PutTargetsResponse' + { _ptrsFailedEntryCount :: !(Maybe Int) + , _ptrsFailedEntries :: !(Maybe [PutTargetsResultEntry]) + , _ptrsResponseStatus :: !Int + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'PutTargetsResponse' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'ptrsFailedEntryCount' +-- +-- * 'ptrsFailedEntries' +-- +-- * 'ptrsResponseStatus' +putTargetsResponse + :: Int -- ^ 'ptrsResponseStatus' + -> PutTargetsResponse +putTargetsResponse pResponseStatus_ = + PutTargetsResponse' + { _ptrsFailedEntryCount = Nothing + , _ptrsFailedEntries = Nothing + , _ptrsResponseStatus = pResponseStatus_ + } + +-- | The number of failed entries. +ptrsFailedEntryCount :: Lens' PutTargetsResponse (Maybe Int) +ptrsFailedEntryCount = lens _ptrsFailedEntryCount (\ s a -> s{_ptrsFailedEntryCount = a}); + +-- | An array of failed target entries. +ptrsFailedEntries :: Lens' PutTargetsResponse [PutTargetsResultEntry] +ptrsFailedEntries = lens _ptrsFailedEntries (\ s a -> s{_ptrsFailedEntries = a}) . _Default . _Coerce; + +-- | The response status code. +ptrsResponseStatus :: Lens' PutTargetsResponse Int +ptrsResponseStatus = lens _ptrsResponseStatus (\ s a -> s{_ptrsResponseStatus = a}); diff --git a/gen/Network/AWS/CloudWatchEvents/RemoveTargets.hs b/gen/Network/AWS/CloudWatchEvents/RemoveTargets.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudWatchEvents/RemoveTargets.hs @@ -0,0 +1,157 @@ +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-matches #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.CloudWatchEvents.RemoveTargets +-- Copyright : (c) 2013-2016 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Removes target(s) from a rule so that when the rule is triggered, those +-- targets will no longer be invoked. +-- +-- __Note:__ When you remove a target, when the associated rule triggers, +-- removed targets might still continue to be invoked. Please allow a short +-- period of time for changes to take effect. +module Network.AWS.CloudWatchEvents.RemoveTargets + ( + -- * Creating a Request + removeTargets + , RemoveTargets + -- * Request Lenses + , rtRule + , rtIds + + -- * Destructuring the Response + , removeTargetsResponse + , RemoveTargetsResponse + -- * Response Lenses + , rtrsFailedEntryCount + , rtrsFailedEntries + , rtrsResponseStatus + ) where + +import Network.AWS.CloudWatchEvents.Types +import Network.AWS.CloudWatchEvents.Types.Product +import Network.AWS.Lens +import Network.AWS.Prelude +import Network.AWS.Request +import Network.AWS.Response + +-- | Container for the parameters to the < RemoveTargets> operation. +-- +-- /See:/ 'removeTargets' smart constructor. +data RemoveTargets = RemoveTargets' + { _rtRule :: !Text + , _rtIds :: !(List1 Text) + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'RemoveTargets' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'rtRule' +-- +-- * 'rtIds' +removeTargets + :: Text -- ^ 'rtRule' + -> NonEmpty Text -- ^ 'rtIds' + -> RemoveTargets +removeTargets pRule_ pIds_ = + RemoveTargets' + { _rtRule = pRule_ + , _rtIds = _List1 # pIds_ + } + +-- | The name of the rule you want to remove targets from. +rtRule :: Lens' RemoveTargets Text +rtRule = lens _rtRule (\ s a -> s{_rtRule = a}); + +-- | The list of target IDs to remove from the rule. +rtIds :: Lens' RemoveTargets (NonEmpty Text) +rtIds = lens _rtIds (\ s a -> s{_rtIds = a}) . _List1; + +instance AWSRequest RemoveTargets where + type Rs RemoveTargets = RemoveTargetsResponse + request = postJSON cloudWatchEvents + response + = receiveJSON + (\ s h x -> + RemoveTargetsResponse' <$> + (x .?> "FailedEntryCount") <*> + (x .?> "FailedEntries" .!@ mempty) + <*> (pure (fromEnum s))) + +instance Hashable RemoveTargets + +instance ToHeaders RemoveTargets where + toHeaders + = const + (mconcat + ["X-Amz-Target" =# + ("AWSEvents.RemoveTargets" :: ByteString), + "Content-Type" =# + ("application/x-amz-json-1.1" :: ByteString)]) + +instance ToJSON RemoveTargets where + toJSON RemoveTargets'{..} + = object + (catMaybes + [Just ("Rule" .= _rtRule), Just ("Ids" .= _rtIds)]) + +instance ToPath RemoveTargets where + toPath = const "/" + +instance ToQuery RemoveTargets where + toQuery = const mempty + +-- | The result of the < RemoveTargets> operation. +-- +-- /See:/ 'removeTargetsResponse' smart constructor. +data RemoveTargetsResponse = RemoveTargetsResponse' + { _rtrsFailedEntryCount :: !(Maybe Int) + , _rtrsFailedEntries :: !(Maybe [RemoveTargetsResultEntry]) + , _rtrsResponseStatus :: !Int + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'RemoveTargetsResponse' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'rtrsFailedEntryCount' +-- +-- * 'rtrsFailedEntries' +-- +-- * 'rtrsResponseStatus' +removeTargetsResponse + :: Int -- ^ 'rtrsResponseStatus' + -> RemoveTargetsResponse +removeTargetsResponse pResponseStatus_ = + RemoveTargetsResponse' + { _rtrsFailedEntryCount = Nothing + , _rtrsFailedEntries = Nothing + , _rtrsResponseStatus = pResponseStatus_ + } + +-- | The number of failed entries. +rtrsFailedEntryCount :: Lens' RemoveTargetsResponse (Maybe Int) +rtrsFailedEntryCount = lens _rtrsFailedEntryCount (\ s a -> s{_rtrsFailedEntryCount = a}); + +-- | An array of failed target entries. +rtrsFailedEntries :: Lens' RemoveTargetsResponse [RemoveTargetsResultEntry] +rtrsFailedEntries = lens _rtrsFailedEntries (\ s a -> s{_rtrsFailedEntries = a}) . _Default . _Coerce; + +-- | The response status code. +rtrsResponseStatus :: Lens' RemoveTargetsResponse Int +rtrsResponseStatus = lens _rtrsResponseStatus (\ s a -> s{_rtrsResponseStatus = a}); diff --git a/gen/Network/AWS/CloudWatchEvents/TestEventPattern.hs b/gen/Network/AWS/CloudWatchEvents/TestEventPattern.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudWatchEvents/TestEventPattern.hs @@ -0,0 +1,148 @@ +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-matches #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.CloudWatchEvents.TestEventPattern +-- Copyright : (c) 2013-2016 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Tests whether an event pattern matches the provided event. +-- +-- __Note:__ Most services in AWS treat : or \/ as the same character in +-- Amazon Resource Names (ARNs). However, CloudWatch Events uses an exact +-- match in event patterns and rules. Be sure to use the correct ARN +-- characters when creating event patterns so that they match the ARN +-- syntax in the event you want to match. +module Network.AWS.CloudWatchEvents.TestEventPattern + ( + -- * Creating a Request + testEventPattern + , TestEventPattern + -- * Request Lenses + , tepEventPattern + , tepEvent + + -- * Destructuring the Response + , testEventPatternResponse + , TestEventPatternResponse + -- * Response Lenses + , teprsResult + , teprsResponseStatus + ) where + +import Network.AWS.CloudWatchEvents.Types +import Network.AWS.CloudWatchEvents.Types.Product +import Network.AWS.Lens +import Network.AWS.Prelude +import Network.AWS.Request +import Network.AWS.Response + +-- | Container for the parameters to the < TestEventPattern> operation. +-- +-- /See:/ 'testEventPattern' smart constructor. +data TestEventPattern = TestEventPattern' + { _tepEventPattern :: !Text + , _tepEvent :: !Text + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'TestEventPattern' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'tepEventPattern' +-- +-- * 'tepEvent' +testEventPattern + :: Text -- ^ 'tepEventPattern' + -> Text -- ^ 'tepEvent' + -> TestEventPattern +testEventPattern pEventPattern_ pEvent_ = + TestEventPattern' + { _tepEventPattern = pEventPattern_ + , _tepEvent = pEvent_ + } + +-- | The event pattern you want to test. +tepEventPattern :: Lens' TestEventPattern Text +tepEventPattern = lens _tepEventPattern (\ s a -> s{_tepEventPattern = a}); + +-- | The event in the JSON format to test against the event pattern. +tepEvent :: Lens' TestEventPattern Text +tepEvent = lens _tepEvent (\ s a -> s{_tepEvent = a}); + +instance AWSRequest TestEventPattern where + type Rs TestEventPattern = TestEventPatternResponse + request = postJSON cloudWatchEvents + response + = receiveJSON + (\ s h x -> + TestEventPatternResponse' <$> + (x .?> "Result") <*> (pure (fromEnum s))) + +instance Hashable TestEventPattern + +instance ToHeaders TestEventPattern where + toHeaders + = const + (mconcat + ["X-Amz-Target" =# + ("AWSEvents.TestEventPattern" :: ByteString), + "Content-Type" =# + ("application/x-amz-json-1.1" :: ByteString)]) + +instance ToJSON TestEventPattern where + toJSON TestEventPattern'{..} + = object + (catMaybes + [Just ("EventPattern" .= _tepEventPattern), + Just ("Event" .= _tepEvent)]) + +instance ToPath TestEventPattern where + toPath = const "/" + +instance ToQuery TestEventPattern where + toQuery = const mempty + +-- | The result of the < TestEventPattern> operation. +-- +-- /See:/ 'testEventPatternResponse' smart constructor. +data TestEventPatternResponse = TestEventPatternResponse' + { _teprsResult :: !(Maybe Bool) + , _teprsResponseStatus :: !Int + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'TestEventPatternResponse' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'teprsResult' +-- +-- * 'teprsResponseStatus' +testEventPatternResponse + :: Int -- ^ 'teprsResponseStatus' + -> TestEventPatternResponse +testEventPatternResponse pResponseStatus_ = + TestEventPatternResponse' + { _teprsResult = Nothing + , _teprsResponseStatus = pResponseStatus_ + } + +-- | Indicates whether the event matches the event pattern. +teprsResult :: Lens' TestEventPatternResponse (Maybe Bool) +teprsResult = lens _teprsResult (\ s a -> s{_teprsResult = a}); + +-- | The response status code. +teprsResponseStatus :: Lens' TestEventPatternResponse Int +teprsResponseStatus = lens _teprsResponseStatus (\ s a -> s{_teprsResponseStatus = a}); diff --git a/gen/Network/AWS/CloudWatchEvents/Types.hs b/gen/Network/AWS/CloudWatchEvents/Types.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudWatchEvents/Types.hs @@ -0,0 +1,139 @@ +{-# LANGUAGE OverloadedStrings #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.CloudWatchEvents.Types +-- Copyright : (c) 2013-2016 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +module Network.AWS.CloudWatchEvents.Types + ( + -- * Service Configuration + cloudWatchEvents + + -- * Errors + , _ConcurrentModificationException + , _InvalidEventPatternException + , _InternalException + , _ResourceNotFoundException + , _LimitExceededException + + -- * RuleState + , RuleState (..) + + -- * PutEventsRequestEntry + , PutEventsRequestEntry + , putEventsRequestEntry + , pereTime + , pereDetailType + , pereResources + , pereSource + , pereDetail + + -- * PutEventsResultEntry + , PutEventsResultEntry + , putEventsResultEntry + , pereErrorCode + , pereErrorMessage + , pereEventId + + -- * PutTargetsResultEntry + , PutTargetsResultEntry + , putTargetsResultEntry + , ptreTargetId + , ptreErrorCode + , ptreErrorMessage + + -- * RemoveTargetsResultEntry + , RemoveTargetsResultEntry + , removeTargetsResultEntry + , rtreTargetId + , rtreErrorCode + , rtreErrorMessage + + -- * Rule + , Rule + , rule + , rEventPattern + , rState + , rARN + , rScheduleExpression + , rName + , rDescription + , rRoleARN + + -- * Target + , Target + , target + , tInput + , tInputPath + , tId + , tARN + ) where + +import Network.AWS.CloudWatchEvents.Types.Product +import Network.AWS.CloudWatchEvents.Types.Sum +import Network.AWS.Lens +import Network.AWS.Prelude +import Network.AWS.Sign.V4 + +-- | API version '2015-10-07' of the Amazon CloudWatch Events SDK configuration. +cloudWatchEvents :: Service +cloudWatchEvents = + Service + { _svcAbbrev = "CloudWatchEvents" + , _svcSigner = v4 + , _svcPrefix = "events" + , _svcVersion = "2015-10-07" + , _svcEndpoint = defaultEndpoint cloudWatchEvents + , _svcTimeout = Just 70 + , _svcCheck = statusSuccess + , _svcError = parseJSONError + , _svcRetry = retry + } + where + retry = + Exponential + { _retryBase = 5.0e-2 + , _retryGrowth = 2 + , _retryAttempts = 5 + , _retryCheck = check + } + check e + | has (hasStatus 429) e = Just "too_many_requests" + | has (hasCode "ThrottlingException" . hasStatus 400) e = + Just "throttling_exception" + | has (hasCode "Throttling" . hasStatus 400) e = Just "throttling" + | has (hasStatus 503) e = Just "service_unavailable" + | has (hasStatus 500) e = Just "general_server_error" + | has (hasStatus 509) e = Just "limit_exceeded" + | otherwise = Nothing + +-- | This exception occurs if there is concurrent modification on rule or +-- target. +_ConcurrentModificationException :: AsError a => Getting (First ServiceError) a ServiceError +_ConcurrentModificationException = + _ServiceError . hasCode "ConcurrentModificationException" + +-- | The event pattern is invalid. +_InvalidEventPatternException :: AsError a => Getting (First ServiceError) a ServiceError +_InvalidEventPatternException = + _ServiceError . hasCode "InvalidEventPatternException" + +-- | This exception occurs due to unexpected causes. +_InternalException :: AsError a => Getting (First ServiceError) a ServiceError +_InternalException = _ServiceError . hasCode "InternalException" + +-- | The rule does not exist. +_ResourceNotFoundException :: AsError a => Getting (First ServiceError) a ServiceError +_ResourceNotFoundException = + _ServiceError . hasCode "ResourceNotFoundException" + +-- | This exception occurs if you try to create more rules or add more +-- targets to a rule than allowed by default. +_LimitExceededException :: AsError a => Getting (First ServiceError) a ServiceError +_LimitExceededException = _ServiceError . hasCode "LimitExceededException" diff --git a/gen/Network/AWS/CloudWatchEvents/Types/Product.hs b/gen/Network/AWS/CloudWatchEvents/Types/Product.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudWatchEvents/Types/Product.hs @@ -0,0 +1,423 @@ +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.CloudWatchEvents.Types.Product +-- Copyright : (c) 2013-2016 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +module Network.AWS.CloudWatchEvents.Types.Product where + +import Network.AWS.CloudWatchEvents.Types.Sum +import Network.AWS.Lens +import Network.AWS.Prelude + +-- | Contains information about the event to be used in PutEvents. +-- +-- /See:/ 'putEventsRequestEntry' smart constructor. +data PutEventsRequestEntry = PutEventsRequestEntry' + { _pereTime :: !(Maybe POSIX) + , _pereDetailType :: !(Maybe Text) + , _pereResources :: !(Maybe [Text]) + , _pereSource :: !(Maybe Text) + , _pereDetail :: !(Maybe Text) + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'PutEventsRequestEntry' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'pereTime' +-- +-- * 'pereDetailType' +-- +-- * 'pereResources' +-- +-- * 'pereSource' +-- +-- * 'pereDetail' +putEventsRequestEntry + :: PutEventsRequestEntry +putEventsRequestEntry = + PutEventsRequestEntry' + { _pereTime = Nothing + , _pereDetailType = Nothing + , _pereResources = Nothing + , _pereSource = Nothing + , _pereDetail = Nothing + } + +-- | Timestamp of event, per +-- . If no timestamp is +-- provided, the timestamp of the < PutEvents> call will be used. +pereTime :: Lens' PutEventsRequestEntry (Maybe UTCTime) +pereTime = lens _pereTime (\ s a -> s{_pereTime = a}) . mapping _Time; + +-- | Free-form string used to decide what fields to expect in the event +-- detail. +pereDetailType :: Lens' PutEventsRequestEntry (Maybe Text) +pereDetailType = lens _pereDetailType (\ s a -> s{_pereDetailType = a}); + +-- | AWS resources, identified by Amazon Resource Name (ARN), which the event +-- primarily concerns. Any number, including zero, may be present. +pereResources :: Lens' PutEventsRequestEntry [Text] +pereResources = lens _pereResources (\ s a -> s{_pereResources = a}) . _Default . _Coerce; + +-- | The source of the event. +pereSource :: Lens' PutEventsRequestEntry (Maybe Text) +pereSource = lens _pereSource (\ s a -> s{_pereSource = a}); + +-- | In the JSON sense, an object containing fields, which may also contain +-- nested sub-objects. No constraints are imposed on its contents. +pereDetail :: Lens' PutEventsRequestEntry (Maybe Text) +pereDetail = lens _pereDetail (\ s a -> s{_pereDetail = a}); + +instance Hashable PutEventsRequestEntry + +instance ToJSON PutEventsRequestEntry where + toJSON PutEventsRequestEntry'{..} + = object + (catMaybes + [("Time" .=) <$> _pereTime, + ("DetailType" .=) <$> _pereDetailType, + ("Resources" .=) <$> _pereResources, + ("Source" .=) <$> _pereSource, + ("Detail" .=) <$> _pereDetail]) + +-- | A PutEventsResult contains a list of PutEventsResultEntry. +-- +-- /See:/ 'putEventsResultEntry' smart constructor. +data PutEventsResultEntry = PutEventsResultEntry' + { _pereErrorCode :: !(Maybe Text) + , _pereErrorMessage :: !(Maybe Text) + , _pereEventId :: !(Maybe Text) + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'PutEventsResultEntry' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'pereErrorCode' +-- +-- * 'pereErrorMessage' +-- +-- * 'pereEventId' +putEventsResultEntry + :: PutEventsResultEntry +putEventsResultEntry = + PutEventsResultEntry' + { _pereErrorCode = Nothing + , _pereErrorMessage = Nothing + , _pereEventId = Nothing + } + +-- | The error code representing why the event submission failed on this +-- entry. +pereErrorCode :: Lens' PutEventsResultEntry (Maybe Text) +pereErrorCode = lens _pereErrorCode (\ s a -> s{_pereErrorCode = a}); + +-- | The error message explaining why the event submission failed on this +-- entry. +pereErrorMessage :: Lens' PutEventsResultEntry (Maybe Text) +pereErrorMessage = lens _pereErrorMessage (\ s a -> s{_pereErrorMessage = a}); + +-- | The ID of the event submitted to Amazon CloudWatch Events. +pereEventId :: Lens' PutEventsResultEntry (Maybe Text) +pereEventId = lens _pereEventId (\ s a -> s{_pereEventId = a}); + +instance FromJSON PutEventsResultEntry where + parseJSON + = withObject "PutEventsResultEntry" + (\ x -> + PutEventsResultEntry' <$> + (x .:? "ErrorCode") <*> (x .:? "ErrorMessage") <*> + (x .:? "EventId")) + +instance Hashable PutEventsResultEntry + +-- | A PutTargetsResult contains a list of PutTargetsResultEntry. +-- +-- /See:/ 'putTargetsResultEntry' smart constructor. +data PutTargetsResultEntry = PutTargetsResultEntry' + { _ptreTargetId :: !(Maybe Text) + , _ptreErrorCode :: !(Maybe Text) + , _ptreErrorMessage :: !(Maybe Text) + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'PutTargetsResultEntry' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'ptreTargetId' +-- +-- * 'ptreErrorCode' +-- +-- * 'ptreErrorMessage' +putTargetsResultEntry + :: PutTargetsResultEntry +putTargetsResultEntry = + PutTargetsResultEntry' + { _ptreTargetId = Nothing + , _ptreErrorCode = Nothing + , _ptreErrorMessage = Nothing + } + +-- | The ID of the target submitted to Amazon CloudWatch Events. +ptreTargetId :: Lens' PutTargetsResultEntry (Maybe Text) +ptreTargetId = lens _ptreTargetId (\ s a -> s{_ptreTargetId = a}); + +-- | The error code representing why the target submission failed on this +-- entry. +ptreErrorCode :: Lens' PutTargetsResultEntry (Maybe Text) +ptreErrorCode = lens _ptreErrorCode (\ s a -> s{_ptreErrorCode = a}); + +-- | The error message explaining why the target submission failed on this +-- entry. +ptreErrorMessage :: Lens' PutTargetsResultEntry (Maybe Text) +ptreErrorMessage = lens _ptreErrorMessage (\ s a -> s{_ptreErrorMessage = a}); + +instance FromJSON PutTargetsResultEntry where + parseJSON + = withObject "PutTargetsResultEntry" + (\ x -> + PutTargetsResultEntry' <$> + (x .:? "TargetId") <*> (x .:? "ErrorCode") <*> + (x .:? "ErrorMessage")) + +instance Hashable PutTargetsResultEntry + +-- | The ID of the target requested to be removed from the rule by Amazon +-- CloudWatch Events. +-- +-- /See:/ 'removeTargetsResultEntry' smart constructor. +data RemoveTargetsResultEntry = RemoveTargetsResultEntry' + { _rtreTargetId :: !(Maybe Text) + , _rtreErrorCode :: !(Maybe Text) + , _rtreErrorMessage :: !(Maybe Text) + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'RemoveTargetsResultEntry' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'rtreTargetId' +-- +-- * 'rtreErrorCode' +-- +-- * 'rtreErrorMessage' +removeTargetsResultEntry + :: RemoveTargetsResultEntry +removeTargetsResultEntry = + RemoveTargetsResultEntry' + { _rtreTargetId = Nothing + , _rtreErrorCode = Nothing + , _rtreErrorMessage = Nothing + } + +-- | The ID of the target requested to be removed by Amazon CloudWatch +-- Events. +rtreTargetId :: Lens' RemoveTargetsResultEntry (Maybe Text) +rtreTargetId = lens _rtreTargetId (\ s a -> s{_rtreTargetId = a}); + +-- | The error code representing why the target removal failed on this entry. +rtreErrorCode :: Lens' RemoveTargetsResultEntry (Maybe Text) +rtreErrorCode = lens _rtreErrorCode (\ s a -> s{_rtreErrorCode = a}); + +-- | The error message explaining why the target removal failed on this +-- entry. +rtreErrorMessage :: Lens' RemoveTargetsResultEntry (Maybe Text) +rtreErrorMessage = lens _rtreErrorMessage (\ s a -> s{_rtreErrorMessage = a}); + +instance FromJSON RemoveTargetsResultEntry where + parseJSON + = withObject "RemoveTargetsResultEntry" + (\ x -> + RemoveTargetsResultEntry' <$> + (x .:? "TargetId") <*> (x .:? "ErrorCode") <*> + (x .:? "ErrorMessage")) + +instance Hashable RemoveTargetsResultEntry + +-- | Contains information about a rule in Amazon CloudWatch Events. A +-- ListRulesResult contains a list of Rules. +-- +-- /See:/ 'rule' smart constructor. +data Rule = Rule' + { _rEventPattern :: !(Maybe Text) + , _rState :: !(Maybe RuleState) + , _rARN :: !(Maybe Text) + , _rScheduleExpression :: !(Maybe Text) + , _rName :: !(Maybe Text) + , _rDescription :: !(Maybe Text) + , _rRoleARN :: !(Maybe Text) + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'Rule' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'rEventPattern' +-- +-- * 'rState' +-- +-- * 'rARN' +-- +-- * 'rScheduleExpression' +-- +-- * 'rName' +-- +-- * 'rDescription' +-- +-- * 'rRoleARN' +rule + :: Rule +rule = + Rule' + { _rEventPattern = Nothing + , _rState = Nothing + , _rARN = Nothing + , _rScheduleExpression = Nothing + , _rName = Nothing + , _rDescription = Nothing + , _rRoleARN = Nothing + } + +-- | The event pattern of the rule. +rEventPattern :: Lens' Rule (Maybe Text) +rEventPattern = lens _rEventPattern (\ s a -> s{_rEventPattern = a}); + +-- | The rule\'s state. +rState :: Lens' Rule (Maybe RuleState) +rState = lens _rState (\ s a -> s{_rState = a}); + +-- | The Amazon Resource Name (ARN) of the rule. +rARN :: Lens' Rule (Maybe Text) +rARN = lens _rARN (\ s a -> s{_rARN = a}); + +-- | The scheduling expression. For example, \"cron(0 20 * * ? *)\", \"rate(5 +-- minutes)\". +rScheduleExpression :: Lens' Rule (Maybe Text) +rScheduleExpression = lens _rScheduleExpression (\ s a -> s{_rScheduleExpression = a}); + +-- | The rule\'s name. +rName :: Lens' Rule (Maybe Text) +rName = lens _rName (\ s a -> s{_rName = a}); + +-- | The description of the rule. +rDescription :: Lens' Rule (Maybe Text) +rDescription = lens _rDescription (\ s a -> s{_rDescription = a}); + +-- | The Amazon Resource Name (ARN) associated with the role that is used for +-- target invocation. +rRoleARN :: Lens' Rule (Maybe Text) +rRoleARN = lens _rRoleARN (\ s a -> s{_rRoleARN = a}); + +instance FromJSON Rule where + parseJSON + = withObject "Rule" + (\ x -> + Rule' <$> + (x .:? "EventPattern") <*> (x .:? "State") <*> + (x .:? "Arn") + <*> (x .:? "ScheduleExpression") + <*> (x .:? "Name") + <*> (x .:? "Description") + <*> (x .:? "RoleArn")) + +instance Hashable Rule + +-- | Targets are the resources that can be invoked when a rule is triggered. +-- For example, AWS Lambda functions, Amazon Kinesis streams, and built-in +-- targets. +-- +-- __Input__ and __InputPath__ are mutually-exclusive and optional +-- parameters of a target. When a rule is triggered due to a matched event, +-- if for a target: +-- +-- - Neither __Input__ nor __InputPath__ is specified, then the entire +-- event is passed to the target in JSON form. +-- - __InputPath__ is specified in the form of JSONPath (e.g. +-- __$.detail__), then only the part of the event specified in the path +-- is passed to the target (e.g. only the detail part of the event is +-- passed). +-- - __Input__ is specified in the form of a valid JSON, then the matched +-- event is overridden with this constant. +-- +-- /See:/ 'target' smart constructor. +data Target = Target' + { _tInput :: !(Maybe Text) + , _tInputPath :: !(Maybe Text) + , _tId :: !Text + , _tARN :: !Text + } deriving (Eq,Read,Show,Data,Typeable,Generic) + +-- | Creates a value of 'Target' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'tInput' +-- +-- * 'tInputPath' +-- +-- * 'tId' +-- +-- * 'tARN' +target + :: Text -- ^ 'tId' + -> Text -- ^ 'tARN' + -> Target +target pId_ pARN_ = + Target' + { _tInput = Nothing + , _tInputPath = Nothing + , _tId = pId_ + , _tARN = pARN_ + } + +-- | Valid JSON text passed to the target. For more information about JSON +-- text, see +-- . +tInput :: Lens' Target (Maybe Text) +tInput = lens _tInput (\ s a -> s{_tInput = a}); + +-- | The value of the JSONPath that is used for extracting part of the +-- matched event when passing it to the target. For more information about +-- JSON paths, see . +tInputPath :: Lens' Target (Maybe Text) +tInputPath = lens _tInputPath (\ s a -> s{_tInputPath = a}); + +-- | The unique target assignment ID. +tId :: Lens' Target Text +tId = lens _tId (\ s a -> s{_tId = a}); + +-- | The Amazon Resource Name (ARN) associated of the target. +tARN :: Lens' Target Text +tARN = lens _tARN (\ s a -> s{_tARN = a}); + +instance FromJSON Target where + parseJSON + = withObject "Target" + (\ x -> + Target' <$> + (x .:? "Input") <*> (x .:? "InputPath") <*> + (x .: "Id") + <*> (x .: "Arn")) + +instance Hashable Target + +instance ToJSON Target where + toJSON Target'{..} + = object + (catMaybes + [("Input" .=) <$> _tInput, + ("InputPath" .=) <$> _tInputPath, + Just ("Id" .= _tId), Just ("Arn" .= _tARN)]) diff --git a/gen/Network/AWS/CloudWatchEvents/Types/Sum.hs b/gen/Network/AWS/CloudWatchEvents/Types/Sum.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudWatchEvents/Types/Sum.hs @@ -0,0 +1,48 @@ +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE OverloadedStrings #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.CloudWatchEvents.Types.Sum +-- Copyright : (c) 2013-2016 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +module Network.AWS.CloudWatchEvents.Types.Sum where + +import Network.AWS.Prelude + +data RuleState + = Disabled + | Enabled + deriving (Eq,Ord,Read,Show,Enum,Bounded,Data,Typeable,Generic) + +instance FromText RuleState where + parser = takeLowerText >>= \case + "disabled" -> pure Disabled + "enabled" -> pure Enabled + e -> fromTextError $ "Failure parsing RuleState from value: '" <> e + <> "'. Accepted values: DISABLED, ENABLED" + +instance ToText RuleState where + toText = \case + Disabled -> "DISABLED" + Enabled -> "ENABLED" + +instance Hashable RuleState +instance ToByteString RuleState +instance ToQuery RuleState +instance ToHeader RuleState + +instance ToJSON RuleState where + toJSON = toJSONText + +instance FromJSON RuleState where + parseJSON = parseJSONText "RuleState" diff --git a/gen/Network/AWS/CloudWatchEvents/Waiters.hs b/gen/Network/AWS/CloudWatchEvents/Waiters.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudWatchEvents/Waiters.hs @@ -0,0 +1,21 @@ +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.CloudWatchEvents.Waiters +-- Copyright : (c) 2013-2016 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +module Network.AWS.CloudWatchEvents.Waiters where + +import Network.AWS.CloudWatchEvents.Types +import Network.AWS.Lens +import Network.AWS.Prelude +import Network.AWS.Waiter diff --git a/test/Main.hs b/test/Main.hs new file mode 100644 --- /dev/null +++ b/test/Main.hs @@ -0,0 +1,21 @@ +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- | +-- Module : Main +-- Copyright : (c) 2013-2016 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +module Main (main) where + +import Test.Tasty +import Test.AWS.CloudWatchEvents +import Test.AWS.CloudWatchEvents.Internal + +main :: IO () +main = defaultMain $ testGroup "CloudWatchEvents" + [ testGroup "tests" tests + , testGroup "fixtures" fixtures + ] diff --git a/test/Test/AWS/CloudWatchEvents.hs b/test/Test/AWS/CloudWatchEvents.hs new file mode 100644 --- /dev/null +++ b/test/Test/AWS/CloudWatchEvents.hs @@ -0,0 +1,23 @@ +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE TemplateHaskell #-} + +-- | +-- Module : Test.AWS.CloudWatchEvents +-- Copyright : (c) 2013-2016 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) +-- +module Test.AWS.CloudWatchEvents + ( tests + , fixtures + ) where + +import Test.AWS.Prelude + +tests :: [TestTree] +tests = [] + +fixtures :: [TestTree] +fixtures = [] diff --git a/test/Test/AWS/CloudWatchEvents/Internal.hs b/test/Test/AWS/CloudWatchEvents/Internal.hs new file mode 100644 --- /dev/null +++ b/test/Test/AWS/CloudWatchEvents/Internal.hs @@ -0,0 +1,15 @@ +{-# LANGUAGE OverloadedStrings #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- | +-- Module : Test.AWS.CloudWatchEvents.Internal +-- Copyright : (c) 2013-2016 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) +-- + +module Test.AWS.CloudWatchEvents.Internal where + +import Test.AWS.Prelude diff --git a/test/Test/AWS/Gen/CloudWatchEvents.hs b/test/Test/AWS/Gen/CloudWatchEvents.hs new file mode 100644 --- /dev/null +++ b/test/Test/AWS/Gen/CloudWatchEvents.hs @@ -0,0 +1,255 @@ +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-orphans #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Test.AWS.Gen.CloudWatchEvents +-- Copyright : (c) 2013-2016 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +module Test.AWS.Gen.CloudWatchEvents where + +import Data.Proxy +import Test.AWS.Fixture +import Test.AWS.Prelude +import Test.Tasty +import Network.AWS.CloudWatchEvents +import Test.AWS.CloudWatchEvents.Internal + +-- Auto-generated: the actual test selection needs to be manually placed into +-- the top-level so that real test data can be incrementally added. +-- +-- This commented snippet is what the entire set should look like: + +-- fixtures :: TestTree +-- fixtures = +-- [ testGroup "request" +-- [ testRemoveTargets $ +-- removeTargets +-- +-- , testDeleteRule $ +-- deleteRule +-- +-- , testListRules $ +-- listRules +-- +-- , testPutRule $ +-- putRule +-- +-- , testDisableRule $ +-- disableRule +-- +-- , testListTargetsByRule $ +-- listTargetsByRule +-- +-- , testDescribeRule $ +-- describeRule +-- +-- , testEnableRule $ +-- enableRule +-- +-- , testListRuleNamesByTarget $ +-- listRuleNamesByTarget +-- +-- , testTestEventPattern $ +-- testEventPattern +-- +-- , testPutTargets $ +-- putTargets +-- +-- , testPutEvents $ +-- putEvents +-- +-- ] + +-- , testGroup "response" +-- [ testRemoveTargetsResponse $ +-- removeTargetsResponse +-- +-- , testDeleteRuleResponse $ +-- deleteRuleResponse +-- +-- , testListRulesResponse $ +-- listRulesResponse +-- +-- , testPutRuleResponse $ +-- putRuleResponse +-- +-- , testDisableRuleResponse $ +-- disableRuleResponse +-- +-- , testListTargetsByRuleResponse $ +-- listTargetsByRuleResponse +-- +-- , testDescribeRuleResponse $ +-- describeRuleResponse +-- +-- , testEnableRuleResponse $ +-- enableRuleResponse +-- +-- , testListRuleNamesByTargetResponse $ +-- listRuleNamesByTargetResponse +-- +-- , testTestEventPatternResponse $ +-- testEventPatternResponse +-- +-- , testPutTargetsResponse $ +-- putTargetsResponse +-- +-- , testPutEventsResponse $ +-- putEventsResponse +-- +-- ] +-- ] + +-- Requests + +testRemoveTargets :: RemoveTargets -> TestTree +testRemoveTargets = req + "RemoveTargets" + "fixture/RemoveTargets.yaml" + +testDeleteRule :: DeleteRule -> TestTree +testDeleteRule = req + "DeleteRule" + "fixture/DeleteRule.yaml" + +testListRules :: ListRules -> TestTree +testListRules = req + "ListRules" + "fixture/ListRules.yaml" + +testPutRule :: PutRule -> TestTree +testPutRule = req + "PutRule" + "fixture/PutRule.yaml" + +testDisableRule :: DisableRule -> TestTree +testDisableRule = req + "DisableRule" + "fixture/DisableRule.yaml" + +testListTargetsByRule :: ListTargetsByRule -> TestTree +testListTargetsByRule = req + "ListTargetsByRule" + "fixture/ListTargetsByRule.yaml" + +testDescribeRule :: DescribeRule -> TestTree +testDescribeRule = req + "DescribeRule" + "fixture/DescribeRule.yaml" + +testEnableRule :: EnableRule -> TestTree +testEnableRule = req + "EnableRule" + "fixture/EnableRule.yaml" + +testListRuleNamesByTarget :: ListRuleNamesByTarget -> TestTree +testListRuleNamesByTarget = req + "ListRuleNamesByTarget" + "fixture/ListRuleNamesByTarget.yaml" + +testTestEventPattern :: TestEventPattern -> TestTree +testTestEventPattern = req + "TestEventPattern" + "fixture/TestEventPattern.yaml" + +testPutTargets :: PutTargets -> TestTree +testPutTargets = req + "PutTargets" + "fixture/PutTargets.yaml" + +testPutEvents :: PutEvents -> TestTree +testPutEvents = req + "PutEvents" + "fixture/PutEvents.yaml" + +-- Responses + +testRemoveTargetsResponse :: RemoveTargetsResponse -> TestTree +testRemoveTargetsResponse = res + "RemoveTargetsResponse" + "fixture/RemoveTargetsResponse.proto" + cloudWatchEvents + (Proxy :: Proxy RemoveTargets) + +testDeleteRuleResponse :: DeleteRuleResponse -> TestTree +testDeleteRuleResponse = res + "DeleteRuleResponse" + "fixture/DeleteRuleResponse.proto" + cloudWatchEvents + (Proxy :: Proxy DeleteRule) + +testListRulesResponse :: ListRulesResponse -> TestTree +testListRulesResponse = res + "ListRulesResponse" + "fixture/ListRulesResponse.proto" + cloudWatchEvents + (Proxy :: Proxy ListRules) + +testPutRuleResponse :: PutRuleResponse -> TestTree +testPutRuleResponse = res + "PutRuleResponse" + "fixture/PutRuleResponse.proto" + cloudWatchEvents + (Proxy :: Proxy PutRule) + +testDisableRuleResponse :: DisableRuleResponse -> TestTree +testDisableRuleResponse = res + "DisableRuleResponse" + "fixture/DisableRuleResponse.proto" + cloudWatchEvents + (Proxy :: Proxy DisableRule) + +testListTargetsByRuleResponse :: ListTargetsByRuleResponse -> TestTree +testListTargetsByRuleResponse = res + "ListTargetsByRuleResponse" + "fixture/ListTargetsByRuleResponse.proto" + cloudWatchEvents + (Proxy :: Proxy ListTargetsByRule) + +testDescribeRuleResponse :: DescribeRuleResponse -> TestTree +testDescribeRuleResponse = res + "DescribeRuleResponse" + "fixture/DescribeRuleResponse.proto" + cloudWatchEvents + (Proxy :: Proxy DescribeRule) + +testEnableRuleResponse :: EnableRuleResponse -> TestTree +testEnableRuleResponse = res + "EnableRuleResponse" + "fixture/EnableRuleResponse.proto" + cloudWatchEvents + (Proxy :: Proxy EnableRule) + +testListRuleNamesByTargetResponse :: ListRuleNamesByTargetResponse -> TestTree +testListRuleNamesByTargetResponse = res + "ListRuleNamesByTargetResponse" + "fixture/ListRuleNamesByTargetResponse.proto" + cloudWatchEvents + (Proxy :: Proxy ListRuleNamesByTarget) + +testTestEventPatternResponse :: TestEventPatternResponse -> TestTree +testTestEventPatternResponse = res + "TestEventPatternResponse" + "fixture/TestEventPatternResponse.proto" + cloudWatchEvents + (Proxy :: Proxy TestEventPattern) + +testPutTargetsResponse :: PutTargetsResponse -> TestTree +testPutTargetsResponse = res + "PutTargetsResponse" + "fixture/PutTargetsResponse.proto" + cloudWatchEvents + (Proxy :: Proxy PutTargets) + +testPutEventsResponse :: PutEventsResponse -> TestTree +testPutEventsResponse = res + "PutEventsResponse" + "fixture/PutEventsResponse.proto" + cloudWatchEvents + (Proxy :: Proxy PutEvents)