diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,373 @@ +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. + +Exhibit B - "Incompatible With Secondary Licenses" Notice +--------------------------------------------------------- + + This Source Code Form is "Incompatible With Secondary Licenses", as + defined by the Mozilla Public License, v. 2.0. diff --git a/README.md b/README.md new file mode 100644 --- /dev/null +++ b/README.md @@ -0,0 +1,26 @@ +# Amazon Elastic Load Balancing SDK + +> _Warning:_ This is an experimental preview release which is still under heavy development and not intended for public consumption, _caveat emptor_! + +* [description](#description) +* [Contribute](#contribute) +* [Licence](#licence) + +## Description + +Elastic Load Balancing automatically distributes incoming application traffic across multiple Amazon EC2 instances. It enables you to achieve greater levels of fault tolerance in your applications, seamlessly providing the required amount of load balancing capacity needed to distribute application traffic. + +Documentation is available via [Hackage](http://hackage.haskell.org/package/amazonka-elb) +and [AWS API Reference](http://docs.aws.amazon.com/ElasticLoadBalancing/latest/APIReference/Welcome.html). + + +## 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-elb` is released under the [Mozilla Public License Version 2.0](http://www.mozilla.org/MPL/). 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-elb.cabal b/amazonka-elb.cabal new file mode 100644 --- /dev/null +++ b/amazonka-elb.cabal @@ -0,0 +1,73 @@ +name: amazonka-elb +version: 0.0.0 +synopsis: Amazon Elastic Load Balancing SDK. +homepage: https://github.com/brendanhay/amazonka +license: OtherLicense +license-file: LICENSE +author: Brendan Hay +maintainer: Brendan Hay +copyright: Copyright (c) 2013-2014 Brendan Hay +category: Network, AWS, Cloud +build-type: Simple +extra-source-files: README.md +cabal-version: >= 1.10 + +description: + Elastic Load Balancing automatically distributes incoming application + traffic across multiple Amazon EC2 instances. It enables you to achieve + greater levels of fault tolerance in your applications, seamlessly + providing the required amount of load balancing capacity needed to + distribute application traffic. + . + /See:/ + . + /Warning:/ This is an experimental preview release which is still under + heavy development and not intended for public consumption, caveat emptor! + +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.ELB + , Network.AWS.ELB.AddTags + , Network.AWS.ELB.ApplySecurityGroupsToLoadBalancer + , Network.AWS.ELB.AttachLoadBalancerToSubnets + , Network.AWS.ELB.ConfigureHealthCheck + , Network.AWS.ELB.CreateAppCookieStickinessPolicy + , Network.AWS.ELB.CreateLBCookieStickinessPolicy + , Network.AWS.ELB.CreateLoadBalancer + , Network.AWS.ELB.CreateLoadBalancerListeners + , Network.AWS.ELB.CreateLoadBalancerPolicy + , Network.AWS.ELB.DeleteLoadBalancer + , Network.AWS.ELB.DeleteLoadBalancerListeners + , Network.AWS.ELB.DeleteLoadBalancerPolicy + , Network.AWS.ELB.DeregisterInstancesFromLoadBalancer + , Network.AWS.ELB.DescribeInstanceHealth + , Network.AWS.ELB.DescribeLoadBalancerAttributes + , Network.AWS.ELB.DescribeLoadBalancerPolicies + , Network.AWS.ELB.DescribeLoadBalancerPolicyTypes + , Network.AWS.ELB.DescribeLoadBalancers + , Network.AWS.ELB.DescribeTags + , Network.AWS.ELB.DetachLoadBalancerFromSubnets + , Network.AWS.ELB.DisableAvailabilityZonesForLoadBalancer + , Network.AWS.ELB.EnableAvailabilityZonesForLoadBalancer + , Network.AWS.ELB.ModifyLoadBalancerAttributes + , Network.AWS.ELB.RegisterInstancesWithLoadBalancer + , Network.AWS.ELB.RemoveTags + , Network.AWS.ELB.SetLoadBalancerListenerSSLCertificate + , Network.AWS.ELB.SetLoadBalancerPoliciesForBackendServer + , Network.AWS.ELB.SetLoadBalancerPoliciesOfListener + , Network.AWS.ELB.Types + + other-modules: + + build-depends: + amazonka-core + , base >= 4.7 && < 5 diff --git a/gen/Network/AWS/ELB.hs b/gen/Network/AWS/ELB.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB.hs @@ -0,0 +1,76 @@ +-- Module : Network.AWS.ELB +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Elastic Load Balancing automatically distributes incoming application +-- traffic across multiple Amazon EC2 instances. It enables you to achieve +-- greater levels of fault tolerance in your applications, seamlessly +-- providing the required amount of load balancing capacity needed to +-- distribute application traffic. +module Network.AWS.ELB + ( module Network.AWS.ELB.AddTags + , module Network.AWS.ELB.ApplySecurityGroupsToLoadBalancer + , module Network.AWS.ELB.AttachLoadBalancerToSubnets + , module Network.AWS.ELB.ConfigureHealthCheck + , module Network.AWS.ELB.CreateAppCookieStickinessPolicy + , module Network.AWS.ELB.CreateLBCookieStickinessPolicy + , module Network.AWS.ELB.CreateLoadBalancer + , module Network.AWS.ELB.CreateLoadBalancerListeners + , module Network.AWS.ELB.CreateLoadBalancerPolicy + , module Network.AWS.ELB.DeleteLoadBalancer + , module Network.AWS.ELB.DeleteLoadBalancerListeners + , module Network.AWS.ELB.DeleteLoadBalancerPolicy + , module Network.AWS.ELB.DeregisterInstancesFromLoadBalancer + , module Network.AWS.ELB.DescribeInstanceHealth + , module Network.AWS.ELB.DescribeLoadBalancerAttributes + , module Network.AWS.ELB.DescribeLoadBalancerPolicies + , module Network.AWS.ELB.DescribeLoadBalancerPolicyTypes + , module Network.AWS.ELB.DescribeLoadBalancers + , module Network.AWS.ELB.DescribeTags + , module Network.AWS.ELB.DetachLoadBalancerFromSubnets + , module Network.AWS.ELB.DisableAvailabilityZonesForLoadBalancer + , module Network.AWS.ELB.EnableAvailabilityZonesForLoadBalancer + , module Network.AWS.ELB.ModifyLoadBalancerAttributes + , module Network.AWS.ELB.RegisterInstancesWithLoadBalancer + , module Network.AWS.ELB.RemoveTags + , module Network.AWS.ELB.SetLoadBalancerListenerSSLCertificate + , module Network.AWS.ELB.SetLoadBalancerPoliciesForBackendServer + , module Network.AWS.ELB.SetLoadBalancerPoliciesOfListener + , module Network.AWS.ELB.Types + ) where + +import Network.AWS.ELB.AddTags +import Network.AWS.ELB.ApplySecurityGroupsToLoadBalancer +import Network.AWS.ELB.AttachLoadBalancerToSubnets +import Network.AWS.ELB.ConfigureHealthCheck +import Network.AWS.ELB.CreateAppCookieStickinessPolicy +import Network.AWS.ELB.CreateLBCookieStickinessPolicy +import Network.AWS.ELB.CreateLoadBalancer +import Network.AWS.ELB.CreateLoadBalancerListeners +import Network.AWS.ELB.CreateLoadBalancerPolicy +import Network.AWS.ELB.DeleteLoadBalancer +import Network.AWS.ELB.DeleteLoadBalancerListeners +import Network.AWS.ELB.DeleteLoadBalancerPolicy +import Network.AWS.ELB.DeregisterInstancesFromLoadBalancer +import Network.AWS.ELB.DescribeInstanceHealth +import Network.AWS.ELB.DescribeLoadBalancerAttributes +import Network.AWS.ELB.DescribeLoadBalancerPolicies +import Network.AWS.ELB.DescribeLoadBalancerPolicyTypes +import Network.AWS.ELB.DescribeLoadBalancers +import Network.AWS.ELB.DescribeTags +import Network.AWS.ELB.DetachLoadBalancerFromSubnets +import Network.AWS.ELB.DisableAvailabilityZonesForLoadBalancer +import Network.AWS.ELB.EnableAvailabilityZonesForLoadBalancer +import Network.AWS.ELB.ModifyLoadBalancerAttributes +import Network.AWS.ELB.RegisterInstancesWithLoadBalancer +import Network.AWS.ELB.RemoveTags +import Network.AWS.ELB.SetLoadBalancerListenerSSLCertificate +import Network.AWS.ELB.SetLoadBalancerPoliciesForBackendServer +import Network.AWS.ELB.SetLoadBalancerPoliciesOfListener +import Network.AWS.ELB.Types diff --git a/gen/Network/AWS/ELB/AddTags.hs b/gen/Network/AWS/ELB/AddTags.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/AddTags.hs @@ -0,0 +1,106 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.AddTags +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Adds one or more tags for the specified load balancer. Each load balancer +-- can have a maximum of 10 tags. Each tag consists of a key and an optional +-- value. Tag keys must be unique for each load balancer. If a tag with the +-- same key is already associated with the load balancer, this action will +-- update the value of the key. For more information, see Tagging in the +-- Elastic Load Balancing Developer Guide. +-- +-- +module Network.AWS.ELB.AddTags + ( + -- * Request + AddTags + -- ** Request constructor + , addTags + -- ** Request lenses + , atLoadBalancerNames + , atTags + + -- * Response + , AddTagsResponse + -- ** Response constructor + , addTagsResponse + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data AddTags = AddTags + { _atLoadBalancerNames :: List "LoadBalancerNames" Text + , _atTags :: List1 "Tags" Tag + } deriving (Eq, Show) + +-- | 'AddTags' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'atLoadBalancerNames' @::@ ['Text'] +-- +-- * 'atTags' @::@ 'NonEmpty' 'Tag' +-- +addTags :: NonEmpty Tag -- ^ 'atTags' + -> AddTags +addTags p1 = AddTags + { _atTags = withIso _List1 (const id) p1 + , _atLoadBalancerNames = mempty + } + +-- | The name of the load balancer to tag. You can specify a maximum of one +-- load balancer name. +atLoadBalancerNames :: Lens' AddTags [Text] +atLoadBalancerNames = + lens _atLoadBalancerNames (\s a -> s { _atLoadBalancerNames = a }) + . _List + +-- | A list of tags for each load balancer. +atTags :: Lens' AddTags (NonEmpty Tag) +atTags = lens _atTags (\s a -> s { _atTags = a }) . _List1 + +data AddTagsResponse = AddTagsResponse + deriving (Eq, Ord, Show, Generic) + +-- | 'AddTagsResponse' constructor. +addTagsResponse :: AddTagsResponse +addTagsResponse = AddTagsResponse + +instance ToPath AddTags where + toPath = const "/" + +instance ToQuery AddTags where + toQuery AddTags{..} = mconcat + [ "LoadBalancerNames" =? _atLoadBalancerNames + , "Tags" =? _atTags + ] + +instance ToHeaders AddTags + +instance AWSRequest AddTags where + type Sv AddTags = ELB + type Rs AddTags = AddTagsResponse + + request = post "AddTags" + response = nullResponse AddTagsResponse diff --git a/gen/Network/AWS/ELB/ApplySecurityGroupsToLoadBalancer.hs b/gen/Network/AWS/ELB/ApplySecurityGroupsToLoadBalancer.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/ApplySecurityGroupsToLoadBalancer.hs @@ -0,0 +1,134 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.ApplySecurityGroupsToLoadBalancer +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Associates one or more security groups with your load balancer in Amazon +-- Virtual Private Cloud (Amazon VPC). The provided security group IDs will +-- override any currently applied security groups. For more information, see +-- Manage Security Groups in Amazon VPC in the Elastic Load Balancing +-- Developer Guide. +-- +-- +module Network.AWS.ELB.ApplySecurityGroupsToLoadBalancer + ( + -- * Request + ApplySecurityGroupsToLoadBalancer + -- ** Request constructor + , applySecurityGroupsToLoadBalancer + -- ** Request lenses + , asgtlbLoadBalancerName + , asgtlbSecurityGroups + + -- * Response + , ApplySecurityGroupsToLoadBalancerResponse + -- ** Response constructor + , applySecurityGroupsToLoadBalancerResponse + -- ** Response lenses + , asgtlbrSecurityGroups + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data ApplySecurityGroupsToLoadBalancer = ApplySecurityGroupsToLoadBalancer + { _asgtlbLoadBalancerName :: Text + , _asgtlbSecurityGroups :: List "SecurityGroups" Text + } deriving (Eq, Ord, Show) + +-- | 'ApplySecurityGroupsToLoadBalancer' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'asgtlbLoadBalancerName' @::@ 'Text' +-- +-- * 'asgtlbSecurityGroups' @::@ ['Text'] +-- +applySecurityGroupsToLoadBalancer :: Text -- ^ 'asgtlbLoadBalancerName' + -> ApplySecurityGroupsToLoadBalancer +applySecurityGroupsToLoadBalancer p1 = ApplySecurityGroupsToLoadBalancer + { _asgtlbLoadBalancerName = p1 + , _asgtlbSecurityGroups = mempty + } + +-- | The name associated with the load balancer. The name must be unique +-- within the set of load balancers associated with your AWS account. +asgtlbLoadBalancerName :: Lens' ApplySecurityGroupsToLoadBalancer Text +asgtlbLoadBalancerName = + lens _asgtlbLoadBalancerName (\s a -> s { _asgtlbLoadBalancerName = a }) + +-- | A list of security group IDs to associate with your load balancer in VPC. +-- The security group IDs must be provided as the ID and not the security +-- group name (For example, sg-1234). +asgtlbSecurityGroups :: Lens' ApplySecurityGroupsToLoadBalancer [Text] +asgtlbSecurityGroups = + lens _asgtlbSecurityGroups (\s a -> s { _asgtlbSecurityGroups = a }) + . _List + +newtype ApplySecurityGroupsToLoadBalancerResponse = ApplySecurityGroupsToLoadBalancerResponse + { _asgtlbrSecurityGroups :: List "SecurityGroups" Text + } deriving (Eq, Ord, Show, Monoid, Semigroup) + +instance GHC.Exts.IsList ApplySecurityGroupsToLoadBalancerResponse where + type Item ApplySecurityGroupsToLoadBalancerResponse = Text + + fromList = ApplySecurityGroupsToLoadBalancerResponse . GHC.Exts.fromList + toList = GHC.Exts.toList . _asgtlbrSecurityGroups + +-- | 'ApplySecurityGroupsToLoadBalancerResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'asgtlbrSecurityGroups' @::@ ['Text'] +-- +applySecurityGroupsToLoadBalancerResponse :: ApplySecurityGroupsToLoadBalancerResponse +applySecurityGroupsToLoadBalancerResponse = ApplySecurityGroupsToLoadBalancerResponse + { _asgtlbrSecurityGroups = mempty + } + +-- | A list of security group IDs associated with your load balancer. +asgtlbrSecurityGroups :: Lens' ApplySecurityGroupsToLoadBalancerResponse [Text] +asgtlbrSecurityGroups = + lens _asgtlbrSecurityGroups (\s a -> s { _asgtlbrSecurityGroups = a }) + . _List + +instance ToPath ApplySecurityGroupsToLoadBalancer where + toPath = const "/" + +instance ToQuery ApplySecurityGroupsToLoadBalancer where + toQuery ApplySecurityGroupsToLoadBalancer{..} = mconcat + [ "LoadBalancerName" =? _asgtlbLoadBalancerName + , "SecurityGroups" =? _asgtlbSecurityGroups + ] + +instance ToHeaders ApplySecurityGroupsToLoadBalancer + +instance AWSRequest ApplySecurityGroupsToLoadBalancer where + type Sv ApplySecurityGroupsToLoadBalancer = ELB + type Rs ApplySecurityGroupsToLoadBalancer = ApplySecurityGroupsToLoadBalancerResponse + + request = post "ApplySecurityGroupsToLoadBalancer" + response = xmlResponse + +instance FromXML ApplySecurityGroupsToLoadBalancerResponse where + parseXML = withElement "ApplySecurityGroupsToLoadBalancerResult" $ \x -> ApplySecurityGroupsToLoadBalancerResponse + <$> x .@ "SecurityGroups" diff --git a/gen/Network/AWS/ELB/AttachLoadBalancerToSubnets.hs b/gen/Network/AWS/ELB/AttachLoadBalancerToSubnets.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/AttachLoadBalancerToSubnets.hs @@ -0,0 +1,129 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.AttachLoadBalancerToSubnets +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Adds one or more subnets to the set of configured subnets in the Amazon +-- Virtual Private Cloud (Amazon VPC) for the load balancer. The load +-- balancers evenly distribute requests across all of the registered subnets. +-- For more information, see Deploy Elastic Load Balancing in Amazon VPC in +-- the Elastic Load Balancing Developer Guide. +-- +-- +module Network.AWS.ELB.AttachLoadBalancerToSubnets + ( + -- * Request + AttachLoadBalancerToSubnets + -- ** Request constructor + , attachLoadBalancerToSubnets + -- ** Request lenses + , albtsLoadBalancerName + , albtsSubnets + + -- * Response + , AttachLoadBalancerToSubnetsResponse + -- ** Response constructor + , attachLoadBalancerToSubnetsResponse + -- ** Response lenses + , albtsrSubnets + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data AttachLoadBalancerToSubnets = AttachLoadBalancerToSubnets + { _albtsLoadBalancerName :: Text + , _albtsSubnets :: List "Subnets" Text + } deriving (Eq, Ord, Show) + +-- | 'AttachLoadBalancerToSubnets' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'albtsLoadBalancerName' @::@ 'Text' +-- +-- * 'albtsSubnets' @::@ ['Text'] +-- +attachLoadBalancerToSubnets :: Text -- ^ 'albtsLoadBalancerName' + -> AttachLoadBalancerToSubnets +attachLoadBalancerToSubnets p1 = AttachLoadBalancerToSubnets + { _albtsLoadBalancerName = p1 + , _albtsSubnets = mempty + } + +-- | The name associated with the load balancer. The name must be unique +-- within the set of load balancers associated with your AWS account. +albtsLoadBalancerName :: Lens' AttachLoadBalancerToSubnets Text +albtsLoadBalancerName = + lens _albtsLoadBalancerName (\s a -> s { _albtsLoadBalancerName = a }) + +-- | A list of subnet IDs to add for the load balancer. You can add only one +-- subnet per Availability Zone. +albtsSubnets :: Lens' AttachLoadBalancerToSubnets [Text] +albtsSubnets = lens _albtsSubnets (\s a -> s { _albtsSubnets = a }) . _List + +newtype AttachLoadBalancerToSubnetsResponse = AttachLoadBalancerToSubnetsResponse + { _albtsrSubnets :: List "Subnets" Text + } deriving (Eq, Ord, Show, Monoid, Semigroup) + +instance GHC.Exts.IsList AttachLoadBalancerToSubnetsResponse where + type Item AttachLoadBalancerToSubnetsResponse = Text + + fromList = AttachLoadBalancerToSubnetsResponse . GHC.Exts.fromList + toList = GHC.Exts.toList . _albtsrSubnets + +-- | 'AttachLoadBalancerToSubnetsResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'albtsrSubnets' @::@ ['Text'] +-- +attachLoadBalancerToSubnetsResponse :: AttachLoadBalancerToSubnetsResponse +attachLoadBalancerToSubnetsResponse = AttachLoadBalancerToSubnetsResponse + { _albtsrSubnets = mempty + } + +-- | A list of subnet IDs attached to the load balancer. +albtsrSubnets :: Lens' AttachLoadBalancerToSubnetsResponse [Text] +albtsrSubnets = lens _albtsrSubnets (\s a -> s { _albtsrSubnets = a }) . _List + +instance ToPath AttachLoadBalancerToSubnets where + toPath = const "/" + +instance ToQuery AttachLoadBalancerToSubnets where + toQuery AttachLoadBalancerToSubnets{..} = mconcat + [ "LoadBalancerName" =? _albtsLoadBalancerName + , "Subnets" =? _albtsSubnets + ] + +instance ToHeaders AttachLoadBalancerToSubnets + +instance AWSRequest AttachLoadBalancerToSubnets where + type Sv AttachLoadBalancerToSubnets = ELB + type Rs AttachLoadBalancerToSubnets = AttachLoadBalancerToSubnetsResponse + + request = post "AttachLoadBalancerToSubnets" + response = xmlResponse + +instance FromXML AttachLoadBalancerToSubnetsResponse where + parseXML = withElement "AttachLoadBalancerToSubnetsResult" $ \x -> AttachLoadBalancerToSubnetsResponse + <$> x .@ "Subnets" diff --git a/gen/Network/AWS/ELB/ConfigureHealthCheck.hs b/gen/Network/AWS/ELB/ConfigureHealthCheck.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/ConfigureHealthCheck.hs @@ -0,0 +1,122 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.ConfigureHealthCheck +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Specifies the health check settings to use for evaluating the health state +-- of your back-end instances. For more information, see Health Check in the +-- Elastic Load Balancing Developer Guide. +-- +-- +module Network.AWS.ELB.ConfigureHealthCheck + ( + -- * Request + ConfigureHealthCheck + -- ** Request constructor + , configureHealthCheck + -- ** Request lenses + , chcHealthCheck + , chcLoadBalancerName + + -- * Response + , ConfigureHealthCheckResponse + -- ** Response constructor + , configureHealthCheckResponse + -- ** Response lenses + , chcrHealthCheck + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data ConfigureHealthCheck = ConfigureHealthCheck + { _chcHealthCheck :: HealthCheck + , _chcLoadBalancerName :: Text + } deriving (Eq, Show) + +-- | 'ConfigureHealthCheck' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'chcHealthCheck' @::@ 'HealthCheck' +-- +-- * 'chcLoadBalancerName' @::@ 'Text' +-- +configureHealthCheck :: Text -- ^ 'chcLoadBalancerName' + -> HealthCheck -- ^ 'chcHealthCheck' + -> ConfigureHealthCheck +configureHealthCheck p1 p2 = ConfigureHealthCheck + { _chcLoadBalancerName = p1 + , _chcHealthCheck = p2 + } + +-- | A structure containing the configuration information for the new +-- healthcheck. +chcHealthCheck :: Lens' ConfigureHealthCheck HealthCheck +chcHealthCheck = lens _chcHealthCheck (\s a -> s { _chcHealthCheck = a }) + +-- | The mnemonic name associated with the load balancer. The name must be +-- unique within the set of load balancers associated with your AWS account. +chcLoadBalancerName :: Lens' ConfigureHealthCheck Text +chcLoadBalancerName = + lens _chcLoadBalancerName (\s a -> s { _chcLoadBalancerName = a }) + +newtype ConfigureHealthCheckResponse = ConfigureHealthCheckResponse + { _chcrHealthCheck :: Maybe HealthCheck + } deriving (Eq, Show) + +-- | 'ConfigureHealthCheckResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'chcrHealthCheck' @::@ 'Maybe' 'HealthCheck' +-- +configureHealthCheckResponse :: ConfigureHealthCheckResponse +configureHealthCheckResponse = ConfigureHealthCheckResponse + { _chcrHealthCheck = Nothing + } + +-- | The updated healthcheck for the instances. +chcrHealthCheck :: Lens' ConfigureHealthCheckResponse (Maybe HealthCheck) +chcrHealthCheck = lens _chcrHealthCheck (\s a -> s { _chcrHealthCheck = a }) + +instance ToPath ConfigureHealthCheck where + toPath = const "/" + +instance ToQuery ConfigureHealthCheck where + toQuery ConfigureHealthCheck{..} = mconcat + [ "HealthCheck" =? _chcHealthCheck + , "LoadBalancerName" =? _chcLoadBalancerName + ] + +instance ToHeaders ConfigureHealthCheck + +instance AWSRequest ConfigureHealthCheck where + type Sv ConfigureHealthCheck = ELB + type Rs ConfigureHealthCheck = ConfigureHealthCheckResponse + + request = post "ConfigureHealthCheck" + response = xmlResponse + +instance FromXML ConfigureHealthCheckResponse where + parseXML = withElement "ConfigureHealthCheckResult" $ \x -> ConfigureHealthCheckResponse + <$> x .@? "HealthCheck" diff --git a/gen/Network/AWS/ELB/CreateAppCookieStickinessPolicy.hs b/gen/Network/AWS/ELB/CreateAppCookieStickinessPolicy.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/CreateAppCookieStickinessPolicy.hs @@ -0,0 +1,125 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.CreateAppCookieStickinessPolicy +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Generates a stickiness policy with sticky session lifetimes that follow +-- that of an application-generated cookie. This policy can be associated only +-- with HTTP/HTTPS listeners. This policy is similar to the policy created by +-- CreateLBCookieStickinessPolicy, except that the lifetime of the special +-- Elastic Load Balancing cookie follows the lifetime of the +-- application-generated cookie specified in the policy configuration. The +-- load balancer only inserts a new stickiness cookie when the application +-- response includes a new application cookie. If the application cookie is +-- explicitly removed or expires, the session stops being sticky until a new +-- application cookie is issued. An application client must receive and send +-- two cookies: the application-generated cookie and the special Elastic Load +-- Balancing cookie named AWSELB. This is the default behavior for many common +-- web browsers. For more information, see Enabling Application-Controlled +-- Session Stickiness in the Elastic Load Balancing Developer Guide. +-- +-- +module Network.AWS.ELB.CreateAppCookieStickinessPolicy + ( + -- * Request + CreateAppCookieStickinessPolicy + -- ** Request constructor + , createAppCookieStickinessPolicy + -- ** Request lenses + , cacspCookieName + , cacspLoadBalancerName + , cacspPolicyName + + -- * Response + , CreateAppCookieStickinessPolicyResponse + -- ** Response constructor + , createAppCookieStickinessPolicyResponse + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data CreateAppCookieStickinessPolicy = CreateAppCookieStickinessPolicy + { _cacspCookieName :: Text + , _cacspLoadBalancerName :: Text + , _cacspPolicyName :: Text + } deriving (Eq, Ord, Show) + +-- | 'CreateAppCookieStickinessPolicy' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'cacspCookieName' @::@ 'Text' +-- +-- * 'cacspLoadBalancerName' @::@ 'Text' +-- +-- * 'cacspPolicyName' @::@ 'Text' +-- +createAppCookieStickinessPolicy :: Text -- ^ 'cacspLoadBalancerName' + -> Text -- ^ 'cacspPolicyName' + -> Text -- ^ 'cacspCookieName' + -> CreateAppCookieStickinessPolicy +createAppCookieStickinessPolicy p1 p2 p3 = CreateAppCookieStickinessPolicy + { _cacspLoadBalancerName = p1 + , _cacspPolicyName = p2 + , _cacspCookieName = p3 + } + +-- | Name of the application cookie used for stickiness. +cacspCookieName :: Lens' CreateAppCookieStickinessPolicy Text +cacspCookieName = lens _cacspCookieName (\s a -> s { _cacspCookieName = a }) + +-- | The name of the load balancer. +cacspLoadBalancerName :: Lens' CreateAppCookieStickinessPolicy Text +cacspLoadBalancerName = + lens _cacspLoadBalancerName (\s a -> s { _cacspLoadBalancerName = a }) + +-- | The name of the policy being created. The name must be unique within the +-- set of policies for this load balancer. +cacspPolicyName :: Lens' CreateAppCookieStickinessPolicy Text +cacspPolicyName = lens _cacspPolicyName (\s a -> s { _cacspPolicyName = a }) + +data CreateAppCookieStickinessPolicyResponse = CreateAppCookieStickinessPolicyResponse + deriving (Eq, Ord, Show, Generic) + +-- | 'CreateAppCookieStickinessPolicyResponse' constructor. +createAppCookieStickinessPolicyResponse :: CreateAppCookieStickinessPolicyResponse +createAppCookieStickinessPolicyResponse = CreateAppCookieStickinessPolicyResponse + +instance ToPath CreateAppCookieStickinessPolicy where + toPath = const "/" + +instance ToQuery CreateAppCookieStickinessPolicy where + toQuery CreateAppCookieStickinessPolicy{..} = mconcat + [ "CookieName" =? _cacspCookieName + , "LoadBalancerName" =? _cacspLoadBalancerName + , "PolicyName" =? _cacspPolicyName + ] + +instance ToHeaders CreateAppCookieStickinessPolicy + +instance AWSRequest CreateAppCookieStickinessPolicy where + type Sv CreateAppCookieStickinessPolicy = ELB + type Rs CreateAppCookieStickinessPolicy = CreateAppCookieStickinessPolicyResponse + + request = post "CreateAppCookieStickinessPolicy" + response = nullResponse CreateAppCookieStickinessPolicyResponse diff --git a/gen/Network/AWS/ELB/CreateLBCookieStickinessPolicy.hs b/gen/Network/AWS/ELB/CreateLBCookieStickinessPolicy.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/CreateLBCookieStickinessPolicy.hs @@ -0,0 +1,128 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.CreateLBCookieStickinessPolicy +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Generates a stickiness policy with sticky session lifetimes controlled by +-- the lifetime of the browser (user-agent) or a specified expiration period. +-- This policy can be associated only with HTTP/HTTPS listeners. When a load +-- balancer implements this policy, the load balancer uses a special cookie to +-- track the backend server instance for each request. When the load balancer +-- receives a request, it first checks to see if this cookie is present in the +-- request. If so, the load balancer sends the request to the application +-- server specified in the cookie. If not, the load balancer sends the request +-- to a server that is chosen based on the existing load balancing algorithm. +-- A cookie is inserted into the response for binding subsequent requests from +-- the same user to that server. The validity of the cookie is based on the +-- cookie expiration time, which is specified in the policy configuration. For +-- more information, see Enabling Duration-Based Session Stickiness in the +-- Elastic Load Balancing Developer Guide. +-- +-- +module Network.AWS.ELB.CreateLBCookieStickinessPolicy + ( + -- * Request + CreateLBCookieStickinessPolicy + -- ** Request constructor + , createLBCookieStickinessPolicy + -- ** Request lenses + , clbcspCookieExpirationPeriod + , clbcspLoadBalancerName + , clbcspPolicyName + + -- * Response + , CreateLBCookieStickinessPolicyResponse + -- ** Response constructor + , createLBCookieStickinessPolicyResponse + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data CreateLBCookieStickinessPolicy = CreateLBCookieStickinessPolicy + { _clbcspCookieExpirationPeriod :: Maybe Integer + , _clbcspLoadBalancerName :: Text + , _clbcspPolicyName :: Text + } deriving (Eq, Ord, Show) + +-- | 'CreateLBCookieStickinessPolicy' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'clbcspCookieExpirationPeriod' @::@ 'Maybe' 'Integer' +-- +-- * 'clbcspLoadBalancerName' @::@ 'Text' +-- +-- * 'clbcspPolicyName' @::@ 'Text' +-- +createLBCookieStickinessPolicy :: Text -- ^ 'clbcspLoadBalancerName' + -> Text -- ^ 'clbcspPolicyName' + -> CreateLBCookieStickinessPolicy +createLBCookieStickinessPolicy p1 p2 = CreateLBCookieStickinessPolicy + { _clbcspLoadBalancerName = p1 + , _clbcspPolicyName = p2 + , _clbcspCookieExpirationPeriod = Nothing + } + +-- | The time period in seconds after which the cookie should be considered +-- stale. Not specifying this parameter indicates that the sticky session +-- will last for the duration of the browser session. +clbcspCookieExpirationPeriod :: Lens' CreateLBCookieStickinessPolicy (Maybe Integer) +clbcspCookieExpirationPeriod = + lens _clbcspCookieExpirationPeriod + (\s a -> s { _clbcspCookieExpirationPeriod = a }) + +-- | The name associated with the load balancer. +clbcspLoadBalancerName :: Lens' CreateLBCookieStickinessPolicy Text +clbcspLoadBalancerName = + lens _clbcspLoadBalancerName (\s a -> s { _clbcspLoadBalancerName = a }) + +-- | The name of the policy being created. The name must be unique within the +-- set of policies for this load balancer. +clbcspPolicyName :: Lens' CreateLBCookieStickinessPolicy Text +clbcspPolicyName = lens _clbcspPolicyName (\s a -> s { _clbcspPolicyName = a }) + +data CreateLBCookieStickinessPolicyResponse = CreateLBCookieStickinessPolicyResponse + deriving (Eq, Ord, Show, Generic) + +-- | 'CreateLBCookieStickinessPolicyResponse' constructor. +createLBCookieStickinessPolicyResponse :: CreateLBCookieStickinessPolicyResponse +createLBCookieStickinessPolicyResponse = CreateLBCookieStickinessPolicyResponse + +instance ToPath CreateLBCookieStickinessPolicy where + toPath = const "/" + +instance ToQuery CreateLBCookieStickinessPolicy where + toQuery CreateLBCookieStickinessPolicy{..} = mconcat + [ "CookieExpirationPeriod" =? _clbcspCookieExpirationPeriod + , "LoadBalancerName" =? _clbcspLoadBalancerName + , "PolicyName" =? _clbcspPolicyName + ] + +instance ToHeaders CreateLBCookieStickinessPolicy + +instance AWSRequest CreateLBCookieStickinessPolicy where + type Sv CreateLBCookieStickinessPolicy = ELB + type Rs CreateLBCookieStickinessPolicy = CreateLBCookieStickinessPolicyResponse + + request = post "CreateLBCookieStickinessPolicy" + response = nullResponse CreateLBCookieStickinessPolicyResponse diff --git a/gen/Network/AWS/ELB/CreateLoadBalancer.hs b/gen/Network/AWS/ELB/CreateLoadBalancer.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/CreateLoadBalancer.hs @@ -0,0 +1,202 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.CreateLoadBalancer +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Creates a new load balancer. After the call has completed successfully, a +-- new load balancer is created with a unique Domain Name Service (DNS) name. +-- The DNS name includes the name of the AWS region in which the load balance +-- was created. For example, if your load balancer was created in the United +-- States, the DNS name might end with either of the following: +-- us-east-1.elb.amazonaws.com (for the Northern Virginia region) +-- us-west-1.elb.amazonaws.com (for the Northern California region) For +-- information about the AWS regions supported by Elastic Load Balancing, see +-- Regions and Endpoints. You can create up to 20 load balancers per region +-- per account. Elastic Load Balancing supports load balancing your Amazon EC2 +-- instances launched within any one of the following platforms: EC2-Classic +-- For information on creating and managing your load balancers in +-- EC2-Classic, see Deploy Elastic Load Balancing in Amazon EC2-Classic. +-- EC2-VPC For information on creating and managing your load balancers in +-- EC2-VPC, see Deploy Elastic Load Balancing in Amazon VPC. +-- +-- +module Network.AWS.ELB.CreateLoadBalancer + ( + -- * Request + CreateLoadBalancer + -- ** Request constructor + , createLoadBalancer + -- ** Request lenses + , clbAvailabilityZones + , clbListeners + , clbLoadBalancerName + , clbScheme + , clbSecurityGroups + , clbSubnets + , clbTags + + -- * Response + , CreateLoadBalancerResponse + -- ** Response constructor + , createLoadBalancerResponse + -- ** Response lenses + , clbrDNSName + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data CreateLoadBalancer = CreateLoadBalancer + { _clbAvailabilityZones :: List "AvailabilityZones" Text + , _clbListeners :: List "Listeners" Listener + , _clbLoadBalancerName :: Text + , _clbScheme :: Maybe Text + , _clbSecurityGroups :: List "SecurityGroups" Text + , _clbSubnets :: List "Subnets" Text + , _clbTags :: List1 "Tags" Tag + } deriving (Eq, Show) + +-- | 'CreateLoadBalancer' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'clbAvailabilityZones' @::@ ['Text'] +-- +-- * 'clbListeners' @::@ ['Listener'] +-- +-- * 'clbLoadBalancerName' @::@ 'Text' +-- +-- * 'clbScheme' @::@ 'Maybe' 'Text' +-- +-- * 'clbSecurityGroups' @::@ ['Text'] +-- +-- * 'clbSubnets' @::@ ['Text'] +-- +-- * 'clbTags' @::@ 'NonEmpty' 'Tag' +-- +createLoadBalancer :: Text -- ^ 'clbLoadBalancerName' + -> NonEmpty Tag -- ^ 'clbTags' + -> CreateLoadBalancer +createLoadBalancer p1 p2 = CreateLoadBalancer + { _clbLoadBalancerName = p1 + , _clbTags = withIso _List1 (const id) p2 + , _clbListeners = mempty + , _clbAvailabilityZones = mempty + , _clbSubnets = mempty + , _clbSecurityGroups = mempty + , _clbScheme = Nothing + } + +-- | A list of Availability Zones. At least one Availability Zone must be +-- specified. Specified Availability Zones must be in the same EC2 Region as +-- the load balancer. Traffic will be equally distributed across all zones. +-- You can later add more Availability Zones after the creation of the load +-- balancer by calling EnableAvailabilityZonesForLoadBalancer action. +clbAvailabilityZones :: Lens' CreateLoadBalancer [Text] +clbAvailabilityZones = + lens _clbAvailabilityZones (\s a -> s { _clbAvailabilityZones = a }) + . _List + +-- | A list of the following tuples: Protocol, LoadBalancerPort, +-- InstanceProtocol, InstancePort, and SSLCertificateId. +clbListeners :: Lens' CreateLoadBalancer [Listener] +clbListeners = lens _clbListeners (\s a -> s { _clbListeners = a }) . _List + +-- | The name associated with the load balancer. The name must be unique +-- within your set of load balancers, must have a maximum of 32 characters, +-- and must only contain alphanumeric characters or hyphens. +clbLoadBalancerName :: Lens' CreateLoadBalancer Text +clbLoadBalancerName = + lens _clbLoadBalancerName (\s a -> s { _clbLoadBalancerName = a }) + +-- | The type of a load balancer. By default, Elastic Load Balancing creates +-- an Internet-facing load balancer with a publicly resolvable DNS name, +-- which resolves to public IP addresses. For more information about +-- Internet-facing and Internal load balancers, see Internet-facing and +-- Internal Load Balancers. Specify the value internal for this option to +-- create an internal load balancer with a DNS name that resolves to private +-- IP addresses. This option is only available for load balancers created +-- within EC2-VPC. +clbScheme :: Lens' CreateLoadBalancer (Maybe Text) +clbScheme = lens _clbScheme (\s a -> s { _clbScheme = a }) + +-- | The security groups to assign to your load balancer within your VPC. +clbSecurityGroups :: Lens' CreateLoadBalancer [Text] +clbSecurityGroups = + lens _clbSecurityGroups (\s a -> s { _clbSecurityGroups = a }) + . _List + +-- | A list of subnet IDs in your VPC to attach to your load balancer. Specify +-- one subnet per Availability Zone. +clbSubnets :: Lens' CreateLoadBalancer [Text] +clbSubnets = lens _clbSubnets (\s a -> s { _clbSubnets = a }) . _List + +-- | A list of tags to assign to the load balancer. For more information about +-- setting tags for your load balancer, see Tagging. +clbTags :: Lens' CreateLoadBalancer (NonEmpty Tag) +clbTags = lens _clbTags (\s a -> s { _clbTags = a }) . _List1 + +newtype CreateLoadBalancerResponse = CreateLoadBalancerResponse + { _clbrDNSName :: Maybe Text + } deriving (Eq, Ord, Show, Monoid) + +-- | 'CreateLoadBalancerResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'clbrDNSName' @::@ 'Maybe' 'Text' +-- +createLoadBalancerResponse :: CreateLoadBalancerResponse +createLoadBalancerResponse = CreateLoadBalancerResponse + { _clbrDNSName = Nothing + } + +-- | The DNS name for the load balancer. +clbrDNSName :: Lens' CreateLoadBalancerResponse (Maybe Text) +clbrDNSName = lens _clbrDNSName (\s a -> s { _clbrDNSName = a }) + +instance ToPath CreateLoadBalancer where + toPath = const "/" + +instance ToQuery CreateLoadBalancer where + toQuery CreateLoadBalancer{..} = mconcat + [ "AvailabilityZones" =? _clbAvailabilityZones + , "Listeners" =? _clbListeners + , "LoadBalancerName" =? _clbLoadBalancerName + , "Scheme" =? _clbScheme + , "SecurityGroups" =? _clbSecurityGroups + , "Subnets" =? _clbSubnets + , "Tags" =? _clbTags + ] + +instance ToHeaders CreateLoadBalancer + +instance AWSRequest CreateLoadBalancer where + type Sv CreateLoadBalancer = ELB + type Rs CreateLoadBalancer = CreateLoadBalancerResponse + + request = post "CreateLoadBalancer" + response = xmlResponse + +instance FromXML CreateLoadBalancerResponse where + parseXML = withElement "CreateLoadBalancerResult" $ \x -> CreateLoadBalancerResponse + <$> x .@? "DNSName" diff --git a/gen/Network/AWS/ELB/CreateLoadBalancerListeners.hs b/gen/Network/AWS/ELB/CreateLoadBalancerListeners.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/CreateLoadBalancerListeners.hs @@ -0,0 +1,104 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.CreateLoadBalancerListeners +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Creates one or more listeners on a load balancer for the specified port. If +-- a listener with the given port does not already exist, it will be created; +-- otherwise, the properties of the new listener must match the properties of +-- the existing listener. For more information, see Add a Listener to Your +-- Load Balancer in the Elastic Load Balancing Developer Guide. +-- +-- +module Network.AWS.ELB.CreateLoadBalancerListeners + ( + -- * Request + CreateLoadBalancerListeners + -- ** Request constructor + , createLoadBalancerListeners + -- ** Request lenses + , clblListeners + , clblLoadBalancerName + + -- * Response + , CreateLoadBalancerListenersResponse + -- ** Response constructor + , createLoadBalancerListenersResponse + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data CreateLoadBalancerListeners = CreateLoadBalancerListeners + { _clblListeners :: List "Listeners" Listener + , _clblLoadBalancerName :: Text + } deriving (Eq, Show) + +-- | 'CreateLoadBalancerListeners' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'clblListeners' @::@ ['Listener'] +-- +-- * 'clblLoadBalancerName' @::@ 'Text' +-- +createLoadBalancerListeners :: Text -- ^ 'clblLoadBalancerName' + -> CreateLoadBalancerListeners +createLoadBalancerListeners p1 = CreateLoadBalancerListeners + { _clblLoadBalancerName = p1 + , _clblListeners = mempty + } + +-- | A list of LoadBalancerPort, InstancePort, Protocol, InstanceProtocol, and +-- SSLCertificateId items. +clblListeners :: Lens' CreateLoadBalancerListeners [Listener] +clblListeners = lens _clblListeners (\s a -> s { _clblListeners = a }) . _List + +-- | The name of the load balancer. +clblLoadBalancerName :: Lens' CreateLoadBalancerListeners Text +clblLoadBalancerName = + lens _clblLoadBalancerName (\s a -> s { _clblLoadBalancerName = a }) + +data CreateLoadBalancerListenersResponse = CreateLoadBalancerListenersResponse + deriving (Eq, Ord, Show, Generic) + +-- | 'CreateLoadBalancerListenersResponse' constructor. +createLoadBalancerListenersResponse :: CreateLoadBalancerListenersResponse +createLoadBalancerListenersResponse = CreateLoadBalancerListenersResponse + +instance ToPath CreateLoadBalancerListeners where + toPath = const "/" + +instance ToQuery CreateLoadBalancerListeners where + toQuery CreateLoadBalancerListeners{..} = mconcat + [ "Listeners" =? _clblListeners + , "LoadBalancerName" =? _clblLoadBalancerName + ] + +instance ToHeaders CreateLoadBalancerListeners + +instance AWSRequest CreateLoadBalancerListeners where + type Sv CreateLoadBalancerListeners = ELB + type Rs CreateLoadBalancerListeners = CreateLoadBalancerListenersResponse + + request = post "CreateLoadBalancerListeners" + response = nullResponse CreateLoadBalancerListenersResponse diff --git a/gen/Network/AWS/ELB/CreateLoadBalancerPolicy.hs b/gen/Network/AWS/ELB/CreateLoadBalancerPolicy.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/CreateLoadBalancerPolicy.hs @@ -0,0 +1,130 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.CreateLoadBalancerPolicy +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Creates a new policy that contains the necessary attributes depending on +-- the policy type. Policies are settings that are saved for your load +-- balancer and that can be applied to the front-end listener, or the back-end +-- application server, depending on your policy type. +-- +-- +module Network.AWS.ELB.CreateLoadBalancerPolicy + ( + -- * Request + CreateLoadBalancerPolicy + -- ** Request constructor + , createLoadBalancerPolicy + -- ** Request lenses + , clbpLoadBalancerName + , clbpPolicyAttributes + , clbpPolicyName + , clbpPolicyTypeName + + -- * Response + , CreateLoadBalancerPolicyResponse + -- ** Response constructor + , createLoadBalancerPolicyResponse + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data CreateLoadBalancerPolicy = CreateLoadBalancerPolicy + { _clbpLoadBalancerName :: Text + , _clbpPolicyAttributes :: List "PolicyAttributes" PolicyAttribute + , _clbpPolicyName :: Text + , _clbpPolicyTypeName :: Text + } deriving (Eq, Show) + +-- | 'CreateLoadBalancerPolicy' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'clbpLoadBalancerName' @::@ 'Text' +-- +-- * 'clbpPolicyAttributes' @::@ ['PolicyAttribute'] +-- +-- * 'clbpPolicyName' @::@ 'Text' +-- +-- * 'clbpPolicyTypeName' @::@ 'Text' +-- +createLoadBalancerPolicy :: Text -- ^ 'clbpLoadBalancerName' + -> Text -- ^ 'clbpPolicyName' + -> Text -- ^ 'clbpPolicyTypeName' + -> CreateLoadBalancerPolicy +createLoadBalancerPolicy p1 p2 p3 = CreateLoadBalancerPolicy + { _clbpLoadBalancerName = p1 + , _clbpPolicyName = p2 + , _clbpPolicyTypeName = p3 + , _clbpPolicyAttributes = mempty + } + +-- | The name associated with the LoadBalancer for which the policy is being +-- created. +clbpLoadBalancerName :: Lens' CreateLoadBalancerPolicy Text +clbpLoadBalancerName = + lens _clbpLoadBalancerName (\s a -> s { _clbpLoadBalancerName = a }) + +-- | A list of attributes associated with the policy being created. +clbpPolicyAttributes :: Lens' CreateLoadBalancerPolicy [PolicyAttribute] +clbpPolicyAttributes = + lens _clbpPolicyAttributes (\s a -> s { _clbpPolicyAttributes = a }) + . _List + +-- | The name of the load balancer policy being created. The name must be +-- unique within the set of policies for this load balancer. +clbpPolicyName :: Lens' CreateLoadBalancerPolicy Text +clbpPolicyName = lens _clbpPolicyName (\s a -> s { _clbpPolicyName = a }) + +-- | The name of the base policy type being used to create this policy. To get +-- the list of policy types, use the DescribeLoadBalancerPolicyTypes action. +clbpPolicyTypeName :: Lens' CreateLoadBalancerPolicy Text +clbpPolicyTypeName = + lens _clbpPolicyTypeName (\s a -> s { _clbpPolicyTypeName = a }) + +data CreateLoadBalancerPolicyResponse = CreateLoadBalancerPolicyResponse + deriving (Eq, Ord, Show, Generic) + +-- | 'CreateLoadBalancerPolicyResponse' constructor. +createLoadBalancerPolicyResponse :: CreateLoadBalancerPolicyResponse +createLoadBalancerPolicyResponse = CreateLoadBalancerPolicyResponse + +instance ToPath CreateLoadBalancerPolicy where + toPath = const "/" + +instance ToQuery CreateLoadBalancerPolicy where + toQuery CreateLoadBalancerPolicy{..} = mconcat + [ "LoadBalancerName" =? _clbpLoadBalancerName + , "PolicyAttributes" =? _clbpPolicyAttributes + , "PolicyName" =? _clbpPolicyName + , "PolicyTypeName" =? _clbpPolicyTypeName + ] + +instance ToHeaders CreateLoadBalancerPolicy + +instance AWSRequest CreateLoadBalancerPolicy where + type Sv CreateLoadBalancerPolicy = ELB + type Rs CreateLoadBalancerPolicy = CreateLoadBalancerPolicyResponse + + request = post "CreateLoadBalancerPolicy" + response = nullResponse CreateLoadBalancerPolicyResponse diff --git a/gen/Network/AWS/ELB/DeleteLoadBalancer.hs b/gen/Network/AWS/ELB/DeleteLoadBalancer.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/DeleteLoadBalancer.hs @@ -0,0 +1,97 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.DeleteLoadBalancer +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Deletes the specified load balancer. If attempting to recreate the load +-- balancer, you must reconfigure all the settings. The DNS name associated +-- with a deleted load balancer will no longer be usable. Once deleted, the +-- name and associated DNS record of the load balancer no longer exist and +-- traffic sent to any of its IP addresses will no longer be delivered to +-- back-end instances. To successfully call this API, you must provide the +-- same account credentials as were used to create the load balancer. By +-- design, if the load balancer does not exist or has already been deleted, a +-- call to DeleteLoadBalancer action still succeeds. +-- +-- +module Network.AWS.ELB.DeleteLoadBalancer + ( + -- * Request + DeleteLoadBalancer + -- ** Request constructor + , deleteLoadBalancer + -- ** Request lenses + , dlbLoadBalancerName + + -- * Response + , DeleteLoadBalancerResponse + -- ** Response constructor + , deleteLoadBalancerResponse + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +newtype DeleteLoadBalancer = DeleteLoadBalancer + { _dlbLoadBalancerName :: Text + } deriving (Eq, Ord, Show, Monoid, IsString) + +-- | 'DeleteLoadBalancer' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dlbLoadBalancerName' @::@ 'Text' +-- +deleteLoadBalancer :: Text -- ^ 'dlbLoadBalancerName' + -> DeleteLoadBalancer +deleteLoadBalancer p1 = DeleteLoadBalancer + { _dlbLoadBalancerName = p1 + } + +-- | The name associated with the load balancer. +dlbLoadBalancerName :: Lens' DeleteLoadBalancer Text +dlbLoadBalancerName = + lens _dlbLoadBalancerName (\s a -> s { _dlbLoadBalancerName = a }) + +data DeleteLoadBalancerResponse = DeleteLoadBalancerResponse + deriving (Eq, Ord, Show, Generic) + +-- | 'DeleteLoadBalancerResponse' constructor. +deleteLoadBalancerResponse :: DeleteLoadBalancerResponse +deleteLoadBalancerResponse = DeleteLoadBalancerResponse + +instance ToPath DeleteLoadBalancer where + toPath = const "/" + +instance ToQuery DeleteLoadBalancer where + toQuery DeleteLoadBalancer{..} = mconcat + [ "LoadBalancerName" =? _dlbLoadBalancerName + ] + +instance ToHeaders DeleteLoadBalancer + +instance AWSRequest DeleteLoadBalancer where + type Sv DeleteLoadBalancer = ELB + type Rs DeleteLoadBalancer = DeleteLoadBalancerResponse + + request = post "DeleteLoadBalancer" + response = nullResponse DeleteLoadBalancerResponse diff --git a/gen/Network/AWS/ELB/DeleteLoadBalancerListeners.hs b/gen/Network/AWS/ELB/DeleteLoadBalancerListeners.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/DeleteLoadBalancerListeners.hs @@ -0,0 +1,101 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.DeleteLoadBalancerListeners +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Deletes listeners from the load balancer for the specified port. +-- +-- +module Network.AWS.ELB.DeleteLoadBalancerListeners + ( + -- * Request + DeleteLoadBalancerListeners + -- ** Request constructor + , deleteLoadBalancerListeners + -- ** Request lenses + , dlblLoadBalancerName + , dlblLoadBalancerPorts + + -- * Response + , DeleteLoadBalancerListenersResponse + -- ** Response constructor + , deleteLoadBalancerListenersResponse + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data DeleteLoadBalancerListeners = DeleteLoadBalancerListeners + { _dlblLoadBalancerName :: Text + , _dlblLoadBalancerPorts :: List "LoadBalancerPorts" Int + } deriving (Eq, Ord, Show) + +-- | 'DeleteLoadBalancerListeners' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dlblLoadBalancerName' @::@ 'Text' +-- +-- * 'dlblLoadBalancerPorts' @::@ ['Int'] +-- +deleteLoadBalancerListeners :: Text -- ^ 'dlblLoadBalancerName' + -> DeleteLoadBalancerListeners +deleteLoadBalancerListeners p1 = DeleteLoadBalancerListeners + { _dlblLoadBalancerName = p1 + , _dlblLoadBalancerPorts = mempty + } + +-- | The mnemonic name associated with the load balancer. +dlblLoadBalancerName :: Lens' DeleteLoadBalancerListeners Text +dlblLoadBalancerName = + lens _dlblLoadBalancerName (\s a -> s { _dlblLoadBalancerName = a }) + +-- | The client port number(s) of the load balancer listener(s) to be removed. +dlblLoadBalancerPorts :: Lens' DeleteLoadBalancerListeners [Int] +dlblLoadBalancerPorts = + lens _dlblLoadBalancerPorts (\s a -> s { _dlblLoadBalancerPorts = a }) + . _List + +data DeleteLoadBalancerListenersResponse = DeleteLoadBalancerListenersResponse + deriving (Eq, Ord, Show, Generic) + +-- | 'DeleteLoadBalancerListenersResponse' constructor. +deleteLoadBalancerListenersResponse :: DeleteLoadBalancerListenersResponse +deleteLoadBalancerListenersResponse = DeleteLoadBalancerListenersResponse + +instance ToPath DeleteLoadBalancerListeners where + toPath = const "/" + +instance ToQuery DeleteLoadBalancerListeners where + toQuery DeleteLoadBalancerListeners{..} = mconcat + [ "LoadBalancerName" =? _dlblLoadBalancerName + , "LoadBalancerPorts" =? _dlblLoadBalancerPorts + ] + +instance ToHeaders DeleteLoadBalancerListeners + +instance AWSRequest DeleteLoadBalancerListeners where + type Sv DeleteLoadBalancerListeners = ELB + type Rs DeleteLoadBalancerListeners = DeleteLoadBalancerListenersResponse + + request = post "DeleteLoadBalancerListeners" + response = nullResponse DeleteLoadBalancerListenersResponse diff --git a/gen/Network/AWS/ELB/DeleteLoadBalancerPolicy.hs b/gen/Network/AWS/ELB/DeleteLoadBalancerPolicy.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/DeleteLoadBalancerPolicy.hs @@ -0,0 +1,101 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.DeleteLoadBalancerPolicy +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Deletes a policy from the load balancer. The specified policy must not be +-- enabled for any listeners. +-- +-- +module Network.AWS.ELB.DeleteLoadBalancerPolicy + ( + -- * Request + DeleteLoadBalancerPolicy + -- ** Request constructor + , deleteLoadBalancerPolicy + -- ** Request lenses + , dlbp1LoadBalancerName + , dlbp1PolicyName + + -- * Response + , DeleteLoadBalancerPolicyResponse + -- ** Response constructor + , deleteLoadBalancerPolicyResponse + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data DeleteLoadBalancerPolicy = DeleteLoadBalancerPolicy + { _dlbp1LoadBalancerName :: Text + , _dlbp1PolicyName :: Text + } deriving (Eq, Ord, Show) + +-- | 'DeleteLoadBalancerPolicy' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dlbp1LoadBalancerName' @::@ 'Text' +-- +-- * 'dlbp1PolicyName' @::@ 'Text' +-- +deleteLoadBalancerPolicy :: Text -- ^ 'dlbp1LoadBalancerName' + -> Text -- ^ 'dlbp1PolicyName' + -> DeleteLoadBalancerPolicy +deleteLoadBalancerPolicy p1 p2 = DeleteLoadBalancerPolicy + { _dlbp1LoadBalancerName = p1 + , _dlbp1PolicyName = p2 + } + +-- | The mnemonic name associated with the load balancer. +dlbp1LoadBalancerName :: Lens' DeleteLoadBalancerPolicy Text +dlbp1LoadBalancerName = + lens _dlbp1LoadBalancerName (\s a -> s { _dlbp1LoadBalancerName = a }) + +-- | The mnemonic name for the policy being deleted. +dlbp1PolicyName :: Lens' DeleteLoadBalancerPolicy Text +dlbp1PolicyName = lens _dlbp1PolicyName (\s a -> s { _dlbp1PolicyName = a }) + +data DeleteLoadBalancerPolicyResponse = DeleteLoadBalancerPolicyResponse + deriving (Eq, Ord, Show, Generic) + +-- | 'DeleteLoadBalancerPolicyResponse' constructor. +deleteLoadBalancerPolicyResponse :: DeleteLoadBalancerPolicyResponse +deleteLoadBalancerPolicyResponse = DeleteLoadBalancerPolicyResponse + +instance ToPath DeleteLoadBalancerPolicy where + toPath = const "/" + +instance ToQuery DeleteLoadBalancerPolicy where + toQuery DeleteLoadBalancerPolicy{..} = mconcat + [ "LoadBalancerName" =? _dlbp1LoadBalancerName + , "PolicyName" =? _dlbp1PolicyName + ] + +instance ToHeaders DeleteLoadBalancerPolicy + +instance AWSRequest DeleteLoadBalancerPolicy where + type Sv DeleteLoadBalancerPolicy = ELB + type Rs DeleteLoadBalancerPolicy = DeleteLoadBalancerPolicyResponse + + request = post "DeleteLoadBalancerPolicy" + response = nullResponse DeleteLoadBalancerPolicyResponse diff --git a/gen/Network/AWS/ELB/DeregisterInstancesFromLoadBalancer.hs b/gen/Network/AWS/ELB/DeregisterInstancesFromLoadBalancer.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/DeregisterInstancesFromLoadBalancer.hs @@ -0,0 +1,130 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.DeregisterInstancesFromLoadBalancer +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Deregisters instances from the load balancer. Once the instance is +-- deregistered, it will stop receiving traffic from the load balancer. In +-- order to successfully call this API, the same account credentials as those +-- used to create the load balancer must be provided. For more information, +-- see De-register and Register Amazon EC2 Instances in the Elastic Load +-- Balancing Developer Guide. You can use DescribeLoadBalancers to verify if +-- the instance is deregistered from the load balancer. +-- +-- +module Network.AWS.ELB.DeregisterInstancesFromLoadBalancer + ( + -- * Request + DeregisterInstancesFromLoadBalancer + -- ** Request constructor + , deregisterInstancesFromLoadBalancer + -- ** Request lenses + , diflbInstances + , diflbLoadBalancerName + + -- * Response + , DeregisterInstancesFromLoadBalancerResponse + -- ** Response constructor + , deregisterInstancesFromLoadBalancerResponse + -- ** Response lenses + , diflbrInstances + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data DeregisterInstancesFromLoadBalancer = DeregisterInstancesFromLoadBalancer + { _diflbInstances :: List "Instances" Instance + , _diflbLoadBalancerName :: Text + } deriving (Eq, Show) + +-- | 'DeregisterInstancesFromLoadBalancer' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'diflbInstances' @::@ ['Instance'] +-- +-- * 'diflbLoadBalancerName' @::@ 'Text' +-- +deregisterInstancesFromLoadBalancer :: Text -- ^ 'diflbLoadBalancerName' + -> DeregisterInstancesFromLoadBalancer +deregisterInstancesFromLoadBalancer p1 = DeregisterInstancesFromLoadBalancer + { _diflbLoadBalancerName = p1 + , _diflbInstances = mempty + } + +-- | A list of EC2 instance IDs consisting of all instances to be +-- deregistered. +diflbInstances :: Lens' DeregisterInstancesFromLoadBalancer [Instance] +diflbInstances = lens _diflbInstances (\s a -> s { _diflbInstances = a }) . _List + +-- | The name associated with the load balancer. +diflbLoadBalancerName :: Lens' DeregisterInstancesFromLoadBalancer Text +diflbLoadBalancerName = + lens _diflbLoadBalancerName (\s a -> s { _diflbLoadBalancerName = a }) + +newtype DeregisterInstancesFromLoadBalancerResponse = DeregisterInstancesFromLoadBalancerResponse + { _diflbrInstances :: List "Instances" Instance + } deriving (Eq, Show, Monoid, Semigroup) + +instance GHC.Exts.IsList DeregisterInstancesFromLoadBalancerResponse where + type Item DeregisterInstancesFromLoadBalancerResponse = Instance + + fromList = DeregisterInstancesFromLoadBalancerResponse . GHC.Exts.fromList + toList = GHC.Exts.toList . _diflbrInstances + +-- | 'DeregisterInstancesFromLoadBalancerResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'diflbrInstances' @::@ ['Instance'] +-- +deregisterInstancesFromLoadBalancerResponse :: DeregisterInstancesFromLoadBalancerResponse +deregisterInstancesFromLoadBalancerResponse = DeregisterInstancesFromLoadBalancerResponse + { _diflbrInstances = mempty + } + +-- | An updated list of remaining instances registered with the load balancer. +diflbrInstances :: Lens' DeregisterInstancesFromLoadBalancerResponse [Instance] +diflbrInstances = lens _diflbrInstances (\s a -> s { _diflbrInstances = a }) . _List + +instance ToPath DeregisterInstancesFromLoadBalancer where + toPath = const "/" + +instance ToQuery DeregisterInstancesFromLoadBalancer where + toQuery DeregisterInstancesFromLoadBalancer{..} = mconcat + [ "Instances" =? _diflbInstances + , "LoadBalancerName" =? _diflbLoadBalancerName + ] + +instance ToHeaders DeregisterInstancesFromLoadBalancer + +instance AWSRequest DeregisterInstancesFromLoadBalancer where + type Sv DeregisterInstancesFromLoadBalancer = ELB + type Rs DeregisterInstancesFromLoadBalancer = DeregisterInstancesFromLoadBalancerResponse + + request = post "DeregisterInstancesFromLoadBalancer" + response = xmlResponse + +instance FromXML DeregisterInstancesFromLoadBalancerResponse where + parseXML = withElement "DeregisterInstancesFromLoadBalancerResult" $ \x -> DeregisterInstancesFromLoadBalancerResponse + <$> x .@ "Instances" diff --git a/gen/Network/AWS/ELB/DescribeInstanceHealth.hs b/gen/Network/AWS/ELB/DescribeInstanceHealth.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/DescribeInstanceHealth.hs @@ -0,0 +1,129 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.DescribeInstanceHealth +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Returns the current state of the specified instances registered with the +-- specified load balancer. If no instances are specified, the state of all +-- the instances registered with the load balancer is returned. You must +-- provide the same account credentials as those that were used to create the +-- load balancer. +-- +-- +module Network.AWS.ELB.DescribeInstanceHealth + ( + -- * Request + DescribeInstanceHealth + -- ** Request constructor + , describeInstanceHealth + -- ** Request lenses + , dihInstances + , dihLoadBalancerName + + -- * Response + , DescribeInstanceHealthResponse + -- ** Response constructor + , describeInstanceHealthResponse + -- ** Response lenses + , dihrInstanceStates + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data DescribeInstanceHealth = DescribeInstanceHealth + { _dihInstances :: List "Instances" Instance + , _dihLoadBalancerName :: Text + } deriving (Eq, Show) + +-- | 'DescribeInstanceHealth' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dihInstances' @::@ ['Instance'] +-- +-- * 'dihLoadBalancerName' @::@ 'Text' +-- +describeInstanceHealth :: Text -- ^ 'dihLoadBalancerName' + -> DescribeInstanceHealth +describeInstanceHealth p1 = DescribeInstanceHealth + { _dihLoadBalancerName = p1 + , _dihInstances = mempty + } + +-- | A list of instance IDs whose states are being queried. +dihInstances :: Lens' DescribeInstanceHealth [Instance] +dihInstances = lens _dihInstances (\s a -> s { _dihInstances = a }) . _List + +-- | The name of the load balancer. +dihLoadBalancerName :: Lens' DescribeInstanceHealth Text +dihLoadBalancerName = + lens _dihLoadBalancerName (\s a -> s { _dihLoadBalancerName = a }) + +newtype DescribeInstanceHealthResponse = DescribeInstanceHealthResponse + { _dihrInstanceStates :: List "InstanceStates" InstanceState + } deriving (Eq, Show, Monoid, Semigroup) + +instance GHC.Exts.IsList DescribeInstanceHealthResponse where + type Item DescribeInstanceHealthResponse = InstanceState + + fromList = DescribeInstanceHealthResponse . GHC.Exts.fromList + toList = GHC.Exts.toList . _dihrInstanceStates + +-- | 'DescribeInstanceHealthResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dihrInstanceStates' @::@ ['InstanceState'] +-- +describeInstanceHealthResponse :: DescribeInstanceHealthResponse +describeInstanceHealthResponse = DescribeInstanceHealthResponse + { _dihrInstanceStates = mempty + } + +-- | A list containing health information for the specified instances. +dihrInstanceStates :: Lens' DescribeInstanceHealthResponse [InstanceState] +dihrInstanceStates = + lens _dihrInstanceStates (\s a -> s { _dihrInstanceStates = a }) + . _List + +instance ToPath DescribeInstanceHealth where + toPath = const "/" + +instance ToQuery DescribeInstanceHealth where + toQuery DescribeInstanceHealth{..} = mconcat + [ "Instances" =? _dihInstances + , "LoadBalancerName" =? _dihLoadBalancerName + ] + +instance ToHeaders DescribeInstanceHealth + +instance AWSRequest DescribeInstanceHealth where + type Sv DescribeInstanceHealth = ELB + type Rs DescribeInstanceHealth = DescribeInstanceHealthResponse + + request = post "DescribeInstanceHealth" + response = xmlResponse + +instance FromXML DescribeInstanceHealthResponse where + parseXML = withElement "DescribeInstanceHealthResult" $ \x -> DescribeInstanceHealthResponse + <$> x .@ "InstanceStates" diff --git a/gen/Network/AWS/ELB/DescribeLoadBalancerAttributes.hs b/gen/Network/AWS/ELB/DescribeLoadBalancerAttributes.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/DescribeLoadBalancerAttributes.hs @@ -0,0 +1,110 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.DescribeLoadBalancerAttributes +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Returns detailed information about all of the attributes associated with +-- the specified load balancer. +-- +-- +module Network.AWS.ELB.DescribeLoadBalancerAttributes + ( + -- * Request + DescribeLoadBalancerAttributes + -- ** Request constructor + , describeLoadBalancerAttributes + -- ** Request lenses + , dlbaLoadBalancerName + + -- * Response + , DescribeLoadBalancerAttributesResponse + -- ** Response constructor + , describeLoadBalancerAttributesResponse + -- ** Response lenses + , dlbarLoadBalancerAttributes + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +newtype DescribeLoadBalancerAttributes = DescribeLoadBalancerAttributes + { _dlbaLoadBalancerName :: Text + } deriving (Eq, Ord, Show, Monoid, IsString) + +-- | 'DescribeLoadBalancerAttributes' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dlbaLoadBalancerName' @::@ 'Text' +-- +describeLoadBalancerAttributes :: Text -- ^ 'dlbaLoadBalancerName' + -> DescribeLoadBalancerAttributes +describeLoadBalancerAttributes p1 = DescribeLoadBalancerAttributes + { _dlbaLoadBalancerName = p1 + } + +-- | The name of the load balancer. +dlbaLoadBalancerName :: Lens' DescribeLoadBalancerAttributes Text +dlbaLoadBalancerName = + lens _dlbaLoadBalancerName (\s a -> s { _dlbaLoadBalancerName = a }) + +newtype DescribeLoadBalancerAttributesResponse = DescribeLoadBalancerAttributesResponse + { _dlbarLoadBalancerAttributes :: Maybe LoadBalancerAttributes + } deriving (Eq, Show) + +-- | 'DescribeLoadBalancerAttributesResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dlbarLoadBalancerAttributes' @::@ 'Maybe' 'LoadBalancerAttributes' +-- +describeLoadBalancerAttributesResponse :: DescribeLoadBalancerAttributesResponse +describeLoadBalancerAttributesResponse = DescribeLoadBalancerAttributesResponse + { _dlbarLoadBalancerAttributes = Nothing + } + +-- | The load balancer attributes structure. +dlbarLoadBalancerAttributes :: Lens' DescribeLoadBalancerAttributesResponse (Maybe LoadBalancerAttributes) +dlbarLoadBalancerAttributes = + lens _dlbarLoadBalancerAttributes + (\s a -> s { _dlbarLoadBalancerAttributes = a }) + +instance ToPath DescribeLoadBalancerAttributes where + toPath = const "/" + +instance ToQuery DescribeLoadBalancerAttributes where + toQuery DescribeLoadBalancerAttributes{..} = mconcat + [ "LoadBalancerName" =? _dlbaLoadBalancerName + ] + +instance ToHeaders DescribeLoadBalancerAttributes + +instance AWSRequest DescribeLoadBalancerAttributes where + type Sv DescribeLoadBalancerAttributes = ELB + type Rs DescribeLoadBalancerAttributes = DescribeLoadBalancerAttributesResponse + + request = post "DescribeLoadBalancerAttributes" + response = xmlResponse + +instance FromXML DescribeLoadBalancerAttributesResponse where + parseXML = withElement "DescribeLoadBalancerAttributesResult" $ \x -> DescribeLoadBalancerAttributesResponse + <$> x .@? "LoadBalancerAttributes" diff --git a/gen/Network/AWS/ELB/DescribeLoadBalancerPolicies.hs b/gen/Network/AWS/ELB/DescribeLoadBalancerPolicies.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/DescribeLoadBalancerPolicies.hs @@ -0,0 +1,134 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.DescribeLoadBalancerPolicies +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Returns detailed descriptions of the policies. If you specify a load +-- balancer name, the action returns the descriptions of all the policies +-- created for the load balancer. If you specify a policy name associated with +-- your load balancer, the action returns the description of that policy. If +-- you don't specify a load balancer name, the action returns descriptions of +-- the specified sample policies, or descriptions of all the sample policies. +-- The names of the sample policies have the ELBSample- prefix. +-- +-- +module Network.AWS.ELB.DescribeLoadBalancerPolicies + ( + -- * Request + DescribeLoadBalancerPolicies + -- ** Request constructor + , describeLoadBalancerPolicies + -- ** Request lenses + , dlbpLoadBalancerName + , dlbpPolicyNames + + -- * Response + , DescribeLoadBalancerPoliciesResponse + -- ** Response constructor + , describeLoadBalancerPoliciesResponse + -- ** Response lenses + , dlbprPolicyDescriptions + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data DescribeLoadBalancerPolicies = DescribeLoadBalancerPolicies + { _dlbpLoadBalancerName :: Maybe Text + , _dlbpPolicyNames :: List "PolicyNames" Text + } deriving (Eq, Ord, Show) + +-- | 'DescribeLoadBalancerPolicies' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dlbpLoadBalancerName' @::@ 'Maybe' 'Text' +-- +-- * 'dlbpPolicyNames' @::@ ['Text'] +-- +describeLoadBalancerPolicies :: DescribeLoadBalancerPolicies +describeLoadBalancerPolicies = DescribeLoadBalancerPolicies + { _dlbpLoadBalancerName = Nothing + , _dlbpPolicyNames = mempty + } + +-- | The mnemonic name associated with the load balancer. If no name is +-- specified, the operation returns the attributes of either all the sample +-- policies pre-defined by Elastic Load Balancing or the specified sample +-- polices. +dlbpLoadBalancerName :: Lens' DescribeLoadBalancerPolicies (Maybe Text) +dlbpLoadBalancerName = + lens _dlbpLoadBalancerName (\s a -> s { _dlbpLoadBalancerName = a }) + +-- | The names of load balancer policies you've created or Elastic Load +-- Balancing sample policy names. +dlbpPolicyNames :: Lens' DescribeLoadBalancerPolicies [Text] +dlbpPolicyNames = lens _dlbpPolicyNames (\s a -> s { _dlbpPolicyNames = a }) . _List + +newtype DescribeLoadBalancerPoliciesResponse = DescribeLoadBalancerPoliciesResponse + { _dlbprPolicyDescriptions :: List "PolicyDescriptions" PolicyDescription + } deriving (Eq, Show, Monoid, Semigroup) + +instance GHC.Exts.IsList DescribeLoadBalancerPoliciesResponse where + type Item DescribeLoadBalancerPoliciesResponse = PolicyDescription + + fromList = DescribeLoadBalancerPoliciesResponse . GHC.Exts.fromList + toList = GHC.Exts.toList . _dlbprPolicyDescriptions + +-- | 'DescribeLoadBalancerPoliciesResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dlbprPolicyDescriptions' @::@ ['PolicyDescription'] +-- +describeLoadBalancerPoliciesResponse :: DescribeLoadBalancerPoliciesResponse +describeLoadBalancerPoliciesResponse = DescribeLoadBalancerPoliciesResponse + { _dlbprPolicyDescriptions = mempty + } + +-- | A list of policy description structures. +dlbprPolicyDescriptions :: Lens' DescribeLoadBalancerPoliciesResponse [PolicyDescription] +dlbprPolicyDescriptions = + lens _dlbprPolicyDescriptions (\s a -> s { _dlbprPolicyDescriptions = a }) + . _List + +instance ToPath DescribeLoadBalancerPolicies where + toPath = const "/" + +instance ToQuery DescribeLoadBalancerPolicies where + toQuery DescribeLoadBalancerPolicies{..} = mconcat + [ "LoadBalancerName" =? _dlbpLoadBalancerName + , "PolicyNames" =? _dlbpPolicyNames + ] + +instance ToHeaders DescribeLoadBalancerPolicies + +instance AWSRequest DescribeLoadBalancerPolicies where + type Sv DescribeLoadBalancerPolicies = ELB + type Rs DescribeLoadBalancerPolicies = DescribeLoadBalancerPoliciesResponse + + request = post "DescribeLoadBalancerPolicies" + response = xmlResponse + +instance FromXML DescribeLoadBalancerPoliciesResponse where + parseXML = withElement "DescribeLoadBalancerPoliciesResult" $ \x -> DescribeLoadBalancerPoliciesResponse + <$> x .@ "PolicyDescriptions" diff --git a/gen/Network/AWS/ELB/DescribeLoadBalancerPolicyTypes.hs b/gen/Network/AWS/ELB/DescribeLoadBalancerPolicyTypes.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/DescribeLoadBalancerPolicyTypes.hs @@ -0,0 +1,129 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.DescribeLoadBalancerPolicyTypes +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Returns meta-information on the specified load balancer policies defined by +-- the Elastic Load Balancing service. The policy types that are returned from +-- this action can be used in a CreateLoadBalancerPolicy action to instantiate +-- specific policy configurations that will be applied to a load balancer. +-- +-- +module Network.AWS.ELB.DescribeLoadBalancerPolicyTypes + ( + -- * Request + DescribeLoadBalancerPolicyTypes + -- ** Request constructor + , describeLoadBalancerPolicyTypes + -- ** Request lenses + , dlbptPolicyTypeNames + + -- * Response + , DescribeLoadBalancerPolicyTypesResponse + -- ** Response constructor + , describeLoadBalancerPolicyTypesResponse + -- ** Response lenses + , dlbptrPolicyTypeDescriptions + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +newtype DescribeLoadBalancerPolicyTypes = DescribeLoadBalancerPolicyTypes + { _dlbptPolicyTypeNames :: List "PolicyTypeNames" Text + } deriving (Eq, Ord, Show, Monoid, Semigroup) + +instance GHC.Exts.IsList DescribeLoadBalancerPolicyTypes where + type Item DescribeLoadBalancerPolicyTypes = Text + + fromList = DescribeLoadBalancerPolicyTypes . GHC.Exts.fromList + toList = GHC.Exts.toList . _dlbptPolicyTypeNames + +-- | 'DescribeLoadBalancerPolicyTypes' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dlbptPolicyTypeNames' @::@ ['Text'] +-- +describeLoadBalancerPolicyTypes :: DescribeLoadBalancerPolicyTypes +describeLoadBalancerPolicyTypes = DescribeLoadBalancerPolicyTypes + { _dlbptPolicyTypeNames = mempty + } + +-- | Specifies the name of the policy types. If no names are specified, +-- returns the description of all the policy types defined by Elastic Load +-- Balancing service. +dlbptPolicyTypeNames :: Lens' DescribeLoadBalancerPolicyTypes [Text] +dlbptPolicyTypeNames = + lens _dlbptPolicyTypeNames (\s a -> s { _dlbptPolicyTypeNames = a }) + . _List + +newtype DescribeLoadBalancerPolicyTypesResponse = DescribeLoadBalancerPolicyTypesResponse + { _dlbptrPolicyTypeDescriptions :: List "PolicyTypeDescriptions" PolicyTypeDescription + } deriving (Eq, Show, Monoid, Semigroup) + +instance GHC.Exts.IsList DescribeLoadBalancerPolicyTypesResponse where + type Item DescribeLoadBalancerPolicyTypesResponse = PolicyTypeDescription + + fromList = DescribeLoadBalancerPolicyTypesResponse . GHC.Exts.fromList + toList = GHC.Exts.toList . _dlbptrPolicyTypeDescriptions + +-- | 'DescribeLoadBalancerPolicyTypesResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dlbptrPolicyTypeDescriptions' @::@ ['PolicyTypeDescription'] +-- +describeLoadBalancerPolicyTypesResponse :: DescribeLoadBalancerPolicyTypesResponse +describeLoadBalancerPolicyTypesResponse = DescribeLoadBalancerPolicyTypesResponse + { _dlbptrPolicyTypeDescriptions = mempty + } + +-- | List of policy type description structures of the specified policy type. +-- If no policy type names are specified, returns the description of all the +-- policy types defined by Elastic Load Balancing service. +dlbptrPolicyTypeDescriptions :: Lens' DescribeLoadBalancerPolicyTypesResponse [PolicyTypeDescription] +dlbptrPolicyTypeDescriptions = + lens _dlbptrPolicyTypeDescriptions + (\s a -> s { _dlbptrPolicyTypeDescriptions = a }) + . _List + +instance ToPath DescribeLoadBalancerPolicyTypes where + toPath = const "/" + +instance ToQuery DescribeLoadBalancerPolicyTypes where + toQuery DescribeLoadBalancerPolicyTypes{..} = mconcat + [ "PolicyTypeNames" =? _dlbptPolicyTypeNames + ] + +instance ToHeaders DescribeLoadBalancerPolicyTypes + +instance AWSRequest DescribeLoadBalancerPolicyTypes where + type Sv DescribeLoadBalancerPolicyTypes = ELB + type Rs DescribeLoadBalancerPolicyTypes = DescribeLoadBalancerPolicyTypesResponse + + request = post "DescribeLoadBalancerPolicyTypes" + response = xmlResponse + +instance FromXML DescribeLoadBalancerPolicyTypesResponse where + parseXML = withElement "DescribeLoadBalancerPolicyTypesResult" $ \x -> DescribeLoadBalancerPolicyTypesResponse + <$> x .@ "PolicyTypeDescriptions" diff --git a/gen/Network/AWS/ELB/DescribeLoadBalancers.hs b/gen/Network/AWS/ELB/DescribeLoadBalancers.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/DescribeLoadBalancers.hs @@ -0,0 +1,153 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.DescribeLoadBalancers +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Returns detailed configuration information for all the load balancers +-- created for the account. If you specify load balancer names, the action +-- returns configuration information of the specified load balancers. In order +-- to retrieve this information, you must provide the same account credentials +-- that was used to create the load balancer. +-- +-- +module Network.AWS.ELB.DescribeLoadBalancers + ( + -- * Request + DescribeLoadBalancers + -- ** Request constructor + , describeLoadBalancers + -- ** Request lenses + , dlbLoadBalancerNames + , dlbMarker + , dlbPageSize + + -- * Response + , DescribeLoadBalancersResponse + -- ** Response constructor + , describeLoadBalancersResponse + -- ** Response lenses + , dlbrLoadBalancerDescriptions + , dlbrNextMarker + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data DescribeLoadBalancers = DescribeLoadBalancers + { _dlbLoadBalancerNames :: List "LoadBalancerNames" Text + , _dlbMarker :: Maybe Text + , _dlbPageSize :: Maybe Nat + } deriving (Eq, Ord, Show) + +-- | 'DescribeLoadBalancers' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dlbLoadBalancerNames' @::@ ['Text'] +-- +-- * 'dlbMarker' @::@ 'Maybe' 'Text' +-- +-- * 'dlbPageSize' @::@ 'Maybe' 'Natural' +-- +describeLoadBalancers :: DescribeLoadBalancers +describeLoadBalancers = DescribeLoadBalancers + { _dlbLoadBalancerNames = mempty + , _dlbMarker = Nothing + , _dlbPageSize = Nothing + } + +-- | A list of load balancer names associated with the account. +dlbLoadBalancerNames :: Lens' DescribeLoadBalancers [Text] +dlbLoadBalancerNames = + lens _dlbLoadBalancerNames (\s a -> s { _dlbLoadBalancerNames = a }) + . _List + +-- | An optional parameter used for pagination of results from this call. If +-- specified, the response includes only records beyond the marker. +dlbMarker :: Lens' DescribeLoadBalancers (Maybe Text) +dlbMarker = lens _dlbMarker (\s a -> s { _dlbMarker = a }) + +-- | The number of results returned in each page. The default is 400. You +-- cannot specify a page size greater than 400 or less than 1. +dlbPageSize :: Lens' DescribeLoadBalancers (Maybe Natural) +dlbPageSize = lens _dlbPageSize (\s a -> s { _dlbPageSize = a }) . mapping _Nat + +data DescribeLoadBalancersResponse = DescribeLoadBalancersResponse + { _dlbrLoadBalancerDescriptions :: List "LoadBalancerDescriptions" LoadBalancerDescription + , _dlbrNextMarker :: Maybe Text + } deriving (Eq, Show) + +-- | 'DescribeLoadBalancersResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dlbrLoadBalancerDescriptions' @::@ ['LoadBalancerDescription'] +-- +-- * 'dlbrNextMarker' @::@ 'Maybe' 'Text' +-- +describeLoadBalancersResponse :: DescribeLoadBalancersResponse +describeLoadBalancersResponse = DescribeLoadBalancersResponse + { _dlbrLoadBalancerDescriptions = mempty + , _dlbrNextMarker = Nothing + } + +-- | A list of load balancer description structures. +dlbrLoadBalancerDescriptions :: Lens' DescribeLoadBalancersResponse [LoadBalancerDescription] +dlbrLoadBalancerDescriptions = + lens _dlbrLoadBalancerDescriptions + (\s a -> s { _dlbrLoadBalancerDescriptions = a }) + . _List + +-- | Specifies the value of next marker if the request returned more than one +-- page of results. +dlbrNextMarker :: Lens' DescribeLoadBalancersResponse (Maybe Text) +dlbrNextMarker = lens _dlbrNextMarker (\s a -> s { _dlbrNextMarker = a }) + +instance ToPath DescribeLoadBalancers where + toPath = const "/" + +instance ToQuery DescribeLoadBalancers where + toQuery DescribeLoadBalancers{..} = mconcat + [ "LoadBalancerNames" =? _dlbLoadBalancerNames + , "Marker" =? _dlbMarker + , "PageSize" =? _dlbPageSize + ] + +instance ToHeaders DescribeLoadBalancers + +instance AWSRequest DescribeLoadBalancers where + type Sv DescribeLoadBalancers = ELB + type Rs DescribeLoadBalancers = DescribeLoadBalancersResponse + + request = post "DescribeLoadBalancers" + response = xmlResponse + +instance FromXML DescribeLoadBalancersResponse where + parseXML = withElement "DescribeLoadBalancersResult" $ \x -> DescribeLoadBalancersResponse + <$> x .@ "LoadBalancerDescriptions" + <*> x .@? "NextMarker" + +instance AWSPager DescribeLoadBalancers where + page rq rs + | stop (rq ^. dlbMarker) = Nothing + | otherwise = (\x -> rq & dlbMarker ?~ x) + <$> (rs ^. dlbrNextMarker) diff --git a/gen/Network/AWS/ELB/DescribeTags.hs b/gen/Network/AWS/ELB/DescribeTags.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/DescribeTags.hs @@ -0,0 +1,116 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.DescribeTags +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Describes the tags associated with one or more load balancers. +-- +-- +module Network.AWS.ELB.DescribeTags + ( + -- * Request + DescribeTags + -- ** Request constructor + , describeTags + -- ** Request lenses + , dtLoadBalancerNames + + -- * Response + , DescribeTagsResponse + -- ** Response constructor + , describeTagsResponse + -- ** Response lenses + , dtrTagDescriptions + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +newtype DescribeTags = DescribeTags + { _dtLoadBalancerNames :: List1 "LoadBalancerNames" Text + } deriving (Eq, Ord, Show, Semigroup) + +-- | 'DescribeTags' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dtLoadBalancerNames' @::@ 'NonEmpty' 'Text' +-- +describeTags :: NonEmpty Text -- ^ 'dtLoadBalancerNames' + -> DescribeTags +describeTags p1 = DescribeTags + { _dtLoadBalancerNames = withIso _List1 (const id) p1 + } + +-- | The names of the load balancers. +dtLoadBalancerNames :: Lens' DescribeTags (NonEmpty Text) +dtLoadBalancerNames = + lens _dtLoadBalancerNames (\s a -> s { _dtLoadBalancerNames = a }) + . _List1 + +newtype DescribeTagsResponse = DescribeTagsResponse + { _dtrTagDescriptions :: List "TagDescriptions" TagDescription + } deriving (Eq, Show, Monoid, Semigroup) + +instance GHC.Exts.IsList DescribeTagsResponse where + type Item DescribeTagsResponse = TagDescription + + fromList = DescribeTagsResponse . GHC.Exts.fromList + toList = GHC.Exts.toList . _dtrTagDescriptions + +-- | 'DescribeTagsResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dtrTagDescriptions' @::@ ['TagDescription'] +-- +describeTagsResponse :: DescribeTagsResponse +describeTagsResponse = DescribeTagsResponse + { _dtrTagDescriptions = mempty + } + +-- | A list of tag description structures. +dtrTagDescriptions :: Lens' DescribeTagsResponse [TagDescription] +dtrTagDescriptions = + lens _dtrTagDescriptions (\s a -> s { _dtrTagDescriptions = a }) + . _List + +instance ToPath DescribeTags where + toPath = const "/" + +instance ToQuery DescribeTags where + toQuery DescribeTags{..} = mconcat + [ "LoadBalancerNames" =? _dtLoadBalancerNames + ] + +instance ToHeaders DescribeTags + +instance AWSRequest DescribeTags where + type Sv DescribeTags = ELB + type Rs DescribeTags = DescribeTagsResponse + + request = post "DescribeTags" + response = xmlResponse + +instance FromXML DescribeTagsResponse where + parseXML = withElement "DescribeTagsResult" $ \x -> DescribeTagsResponse + <$> x .@ "TagDescriptions" diff --git a/gen/Network/AWS/ELB/DetachLoadBalancerFromSubnets.hs b/gen/Network/AWS/ELB/DetachLoadBalancerFromSubnets.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/DetachLoadBalancerFromSubnets.hs @@ -0,0 +1,129 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.DetachLoadBalancerFromSubnets +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Removes subnets from the set of configured subnets in the Amazon Virtual +-- Private Cloud (Amazon VPC) for the load balancer. After a subnet is removed +-- all of the EC2 instances registered with the load balancer that are in the +-- removed subnet will go into the OutOfService state. When a subnet is +-- removed, the load balancer will balance the traffic among the remaining +-- routable subnets for the load balancer. +-- +-- +module Network.AWS.ELB.DetachLoadBalancerFromSubnets + ( + -- * Request + DetachLoadBalancerFromSubnets + -- ** Request constructor + , detachLoadBalancerFromSubnets + -- ** Request lenses + , dlbfsLoadBalancerName + , dlbfsSubnets + + -- * Response + , DetachLoadBalancerFromSubnetsResponse + -- ** Response constructor + , detachLoadBalancerFromSubnetsResponse + -- ** Response lenses + , dlbfsrSubnets + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data DetachLoadBalancerFromSubnets = DetachLoadBalancerFromSubnets + { _dlbfsLoadBalancerName :: Text + , _dlbfsSubnets :: List "Subnets" Text + } deriving (Eq, Ord, Show) + +-- | 'DetachLoadBalancerFromSubnets' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dlbfsLoadBalancerName' @::@ 'Text' +-- +-- * 'dlbfsSubnets' @::@ ['Text'] +-- +detachLoadBalancerFromSubnets :: Text -- ^ 'dlbfsLoadBalancerName' + -> DetachLoadBalancerFromSubnets +detachLoadBalancerFromSubnets p1 = DetachLoadBalancerFromSubnets + { _dlbfsLoadBalancerName = p1 + , _dlbfsSubnets = mempty + } + +-- | The name associated with the load balancer to be detached. +dlbfsLoadBalancerName :: Lens' DetachLoadBalancerFromSubnets Text +dlbfsLoadBalancerName = + lens _dlbfsLoadBalancerName (\s a -> s { _dlbfsLoadBalancerName = a }) + +-- | A list of subnet IDs to remove from the set of configured subnets for the +-- load balancer. +dlbfsSubnets :: Lens' DetachLoadBalancerFromSubnets [Text] +dlbfsSubnets = lens _dlbfsSubnets (\s a -> s { _dlbfsSubnets = a }) . _List + +newtype DetachLoadBalancerFromSubnetsResponse = DetachLoadBalancerFromSubnetsResponse + { _dlbfsrSubnets :: List "Subnets" Text + } deriving (Eq, Ord, Show, Monoid, Semigroup) + +instance GHC.Exts.IsList DetachLoadBalancerFromSubnetsResponse where + type Item DetachLoadBalancerFromSubnetsResponse = Text + + fromList = DetachLoadBalancerFromSubnetsResponse . GHC.Exts.fromList + toList = GHC.Exts.toList . _dlbfsrSubnets + +-- | 'DetachLoadBalancerFromSubnetsResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dlbfsrSubnets' @::@ ['Text'] +-- +detachLoadBalancerFromSubnetsResponse :: DetachLoadBalancerFromSubnetsResponse +detachLoadBalancerFromSubnetsResponse = DetachLoadBalancerFromSubnetsResponse + { _dlbfsrSubnets = mempty + } + +-- | A list of subnet IDs the load balancer is now attached to. +dlbfsrSubnets :: Lens' DetachLoadBalancerFromSubnetsResponse [Text] +dlbfsrSubnets = lens _dlbfsrSubnets (\s a -> s { _dlbfsrSubnets = a }) . _List + +instance ToPath DetachLoadBalancerFromSubnets where + toPath = const "/" + +instance ToQuery DetachLoadBalancerFromSubnets where + toQuery DetachLoadBalancerFromSubnets{..} = mconcat + [ "LoadBalancerName" =? _dlbfsLoadBalancerName + , "Subnets" =? _dlbfsSubnets + ] + +instance ToHeaders DetachLoadBalancerFromSubnets + +instance AWSRequest DetachLoadBalancerFromSubnets where + type Sv DetachLoadBalancerFromSubnets = ELB + type Rs DetachLoadBalancerFromSubnets = DetachLoadBalancerFromSubnetsResponse + + request = post "DetachLoadBalancerFromSubnets" + response = xmlResponse + +instance FromXML DetachLoadBalancerFromSubnetsResponse where + parseXML = withElement "DetachLoadBalancerFromSubnetsResult" $ \x -> DetachLoadBalancerFromSubnetsResponse + <$> x .@ "Subnets" diff --git a/gen/Network/AWS/ELB/DisableAvailabilityZonesForLoadBalancer.hs b/gen/Network/AWS/ELB/DisableAvailabilityZonesForLoadBalancer.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/DisableAvailabilityZonesForLoadBalancer.hs @@ -0,0 +1,140 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.DisableAvailabilityZonesForLoadBalancer +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Removes the specified EC2 Availability Zones from the set of configured +-- Availability Zones for the load balancer. There must be at least one +-- Availability Zone registered with a load balancer at all times. Once an +-- Availability Zone is removed, all the instances registered with the load +-- balancer that are in the removed Availability Zone go into the OutOfService +-- state. Upon Availability Zone removal, the load balancer attempts to +-- equally balance the traffic among its remaining usable Availability Zones. +-- Trying to remove an Availability Zone that was not associated with the load +-- balancer does nothing. For more information, see Disable an Availability +-- Zone from a Load-Balanced Application in the Elastic Load Balancing +-- Developer Guide. +-- +-- +module Network.AWS.ELB.DisableAvailabilityZonesForLoadBalancer + ( + -- * Request + DisableAvailabilityZonesForLoadBalancer + -- ** Request constructor + , disableAvailabilityZonesForLoadBalancer + -- ** Request lenses + , dazflbAvailabilityZones + , dazflbLoadBalancerName + + -- * Response + , DisableAvailabilityZonesForLoadBalancerResponse + -- ** Response constructor + , disableAvailabilityZonesForLoadBalancerResponse + -- ** Response lenses + , dazflbrAvailabilityZones + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data DisableAvailabilityZonesForLoadBalancer = DisableAvailabilityZonesForLoadBalancer + { _dazflbAvailabilityZones :: List "AvailabilityZones" Text + , _dazflbLoadBalancerName :: Text + } deriving (Eq, Ord, Show) + +-- | 'DisableAvailabilityZonesForLoadBalancer' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dazflbAvailabilityZones' @::@ ['Text'] +-- +-- * 'dazflbLoadBalancerName' @::@ 'Text' +-- +disableAvailabilityZonesForLoadBalancer :: Text -- ^ 'dazflbLoadBalancerName' + -> DisableAvailabilityZonesForLoadBalancer +disableAvailabilityZonesForLoadBalancer p1 = DisableAvailabilityZonesForLoadBalancer + { _dazflbLoadBalancerName = p1 + , _dazflbAvailabilityZones = mempty + } + +-- | A list of Availability Zones to be removed from the load balancer. There +-- must be at least one Availability Zone registered with a load balancer at +-- all times. Specified Availability Zones must be in the same region. +dazflbAvailabilityZones :: Lens' DisableAvailabilityZonesForLoadBalancer [Text] +dazflbAvailabilityZones = + lens _dazflbAvailabilityZones (\s a -> s { _dazflbAvailabilityZones = a }) + . _List + +-- | The name associated with the load balancer. +dazflbLoadBalancerName :: Lens' DisableAvailabilityZonesForLoadBalancer Text +dazflbLoadBalancerName = + lens _dazflbLoadBalancerName (\s a -> s { _dazflbLoadBalancerName = a }) + +newtype DisableAvailabilityZonesForLoadBalancerResponse = DisableAvailabilityZonesForLoadBalancerResponse + { _dazflbrAvailabilityZones :: List "AvailabilityZones" Text + } deriving (Eq, Ord, Show, Monoid, Semigroup) + +instance GHC.Exts.IsList DisableAvailabilityZonesForLoadBalancerResponse where + type Item DisableAvailabilityZonesForLoadBalancerResponse = Text + + fromList = DisableAvailabilityZonesForLoadBalancerResponse . GHC.Exts.fromList + toList = GHC.Exts.toList . _dazflbrAvailabilityZones + +-- | 'DisableAvailabilityZonesForLoadBalancerResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dazflbrAvailabilityZones' @::@ ['Text'] +-- +disableAvailabilityZonesForLoadBalancerResponse :: DisableAvailabilityZonesForLoadBalancerResponse +disableAvailabilityZonesForLoadBalancerResponse = DisableAvailabilityZonesForLoadBalancerResponse + { _dazflbrAvailabilityZones = mempty + } + +-- | A list of updated Availability Zones for the load balancer. +dazflbrAvailabilityZones :: Lens' DisableAvailabilityZonesForLoadBalancerResponse [Text] +dazflbrAvailabilityZones = + lens _dazflbrAvailabilityZones + (\s a -> s { _dazflbrAvailabilityZones = a }) + . _List + +instance ToPath DisableAvailabilityZonesForLoadBalancer where + toPath = const "/" + +instance ToQuery DisableAvailabilityZonesForLoadBalancer where + toQuery DisableAvailabilityZonesForLoadBalancer{..} = mconcat + [ "AvailabilityZones" =? _dazflbAvailabilityZones + , "LoadBalancerName" =? _dazflbLoadBalancerName + ] + +instance ToHeaders DisableAvailabilityZonesForLoadBalancer + +instance AWSRequest DisableAvailabilityZonesForLoadBalancer where + type Sv DisableAvailabilityZonesForLoadBalancer = ELB + type Rs DisableAvailabilityZonesForLoadBalancer = DisableAvailabilityZonesForLoadBalancerResponse + + request = post "DisableAvailabilityZonesForLoadBalancer" + response = xmlResponse + +instance FromXML DisableAvailabilityZonesForLoadBalancerResponse where + parseXML = withElement "DisableAvailabilityZonesForLoadBalancerResult" $ \x -> DisableAvailabilityZonesForLoadBalancerResponse + <$> x .@ "AvailabilityZones" diff --git a/gen/Network/AWS/ELB/EnableAvailabilityZonesForLoadBalancer.hs b/gen/Network/AWS/ELB/EnableAvailabilityZonesForLoadBalancer.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/EnableAvailabilityZonesForLoadBalancer.hs @@ -0,0 +1,135 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.EnableAvailabilityZonesForLoadBalancer +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Adds one or more EC2 Availability Zones to the load balancer. The load +-- balancer evenly distributes requests across all its registered Availability +-- Zones that contain instances. The new EC2 Availability Zones to be added +-- must be in the same EC2 Region as the Availability Zones for which the load +-- balancer was created. For more information, see Expand a Load Balanced +-- Application to an Additional Availability Zone in the Elastic Load +-- Balancing Developer Guide. +-- +-- +module Network.AWS.ELB.EnableAvailabilityZonesForLoadBalancer + ( + -- * Request + EnableAvailabilityZonesForLoadBalancer + -- ** Request constructor + , enableAvailabilityZonesForLoadBalancer + -- ** Request lenses + , eazflbAvailabilityZones + , eazflbLoadBalancerName + + -- * Response + , EnableAvailabilityZonesForLoadBalancerResponse + -- ** Response constructor + , enableAvailabilityZonesForLoadBalancerResponse + -- ** Response lenses + , eazflbrAvailabilityZones + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data EnableAvailabilityZonesForLoadBalancer = EnableAvailabilityZonesForLoadBalancer + { _eazflbAvailabilityZones :: List "AvailabilityZones" Text + , _eazflbLoadBalancerName :: Text + } deriving (Eq, Ord, Show) + +-- | 'EnableAvailabilityZonesForLoadBalancer' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'eazflbAvailabilityZones' @::@ ['Text'] +-- +-- * 'eazflbLoadBalancerName' @::@ 'Text' +-- +enableAvailabilityZonesForLoadBalancer :: Text -- ^ 'eazflbLoadBalancerName' + -> EnableAvailabilityZonesForLoadBalancer +enableAvailabilityZonesForLoadBalancer p1 = EnableAvailabilityZonesForLoadBalancer + { _eazflbLoadBalancerName = p1 + , _eazflbAvailabilityZones = mempty + } + +-- | A list of new Availability Zones for the load balancer. Each Availability +-- Zone must be in the same region as the load balancer. +eazflbAvailabilityZones :: Lens' EnableAvailabilityZonesForLoadBalancer [Text] +eazflbAvailabilityZones = + lens _eazflbAvailabilityZones (\s a -> s { _eazflbAvailabilityZones = a }) + . _List + +-- | The name associated with the load balancer. +eazflbLoadBalancerName :: Lens' EnableAvailabilityZonesForLoadBalancer Text +eazflbLoadBalancerName = + lens _eazflbLoadBalancerName (\s a -> s { _eazflbLoadBalancerName = a }) + +newtype EnableAvailabilityZonesForLoadBalancerResponse = EnableAvailabilityZonesForLoadBalancerResponse + { _eazflbrAvailabilityZones :: List "AvailabilityZones" Text + } deriving (Eq, Ord, Show, Monoid, Semigroup) + +instance GHC.Exts.IsList EnableAvailabilityZonesForLoadBalancerResponse where + type Item EnableAvailabilityZonesForLoadBalancerResponse = Text + + fromList = EnableAvailabilityZonesForLoadBalancerResponse . GHC.Exts.fromList + toList = GHC.Exts.toList . _eazflbrAvailabilityZones + +-- | 'EnableAvailabilityZonesForLoadBalancerResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'eazflbrAvailabilityZones' @::@ ['Text'] +-- +enableAvailabilityZonesForLoadBalancerResponse :: EnableAvailabilityZonesForLoadBalancerResponse +enableAvailabilityZonesForLoadBalancerResponse = EnableAvailabilityZonesForLoadBalancerResponse + { _eazflbrAvailabilityZones = mempty + } + +-- | An updated list of Availability Zones for the load balancer. +eazflbrAvailabilityZones :: Lens' EnableAvailabilityZonesForLoadBalancerResponse [Text] +eazflbrAvailabilityZones = + lens _eazflbrAvailabilityZones + (\s a -> s { _eazflbrAvailabilityZones = a }) + . _List + +instance ToPath EnableAvailabilityZonesForLoadBalancer where + toPath = const "/" + +instance ToQuery EnableAvailabilityZonesForLoadBalancer where + toQuery EnableAvailabilityZonesForLoadBalancer{..} = mconcat + [ "AvailabilityZones" =? _eazflbAvailabilityZones + , "LoadBalancerName" =? _eazflbLoadBalancerName + ] + +instance ToHeaders EnableAvailabilityZonesForLoadBalancer + +instance AWSRequest EnableAvailabilityZonesForLoadBalancer where + type Sv EnableAvailabilityZonesForLoadBalancer = ELB + type Rs EnableAvailabilityZonesForLoadBalancer = EnableAvailabilityZonesForLoadBalancerResponse + + request = post "EnableAvailabilityZonesForLoadBalancer" + response = xmlResponse + +instance FromXML EnableAvailabilityZonesForLoadBalancerResponse where + parseXML = withElement "EnableAvailabilityZonesForLoadBalancerResult" $ \x -> EnableAvailabilityZonesForLoadBalancerResponse + <$> x .@ "AvailabilityZones" diff --git a/gen/Network/AWS/ELB/ModifyLoadBalancerAttributes.hs b/gen/Network/AWS/ELB/ModifyLoadBalancerAttributes.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/ModifyLoadBalancerAttributes.hs @@ -0,0 +1,138 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.ModifyLoadBalancerAttributes +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Modifies the attributes of a specified load balancer. You can modify the +-- load balancer attributes, such as AccessLogs, ConnectionDraining, and +-- CrossZoneLoadBalancing by either enabling or disabling them. Or, you can +-- modify the load balancer attribute ConnectionSettings by specifying an idle +-- connection timeout value for your load balancer. For more information, see +-- the following: Cross-Zone Load Balancing Connection Draining Access Logs +-- Idle Connection Timeout. +-- +-- +module Network.AWS.ELB.ModifyLoadBalancerAttributes + ( + -- * Request + ModifyLoadBalancerAttributes + -- ** Request constructor + , modifyLoadBalancerAttributes + -- ** Request lenses + , mlbaLoadBalancerAttributes + , mlbaLoadBalancerName + + -- * Response + , ModifyLoadBalancerAttributesResponse + -- ** Response constructor + , modifyLoadBalancerAttributesResponse + -- ** Response lenses + , mlbarLoadBalancerAttributes + , mlbarLoadBalancerName + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data ModifyLoadBalancerAttributes = ModifyLoadBalancerAttributes + { _mlbaLoadBalancerAttributes :: LoadBalancerAttributes + , _mlbaLoadBalancerName :: Text + } deriving (Eq, Show) + +-- | 'ModifyLoadBalancerAttributes' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'mlbaLoadBalancerAttributes' @::@ 'LoadBalancerAttributes' +-- +-- * 'mlbaLoadBalancerName' @::@ 'Text' +-- +modifyLoadBalancerAttributes :: Text -- ^ 'mlbaLoadBalancerName' + -> LoadBalancerAttributes -- ^ 'mlbaLoadBalancerAttributes' + -> ModifyLoadBalancerAttributes +modifyLoadBalancerAttributes p1 p2 = ModifyLoadBalancerAttributes + { _mlbaLoadBalancerName = p1 + , _mlbaLoadBalancerAttributes = p2 + } + +-- | Attributes of the load balancer. +mlbaLoadBalancerAttributes :: Lens' ModifyLoadBalancerAttributes LoadBalancerAttributes +mlbaLoadBalancerAttributes = + lens _mlbaLoadBalancerAttributes + (\s a -> s { _mlbaLoadBalancerAttributes = a }) + +-- | The name of the load balancer. +mlbaLoadBalancerName :: Lens' ModifyLoadBalancerAttributes Text +mlbaLoadBalancerName = + lens _mlbaLoadBalancerName (\s a -> s { _mlbaLoadBalancerName = a }) + +data ModifyLoadBalancerAttributesResponse = ModifyLoadBalancerAttributesResponse + { _mlbarLoadBalancerAttributes :: Maybe LoadBalancerAttributes + , _mlbarLoadBalancerName :: Maybe Text + } deriving (Eq, Show) + +-- | 'ModifyLoadBalancerAttributesResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'mlbarLoadBalancerAttributes' @::@ 'Maybe' 'LoadBalancerAttributes' +-- +-- * 'mlbarLoadBalancerName' @::@ 'Maybe' 'Text' +-- +modifyLoadBalancerAttributesResponse :: ModifyLoadBalancerAttributesResponse +modifyLoadBalancerAttributesResponse = ModifyLoadBalancerAttributesResponse + { _mlbarLoadBalancerName = Nothing + , _mlbarLoadBalancerAttributes = Nothing + } + +mlbarLoadBalancerAttributes :: Lens' ModifyLoadBalancerAttributesResponse (Maybe LoadBalancerAttributes) +mlbarLoadBalancerAttributes = + lens _mlbarLoadBalancerAttributes + (\s a -> s { _mlbarLoadBalancerAttributes = a }) + +-- | The name of the load balancer. +mlbarLoadBalancerName :: Lens' ModifyLoadBalancerAttributesResponse (Maybe Text) +mlbarLoadBalancerName = + lens _mlbarLoadBalancerName (\s a -> s { _mlbarLoadBalancerName = a }) + +instance ToPath ModifyLoadBalancerAttributes where + toPath = const "/" + +instance ToQuery ModifyLoadBalancerAttributes where + toQuery ModifyLoadBalancerAttributes{..} = mconcat + [ "LoadBalancerAttributes" =? _mlbaLoadBalancerAttributes + , "LoadBalancerName" =? _mlbaLoadBalancerName + ] + +instance ToHeaders ModifyLoadBalancerAttributes + +instance AWSRequest ModifyLoadBalancerAttributes where + type Sv ModifyLoadBalancerAttributes = ELB + type Rs ModifyLoadBalancerAttributes = ModifyLoadBalancerAttributesResponse + + request = post "ModifyLoadBalancerAttributes" + response = xmlResponse + +instance FromXML ModifyLoadBalancerAttributesResponse where + parseXML = withElement "ModifyLoadBalancerAttributesResult" $ \x -> ModifyLoadBalancerAttributesResponse + <$> x .@? "LoadBalancerAttributes" + <*> x .@? "LoadBalancerName" diff --git a/gen/Network/AWS/ELB/RegisterInstancesWithLoadBalancer.hs b/gen/Network/AWS/ELB/RegisterInstancesWithLoadBalancer.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/RegisterInstancesWithLoadBalancer.hs @@ -0,0 +1,144 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.RegisterInstancesWithLoadBalancer +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Adds new instances to the load balancer. Once the instance is registered, +-- it starts receiving traffic and requests from the load balancer. Any +-- instance that is not in any of the Availability Zones registered for the +-- load balancer will be moved to the OutOfService state. It will move to the +-- InService state when the Availability Zone is added to the load balancer. +-- When an instance registered with a load balancer is stopped and then +-- restarted, the IP addresses associated with the instance changes. Elastic +-- Load Balancing cannot recognize the new IP address, which prevents it from +-- routing traffic to the instances. We recommend that you de-register your +-- Amazon EC2 instances from your load balancer after you stop your instance, +-- and then register the load balancer with your instance after you've +-- restarted. To de-register your instances from load balancer, use +-- DeregisterInstancesFromLoadBalancer action. For more information, see +-- De-register and Register Amazon EC2 Instances in the Elastic Load Balancing +-- Developer Guide. In order for this call to be successful, you must provide +-- the same account credentials as those that were used to create the load +-- balancer. Completion of this API does not guarantee that operation has +-- completed. Rather, it means that the request has been registered and the +-- changes will happen shortly. You can use DescribeLoadBalancers or +-- DescribeInstanceHealth action to check the state of the newly registered +-- instances. +-- +-- +module Network.AWS.ELB.RegisterInstancesWithLoadBalancer + ( + -- * Request + RegisterInstancesWithLoadBalancer + -- ** Request constructor + , registerInstancesWithLoadBalancer + -- ** Request lenses + , riwlbInstances + , riwlbLoadBalancerName + + -- * Response + , RegisterInstancesWithLoadBalancerResponse + -- ** Response constructor + , registerInstancesWithLoadBalancerResponse + -- ** Response lenses + , riwlbrInstances + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data RegisterInstancesWithLoadBalancer = RegisterInstancesWithLoadBalancer + { _riwlbInstances :: List "Instances" Instance + , _riwlbLoadBalancerName :: Text + } deriving (Eq, Show) + +-- | 'RegisterInstancesWithLoadBalancer' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'riwlbInstances' @::@ ['Instance'] +-- +-- * 'riwlbLoadBalancerName' @::@ 'Text' +-- +registerInstancesWithLoadBalancer :: Text -- ^ 'riwlbLoadBalancerName' + -> RegisterInstancesWithLoadBalancer +registerInstancesWithLoadBalancer p1 = RegisterInstancesWithLoadBalancer + { _riwlbLoadBalancerName = p1 + , _riwlbInstances = mempty + } + +-- | A list of instance IDs that should be registered with the load balancer. +riwlbInstances :: Lens' RegisterInstancesWithLoadBalancer [Instance] +riwlbInstances = lens _riwlbInstances (\s a -> s { _riwlbInstances = a }) . _List + +-- | The name associated with the load balancer. The name must be unique +-- within your set of load balancers. +riwlbLoadBalancerName :: Lens' RegisterInstancesWithLoadBalancer Text +riwlbLoadBalancerName = + lens _riwlbLoadBalancerName (\s a -> s { _riwlbLoadBalancerName = a }) + +newtype RegisterInstancesWithLoadBalancerResponse = RegisterInstancesWithLoadBalancerResponse + { _riwlbrInstances :: List "Instances" Instance + } deriving (Eq, Show, Monoid, Semigroup) + +instance GHC.Exts.IsList RegisterInstancesWithLoadBalancerResponse where + type Item RegisterInstancesWithLoadBalancerResponse = Instance + + fromList = RegisterInstancesWithLoadBalancerResponse . GHC.Exts.fromList + toList = GHC.Exts.toList . _riwlbrInstances + +-- | 'RegisterInstancesWithLoadBalancerResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'riwlbrInstances' @::@ ['Instance'] +-- +registerInstancesWithLoadBalancerResponse :: RegisterInstancesWithLoadBalancerResponse +registerInstancesWithLoadBalancerResponse = RegisterInstancesWithLoadBalancerResponse + { _riwlbrInstances = mempty + } + +-- | An updated list of instances for the load balancer. +riwlbrInstances :: Lens' RegisterInstancesWithLoadBalancerResponse [Instance] +riwlbrInstances = lens _riwlbrInstances (\s a -> s { _riwlbrInstances = a }) . _List + +instance ToPath RegisterInstancesWithLoadBalancer where + toPath = const "/" + +instance ToQuery RegisterInstancesWithLoadBalancer where + toQuery RegisterInstancesWithLoadBalancer{..} = mconcat + [ "Instances" =? _riwlbInstances + , "LoadBalancerName" =? _riwlbLoadBalancerName + ] + +instance ToHeaders RegisterInstancesWithLoadBalancer + +instance AWSRequest RegisterInstancesWithLoadBalancer where + type Sv RegisterInstancesWithLoadBalancer = ELB + type Rs RegisterInstancesWithLoadBalancer = RegisterInstancesWithLoadBalancerResponse + + request = post "RegisterInstancesWithLoadBalancer" + response = xmlResponse + +instance FromXML RegisterInstancesWithLoadBalancerResponse where + parseXML = withElement "RegisterInstancesWithLoadBalancerResult" $ \x -> RegisterInstancesWithLoadBalancerResponse + <$> x .@ "Instances" diff --git a/gen/Network/AWS/ELB/RemoveTags.hs b/gen/Network/AWS/ELB/RemoveTags.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/RemoveTags.hs @@ -0,0 +1,101 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.RemoveTags +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Removes one or more tags from the specified load balancer. +-- +-- +module Network.AWS.ELB.RemoveTags + ( + -- * Request + RemoveTags + -- ** Request constructor + , removeTags + -- ** Request lenses + , rtLoadBalancerNames + , rtTags + + -- * Response + , RemoveTagsResponse + -- ** Response constructor + , removeTagsResponse + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data RemoveTags = RemoveTags + { _rtLoadBalancerNames :: List "LoadBalancerNames" Text + , _rtTags :: List1 "Tags" TagKeyOnly + } deriving (Eq, Show) + +-- | 'RemoveTags' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'rtLoadBalancerNames' @::@ ['Text'] +-- +-- * 'rtTags' @::@ 'NonEmpty' 'TagKeyOnly' +-- +removeTags :: NonEmpty TagKeyOnly -- ^ 'rtTags' + -> RemoveTags +removeTags p1 = RemoveTags + { _rtTags = withIso _List1 (const id) p1 + , _rtLoadBalancerNames = mempty + } + +-- | The name of the load balancer. You can specify a maximum of one load +-- balancer name. +rtLoadBalancerNames :: Lens' RemoveTags [Text] +rtLoadBalancerNames = + lens _rtLoadBalancerNames (\s a -> s { _rtLoadBalancerNames = a }) + . _List + +-- | A list of tag keys to remove. +rtTags :: Lens' RemoveTags (NonEmpty TagKeyOnly) +rtTags = lens _rtTags (\s a -> s { _rtTags = a }) . _List1 + +data RemoveTagsResponse = RemoveTagsResponse + deriving (Eq, Ord, Show, Generic) + +-- | 'RemoveTagsResponse' constructor. +removeTagsResponse :: RemoveTagsResponse +removeTagsResponse = RemoveTagsResponse + +instance ToPath RemoveTags where + toPath = const "/" + +instance ToQuery RemoveTags where + toQuery RemoveTags{..} = mconcat + [ "LoadBalancerNames" =? _rtLoadBalancerNames + , "Tags" =? _rtTags + ] + +instance ToHeaders RemoveTags + +instance AWSRequest RemoveTags where + type Sv RemoveTags = ELB + type Rs RemoveTags = RemoveTagsResponse + + request = post "RemoveTags" + response = nullResponse RemoveTagsResponse diff --git a/gen/Network/AWS/ELB/SetLoadBalancerListenerSSLCertificate.hs b/gen/Network/AWS/ELB/SetLoadBalancerListenerSSLCertificate.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/SetLoadBalancerListenerSSLCertificate.hs @@ -0,0 +1,122 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.SetLoadBalancerListenerSSLCertificate +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Sets the certificate that terminates the specified listener's SSL +-- connections. The specified certificate replaces any prior certificate that +-- was used on the same load balancer and port. For more information on +-- updating your SSL certificate, see Updating an SSL Certificate for a Load +-- Balancer in the Elastic Load Balancing Developer Guide. +-- +-- +module Network.AWS.ELB.SetLoadBalancerListenerSSLCertificate + ( + -- * Request + SetLoadBalancerListenerSSLCertificate + -- ** Request constructor + , setLoadBalancerListenerSSLCertificate + -- ** Request lenses + , slblsslcLoadBalancerName + , slblsslcLoadBalancerPort + , slblsslcSSLCertificateId + + -- * Response + , SetLoadBalancerListenerSSLCertificateResponse + -- ** Response constructor + , setLoadBalancerListenerSSLCertificateResponse + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data SetLoadBalancerListenerSSLCertificate = SetLoadBalancerListenerSSLCertificate + { _slblsslcLoadBalancerName :: Text + , _slblsslcLoadBalancerPort :: Int + , _slblsslcSSLCertificateId :: Text + } deriving (Eq, Ord, Show) + +-- | 'SetLoadBalancerListenerSSLCertificate' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'slblsslcLoadBalancerName' @::@ 'Text' +-- +-- * 'slblsslcLoadBalancerPort' @::@ 'Int' +-- +-- * 'slblsslcSSLCertificateId' @::@ 'Text' +-- +setLoadBalancerListenerSSLCertificate :: Text -- ^ 'slblsslcLoadBalancerName' + -> Int -- ^ 'slblsslcLoadBalancerPort' + -> Text -- ^ 'slblsslcSSLCertificateId' + -> SetLoadBalancerListenerSSLCertificate +setLoadBalancerListenerSSLCertificate p1 p2 p3 = SetLoadBalancerListenerSSLCertificate + { _slblsslcLoadBalancerName = p1 + , _slblsslcLoadBalancerPort = p2 + , _slblsslcSSLCertificateId = p3 + } + +-- | The name of the load balancer. +slblsslcLoadBalancerName :: Lens' SetLoadBalancerListenerSSLCertificate Text +slblsslcLoadBalancerName = + lens _slblsslcLoadBalancerName + (\s a -> s { _slblsslcLoadBalancerName = a }) + +-- | The port that uses the specified SSL certificate. +slblsslcLoadBalancerPort :: Lens' SetLoadBalancerListenerSSLCertificate Int +slblsslcLoadBalancerPort = + lens _slblsslcLoadBalancerPort + (\s a -> s { _slblsslcLoadBalancerPort = a }) + +-- | The Amazon Resource Number (ARN) of the SSL certificate chain to use. For +-- more information on SSL certificates, see Managing Server Certificates in +-- the AWS Identity and Access Management User Guide. +slblsslcSSLCertificateId :: Lens' SetLoadBalancerListenerSSLCertificate Text +slblsslcSSLCertificateId = + lens _slblsslcSSLCertificateId + (\s a -> s { _slblsslcSSLCertificateId = a }) + +data SetLoadBalancerListenerSSLCertificateResponse = SetLoadBalancerListenerSSLCertificateResponse + deriving (Eq, Ord, Show, Generic) + +-- | 'SetLoadBalancerListenerSSLCertificateResponse' constructor. +setLoadBalancerListenerSSLCertificateResponse :: SetLoadBalancerListenerSSLCertificateResponse +setLoadBalancerListenerSSLCertificateResponse = SetLoadBalancerListenerSSLCertificateResponse + +instance ToPath SetLoadBalancerListenerSSLCertificate where + toPath = const "/" + +instance ToQuery SetLoadBalancerListenerSSLCertificate where + toQuery SetLoadBalancerListenerSSLCertificate{..} = mconcat + [ "LoadBalancerName" =? _slblsslcLoadBalancerName + , "LoadBalancerPort" =? _slblsslcLoadBalancerPort + , "SSLCertificateId" =? _slblsslcSSLCertificateId + ] + +instance ToHeaders SetLoadBalancerListenerSSLCertificate + +instance AWSRequest SetLoadBalancerListenerSSLCertificate where + type Sv SetLoadBalancerListenerSSLCertificate = ELB + type Rs SetLoadBalancerListenerSSLCertificate = SetLoadBalancerListenerSSLCertificateResponse + + request = post "SetLoadBalancerListenerSSLCertificate" + response = nullResponse SetLoadBalancerListenerSSLCertificateResponse diff --git a/gen/Network/AWS/ELB/SetLoadBalancerPoliciesForBackendServer.hs b/gen/Network/AWS/ELB/SetLoadBalancerPoliciesForBackendServer.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/SetLoadBalancerPoliciesForBackendServer.hs @@ -0,0 +1,125 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.SetLoadBalancerPoliciesForBackendServer +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Replaces the current set of policies associated with a port on which the +-- back-end server is listening with a new set of policies. After the policies +-- have been created using CreateLoadBalancerPolicy, they can be applied here +-- as a list. At this time, only the back-end server authentication policy +-- type can be applied to the back-end ports; this policy type is composed of +-- multiple public key policies. The SetLoadBalancerPoliciesForBackendServer +-- replaces the current set of policies associated with the specified instance +-- port. Every time you use this action to enable the policies, use the +-- PolicyNames parameter to list all the policies you want to enable. You can +-- use DescribeLoadBalancers or DescribeLoadBalancerPolicies action to verify +-- that the policy has been associated with the back-end server. +-- +-- +module Network.AWS.ELB.SetLoadBalancerPoliciesForBackendServer + ( + -- * Request + SetLoadBalancerPoliciesForBackendServer + -- ** Request constructor + , setLoadBalancerPoliciesForBackendServer + -- ** Request lenses + , slbpfbsInstancePort + , slbpfbsLoadBalancerName + , slbpfbsPolicyNames + + -- * Response + , SetLoadBalancerPoliciesForBackendServerResponse + -- ** Response constructor + , setLoadBalancerPoliciesForBackendServerResponse + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data SetLoadBalancerPoliciesForBackendServer = SetLoadBalancerPoliciesForBackendServer + { _slbpfbsInstancePort :: Int + , _slbpfbsLoadBalancerName :: Text + , _slbpfbsPolicyNames :: List "PolicyNames" Text + } deriving (Eq, Ord, Show) + +-- | 'SetLoadBalancerPoliciesForBackendServer' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'slbpfbsInstancePort' @::@ 'Int' +-- +-- * 'slbpfbsLoadBalancerName' @::@ 'Text' +-- +-- * 'slbpfbsPolicyNames' @::@ ['Text'] +-- +setLoadBalancerPoliciesForBackendServer :: Text -- ^ 'slbpfbsLoadBalancerName' + -> Int -- ^ 'slbpfbsInstancePort' + -> SetLoadBalancerPoliciesForBackendServer +setLoadBalancerPoliciesForBackendServer p1 p2 = SetLoadBalancerPoliciesForBackendServer + { _slbpfbsLoadBalancerName = p1 + , _slbpfbsInstancePort = p2 + , _slbpfbsPolicyNames = mempty + } + +-- | The port number associated with the back-end server. +slbpfbsInstancePort :: Lens' SetLoadBalancerPoliciesForBackendServer Int +slbpfbsInstancePort = + lens _slbpfbsInstancePort (\s a -> s { _slbpfbsInstancePort = a }) + +-- | The mnemonic name associated with the load balancer. This name must be +-- unique within the set of your load balancers. +slbpfbsLoadBalancerName :: Lens' SetLoadBalancerPoliciesForBackendServer Text +slbpfbsLoadBalancerName = + lens _slbpfbsLoadBalancerName (\s a -> s { _slbpfbsLoadBalancerName = a }) + +-- | List of policy names to be set. If the list is empty, then all current +-- polices are removed from the back-end server. +slbpfbsPolicyNames :: Lens' SetLoadBalancerPoliciesForBackendServer [Text] +slbpfbsPolicyNames = + lens _slbpfbsPolicyNames (\s a -> s { _slbpfbsPolicyNames = a }) + . _List + +data SetLoadBalancerPoliciesForBackendServerResponse = SetLoadBalancerPoliciesForBackendServerResponse + deriving (Eq, Ord, Show, Generic) + +-- | 'SetLoadBalancerPoliciesForBackendServerResponse' constructor. +setLoadBalancerPoliciesForBackendServerResponse :: SetLoadBalancerPoliciesForBackendServerResponse +setLoadBalancerPoliciesForBackendServerResponse = SetLoadBalancerPoliciesForBackendServerResponse + +instance ToPath SetLoadBalancerPoliciesForBackendServer where + toPath = const "/" + +instance ToQuery SetLoadBalancerPoliciesForBackendServer where + toQuery SetLoadBalancerPoliciesForBackendServer{..} = mconcat + [ "InstancePort" =? _slbpfbsInstancePort + , "LoadBalancerName" =? _slbpfbsLoadBalancerName + , "PolicyNames" =? _slbpfbsPolicyNames + ] + +instance ToHeaders SetLoadBalancerPoliciesForBackendServer + +instance AWSRequest SetLoadBalancerPoliciesForBackendServer where + type Sv SetLoadBalancerPoliciesForBackendServer = ELB + type Rs SetLoadBalancerPoliciesForBackendServer = SetLoadBalancerPoliciesForBackendServerResponse + + request = post "SetLoadBalancerPoliciesForBackendServer" + response = nullResponse SetLoadBalancerPoliciesForBackendServerResponse diff --git a/gen/Network/AWS/ELB/SetLoadBalancerPoliciesOfListener.hs b/gen/Network/AWS/ELB/SetLoadBalancerPoliciesOfListener.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/SetLoadBalancerPoliciesOfListener.hs @@ -0,0 +1,115 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.SetLoadBalancerPoliciesOfListener +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Associates, updates, or disables a policy with a listener on the load +-- balancer. You can associate multiple policies with a listener. +-- +-- +module Network.AWS.ELB.SetLoadBalancerPoliciesOfListener + ( + -- * Request + SetLoadBalancerPoliciesOfListener + -- ** Request constructor + , setLoadBalancerPoliciesOfListener + -- ** Request lenses + , slbpolLoadBalancerName + , slbpolLoadBalancerPort + , slbpolPolicyNames + + -- * Response + , SetLoadBalancerPoliciesOfListenerResponse + -- ** Response constructor + , setLoadBalancerPoliciesOfListenerResponse + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.ELB.Types +import qualified GHC.Exts + +data SetLoadBalancerPoliciesOfListener = SetLoadBalancerPoliciesOfListener + { _slbpolLoadBalancerName :: Text + , _slbpolLoadBalancerPort :: Int + , _slbpolPolicyNames :: List "PolicyNames" Text + } deriving (Eq, Ord, Show) + +-- | 'SetLoadBalancerPoliciesOfListener' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'slbpolLoadBalancerName' @::@ 'Text' +-- +-- * 'slbpolLoadBalancerPort' @::@ 'Int' +-- +-- * 'slbpolPolicyNames' @::@ ['Text'] +-- +setLoadBalancerPoliciesOfListener :: Text -- ^ 'slbpolLoadBalancerName' + -> Int -- ^ 'slbpolLoadBalancerPort' + -> SetLoadBalancerPoliciesOfListener +setLoadBalancerPoliciesOfListener p1 p2 = SetLoadBalancerPoliciesOfListener + { _slbpolLoadBalancerName = p1 + , _slbpolLoadBalancerPort = p2 + , _slbpolPolicyNames = mempty + } + +-- | The name of the load balancer. +slbpolLoadBalancerName :: Lens' SetLoadBalancerPoliciesOfListener Text +slbpolLoadBalancerName = + lens _slbpolLoadBalancerName (\s a -> s { _slbpolLoadBalancerName = a }) + +-- | The external port of the load balancer to associate the policy. +slbpolLoadBalancerPort :: Lens' SetLoadBalancerPoliciesOfListener Int +slbpolLoadBalancerPort = + lens _slbpolLoadBalancerPort (\s a -> s { _slbpolLoadBalancerPort = a }) + +-- | List of policies to be associated with the listener. If the list is +-- empty, the current policy is removed from the listener. +slbpolPolicyNames :: Lens' SetLoadBalancerPoliciesOfListener [Text] +slbpolPolicyNames = + lens _slbpolPolicyNames (\s a -> s { _slbpolPolicyNames = a }) + . _List + +data SetLoadBalancerPoliciesOfListenerResponse = SetLoadBalancerPoliciesOfListenerResponse + deriving (Eq, Ord, Show, Generic) + +-- | 'SetLoadBalancerPoliciesOfListenerResponse' constructor. +setLoadBalancerPoliciesOfListenerResponse :: SetLoadBalancerPoliciesOfListenerResponse +setLoadBalancerPoliciesOfListenerResponse = SetLoadBalancerPoliciesOfListenerResponse + +instance ToPath SetLoadBalancerPoliciesOfListener where + toPath = const "/" + +instance ToQuery SetLoadBalancerPoliciesOfListener where + toQuery SetLoadBalancerPoliciesOfListener{..} = mconcat + [ "LoadBalancerName" =? _slbpolLoadBalancerName + , "LoadBalancerPort" =? _slbpolLoadBalancerPort + , "PolicyNames" =? _slbpolPolicyNames + ] + +instance ToHeaders SetLoadBalancerPoliciesOfListener + +instance AWSRequest SetLoadBalancerPoliciesOfListener where + type Sv SetLoadBalancerPoliciesOfListener = ELB + type Rs SetLoadBalancerPoliciesOfListener = SetLoadBalancerPoliciesOfListenerResponse + + request = post "SetLoadBalancerPoliciesOfListener" + response = nullResponse SetLoadBalancerPoliciesOfListenerResponse diff --git a/gen/Network/AWS/ELB/Types.hs b/gen/Network/AWS/ELB/Types.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/ELB/Types.hs @@ -0,0 +1,1624 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.ELB.Types +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +module Network.AWS.ELB.Types + ( + -- * Service + ELB + -- ** Error + , RESTError + -- ** XML + , ns + + -- * SourceSecurityGroup + , SourceSecurityGroup + , sourceSecurityGroup + , ssgGroupName + , ssgOwnerAlias + + -- * TagDescription + , TagDescription + , tagDescription + , tdLoadBalancerName + , tdTags + + -- * Tag + , Tag + , tag + , tagKey + , tagValue + + -- * PolicyAttributeTypeDescription + , PolicyAttributeTypeDescription + , policyAttributeTypeDescription + , patdAttributeName + , patdAttributeType + , patdCardinality + , patdDefaultValue + , patdDescription + + -- * HealthCheck + , HealthCheck + , healthCheck + , hcHealthyThreshold + , hcInterval + , hcTarget + , hcTimeout + , hcUnhealthyThreshold + + -- * CrossZoneLoadBalancing + , CrossZoneLoadBalancing + , crossZoneLoadBalancing + , czlbEnabled + + -- * LoadBalancerAttributes + , LoadBalancerAttributes + , loadBalancerAttributes + , lbaAccessLog + , lbaAdditionalAttributes + , lbaConnectionDraining + , lbaConnectionSettings + , lbaCrossZoneLoadBalancing + + -- * AccessLog + , AccessLog + , accessLog + , alEmitInterval + , alEnabled + , alS3BucketName + , alS3BucketPrefix + + -- * ListenerDescription + , ListenerDescription + , listenerDescription + , ldListener + , ldPolicyNames + + -- * LBCookieStickinessPolicy + , LBCookieStickinessPolicy + , lbcookieStickinessPolicy + , lbcspCookieExpirationPeriod + , lbcspPolicyName + + -- * PolicyDescription + , PolicyDescription + , policyDescription + , pdPolicyAttributeDescriptions + , pdPolicyName + , pdPolicyTypeName + + -- * AppCookieStickinessPolicy + , AppCookieStickinessPolicy + , appCookieStickinessPolicy + , acspCookieName + , acspPolicyName + + -- * PolicyAttribute + , PolicyAttribute + , policyAttribute + , paAttributeName + , paAttributeValue + + -- * LoadBalancerDescription + , LoadBalancerDescription + , loadBalancerDescription + , lbdAvailabilityZones + , lbdBackendServerDescriptions + , lbdCanonicalHostedZoneName + , lbdCanonicalHostedZoneNameID + , lbdCreatedTime + , lbdDNSName + , lbdHealthCheck + , lbdInstances + , lbdListenerDescriptions + , lbdLoadBalancerName + , lbdPolicies + , lbdScheme + , lbdSecurityGroups + , lbdSourceSecurityGroup + , lbdSubnets + , lbdVPCId + + -- * BackendServerDescription + , BackendServerDescription + , backendServerDescription + , bsdInstancePort + , bsdPolicyNames + + -- * PolicyAttributeDescription + , PolicyAttributeDescription + , policyAttributeDescription + , padAttributeName + , padAttributeValue + + -- * AdditionalAttribute + , AdditionalAttribute + , additionalAttribute + , aaKey + , aaValue + + -- * ConnectionSettings + , ConnectionSettings + , connectionSettings + , csIdleTimeout + + -- * PolicyTypeDescription + , PolicyTypeDescription + , policyTypeDescription + , ptdDescription + , ptdPolicyAttributeTypeDescriptions + , ptdPolicyTypeName + + -- * Policies + , Policies + , policies + , pAppCookieStickinessPolicies + , pLBCookieStickinessPolicies + , pOtherPolicies + + -- * Listener + , Listener + , listener + , lInstancePort + , lInstanceProtocol + , lLoadBalancerPort + , lProtocol + , lSSLCertificateId + + -- * ConnectionDraining + , ConnectionDraining + , connectionDraining + , cdEnabled + , cdTimeout + + -- * InstanceState + , InstanceState + , instanceState + , isDescription + , isInstanceId + , isReasonCode + , isState + + -- * TagKeyOnly + , TagKeyOnly + , tagKeyOnly + , tkoKey + + -- * Instance + , Instance + , instance' + , iInstanceId + ) where + +import Network.AWS.Error +import Network.AWS.Prelude +import Network.AWS.Signing.V4 +import qualified GHC.Exts + +-- | Version @2012-06-01@ of the Amazon Elastic Load Balancing service. +data ELB + +instance AWSService ELB where + type Sg ELB = V4 + type Er ELB = RESTError + + service = Service + { _svcEndpoint = regional + , _svcAbbrev = "ELB" + , _svcPrefix = "elasticloadbalancing" + , _svcVersion = "2012-06-01" + , _svcTargetPrefix = Nothing + , _svcJSONVersion = Nothing + } + + handle = restError statusSuccess + +ns :: Text +ns = "http://elasticloadbalancing.amazonaws.com/doc/2012-06-01/" + +data SourceSecurityGroup = SourceSecurityGroup + { _ssgGroupName :: Maybe Text + , _ssgOwnerAlias :: Maybe Text + } deriving (Eq, Ord, Show) + +-- | 'SourceSecurityGroup' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'ssgGroupName' @::@ 'Maybe' 'Text' +-- +-- * 'ssgOwnerAlias' @::@ 'Maybe' 'Text' +-- +sourceSecurityGroup :: SourceSecurityGroup +sourceSecurityGroup = SourceSecurityGroup + { _ssgOwnerAlias = Nothing + , _ssgGroupName = Nothing + } + +-- | Name of the source security group. Use this value for the --source-group +-- parameter of the ec2-authorize command in the Amazon EC2 command line +-- tool. +ssgGroupName :: Lens' SourceSecurityGroup (Maybe Text) +ssgGroupName = lens _ssgGroupName (\s a -> s { _ssgGroupName = a }) + +-- | Owner of the source security group. Use this value for the +-- --source-group-user parameter of the ec2-authorize command in the Amazon +-- EC2 command line tool. +ssgOwnerAlias :: Lens' SourceSecurityGroup (Maybe Text) +ssgOwnerAlias = lens _ssgOwnerAlias (\s a -> s { _ssgOwnerAlias = a }) + +instance FromXML SourceSecurityGroup where + parseXML x = SourceSecurityGroup + <$> x .@? "GroupName" + <*> x .@? "OwnerAlias" + +instance ToQuery SourceSecurityGroup where + toQuery SourceSecurityGroup{..} = mconcat + [ "GroupName" =? _ssgGroupName + , "OwnerAlias" =? _ssgOwnerAlias + ] + +data TagDescription = TagDescription + { _tdLoadBalancerName :: Maybe Text + , _tdTags :: List1 "Tags" Tag + } deriving (Eq, Show) + +-- | 'TagDescription' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'tdLoadBalancerName' @::@ 'Maybe' 'Text' +-- +-- * 'tdTags' @::@ 'NonEmpty' 'Tag' +-- +tagDescription :: NonEmpty Tag -- ^ 'tdTags' + -> TagDescription +tagDescription p1 = TagDescription + { _tdTags = withIso _List1 (const id) p1 + , _tdLoadBalancerName = Nothing + } + +-- | The name of the load balancer. +tdLoadBalancerName :: Lens' TagDescription (Maybe Text) +tdLoadBalancerName = + lens _tdLoadBalancerName (\s a -> s { _tdLoadBalancerName = a }) + +-- | List of tags associated with the load balancer. +tdTags :: Lens' TagDescription (NonEmpty Tag) +tdTags = lens _tdTags (\s a -> s { _tdTags = a }) . _List1 + +instance FromXML TagDescription where + parseXML x = TagDescription + <$> x .@? "LoadBalancerName" + <*> x .@ "Tags" + +instance ToQuery TagDescription where + toQuery TagDescription{..} = mconcat + [ "LoadBalancerName" =? _tdLoadBalancerName + , "Tags" =? _tdTags + ] + +data Tag = Tag + { _tagKey :: Text + , _tagValue :: Maybe Text + } deriving (Eq, Ord, Show) + +-- | 'Tag' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'tagKey' @::@ 'Text' +-- +-- * 'tagValue' @::@ 'Maybe' 'Text' +-- +tag :: Text -- ^ 'tagKey' + -> Tag +tag p1 = Tag + { _tagKey = p1 + , _tagValue = Nothing + } + +-- | The key of the tag. +tagKey :: Lens' Tag Text +tagKey = lens _tagKey (\s a -> s { _tagKey = a }) + +-- | The value of the tag. +tagValue :: Lens' Tag (Maybe Text) +tagValue = lens _tagValue (\s a -> s { _tagValue = a }) + +instance FromXML Tag where + parseXML x = Tag + <$> x .@ "Key" + <*> x .@? "Value" + +instance ToQuery Tag where + toQuery Tag{..} = mconcat + [ "Key" =? _tagKey + , "Value" =? _tagValue + ] + +data PolicyAttributeTypeDescription = PolicyAttributeTypeDescription + { _patdAttributeName :: Maybe Text + , _patdAttributeType :: Maybe Text + , _patdCardinality :: Maybe Text + , _patdDefaultValue :: Maybe Text + , _patdDescription :: Maybe Text + } deriving (Eq, Ord, Show) + +-- | 'PolicyAttributeTypeDescription' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'patdAttributeName' @::@ 'Maybe' 'Text' +-- +-- * 'patdAttributeType' @::@ 'Maybe' 'Text' +-- +-- * 'patdCardinality' @::@ 'Maybe' 'Text' +-- +-- * 'patdDefaultValue' @::@ 'Maybe' 'Text' +-- +-- * 'patdDescription' @::@ 'Maybe' 'Text' +-- +policyAttributeTypeDescription :: PolicyAttributeTypeDescription +policyAttributeTypeDescription = PolicyAttributeTypeDescription + { _patdAttributeName = Nothing + , _patdAttributeType = Nothing + , _patdDescription = Nothing + , _patdDefaultValue = Nothing + , _patdCardinality = Nothing + } + +-- | The name of the attribute associated with the policy type. +patdAttributeName :: Lens' PolicyAttributeTypeDescription (Maybe Text) +patdAttributeName = + lens _patdAttributeName (\s a -> s { _patdAttributeName = a }) + +-- | The type of attribute. For example, Boolean, Integer, etc. +patdAttributeType :: Lens' PolicyAttributeTypeDescription (Maybe Text) +patdAttributeType = + lens _patdAttributeType (\s a -> s { _patdAttributeType = a }) + +-- | The cardinality of the attribute. Valid Values: ONE(1) : Single value +-- required ZERO_OR_ONE(0..1) : Up to one value can be supplied +-- ZERO_OR_MORE(0..*) : Optional. Multiple values are allowed +-- ONE_OR_MORE(1..*0) : Required. Multiple values are allowed. +patdCardinality :: Lens' PolicyAttributeTypeDescription (Maybe Text) +patdCardinality = lens _patdCardinality (\s a -> s { _patdCardinality = a }) + +-- | The default value of the attribute, if applicable. +patdDefaultValue :: Lens' PolicyAttributeTypeDescription (Maybe Text) +patdDefaultValue = lens _patdDefaultValue (\s a -> s { _patdDefaultValue = a }) + +-- | A human-readable description of the attribute. +patdDescription :: Lens' PolicyAttributeTypeDescription (Maybe Text) +patdDescription = lens _patdDescription (\s a -> s { _patdDescription = a }) + +instance FromXML PolicyAttributeTypeDescription where + parseXML x = PolicyAttributeTypeDescription + <$> x .@? "AttributeName" + <*> x .@? "AttributeType" + <*> x .@? "Cardinality" + <*> x .@? "DefaultValue" + <*> x .@? "Description" + +instance ToQuery PolicyAttributeTypeDescription where + toQuery PolicyAttributeTypeDescription{..} = mconcat + [ "AttributeName" =? _patdAttributeName + , "AttributeType" =? _patdAttributeType + , "Cardinality" =? _patdCardinality + , "DefaultValue" =? _patdDefaultValue + , "Description" =? _patdDescription + ] + +data HealthCheck = HealthCheck + { _hcHealthyThreshold :: Nat + , _hcInterval :: Nat + , _hcTarget :: Text + , _hcTimeout :: Nat + , _hcUnhealthyThreshold :: Nat + } deriving (Eq, Ord, Show) + +-- | 'HealthCheck' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'hcHealthyThreshold' @::@ 'Natural' +-- +-- * 'hcInterval' @::@ 'Natural' +-- +-- * 'hcTarget' @::@ 'Text' +-- +-- * 'hcTimeout' @::@ 'Natural' +-- +-- * 'hcUnhealthyThreshold' @::@ 'Natural' +-- +healthCheck :: Text -- ^ 'hcTarget' + -> Natural -- ^ 'hcInterval' + -> Natural -- ^ 'hcTimeout' + -> Natural -- ^ 'hcUnhealthyThreshold' + -> Natural -- ^ 'hcHealthyThreshold' + -> HealthCheck +healthCheck p1 p2 p3 p4 p5 = HealthCheck + { _hcTarget = p1 + , _hcInterval = withIso _Nat (const id) p2 + , _hcTimeout = withIso _Nat (const id) p3 + , _hcUnhealthyThreshold = withIso _Nat (const id) p4 + , _hcHealthyThreshold = withIso _Nat (const id) p5 + } + +-- | Specifies the number of consecutive health probe successes required +-- before moving the instance to the Healthy state. +hcHealthyThreshold :: Lens' HealthCheck Natural +hcHealthyThreshold = + lens _hcHealthyThreshold (\s a -> s { _hcHealthyThreshold = a }) + . _Nat + +-- | Specifies the approximate interval, in seconds, between health checks of +-- an individual instance. +hcInterval :: Lens' HealthCheck Natural +hcInterval = lens _hcInterval (\s a -> s { _hcInterval = a }) . _Nat + +-- | Specifies the instance being checked. The protocol is either TCP, HTTP, +-- HTTPS, or SSL. The range of valid ports is one (1) through 65535. TCP is +-- the default, specified as a TCP: port pair, for example "TCP:5000". In +-- this case a healthcheck simply attempts to open a TCP connection to the +-- instance on the specified port. Failure to connect within the configured +-- timeout is considered unhealthy. SSL is also specified as SSL: port pair, +-- for example, SSL:5000. For HTTP or HTTPS protocol, the situation is +-- different. You have to include a ping path in the string. HTTP is +-- specified as a HTTP:port;/;PathToPing; grouping, for example +-- "HTTP:80/weather/us/wa/seattle". In this case, a HTTP GET request is +-- issued to the instance on the given port and path. Any answer other than +-- "200 OK" within the timeout period is considered unhealthy. The total +-- length of the HTTP ping target needs to be 1024 16-bit Unicode characters +-- or less. +hcTarget :: Lens' HealthCheck Text +hcTarget = lens _hcTarget (\s a -> s { _hcTarget = a }) + +-- | Specifies the amount of time, in seconds, during which no response means +-- a failed health probe. This value must be less than the Interval value. +hcTimeout :: Lens' HealthCheck Natural +hcTimeout = lens _hcTimeout (\s a -> s { _hcTimeout = a }) . _Nat + +-- | Specifies the number of consecutive health probe failures required before +-- moving the instance to the Unhealthy state. +hcUnhealthyThreshold :: Lens' HealthCheck Natural +hcUnhealthyThreshold = + lens _hcUnhealthyThreshold (\s a -> s { _hcUnhealthyThreshold = a }) + . _Nat + +instance FromXML HealthCheck where + parseXML x = HealthCheck + <$> x .@ "HealthyThreshold" + <*> x .@ "Interval" + <*> x .@ "Target" + <*> x .@ "Timeout" + <*> x .@ "UnhealthyThreshold" + +instance ToQuery HealthCheck where + toQuery HealthCheck{..} = mconcat + [ "HealthyThreshold" =? _hcHealthyThreshold + , "Interval" =? _hcInterval + , "Target" =? _hcTarget + , "Timeout" =? _hcTimeout + , "UnhealthyThreshold" =? _hcUnhealthyThreshold + ] + +newtype CrossZoneLoadBalancing = CrossZoneLoadBalancing + { _czlbEnabled :: Bool + } deriving (Eq, Ord, Show, Enum) + +-- | 'CrossZoneLoadBalancing' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'czlbEnabled' @::@ 'Bool' +-- +crossZoneLoadBalancing :: Bool -- ^ 'czlbEnabled' + -> CrossZoneLoadBalancing +crossZoneLoadBalancing p1 = CrossZoneLoadBalancing + { _czlbEnabled = p1 + } + +-- | Specifies whether cross-zone load balancing is enabled for the load +-- balancer. +czlbEnabled :: Lens' CrossZoneLoadBalancing Bool +czlbEnabled = lens _czlbEnabled (\s a -> s { _czlbEnabled = a }) + +instance FromXML CrossZoneLoadBalancing where + parseXML x = CrossZoneLoadBalancing + <$> x .@ "Enabled" + +instance ToQuery CrossZoneLoadBalancing where + toQuery CrossZoneLoadBalancing{..} = mconcat + [ "Enabled" =? _czlbEnabled + ] + +data LoadBalancerAttributes = LoadBalancerAttributes + { _lbaAccessLog :: Maybe AccessLog + , _lbaAdditionalAttributes :: List "AdditionalAttributes" AdditionalAttribute + , _lbaConnectionDraining :: Maybe ConnectionDraining + , _lbaConnectionSettings :: Maybe ConnectionSettings + , _lbaCrossZoneLoadBalancing :: Maybe CrossZoneLoadBalancing + } deriving (Eq, Show) + +-- | 'LoadBalancerAttributes' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'lbaAccessLog' @::@ 'Maybe' 'AccessLog' +-- +-- * 'lbaAdditionalAttributes' @::@ ['AdditionalAttribute'] +-- +-- * 'lbaConnectionDraining' @::@ 'Maybe' 'ConnectionDraining' +-- +-- * 'lbaConnectionSettings' @::@ 'Maybe' 'ConnectionSettings' +-- +-- * 'lbaCrossZoneLoadBalancing' @::@ 'Maybe' 'CrossZoneLoadBalancing' +-- +loadBalancerAttributes :: LoadBalancerAttributes +loadBalancerAttributes = LoadBalancerAttributes + { _lbaCrossZoneLoadBalancing = Nothing + , _lbaAccessLog = Nothing + , _lbaConnectionDraining = Nothing + , _lbaConnectionSettings = Nothing + , _lbaAdditionalAttributes = mempty + } + +-- | The name of the load balancer attribute. If enabled, the load balancer +-- captures detailed information of all the requests and delivers the +-- information to the Amazon S3 bucket that you specify. For more +-- information, see Enable Access Logs. +lbaAccessLog :: Lens' LoadBalancerAttributes (Maybe AccessLog) +lbaAccessLog = lens _lbaAccessLog (\s a -> s { _lbaAccessLog = a }) + +lbaAdditionalAttributes :: Lens' LoadBalancerAttributes [AdditionalAttribute] +lbaAdditionalAttributes = + lens _lbaAdditionalAttributes (\s a -> s { _lbaAdditionalAttributes = a }) + . _List + +-- | The name of the load balancer attribute. If enabled, the load balancer +-- allows existing requests to complete before the load balancer shifts +-- traffic away from a deregistered or unhealthy back-end instance. For more +-- information, see Enable Connection Draining. +lbaConnectionDraining :: Lens' LoadBalancerAttributes (Maybe ConnectionDraining) +lbaConnectionDraining = + lens _lbaConnectionDraining (\s a -> s { _lbaConnectionDraining = a }) + +-- | The name of the load balancer attribute. By default, Elastic Load +-- Balancing maintains a 60-second idle connection timeout for both +-- front-end and back-end connections of your load balancer. If the +-- ConnectionSettings attribute is set, Elastic Load Balancing will allow +-- the connections to remain idle (no data is sent over the connection) for +-- the specified duration. For more information, see Configure Idle +-- Connection Timeout. +lbaConnectionSettings :: Lens' LoadBalancerAttributes (Maybe ConnectionSettings) +lbaConnectionSettings = + lens _lbaConnectionSettings (\s a -> s { _lbaConnectionSettings = a }) + +-- | The name of the load balancer attribute. If enabled, the load balancer +-- routes the request traffic evenly across all back-end instances +-- regardless of the Availability Zones. For more information, see Enable +-- Cross-Zone Load Balancing. +lbaCrossZoneLoadBalancing :: Lens' LoadBalancerAttributes (Maybe CrossZoneLoadBalancing) +lbaCrossZoneLoadBalancing = + lens _lbaCrossZoneLoadBalancing + (\s a -> s { _lbaCrossZoneLoadBalancing = a }) + +instance FromXML LoadBalancerAttributes where + parseXML x = LoadBalancerAttributes + <$> x .@? "AccessLog" + <*> x .@ "AdditionalAttributes" + <*> x .@? "ConnectionDraining" + <*> x .@? "ConnectionSettings" + <*> x .@? "CrossZoneLoadBalancing" + +instance ToQuery LoadBalancerAttributes where + toQuery LoadBalancerAttributes{..} = mconcat + [ "AccessLog" =? _lbaAccessLog + , "AdditionalAttributes" =? _lbaAdditionalAttributes + , "ConnectionDraining" =? _lbaConnectionDraining + , "ConnectionSettings" =? _lbaConnectionSettings + , "CrossZoneLoadBalancing" =? _lbaCrossZoneLoadBalancing + ] + +data AccessLog = AccessLog + { _alEmitInterval :: Maybe Int + , _alEnabled :: Bool + , _alS3BucketName :: Maybe Text + , _alS3BucketPrefix :: Maybe Text + } deriving (Eq, Ord, Show) + +-- | 'AccessLog' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'alEmitInterval' @::@ 'Maybe' 'Int' +-- +-- * 'alEnabled' @::@ 'Bool' +-- +-- * 'alS3BucketName' @::@ 'Maybe' 'Text' +-- +-- * 'alS3BucketPrefix' @::@ 'Maybe' 'Text' +-- +accessLog :: Bool -- ^ 'alEnabled' + -> AccessLog +accessLog p1 = AccessLog + { _alEnabled = p1 + , _alS3BucketName = Nothing + , _alEmitInterval = Nothing + , _alS3BucketPrefix = Nothing + } + +-- | The interval for publishing the access logs. You can specify an interval +-- of either 5 minutes or 60 minutes. Default: 60 minutes. +alEmitInterval :: Lens' AccessLog (Maybe Int) +alEmitInterval = lens _alEmitInterval (\s a -> s { _alEmitInterval = a }) + +-- | Specifies whether access log is enabled for the load balancer. +alEnabled :: Lens' AccessLog Bool +alEnabled = lens _alEnabled (\s a -> s { _alEnabled = a }) + +-- | The name of the Amazon S3 bucket where the access logs are stored. +alS3BucketName :: Lens' AccessLog (Maybe Text) +alS3BucketName = lens _alS3BucketName (\s a -> s { _alS3BucketName = a }) + +-- | The logical hierarchy you created for your Amazon S3 bucket, for example +-- my-bucket-prefix/prod. If the prefix is not provided, the log is placed +-- at the root level of the bucket. +alS3BucketPrefix :: Lens' AccessLog (Maybe Text) +alS3BucketPrefix = lens _alS3BucketPrefix (\s a -> s { _alS3BucketPrefix = a }) + +instance FromXML AccessLog where + parseXML x = AccessLog + <$> x .@? "EmitInterval" + <*> x .@ "Enabled" + <*> x .@? "S3BucketName" + <*> x .@? "S3BucketPrefix" + +instance ToQuery AccessLog where + toQuery AccessLog{..} = mconcat + [ "EmitInterval" =? _alEmitInterval + , "Enabled" =? _alEnabled + , "S3BucketName" =? _alS3BucketName + , "S3BucketPrefix" =? _alS3BucketPrefix + ] + +data ListenerDescription = ListenerDescription + { _ldListener :: Maybe Listener + , _ldPolicyNames :: List "PolicyNames" Text + } deriving (Eq, Show) + +-- | 'ListenerDescription' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'ldListener' @::@ 'Maybe' 'Listener' +-- +-- * 'ldPolicyNames' @::@ ['Text'] +-- +listenerDescription :: ListenerDescription +listenerDescription = ListenerDescription + { _ldListener = Nothing + , _ldPolicyNames = mempty + } + +ldListener :: Lens' ListenerDescription (Maybe Listener) +ldListener = lens _ldListener (\s a -> s { _ldListener = a }) + +-- | A list of policies enabled for this listener. An empty list indicates +-- that no policies are enabled. +ldPolicyNames :: Lens' ListenerDescription [Text] +ldPolicyNames = lens _ldPolicyNames (\s a -> s { _ldPolicyNames = a }) . _List + +instance FromXML ListenerDescription where + parseXML x = ListenerDescription + <$> x .@? "Listener" + <*> x .@ "PolicyNames" + +instance ToQuery ListenerDescription where + toQuery ListenerDescription{..} = mconcat + [ "Listener" =? _ldListener + , "PolicyNames" =? _ldPolicyNames + ] + +data LBCookieStickinessPolicy = LBCookieStickinessPolicy + { _lbcspCookieExpirationPeriod :: Maybe Integer + , _lbcspPolicyName :: Maybe Text + } deriving (Eq, Ord, Show) + +-- | 'LBCookieStickinessPolicy' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'lbcspCookieExpirationPeriod' @::@ 'Maybe' 'Integer' +-- +-- * 'lbcspPolicyName' @::@ 'Maybe' 'Text' +-- +lbcookieStickinessPolicy :: LBCookieStickinessPolicy +lbcookieStickinessPolicy = LBCookieStickinessPolicy + { _lbcspPolicyName = Nothing + , _lbcspCookieExpirationPeriod = Nothing + } + +-- | The time period in seconds after which the cookie should be considered +-- stale. Not specifying this parameter indicates that the stickiness +-- session will last for the duration of the browser session. +lbcspCookieExpirationPeriod :: Lens' LBCookieStickinessPolicy (Maybe Integer) +lbcspCookieExpirationPeriod = + lens _lbcspCookieExpirationPeriod + (\s a -> s { _lbcspCookieExpirationPeriod = a }) + +-- | The name for the policy being created. The name must be unique within the +-- set of policies for this load balancer. +lbcspPolicyName :: Lens' LBCookieStickinessPolicy (Maybe Text) +lbcspPolicyName = lens _lbcspPolicyName (\s a -> s { _lbcspPolicyName = a }) + +instance FromXML LBCookieStickinessPolicy where + parseXML x = LBCookieStickinessPolicy + <$> x .@? "CookieExpirationPeriod" + <*> x .@? "PolicyName" + +instance ToQuery LBCookieStickinessPolicy where + toQuery LBCookieStickinessPolicy{..} = mconcat + [ "CookieExpirationPeriod" =? _lbcspCookieExpirationPeriod + , "PolicyName" =? _lbcspPolicyName + ] + +data PolicyDescription = PolicyDescription + { _pdPolicyAttributeDescriptions :: List "PolicyAttributeDescriptions" PolicyAttributeDescription + , _pdPolicyName :: Maybe Text + , _pdPolicyTypeName :: Maybe Text + } deriving (Eq, Show) + +-- | 'PolicyDescription' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'pdPolicyAttributeDescriptions' @::@ ['PolicyAttributeDescription'] +-- +-- * 'pdPolicyName' @::@ 'Maybe' 'Text' +-- +-- * 'pdPolicyTypeName' @::@ 'Maybe' 'Text' +-- +policyDescription :: PolicyDescription +policyDescription = PolicyDescription + { _pdPolicyName = Nothing + , _pdPolicyTypeName = Nothing + , _pdPolicyAttributeDescriptions = mempty + } + +-- | A list of policy attribute description structures. +pdPolicyAttributeDescriptions :: Lens' PolicyDescription [PolicyAttributeDescription] +pdPolicyAttributeDescriptions = + lens _pdPolicyAttributeDescriptions + (\s a -> s { _pdPolicyAttributeDescriptions = a }) + . _List + +-- | The name of the policy associated with the load balancer. +pdPolicyName :: Lens' PolicyDescription (Maybe Text) +pdPolicyName = lens _pdPolicyName (\s a -> s { _pdPolicyName = a }) + +-- | The name of the policy type associated with the load balancer. +pdPolicyTypeName :: Lens' PolicyDescription (Maybe Text) +pdPolicyTypeName = lens _pdPolicyTypeName (\s a -> s { _pdPolicyTypeName = a }) + +instance FromXML PolicyDescription where + parseXML x = PolicyDescription + <$> x .@ "PolicyAttributeDescriptions" + <*> x .@? "PolicyName" + <*> x .@? "PolicyTypeName" + +instance ToQuery PolicyDescription where + toQuery PolicyDescription{..} = mconcat + [ "PolicyAttributeDescriptions" =? _pdPolicyAttributeDescriptions + , "PolicyName" =? _pdPolicyName + , "PolicyTypeName" =? _pdPolicyTypeName + ] + +data AppCookieStickinessPolicy = AppCookieStickinessPolicy + { _acspCookieName :: Maybe Text + , _acspPolicyName :: Maybe Text + } deriving (Eq, Ord, Show) + +-- | 'AppCookieStickinessPolicy' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'acspCookieName' @::@ 'Maybe' 'Text' +-- +-- * 'acspPolicyName' @::@ 'Maybe' 'Text' +-- +appCookieStickinessPolicy :: AppCookieStickinessPolicy +appCookieStickinessPolicy = AppCookieStickinessPolicy + { _acspPolicyName = Nothing + , _acspCookieName = Nothing + } + +-- | The name of the application cookie used for stickiness. +acspCookieName :: Lens' AppCookieStickinessPolicy (Maybe Text) +acspCookieName = lens _acspCookieName (\s a -> s { _acspCookieName = a }) + +-- | The mnemonic name for the policy being created. The name must be unique +-- within a set of policies for this load balancer. +acspPolicyName :: Lens' AppCookieStickinessPolicy (Maybe Text) +acspPolicyName = lens _acspPolicyName (\s a -> s { _acspPolicyName = a }) + +instance FromXML AppCookieStickinessPolicy where + parseXML x = AppCookieStickinessPolicy + <$> x .@? "CookieName" + <*> x .@? "PolicyName" + +instance ToQuery AppCookieStickinessPolicy where + toQuery AppCookieStickinessPolicy{..} = mconcat + [ "CookieName" =? _acspCookieName + , "PolicyName" =? _acspPolicyName + ] + +data PolicyAttribute = PolicyAttribute + { _paAttributeName :: Maybe Text + , _paAttributeValue :: Maybe Text + } deriving (Eq, Ord, Show) + +-- | 'PolicyAttribute' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'paAttributeName' @::@ 'Maybe' 'Text' +-- +-- * 'paAttributeValue' @::@ 'Maybe' 'Text' +-- +policyAttribute :: PolicyAttribute +policyAttribute = PolicyAttribute + { _paAttributeName = Nothing + , _paAttributeValue = Nothing + } + +-- | The name of the attribute associated with the policy. +paAttributeName :: Lens' PolicyAttribute (Maybe Text) +paAttributeName = lens _paAttributeName (\s a -> s { _paAttributeName = a }) + +-- | The value of the attribute associated with the policy. +paAttributeValue :: Lens' PolicyAttribute (Maybe Text) +paAttributeValue = lens _paAttributeValue (\s a -> s { _paAttributeValue = a }) + +instance FromXML PolicyAttribute where + parseXML x = PolicyAttribute + <$> x .@? "AttributeName" + <*> x .@? "AttributeValue" + +instance ToQuery PolicyAttribute where + toQuery PolicyAttribute{..} = mconcat + [ "AttributeName" =? _paAttributeName + , "AttributeValue" =? _paAttributeValue + ] + +data LoadBalancerDescription = LoadBalancerDescription + { _lbdAvailabilityZones :: List "AvailabilityZones" Text + , _lbdBackendServerDescriptions :: List "BackendServerDescriptions" BackendServerDescription + , _lbdCanonicalHostedZoneName :: Maybe Text + , _lbdCanonicalHostedZoneNameID :: Maybe Text + , _lbdCreatedTime :: Maybe RFC822 + , _lbdDNSName :: Maybe Text + , _lbdHealthCheck :: Maybe HealthCheck + , _lbdInstances :: List "Instances" Instance + , _lbdListenerDescriptions :: List "ListenerDescriptions" ListenerDescription + , _lbdLoadBalancerName :: Maybe Text + , _lbdPolicies :: Maybe Policies + , _lbdScheme :: Maybe Text + , _lbdSecurityGroups :: List "SecurityGroups" Text + , _lbdSourceSecurityGroup :: Maybe SourceSecurityGroup + , _lbdSubnets :: List "Subnets" Text + , _lbdVPCId :: Maybe Text + } deriving (Eq, Show) + +-- | 'LoadBalancerDescription' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'lbdAvailabilityZones' @::@ ['Text'] +-- +-- * 'lbdBackendServerDescriptions' @::@ ['BackendServerDescription'] +-- +-- * 'lbdCanonicalHostedZoneName' @::@ 'Maybe' 'Text' +-- +-- * 'lbdCanonicalHostedZoneNameID' @::@ 'Maybe' 'Text' +-- +-- * 'lbdCreatedTime' @::@ 'Maybe' 'UTCTime' +-- +-- * 'lbdDNSName' @::@ 'Maybe' 'Text' +-- +-- * 'lbdHealthCheck' @::@ 'Maybe' 'HealthCheck' +-- +-- * 'lbdInstances' @::@ ['Instance'] +-- +-- * 'lbdListenerDescriptions' @::@ ['ListenerDescription'] +-- +-- * 'lbdLoadBalancerName' @::@ 'Maybe' 'Text' +-- +-- * 'lbdPolicies' @::@ 'Maybe' 'Policies' +-- +-- * 'lbdScheme' @::@ 'Maybe' 'Text' +-- +-- * 'lbdSecurityGroups' @::@ ['Text'] +-- +-- * 'lbdSourceSecurityGroup' @::@ 'Maybe' 'SourceSecurityGroup' +-- +-- * 'lbdSubnets' @::@ ['Text'] +-- +-- * 'lbdVPCId' @::@ 'Maybe' 'Text' +-- +loadBalancerDescription :: LoadBalancerDescription +loadBalancerDescription = LoadBalancerDescription + { _lbdLoadBalancerName = Nothing + , _lbdDNSName = Nothing + , _lbdCanonicalHostedZoneName = Nothing + , _lbdCanonicalHostedZoneNameID = Nothing + , _lbdListenerDescriptions = mempty + , _lbdPolicies = Nothing + , _lbdBackendServerDescriptions = mempty + , _lbdAvailabilityZones = mempty + , _lbdSubnets = mempty + , _lbdVPCId = Nothing + , _lbdInstances = mempty + , _lbdHealthCheck = Nothing + , _lbdSourceSecurityGroup = Nothing + , _lbdSecurityGroups = mempty + , _lbdCreatedTime = Nothing + , _lbdScheme = Nothing + } + +-- | Specifies a list of Availability Zones. +lbdAvailabilityZones :: Lens' LoadBalancerDescription [Text] +lbdAvailabilityZones = + lens _lbdAvailabilityZones (\s a -> s { _lbdAvailabilityZones = a }) + . _List + +-- | Contains a list of back-end server descriptions. +lbdBackendServerDescriptions :: Lens' LoadBalancerDescription [BackendServerDescription] +lbdBackendServerDescriptions = + lens _lbdBackendServerDescriptions + (\s a -> s { _lbdBackendServerDescriptions = a }) + . _List + +-- | Provides the name of the Amazon Route 53 hosted zone that is associated +-- with the load balancer. For information on how to associate your load +-- balancer with a hosted zone, go to Using Domain Names With Elastic Load +-- Balancing in the Elastic Load Balancing Developer Guide. +lbdCanonicalHostedZoneName :: Lens' LoadBalancerDescription (Maybe Text) +lbdCanonicalHostedZoneName = + lens _lbdCanonicalHostedZoneName + (\s a -> s { _lbdCanonicalHostedZoneName = a }) + +-- | Provides the ID of the Amazon Route 53 hosted zone name that is +-- associated with the load balancer. For information on how to associate or +-- disassociate your load balancer with a hosted zone, go to Using Domain +-- Names With Elastic Load Balancing in the Elastic Load Balancing Developer +-- Guide. +lbdCanonicalHostedZoneNameID :: Lens' LoadBalancerDescription (Maybe Text) +lbdCanonicalHostedZoneNameID = + lens _lbdCanonicalHostedZoneNameID + (\s a -> s { _lbdCanonicalHostedZoneNameID = a }) + +-- | Provides the date and time the load balancer was created. +lbdCreatedTime :: Lens' LoadBalancerDescription (Maybe UTCTime) +lbdCreatedTime = lens _lbdCreatedTime (\s a -> s { _lbdCreatedTime = a }) . mapping _Time + +-- | Specifies the external DNS name associated with the load balancer. +lbdDNSName :: Lens' LoadBalancerDescription (Maybe Text) +lbdDNSName = lens _lbdDNSName (\s a -> s { _lbdDNSName = a }) + +-- | Specifies information regarding the various health probes conducted on +-- the load balancer. +lbdHealthCheck :: Lens' LoadBalancerDescription (Maybe HealthCheck) +lbdHealthCheck = lens _lbdHealthCheck (\s a -> s { _lbdHealthCheck = a }) + +-- | Provides a list of EC2 instance IDs for the load balancer. +lbdInstances :: Lens' LoadBalancerDescription [Instance] +lbdInstances = lens _lbdInstances (\s a -> s { _lbdInstances = a }) . _List + +-- | LoadBalancerPort, InstancePort, Protocol, InstanceProtocol, and +-- PolicyNames are returned in a list of tuples in the ListenerDescriptions +-- element. +lbdListenerDescriptions :: Lens' LoadBalancerDescription [ListenerDescription] +lbdListenerDescriptions = + lens _lbdListenerDescriptions (\s a -> s { _lbdListenerDescriptions = a }) + . _List + +-- | Specifies the name associated with the load balancer. +lbdLoadBalancerName :: Lens' LoadBalancerDescription (Maybe Text) +lbdLoadBalancerName = + lens _lbdLoadBalancerName (\s a -> s { _lbdLoadBalancerName = a }) + +-- | Provides a list of policies defined for the load balancer. +lbdPolicies :: Lens' LoadBalancerDescription (Maybe Policies) +lbdPolicies = lens _lbdPolicies (\s a -> s { _lbdPolicies = a }) + +-- | Specifies the type of load balancer. If the Scheme is internet-facing, +-- the load balancer has a publicly resolvable DNS name that resolves to +-- public IP addresses. If the Scheme is internal, the load balancer has a +-- publicly resolvable DNS name that resolves to private IP addresses. This +-- option is only available for load balancers attached to an Amazon VPC. +lbdScheme :: Lens' LoadBalancerDescription (Maybe Text) +lbdScheme = lens _lbdScheme (\s a -> s { _lbdScheme = a }) + +-- | The security groups the load balancer is a member of (VPC only). +lbdSecurityGroups :: Lens' LoadBalancerDescription [Text] +lbdSecurityGroups = + lens _lbdSecurityGroups (\s a -> s { _lbdSecurityGroups = a }) + . _List + +-- | The security group that you can use as part of your inbound rules for +-- your load balancer's back-end Amazon EC2 application instances. To only +-- allow traffic from load balancers, add a security group rule to your back +-- end instance that specifies this source security group as the inbound +-- source. +lbdSourceSecurityGroup :: Lens' LoadBalancerDescription (Maybe SourceSecurityGroup) +lbdSourceSecurityGroup = + lens _lbdSourceSecurityGroup (\s a -> s { _lbdSourceSecurityGroup = a }) + +-- | Provides a list of VPC subnet IDs for the load balancer. +lbdSubnets :: Lens' LoadBalancerDescription [Text] +lbdSubnets = lens _lbdSubnets (\s a -> s { _lbdSubnets = a }) . _List + +-- | Provides the ID of the VPC attached to the load balancer. +lbdVPCId :: Lens' LoadBalancerDescription (Maybe Text) +lbdVPCId = lens _lbdVPCId (\s a -> s { _lbdVPCId = a }) + +instance FromXML LoadBalancerDescription where + parseXML x = LoadBalancerDescription + <$> x .@ "AvailabilityZones" + <*> x .@ "BackendServerDescriptions" + <*> x .@? "CanonicalHostedZoneName" + <*> x .@? "CanonicalHostedZoneNameID" + <*> x .@? "CreatedTime" + <*> x .@? "DNSName" + <*> x .@? "HealthCheck" + <*> x .@ "Instances" + <*> x .@ "ListenerDescriptions" + <*> x .@? "LoadBalancerName" + <*> x .@? "Policies" + <*> x .@? "Scheme" + <*> x .@ "SecurityGroups" + <*> x .@? "SourceSecurityGroup" + <*> x .@ "Subnets" + <*> x .@? "VPCId" + +instance ToQuery LoadBalancerDescription where + toQuery LoadBalancerDescription{..} = mconcat + [ "AvailabilityZones" =? _lbdAvailabilityZones + , "BackendServerDescriptions" =? _lbdBackendServerDescriptions + , "CanonicalHostedZoneName" =? _lbdCanonicalHostedZoneName + , "CanonicalHostedZoneNameID" =? _lbdCanonicalHostedZoneNameID + , "CreatedTime" =? _lbdCreatedTime + , "DNSName" =? _lbdDNSName + , "HealthCheck" =? _lbdHealthCheck + , "Instances" =? _lbdInstances + , "ListenerDescriptions" =? _lbdListenerDescriptions + , "LoadBalancerName" =? _lbdLoadBalancerName + , "Policies" =? _lbdPolicies + , "Scheme" =? _lbdScheme + , "SecurityGroups" =? _lbdSecurityGroups + , "SourceSecurityGroup" =? _lbdSourceSecurityGroup + , "Subnets" =? _lbdSubnets + , "VPCId" =? _lbdVPCId + ] + +data BackendServerDescription = BackendServerDescription + { _bsdInstancePort :: Maybe Nat + , _bsdPolicyNames :: List "PolicyNames" Text + } deriving (Eq, Ord, Show) + +-- | 'BackendServerDescription' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'bsdInstancePort' @::@ 'Maybe' 'Natural' +-- +-- * 'bsdPolicyNames' @::@ ['Text'] +-- +backendServerDescription :: BackendServerDescription +backendServerDescription = BackendServerDescription + { _bsdInstancePort = Nothing + , _bsdPolicyNames = mempty + } + +-- | Provides the port on which the back-end server is listening. +bsdInstancePort :: Lens' BackendServerDescription (Maybe Natural) +bsdInstancePort = lens _bsdInstancePort (\s a -> s { _bsdInstancePort = a }) . mapping _Nat + +-- | Provides a list of policy names enabled for the back-end server. +bsdPolicyNames :: Lens' BackendServerDescription [Text] +bsdPolicyNames = lens _bsdPolicyNames (\s a -> s { _bsdPolicyNames = a }) . _List + +instance FromXML BackendServerDescription where + parseXML x = BackendServerDescription + <$> x .@? "InstancePort" + <*> x .@ "PolicyNames" + +instance ToQuery BackendServerDescription where + toQuery BackendServerDescription{..} = mconcat + [ "InstancePort" =? _bsdInstancePort + , "PolicyNames" =? _bsdPolicyNames + ] + +data PolicyAttributeDescription = PolicyAttributeDescription + { _padAttributeName :: Maybe Text + , _padAttributeValue :: Maybe Text + } deriving (Eq, Ord, Show) + +-- | 'PolicyAttributeDescription' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'padAttributeName' @::@ 'Maybe' 'Text' +-- +-- * 'padAttributeValue' @::@ 'Maybe' 'Text' +-- +policyAttributeDescription :: PolicyAttributeDescription +policyAttributeDescription = PolicyAttributeDescription + { _padAttributeName = Nothing + , _padAttributeValue = Nothing + } + +-- | The name of the attribute associated with the policy. +padAttributeName :: Lens' PolicyAttributeDescription (Maybe Text) +padAttributeName = lens _padAttributeName (\s a -> s { _padAttributeName = a }) + +-- | The value of the attribute associated with the policy. +padAttributeValue :: Lens' PolicyAttributeDescription (Maybe Text) +padAttributeValue = + lens _padAttributeValue (\s a -> s { _padAttributeValue = a }) + +instance FromXML PolicyAttributeDescription where + parseXML x = PolicyAttributeDescription + <$> x .@? "AttributeName" + <*> x .@? "AttributeValue" + +instance ToQuery PolicyAttributeDescription where + toQuery PolicyAttributeDescription{..} = mconcat + [ "AttributeName" =? _padAttributeName + , "AttributeValue" =? _padAttributeValue + ] + +data AdditionalAttribute = AdditionalAttribute + { _aaKey :: Maybe Text + , _aaValue :: Maybe Text + } deriving (Eq, Ord, Show) + +-- | 'AdditionalAttribute' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'aaKey' @::@ 'Maybe' 'Text' +-- +-- * 'aaValue' @::@ 'Maybe' 'Text' +-- +additionalAttribute :: AdditionalAttribute +additionalAttribute = AdditionalAttribute + { _aaKey = Nothing + , _aaValue = Nothing + } + +aaKey :: Lens' AdditionalAttribute (Maybe Text) +aaKey = lens _aaKey (\s a -> s { _aaKey = a }) + +aaValue :: Lens' AdditionalAttribute (Maybe Text) +aaValue = lens _aaValue (\s a -> s { _aaValue = a }) + +instance FromXML AdditionalAttribute where + parseXML x = AdditionalAttribute + <$> x .@? "Key" + <*> x .@? "Value" + +instance ToQuery AdditionalAttribute where + toQuery AdditionalAttribute{..} = mconcat + [ "Key" =? _aaKey + , "Value" =? _aaValue + ] + +newtype ConnectionSettings = ConnectionSettings + { _csIdleTimeout :: Nat + } deriving (Eq, Ord, Show, Enum, Num, Integral, Whole, Real) + +-- | 'ConnectionSettings' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'csIdleTimeout' @::@ 'Natural' +-- +connectionSettings :: Natural -- ^ 'csIdleTimeout' + -> ConnectionSettings +connectionSettings p1 = ConnectionSettings + { _csIdleTimeout = withIso _Nat (const id) p1 + } + +-- | Specifies the time (in seconds) the connection is allowed to be idle (no +-- data has been sent over the connection) before it is closed by the load +-- balancer. +csIdleTimeout :: Lens' ConnectionSettings Natural +csIdleTimeout = lens _csIdleTimeout (\s a -> s { _csIdleTimeout = a }) . _Nat + +instance FromXML ConnectionSettings where + parseXML x = ConnectionSettings + <$> x .@ "IdleTimeout" + +instance ToQuery ConnectionSettings where + toQuery ConnectionSettings{..} = mconcat + [ "IdleTimeout" =? _csIdleTimeout + ] + +data PolicyTypeDescription = PolicyTypeDescription + { _ptdDescription :: Maybe Text + , _ptdPolicyAttributeTypeDescriptions :: List "PolicyAttributeTypeDescriptions" PolicyAttributeTypeDescription + , _ptdPolicyTypeName :: Maybe Text + } deriving (Eq, Show) + +-- | 'PolicyTypeDescription' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'ptdDescription' @::@ 'Maybe' 'Text' +-- +-- * 'ptdPolicyAttributeTypeDescriptions' @::@ ['PolicyAttributeTypeDescription'] +-- +-- * 'ptdPolicyTypeName' @::@ 'Maybe' 'Text' +-- +policyTypeDescription :: PolicyTypeDescription +policyTypeDescription = PolicyTypeDescription + { _ptdPolicyTypeName = Nothing + , _ptdDescription = Nothing + , _ptdPolicyAttributeTypeDescriptions = mempty + } + +-- | A human-readable description of the policy type. +ptdDescription :: Lens' PolicyTypeDescription (Maybe Text) +ptdDescription = lens _ptdDescription (\s a -> s { _ptdDescription = a }) + +-- | The description of the policy attributes associated with the load +-- balancer policies defined by the Elastic Load Balancing service. +ptdPolicyAttributeTypeDescriptions :: Lens' PolicyTypeDescription [PolicyAttributeTypeDescription] +ptdPolicyAttributeTypeDescriptions = + lens _ptdPolicyAttributeTypeDescriptions + (\s a -> s { _ptdPolicyAttributeTypeDescriptions = a }) + . _List + +-- | The name of the policy type. +ptdPolicyTypeName :: Lens' PolicyTypeDescription (Maybe Text) +ptdPolicyTypeName = + lens _ptdPolicyTypeName (\s a -> s { _ptdPolicyTypeName = a }) + +instance FromXML PolicyTypeDescription where + parseXML x = PolicyTypeDescription + <$> x .@? "Description" + <*> x .@ "PolicyAttributeTypeDescriptions" + <*> x .@? "PolicyTypeName" + +instance ToQuery PolicyTypeDescription where + toQuery PolicyTypeDescription{..} = mconcat + [ "Description" =? _ptdDescription + , "PolicyAttributeTypeDescriptions" =? _ptdPolicyAttributeTypeDescriptions + , "PolicyTypeName" =? _ptdPolicyTypeName + ] + +data Policies = Policies + { _pAppCookieStickinessPolicies :: List "AppCookieStickinessPolicies" AppCookieStickinessPolicy + , _pLBCookieStickinessPolicies :: List "LBCookieStickinessPolicies" LBCookieStickinessPolicy + , _pOtherPolicies :: List "PolicyNames" Text + } deriving (Eq, Show) + +-- | 'Policies' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'pAppCookieStickinessPolicies' @::@ ['AppCookieStickinessPolicy'] +-- +-- * 'pLBCookieStickinessPolicies' @::@ ['LBCookieStickinessPolicy'] +-- +-- * 'pOtherPolicies' @::@ ['Text'] +-- +policies :: Policies +policies = Policies + { _pAppCookieStickinessPolicies = mempty + , _pLBCookieStickinessPolicies = mempty + , _pOtherPolicies = mempty + } + +-- | A list of the AppCookieStickinessPolicy objects created with +-- CreateAppCookieStickinessPolicy. +pAppCookieStickinessPolicies :: Lens' Policies [AppCookieStickinessPolicy] +pAppCookieStickinessPolicies = + lens _pAppCookieStickinessPolicies + (\s a -> s { _pAppCookieStickinessPolicies = a }) + . _List + +-- | A list of LBCookieStickinessPolicy objects created with +-- CreateAppCookieStickinessPolicy. +pLBCookieStickinessPolicies :: Lens' Policies [LBCookieStickinessPolicy] +pLBCookieStickinessPolicies = + lens _pLBCookieStickinessPolicies + (\s a -> s { _pLBCookieStickinessPolicies = a }) + . _List + +-- | A list of policy names other than the stickiness policies. +pOtherPolicies :: Lens' Policies [Text] +pOtherPolicies = lens _pOtherPolicies (\s a -> s { _pOtherPolicies = a }) . _List + +instance FromXML Policies where + parseXML x = Policies + <$> x .@ "AppCookieStickinessPolicies" + <*> x .@ "LBCookieStickinessPolicies" + <*> x .@ "OtherPolicies" + +instance ToQuery Policies where + toQuery Policies{..} = mconcat + [ "AppCookieStickinessPolicies" =? _pAppCookieStickinessPolicies + , "LBCookieStickinessPolicies" =? _pLBCookieStickinessPolicies + , "OtherPolicies" =? _pOtherPolicies + ] + +data Listener = Listener + { _lInstancePort :: Nat + , _lInstanceProtocol :: Maybe Text + , _lLoadBalancerPort :: Int + , _lProtocol :: Text + , _lSSLCertificateId :: Maybe Text + } deriving (Eq, Ord, Show) + +-- | 'Listener' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'lInstancePort' @::@ 'Natural' +-- +-- * 'lInstanceProtocol' @::@ 'Maybe' 'Text' +-- +-- * 'lLoadBalancerPort' @::@ 'Int' +-- +-- * 'lProtocol' @::@ 'Text' +-- +-- * 'lSSLCertificateId' @::@ 'Maybe' 'Text' +-- +listener :: Text -- ^ 'lProtocol' + -> Int -- ^ 'lLoadBalancerPort' + -> Natural -- ^ 'lInstancePort' + -> Listener +listener p1 p2 p3 = Listener + { _lProtocol = p1 + , _lLoadBalancerPort = p2 + , _lInstancePort = withIso _Nat (const id) p3 + , _lInstanceProtocol = Nothing + , _lSSLCertificateId = Nothing + } + +-- | Specifies the TCP port on which the instance server is listening. This +-- property cannot be modified for the life of the load balancer. +lInstancePort :: Lens' Listener Natural +lInstancePort = lens _lInstancePort (\s a -> s { _lInstancePort = a }) . _Nat + +-- | Specifies the protocol to use for routing traffic to back-end instances - +-- HTTP, HTTPS, TCP, or SSL. This property cannot be modified for the life +-- of the load balancer. If the front-end protocol is HTTP or HTTPS, +-- InstanceProtocol has to be at the same protocol layer, i.e., HTTP or +-- HTTPS. Likewise, if the front-end protocol is TCP or SSL, +-- InstanceProtocol has to be TCP or SSL. If there is another listener with +-- the same InstancePort whose InstanceProtocol is secure, i.e., HTTPS or +-- SSL, the listener's InstanceProtocol has to be secure, i.e., HTTPS or +-- SSL. If there is another listener with the same InstancePort whose +-- InstanceProtocol is HTTP or TCP, the listener's InstanceProtocol must be +-- either HTTP or TCP. +lInstanceProtocol :: Lens' Listener (Maybe Text) +lInstanceProtocol = + lens _lInstanceProtocol (\s a -> s { _lInstanceProtocol = a }) + +-- | Specifies the external load balancer port number. This property cannot be +-- modified for the life of the load balancer. +lLoadBalancerPort :: Lens' Listener Int +lLoadBalancerPort = + lens _lLoadBalancerPort (\s a -> s { _lLoadBalancerPort = a }) + +-- | Specifies the load balancer transport protocol to use for routing - HTTP, +-- HTTPS, TCP or SSL. This property cannot be modified for the life of the +-- load balancer. +lProtocol :: Lens' Listener Text +lProtocol = lens _lProtocol (\s a -> s { _lProtocol = a }) + +-- | The ARN string of the server certificate. To get the ARN of the server +-- certificate, call the AWS Identity and Access Management +-- UploadServerCertificate API. +lSSLCertificateId :: Lens' Listener (Maybe Text) +lSSLCertificateId = + lens _lSSLCertificateId (\s a -> s { _lSSLCertificateId = a }) + +instance FromXML Listener where + parseXML x = Listener + <$> x .@ "InstancePort" + <*> x .@? "InstanceProtocol" + <*> x .@ "LoadBalancerPort" + <*> x .@ "Protocol" + <*> x .@? "SSLCertificateId" + +instance ToQuery Listener where + toQuery Listener{..} = mconcat + [ "InstancePort" =? _lInstancePort + , "InstanceProtocol" =? _lInstanceProtocol + , "LoadBalancerPort" =? _lLoadBalancerPort + , "Protocol" =? _lProtocol + , "SSLCertificateId" =? _lSSLCertificateId + ] + +data ConnectionDraining = ConnectionDraining + { _cdEnabled :: Bool + , _cdTimeout :: Maybe Int + } deriving (Eq, Ord, Show) + +-- | 'ConnectionDraining' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'cdEnabled' @::@ 'Bool' +-- +-- * 'cdTimeout' @::@ 'Maybe' 'Int' +-- +connectionDraining :: Bool -- ^ 'cdEnabled' + -> ConnectionDraining +connectionDraining p1 = ConnectionDraining + { _cdEnabled = p1 + , _cdTimeout = Nothing + } + +-- | Specifies whether connection draining is enabled for the load balancer. +cdEnabled :: Lens' ConnectionDraining Bool +cdEnabled = lens _cdEnabled (\s a -> s { _cdEnabled = a }) + +-- | Specifies the maximum time (in seconds) to keep the existing connections +-- open before deregistering the instances. +cdTimeout :: Lens' ConnectionDraining (Maybe Int) +cdTimeout = lens _cdTimeout (\s a -> s { _cdTimeout = a }) + +instance FromXML ConnectionDraining where + parseXML x = ConnectionDraining + <$> x .@ "Enabled" + <*> x .@? "Timeout" + +instance ToQuery ConnectionDraining where + toQuery ConnectionDraining{..} = mconcat + [ "Enabled" =? _cdEnabled + , "Timeout" =? _cdTimeout + ] + +data InstanceState = InstanceState + { _isDescription :: Maybe Text + , _isInstanceId :: Maybe Text + , _isReasonCode :: Maybe Text + , _isState :: Maybe Text + } deriving (Eq, Ord, Show) + +-- | 'InstanceState' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'isDescription' @::@ 'Maybe' 'Text' +-- +-- * 'isInstanceId' @::@ 'Maybe' 'Text' +-- +-- * 'isReasonCode' @::@ 'Maybe' 'Text' +-- +-- * 'isState' @::@ 'Maybe' 'Text' +-- +instanceState :: InstanceState +instanceState = InstanceState + { _isInstanceId = Nothing + , _isState = Nothing + , _isReasonCode = Nothing + , _isDescription = Nothing + } + +-- | Provides a description of the instance state. +isDescription :: Lens' InstanceState (Maybe Text) +isDescription = lens _isDescription (\s a -> s { _isDescription = a }) + +-- | Provides an EC2 instance ID. +isInstanceId :: Lens' InstanceState (Maybe Text) +isInstanceId = lens _isInstanceId (\s a -> s { _isInstanceId = a }) + +-- | Provides information about the cause of OutOfService instances. +-- Specifically, it indicates whether the cause is Elastic Load Balancing or +-- the instance behind the load balancer. Valid value: ELB|Instance|N/A. +isReasonCode :: Lens' InstanceState (Maybe Text) +isReasonCode = lens _isReasonCode (\s a -> s { _isReasonCode = a }) + +-- | Specifies the current state of the instance. Valid value: +-- InService|OutOfService|Unknown. +isState :: Lens' InstanceState (Maybe Text) +isState = lens _isState (\s a -> s { _isState = a }) + +instance FromXML InstanceState where + parseXML x = InstanceState + <$> x .@? "Description" + <*> x .@? "InstanceId" + <*> x .@? "ReasonCode" + <*> x .@? "State" + +instance ToQuery InstanceState where + toQuery InstanceState{..} = mconcat + [ "Description" =? _isDescription + , "InstanceId" =? _isInstanceId + , "ReasonCode" =? _isReasonCode + , "State" =? _isState + ] + +newtype TagKeyOnly = TagKeyOnly + { _tkoKey :: Maybe Text + } deriving (Eq, Ord, Show, Monoid) + +-- | 'TagKeyOnly' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'tkoKey' @::@ 'Maybe' 'Text' +-- +tagKeyOnly :: TagKeyOnly +tagKeyOnly = TagKeyOnly + { _tkoKey = Nothing + } + +-- | The name of the key. +tkoKey :: Lens' TagKeyOnly (Maybe Text) +tkoKey = lens _tkoKey (\s a -> s { _tkoKey = a }) + +instance FromXML TagKeyOnly where + parseXML x = TagKeyOnly + <$> x .@? "Key" + +instance ToQuery TagKeyOnly where + toQuery TagKeyOnly{..} = mconcat + [ "Key" =? _tkoKey + ] + +newtype Instance = Instance + { _iInstanceId :: Maybe Text + } deriving (Eq, Ord, Show, Monoid) + +-- | 'Instance' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'iInstanceId' @::@ 'Maybe' 'Text' +-- +instance' :: Instance +instance' = Instance + { _iInstanceId = Nothing + } + +-- | Provides an EC2 instance ID. +iInstanceId :: Lens' Instance (Maybe Text) +iInstanceId = lens _iInstanceId (\s a -> s { _iInstanceId = a }) + +instance FromXML Instance where + parseXML x = Instance + <$> x .@? "InstanceId" + +instance ToQuery Instance where + toQuery Instance{..} = mconcat + [ "InstanceId" =? _iInstanceId + ]