{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.EC2.Types.SecurityGroup
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.EC2.Types.SecurityGroup where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.EC2.Internal
import Amazonka.EC2.Types.IpPermission
import Amazonka.EC2.Types.Tag
import qualified Amazonka.Prelude as Prelude

-- | Describes a security group.
--
-- /See:/ 'newSecurityGroup' smart constructor.
data SecurityGroup = SecurityGroup'
  { -- | The inbound rules associated with the security group.
    SecurityGroup -> Maybe [IpPermission]
ipPermissions :: Prelude.Maybe [IpPermission],
    -- | [VPC only] The outbound rules associated with the security group.
    SecurityGroup -> Maybe [IpPermission]
ipPermissionsEgress :: Prelude.Maybe [IpPermission],
    -- | Any tags assigned to the security group.
    SecurityGroup -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | [VPC only] The ID of the VPC for the security group.
    SecurityGroup -> Maybe Text
vpcId :: Prelude.Maybe Prelude.Text,
    -- | The Amazon Web Services account ID of the owner of the security group.
    SecurityGroup -> Text
ownerId :: Prelude.Text,
    -- | The ID of the security group.
    SecurityGroup -> Text
groupId :: Prelude.Text,
    -- | The name of the security group.
    SecurityGroup -> Text
groupName :: Prelude.Text,
    -- | A description of the security group.
    SecurityGroup -> Text
description :: Prelude.Text
  }
  deriving (SecurityGroup -> SecurityGroup -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SecurityGroup -> SecurityGroup -> Bool
$c/= :: SecurityGroup -> SecurityGroup -> Bool
== :: SecurityGroup -> SecurityGroup -> Bool
$c== :: SecurityGroup -> SecurityGroup -> Bool
Prelude.Eq, ReadPrec [SecurityGroup]
ReadPrec SecurityGroup
Int -> ReadS SecurityGroup
ReadS [SecurityGroup]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SecurityGroup]
$creadListPrec :: ReadPrec [SecurityGroup]
readPrec :: ReadPrec SecurityGroup
$creadPrec :: ReadPrec SecurityGroup
readList :: ReadS [SecurityGroup]
$creadList :: ReadS [SecurityGroup]
readsPrec :: Int -> ReadS SecurityGroup
$creadsPrec :: Int -> ReadS SecurityGroup
Prelude.Read, Int -> SecurityGroup -> ShowS
[SecurityGroup] -> ShowS
SecurityGroup -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SecurityGroup] -> ShowS
$cshowList :: [SecurityGroup] -> ShowS
show :: SecurityGroup -> String
$cshow :: SecurityGroup -> String
showsPrec :: Int -> SecurityGroup -> ShowS
$cshowsPrec :: Int -> SecurityGroup -> ShowS
Prelude.Show, forall x. Rep SecurityGroup x -> SecurityGroup
forall x. SecurityGroup -> Rep SecurityGroup x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SecurityGroup x -> SecurityGroup
$cfrom :: forall x. SecurityGroup -> Rep SecurityGroup x
Prelude.Generic)

-- |
-- Create a value of 'SecurityGroup' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'ipPermissions', 'securityGroup_ipPermissions' - The inbound rules associated with the security group.
--
-- 'ipPermissionsEgress', 'securityGroup_ipPermissionsEgress' - [VPC only] The outbound rules associated with the security group.
--
-- 'tags', 'securityGroup_tags' - Any tags assigned to the security group.
--
-- 'vpcId', 'securityGroup_vpcId' - [VPC only] The ID of the VPC for the security group.
--
-- 'ownerId', 'securityGroup_ownerId' - The Amazon Web Services account ID of the owner of the security group.
--
-- 'groupId', 'securityGroup_groupId' - The ID of the security group.
--
-- 'groupName', 'securityGroup_groupName' - The name of the security group.
--
-- 'description', 'securityGroup_description' - A description of the security group.
newSecurityGroup ::
  -- | 'ownerId'
  Prelude.Text ->
  -- | 'groupId'
  Prelude.Text ->
  -- | 'groupName'
  Prelude.Text ->
  -- | 'description'
  Prelude.Text ->
  SecurityGroup
newSecurityGroup :: Text -> Text -> Text -> Text -> SecurityGroup
newSecurityGroup
  Text
pOwnerId_
  Text
pGroupId_
  Text
pGroupName_
  Text
pDescription_ =
    SecurityGroup'
      { $sel:ipPermissions:SecurityGroup' :: Maybe [IpPermission]
ipPermissions = forall a. Maybe a
Prelude.Nothing,
        $sel:ipPermissionsEgress:SecurityGroup' :: Maybe [IpPermission]
ipPermissionsEgress = forall a. Maybe a
Prelude.Nothing,
        $sel:tags:SecurityGroup' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:vpcId:SecurityGroup' :: Maybe Text
vpcId = forall a. Maybe a
Prelude.Nothing,
        $sel:ownerId:SecurityGroup' :: Text
ownerId = Text
pOwnerId_,
        $sel:groupId:SecurityGroup' :: Text
groupId = Text
pGroupId_,
        $sel:groupName:SecurityGroup' :: Text
groupName = Text
pGroupName_,
        $sel:description:SecurityGroup' :: Text
description = Text
pDescription_
      }

-- | The inbound rules associated with the security group.
securityGroup_ipPermissions :: Lens.Lens' SecurityGroup (Prelude.Maybe [IpPermission])
securityGroup_ipPermissions :: Lens' SecurityGroup (Maybe [IpPermission])
securityGroup_ipPermissions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SecurityGroup' {Maybe [IpPermission]
ipPermissions :: Maybe [IpPermission]
$sel:ipPermissions:SecurityGroup' :: SecurityGroup -> Maybe [IpPermission]
ipPermissions} -> Maybe [IpPermission]
ipPermissions) (\s :: SecurityGroup
s@SecurityGroup' {} Maybe [IpPermission]
a -> SecurityGroup
s {$sel:ipPermissions:SecurityGroup' :: Maybe [IpPermission]
ipPermissions = Maybe [IpPermission]
a} :: SecurityGroup) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | [VPC only] The outbound rules associated with the security group.
securityGroup_ipPermissionsEgress :: Lens.Lens' SecurityGroup (Prelude.Maybe [IpPermission])
securityGroup_ipPermissionsEgress :: Lens' SecurityGroup (Maybe [IpPermission])
securityGroup_ipPermissionsEgress = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SecurityGroup' {Maybe [IpPermission]
ipPermissionsEgress :: Maybe [IpPermission]
$sel:ipPermissionsEgress:SecurityGroup' :: SecurityGroup -> Maybe [IpPermission]
ipPermissionsEgress} -> Maybe [IpPermission]
ipPermissionsEgress) (\s :: SecurityGroup
s@SecurityGroup' {} Maybe [IpPermission]
a -> SecurityGroup
s {$sel:ipPermissionsEgress:SecurityGroup' :: Maybe [IpPermission]
ipPermissionsEgress = Maybe [IpPermission]
a} :: SecurityGroup) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Any tags assigned to the security group.
securityGroup_tags :: Lens.Lens' SecurityGroup (Prelude.Maybe [Tag])
securityGroup_tags :: Lens' SecurityGroup (Maybe [Tag])
securityGroup_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SecurityGroup' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:SecurityGroup' :: SecurityGroup -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: SecurityGroup
s@SecurityGroup' {} Maybe [Tag]
a -> SecurityGroup
s {$sel:tags:SecurityGroup' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: SecurityGroup) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | [VPC only] The ID of the VPC for the security group.
securityGroup_vpcId :: Lens.Lens' SecurityGroup (Prelude.Maybe Prelude.Text)
securityGroup_vpcId :: Lens' SecurityGroup (Maybe Text)
securityGroup_vpcId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SecurityGroup' {Maybe Text
vpcId :: Maybe Text
$sel:vpcId:SecurityGroup' :: SecurityGroup -> Maybe Text
vpcId} -> Maybe Text
vpcId) (\s :: SecurityGroup
s@SecurityGroup' {} Maybe Text
a -> SecurityGroup
s {$sel:vpcId:SecurityGroup' :: Maybe Text
vpcId = Maybe Text
a} :: SecurityGroup)

-- | The Amazon Web Services account ID of the owner of the security group.
securityGroup_ownerId :: Lens.Lens' SecurityGroup Prelude.Text
securityGroup_ownerId :: Lens' SecurityGroup Text
securityGroup_ownerId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SecurityGroup' {Text
ownerId :: Text
$sel:ownerId:SecurityGroup' :: SecurityGroup -> Text
ownerId} -> Text
ownerId) (\s :: SecurityGroup
s@SecurityGroup' {} Text
a -> SecurityGroup
s {$sel:ownerId:SecurityGroup' :: Text
ownerId = Text
a} :: SecurityGroup)

-- | The ID of the security group.
securityGroup_groupId :: Lens.Lens' SecurityGroup Prelude.Text
securityGroup_groupId :: Lens' SecurityGroup Text
securityGroup_groupId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SecurityGroup' {Text
groupId :: Text
$sel:groupId:SecurityGroup' :: SecurityGroup -> Text
groupId} -> Text
groupId) (\s :: SecurityGroup
s@SecurityGroup' {} Text
a -> SecurityGroup
s {$sel:groupId:SecurityGroup' :: Text
groupId = Text
a} :: SecurityGroup)

-- | The name of the security group.
securityGroup_groupName :: Lens.Lens' SecurityGroup Prelude.Text
securityGroup_groupName :: Lens' SecurityGroup Text
securityGroup_groupName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SecurityGroup' {Text
groupName :: Text
$sel:groupName:SecurityGroup' :: SecurityGroup -> Text
groupName} -> Text
groupName) (\s :: SecurityGroup
s@SecurityGroup' {} Text
a -> SecurityGroup
s {$sel:groupName:SecurityGroup' :: Text
groupName = Text
a} :: SecurityGroup)

-- | A description of the security group.
securityGroup_description :: Lens.Lens' SecurityGroup Prelude.Text
securityGroup_description :: Lens' SecurityGroup Text
securityGroup_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SecurityGroup' {Text
description :: Text
$sel:description:SecurityGroup' :: SecurityGroup -> Text
description} -> Text
description) (\s :: SecurityGroup
s@SecurityGroup' {} Text
a -> SecurityGroup
s {$sel:description:SecurityGroup' :: Text
description = Text
a} :: SecurityGroup)

instance Data.FromXML SecurityGroup where
  parseXML :: [Node] -> Either String SecurityGroup
parseXML [Node]
x =
    Maybe [IpPermission]
-> Maybe [IpPermission]
-> Maybe [Tag]
-> Maybe Text
-> Text
-> Text
-> Text
-> Text
-> SecurityGroup
SecurityGroup'
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"ipPermissions"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"item")
                  )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"ipPermissionsEgress"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"item")
                  )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"tagSet"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"item")
                  )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"vpcId")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String a
Data..@ Text
"ownerId")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String a
Data..@ Text
"groupId")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String a
Data..@ Text
"groupName")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String a
Data..@ Text
"groupDescription")

instance Prelude.Hashable SecurityGroup where
  hashWithSalt :: Int -> SecurityGroup -> Int
hashWithSalt Int
_salt SecurityGroup' {Maybe [Tag]
Maybe [IpPermission]
Maybe Text
Text
description :: Text
groupName :: Text
groupId :: Text
ownerId :: Text
vpcId :: Maybe Text
tags :: Maybe [Tag]
ipPermissionsEgress :: Maybe [IpPermission]
ipPermissions :: Maybe [IpPermission]
$sel:description:SecurityGroup' :: SecurityGroup -> Text
$sel:groupName:SecurityGroup' :: SecurityGroup -> Text
$sel:groupId:SecurityGroup' :: SecurityGroup -> Text
$sel:ownerId:SecurityGroup' :: SecurityGroup -> Text
$sel:vpcId:SecurityGroup' :: SecurityGroup -> Maybe Text
$sel:tags:SecurityGroup' :: SecurityGroup -> Maybe [Tag]
$sel:ipPermissionsEgress:SecurityGroup' :: SecurityGroup -> Maybe [IpPermission]
$sel:ipPermissions:SecurityGroup' :: SecurityGroup -> Maybe [IpPermission]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [IpPermission]
ipPermissions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [IpPermission]
ipPermissionsEgress
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
vpcId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
ownerId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
groupId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
groupName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
description

instance Prelude.NFData SecurityGroup where
  rnf :: SecurityGroup -> ()
rnf SecurityGroup' {Maybe [Tag]
Maybe [IpPermission]
Maybe Text
Text
description :: Text
groupName :: Text
groupId :: Text
ownerId :: Text
vpcId :: Maybe Text
tags :: Maybe [Tag]
ipPermissionsEgress :: Maybe [IpPermission]
ipPermissions :: Maybe [IpPermission]
$sel:description:SecurityGroup' :: SecurityGroup -> Text
$sel:groupName:SecurityGroup' :: SecurityGroup -> Text
$sel:groupId:SecurityGroup' :: SecurityGroup -> Text
$sel:ownerId:SecurityGroup' :: SecurityGroup -> Text
$sel:vpcId:SecurityGroup' :: SecurityGroup -> Maybe Text
$sel:tags:SecurityGroup' :: SecurityGroup -> Maybe [Tag]
$sel:ipPermissionsEgress:SecurityGroup' :: SecurityGroup -> Maybe [IpPermission]
$sel:ipPermissions:SecurityGroup' :: SecurityGroup -> Maybe [IpPermission]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [IpPermission]
ipPermissions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [IpPermission]
ipPermissionsEgress
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Tag]
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
vpcId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
ownerId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
groupId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
groupName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
description