File: GetBucketObjectVersions.hs

package info (click to toggle)
haskell-aws 0.24.1-2
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid, trixie
  • size: 868 kB
  • sloc: haskell: 9,593; makefile: 2
file content (125 lines) | stat: -rw-r--r-- 6,902 bytes parent folder | download | duplicates (4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
module Aws.S3.Commands.GetBucketObjectVersions
where

import           Aws.Core
import           Aws.S3.Core
import           Control.Applicative
import           Data.ByteString.Char8 ({- IsString -})
import           Data.Maybe
import           Text.XML.Cursor       (($/), (&|), (&//))
import qualified Data.ByteString.Char8 as B8
import qualified Data.Text             as T
import qualified Data.Text.Encoding    as T
import qualified Data.Traversable
import           Prelude
import qualified Network.HTTP.Types    as HTTP
import qualified Text.XML.Cursor       as Cu
import qualified Text.XML              as XML

data GetBucketObjectVersions
    = GetBucketObjectVersions {
        gbovBucket          :: Bucket
      , gbovDelimiter       :: Maybe T.Text
      , gbovKeyMarker       :: Maybe T.Text
      , gbovMaxKeys         :: Maybe Int
      , gbovPrefix          :: Maybe T.Text
      , gbovVersionIdMarker :: Maybe T.Text
      }
    deriving (Show)

getBucketObjectVersions :: Bucket -> GetBucketObjectVersions
getBucketObjectVersions bucket
    = GetBucketObjectVersions {
        gbovBucket          = bucket
      , gbovDelimiter       = Nothing
      , gbovKeyMarker       = Nothing
      , gbovMaxKeys         = Nothing
      , gbovPrefix          = Nothing
      , gbovVersionIdMarker = Nothing
      }

data GetBucketObjectVersionsResponse
    = GetBucketObjectVersionsResponse {
        gbovrName                :: Bucket
      , gbovrDelimiter           :: Maybe T.Text
      , gbovrKeyMarker           :: Maybe T.Text
      , gbovrMaxKeys             :: Maybe Int
      , gbovrPrefix              :: Maybe T.Text
      , gbovrVersionIdMarker     :: Maybe T.Text
      , gbovrContents            :: [ObjectVersionInfo]
      , gbovrCommonPrefixes      :: [T.Text]
      , gbovrIsTruncated         :: Bool
      , gbovrNextKeyMarker       :: Maybe T.Text
      , gbovrNextVersionIdMarker :: Maybe T.Text
      }
    deriving (Show)

-- | ServiceConfiguration: 'S3Configuration'
instance SignQuery GetBucketObjectVersions where
    type ServiceConfiguration GetBucketObjectVersions = S3Configuration
    signQuery GetBucketObjectVersions {..} = s3SignQuery S3Query {
                                 s3QMethod = Get
                               , s3QBucket = Just $ T.encodeUtf8 gbovBucket
                               , s3QObject = Nothing
                               , s3QSubresources = [ ("versions", Nothing) ]
                               , s3QQuery = HTTP.toQuery [
                                              ("delimiter" :: B8.ByteString ,) <$> gbovDelimiter
                                            , ("key-marker",) <$> gbovKeyMarker
                                            , ("max-keys",) . T.pack . show <$> gbovMaxKeys
                                            , ("prefix",) <$> gbovPrefix
                                            , ("version-id-marker",) <$> gbovVersionIdMarker
                                            ]
                               , s3QContentType = Nothing
                               , s3QContentMd5 = Nothing
                               , s3QAmzHeaders = []
                               , s3QOtherHeaders = []
                               , s3QRequestBody = Nothing
                               }

instance ResponseConsumer r GetBucketObjectVersionsResponse where
    type ResponseMetadata GetBucketObjectVersionsResponse = S3Metadata

    responseConsumer _ _ = s3XmlResponseConsumer parse
        where parse cursor
                  = do name <- force "Missing Name" $ cursor $/ elContent "Name"
                       let delimiter = listToMaybe $ cursor $/ elContent "Delimiter"
                       let keyMarker = listToMaybe $ cursor $/ elContent "KeyMarker"
                       let versionMarker = listToMaybe $ cursor $/ elContent "VersionIdMarker"
                       maxKeys <- Data.Traversable.sequence . listToMaybe $ cursor $/ elContent "MaxKeys" &| textReadInt
                       let truncated = maybe True (/= "false") $ listToMaybe $ cursor $/ elContent "IsTruncated"
                       let nextKeyMarker = listToMaybe $ cursor $/ elContent "NextKeyMarker"
                       let nextVersionMarker = listToMaybe $ cursor $/ elContent "NextVersionIdMarker"
                       let prefix = listToMaybe $ cursor $/ elContent "Prefix"
                       contents <- sequence $ cursor $/ Cu.checkName objectNodeName &| parseObjectVersionInfo
                       let commonPrefixes = cursor $/ Cu.laxElement "CommonPrefixes" &// Cu.content
                       return GetBucketObjectVersionsResponse{
                                                gbovrName                = name
                                              , gbovrDelimiter           = delimiter
                                              , gbovrKeyMarker           = keyMarker
                                              , gbovrMaxKeys             = maxKeys
                                              , gbovrPrefix              = prefix
                                              , gbovrVersionIdMarker     = versionMarker
                                              , gbovrContents            = contents
                                              , gbovrCommonPrefixes      = commonPrefixes
                                              , gbovrIsTruncated         = truncated
                                              , gbovrNextKeyMarker       = nextKeyMarker
                                              , gbovrNextVersionIdMarker = nextVersionMarker
                                              }
              objectNodeName n = let fn = T.toCaseFold $ XML.nameLocalName n
                                  in fn == T.toCaseFold "Version" || fn == T.toCaseFold "DeleteMarker"

instance Transaction GetBucketObjectVersions GetBucketObjectVersionsResponse

instance IteratedTransaction GetBucketObjectVersions GetBucketObjectVersionsResponse where
    nextIteratedRequest request response
        = case (gbovrIsTruncated response, gbovrNextKeyMarker response, gbovrNextVersionIdMarker response, gbovrContents response) of
            (True, Just keyMarker, Just versionMarker, _             ) -> Just $ request { gbovKeyMarker = Just keyMarker, gbovVersionIdMarker = Just versionMarker }
            (True, Nothing,        Nothing,            contents@(_:_)) -> Just $ request { gbovKeyMarker = Just $ oviKey $ last contents, gbovVersionIdMarker = Just $ oviVersionId $ last contents }
            (_,    _,              _,                  _             ) -> Nothing

instance ListResponse GetBucketObjectVersionsResponse ObjectVersionInfo where
    listResponse = gbovrContents

instance AsMemoryResponse GetBucketObjectVersionsResponse where
    type MemoryResponse GetBucketObjectVersionsResponse = GetBucketObjectVersionsResponse
    loadToMemory = return