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

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

-- |
-- Module      : Amazonka.Kinesis.SplitShard
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Splits a shard into two new shards in the Kinesis data stream, to
-- increase the stream\'s capacity to ingest and transport data.
-- @SplitShard@ is called when there is a need to increase the overall
-- capacity of a stream because of an expected increase in the volume of
-- data records being ingested.
--
-- You can also use @SplitShard@ when a shard appears to be approaching its
-- maximum utilization; for example, the producers sending data into the
-- specific shard are suddenly sending more than previously anticipated.
-- You can also call @SplitShard@ to increase stream capacity, so that more
-- Kinesis Data Streams applications can simultaneously read data from the
-- stream for real-time processing.
--
-- You must specify the shard to be split and the new hash key, which is
-- the position in the shard where the shard gets split in two. In many
-- cases, the new hash key might be the average of the beginning and ending
-- hash key, but it can be any hash key value in the range being mapped
-- into the shard. For more information, see
-- <https://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-resharding-split.html Split a Shard>
-- in the /Amazon Kinesis Data Streams Developer Guide/.
--
-- You can use DescribeStream to determine the shard ID and hash key values
-- for the @ShardToSplit@ and @NewStartingHashKey@ parameters that are
-- specified in the @SplitShard@ request.
--
-- @SplitShard@ is an asynchronous operation. Upon receiving a @SplitShard@
-- request, Kinesis Data Streams immediately returns a response and sets
-- the stream status to @UPDATING@. After the operation is completed,
-- Kinesis Data Streams sets the stream status to @ACTIVE@. Read and write
-- operations continue to work while the stream is in the @UPDATING@ state.
--
-- You can use @DescribeStream@ to check the status of the stream, which is
-- returned in @StreamStatus@. If the stream is in the @ACTIVE@ state, you
-- can call @SplitShard@. If a stream is in @CREATING@ or @UPDATING@ or
-- @DELETING@ states, @DescribeStream@ returns a @ResourceInUseException@.
--
-- If the specified stream does not exist, @DescribeStream@ returns a
-- @ResourceNotFoundException@. If you try to create more shards than are
-- authorized for your account, you receive a @LimitExceededException@.
--
-- For the default shard limit for an AWS account, see
-- <https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html Kinesis Data Streams Limits>
-- in the /Amazon Kinesis Data Streams Developer Guide/. To increase this
-- limit,
-- <https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html contact AWS Support>.
--
-- If you try to operate on too many streams simultaneously using
-- CreateStream, DeleteStream, MergeShards, and\/or SplitShard, you receive
-- a @LimitExceededException@.
--
-- @SplitShard@ has a limit of five transactions per second per account.
module Amazonka.Kinesis.SplitShard
  ( -- * Creating a Request
    SplitShard (..),
    newSplitShard,

    -- * Request Lenses
    splitShard_streamName,
    splitShard_shardToSplit,
    splitShard_newStartingHashKey,

    -- * Destructuring the Response
    SplitShardResponse (..),
    newSplitShardResponse,
  )
where

import qualified Amazonka.Core as Core
import Amazonka.Kinesis.Types
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | Represents the input for @SplitShard@.
--
-- /See:/ 'newSplitShard' smart constructor.
data SplitShard = SplitShard'
  { -- | The name of the stream for the shard split.
    SplitShard -> Text
streamName :: Prelude.Text,
    -- | The shard ID of the shard to split.
    SplitShard -> Text
shardToSplit :: Prelude.Text,
    -- | A hash key value for the starting hash key of one of the child shards
    -- created by the split. The hash key range for a given shard constitutes a
    -- set of ordered contiguous positive integers. The value for
    -- @NewStartingHashKey@ must be in the range of hash keys being mapped into
    -- the shard. The @NewStartingHashKey@ hash key value and all higher hash
    -- key values in hash key range are distributed to one of the child shards.
    -- All the lower hash key values in the range are distributed to the other
    -- child shard.
    SplitShard -> Text
newStartingHashKey' :: Prelude.Text
  }
  deriving (SplitShard -> SplitShard -> Bool
(SplitShard -> SplitShard -> Bool)
-> (SplitShard -> SplitShard -> Bool) -> Eq SplitShard
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SplitShard -> SplitShard -> Bool
$c/= :: SplitShard -> SplitShard -> Bool
== :: SplitShard -> SplitShard -> Bool
$c== :: SplitShard -> SplitShard -> Bool
Prelude.Eq, ReadPrec [SplitShard]
ReadPrec SplitShard
Int -> ReadS SplitShard
ReadS [SplitShard]
(Int -> ReadS SplitShard)
-> ReadS [SplitShard]
-> ReadPrec SplitShard
-> ReadPrec [SplitShard]
-> Read SplitShard
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SplitShard]
$creadListPrec :: ReadPrec [SplitShard]
readPrec :: ReadPrec SplitShard
$creadPrec :: ReadPrec SplitShard
readList :: ReadS [SplitShard]
$creadList :: ReadS [SplitShard]
readsPrec :: Int -> ReadS SplitShard
$creadsPrec :: Int -> ReadS SplitShard
Prelude.Read, Int -> SplitShard -> ShowS
[SplitShard] -> ShowS
SplitShard -> String
(Int -> SplitShard -> ShowS)
-> (SplitShard -> String)
-> ([SplitShard] -> ShowS)
-> Show SplitShard
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SplitShard] -> ShowS
$cshowList :: [SplitShard] -> ShowS
show :: SplitShard -> String
$cshow :: SplitShard -> String
showsPrec :: Int -> SplitShard -> ShowS
$cshowsPrec :: Int -> SplitShard -> ShowS
Prelude.Show, (forall x. SplitShard -> Rep SplitShard x)
-> (forall x. Rep SplitShard x -> SplitShard) -> Generic SplitShard
forall x. Rep SplitShard x -> SplitShard
forall x. SplitShard -> Rep SplitShard x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SplitShard x -> SplitShard
$cfrom :: forall x. SplitShard -> Rep SplitShard x
Prelude.Generic)

-- |
-- Create a value of 'SplitShard' 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:
--
-- 'streamName', 'splitShard_streamName' - The name of the stream for the shard split.
--
-- 'shardToSplit', 'splitShard_shardToSplit' - The shard ID of the shard to split.
--
-- 'newStartingHashKey'', 'splitShard_newStartingHashKey' - A hash key value for the starting hash key of one of the child shards
-- created by the split. The hash key range for a given shard constitutes a
-- set of ordered contiguous positive integers. The value for
-- @NewStartingHashKey@ must be in the range of hash keys being mapped into
-- the shard. The @NewStartingHashKey@ hash key value and all higher hash
-- key values in hash key range are distributed to one of the child shards.
-- All the lower hash key values in the range are distributed to the other
-- child shard.
newSplitShard ::
  -- | 'streamName'
  Prelude.Text ->
  -- | 'shardToSplit'
  Prelude.Text ->
  -- | 'newStartingHashKey''
  Prelude.Text ->
  SplitShard
newSplitShard :: Text -> Text -> Text -> SplitShard
newSplitShard
  Text
pStreamName_
  Text
pShardToSplit_
  Text
pNewStartingHashKey_ =
    SplitShard' :: Text -> Text -> Text -> SplitShard
SplitShard'
      { $sel:streamName:SplitShard' :: Text
streamName = Text
pStreamName_,
        $sel:shardToSplit:SplitShard' :: Text
shardToSplit = Text
pShardToSplit_,
        $sel:newStartingHashKey':SplitShard' :: Text
newStartingHashKey' = Text
pNewStartingHashKey_
      }

-- | The name of the stream for the shard split.
splitShard_streamName :: Lens.Lens' SplitShard Prelude.Text
splitShard_streamName :: (Text -> f Text) -> SplitShard -> f SplitShard
splitShard_streamName = (SplitShard -> Text)
-> (SplitShard -> Text -> SplitShard)
-> Lens SplitShard SplitShard Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SplitShard' {Text
streamName :: Text
$sel:streamName:SplitShard' :: SplitShard -> Text
streamName} -> Text
streamName) (\s :: SplitShard
s@SplitShard' {} Text
a -> SplitShard
s {$sel:streamName:SplitShard' :: Text
streamName = Text
a} :: SplitShard)

-- | The shard ID of the shard to split.
splitShard_shardToSplit :: Lens.Lens' SplitShard Prelude.Text
splitShard_shardToSplit :: (Text -> f Text) -> SplitShard -> f SplitShard
splitShard_shardToSplit = (SplitShard -> Text)
-> (SplitShard -> Text -> SplitShard)
-> Lens SplitShard SplitShard Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SplitShard' {Text
shardToSplit :: Text
$sel:shardToSplit:SplitShard' :: SplitShard -> Text
shardToSplit} -> Text
shardToSplit) (\s :: SplitShard
s@SplitShard' {} Text
a -> SplitShard
s {$sel:shardToSplit:SplitShard' :: Text
shardToSplit = Text
a} :: SplitShard)

-- | A hash key value for the starting hash key of one of the child shards
-- created by the split. The hash key range for a given shard constitutes a
-- set of ordered contiguous positive integers. The value for
-- @NewStartingHashKey@ must be in the range of hash keys being mapped into
-- the shard. The @NewStartingHashKey@ hash key value and all higher hash
-- key values in hash key range are distributed to one of the child shards.
-- All the lower hash key values in the range are distributed to the other
-- child shard.
splitShard_newStartingHashKey :: Lens.Lens' SplitShard Prelude.Text
splitShard_newStartingHashKey :: (Text -> f Text) -> SplitShard -> f SplitShard
splitShard_newStartingHashKey = (SplitShard -> Text)
-> (SplitShard -> Text -> SplitShard)
-> Lens SplitShard SplitShard Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SplitShard' {Text
newStartingHashKey' :: Text
$sel:newStartingHashKey':SplitShard' :: SplitShard -> Text
newStartingHashKey'} -> Text
newStartingHashKey') (\s :: SplitShard
s@SplitShard' {} Text
a -> SplitShard
s {$sel:newStartingHashKey':SplitShard' :: Text
newStartingHashKey' = Text
a} :: SplitShard)

instance Core.AWSRequest SplitShard where
  type AWSResponse SplitShard = SplitShardResponse
  request :: SplitShard -> Request SplitShard
request = Service -> SplitShard -> Request SplitShard
forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON Service
defaultService
  response :: Logger
-> Service
-> Proxy SplitShard
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse SplitShard)))
response = AWSResponse SplitShard
-> Logger
-> Service
-> Proxy SplitShard
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse SplitShard)))
forall (m :: * -> *) a.
MonadResource m =>
AWSResponse a
-> Logger
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveNull AWSResponse SplitShard
SplitShardResponse
SplitShardResponse'

instance Prelude.Hashable SplitShard

instance Prelude.NFData SplitShard

instance Core.ToHeaders SplitShard where
  toHeaders :: SplitShard -> [Header]
toHeaders =
    [Header] -> SplitShard -> [Header]
forall a b. a -> b -> a
Prelude.const
      ( [[Header]] -> [Header]
forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              HeaderName -> ByteString -> [Header]
forall a. ToHeader a => HeaderName -> a -> [Header]
Core.=# ( ByteString
"Kinesis_20131202.SplitShard" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              HeaderName -> ByteString -> [Header]
forall a. ToHeader a => HeaderName -> a -> [Header]
Core.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Core.ToJSON SplitShard where
  toJSON :: SplitShard -> Value
toJSON SplitShard' {Text
newStartingHashKey' :: Text
shardToSplit :: Text
streamName :: Text
$sel:newStartingHashKey':SplitShard' :: SplitShard -> Text
$sel:shardToSplit:SplitShard' :: SplitShard -> Text
$sel:streamName:SplitShard' :: SplitShard -> Text
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"StreamName" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Text
streamName),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"ShardToSplit" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Text
shardToSplit),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just
              (Text
"NewStartingHashKey" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Text
newStartingHashKey')
          ]
      )

instance Core.ToPath SplitShard where
  toPath :: SplitShard -> ByteString
toPath = ByteString -> SplitShard -> ByteString
forall a b. a -> b -> a
Prelude.const ByteString
"/"

instance Core.ToQuery SplitShard where
  toQuery :: SplitShard -> QueryString
toQuery = QueryString -> SplitShard -> QueryString
forall a b. a -> b -> a
Prelude.const QueryString
forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newSplitShardResponse' smart constructor.
data SplitShardResponse = SplitShardResponse'
  {
  }
  deriving (SplitShardResponse -> SplitShardResponse -> Bool
(SplitShardResponse -> SplitShardResponse -> Bool)
-> (SplitShardResponse -> SplitShardResponse -> Bool)
-> Eq SplitShardResponse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SplitShardResponse -> SplitShardResponse -> Bool
$c/= :: SplitShardResponse -> SplitShardResponse -> Bool
== :: SplitShardResponse -> SplitShardResponse -> Bool
$c== :: SplitShardResponse -> SplitShardResponse -> Bool
Prelude.Eq, ReadPrec [SplitShardResponse]
ReadPrec SplitShardResponse
Int -> ReadS SplitShardResponse
ReadS [SplitShardResponse]
(Int -> ReadS SplitShardResponse)
-> ReadS [SplitShardResponse]
-> ReadPrec SplitShardResponse
-> ReadPrec [SplitShardResponse]
-> Read SplitShardResponse
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SplitShardResponse]
$creadListPrec :: ReadPrec [SplitShardResponse]
readPrec :: ReadPrec SplitShardResponse
$creadPrec :: ReadPrec SplitShardResponse
readList :: ReadS [SplitShardResponse]
$creadList :: ReadS [SplitShardResponse]
readsPrec :: Int -> ReadS SplitShardResponse
$creadsPrec :: Int -> ReadS SplitShardResponse
Prelude.Read, Int -> SplitShardResponse -> ShowS
[SplitShardResponse] -> ShowS
SplitShardResponse -> String
(Int -> SplitShardResponse -> ShowS)
-> (SplitShardResponse -> String)
-> ([SplitShardResponse] -> ShowS)
-> Show SplitShardResponse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SplitShardResponse] -> ShowS
$cshowList :: [SplitShardResponse] -> ShowS
show :: SplitShardResponse -> String
$cshow :: SplitShardResponse -> String
showsPrec :: Int -> SplitShardResponse -> ShowS
$cshowsPrec :: Int -> SplitShardResponse -> ShowS
Prelude.Show, (forall x. SplitShardResponse -> Rep SplitShardResponse x)
-> (forall x. Rep SplitShardResponse x -> SplitShardResponse)
-> Generic SplitShardResponse
forall x. Rep SplitShardResponse x -> SplitShardResponse
forall x. SplitShardResponse -> Rep SplitShardResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SplitShardResponse x -> SplitShardResponse
$cfrom :: forall x. SplitShardResponse -> Rep SplitShardResponse x
Prelude.Generic)

-- |
-- Create a value of 'SplitShardResponse' 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.
newSplitShardResponse ::
  SplitShardResponse
newSplitShardResponse :: SplitShardResponse
newSplitShardResponse = SplitShardResponse
SplitShardResponse'

instance Prelude.NFData SplitShardResponse