brendanhay / amazonka

A comprehensive Amazon Web Services SDK for Haskell.

Amazonka

An Amazon Web Services SDK for Haskell with support for most public services. Parts of the code contained in this repository are auto-generated and automatically kept up to date with Amazon's latest service APIs.

• You can find the latest Haddock documentation for each respective library on the Amazonka website.
• A release changelog can be found in lib/amazonka/CHANGELOG.md.
• For problems, comments, or feedback please create an issue here on GitHub.

Table of Contents

• License
• Directory Layout
• Supported Platforms and GHC Versions
• Getting Started
• Building the Project
• Running the Code Generator
• Amazonka as a Git Dependency
• Code Formatting
• Third Party Packages

License

Amazonka is licensed under the Mozilla Public License Version 2.0.

The AWS service descriptions are licensed under Apache 2.0. Source files derived from the service descriptions contain an additional licensing clause in their header.

Directory Layout

This repository is organised under the following directory structure:

• lib/amazonka: The main library containing setup, authentication, and send logic. This will be your primary dependency.
• lib/service/amazonka-*: A library per supported Amazon Web Service, you'll need to add a dependency on each selected service library.
• lib/amazonka-core: The amazonka-core library upon which each of the services depends.
• lib/amazonka-test: Common test functionality.
• examples: Basic examples for using the service libraries.
• configs: Service configuration, templates, and assets used by the code generator.
• docs: The documentation website.
• gen: The code and configuration generators.
• scripts: Scripts to manage the project, such as the release lifecycle.

Supported Platforms and GHC Versions

GHC versions 9.0.*, 9.4.* and 9.6.* are officially supported and tested on NixOS, Ubuntu, and macOS. Earlier or later versions of GHC may also work, but only the aforementioned versions are tested by our continuous integration pipeline.

Getting Started

This repository is built using a combination of Nix and Cabal. If you're just using Amazonka as a git dependency in your Cabal or Stack project, you can skip the following steps and read Amazonka as a Git dependency. But if you plan on contributing to the codebase - welcome, read on!

1. Clone this repository

git clone [email protected]:brendanhay/amazonka.git
cd amazonka

2. Setup Nix

Building the code in this repository requires various development dependencies that are obtained and built via the Nix package manager in a reproducible and hermetic environment. You can install Nix by following the official installation instructions:

sh <(curl -L https://nixos.org/nix/install) --daemon

Once Nix is setup, you can enable the cache to avoid building dependencies:

nix-env -iA cachix -f https://cachix.org/api/v1/install
cachix use amazonka

A flake.nix is provided which will require your Nix configuration to enable flake support if you haven't done so already.

Edit either ~/.config/nix/nix.conf or /etc/nix/nix.conf and add:

experimental-features = nix-command flakes

If the Nix installation is in multi-user mode, don’t forget to restart the nix-daemon.

3. Enter a Nix Shell

The build tools are installed and activated upon entering a Nix shell, which is achieved by running the following command in the root of the repository:

nix develop

You can also enter a shell and by specifying one of the GHC versions declared by flake.nix, which can be inspected by running:

nix flake show
...
└───<system>
    ├───default: development environment 'amazonka-ghc944'
    ├───ghc810:  development environment 'amazonka-ghc8107'
    ├───ghc90:   development environment 'amazonka-ghc902'
    ├───ghc92:   development environment 'amazonka-ghc927'
    ├───ghc94:   development environment 'amazonka-ghc944'
    └───ghc96:   development environment 'amazonka-ghc961'

And then running nix develop for the desired version from the attribute list above:

nix develop '.#ghc90'

Note: the naming pattern for shells follows the GHC major versions available in nixpkgs. This means the minor versions will increment automatically as the flake.lock is updated.

If you have Direnv installed you can use the provided .envrc to automatically enter the default nix develop, which will also add the scripts directory to your PATH. You can extend this by adding your own uncommitted .envrc.local file. See the Direnv Wiki for various recipes.

Building the Project

The following commands assume you're already in a nix shell outlined in the previous step.

Once you've entered a Nix shell you can build amazonka-* packages via:

cabal build amazonka amazonka-s3

Or the entire project (which will take a very long time!):

cabal build all

Running the Code Generator

The gen package contain a code generator for synthesising Haskell data types, packages, and configuration from the botocore service definitions.

scripts/generate will run the code generator for all services configured in config/services, for example:

./scripts/generate

Or, you can selectively run the generator on one or more services:

./scripts/generate ec2 s3 iam

To update the botocore service definitions used by the generator, you can run:

./scripts/update-botocore

scripts/generate-configs will run the config generator to produce placeholder config/services configurations for any botocore services.

To generate configurations for any new/missing services:

./scripts/generate-configs

Service configurations generated in this way are intended as examples only and the resulting configs/services/<name>.json:libraryName (Haskell package name) and configs/annexes/<name>.json:serviceAbbreviation (Haskell package namespace) should be manually verified and curated as necessary.

For pull requests which affect generated output please do not include the regenerated amazonka-* packages, only commit updates to the build rules, documentation, generator, and related configuration. This is to make code review more manageable by focusing pertinent changes such as configuration and logic changes in pull requests and designates the maintainers and Continuous Integration as the source of truth for the generated code.

Amazonka as a Git Dependency

If there are as-yet-unreleased features or fixes that have yet to make it to Hackage, you can use the main (or another) development branch by declaring Amazonka as a Git dependency by following the Cabal or Stack instructions below.

Note: amazonka-core is a required dependency of the main amazonka package, in addition to amazonka-sts and amazonka-sso for sts:AssumeRoleWithWebIdentity and SSO via AWS IAM Identity Center, respectively. These required dependencies can then be supplemented by any additional service libraries you use from lib/services/amazonka-<service>.

Cabal

To add Amazonka as a Git dependency to your Cabal project, you will need to add a source-repository-package section for amazonka to your cabal.project file:

-- For amazonka
-- Multiple subdirs in a single `source-repository-package` stanza are supported by cabal-install >= 3.2.0.0.
source-repository-package
    type: git
    location: https://github.com/brendanhay/amazonka
    tag: <current revision of the `main` branch>
    subdir: lib/amazonka lib/amazonka-core lib/services/amazonka-sso lib/services/amazonka-sts lib/services/amazonka-<service>

Stack

Stack users should add an extra-deps: stanza to their stack.yaml:

extra-deps:
- github: brendanhay/amazonka
  commit: <current revision of the `main` branch>
  subdirs:
  - lib/amazonka
  - lib/amazonka-core
  - lib/services/amazonka-sso
  - lib/services/amazonka-sts
  - lib/services/amazonka-<service>

Haskell.nix + Stack

Stack users who also use haskell.nix will need to configure haskell.nix to fetch Amazonka commits from a specific git branch/rev by using the branchMap parameter:

pkgs.haskell-nix.project {
  branchMap = {
    "https://github.com/brendanhay/amazonka" = {
      "<git-commit-sha>" = "main";
    };
  };

  ...
}

Code Formatting

Provided automatically by the pre-commit hooks configured in flake.nix --- please use nix develop.

Third Party Packages

When naming an additional library which provides supplemental functionality to amazonka, if you want to use the amazonka-* namespace, then please consider prefixing your package names with amazonka-contrib-*. For example, amazonka-contrib-rds-utils.

This minimises potential future collisions with auto-generated package names and new AWS service and product releases.

amazonka's Issues

SignatureDoesNotMatch error in SQS deleteMessage

Hot on the heels of the last issue :)

sample env = runAWST env $ do
  r <- send $ receiveMessage eventQueue
  forM_ (r ^. rmrMessages) $ \m -> do
    liftIO $ print $ m ^. mBody
    liftIO $ print $ m ^. mReceiptHandle
    m ^!? mReceiptHandle . _Just . act (send . deleteMessage eventQueue)

^ Running this code gives me this error:

ServiceError "SQS" (Status {statusCode = 403, statusMessage = "Forbidden"}) "RESTError {_restRequestId = \"c1dc6e82-b6f5-58b8-8dfa-226c13a192af\", _restType = Just Sender, _restCode = \"SignatureDoesNotMatch\", _restMessage = \"The request signature we calculated does not match the signature you provided. Check your AWS Secret Access Key and signing method. Consult the service documentation for details.\\n\\nThe Canonical String for this request should have been\\n'POST\\n/\\nAction=DeleteMessage&QueueUrl=https%3A%2F%2Fsqs.us-east-1.amazonaws.com%2F235347918795%2Fbrewtown-events&ReceiptHandle=0NNAq8PwvXtwL%20PPcKxShYdkFEA%2F0c%2F7I2wESI09NTe%2FqEGF2bsR08K4R7Q2gmi6hZkFJnMYBVCZS5EvTFAlmiQvdwtcSAqki2707JaoDgpwEzCAK2eezFZxLcdWJVn8DQyxGSKUdAAbM1%20jlBVlKr4Hnhpmo%20jyKYB6V7DeEZz3O8wcWaBJc3GRKf1knNqIkfDcqw8j9PU%2FWu9Tr8JNRN9KbzTfKhemA6Rd8e1cid7z1mC5EmcoDAeEN9YckN6hQ5%2Fx%2FuSUeKVv%2F9JwLLwiEHm4VGNW8ZBAFd2dF3wgGe0fp4f0EtJ%20ejWo5uxqFPbqRG%20ivNm99RLLqwYYOR72PVQZ%2F6pxdO666Y%2F7qxc9h7Y%3D&Version=2012-11-05\\nhost:sqs.us-east-1.amazonaws.com\\nx-amz-date:20141125T154108Z\\n\\nhost;x-amz-date\\ne3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'\\n\\nThe String-to-Sign should have been\\n'AWS4-HMAC-SHA256\\n20141125T154108Z\\n20141125/us-east-1/sqs/aws4_request\\n87f60d3ea043b9389089e412da52d418d10fc94183088b2552e4a1e391ee8765'\\n\"}"

DescribeSecurityGroups fails with SerializerError when All Traffic is in any security group

If any security group in scope of the DescribeSecurityGroups requests contains a rule specifying All Traffic the request will fail.

Specific error encountered:

Left (SerializerError "EC2" "unable to find element \"fromPort\" in nodes [\"ipProtocol\",\"groups\",\"ipRanges\"]")

Program that exhibits this problem:

import Control.Monad.Trans.AWS
import Network.AWS.EC2

main  = do
  e <- getEnv Ireland Discover
  r <- runAWST e $ do { send describeSecurityGroups }
  print r

Sanitized JSON output from AWS Command Line Interface:

$ aws ec2 describe-security-groups --profile ireland

{
    "SecurityGroups": [
        {
            "GroupId": "sg-abcd1234",
            "IpPermissions": [
                {
                    "UserIdGroupPairs": [
                        {
                            "UserId": "123456789012",
                            "GroupId": "sg-abcd1234"
                        }
                    ],
                    "IpProtocol": "-1",
                    "IpRanges": []
                }
            ],
            "GroupName": "default",
            "VpcId": "vpc-1234abcd",
            "IpPermissionsEgress": [],
            "Description": "default VPC security group",
            "OwnerId": "123456789012"
        }
    ]
}

With ~/.aws/config:

[profile ireland]
aws_access_key_id = ...
output = json
region = eu-west-1
aws_secret_access_key = ...

Generate endpoint selection logic from the service descriptions

Currently the Endpoint type in core and the corresponding endpointScope function are hand-rolled.

endpointScope in particular contains logic pertaining to individual services as well as a default case if no service specific logic exists. This was translated from _endpoints.json for expediency.

The default case should continue to live in core, but _endpoints.json should be used by gen to apply any related service cases directly to its respective .Types module.

Construction of RqBody using sourceFileIO causes incorrect headers to be sent

Such as double Content-Lengths or Transfer-Encoding chunked.

The source* code in Network.AWS.Data.Internal.Body is now absolute due to the direct http-conduit dependency and should be removed or replaced with the functions of the same name from http-conduit.

Improved logging

More log levels would be convenient to avoid leaking any potentially sensitive signing metadata if desired, or log raw non-streaming response bodies for debugging.

Value serialization error with DynamoDB API

Hi -

I was playing around with the amazonka-dynamodb module and I ran into what seems like a JSON serialization error in the POST body. The trace output follows the code snippet (AWS-side SerializationException is at the very end).

Here's what I tried....

module DynamoDB where

import           Control.Applicative
import           Control.Lens
import           Control.Monad.Trans.AWS
import qualified Data.ByteString.Builder as Build
import           Data.Monoid
import qualified Data.Text               as Text
import           Data.Time.Clock.POSIX
import           Network.AWS.DynamoDB
import           Network.AWS.Prelude
import           System.IO

example = do
    lgr <- newLogger Trace stdout
    env <- getEnv NorthVirginia (FromEnv "AWS_ACCESS_KEY_ID" "AWS_SECRET_ACCESS_KEY") <&> envLogger .~ lgr
    ts  <- Text.pack . show <$> getTimestamp
    let tableName = "AmazonikaTestTable"
        throughput = provisionedThroughput 1 1
        schema = keySchemaElement "id" Hash :| []
    runAWST env $ do
        say "Creating DynamoDB table " tableName
        response <- send $ createTable tableName schema throughput
        return ()

-- boilerplate utility from ec2 example omitted

... and here's what I got:

λ> example
[Amazonka Env] {
  region      = us-east-1
  retry (n=0) = Nothing
  [Amazonka Auth] {
    access key     = <omitted>
    secret key     = ****
    security token = Nothing
    expiry         = Nothing
  }
}
Creating DynamoDB table "AmazonikaTestTable"
[Raw Request] {
  method  = POST
  path    = /
  query   = 
  headers = x-amz-target: DynamoDB_20120810.CreateTable; content-type: application/x-amz-json-1.0
  body    = {
    hash    = 9af1281e17d13157f620e3a2c6255e5b0c63f83e4762a3f55b957c9bff668d5a
    payload =
{"AttributeDefinitions":[],"ProvisionedThroughput":{"ReadCapacityUnits":"1","WriteCapacityUnits":"1"},"KeySchema":[{"KeyType":"HASH","AttributeName":"id"}],"GlobalSecondaryIndexes":[],"LocalSecondaryIndexes":[],"TableName":"AmazonikaTestTable"}
  }
}
[Client Request] {
  host              = dynamodb.us-east-1.amazonaws.com
  port              = 443
  secure            = True
  headers           = authorization: AWS4-HMAC-SHA256 Credential=<omitted>/20141227/us-east-1/dynamodb/aws4_request, SignedHeaders=content-type;host;x-amz-date;x-amz-target, Signature=4742fb33571580e3b5acd07b7d4f6c34d4dab21053f32e4e32a4dc8241fce984; content-type: application/x-amz-json-1.0; host: dynamodb.us-east-1.amazonaws.com; x-amz-date: 20141227T062859Z; x-amz-target: DynamoDB_20120810.CreateTable
  path              = /
  query             = ?
  method            = POST
  redirect count    = 10
  response timeout  = Just -3425
  request version   = HTTP/1.1
}
[Version 4 Metadata] {
  algorithm         = AWS4-HMAC-SHA256
  credential scope  =<omitted>/20141227/us-east-1/dynamodb/aws4_request
  signed headers    = content-type;host;x-amz-date;x-amz-target
  canonical request = {
POST
/

content-type:application/x-amz-json-1.0
host:dynamodb.us-east-1.amazonaws.com
x-amz-date:20141227T062859Z
x-amz-target:DynamoDB_20120810.CreateTable

content-type;host;x-amz-date;x-amz-target
9af1281e17d13157f620e3a2c6255e5b0c63f83e4762a3f55b957c9bff668d5a
  }
  string to sign    = AWS4-HMAC-SHA256
20141227T062859Z
20141227/us-east-1/dynamodb/aws4_request
4a2d74c67b9ddeb6ca971e117e288ae3da464529970f31d459253b7846200e44
  signature         = 4742fb33571580e3b5acd07b7d4f6c34d4dab21053f32e4e32a4dc8241fce984
  time              = 2014-12-27 06:28:59.065813 UTC
}
[Client Response] {
  status code    = 400
  status message = Bad Request
  version        = HTTP/1.1
  headers        = x-amzn-requestid: 2R2QG8CIPUMPLQIP812C5KGVJNVV4KQNSO5AEMVJF66Q9ASUAAJG; x-amz-crc32: 2273245304; content-type: application/x-amz-json-1.0; content-length: 127; date: Sat, 27 Dec 2014 06:28:59 GMT
  cookies        = CJ {expose = []}
}
Left (SerializerError "DynamoDB" "key \"code\" not present:\n{\"__type\":\"com.amazon.coral.service#SerializationException\",\"Message\":\"class java.lang.String can not be converted to an Long\"}")
it :: Either Error ()

EDIT: Nat's in Network.AWS.Data.Internal.Numeric get converted to Strings... is that the intended behavior?

instance ToJSON Nat where
    toJSON = String . toText . unNat

Thanks for the hard work!
Buro

A group of S3 problems with known fixes

I've found three problems with S3 and fixed them in my local source tree, though some of the fixes are in generated code that I'm not sure how to tell the overrides about.

• S3 needs to be a regional service, not a global one.
• The URL it constructs is s3.$regionfragment.amazonaws.com, but it needs to be s3-$regionfragment.amazonaws.com. I don't know if that's an S3-specific URL shape; if it's not,

diff --git a/core/src/Network/AWS/Types.hs b/core/src/Network/AWS/Types.hs
index a28b8ff..aec3fcb 100644
--- a/core/src/Network/AWS/Types.hs
+++ b/core/src/Network/AWS/Types.hs
@@ -330,7 +330,7 @@ endpoint Service{..} reg =
     let suf = ".amazonaws.com"
      in Host $ case _svcEndpoint of
             Global   -> _svcPrefix <> suf
-            Regional -> _svcPrefix <> "." <> toBS reg <> suf
+            Regional -> _svcPrefix <> "-" <> toBS reg <> suf
             Custom x -> x

 global, regional :: Endpoint

will fix it.

• GetObjectResponse's _gorLastModified should be RFC822, not ISO8601. I don't know about the other two dates in that type, though I imagine it's probable they're also not ISO.

With those three things changed, I have successfully listed the contents of a bucket and then done a getObject on a file and retrieved its contents.

CloudFormation DescribeStacks fails with SerializerError

For a standard describeStacks request with a known stack name, I get the following error:

SerializerError "CloudFormation" "unable to find element \"Capabilities\" in nodes [\"Tags\",\"StackId\",\"StackStatus\",\"StackName\",\"StackStatusReason\",\"Description\",\"NotificationARNs\",\"CreationTime\",\"Parameters\",\"DisableRollback\",\"Outputs\"]"

Seems like it ought to be a trivial change to the generator but I'm not quite sure where to look to fix it myself.

SerializerError "SQS" "unable to find element \"Attribute\" in nodes [\"Body\"]"

When I run this SQS request to get back a message, it doesn't deserialize properly. (The error I'm getting is the one in the title)

sample env = runAWST env $ send $ receiveMessage eventQueue

Presigning

I've been looking at trying to get presigning to work. Right now, I've almost got it working but not quite -- at least it's close enough now for AWS to return useful error messages on a presigned S3 GetObject, specifically what it thinks the canonical request and strings to sign are. Right now the biggest issue is the "UNSIGNED-PAYLOAD" string -- amazon's expecting literally that in the canonical request, but amazonka is putting in the sha256 of the empty request body. Oddly, if I'm reading the error from AWS aright, it's also expecting the x-amz-content-sha256 and x-amz-date fields to be listed in the canonical request, but empty. I don't understand that yet.

Remove generated code compilation warnings

amazonka-gen strives to produce warning free code, but there are a couple of particular cases where leakage occurs.

Caused by duplicate module exports:

gen/Network/AWS/EC2/Types.hs:1399:7: Warning:
    ‘EC2Error’ is exported by ‘module Network.AWS.EC2.Internal’ and ‘EC2Error’

Caused by unused bindings in the service's Retry specification:

gen/Network/AWS/CognitoIdentity/Types.hs:95:50: Warning:
    Defined but not used: ‘e’

Parsed + typed EC2 metadata responses

Currently the responses for amazonka's Network.AWS.EC2.Metadata module return ByteString when they could easily be parsed into appropriate types.

Add Amazon licensing information about service descriptions to generated files

Since parts of the code are derived from Amazon service descriptions, and contain the documentation strings verbatim, an addition to the licensing fields in the generated .hs file headers is required:

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

Add option to perform streaming signature calculation for Version 4 signing

Currently the Version 4 signatures are calculated for all services including S3 using the Authenticating Requests by Using the Authorization Header (Compute Checksum of the Entire Payload Prior to Transmission) algorithm.

This is less than ideal in S3's case, and an alternative Authenticating Requests Using HTTP Authorization Header (Chunked Upload) is offered which is considerably more efficient.

An additional signing option should be added which could be utilised for S3 signing purposes.

Create/update a changelog as part of the release process

I like reading other people's changelogs.

I don't like writing them.

I should write a generator for the changelog! Then hand massage the output into something that can piggyback along with any release notes.

Remove Stage1 + Stage2 JSON models from the repository

The gen/stage1 and gen/stage2 JSON models are present in the git repository merely for convenience of making potential changes readily apparent during development.

• stage1 models make it apparent what has changed upstream in the service descriptions.
• stage2 models allow debugging of template parameters, and after effects of gen/src/Transform.hs `changes.

In the long term, the additional overhead of cloning or updating the repository, and in particular the noise these introduce into the git history is probably not worth it.

override/required fields are not quite right for ec2

plan :: Options -> IO (Either Error ())
plan _opts =
  do lgr <- newLogger Trace stdout
     env <- getEnv NorthVirginia Discover <&>
            envLogger .~
            lgr
     ts <- Text.pack . show <$> getTimestamp
     runAWST env $
       do say "Run " ts
          result0 <- sendCatch describeInstances
          case result0 of
            (Left err) -> say "Error " err
            -- Error SerializerError "EC2" "unable to find element
            -- \"keyName\" in nodes
            -- [\"instanceId\",\"imageId\",\"instanceState\",\"privateDnsName\",\"dnsName\",\"reason\",\"amiLaunchIndex\",\"productCodes\",\"instanceType\",\"launchTime\",\"placement\",\"kernelId\",\"monitoring\",\"privateIpAddress\",\"ipAddress\",\"groupSet\",\"architecture\",\"rootDeviceType\",\"rootDeviceName\",\"blockDeviceMapping\",\"virtualizationType\",\"clientToken\",\"tagSet\",\"hypervisor\",\"networkInterfaceSet\",\"ebsOptimized\"]"
            (Right response) ->
              do forM_ (view dirReservations response) $
                   \x ->
                     say " " (x ^. rReservationId)
          result1 <- sendCatch describeVolumes
          case result1 of
            (Left err) -> say "Error " err
            -- Error SerializerError "EC2" "unable to find element
            -- \"iops\" in nodes
            -- [\"volumeId\",\"size\",\"snapshotId\",\"availabilityZone\",\"status\",\"createTime\",\"attachmentSet\",\"tagSet\",\"volumeType\",\"encrypted\"]"
            (Right response) ->
              do forM_ (view dvrVolumes response) $
                   \x -> say " " (x ^. vVolumeId)
          result2 <- sendCatch describeSnapshots
          case result2 of
            (Left err) -> say "Error " err
            -- Result: Error SerializerError "EC2" "empty node list,
            -- when expecting a single node: Text"
            (Right response) ->
              do forM_ (view dsrSnapshots response) $
                   \x ->
                     say " " (x ^. sSnapshotId)
          result3 <- sendCatch listBuckets
          case result3 of
            (Left err) -> say "Error " err
            -- WORKS GREAT!
            (Right response) ->
              do forM_ (view lbrBuckets response) $
                   \x -> say " " (x ^. bName)

say :: Show a => Build.Builder -> a -> AWST IO ()
say msg = info . mappend msg . Build.stringUtf8 . show

getTimestamp :: IO Integer
getTimestamp = truncate <$> getPOSIXTime

ETag in S3 responses are double-quoted

Due to the quoted ETag header format not correctly being accounted for.

Can be fixed in the short-term by implementing a custom FromText instance here. This would account for both cases (quoted and unquoted).

CloudFormation createStack with template body fails with "InvalidStatusLine"

Attempting to send the following createStack request

import           Control.Lens
import           Control.Monad.Trans.AWS
import qualified Data.Text                  as Text
import qualified Data.Text.IO               as Text
import           Network.AWS.CloudFormation

main =
  do env <- getEnv Oregon Discover
     runAWST (env & envLogger .~ (Debug (Text.appendFile "debug.log"))) $
       do let stackName = "test-stack-001"
          templateBody <- liftIO $ Text.readFile "example.template"
          send (createStack stackName & csTemplateBody ?~ templateBody)

gives the following error

Left (HttpError (InvalidStatusLine "<ErrorResponse xmlns=\"http://cloudformation.amazonaws.com/doc/2010-05-15/\">"))

where example.template contains this template: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/example-templates-elb-with-apache.html

Add de/serialisation tests for core type classes and data types

Optimise the cabal sandbox structure to improve build times

Currently the development workflow goes something like:

$ amazonka: make install
... 1a: installs dependencies 
... 1b: recurses through all amazonka-* subdirs add-source'ing to ../core
$ amazonka: make
... 2a: recurses through all amazonka-* subdirs building each library with cabal -j

1b above in particular feels pointless + slow, since it basically need to exec cabal install --only-dependencies which doesn't actually need to do anything (satisfied at step 1a) 43 times.

Network.AWS.Data.Internal.Body causes duplicate content-length headers

When using sourceFileIO and it's ilk to set a request body (ie. for putObject), if a poContentLength is also set manually this causes http-client to set an additional Content-Length header after signature calculation causing a 403 response due to the incorrect signature.

S3 PutObjectACL is not correctly serializing the Grantee xmlns/xsi type

The correct form for serialised Grantee should be:
<Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="CanonicalUser">

Expand per service examples

Each service now contains an example cabal project under amazonka-*/examples.

Additional bite-sized examples per service should be added, focusing on:

• Real world usage.
• Idempotency of actions.
• Cleanup and teardown of created resources.
• Region agnostic .
• Avoid or mitigate related AWS costs.

S3: listBuckets fails due to missing header (and can't interpret the response)

It looks like S3 wants an "x-amz-content-sha256" header and isn't receiving one:

main = do
  env <- getEnv Oregon Discover <&> envLogger .~ Debug Text.putStrLn
  r <- runAWST env $ send listBuckets
  print r

results in the HTTP request/response and Left output:

HTTP Request:
Request {
  host                 = "s3.amazonaws.com"
  port                 = 443
  secure               = True
  requestHeaders       = [("Date","2014-11-24T22:01:44Z"),("Host","s3.amazonaws.com"),("Authorization","AWS4-HMAC-SHA256 Credential=access_key_elided/20141124/us-west-2/s3/aws4_request, SignedHeaders=date;host, Signature=682358cb90440fc52e246826d6e7bfc3c9a4a2ebf50c6a04181f74ee945eb978")]
  path                 = "/"
  queryString          = ""
  method               = "GET"
  proxy                = Nothing
  rawBody              = False
  redirectCount        = 10
  responseTimeout      = Just (-3425)
}


[Raw Response]
Response {responseStatus = Status {statusCode = 400, statusMessage = "Bad Request"}, responseVersion = HTTP/1.1, responseHeaders = [("x-amz-request-id","29ECD5DBC22961BD"),("x-amz-id-2","IufPpdrrBXEu9zoukaFSGY9sNvzZuM03xhwob+mT/SQ9m4EpBu2WASjhBKi74r7U"),("Content-Type","application/xml"),("Transfer-Encoding","chunked"),("Date","Mon, 24 Nov 2014 22:02:22 GMT"),("Connection","close"),("Server","AmazonS3")], responseBody = (), responseCookieJar = CJ {expose = []}, responseClose' = ResponseClose}
Left (SerializerError "S3" "unable to find element \"Error\" in nodes [\"Code\",\"Message\",\"RequestId\",\"HostId\"]:\n<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<Error><Code>UnsignedContentSHA256NotAllowed</Code><Message>The provided 'x-amz-content-sha256' header must be a valid SHA256.</Message><RequestId>29ECD5DBC22961BD</RequestId><HostId>IufPpdrrBXEu9zoukaFSGY9sNvzZuM03xhwob+mT/SQ9m4EpBu2WASjhBKi74r7U</HostId></Error>")

Better documentation structure for top-level service modules

Currently the Network.AWS.<service> module re-exports the respective .Types and operations for the service.

The Haddock documentation is a bit sparse, as it only contains Amazon's general service overview, and then links to the re-exported modules.

It'd be nice to coerce Haddock into pulling in the documentation from the module inline, without sacrificing individual operation exports.

Generalise Operations and Waiter correspondence

Some ideas to improve the usage of Wait specifications:

Correspondence

The selection of waiters is currently up to the user - there is no correspondence between the operations you perform and the Wait specification you choose to await upon.

Potentially you could do something like:

rs <- deleteTable "table-name"
...
await rs

Which would be able to infer the tableNotExists waiter from the response.

Over Specification

Currently the Wait specifications require explicitly specifying the operation's smart constructor. The constructor could be aliased/unrolled into the actual call to the waiter.

For example:

await tableNotExists (describeTable "table-name")

Would become:

await (tableNotExists "table-name")

Upgrade monad-control dependency

With the recent release of monad-control >= 1 the MonadBaseControl instance in amazonka for AWST breaks due to the change from associated data types to associated type synonyms.

Since this is backwards/forwards incompatible, the cabal constraint is currently < 1. At some point this should be changed to > 1 presuming no issues with the usual dependency hell for downstream consumers of this library.

mws (amazon marketplace) support

Hi,

It would be great, to have auto-generated mws bindings via amazonka.

Afaict mws also has an amazon service model (com.amazonservices.mws). I did not look into how the other amazonka bindings get generated, so I am not sure it's all that is needed, though. I am willing to invest time and code in it, but only have very limited time. Pointers welcome.

Document the override structure + process

It'd be useful for people to understand at a glance how to supplement the gen/overrides with annotations that affect the generated output, since is potentially the initial/primary source that should be considered for fixes, corrections, and contributions.

Test directory is missing modules in amazonka-core tarball

http://hackage.haskell.org/package/amazonka-core-0.1.4/src/test/

I noticed that the modules are missing from other-modules, is this maybe why?

Relax time dependency constraint

The aeson == 0.8.* and time >= 1.5 constraints have caused build issues for a number of people.

Ideally I'd like to support time dependency constraints of >= 1.5, and < 1.5 if possible, otherwise supporting the most common case of < 1.5.

CC: @dysinger, @intractable

Re-enable version 4 signing tests

See: core/tests and this commit.

CloudFormation createStack with template url fails with "MalformedInput"

The following createStack request

import           Control.Lens
import           Control.Monad.Trans.AWS
import qualified Data.Text                  as Text
import qualified Data.Text.IO               as Text
import           Network.AWS.CloudFormation

parameter' key value = parameter & pParameterKey ?~ key & pParameterValue ?~ value

main =
  do env <- getEnv Oregon Discover
     runAWST (env & envLogger .~ (Debug (Text.appendFile "debug.log"))) $
       do let stackName = "test-stack"
              templateUrl = "https://s3-us-west-2.amazonaws.com/cloudformation-templates-us-west-2/EC2InstanceWithSecurityGroupSample.template"
              parameters = [ parameter' "KeyPair" "test" ]
          send (createStack stackName & csTemplateURL ?~ templateUrl & csParameters .~ parameters)

fails with the following error

Left (ServiceError "CloudFormation" (Status {statusCode = 400, statusMessage = "Bad Request"}) "RESTError {_restRequestId = \"a6ab62ce-74e5-11e4-bbc6-13c6b5906bb5\", _restType = Just Sender, _restCode = \"MalformedInput\", _restMessage = \"Top level element may not be treated as a list\"}")

Bug in Pagination?

In requesting EC2 Reserved Instance Modifications, I noticed a bug in
the pagination. You'll notice there's no results older than
2014-12-02 in the Amazonka query. You will notice 2015 results in the
awscli query (bottom).

Code

printReservedInstanceModifications :: IO ()
printReservedInstanceModifications =
  do lgr <- newLogger Trace stdout
     env' <-
       getEnv NorthVirginia Discover <&>
       (envLogger .~ lgr)
     _ <- runAWST env'
             (do rims <- view drimrReservedInstancesModifications <$>
                         send describeReservedInstancesModifications
                 forM_ rims
                       (\rim ->
                          info (T.concat ([T.pack (case (rim ^. rimCreateDate) of
                                                     Just t -> show t
                                                     Nothing -> "n/a")
                                          ,T.pack ","
                                          ,(fromMaybe T.empty (rim ^. rimStatus))
                                          ,T.pack ","
                                          ,(fromMaybe T.empty
                                                      (rim ^. rimStatusMessage))
                                          ,T.pack ","
                                          ,fromMaybe T.empty
                                                     (rim ^.
                                                      rimReservedInstancesModificationId)
                                          ,T.pack ","
                                          ,T.intercalate
                                             ","
                                             (map (fromMaybe T.empty)
                                                  (rim ^.
                                                   rimReservedInstancesIds ^..
                                                   traverse .
                                                   riiReservedInstancesId))]))))
     return ()

Code (Alternate - Dosen't change the output)

printReservedInstanceModifications :: IO ()
printReservedInstanceModifications =
  do lgr <- newLogger Trace stdout
     env' <-
       getEnv NorthVirginia Discover <&>
       (envLogger .~ lgr)
     _ <- runAWST env'
             (paginate (describeReservedInstancesModifications) =$
              C.concatMap (view drimrReservedInstancesModifications) $$
              C.mapM_ (info .
                       (\rim ->
                          T.concat ([T.pack (case (rim ^. rimCreateDate) of
                                               Just t -> show t
                                               Nothing -> "n/a")
                                    ,T.pack ","
                                    ,(fromMaybe T.empty (rim ^. rimStatus))
                                    ,T.pack ","
                                    ,(fromMaybe T.empty (rim ^. rimStatusMessage))
                                    ,T.pack ","
                                    ,fromMaybe T.empty
                                               (rim ^.
                                                rimReservedInstancesModificationId)
                                    ,T.pack ","
                                    ,T.intercalate
                                       ","
                                       (map (fromMaybe T.empty)
                                            (rim ^. rimReservedInstancesIds ^..
                                             traverse . riiReservedInstancesId))]))))
     return ()

Code Run

Note: This is snipped (due to size constraints on github bug report)
to the last bit of log.

                <item>
                    <reservedInstancesId>6854cd56-0441-41ed-8278-a501fb6e043e</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1a</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>16</instanceCount>
                        <instanceType>c3.2xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-02T22:28:09.228Z</createDate>
            <updateDate>2014-12-02T22:49:32.534Z</updateDate>
            <effectiveDate>2014-12-02T22:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>a3fcea06-4fbc-43ac-b364-48e3226b9343</clientToken>
        </item>
    </reservedInstancesModificationsSet>
    <nextToken>nk78PD7bIJeSjQYi4URwrdpwV0Cm4KR5RpHzbyle63w=</nextToken>
</DescribeReservedInstancesModificationsResponse>
}
2014-03-24 19:51:35.356 UTC,fulfilled,,rimod-3cbfc788-38f2-4e1f-9173-00583fe719b7,1ba8e2e3-9dd3-42c4-98a8-f616c9adf8df
2014-03-24 19:52:10.902 UTC,fulfilled,,rimod-240570a7-9623-4a64-9b35-121b7f37812d,d16f7a91-b600-47e4-9534-92f3abddf6fc
2014-04-11 19:08:42.398 UTC,fulfilled,,rimod-88331eeb-d8e3-4b03-b764-2128220021a4,af9f760e-b366-4a26-b858-12defa938719
2014-04-11 19:09:23.103 UTC,failed,Insufficient capacity.,rimod-ed166974-2d39-4fce-8924-d69d955f21b4,93bbbca2-12f6-415a-885b-f8fa5785ea97
2014-04-11 19:15:57.768 UTC,fulfilled,,rimod-615e054d-3ba3-40f3-8eec-24f9cda1fe89,4357912c-f5e7-4f16-87c6-41e9d192cd36
2014-04-11 19:17:19.215 UTC,fulfilled,,rimod-71d57449-5bd6-48fd-b52a-7eb1f049d9d4,1ba8e2e3-0b52-4b5f-a56f-48ce53ea7d8e
2014-04-11 19:18:32.719 UTC,fulfilled,,rimod-beb55b71-daf5-478e-a6d0-1245852336a0,93bbbca2-da7e-48b6-80ff-d7668ca176d4
2014-04-11 19:19:03.159 UTC,fulfilled,,rimod-b9d39147-6d3b-4cf0-bacc-427972863cfe,af9f760e-6e12-4b62-a9e6-f9c8409575c6
2014-04-11 19:19:51.595 UTC,fulfilled,,rimod-88b5c4a1-e450-4df3-8371-f804074195ed,1ba8e2e3-5f98-4a66-b378-dd7effe5f496
2014-04-28 19:49:19.709 UTC,fulfilled,,rimod-c3a8ce22-46ae-44e5-b392-456a7c28a6aa,d16f7a91-dec8-4619-b229-061db547155b
2014-04-28 19:49:56.516 UTC,fulfilled,,rimod-6432cd00-5050-4cad-b805-cf2200388702,4357912c-4bcc-4571-8af1-bdd255d7c4e2
2014-04-28 20:00:21.073 UTC,fulfilled,,rimod-38033241-81ec-419d-809b-59209f56c679,d16f7a91-a8f8-4294-81d3-00c71046c841
2014-05-02 20:19:29.106 UTC,failed,Insufficient capacity.,rimod-43e1a13b-8e53-41a1-a7fb-74d0cfb9f6bc,93bbbca2-c4c7-4705-880c-146dea6e73cd
2014-05-02 20:24:54.074 UTC,fulfilled,,rimod-41ffab21-6e68-46a0-bc07-8e25b8317575,93bbbca2-c4c7-4705-880c-146dea6e73cd
2014-05-02 20:25:43.584 UTC,fulfilled,,rimod-3dfd4d09-2b72-483b-bc85-725445e1dfc1,46a408c7-6f0d-4925-84f6-8ccbebf428c8
2014-05-02 20:29:20.796 UTC,fulfilled,,rimod-a4a7cc03-1ef4-4bc5-97d4-92c07b7a1c90,4357912c-4b68-43c7-9cd0-7aee5707e462
2014-05-02 20:34:59.362 UTC,fulfilled,,rimod-1fe5e141-3d10-4dab-8006-c21f73789df8,d16f7a91-3242-4e91-9c70-9dc2a12cbc1a
2014-05-02 20:36:53.517 UTC,fulfilled,,rimod-0ad947e4-2730-4412-9dc2-baaacfa8890f,bbcd9749-cfd7-4a89-a39e-62d8b31ae8f5
2014-05-06 17:12:37.883 UTC,failed,Insufficient capacity.,rimod-033b0af3-c2c8-44b9-8f75-8bd24785b649,1ba8e2e3-26f3-47e7-8568-1983d27cd642
2014-05-06 17:14:37.395 UTC,fulfilled,,rimod-32cab317-c453-4485-b91c-275d1ddd8815,4357912c-fd1d-4464-959f-3738da6f3378
2014-05-09 20:44:43.494 UTC,failed,Insufficient capacity.,rimod-643c2a22-52fe-46c2-87da-3f9ca9c5e3d7,4357912c-c3e9-4eab-a30b-42393c3fce2d
2014-05-09 20:46:50.16 UTC,fulfilled,,rimod-16c0f631-583a-4c98-93a4-32f3ef9584f3,46a408c7-bad4-4c49-bb15-d8485d76dc92
2014-05-23 19:39:21.813 UTC,fulfilled,,rimod-51ac02b1-b867-48d5-987e-9ab5a29b11f0,9d5cb137-bfe1-4ec7-b464-27e29175bef7
2014-05-23 19:44:12.861 UTC,failed,Insufficient capacity.,rimod-f371be7d-ad62-4586-a0f3-354c44b7e215,1ba8e2e3-26f3-47e7-8568-1983d27cd642
2014-05-23 19:44:49.787 UTC,fulfilled,,rimod-1583f2b0-b784-42c2-8db9-bf6598ab9e8f,9d5cb137-1b5d-4bfe-b671-1aca5c599978
2014-06-02 22:22:48.52 UTC,failed,Insufficient capacity.,rimod-bfa654a3-4f8d-4f10-8e6c-bd3f91dcd6ed,4357912c-c3e9-4eab-a30b-42393c3fce2d
2014-12-02 22:21:01.231 UTC,fulfilled,,rimod-4c95242a-d325-4dd4-a50a-619df790be1f,f127bd27-9d47-4302-9543-f889f74f606b
2014-12-02 22:22:24.15 UTC,fulfilled,,rimod-5aca115a-4fee-4a51-a568-0ef4d0b1d5a6,4357912c-13b2-4d24-a672-a876999ee1ed
2014-12-02 22:23:39.606 UTC,fulfilled,,rimod-6e63412d-7f1b-44e4-a357-237e6f01e453,4357912c-ffec-43e9-bfd1-5a1413e9266d
2014-12-02 22:28:09.228 UTC,fulfilled,,rimod-ad9ade35-e3d8-49d7-914a-425757141a04,46a408c7-f2a2-4e77-be3d-7d68de80e9ce

AWS CLI

$ aws --debug ec2 describe-reserved-instances-modifications

Snipped to the last bit where the pagination continues.

            <modificationResultSet>
                <item>
                    <reservedInstancesId>09097195-b11c-4460-ba1e-31a3efd7c84e</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1a</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>2</instanceCount>
                        <instanceType>c3.4xlarge</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <reservedInstancesId>6854cd56-0441-41ed-8278-a501fb6e043e</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1a</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>16</instanceCount>
                        <instanceType>c3.2xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-02T22:28:09.228Z</createDate>
            <updateDate>2014-12-02T22:49:32.534Z</updateDate>
            <effectiveDate>2014-12-02T22:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>a3fcea06-4fbc-43ac-b364-48e3226b9343</clientToken>
        </item>
    </reservedInstancesModificationsSet>
    <nextToken>nk78PD7bIJeSjQYi4URwrdpwV0Cm4KR5RpHzbyle63w=</nextToken>
</DescribeReservedInstancesModificationsResponse>
2015-01-27 10:09:42,818 - MainThread - botocore.hooks - DEBUG - Event needs-retry.ec2.DescribeReservedInstancesModifications: calling handler <botocore.retryhandler.RetryHandler object at 0x10c26ed90>
2015-01-27 10:09:42,818 - MainThread - botocore.retryhandler - DEBUG - No retry needed.
2015-01-27 10:09:42,818 - MainThread - botocore.hooks - DEBUG - Event after-call.ec2.DescribeReservedInstancesModifications: calling handler <awscli.errorhandler.ErrorHandler object at 0x10c0434d0>
2015-01-27 10:09:42,818 - MainThread - awscli.errorhandler - DEBUG - HTTP Response Code: 200
2015-01-27 10:09:42,818 - MainThread - botocore.operation - DEBUG - Operation:DescribeReservedInstancesModifications called with kwargs: {u'NextToken': 'nk78PD7bIJeSjQYi4URwrdpwV0Cm4KR5RpHzbyle63w='}
2015-01-27 10:09:42,818 - MainThread - botocore.endpoint - DEBUG - Making request for <botocore.model.OperationModel object at 0x10c309dd0> (verify_ssl=True) with params: {'query_string': '', 'headers': {}, 'url_path': '/', 'body': {'Action': u'DescribeReservedInstancesModifications', 'Version': u'2014-10-01', u'NextToken': 'nk78PD7bIJeSjQYi4URwrdpwV0Cm4KR5RpHzbyle63w='}, 'method': u'POST'}
2015-01-27 10:09:42,819 - MainThread - botocore.auth - DEBUG - Calculating signature using v4 auth.
2015-01-27 10:09:42,819 - MainThread - botocore.auth - DEBUG - CanonicalRequest:
POST
/

host:ec2.us-east-1.amazonaws.com
user-agent:aws-cli/1.7.0 Python/2.7.6 Darwin/14.0.0
x-amz-date:20150127T200942Z

host;user-agent;x-amz-date
3086d5ee025aca418e711058579e9740693a0d2da2a1a077c96fda7cbfd78c23
2015-01-27 10:09:42,819 - MainThread - botocore.auth - DEBUG - StringToSign:
AWS4-HMAC-SHA256
20150127T200942Z
20150127/us-east-1/ec2/aws4_request
8f576bee12a65675bb06c749492f3528c9bd7d1f8b8ed5591d7e13b5fd8eb58c
2015-01-27 10:09:42,819 - MainThread - botocore.auth - DEBUG - Signature:
a839fd180237da3db6548e0e639ebcd6a3c5e624c33184cb2a5069985f6e8627
2015-01-27 10:09:42,820 - MainThread - botocore.endpoint - DEBUG - Sending http request: <PreparedRequest [POST]>
2015-01-27 10:09:43,333 - MainThread - botocore.vendored.requests.packages.urllib3.connectionpool - DEBUG - "POST / HTTP/1.1" 200 None
2015-01-27 10:09:43,475 - MainThread - botocore.parsers - DEBUG - Response headers:
{'content-type': 'text/xml;charset=UTF-8',
 'date': 'Tue, 27 Jan 2015 20:09:42 GMT',
 'server': 'AmazonEC2',
 'transfer-encoding': 'chunked',
 'vary': 'Accept-Encoding'}
2015-01-27 10:09:43,475 - MainThread - botocore.parsers - DEBUG - Response body:
<?xml version="1.0" encoding="UTF-8"?>
<DescribeReservedInstancesModificationsResponse xmlns="http://ec2.amazonaws.com/doc/2014-10-01/">
    <requestId>9d3564b7-102c-4ad3-bde1-e82a3d99e6c3</requestId>
    <reservedInstancesModificationsSet>
        <item>
            <reservedInstancesModificationId>rimod-e2a0acfa-d684-420e-a5a4-c0925f1ef165</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>4357912c-1131-414d-9245-bfd476d92e9d</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>31010758-6028-4eed-8407-23ced7b59546</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1a</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>2</instanceCount>
                        <instanceType>c3.2xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-02T22:46:37.085Z</createDate>
            <updateDate>2014-12-02T23:01:51.992Z</updateDate>
            <effectiveDate>2014-12-02T22:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>f94d6f6d-3f8e-4fac-ae08-9a3deaa1444d</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-d92963ad-d784-4a7b-a0fc-308e36a22f41</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>1ba8e2e3-23be-41f6-9a70-99e7b721afda</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>aa6e34dc-d46d-44d5-9631-c206c04f1d20</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1a</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>4</instanceCount>
                        <instanceType>c3.2xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-02T22:47:19.438Z</createDate>
            <updateDate>2014-12-02T23:02:36.640Z</updateDate>
            <effectiveDate>2014-12-02T22:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>718374c9-1732-4139-8056-13f97baaa420</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-9facc783-6f7e-4f78-a609-6b627a0559c3</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>93bbbca2-7b10-459a-b34f-f97c56f9da80</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>977f0ae0-df46-4485-88d0-6772fc67bd49</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1d</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>6</instanceCount>
                        <instanceType>c3.4xlarge</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <reservedInstancesId>ea24db09-2ac8-44cf-9e42-7bdd17eb13fd</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1c</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>5</instanceCount>
                        <instanceType>c3.2xlarge</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <reservedInstancesId>d7664b71-b221-488e-aea3-735353ab05f5</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1a</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>12</instanceCount>
                        <instanceType>c3.large</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-02T23:17:30.631Z</createDate>
            <updateDate>2014-12-02T23:32:45.904Z</updateDate>
            <effectiveDate>2014-12-02T23:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>9bf04091-d205-475a-a945-0f2aff1980df</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-2234cf89-a0ae-4d64-8f82-ef7cdff556da</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>1ba8e2e3-5c22-445a-a3e3-554f30f3f994</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1a</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>5</instanceCount>
                        <instanceType>c1.medium</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1c</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>2</instanceCount>
                        <instanceType>c1.medium</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1e</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>4</instanceCount>
                        <instanceType>c1.medium</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-05T21:01:41.758Z</createDate>
            <updateDate>2014-12-05T21:01:55.880Z</updateDate>
            <effectiveDate>2014-12-05T21:00:00.000Z</effectiveDate>
            <status>failed</status>
            <statusMessage>Insufficient capacity.</statusMessage>
            <clientToken>2cae2ee7-35bc-4d94-b392-05b41187ada3</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-547b636e-c4e1-4e1a-9974-5d115b8ae3a9</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>bbcd9749-ce97-4e6a-b0a4-332eaa4893ca</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1e</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>1</instanceCount>
                        <instanceType>c1.xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-05T21:02:05.797Z</createDate>
            <updateDate>2014-12-05T21:02:16.997Z</updateDate>
            <effectiveDate>2014-12-05T21:00:00.000Z</effectiveDate>
            <status>failed</status>
            <statusMessage>Insufficient capacity.</statusMessage>
            <clientToken>90890694-d0d1-45ff-88c1-57c62a3db23e</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-4bab3ee7-a232-4f40-9618-d9a23a3f3454</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>bbcd9749-15e9-4b4e-b2e6-00cf858f3c11</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>da8de600-f2bd-4244-af8b-3737a9eb5a47</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1d</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>1</instanceCount>
                        <instanceType>m2.4xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-05T21:04:42.099Z</createDate>
            <updateDate>2014-12-05T21:16:55.490Z</updateDate>
            <effectiveDate>2014-12-05T21:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>6f50f149-5b22-422a-ad3c-72e5ba35d39c</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-1cfcec7b-5296-46e8-82ac-07f594df61c2</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>6dead480-a61f-4897-a5b8-bad947dded51</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>2fa584e6-5c72-4a63-b4f0-f4b45a06e9e4</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1e</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>1</instanceCount>
                        <instanceType>m1.xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-05T21:09:40.769Z</createDate>
            <updateDate>2014-12-05T21:18:54.477Z</updateDate>
            <effectiveDate>2014-12-05T21:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>c43c2937-355f-46ab-9ff0-d61212c5949e</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-ec4dabaa-2b9d-423f-bbb1-f2a03350d28d</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>bbcd9749-79cc-4dea-a001-d030562c633d</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1d</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>5</instanceCount>
                        <instanceType>m1.medium</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1e</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>3</instanceCount>
                        <instanceType>m1.medium</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-05T21:10:36.464Z</createDate>
            <updateDate>2014-12-05T21:10:49.283Z</updateDate>
            <effectiveDate>2014-12-05T21:00:00.000Z</effectiveDate>
            <status>failed</status>
            <statusMessage>Insufficient capacity.</statusMessage>
            <clientToken>1b071428-0949-4d60-9f4a-a7bf6725c0ce</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-dd17016a-ad3b-4c50-b186-85a84361761e</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>4357912c-7b16-42e3-aed1-15c9aa15b95f</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>67244ac5-ace6-4516-98cc-955df15f9b0d</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1d</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>39</instanceCount>
                        <instanceType>m1.small</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <reservedInstancesId>789d17b4-3fa3-47db-8952-f7eef83bd7dc</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1c</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>3</instanceCount>
                        <instanceType>m1.small</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-05T21:11:36.179Z</createDate>
            <updateDate>2014-12-05T21:17:48.593Z</updateDate>
            <effectiveDate>2014-12-05T21:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>d76c911e-a9be-4254-bcae-cc2c2743cf64</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-ad9e80d6-92a3-4783-8544-bfad01ff468d</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>93bbbca2-97bc-4961-a826-66c6254e5ba8</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>baf46340-552c-4c89-bf57-bde98559756a</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1d</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>63</instanceCount>
                        <instanceType>m1.large</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <reservedInstancesId>5cb784a4-ca7e-4281-a189-0b8c90a87360</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1b</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>4</instanceCount>
                        <instanceType>m1.medium</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-05T21:13:05.521Z</createDate>
            <updateDate>2014-12-05T21:34:23.138Z</updateDate>
            <effectiveDate>2014-12-05T21:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>b70d1c49-d339-445c-ab86-91c4e54ae286</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-63eb28bb-9c79-4cc6-a8b8-2f460b7412e9</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>31010758-6028-4eed-8407-23ced7b59546</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>a354071b-cdbe-425b-bc43-19ce882d72b7</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1a</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>1</instanceCount>
                        <instanceType>c3.2xlarge</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <reservedInstancesId>65152ca5-16c6-4dc3-b3dc-6bd432acc8c6</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1e</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>1</instanceCount>
                        <instanceType>c3.2xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-05T21:14:27.155Z</createDate>
            <updateDate>2014-12-05T21:32:39.937Z</updateDate>
            <effectiveDate>2014-12-05T21:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>3ba5ee6c-bd06-4332-82d6-1fb5b2db3913</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-31b35704-d875-4f63-adaa-d2aed03166dd</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>16547f9e-e2d9-46ad-a020-178aa35449f9</reservedInstancesId>
                </item>
                <item>
                    <reservedInstancesId>1e3b5a8f-536b-4ca6-a26e-765efc7bcb10</reservedInstancesId>
                </item>
                <item>
                    <reservedInstancesId>9a044d2a-3071-45dd-add4-601bbd9b1d56</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>cafb51b2-46db-45ab-9788-4dbdf8f65fa0</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1a</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>2</instanceCount>
                        <instanceType>i2.2xlarge</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <reservedInstancesId>6ddbf4f3-a7cf-45cc-a9c4-4f9466ba6c4a</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1d</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>2</instanceCount>
                        <instanceType>i2.2xlarge</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <reservedInstancesId>d2ebb5b4-3d8b-482f-abc0-24d34f7a0e86</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1e</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>2</instanceCount>
                        <instanceType>i2.2xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-08T21:21:55.796Z</createDate>
            <updateDate>2014-12-08T21:49:17.088Z</updateDate>
            <effectiveDate>2014-12-08T21:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>2fa31e30-41a9-4030-82d5-0b764587ec62</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-b0aeb299-2e68-4522-88b2-294a9825d6ea</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>d124bc35-b356-42f4-b281-5931fc98646f</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>1f3754e8-2ad3-4eb8-a904-4f38393c7998</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1a</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>2</instanceCount>
                        <instanceType>m1.large</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <reservedInstancesId>9f9726be-cb8d-477c-a86b-1c21283ead14</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1a</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>22</instanceCount>
                        <instanceType>m1.xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-08T21:28:05.671Z</createDate>
            <updateDate>2014-12-08T21:46:20.487Z</updateDate>
            <effectiveDate>2014-12-08T21:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>8e596b76-612b-4af6-9072-45933c9f359a</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-e0a714d2-8837-4f5d-97a0-324d118a16cb</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>baf46340-552c-4c89-bf57-bde98559756a</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>a6c3a966-50bd-4a9c-aa63-440138c16e02</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1d</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>33</instanceCount>
                        <instanceType>m1.large</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <reservedInstancesId>78d610b6-2f4f-46a2-8c91-ca8387707fad</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1a</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>15</instanceCount>
                        <instanceType>m1.xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-08T21:28:53.773Z</createDate>
            <updateDate>2014-12-08T21:47:09.364Z</updateDate>
            <effectiveDate>2014-12-08T21:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>746ab983-8544-4ea3-bcf2-71ddb85ebd9a</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-fd1a2d99-b385-43ff-a27d-faaf5ed66d68</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>783b2ae7-b88c-4da6-8410-d8a390a35fa4</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>45baebe8-e6d0-4c34-a0af-2693d1f952cc</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1d</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>4</instanceCount>
                        <instanceType>c3.xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-09T22:43:50.818Z</createDate>
            <updateDate>2014-12-09T23:02:04.754Z</updateDate>
            <effectiveDate>2014-12-09T22:38:31.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>2b9ce5f6-83ee-423c-a5f2-c2874416ff33</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-b0b58d13-cd68-4f4c-a3a8-552c89c03b38</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>09097195-b11c-4460-ba1e-31a3efd7c84e</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>c157a297-bc4d-43f2-8f55-cfa89bd8f940</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1e</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>4</instanceCount>
                        <instanceType>c3.2xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-11T19:44:50.968Z</createDate>
            <updateDate>2014-12-11T20:03:04.651Z</updateDate>
            <effectiveDate>2014-12-11T19:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>14b0e301-781d-4194-a14f-8b08a3350377</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-2c1a022e-54a0-4b5c-9ad4-178e9e17b4fc</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>977f0ae0-df46-4485-88d0-6772fc67bd49</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>f155464a-b80c-4aee-af4a-092526156edd</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1d</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>5</instanceCount>
                        <instanceType>c3.4xlarge</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <reservedInstancesId>f9fd2694-1289-4bd3-b5b3-a0a33a87fd99</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1d</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>2</instanceCount>
                        <instanceType>c3.2xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-11T19:46:01.908Z</createDate>
            <updateDate>2014-12-11T20:01:17.399Z</updateDate>
            <effectiveDate>2014-12-11T19:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>931ccd1e-0f28-483c-ab96-a31a6d5cc168</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-3a3c96e6-a052-4dee-8119-a4c4e8b41e42</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>b847fa93-e27b-4ce6-8ac2-5dd021813f3b</reservedInstancesId>
                </item>
                <item>
                    <reservedInstancesId>d16f7a91-d798-4d92-b4b3-b14024e59d4d</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>c0a6dd4c-4329-44ac-8f69-0aa6e4de4b12</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1a</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>48</instanceCount>
                        <instanceType>m1.small</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-11T21:34:42.159Z</createDate>
            <updateDate>2014-12-11T21:46:56.056Z</updateDate>
            <effectiveDate>2014-12-11T21:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>4834c606-c5e6-4663-b212-64e7c47a1986</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-0a46b031-76eb-4906-a553-9affc313f70e</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>bbcd9749-7994-453d-8b70-68bdc0e7df75</reservedInstancesId>
                </item>
                <item>
                    <reservedInstancesId>d16f7a91-7420-44be-9461-97d1c0836969</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>8d28a379-ec79-4378-95a0-c53e8f0eff56</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1b</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>29</instanceCount>
                        <instanceType>m1.small</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-11T21:35:06.025Z</createDate>
            <updateDate>2014-12-11T21:47:22.461Z</updateDate>
            <effectiveDate>2014-12-11T21:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>f951f67c-efc6-41c9-a510-901b692fa7bd</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-199ebab1-8fae-468c-a025-83e2ed11827f</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>789d17b4-3fa3-47db-8952-f7eef83bd7dc</reservedInstancesId>
                </item>
                <item>
                    <reservedInstancesId>1ba8e2e3-1ed3-436f-baa7-4f23b61a869b</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>8e523110-560a-4f39-8f48-16d5ce9f9674</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1c</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>4</instanceCount>
                        <instanceType>m1.small</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-11T21:35:35.443Z</createDate>
            <updateDate>2014-12-11T21:47:52.290Z</updateDate>
            <effectiveDate>2014-12-11T21:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>82a06f60-95d7-4788-b63c-14da12b6f286</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-74b08668-b35e-4f2f-99be-fbf89f576f3f</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>4357912c-83bf-4f05-a11d-f8677abbb721</reservedInstancesId>
                </item>
                <item>
                    <reservedInstancesId>80f1b8ba-e9ed-4b02-b15a-f0f3772624b2</reservedInstancesId>
                </item>
                <item>
                    <reservedInstancesId>d16f7a91-014c-4efb-a5fa-1c4266392af1</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>b4b51dcf-75f3-45b7-b908-0ec6956952fa</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1a</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>18</instanceCount>
                        <instanceType>m1.medium</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-11T21:36:01.685Z</createDate>
            <updateDate>2014-12-11T21:48:21.162Z</updateDate>
            <effectiveDate>2014-12-11T21:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>9ec32452-351f-42e7-8f6b-5a5324e4b7c8</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-f8cd3187-95ce-4314-97f4-fa3fe14900e3</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>9d5cb137-077a-403d-9930-b3791f597669</reservedInstancesId>
                </item>
                <item>
                    <reservedInstancesId>5cb784a4-ca7e-4281-a189-0b8c90a87360</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>0dc65239-2a1d-42d9-bbcd-a9610dc8bea9</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1b</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>5</instanceCount>
                        <instanceType>m1.medium</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-11T21:36:12.739Z</createDate>
            <updateDate>2014-12-11T21:48:27.357Z</updateDate>
            <effectiveDate>2014-12-11T21:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>d5096de3-0b4e-49e1-a89f-497314854850</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-0828d96e-8a29-46ef-a6da-2ff1f47ea4a8</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>f127bd27-c7a3-4e36-83af-1d14f923b9fb</reservedInstancesId>
                </item>
                <item>
                    <reservedInstancesId>1ba8e2e3-d0ca-4596-ab85-4153ea710c52</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>7f40bfe5-76ea-4b9e-8f55-aaf5cc1cddfe</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1c</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>2</instanceCount>
                        <instanceType>m1.medium</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-11T21:36:25.812Z</createDate>
            <updateDate>2014-12-11T21:48:38.662Z</updateDate>
            <effectiveDate>2014-12-11T21:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>f15d63a2-006d-4659-b77d-7ebb785612f3</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-b23ccdac-46b1-4618-8cc2-5fe8cfb700ee</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>af9f760e-214d-4a72-a387-acadac79cbb1</reservedInstancesId>
                </item>
                <item>
                    <reservedInstancesId>46a408c7-f8d3-40fd-866f-1788e720c5af</reservedInstancesId>
                </item>
                <item>
                    <reservedInstancesId>9d5cb137-35ba-4acb-b223-c7271a302c1d</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>6fd15cb5-a5ae-4878-b0c4-8df8eacc2f95</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1a</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>64</instanceCount>
                        <instanceType>m1.large</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-11T21:36:53.059Z</createDate>
            <updateDate>2014-12-11T21:49:05.995Z</updateDate>
            <effectiveDate>2014-12-11T21:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>91917835-7195-427f-9a18-e4c3ce1d9636</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-6d14a3be-031e-4ba2-87c1-79af4bd7dffb</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>d16f7a91-d0d2-40fa-a821-68d3ea7ef0a7</reservedInstancesId>
                </item>
                <item>
                    <reservedInstancesId>9f9726be-cb8d-477c-a86b-1c21283ead14</reservedInstancesId>
                </item>
                <item>
                    <reservedInstancesId>93bbbca2-4b1c-47b7-952a-b74f71f94e03</reservedInstancesId>
                </item>
                <item>
                    <reservedInstancesId>78d610b6-2f4f-46a2-8c91-ca8387707fad</reservedInstancesId>
                </item>
                <item>
                    <reservedInstancesId>af9f760e-4ca7-45f2-947f-221173a647ec</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>bc7a6ac4-364f-4f3b-a299-d000038ae8f3</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1a</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>60</instanceCount>
                        <instanceType>m1.xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-11T21:37:32.392Z</createDate>
            <updateDate>2014-12-11T21:49:45.608Z</updateDate>
            <effectiveDate>2014-12-11T21:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>c7b770fb-baf9-467e-985f-a77b5c7b3f52</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-e2aa2484-b465-4eac-abd0-28f816053340</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>93bbbca2-caca-49bf-ab49-63fb62982e87</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1b</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>22</instanceCount>
                        <instanceType>m1.large</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1e</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>22</instanceCount>
                        <instanceType>m1.large</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-17T21:07:57.394Z</createDate>
            <updateDate>2014-12-17T21:08:08.935Z</updateDate>
            <effectiveDate>2014-12-17T21:00:00.000Z</effectiveDate>
            <status>failed</status>
            <statusMessage>Insufficient capacity.</statusMessage>
            <clientToken>e7b97efb-00a7-4d5b-9dff-1b301d4257bd</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-1d05d66c-ca39-48e2-a14b-6062d0a412ec</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>4357912c-8c8d-4ecc-8772-a348ade940eb</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1c</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>15</instanceCount>
                        <instanceType>m1.large</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1e</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>5</instanceCount>
                        <instanceType>m1.large</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1d</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>1</instanceCount>
                        <instanceType>m1.large</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-17T21:08:55.516Z</createDate>
            <updateDate>2014-12-17T21:09:07.337Z</updateDate>
            <effectiveDate>2014-12-17T21:00:00.000Z</effectiveDate>
            <status>failed</status>
            <statusMessage>Insufficient capacity.</statusMessage>
            <clientToken>e45da696-23e4-48aa-abe4-d54654866774</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-603ed142-0684-4a52-8545-fa73db7cffe2</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>bbcd9749-61a8-43ad-9ac4-8ce75e5fc32a</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1a</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>3</instanceCount>
                        <instanceType>c1.medium</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1e</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>4</instanceCount>
                        <instanceType>c1.medium</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1c</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>2</instanceCount>
                        <instanceType>c1.medium</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1e</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>1</instanceCount>
                        <instanceType>c1.xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2014-12-17T21:11:00.275Z</createDate>
            <updateDate>2014-12-17T21:11:12.786Z</updateDate>
            <effectiveDate>2014-12-17T21:00:00.000Z</effectiveDate>
            <status>failed</status>
            <statusMessage>Insufficient capacity.</statusMessage>
            <clientToken>4a9ccd84-2686-4115-a0dc-5b5108f0990c</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-e702fc8b-6cd0-4421-98ac-921b677ad2fc</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>93bbbca2-caca-49bf-ab49-63fb62982e87</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1b</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>18</instanceCount>
                        <instanceType>m1.large</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1e</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>26</instanceCount>
                        <instanceType>m1.large</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2015-01-22T18:58:57.597Z</createDate>
            <updateDate>2015-01-22T18:59:09.095Z</updateDate>
            <effectiveDate>2015-01-22T18:00:00.000Z</effectiveDate>
            <status>failed</status>
            <statusMessage>Insufficient capacity.</statusMessage>
            <clientToken>db62c9c9-bc31-4aa1-91dc-3dab245fc2ef</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-dbe0d843-b2e3-40e5-b506-16d4b133e92f</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>f127bd27-1c5e-4f7b-8edc-a1c7f894fd0a</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1b</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>1</instanceCount>
                        <instanceType>c1.xlarge</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1e</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>1</instanceCount>
                        <instanceType>c1.xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2015-01-22T19:51:46.850Z</createDate>
            <updateDate>2015-01-22T19:51:58.770Z</updateDate>
            <effectiveDate>2015-01-22T19:00:00.000Z</effectiveDate>
            <status>failed</status>
            <statusMessage>Insufficient capacity.</statusMessage>
            <clientToken>bb99db2a-1bc3-4921-84bb-b9988655df93</clientToken>
        </item>
    </reservedInstancesModificationsSet>
    <nextToken>YFpl0bFdNq6HU+/AjvYhGtpwV0Cm4KR5RpHzbyle63w=</nextToken>
</DescribeReservedInstancesModificationsResponse>
2015-01-27 10:09:43,483 - MainThread - botocore.hooks - DEBUG - Event needs-retry.ec2.DescribeReservedInstancesModifications: calling handler <botocore.retryhandler.RetryHandler object at 0x10c26ed90>
2015-01-27 10:09:43,483 - MainThread - botocore.retryhandler - DEBUG - No retry needed.
2015-01-27 10:09:43,483 - MainThread - botocore.hooks - DEBUG - Event after-call.ec2.DescribeReservedInstancesModifications: calling handler <awscli.errorhandler.ErrorHandler object at 0x10c0434d0>
2015-01-27 10:09:43,483 - MainThread - awscli.errorhandler - DEBUG - HTTP Response Code: 200
2015-01-27 10:09:43,483 - MainThread - botocore.operation - DEBUG - Operation:DescribeReservedInstancesModifications called with kwargs: {u'NextToken': 'YFpl0bFdNq6HU+/AjvYhGtpwV0Cm4KR5RpHzbyle63w='}
2015-01-27 10:09:43,483 - MainThread - botocore.endpoint - DEBUG - Making request for <botocore.model.OperationModel object at 0x10c309dd0> (verify_ssl=True) with params: {'query_string': '', 'headers': {}, 'url_path': '/', 'body': {'Action': u'DescribeReservedInstancesModifications', 'Version': u'2014-10-01', u'NextToken': 'YFpl0bFdNq6HU+/AjvYhGtpwV0Cm4KR5RpHzbyle63w='}, 'method': u'POST'}
2015-01-27 10:09:43,484 - MainThread - botocore.auth - DEBUG - Calculating signature using v4 auth.
2015-01-27 10:09:43,484 - MainThread - botocore.auth - DEBUG - CanonicalRequest:
POST
/

host:ec2.us-east-1.amazonaws.com
user-agent:aws-cli/1.7.0 Python/2.7.6 Darwin/14.0.0
x-amz-date:20150127T200943Z

host;user-agent;x-amz-date
82721ac7454925da076065377ab93799a434be16369438b71f9cffa74e6f69d6
2015-01-27 10:09:43,484 - MainThread - botocore.auth - DEBUG - StringToSign:
AWS4-HMAC-SHA256
20150127T200943Z
20150127/us-east-1/ec2/aws4_request
38a80a25e10a41176c443923ed8c59299d40d9f48b19c29d3661a0a01b3d22c7
2015-01-27 10:09:43,484 - MainThread - botocore.auth - DEBUG - Signature:
e1a7ecc9c2ad477424d68d2ec4e3f9f30f27d320c328faa2ca9e99cef77ec05f
2015-01-27 10:09:43,485 - MainThread - botocore.endpoint - DEBUG - Sending http request: <PreparedRequest [POST]>
2015-01-27 10:09:43,812 - MainThread - botocore.vendored.requests.packages.urllib3.connectionpool - DEBUG - "POST / HTTP/1.1" 200 None
2015-01-27 10:09:43,815 - MainThread - botocore.parsers - DEBUG - Response headers:
{'content-type': 'text/xml;charset=UTF-8',
 'date': 'Tue, 27 Jan 2015 20:09:42 GMT',
 'server': 'AmazonEC2',
 'transfer-encoding': 'chunked',
 'vary': 'Accept-Encoding'}
2015-01-27 10:09:43,815 - MainThread - botocore.parsers - DEBUG - Response body:
<?xml version="1.0" encoding="UTF-8"?>
<DescribeReservedInstancesModificationsResponse xmlns="http://ec2.amazonaws.com/doc/2014-10-01/">
    <requestId>c6b08ec6-964e-49e8-9a2a-6b39c66fda3b</requestId>
    <reservedInstancesModificationsSet>
        <item>
            <reservedInstancesModificationId>rimod-9657cf08-4e17-496c-bf52-9d5a3d7c9d66</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>da8de600-f2bd-4244-af8b-3737a9eb5a47</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>339a970a-87fa-4a97-bad6-120d50e90e57</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1b</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>1</instanceCount>
                        <instanceType>m2.2xlarge</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <reservedInstancesId>5ff29764-0261-47ab-88fd-fba946e447b3</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1a</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>1</instanceCount>
                        <instanceType>m2.2xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2015-01-22T19:53:39.610Z</createDate>
            <updateDate>2015-01-22T20:08:52.822Z</updateDate>
            <effectiveDate>2015-01-22T19:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>5e61a476-9db9-4a9b-b780-d9f05f88d00f</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-b76f4abe-e60a-40f8-95fb-44ef714e7d58</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>bbcd9749-45ac-4b1f-a2c5-63a34aab2549</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>cdabeebc-9ed4-4e4a-9949-4421da0e5241</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1d</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>4</instanceCount>
                        <instanceType>m2.xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2015-01-22T19:54:31.983Z</createDate>
            <updateDate>2015-01-22T20:09:46.128Z</updateDate>
            <effectiveDate>2015-01-22T19:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>df121207-521b-4aae-ad12-d5469b9c940e</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-76cdf433-556e-49f0-b803-a1e5e95b6d81</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>bc7a6ac4-364f-4f3b-a299-d000038ae8f3</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1e</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>26</instanceCount>
                        <instanceType>m1.large</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1a</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>47</instanceCount>
                        <instanceType>m1.xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2015-01-23T05:17:47.401Z</createDate>
            <updateDate>2015-01-23T05:17:58.891Z</updateDate>
            <effectiveDate>2015-01-23T05:00:00.000Z</effectiveDate>
            <status>failed</status>
            <statusMessage>Insufficient capacity.</statusMessage>
            <clientToken>11aab180-0c03-4e42-847e-5a041e74fcb2</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-a4cb97e3-8783-4c20-bff0-c874fc31a039</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>bc7a6ac4-364f-4f3b-a299-d000038ae8f3</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1e</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>24</instanceCount>
                        <instanceType>m1.medium</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1a</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>54</instanceCount>
                        <instanceType>m1.xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2015-01-23T05:57:56.846Z</createDate>
            <updateDate>2015-01-23T05:58:19.209Z</updateDate>
            <effectiveDate>2015-01-23T05:00:00.000Z</effectiveDate>
            <status>failed</status>
            <statusMessage>Insufficient capacity.</statusMessage>
            <clientToken>9c977895-cb17-4de2-8b66-c202bd3acb16</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-00ef6d24-71ec-4ff5-8442-499e9673b56a</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>93bbbca2-caca-49bf-ab49-63fb62982e87</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1b</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>19</instanceCount>
                        <instanceType>m1.large</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1e</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>25</instanceCount>
                        <instanceType>m1.large</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2015-01-23T19:14:15.145Z</createDate>
            <updateDate>2015-01-23T19:14:27.695Z</updateDate>
            <effectiveDate>2015-01-23T19:00:00.000Z</effectiveDate>
            <status>failed</status>
            <statusMessage>Insufficient capacity.</statusMessage>
            <clientToken>f92c6ce6-0060-437d-83a9-8956643b59c9</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-c266c5f9-4e94-49a8-9c1c-956566a8c5b8</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>93bbbca2-caca-49bf-ab49-63fb62982e87</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1b</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>19</instanceCount>
                        <instanceType>m1.large</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <targetConfiguration>
                        <availabilityZone>us-east-1e</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>25</instanceCount>
                        <instanceType>m1.large</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2015-01-23T19:18:18.811Z</createDate>
            <updateDate>2015-01-23T19:18:36.466Z</updateDate>
            <effectiveDate>2015-01-23T19:00:00.000Z</effectiveDate>
            <status>failed</status>
            <statusMessage>Insufficient capacity.</statusMessage>
            <clientToken>5b88f3ca-03a4-45b3-a607-bbcadd0b593c</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-dc5a9ff2-2964-4db3-9125-2b850f26c22c</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>b847fa93-5cc2-4d44-a491-7b1e3e4f1543</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>130e039a-a4ed-48aa-8e7f-e48574098e22</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1d</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>4</instanceCount>
                        <instanceType>m2.4xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2015-01-23T22:08:39.764Z</createDate>
            <updateDate>2015-01-23T22:17:54.264Z</updateDate>
            <effectiveDate>2015-01-23T22:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>a3df9cb0-9277-4ee9-9ef2-0b4464d30401</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-cff9ae87-df94-4631-8e40-4e74119bfe3a</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>cdabeebc-9ed4-4e4a-9949-4421da0e5241</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>f96c636b-2fcb-4209-8e1a-fb6a429f44df</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1d</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>1</instanceCount>
                        <instanceType>m2.xlarge</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <reservedInstancesId>c848152d-2b08-4d96-9693-2924cad038a4</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1a</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>3</instanceCount>
                        <instanceType>m2.xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2015-01-24T00:47:06.342Z</createDate>
            <updateDate>2015-01-24T01:05:21.336Z</updateDate>
            <effectiveDate>2015-01-24T00:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>448f9d25-0ad4-49c5-bd78-bdae6b2096c2</clientToken>
        </item>
        <item>
            <reservedInstancesModificationId>rimod-6ada32b4-6b5a-4165-a432-3af128c7fdd4</reservedInstancesModificationId>
            <reservedInstancesSet>
                <item>
                    <reservedInstancesId>130e039a-a4ed-48aa-8e7f-e48574098e22</reservedInstancesId>
                </item>
            </reservedInstancesSet>
            <modificationResultSet>
                <item>
                    <reservedInstancesId>c1a6acde-10ab-4997-9958-7b1da06a4e02</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1c</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>2</instanceCount>
                        <instanceType>m2.4xlarge</instanceType>
                    </targetConfiguration>
                </item>
                <item>
                    <reservedInstancesId>934cd54f-d6a2-4048-8f2a-21bca3a9fe7e</reservedInstancesId>
                    <targetConfiguration>
                        <availabilityZone>us-east-1b</availabilityZone>
                        <platform>EC2-Classic</platform>
                        <instanceCount>2</instanceCount>
                        <instanceType>m2.4xlarge</instanceType>
                    </targetConfiguration>
                </item>
            </modificationResultSet>
            <createDate>2015-01-24T03:08:43.547Z</createDate>
            <updateDate>2015-01-24T03:20:58.927Z</updateDate>
            <effectiveDate>2015-01-24T03:00:00.000Z</effectiveDate>
            <status>fulfilled</status>
            <clientToken>ABC123</clientToken>
        </item>
    </reservedInstancesModificationsSet>
</DescribeReservedInstancesModificationsResponse>
2015-01-27 10:09:43,818 - MainThread - botocore.hooks - DEBUG - Event needs-retry.ec2.DescribeReservedInstancesModifications: calling handler <botocore.retryhandler.RetryHandler object at 0x10c26ed90>
2015-01-27 10:09:43,818 - MainThread - botocore.retryhandler - DEBUG - No retry needed.
2015-01-27 10:09:43,818 - MainThread - botocore.hooks - DEBUG - Event after-call.ec2.DescribeReservedInstancesModifications: calling handler <awscli.errorhandler.ErrorHandler object at 0x10c0434d0>
2015-01-27 10:09:43,818 - MainThread - awscli.errorhandler - DEBUG - HTTP Response Code: 200
{
    "ReservedInstancesModifications": [
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "46a408c7-3d9b-49f9-9ebb-208270401aab", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m1.xlarge", 
                        "InstanceCount": 21
                    }
                }, 
                {
                    "ReservedInstancesId": "93bbbca2-da7e-48b6-80ff-d7668ca176d4", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "m1.xlarge", 
                        "InstanceCount": 1
                    }
                }
            ], 
            "EffectiveDate": "2014-03-24T19:00:00.000Z", 
            "CreateDate": "2014-03-24T19:51:35.356Z", 
            "UpdateDate": "2014-03-24T20:06:45.919Z", 
            "ClientToken": "f26cd1d9-b8d7-48a9-8b19-f49edf77acbb", 
            "ReservedInstancesModificationId": "rimod-3cbfc788-38f2-4e1f-9173-00583fe719b7", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "1ba8e2e3-9dd3-42c4-98a8-f616c9adf8df"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "1ba8e2e3-5f98-4a66-b378-dd7effe5f496", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "m2.4xlarge", 
                        "InstanceCount": 1
                    }
                }, 
                {
                    "ReservedInstancesId": "1ba8e2e3-1b7c-494b-975b-45f42769ab30", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m2.4xlarge", 
                        "InstanceCount": 4
                    }
                }
            ], 
            "EffectiveDate": "2014-03-24T19:00:00.000Z", 
            "CreateDate": "2014-03-24T19:52:10.902Z", 
            "UpdateDate": "2014-03-24T20:07:18.580Z", 
            "ClientToken": "d5ba95af-a0c1-454e-a5f4-392ad507b86e", 
            "ReservedInstancesModificationId": "rimod-240570a7-9623-4a64-9b35-121b7f37812d", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "d16f7a91-b600-47e4-9534-92f3abddf6fc"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "93bbbca2-657b-49e7-b0b3-1235804fb29d", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1d", 
                        "InstanceType": "c1.xlarge", 
                        "InstanceCount": 9
                    }
                }, 
                {
                    "ReservedInstancesId": "b847fa93-01ce-42c0-ba81-2f640f780323", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "c1.xlarge", 
                        "InstanceCount": 1
                    }
                }
            ], 
            "EffectiveDate": "2014-04-11T19:00:00.000Z", 
            "CreateDate": "2014-04-11T19:08:42.398Z", 
            "UpdateDate": "2014-04-11T19:17:50.176Z", 
            "ClientToken": "d1b05ed2-737d-43ef-a8d0-ba2181a510cf", 
            "ReservedInstancesModificationId": "rimod-88331eeb-d8e3-4b03-b764-2128220021a4", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "af9f760e-b366-4a26-b858-12defa938719"
                }
            ]
        }, 
        {
            "Status": "failed", 
            "ModificationResults": [
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "c3.large", 
                        "InstanceCount": 10
                    }
                }, 
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "c3.large", 
                        "InstanceCount": 1
                    }
                }
            ], 
            "EffectiveDate": "2014-04-11T19:00:00.000Z", 
            "CreateDate": "2014-04-11T19:09:23.103Z", 
            "UpdateDate": "2014-04-11T19:09:28.563Z", 
            "ClientToken": "f0e8cde7-df2d-44be-9cb1-5912fa4d8aa2", 
            "ReservedInstancesModificationId": "rimod-ed166974-2d39-4fce-8924-d69d955f21b4", 
            "StatusMessage": "Insufficient capacity.", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "93bbbca2-12f6-415a-885b-f8fa5785ea97"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "4357912c-a341-4a9a-9d95-1a2c81796136", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m1.medium", 
                        "InstanceCount": 11
                    }
                }, 
                {
                    "ReservedInstancesId": "d16f7a91-b532-4414-a074-7f57e5020425", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1c", 
                        "InstanceType": "m1.medium", 
                        "InstanceCount": 1
                    }
                }
            ], 
            "EffectiveDate": "2014-04-11T19:00:00.000Z", 
            "CreateDate": "2014-04-11T19:15:57.768Z", 
            "UpdateDate": "2014-04-11T19:28:05.973Z", 
            "ClientToken": "06c63722-a733-49da-8592-f51dd76894ad", 
            "ReservedInstancesModificationId": "rimod-615e054d-3ba3-40f3-8eec-24f9cda1fe89", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "4357912c-f5e7-4f16-87c6-41e9d192cd36"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "af9f760e-663c-444f-80de-fa1a17148420", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1d", 
                        "InstanceType": "m1.small", 
                        "InstanceCount": 42
                    }
                }, 
                {
                    "ReservedInstancesId": "af9f760e-eccb-453f-b174-ae75556e6f2c", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "m1.small", 
                        "InstanceCount": 4
                    }
                }, 
                {
                    "ReservedInstancesId": "f127bd27-5dff-473f-9482-d9da0305e032", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m1.small", 
                        "InstanceCount": 5
                    }
                }
            ], 
            "EffectiveDate": "2014-04-11T19:00:00.000Z", 
            "CreateDate": "2014-04-11T19:17:19.215Z", 
            "UpdateDate": "2014-04-11T19:26:26.843Z", 
            "ClientToken": "bea7a11d-efb7-4de7-b971-18cffa140786", 
            "ReservedInstancesModificationId": "rimod-71d57449-5bd6-48fd-b52a-7eb1f049d9d4", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "1ba8e2e3-0b52-4b5f-a56f-48ce53ea7d8e"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "f127bd27-0b6d-4ec9-8293-3fcf55684ab8", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m1.xlarge", 
                        "InstanceCount": 1
                    }
                }
            ], 
            "EffectiveDate": "2014-04-11T19:00:00.000Z", 
            "CreateDate": "2014-04-11T19:18:32.719Z", 
            "UpdateDate": "2014-04-11T19:27:39.322Z", 
            "ClientToken": "588489d0-6771-4017-a9e7-28f2aaa73ef3", 
            "ReservedInstancesModificationId": "rimod-beb55b71-daf5-478e-a6d0-1245852336a0", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "93bbbca2-da7e-48b6-80ff-d7668ca176d4"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "4357912c-4831-49b8-81b4-a1c415524e13", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1c", 
                        "InstanceType": "m1.xlarge", 
                        "InstanceCount": 2
                    }
                }, 
                {
                    "ReservedInstancesId": "b847fa93-35ec-4403-8bd4-4dac0b8f699b", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m1.xlarge", 
                        "InstanceCount": 1
                    }
                }
            ], 
            "EffectiveDate": "2014-04-11T19:00:00.000Z", 
            "CreateDate": "2014-04-11T19:19:03.159Z", 
            "UpdateDate": "2014-04-11T19:28:09.497Z", 
            "ClientToken": "87471fb1-c283-4844-ae62-95043f53bcc9", 
            "ReservedInstancesModificationId": "rimod-b9d39147-6d3b-4cf0-bacc-427972863cfe", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "af9f760e-6e12-4b62-a9e6-f9c8409575c6"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "d16f7a91-6f26-42f5-b451-07187b621d70", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m2.4xlarge", 
                        "InstanceCount": 1
                    }
                }
            ], 
            "EffectiveDate": "2014-04-11T19:00:00.000Z", 
            "CreateDate": "2014-04-11T19:19:51.595Z", 
            "UpdateDate": "2014-04-11T19:25:57.966Z", 
            "ClientToken": "c64031bb-3bb6-462d-b9ff-fb397f8c1617", 
            "ReservedInstancesModificationId": "rimod-88b5c4a1-e450-4df3-8371-f804074195ed", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "1ba8e2e3-5f98-4a66-b378-dd7effe5f496"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "f127bd27-fd9c-4b45-a28c-812c81ee9ef2", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "c1.xlarge", 
                        "InstanceCount": 1
                    }
                }, 
                {
                    "ReservedInstancesId": "f127bd27-1c5e-4f7b-8edc-a1c7f894fd0a", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "c1.xlarge", 
                        "InstanceCount": 2
                    }
                }
            ], 
            "EffectiveDate": "2014-04-28T19:00:00.000Z", 
            "CreateDate": "2014-04-28T19:49:19.709Z", 
            "UpdateDate": "2014-04-28T19:58:28.116Z", 
            "ClientToken": "ca970942-a3f0-4fa5-88cf-6036b3cda83b", 
            "ReservedInstancesModificationId": "rimod-c3a8ce22-46ae-44e5-b392-456a7c28a6aa", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "d16f7a91-dec8-4619-b229-061db547155b"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "9d5cb137-35ba-4acb-b223-c7271a302c1d", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 5
                    }
                }, 
                {
                    "ReservedInstancesId": "9d5cb137-1b5d-4bfe-b671-1aca5c599978", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 45
                    }
                }
            ], 
            "EffectiveDate": "2014-04-28T19:00:00.000Z", 
            "CreateDate": "2014-04-28T19:49:56.516Z", 
            "UpdateDate": "2014-04-28T19:56:04.916Z", 
            "ClientToken": "04f354e7-70f1-4a52-b34c-f24b4fd2db3b", 
            "ReservedInstancesModificationId": "rimod-6432cd00-5050-4cad-b805-cf2200388702", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "4357912c-4bcc-4571-8af1-bdd255d7c4e2"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "af9f760e-214d-4a72-a387-acadac79cbb1", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 3
                    }
                }, 
                {
                    "ReservedInstancesId": "93bbbca2-97bc-4961-a826-66c6254e5ba8", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1d", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 65
                    }
                }
            ], 
            "EffectiveDate": "2014-04-28T20:00:00.000Z", 
            "CreateDate": "2014-04-28T20:00:21.073Z", 
            "UpdateDate": "2014-04-28T20:06:28.539Z", 
            "ClientToken": "e0d7e185-c635-4205-b03a-7f47a2e16c4d", 
            "ReservedInstancesModificationId": "rimod-38033241-81ec-419d-809b-59209f56c679", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "d16f7a91-a8f8-4294-81d3-00c71046c841"
                }
            ]
        }, 
        {
            "Status": "failed", 
            "ModificationResults": [
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "c3.large", 
                        "InstanceCount": 10
                    }
                }, 
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "c3.large", 
                        "InstanceCount": 1
                    }
                }
            ], 
            "EffectiveDate": "2014-05-02T20:00:00.000Z", 
            "CreateDate": "2014-05-02T20:19:29.106Z", 
            "UpdateDate": "2014-05-02T20:19:35.304Z", 
            "ClientToken": "b5a6ef31-eb8b-406d-add6-0d9a8fd8ad2a", 
            "ReservedInstancesModificationId": "rimod-43e1a13b-8e53-41a1-a7fb-74d0cfb9f6bc", 
            "StatusMessage": "Insufficient capacity.", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "93bbbca2-c4c7-4705-880c-146dea6e73cd"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "4357912c-c3e9-4eab-a30b-42393c3fce2d", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "c3.large", 
                        "InstanceCount": 7
                    }
                }, 
                {
                    "ReservedInstancesId": "af9f760e-faff-435c-9e6e-c9b16883ca10", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "c3.xlarge", 
                        "InstanceCount": 2
                    }
                }
            ], 
            "EffectiveDate": "2014-05-02T20:00:00.000Z", 
            "CreateDate": "2014-05-02T20:24:54.074Z", 
            "UpdateDate": "2014-05-02T20:37:03.485Z", 
            "ClientToken": "be958a5c-199b-403d-9157-8d965aeff5b7", 
            "ReservedInstancesModificationId": "rimod-41ffab21-6e68-46a0-bc07-8e25b8317575", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "93bbbca2-c4c7-4705-880c-146dea6e73cd"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "1ba8e2e3-cd1e-4d55-8dd6-621272cb5fd2", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1d", 
                        "InstanceType": "c3.xlarge", 
                        "InstanceCount": 2
                    }
                }, 
                {
                    "ReservedInstancesId": "1ba8e2e3-26f3-47e7-8568-1983d27cd642", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1c", 
                        "InstanceType": "c3.large", 
                        "InstanceCount": 4
                    }
                }
            ], 
            "EffectiveDate": "2014-05-02T20:00:00.000Z", 
            "CreateDate": "2014-05-02T20:25:43.584Z", 
            "UpdateDate": "2014-05-02T20:37:52.245Z", 
            "ClientToken": "4fbabf39-7894-4245-83df-9852ee3c3551", 
            "ReservedInstancesModificationId": "rimod-3dfd4d09-2b72-483b-bc85-725445e1dfc1", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "46a408c7-6f0d-4925-84f6-8ccbebf428c8"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "d16f7a91-014c-4efb-a5fa-1c4266392af1", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m1.medium", 
                        "InstanceCount": 9
                    }
                }
            ], 
            "EffectiveDate": "2014-05-02T20:00:00.000Z", 
            "CreateDate": "2014-05-02T20:29:20.796Z", 
            "UpdateDate": "2014-05-02T20:38:27.581Z", 
            "ClientToken": "3605d2f0-493a-48cc-b856-7b142b29ea8a", 
            "ReservedInstancesModificationId": "rimod-a4a7cc03-1ef4-4bc5-97d4-92c07b7a1c90", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "4357912c-4b68-43c7-9cd0-7aee5707e462"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "4357912c-fd1d-4464-959f-3738da6f3378", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m1.medium", 
                        "InstanceCount": 9
                    }
                }, 
                {
                    "ReservedInstancesId": "46a408c7-a571-4ba4-be27-65532f63a17e", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 1
                    }
                }
            ], 
            "EffectiveDate": "2014-05-02T20:00:00.000Z", 
            "CreateDate": "2014-05-02T20:34:59.362Z", 
            "UpdateDate": "2014-05-02T20:47:08.116Z", 
            "ClientToken": "93c6bdd1-0c99-483e-9eb9-ebde9cdd83b4", 
            "ReservedInstancesModificationId": "rimod-1fe5e141-3d10-4dab-8006-c21f73789df8", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "d16f7a91-3242-4e91-9c70-9dc2a12cbc1a"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "4357912c-ffec-43e9-bfd1-5a1413e9266d", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "m1.medium", 
                        "InstanceCount": 8
                    }
                }, 
                {
                    "ReservedInstancesId": "4357912c-83bf-4f05-a11d-f8677abbb721", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m1.medium", 
                        "InstanceCount": 1
                    }
                }
            ], 
            "EffectiveDate": "2014-05-02T20:00:00.000Z", 
            "CreateDate": "2014-05-02T20:36:53.517Z", 
            "UpdateDate": "2014-05-02T20:46:02.491Z", 
            "ClientToken": "890e418c-4da6-46aa-9e32-e173e0038d21", 
            "ReservedInstancesModificationId": "rimod-0ad947e4-2730-4412-9dc2-baaacfa8890f", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "bbcd9749-cfd7-4a89-a39e-62d8b31ae8f5"
                }
            ]
        }, 
        {
            "Status": "failed", 
            "ModificationResults": [
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "c3.large", 
                        "InstanceCount": 1
                    }
                }, 
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1c", 
                        "InstanceType": "c3.large", 
                        "InstanceCount": 3
                    }
                }
            ], 
            "EffectiveDate": "2014-05-06T17:00:00.000Z", 
            "CreateDate": "2014-05-06T17:12:37.883Z", 
            "UpdateDate": "2014-05-06T17:12:43.091Z", 
            "ClientToken": "13b83b67-f7b5-4e78-8995-e89ca4cc13ca", 
            "ReservedInstancesModificationId": "rimod-033b0af3-c2c8-44b9-8f75-8bd24785b649", 
            "StatusMessage": "Insufficient capacity.", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "1ba8e2e3-26f3-47e7-8568-1983d27cd642"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "9d5cb137-077a-403d-9930-b3791f597669", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "m1.medium", 
                        "InstanceCount": 1
                    }
                }, 
                {
                    "ReservedInstancesId": "bbcd9749-79cc-4dea-a001-d030562c633d", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1d", 
                        "InstanceType": "m1.medium", 
                        "InstanceCount": 8
                    }
                }
            ], 
            "EffectiveDate": "2014-05-06T17:00:00.000Z", 
            "CreateDate": "2014-05-06T17:14:37.395Z", 
            "UpdateDate": "2014-05-06T17:26:45.375Z", 
            "ClientToken": "79ad6f17-0b9e-47c9-9b20-a06e5e0488a9", 
            "ReservedInstancesModificationId": "rimod-32cab317-c453-4485-b91c-275d1ddd8815", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "4357912c-fd1d-4464-959f-3738da6f3378"
                }
            ]
        }, 
        {
            "Status": "failed", 
            "ModificationResults": [
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "c3.large", 
                        "InstanceCount": 1
                    }
                }, 
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "c3.large", 
                        "InstanceCount": 6
                    }
                }
            ], 
            "EffectiveDate": "2014-05-09T20:00:00.000Z", 
            "CreateDate": "2014-05-09T20:44:43.494Z", 
            "UpdateDate": "2014-05-09T20:44:48.940Z", 
            "ClientToken": "19f1728b-781d-43e0-bfb6-f503e5d1aff2", 
            "ReservedInstancesModificationId": "rimod-643c2a22-52fe-46c2-87da-3f9ca9c5e3d7", 
            "StatusMessage": "Insufficient capacity.", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "4357912c-c3e9-4eab-a30b-42393c3fce2d"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "bbcd9749-15e9-4b4e-b2e6-00cf858f3c11", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m2.4xlarge", 
                        "InstanceCount": 1
                    }
                }, 
                {
                    "ReservedInstancesId": "46a408c7-2938-4b66-978d-b653291b99df", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1d", 
                        "InstanceType": "m2.2xlarge", 
                        "InstanceCount": 3
                    }
                }
            ], 
            "EffectiveDate": "2014-05-09T20:00:00.000Z", 
            "CreateDate": "2014-05-09T20:46:50.160Z", 
            "UpdateDate": "2014-05-09T20:55:57.869Z", 
            "ClientToken": "954d4c65-072d-4cea-a70d-d80d9e8f8d1e", 
            "ReservedInstancesModificationId": "rimod-16c0f631-583a-4c98-93a4-32f3ef9584f3", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "46a408c7-bad4-4c49-bb15-d8485d76dc92"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "bbcd9749-61a8-43ad-9ac4-8ce75e5fc32a", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "c1.medium", 
                        "InstanceCount": 13
                    }
                }
            ], 
            "EffectiveDate": "2014-05-23T19:00:00.000Z", 
            "CreateDate": "2014-05-23T19:39:21.813Z", 
            "UpdateDate": "2014-05-23T19:48:29.215Z", 
            "ClientToken": "4cc6aace-e04f-40ec-9d69-42c74c1a94a4", 
            "ReservedInstancesModificationId": "rimod-51ac02b1-b867-48d5-987e-9ab5a29b11f0", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "9d5cb137-bfe1-4ec7-b464-27e29175bef7"
                }
            ]
        }, 
        {
            "Status": "failed", 
            "ModificationResults": [
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1c", 
                        "InstanceType": "c3.large", 
                        "InstanceCount": 3
                    }
                }, 
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "c3.large", 
                        "InstanceCount": 1
                    }
                }
            ], 
            "EffectiveDate": "2014-05-23T19:00:00.000Z", 
            "CreateDate": "2014-05-23T19:44:12.861Z", 
            "UpdateDate": "2014-05-23T19:44:19.631Z", 
            "ClientToken": "0bc9c870-7965-4da9-82d4-9817318128c7", 
            "ReservedInstancesModificationId": "rimod-f371be7d-ad62-4586-a0f3-354c44b7e215", 
            "StatusMessage": "Insufficient capacity.", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "1ba8e2e3-26f3-47e7-8568-1983d27cd642"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "93bbbca2-caca-49bf-ab49-63fb62982e87", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 44
                    }
                }, 
                {
                    "ReservedInstancesId": "b847fa93-53ec-416b-a17b-d5b754137d00", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 1
                    }
                }
            ], 
            "EffectiveDate": "2014-05-23T19:00:00.000Z", 
            "CreateDate": "2014-05-23T19:44:49.787Z", 
            "UpdateDate": "2014-05-23T19:56:57.460Z", 
            "ClientToken": "d8d5e899-b570-48fd-bba2-d356d6f8514c", 
            "ReservedInstancesModificationId": "rimod-1583f2b0-b784-42c2-8db9-bf6598ab9e8f", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "9d5cb137-1b5d-4bfe-b671-1aca5c599978"
                }
            ]
        }, 
        {
            "Status": "failed", 
            "ModificationResults": [
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "c3.large", 
                        "InstanceCount": 6
                    }
                }, 
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "c3.large", 
                        "InstanceCount": 1
                    }
                }
            ], 
            "EffectiveDate": "2014-06-02T22:00:00.000Z", 
            "CreateDate": "2014-06-02T22:22:48.520Z", 
            "UpdateDate": "2014-06-02T22:22:55.434Z", 
            "ClientToken": "766d39a2-1371-4433-aa6f-038032fb288e", 
            "ReservedInstancesModificationId": "rimod-bfa654a3-4f8d-4f10-8e6c-bd3f91dcd6ed", 
            "StatusMessage": "Insufficient capacity.", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "4357912c-c3e9-4eab-a30b-42393c3fce2d"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "b5786017-52ae-4c06-b4a5-21043fe2df93", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1c", 
                        "InstanceType": "m1.xlarge", 
                        "InstanceCount": 1
                    }
                }, 
                {
                    "ReservedInstancesId": "6dead480-a61f-4897-a5b8-bad947dded51", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1d", 
                        "InstanceType": "m1.xlarge", 
                        "InstanceCount": 1
                    }
                }
            ], 
            "EffectiveDate": "2014-12-02T22:00:00.000Z", 
            "CreateDate": "2014-12-02T22:21:01.231Z", 
            "UpdateDate": "2014-12-02T22:33:17.724Z", 
            "ClientToken": "b9af4f5d-9dc4-4394-8bac-00567b17e0a7", 
            "ReservedInstancesModificationId": "rimod-4c95242a-d325-4dd4-a50a-619df790be1f", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "f127bd27-9d47-4302-9543-f889f74f606b"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "e1b61ce8-3069-4f33-85e7-128cbdf2ba2c", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1d", 
                        "InstanceType": "m1.xlarge", 
                        "InstanceCount": 3
                    }
                }, 
                {
                    "ReservedInstancesId": "d124bc35-b356-42f4-b281-5931fc98646f", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 46
                    }
                }
            ], 
            "EffectiveDate": "2014-12-02T22:00:00.000Z", 
            "CreateDate": "2014-12-02T22:22:24.150Z", 
            "UpdateDate": "2014-12-02T22:50:25.471Z", 
            "ClientToken": "53bf0216-8ed1-4d75-a9aa-cee9c78ea879", 
            "ReservedInstancesModificationId": "rimod-5aca115a-4fee-4a51-a568-0ef4d0b1d5a6", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "4357912c-13b2-4d24-a672-a876999ee1ed"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "80f1b8ba-e9ed-4b02-b15a-f0f3772624b2", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m1.medium", 
                        "InstanceCount": 8
                    }
                }
            ], 
            "EffectiveDate": "2014-12-02T22:00:00.000Z", 
            "CreateDate": "2014-12-02T22:23:39.606Z", 
            "UpdateDate": "2014-12-02T22:51:38.511Z", 
            "ClientToken": "01c59429-d45e-4a05-a0bd-b9ecb957befb", 
            "ReservedInstancesModificationId": "rimod-6e63412d-7f1b-44e4-a357-237e6f01e453", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "4357912c-ffec-43e9-bfd1-5a1413e9266d"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "09097195-b11c-4460-ba1e-31a3efd7c84e", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "c3.4xlarge", 
                        "InstanceCount": 2
                    }
                }, 
                {
                    "ReservedInstancesId": "6854cd56-0441-41ed-8278-a501fb6e043e", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "c3.2xlarge", 
                        "InstanceCount": 16
                    }
                }
            ], 
            "EffectiveDate": "2014-12-02T22:00:00.000Z", 
            "CreateDate": "2014-12-02T22:28:09.228Z", 
            "UpdateDate": "2014-12-02T22:49:32.534Z", 
            "ClientToken": "a3fcea06-4fbc-43ac-b364-48e3226b9343", 
            "ReservedInstancesModificationId": "rimod-ad9ade35-e3d8-49d7-914a-425757141a04", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "46a408c7-f2a2-4e77-be3d-7d68de80e9ce"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "31010758-6028-4eed-8407-23ced7b59546", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "c3.2xlarge", 
                        "InstanceCount": 2
                    }
                }
            ], 
            "EffectiveDate": "2014-12-02T22:00:00.000Z", 
            "CreateDate": "2014-12-02T22:46:37.085Z", 
            "UpdateDate": "2014-12-02T23:01:51.992Z", 
            "ClientToken": "f94d6f6d-3f8e-4fac-ae08-9a3deaa1444d", 
            "ReservedInstancesModificationId": "rimod-e2a0acfa-d684-420e-a5a4-c0925f1ef165", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "4357912c-1131-414d-9245-bfd476d92e9d"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "aa6e34dc-d46d-44d5-9631-c206c04f1d20", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "c3.2xlarge", 
                        "InstanceCount": 4
                    }
                }
            ], 
            "EffectiveDate": "2014-12-02T22:00:00.000Z", 
            "CreateDate": "2014-12-02T22:47:19.438Z", 
            "UpdateDate": "2014-12-02T23:02:36.640Z", 
            "ClientToken": "718374c9-1732-4139-8056-13f97baaa420", 
            "ReservedInstancesModificationId": "rimod-d92963ad-d784-4a7b-a0fc-308e36a22f41", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "1ba8e2e3-23be-41f6-9a70-99e7b721afda"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "977f0ae0-df46-4485-88d0-6772fc67bd49", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1d", 
                        "InstanceType": "c3.4xlarge", 
                        "InstanceCount": 6
                    }
                }, 
                {
                    "ReservedInstancesId": "ea24db09-2ac8-44cf-9e42-7bdd17eb13fd", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1c", 
                        "InstanceType": "c3.2xlarge", 
                        "InstanceCount": 5
                    }
                }, 
                {
                    "ReservedInstancesId": "d7664b71-b221-488e-aea3-735353ab05f5", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "c3.large", 
                        "InstanceCount": 12
                    }
                }
            ], 
            "EffectiveDate": "2014-12-02T23:00:00.000Z", 
            "CreateDate": "2014-12-02T23:17:30.631Z", 
            "UpdateDate": "2014-12-02T23:32:45.904Z", 
            "ClientToken": "9bf04091-d205-475a-a945-0f2aff1980df", 
            "ReservedInstancesModificationId": "rimod-9facc783-6f7e-4f78-a609-6b627a0559c3", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "93bbbca2-7b10-459a-b34f-f97c56f9da80"
                }
            ]
        }, 
        {
            "Status": "failed", 
            "ModificationResults": [
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "c1.medium", 
                        "InstanceCount": 5
                    }
                }, 
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1c", 
                        "InstanceType": "c1.medium", 
                        "InstanceCount": 2
                    }
                }, 
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1e", 
                        "InstanceType": "c1.medium", 
                        "InstanceCount": 4
                    }
                }
            ], 
            "EffectiveDate": "2014-12-05T21:00:00.000Z", 
            "CreateDate": "2014-12-05T21:01:41.758Z", 
            "UpdateDate": "2014-12-05T21:01:55.880Z", 
            "ClientToken": "2cae2ee7-35bc-4d94-b392-05b41187ada3", 
            "ReservedInstancesModificationId": "rimod-2234cf89-a0ae-4d64-8f82-ef7cdff556da", 
            "StatusMessage": "Insufficient capacity.", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "1ba8e2e3-5c22-445a-a3e3-554f30f3f994"
                }
            ]
        }, 
        {
            "Status": "failed", 
            "ModificationResults": [
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1e", 
                        "InstanceType": "c1.xlarge", 
                        "InstanceCount": 1
                    }
                }
            ], 
            "EffectiveDate": "2014-12-05T21:00:00.000Z", 
            "CreateDate": "2014-12-05T21:02:05.797Z", 
            "UpdateDate": "2014-12-05T21:02:16.997Z", 
            "ClientToken": "90890694-d0d1-45ff-88c1-57c62a3db23e", 
            "ReservedInstancesModificationId": "rimod-547b636e-c4e1-4e1a-9974-5d115b8ae3a9", 
            "StatusMessage": "Insufficient capacity.", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "bbcd9749-ce97-4e6a-b0a4-332eaa4893ca"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "da8de600-f2bd-4244-af8b-3737a9eb5a47", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1d", 
                        "InstanceType": "m2.4xlarge", 
                        "InstanceCount": 1
                    }
                }
            ], 
            "EffectiveDate": "2014-12-05T21:00:00.000Z", 
            "CreateDate": "2014-12-05T21:04:42.099Z", 
            "UpdateDate": "2014-12-05T21:16:55.490Z", 
            "ClientToken": "6f50f149-5b22-422a-ad3c-72e5ba35d39c", 
            "ReservedInstancesModificationId": "rimod-4bab3ee7-a232-4f40-9618-d9a23a3f3454", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "bbcd9749-15e9-4b4e-b2e6-00cf858f3c11"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "2fa584e6-5c72-4a63-b4f0-f4b45a06e9e4", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1e", 
                        "InstanceType": "m1.xlarge", 
                        "InstanceCount": 1
                    }
                }
            ], 
            "EffectiveDate": "2014-12-05T21:00:00.000Z", 
            "CreateDate": "2014-12-05T21:09:40.769Z", 
            "UpdateDate": "2014-12-05T21:18:54.477Z", 
            "ClientToken": "c43c2937-355f-46ab-9ff0-d61212c5949e", 
            "ReservedInstancesModificationId": "rimod-1cfcec7b-5296-46e8-82ac-07f594df61c2", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "6dead480-a61f-4897-a5b8-bad947dded51"
                }
            ]
        }, 
        {
            "Status": "failed", 
            "ModificationResults": [
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1d", 
                        "InstanceType": "m1.medium", 
                        "InstanceCount": 5
                    }
                }, 
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1e", 
                        "InstanceType": "m1.medium", 
                        "InstanceCount": 3
                    }
                }
            ], 
            "EffectiveDate": "2014-12-05T21:00:00.000Z", 
            "CreateDate": "2014-12-05T21:10:36.464Z", 
            "UpdateDate": "2014-12-05T21:10:49.283Z", 
            "ClientToken": "1b071428-0949-4d60-9f4a-a7bf6725c0ce", 
            "ReservedInstancesModificationId": "rimod-ec4dabaa-2b9d-423f-bbb1-f2a03350d28d", 
            "StatusMessage": "Insufficient capacity.", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "bbcd9749-79cc-4dea-a001-d030562c633d"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "67244ac5-ace6-4516-98cc-955df15f9b0d", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1d", 
                        "InstanceType": "m1.small", 
                        "InstanceCount": 39
                    }
                }, 
                {
                    "ReservedInstancesId": "789d17b4-3fa3-47db-8952-f7eef83bd7dc", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1c", 
                        "InstanceType": "m1.small", 
                        "InstanceCount": 3
                    }
                }
            ], 
            "EffectiveDate": "2014-12-05T21:00:00.000Z", 
            "CreateDate": "2014-12-05T21:11:36.179Z", 
            "UpdateDate": "2014-12-05T21:17:48.593Z", 
            "ClientToken": "d76c911e-a9be-4254-bcae-cc2c2743cf64", 
            "ReservedInstancesModificationId": "rimod-dd17016a-ad3b-4c50-b186-85a84361761e", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "4357912c-7b16-42e3-aed1-15c9aa15b95f"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "baf46340-552c-4c89-bf57-bde98559756a", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1d", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 63
                    }
                }, 
                {
                    "ReservedInstancesId": "5cb784a4-ca7e-4281-a189-0b8c90a87360", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "m1.medium", 
                        "InstanceCount": 4
                    }
                }
            ], 
            "EffectiveDate": "2014-12-05T21:00:00.000Z", 
            "CreateDate": "2014-12-05T21:13:05.521Z", 
            "UpdateDate": "2014-12-05T21:34:23.138Z", 
            "ClientToken": "b70d1c49-d339-445c-ab86-91c4e54ae286", 
            "ReservedInstancesModificationId": "rimod-ad9e80d6-92a3-4783-8544-bfad01ff468d", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "93bbbca2-97bc-4961-a826-66c6254e5ba8"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "a354071b-cdbe-425b-bc43-19ce882d72b7", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "c3.2xlarge", 
                        "InstanceCount": 1
                    }
                }, 
                {
                    "ReservedInstancesId": "65152ca5-16c6-4dc3-b3dc-6bd432acc8c6", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1e", 
                        "InstanceType": "c3.2xlarge", 
                        "InstanceCount": 1
                    }
                }
            ], 
            "EffectiveDate": "2014-12-05T21:00:00.000Z", 
            "CreateDate": "2014-12-05T21:14:27.155Z", 
            "UpdateDate": "2014-12-05T21:32:39.937Z", 
            "ClientToken": "3ba5ee6c-bd06-4332-82d6-1fb5b2db3913", 
            "ReservedInstancesModificationId": "rimod-63eb28bb-9c79-4cc6-a8b8-2f460b7412e9", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "31010758-6028-4eed-8407-23ced7b59546"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "cafb51b2-46db-45ab-9788-4dbdf8f65fa0", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "i2.2xlarge", 
                        "InstanceCount": 2
                    }
                }, 
                {
                    "ReservedInstancesId": "6ddbf4f3-a7cf-45cc-a9c4-4f9466ba6c4a", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1d", 
                        "InstanceType": "i2.2xlarge", 
                        "InstanceCount": 2
                    }
                }, 
                {
                    "ReservedInstancesId": "d2ebb5b4-3d8b-482f-abc0-24d34f7a0e86", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1e", 
                        "InstanceType": "i2.2xlarge", 
                        "InstanceCount": 2
                    }
                }
            ], 
            "EffectiveDate": "2014-12-08T21:00:00.000Z", 
            "CreateDate": "2014-12-08T21:21:55.796Z", 
            "UpdateDate": "2014-12-08T21:49:17.088Z", 
            "ClientToken": "2fa31e30-41a9-4030-82d5-0b764587ec62", 
            "ReservedInstancesModificationId": "rimod-31b35704-d875-4f63-adaa-d2aed03166dd", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "16547f9e-e2d9-46ad-a020-178aa35449f9"
                }, 
                {
                    "ReservedInstancesId": "1e3b5a8f-536b-4ca6-a26e-765efc7bcb10"
                }, 
                {
                    "ReservedInstancesId": "9a044d2a-3071-45dd-add4-601bbd9b1d56"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "1f3754e8-2ad3-4eb8-a904-4f38393c7998", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 2
                    }
                }, 
                {
                    "ReservedInstancesId": "9f9726be-cb8d-477c-a86b-1c21283ead14", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m1.xlarge", 
                        "InstanceCount": 22
                    }
                }
            ], 
            "EffectiveDate": "2014-12-08T21:00:00.000Z", 
            "CreateDate": "2014-12-08T21:28:05.671Z", 
            "UpdateDate": "2014-12-08T21:46:20.487Z", 
            "ClientToken": "8e596b76-612b-4af6-9072-45933c9f359a", 
            "ReservedInstancesModificationId": "rimod-b0aeb299-2e68-4522-88b2-294a9825d6ea", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "d124bc35-b356-42f4-b281-5931fc98646f"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "a6c3a966-50bd-4a9c-aa63-440138c16e02", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1d", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 33
                    }
                }, 
                {
                    "ReservedInstancesId": "78d610b6-2f4f-46a2-8c91-ca8387707fad", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m1.xlarge", 
                        "InstanceCount": 15
                    }
                }
            ], 
            "EffectiveDate": "2014-12-08T21:00:00.000Z", 
            "CreateDate": "2014-12-08T21:28:53.773Z", 
            "UpdateDate": "2014-12-08T21:47:09.364Z", 
            "ClientToken": "746ab983-8544-4ea3-bcf2-71ddb85ebd9a", 
            "ReservedInstancesModificationId": "rimod-e0a714d2-8837-4f5d-97a0-324d118a16cb", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "baf46340-552c-4c89-bf57-bde98559756a"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "45baebe8-e6d0-4c34-a0af-2693d1f952cc", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1d", 
                        "InstanceType": "c3.xlarge", 
                        "InstanceCount": 4
                    }
                }
            ], 
            "EffectiveDate": "2014-12-09T22:38:31.000Z", 
            "CreateDate": "2014-12-09T22:43:50.818Z", 
            "UpdateDate": "2014-12-09T23:02:04.754Z", 
            "ClientToken": "2b9ce5f6-83ee-423c-a5f2-c2874416ff33", 
            "ReservedInstancesModificationId": "rimod-fd1a2d99-b385-43ff-a27d-faaf5ed66d68", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "783b2ae7-b88c-4da6-8410-d8a390a35fa4"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "c157a297-bc4d-43f2-8f55-cfa89bd8f940", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1e", 
                        "InstanceType": "c3.2xlarge", 
                        "InstanceCount": 4
                    }
                }
            ], 
            "EffectiveDate": "2014-12-11T19:00:00.000Z", 
            "CreateDate": "2014-12-11T19:44:50.968Z", 
            "UpdateDate": "2014-12-11T20:03:04.651Z", 
            "ClientToken": "14b0e301-781d-4194-a14f-8b08a3350377", 
            "ReservedInstancesModificationId": "rimod-b0b58d13-cd68-4f4c-a3a8-552c89c03b38", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "09097195-b11c-4460-ba1e-31a3efd7c84e"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "f155464a-b80c-4aee-af4a-092526156edd", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1d", 
                        "InstanceType": "c3.4xlarge", 
                        "InstanceCount": 5
                    }
                }, 
                {
                    "ReservedInstancesId": "f9fd2694-1289-4bd3-b5b3-a0a33a87fd99", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1d", 
                        "InstanceType": "c3.2xlarge", 
                        "InstanceCount": 2
                    }
                }
            ], 
            "EffectiveDate": "2014-12-11T19:00:00.000Z", 
            "CreateDate": "2014-12-11T19:46:01.908Z", 
            "UpdateDate": "2014-12-11T20:01:17.399Z", 
            "ClientToken": "931ccd1e-0f28-483c-ab96-a31a6d5cc168", 
            "ReservedInstancesModificationId": "rimod-2c1a022e-54a0-4b5c-9ad4-178e9e17b4fc", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "977f0ae0-df46-4485-88d0-6772fc67bd49"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "c0a6dd4c-4329-44ac-8f69-0aa6e4de4b12", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m1.small", 
                        "InstanceCount": 48
                    }
                }
            ], 
            "EffectiveDate": "2014-12-11T21:00:00.000Z", 
            "CreateDate": "2014-12-11T21:34:42.159Z", 
            "UpdateDate": "2014-12-11T21:46:56.056Z", 
            "ClientToken": "4834c606-c5e6-4663-b212-64e7c47a1986", 
            "ReservedInstancesModificationId": "rimod-3a3c96e6-a052-4dee-8119-a4c4e8b41e42", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "b847fa93-e27b-4ce6-8ac2-5dd021813f3b"
                }, 
                {
                    "ReservedInstancesId": "d16f7a91-d798-4d92-b4b3-b14024e59d4d"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "8d28a379-ec79-4378-95a0-c53e8f0eff56", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "m1.small", 
                        "InstanceCount": 29
                    }
                }
            ], 
            "EffectiveDate": "2014-12-11T21:00:00.000Z", 
            "CreateDate": "2014-12-11T21:35:06.025Z", 
            "UpdateDate": "2014-12-11T21:47:22.461Z", 
            "ClientToken": "f951f67c-efc6-41c9-a510-901b692fa7bd", 
            "ReservedInstancesModificationId": "rimod-0a46b031-76eb-4906-a553-9affc313f70e", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "bbcd9749-7994-453d-8b70-68bdc0e7df75"
                }, 
                {
                    "ReservedInstancesId": "d16f7a91-7420-44be-9461-97d1c0836969"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "8e523110-560a-4f39-8f48-16d5ce9f9674", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1c", 
                        "InstanceType": "m1.small", 
                        "InstanceCount": 4
                    }
                }
            ], 
            "EffectiveDate": "2014-12-11T21:00:00.000Z", 
            "CreateDate": "2014-12-11T21:35:35.443Z", 
            "UpdateDate": "2014-12-11T21:47:52.290Z", 
            "ClientToken": "82a06f60-95d7-4788-b63c-14da12b6f286", 
            "ReservedInstancesModificationId": "rimod-199ebab1-8fae-468c-a025-83e2ed11827f", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "789d17b4-3fa3-47db-8952-f7eef83bd7dc"
                }, 
                {
                    "ReservedInstancesId": "1ba8e2e3-1ed3-436f-baa7-4f23b61a869b"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "b4b51dcf-75f3-45b7-b908-0ec6956952fa", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m1.medium", 
                        "InstanceCount": 18
                    }
                }
            ], 
            "EffectiveDate": "2014-12-11T21:00:00.000Z", 
            "CreateDate": "2014-12-11T21:36:01.685Z", 
            "UpdateDate": "2014-12-11T21:48:21.162Z", 
            "ClientToken": "9ec32452-351f-42e7-8f6b-5a5324e4b7c8", 
            "ReservedInstancesModificationId": "rimod-74b08668-b35e-4f2f-99be-fbf89f576f3f", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "4357912c-83bf-4f05-a11d-f8677abbb721"
                }, 
                {
                    "ReservedInstancesId": "80f1b8ba-e9ed-4b02-b15a-f0f3772624b2"
                }, 
                {
                    "ReservedInstancesId": "d16f7a91-014c-4efb-a5fa-1c4266392af1"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "0dc65239-2a1d-42d9-bbcd-a9610dc8bea9", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "m1.medium", 
                        "InstanceCount": 5
                    }
                }
            ], 
            "EffectiveDate": "2014-12-11T21:00:00.000Z", 
            "CreateDate": "2014-12-11T21:36:12.739Z", 
            "UpdateDate": "2014-12-11T21:48:27.357Z", 
            "ClientToken": "d5096de3-0b4e-49e1-a89f-497314854850", 
            "ReservedInstancesModificationId": "rimod-f8cd3187-95ce-4314-97f4-fa3fe14900e3", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "9d5cb137-077a-403d-9930-b3791f597669"
                }, 
                {
                    "ReservedInstancesId": "5cb784a4-ca7e-4281-a189-0b8c90a87360"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "7f40bfe5-76ea-4b9e-8f55-aaf5cc1cddfe", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1c", 
                        "InstanceType": "m1.medium", 
                        "InstanceCount": 2
                    }
                }
            ], 
            "EffectiveDate": "2014-12-11T21:00:00.000Z", 
            "CreateDate": "2014-12-11T21:36:25.812Z", 
            "UpdateDate": "2014-12-11T21:48:38.662Z", 
            "ClientToken": "f15d63a2-006d-4659-b77d-7ebb785612f3", 
            "ReservedInstancesModificationId": "rimod-0828d96e-8a29-46ef-a6da-2ff1f47ea4a8", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "f127bd27-c7a3-4e36-83af-1d14f923b9fb"
                }, 
                {
                    "ReservedInstancesId": "1ba8e2e3-d0ca-4596-ab85-4153ea710c52"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "6fd15cb5-a5ae-4878-b0c4-8df8eacc2f95", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 64
                    }
                }
            ], 
            "EffectiveDate": "2014-12-11T21:00:00.000Z", 
            "CreateDate": "2014-12-11T21:36:53.059Z", 
            "UpdateDate": "2014-12-11T21:49:05.995Z", 
            "ClientToken": "91917835-7195-427f-9a18-e4c3ce1d9636", 
            "ReservedInstancesModificationId": "rimod-b23ccdac-46b1-4618-8cc2-5fe8cfb700ee", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "af9f760e-214d-4a72-a387-acadac79cbb1"
                }, 
                {
                    "ReservedInstancesId": "46a408c7-f8d3-40fd-866f-1788e720c5af"
                }, 
                {
                    "ReservedInstancesId": "9d5cb137-35ba-4acb-b223-c7271a302c1d"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "bc7a6ac4-364f-4f3b-a299-d000038ae8f3", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m1.xlarge", 
                        "InstanceCount": 60
                    }
                }
            ], 
            "EffectiveDate": "2014-12-11T21:00:00.000Z", 
            "CreateDate": "2014-12-11T21:37:32.392Z", 
            "UpdateDate": "2014-12-11T21:49:45.608Z", 
            "ClientToken": "c7b770fb-baf9-467e-985f-a77b5c7b3f52", 
            "ReservedInstancesModificationId": "rimod-6d14a3be-031e-4ba2-87c1-79af4bd7dffb", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "d16f7a91-d0d2-40fa-a821-68d3ea7ef0a7"
                }, 
                {
                    "ReservedInstancesId": "9f9726be-cb8d-477c-a86b-1c21283ead14"
                }, 
                {
                    "ReservedInstancesId": "93bbbca2-4b1c-47b7-952a-b74f71f94e03"
                }, 
                {
                    "ReservedInstancesId": "78d610b6-2f4f-46a2-8c91-ca8387707fad"
                }, 
                {
                    "ReservedInstancesId": "af9f760e-4ca7-45f2-947f-221173a647ec"
                }
            ]
        }, 
        {
            "Status": "failed", 
            "ModificationResults": [
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 22
                    }
                }, 
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1e", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 22
                    }
                }
            ], 
            "EffectiveDate": "2014-12-17T21:00:00.000Z", 
            "CreateDate": "2014-12-17T21:07:57.394Z", 
            "UpdateDate": "2014-12-17T21:08:08.935Z", 
            "ClientToken": "e7b97efb-00a7-4d5b-9dff-1b301d4257bd", 
            "ReservedInstancesModificationId": "rimod-e2aa2484-b465-4eac-abd0-28f816053340", 
            "StatusMessage": "Insufficient capacity.", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "93bbbca2-caca-49bf-ab49-63fb62982e87"
                }
            ]
        }, 
        {
            "Status": "failed", 
            "ModificationResults": [
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1c", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 15
                    }
                }, 
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1e", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 5
                    }
                }, 
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1d", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 1
                    }
                }
            ], 
            "EffectiveDate": "2014-12-17T21:00:00.000Z", 
            "CreateDate": "2014-12-17T21:08:55.516Z", 
            "UpdateDate": "2014-12-17T21:09:07.337Z", 
            "ClientToken": "e45da696-23e4-48aa-abe4-d54654866774", 
            "ReservedInstancesModificationId": "rimod-1d05d66c-ca39-48e2-a14b-6062d0a412ec", 
            "StatusMessage": "Insufficient capacity.", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "4357912c-8c8d-4ecc-8772-a348ade940eb"
                }
            ]
        }, 
        {
            "Status": "failed", 
            "ModificationResults": [
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "c1.medium", 
                        "InstanceCount": 3
                    }
                }, 
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1e", 
                        "InstanceType": "c1.medium", 
                        "InstanceCount": 4
                    }
                }, 
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1c", 
                        "InstanceType": "c1.medium", 
                        "InstanceCount": 2
                    }
                }, 
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1e", 
                        "InstanceType": "c1.xlarge", 
                        "InstanceCount": 1
                    }
                }
            ], 
            "EffectiveDate": "2014-12-17T21:00:00.000Z", 
            "CreateDate": "2014-12-17T21:11:00.275Z", 
            "UpdateDate": "2014-12-17T21:11:12.786Z", 
            "ClientToken": "4a9ccd84-2686-4115-a0dc-5b5108f0990c", 
            "ReservedInstancesModificationId": "rimod-603ed142-0684-4a52-8545-fa73db7cffe2", 
            "StatusMessage": "Insufficient capacity.", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "bbcd9749-61a8-43ad-9ac4-8ce75e5fc32a"
                }
            ]
        }, 
        {
            "Status": "failed", 
            "ModificationResults": [
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 18
                    }
                }, 
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1e", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 26
                    }
                }
            ], 
            "EffectiveDate": "2015-01-22T18:00:00.000Z", 
            "CreateDate": "2015-01-22T18:58:57.597Z", 
            "UpdateDate": "2015-01-22T18:59:09.095Z", 
            "ClientToken": "db62c9c9-bc31-4aa1-91dc-3dab245fc2ef", 
            "ReservedInstancesModificationId": "rimod-e702fc8b-6cd0-4421-98ac-921b677ad2fc", 
            "StatusMessage": "Insufficient capacity.", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "93bbbca2-caca-49bf-ab49-63fb62982e87"
                }
            ]
        }, 
        {
            "Status": "failed", 
            "ModificationResults": [
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "c1.xlarge", 
                        "InstanceCount": 1
                    }
                }, 
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1e", 
                        "InstanceType": "c1.xlarge", 
                        "InstanceCount": 1
                    }
                }
            ], 
            "EffectiveDate": "2015-01-22T19:00:00.000Z", 
            "CreateDate": "2015-01-22T19:51:46.850Z", 
            "UpdateDate": "2015-01-22T19:51:58.770Z", 
            "ClientToken": "bb99db2a-1bc3-4921-84bb-b9988655df93", 
            "ReservedInstancesModificationId": "rimod-dbe0d843-b2e3-40e5-b506-16d4b133e92f", 
            "StatusMessage": "Insufficient capacity.", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "f127bd27-1c5e-4f7b-8edc-a1c7f894fd0a"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "339a970a-87fa-4a97-bad6-120d50e90e57", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "m2.2xlarge", 
                        "InstanceCount": 1
                    }
                }, 
                {
                    "ReservedInstancesId": "5ff29764-0261-47ab-88fd-fba946e447b3", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m2.2xlarge", 
                        "InstanceCount": 1
                    }
                }
            ], 
            "EffectiveDate": "2015-01-22T19:00:00.000Z", 
            "CreateDate": "2015-01-22T19:53:39.610Z", 
            "UpdateDate": "2015-01-22T20:08:52.822Z", 
            "ClientToken": "5e61a476-9db9-4a9b-b780-d9f05f88d00f", 
            "ReservedInstancesModificationId": "rimod-9657cf08-4e17-496c-bf52-9d5a3d7c9d66", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "da8de600-f2bd-4244-af8b-3737a9eb5a47"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "cdabeebc-9ed4-4e4a-9949-4421da0e5241", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1d", 
                        "InstanceType": "m2.xlarge", 
                        "InstanceCount": 4
                    }
                }
            ], 
            "EffectiveDate": "2015-01-22T19:00:00.000Z", 
            "CreateDate": "2015-01-22T19:54:31.983Z", 
            "UpdateDate": "2015-01-22T20:09:46.128Z", 
            "ClientToken": "df121207-521b-4aae-ad12-d5469b9c940e", 
            "ReservedInstancesModificationId": "rimod-b76f4abe-e60a-40f8-95fb-44ef714e7d58", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "bbcd9749-45ac-4b1f-a2c5-63a34aab2549"
                }
            ]
        }, 
        {
            "Status": "failed", 
            "ModificationResults": [
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1e", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 26
                    }
                }, 
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m1.xlarge", 
                        "InstanceCount": 47
                    }
                }
            ], 
            "EffectiveDate": "2015-01-23T05:00:00.000Z", 
            "CreateDate": "2015-01-23T05:17:47.401Z", 
            "UpdateDate": "2015-01-23T05:17:58.891Z", 
            "ClientToken": "11aab180-0c03-4e42-847e-5a041e74fcb2", 
            "ReservedInstancesModificationId": "rimod-76cdf433-556e-49f0-b803-a1e5e95b6d81", 
            "StatusMessage": "Insufficient capacity.", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "bc7a6ac4-364f-4f3b-a299-d000038ae8f3"
                }
            ]
        }, 
        {
            "Status": "failed", 
            "ModificationResults": [
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1e", 
                        "InstanceType": "m1.medium", 
                        "InstanceCount": 24
                    }
                }, 
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m1.xlarge", 
                        "InstanceCount": 54
                    }
                }
            ], 
            "EffectiveDate": "2015-01-23T05:00:00.000Z", 
            "CreateDate": "2015-01-23T05:57:56.846Z", 
            "UpdateDate": "2015-01-23T05:58:19.209Z", 
            "ClientToken": "9c977895-cb17-4de2-8b66-c202bd3acb16", 
            "ReservedInstancesModificationId": "rimod-a4cb97e3-8783-4c20-bff0-c874fc31a039", 
            "StatusMessage": "Insufficient capacity.", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "bc7a6ac4-364f-4f3b-a299-d000038ae8f3"
                }
            ]
        }, 
        {
            "Status": "failed", 
            "ModificationResults": [
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 19
                    }
                }, 
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1e", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 25
                    }
                }
            ], 
            "EffectiveDate": "2015-01-23T19:00:00.000Z", 
            "CreateDate": "2015-01-23T19:14:15.145Z", 
            "UpdateDate": "2015-01-23T19:14:27.695Z", 
            "ClientToken": "f92c6ce6-0060-437d-83a9-8956643b59c9", 
            "ReservedInstancesModificationId": "rimod-00ef6d24-71ec-4ff5-8442-499e9673b56a", 
            "StatusMessage": "Insufficient capacity.", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "93bbbca2-caca-49bf-ab49-63fb62982e87"
                }
            ]
        }, 
        {
            "Status": "failed", 
            "ModificationResults": [
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 19
                    }
                }, 
                {
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1e", 
                        "InstanceType": "m1.large", 
                        "InstanceCount": 25
                    }
                }
            ], 
            "EffectiveDate": "2015-01-23T19:00:00.000Z", 
            "CreateDate": "2015-01-23T19:18:18.811Z", 
            "UpdateDate": "2015-01-23T19:18:36.466Z", 
            "ClientToken": "5b88f3ca-03a4-45b3-a607-bbcadd0b593c", 
            "ReservedInstancesModificationId": "rimod-c266c5f9-4e94-49a8-9c1c-956566a8c5b8", 
            "StatusMessage": "Insufficient capacity.", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "93bbbca2-caca-49bf-ab49-63fb62982e87"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "130e039a-a4ed-48aa-8e7f-e48574098e22", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1d", 
                        "InstanceType": "m2.4xlarge", 
                        "InstanceCount": 4
                    }
                }
            ], 
            "EffectiveDate": "2015-01-23T22:00:00.000Z", 
            "CreateDate": "2015-01-23T22:08:39.764Z", 
            "UpdateDate": "2015-01-23T22:17:54.264Z", 
            "ClientToken": "a3df9cb0-9277-4ee9-9ef2-0b4464d30401", 
            "ReservedInstancesModificationId": "rimod-dc5a9ff2-2964-4db3-9125-2b850f26c22c", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "b847fa93-5cc2-4d44-a491-7b1e3e4f1543"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "f96c636b-2fcb-4209-8e1a-fb6a429f44df", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1d", 
                        "InstanceType": "m2.xlarge", 
                        "InstanceCount": 1
                    }
                }, 
                {
                    "ReservedInstancesId": "c848152d-2b08-4d96-9693-2924cad038a4", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1a", 
                        "InstanceType": "m2.xlarge", 
                        "InstanceCount": 3
                    }
                }
            ], 
            "EffectiveDate": "2015-01-24T00:00:00.000Z", 
            "CreateDate": "2015-01-24T00:47:06.342Z", 
            "UpdateDate": "2015-01-24T01:05:21.336Z", 
            "ClientToken": "448f9d25-0ad4-49c5-bd78-bdae6b2096c2", 
            "ReservedInstancesModificationId": "rimod-cff9ae87-df94-4631-8e40-4e74119bfe3a", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "cdabeebc-9ed4-4e4a-9949-4421da0e5241"
                }
            ]
        }, 
        {
            "Status": "fulfilled", 
            "ModificationResults": [
                {
                    "ReservedInstancesId": "c1a6acde-10ab-4997-9958-7b1da06a4e02", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1c", 
                        "InstanceType": "m2.4xlarge", 
                        "InstanceCount": 2
                    }
                }, 
                {
                    "ReservedInstancesId": "934cd54f-d6a2-4048-8f2a-21bca3a9fe7e", 
                    "TargetConfiguration": {
                        "Platform": "EC2-Classic", 
                        "AvailabilityZone": "us-east-1b", 
                        "InstanceType": "m2.4xlarge", 
                        "InstanceCount": 2
                    }
                }
            ], 
            "EffectiveDate": "2015-01-24T03:00:00.000Z", 
            "CreateDate": "2015-01-24T03:08:43.547Z", 
            "UpdateDate": "2015-01-24T03:20:58.927Z", 
            "ClientToken": "ABC123", 
            "ReservedInstancesModificationId": "rimod-6ada32b4-6b5a-4165-a432-3af128c7fdd4", 
            "ReservedInstancesIds": [
                {
                    "ReservedInstancesId": "130e039a-a4ed-48aa-8e7f-e48574098e22"
                }
            ]
        }
    ]
}

Notice the 2015 Data

DescribeSecurityGroups fails with SerializerError when All ICMP is in any security group

If any security group in scope of the DescribeSecurityGroups requests contains a rule specifying All ICMP the request will fail.

Specific error encountered:

Left (SerializerError "EC2" "Failed reading: takeWhile1")

Program that exhibits this problem:

import Control.Monad.Trans.AWS
import Network.AWS.EC2

main  = do
  e <- getEnv Ireland Discover
  r <- runAWST e $ do { send describeSecurityGroups }
  print r

Sanitized JSON output from AWS Command Line Interface:

$ aws ec2 describe-security-groups --profile ireland

{
    "SecurityGroups": [
        {
            "IpPermissions": [
                {
                    "UserIdGroupPairs": [
                        {
                            "UserId": "123456789012",
                            "GroupId": "sg-abcd1234"
                        }
                    ],
                    "ToPort": -1,
                    "IpProtocol": "icmp",
                    "IpRanges": [],
                    "FromPort": -1
                }
            ],
            "IpPermissionsEgress": [],
            "GroupId": "sg-abcd1234",
            "GroupName": "default",
            "OwnerId": "123456789012",
            "Description": "default VPC security group",
            "VpcId": "vpc-1234abcd"
        }
    ]
}

With ~/.aws/config:

[profile ireland]
aws_access_key_id = ...
output = json
region = eu-west-1
aws_secret_access_key = ...

Generate CloudHSM bindings

CloudHSM is now available in all of the official bindings.

Treat 3xx responses as successes

Either generally or at least for S3 responses, 3xx codes should be treated as a success to allow client code to identify with 304 responses when using ETags as well as other use-cases involving 3xx response codes.

I already made this change on master but am creating this issue as a reminder that this behaviour should be retained (or generalised for all AWS responses) in the upcoming changes on the gen branch.

Formalise pretty printing of log output

Currently the ToBuilder class is used to create Builder representations of various types for logging purposes.

Since these are indented, it'd be nice to support arbitrary nesting via depth or some similar pretty printing mechanism.

Add usage information to Haddock documentation

Primarily applies to the amazonka library modules, but it also might be nice to have a general usage blurb dropped into the gen/templates/service.ede template so all top-level service namespaces also contain helpful examples and introductory text.

Core depends on unordered-containers >0.2.3

amazonka-core depends on unordered-containers >0.2.3 but undordered-containers before 0.2.5 does not have a Read instance for HashMap. This Read instance is needed to instantiate Read for Network.Internal.AWS.Data.Internal.Map.

Read instances on most datatypes

It would be great to have Read instances on a lot of these datatypes, especially enumerations such as Network.AWS.S3.Types.ObjectStorageClass.

S3 Support

It would be great to have complete support for the S3 APIs. The following operations are the ones that I would need most: GETting/PUTting objects, getting an object's metadata via a HEAD request and the special object copy operation (also via PUT) that allows one to change S3 metadata associated with an object without re-uploading it.

The signing process for S3 requests is described here: http://docs.aws.amazon.com/AmazonS3/latest/dev/RESTAuthentication.html

Thanks for providing this library!

Query serialisation of flattened list items is incorrect

Relates specifically to EC2 and flattened List (e :: Symbol) a types which incorrectly retain the element identifier when serialised.

Generate strictness annotations for primitive data type fields

'Small' types like Int, Bool, and so forth should be annotated as strict ! in the rendered data types.

Additionally {-# UNPACK #-} pragmas or -funbox-strict-fields can be added to benefit GHC pre-7.8.1.

EC2 metadata check fails to correctly suppress HttpExceptions

When attempting to resolve http://instance-data for the purposes of determining if the host is running on EC2 or not, HttpExceptions from Network.AWS.EC2.Metadata.isEC2 are not correctly handled resulting in an error instead of False.

Route53 returns 403s with "SignatureDoesNotMatch"

I wasn't able to find any Route53 requests that worked.

creds = FromKeys (AccessKey ...) (SecretKey ...)
go a = do
  e <- getEnv NorthVirginia creds
  runAWST e a

*Main Network.AWS.Route53> go $ send listHostedZones                 
Left (ServiceError "Route53" (Status {statusCode = 403, statusMessage = "Forbidden"}) "RESTError {_restRequestId = \"6d17918d-a0a0-11e4-a345-c9c3a348897b\", _restType = Just Sender, _restCode = ErrorCode \"SignatureDoesNotMatch\", _restMessage = \"The request signature we calculated does not match the signature you provided. Check your AWS Secret Access Key and signing method. Consult the service documentation for details.\"}")

SQS 400 for sendMessage

When I run this:

send $ sendMessage "$MY_SQS_URL_HERE" "Testing!" H.empty

I get back:

Left (ServiceError "SQS" (Status {statusCode = 400, statusMessage = "Bad Request"}) "RESTError {_errError = RESTMessage {_msgType = Sender, _msgCode = \"IncompleteSignature\", _msgRESTMessage = \"Date must be in ISO-8601 'basic format'. Got 'Sun, 23 Nov 2014 04:07:43 GMT'. See http://en.wikipedia.org/wiki/ISO_8601\"}, _errRequestId = \"1288631a-7731-5c8e-9891-2ff128fe33b0\"}")

I'm not sure if it's a bug or if I'm missing something. Great work on the generated docs though!

Add retry and waiter logic according to the service descriptions

The service descriptions contain _retries.json and <service>/<version>.waiters.json which outline various conditions for retry, backoff, and waiters to account for eventual consistency etc.

It should be trivial to parse these and add generalised retry/wait logic which will be parameterised over each service's specialised error type.

S3 createBucket doesn't work

It seems that Network.AWS.S3.CreateBucket is generating an invalid request:

λ logg <- newLogger Trace stdout
λ runAWST (env & envLogger .~ logg ) . Control.Monad.Trans.AWS.send $ createBucket "lars-test-bucket"
...
[Raw Request] {
  method  = PUT
  path    = /lars-test-bucket
  query   = 
  headers = x-amz-content-sha256: ...
  body    = {
    hash    = ...
    payload =
<?xml version="1.0" encoding="UTF-8"?><CreateBucket xmlns="http://s3.amazonaws.com/doc/2006-03-01/"><CreateBucketConfiguration xmlns=""/></CreateBucket>
  }
}
...
[Client Response] {
  status code    = 400
  status message = Bad Request
  version        = HTTP/1.1
  headers        = x-amz-request-id: ...; x-amz-id-2: ...; content-type: application/xml; transfer-encoding: chunked; date: Fri, 20 Feb 2015 18:08:04 GMT; connection: close; server: AmazonS3
  cookies        = CJ {expose = []}
}
[Client Response Body] {
<?xml version="1.0" encoding="UTF-8"?>
<Error><Code>MalformedXML</Code><Message>The XML you provided was not well-formed or did not validate against our published schema</Message><RequestId>...</RequestId><HostId>...</HostId></Error>
}
    Left
      (ServiceError "S3"
         (Status{statusCode = 400, statusMessage = "Bad Request"})
         "RESTError {_restRequestId = \"...\", _restType = Nothing, _restCode = ErrorCode \"MalformedXML\", _restMessage = \"The XML you provided was not well-formed or did not validate against our published schema\"}")