Main.hs

#!/usr/bin/env stack
{- stack script --nix --resolver lts-10.9
  --package streaming
  --package amazonka
  --package amazonka-s3
  --package amazonka-core
  --package bytestring
  --package resourcet
  --package conduit
  --package conduit-combinators
  --package lens
-}
{-# LANGUAGE OverloadedStrings #-}

import           Data.ByteString as BS
import           Control.Lens       (view)
import           Control.Monad.Trans.AWS  (runResourceT, runAWST, Region(..))
import           Control.Monad.Trans.Resource (ResourceT(..), MonadResource, register)
import           Network.AWS
import           Network.AWS.Data.Body (RsBody(..))
import           Network.AWS.S3
import Data.Conduit                       (($$), unwrapResumable, Source(..), ResumableSource(..))
import Data.Conduit.List                  as CL
import qualified Data.Conduit.Combinators as CC
import           Streaming
import qualified Streaming.Prelude        as S


stream :: (MonadResource m, MonadAWS m) => m (Stream (Of BS.ByteString) (ResourceT IO) ())
stream = do
    resumable <- conduits
    -- TODO: need to do something with finalize?
    (src, finalize) <- liftIO $ runResourceT $ unwrapResumable resumable
    return $ hoist lift src $$ CL.mapM_ S.yield


conduits :: (MonadResource m, MonadAWS m) => m (ResumableSource (ResourceT IO) BS.ByteString)
conduits = do
  let bucketName = BucketName "foobar"
      key = ObjectKey "foo"
  rs <- send (getObject bucketName key)
  let (RsBody body) = view gorsBody rs
  return body

main :: IO ()
main = do
    env <- newEnv Discover
    s <- runResourceT (runAWS env stream)
    runResourceT $ S.print s