fix: ignore body of responses to head requests as per spec

.github/workflows/ci.yml

@@ -18,31 +18,32 @@ env:
   MINIO_ACCESS_KEY: minio
   MINIO_SECRET_KEY: minio123
   MINIO_LOCAL: 1
+  MINIO_SECURE: 1
 
 jobs:
   ormolu:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: haskell-actions/run-ormolu@v15
+      - uses: actions/checkout@v3
+      - uses: haskell-actions/run-ormolu@v12
         with:
           version: "0.5.0.1"
 
   hlint:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+    - uses: actions/checkout@v3
 
-      - name: "Set up HLint"
-        uses: haskell-actions/hlint-setup@v2
-        with:
-          version: "3.5"
+    - name: 'Set up HLint'
+      uses: haskell/actions/hlint-setup@v2
+      with:
+        version: '3.5'
 
-      - name: "Run HLint"
-        uses: haskell-actions/hlint-run@v2
-        with:
-          path: '["src/", "test/", "examples"]'
-          fail-on: warning
+    - name: 'Run HLint'
+      uses: haskell/actions/hlint-run@v2
+      with:
+        path: '["src/", "test/", "examples"]'
+        fail-on: warning
 
   cabal:
     name: ${{ matrix.os }} / ghc-${{ matrix.ghc }} / cabal-${{ matrix.cabal }}
@@ -50,217 +51,180 @@ jobs:
     needs: ormolu
     strategy:
       matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-        cabal: ["3.8", "latest"]
+        os: [ubuntu-latest, windows-latest] # Removed macos-latest due to cert issues.
+        cabal: ["3.6", "3.8", "latest"]
         ghc:
-          - "9.8"
-          - "9.6"
           - "9.4"
           - "9.2"
           - "9.0"
           - "8.10"
+          - "8.8"
+          - "8.6"
         exclude:
-          # macos llvm issue for versions less than 9.2
-          - os: macos-latest
-            ghc: "8.10"
-          - os: macos-latest
-            ghc: "9.0"
-          # Cabal 3.8 supports GHC < 9.6
-          - cabal: "3.8"
-            ghc: "9.6"
-          - cabal: "3.8"
-            ghc: "9.8"
+          - os: windows-latest
+            ghc: "9.4"
+            cabal: "3.6"
 
     steps:
-      - uses: actions/checkout@v4
-        if: github.event.action == 'opened' || github.event.action == 'synchronize' || github.event.ref == 'refs/heads/master'
+    - uses: actions/checkout@v3
+      if: github.event.action == 'opened' || github.event.action == 'synchronize' || github.event.ref == 'refs/heads/master'
 
-      - uses: haskell-actions/setup@v2
-        id: setup
-        name: Setup Haskell
-        with:
-          ghc-version: ${{ matrix.ghc }}
-          cabal-version: ${{ matrix.cabal }}
-          cabal-update: true
+    - uses: haskell/actions/setup@v2
+      id: setup-haskell-cabal
+      name: Setup Haskell
+      with:
+        ghc-version: ${{ matrix.ghc }}
+        cabal-version: ${{ matrix.cabal }}
 
-      - name: Configure
-        run: |
-          cabal configure --enable-tests --enable-benchmarks             --test-show-details=direct -fexamples -fdev -flive-test
-          cabal build all --dry-run
-        # The last step generates dist-newstyle/cache/plan.json for the cache key.
+    - name: Configure
+      run: |
+        cabal configure --enable-tests --enable-benchmarks --test-show-details=direct -fexamples -fdev -flive-test
 
-      - name: Restore cached dependencies
-        uses: actions/cache/restore@v4
-        id: cache
-        env:
-          key: ${{ runner.os }}-ghc-${{ steps.setup.outputs.ghc-version }}-cabal-${{ steps.setup.outputs.cabal-version }}
-        with:
-          path: ${{ steps.setup.outputs.cabal-store }}
-          key: ${{ env.key }}-plan-${{ hashFiles('**/plan.json') }}
-          restore-keys: ${{ env.key }}-
+    - name: Freeze
+      run: |
+        cabal freeze
 
-      - name: Install dependencies
-        # If we had an exact cache hit, the dependencies will be up to date.
-        if: steps.cache.outputs.cache-hit != 'true'
-        run: cabal build all --only-dependencies
+    - uses: actions/cache@v3
+      name: Cache ~/.cabal/packages, ~/.cabal/store and dist-newstyle
+      with:
+        path: |
+          ~/.cabal/packages
+          ~/.cabal/store
+          dist-newstyle
+        key: ${{ runner.os }}-${{ matrix.ghc }}-${{ hashFiles('**/*.cabal', '**/cabal.project', '**/cabal.project.freeze') }}
+        restore-keys: ${{ runner.os }}-${{ matrix.ghc }}-
 
-      # Cache dependencies already here, so that we do not have to rebuild them should the subsequent steps fail.
-      - name: Save cached dependencies
-        uses: actions/cache/save@v4
-        # If we had an exact cache hit, trying to save the cache would error because of key clash.
-        if: steps.cache.outputs.cache-hit != 'true'
-        with:
-          path: ${{ steps.setup.outputs.cabal-store }}
-          key: ${{ steps.cache.outputs.cache-primary-key }}
+    - name: Install dependencies
+      run: |
+        cabal build --only-dependencies
 
-      - name: Build
-        run: |
-          cabal build all
+    - name: Build
+      run: |
+        cabal build
 
-      - name: Setup TLS certs for MinIO for testing (Linux)
-        if: matrix.os == 'ubuntu-latest'
-        run: |
-          mkdir -p /tmp/minio /tmp/minio-config/certs
-          cp test/cert/* /tmp/minio-config/certs/
-          (cd /tmp/minio; wget -q https://dl.min.io/server/minio/release/linux-amd64/minio; chmod +x ./minio)
-          sudo cp /tmp/minio-config/certs/public.crt /usr/local/share/ca-certificates/
-          sudo update-ca-certificates
+    - name: Setup MinIO for testing (Linux)
+      if: matrix.os == 'ubuntu-latest'
+      run: |
+        mkdir -p /tmp/minio /tmp/minio-config/certs
+        cp test/cert/* /tmp/minio-config/certs/
+        (cd /tmp/minio; wget -q https://dl.min.io/server/minio/release/linux-amd64/minio; chmod +x ./minio)
+        sudo cp /tmp/minio-config/certs/public.crt /usr/local/share/ca-certificates/
+        sudo update-ca-certificates
 
-      ## Currently disable TLS setup for MacOS due to issues in trusting it on MacOS.
-      - name: Setup TLS certs for MinIO for testing (MacOS)
-        if: matrix.os == 'macos-latest'
-        run: |
-          mkdir -p /tmp/minio /tmp/minio-config/certs
-          cp test/cert/* /tmp/minio-config/certs/
-          (cd /tmp/minio; wget -q https://dl.min.io/server/minio/release/darwin-amd64/minio; chmod +x ./minio)
-          # sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain /tmp/minio-config/certs/public.crt
+    - name: Setup MinIO for testing (MacOS)
+      if: matrix.os == 'macos-latest'
+      run: |
+        mkdir -p /tmp/minio /tmp/minio-config/certs
+        cp test/cert/* /tmp/minio-config/certs/
+        (cd /tmp/minio; wget -q https://dl.min.io/server/minio/release/darwin-amd64/minio; chmod +x ./minio)
+        sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain /tmp/minio-config/certs/public.crt
 
-      - name: Setup MinIO for testing (Windows)
-        if: matrix.os == 'windows-latest'
-        run: |
-          New-Item -ItemType Directory -Path "$env:temp/minio-config/certs/"
-          Copy-Item -Path test\cert\* -Destination "$env:temp/minio-config/certs/"
-          Invoke-WebRequest -Uri https://dl.minio.io/server/minio/release/windows-amd64/minio.exe -OutFile $HOME/minio.exe
-          Import-Certificate -FilePath "$env:temp/minio-config/certs/public.crt" -CertStoreLocation Cert:\LocalMachine\Root
+    - name: Setup MinIO for testing (Windows)
+      if: matrix.os == 'windows-latest'
+      run: |
+        New-Item -ItemType Directory -Path "$env:temp/minio-config/certs/"
+        Copy-Item -Path test\cert\* -Destination "$env:temp/minio-config/certs/"
+        Invoke-WebRequest -Uri https://dl.minio.io/server/minio/release/windows-amd64/minio.exe -OutFile $HOME/minio.exe
+        Import-Certificate -FilePath "$env:temp/minio-config/certs/public.crt" -CertStoreLocation Cert:\LocalMachine\Root
 
-      - name: Test (Linux)
-        if: matrix.os == 'ubuntu-latest'
-        env:
-          MINIO_SECURE: 1
-        run: |
-          /tmp/minio/minio server --quiet --certs-dir /tmp/minio-config/certs data1 data2 data3 data4 2>&1 > minio.log &
-          ghc --version
-          cabal --version
-          cabal test all
+    - name: Test (Non-Windows)
+      if: matrix.os != 'windows-latest'
+      run: |
+        /tmp/minio/minio server --quiet --certs-dir /tmp/minio-config/certs data1 data2 data3 data4 2>&1 > minio.log &
+        ghc --version
+        cabal --version
+        cabal test
 
-      - name: Test (MacOS)
-        if: matrix.os == 'macos-latest'
-        # # Leave MINIO_SECURE unset to disable TLS in tests.
-        # env:
-        #   MINIO_SECURE: 1
-        run: |
-          /tmp/minio/minio server --quiet data1 data2 data3 data4 2>&1 > minio.log &
-          ghc --version
-          cabal --version
-          cabal test all
-
-      - name: Test (Windows)
-        if: matrix.os == 'windows-latest'
-        env:
-          MINIO_SECURE: 1
-        run: |
-          Start-Process -NoNewWindow -FilePath "$HOME/minio.exe" -ArgumentList "--certs-dir", "$env:temp/minio-config/certs", "server", "$env:temp/data1", "$env:temp/data2", "$env:temp/data3", "$env:temp/data4"
-          ghc --version
-          cabal --version
-          cabal test all
+    - name: Test (Windows)
+      if: matrix.os == 'windows-latest'
+      run: |
+        Start-Process -NoNewWindow -FilePath "$HOME/minio.exe" -ArgumentList "--certs-dir", "$env:temp/minio-config/certs", "server", "$env:temp/data1", "$env:temp/data2", "$env:temp/data3", "$env:temp/data4"
+        ghc --version
+        cabal --version
+        cabal test
 
   stack:
     name: stack / ghc ${{ matrix.ghc }}
     runs-on: ${{ matrix.os }}
-    env:
-      MINIO_SECURE: 1
     strategy:
       matrix:
         ghc:
           - "8.10.7"
           - "9.0.2"
-          - "9.2.8"
-          - "9.4.8"
-          - "9.6.5"
-          - "9.8.2"
+          - "9.2.4"
         os: [ubuntu-latest]
 
     steps:
-      - uses: actions/checkout@v4
-        if: github.event.action == 'opened' || github.event.action == 'synchronize' || github.event.ref == 'refs/heads/master'
+    - uses: actions/checkout@v3
+      if: github.event.action == 'opened' || github.event.action == 'synchronize' || github.event.ref == 'refs/heads/master'
 
-      - uses: haskell-actions/setup@v2
-        with:
-          ghc-version: ${{ matrix.ghc }}
-          enable-stack: true
-          stack-version: "latest"
+    - uses: haskell/actions/setup@v2
+      name: Setup Haskell Stack
+      with:
+        enable-stack: true
+        ghc-version: ${{ matrix.ghc }}
+        stack-version: 'latest'
 
-      - uses: actions/cache@v4
-        name: Cache ~/.stack
-        with:
-          path: ~/.stack
-          key: ${{ runner.os }}-stack-global-${{ hashFiles('stack.yaml') }}-${{ hashFiles('package.yaml') }}
-          restore-keys: |
-            ${{ runner.os }}-stack-global-
-      - uses: actions/cache@v4
-        name: Cache .stack-work
-        with:
-          path: .stack-work
-          key: ${{ runner.os }}-stack-work-${{ hashFiles('stack.yaml') }}-${{ hashFiles('package.yaml') }}-${{ hashFiles('**/*.hs') }}
-          restore-keys: |
-            ${{ runner.os }}-stack-work-
+    - uses: actions/cache@v3
+      name: Cache ~/.stack
+      with:
+        path: ~/.stack
+        key: ${{ runner.os }}-stack-global-${{ hashFiles('stack.yaml') }}-${{ hashFiles('package.yaml') }}
+        restore-keys: |
+          ${{ runner.os }}-stack-global-
+    - uses: actions/cache@v3
+      name: Cache .stack-work
+      with:
+        path: .stack-work
+        key: ${{ runner.os }}-stack-work-${{ hashFiles('stack.yaml') }}-${{ hashFiles('package.yaml') }}-${{ hashFiles('**/*.hs') }}
+        restore-keys: |
+          ${{ runner.os }}-stack-work-
 
-      - name: Install dependencies
-        run: |
-          stack --version
-          stack build --system-ghc --test --bench --no-run-tests --no-run-benchmarks --only-dependencies
+    - name: Install dependencies
+      run: |
+        stack build --system-ghc --test --bench --no-run-tests --no-run-benchmarks --only-dependencies
 
-      - name: Build
-        run: |
-          stack build --system-ghc --test --bench --no-run-tests --no-run-benchmarks --flag minio-hs:examples --flag minio-hs:live-test --flag minio-hs:dev
+    - name: Build
+      run: |
+        stack build --system-ghc --test --bench --no-run-tests --no-run-benchmarks --flag minio-hs:examples --flag minio-hs:live-test --flag minio-hs:dev
 
-      - name: Setup MinIO for testing (Linux)
-        if: matrix.os == 'ubuntu-latest'
-        run: |
-          mkdir -p /tmp/minio /tmp/minio-config/certs
-          cp test/cert/* /tmp/minio-config/certs/
-          (cd /tmp/minio; wget -q https://dl.min.io/server/minio/release/linux-amd64/minio; chmod +x ./minio)
-          sudo cp /tmp/minio-config/certs/public.crt /usr/local/share/ca-certificates/
-          sudo update-ca-certificates
+    - name: Setup MinIO for testing (Linux)
+      if: matrix.os == 'ubuntu-latest'
+      run: |
+        mkdir -p /tmp/minio /tmp/minio-config/certs
+        cp test/cert/* /tmp/minio-config/certs/
+        (cd /tmp/minio; wget -q https://dl.min.io/server/minio/release/linux-amd64/minio; chmod +x ./minio)
+        sudo cp /tmp/minio-config/certs/public.crt /usr/local/share/ca-certificates/
+        sudo update-ca-certificates
 
-      - name: Setup MinIO for testing (MacOS)
-        if: matrix.os == 'macos-latest'
-        run: |
-          mkdir -p /tmp/minio /tmp/minio-config/certs
-          cp test/cert/* /tmp/minio-config/certs/
-          (cd /tmp/minio; wget -q https://dl.min.io/server/minio/release/darwin-amd64/minio; chmod +x ./minio)
-          sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain /tmp/minio-config/certs/public.crt
+    - name: Setup MinIO for testing (MacOS)
+      if: matrix.os == 'macos-latest'
+      run: |
+        mkdir -p /tmp/minio /tmp/minio-config/certs
+        cp test/cert/* /tmp/minio-config/certs/
+        (cd /tmp/minio; wget -q https://dl.min.io/server/minio/release/darwin-amd64/minio; chmod +x ./minio)
+        sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain /tmp/minio-config/certs/public.crt
 
-      - name: Setup MinIO for testing (Windows)
-        if: matrix.os == 'windows-latest'
-        run: |
-          New-Item -ItemType Directory -Path "$env:temp/minio-config/certs/"
-          Copy-Item -Path test\cert\* -Destination "$env:temp/minio-config/certs/"
-          Invoke-WebRequest -Uri https://dl.minio.io/server/minio/release/windows-amd64/minio.exe -OutFile $HOME/minio.exe
-          Import-Certificate -FilePath "$env:temp/minio-config/certs/public.crt" -CertStoreLocation Cert:\LocalMachine\Root
+    - name: Setup MinIO for testing (Windows)
+      if: matrix.os == 'windows-latest'
+      run: |
+        New-Item -ItemType Directory -Path "$env:temp/minio-config/certs/"
+        Copy-Item -Path test\cert\* -Destination "$env:temp/minio-config/certs/"
+        Invoke-WebRequest -Uri https://dl.minio.io/server/minio/release/windows-amd64/minio.exe -OutFile $HOME/minio.exe
+        Import-Certificate -FilePath "$env:temp/minio-config/certs/public.crt" -CertStoreLocation Cert:\LocalMachine\Root
 
-      - name: Test (Non-Windows)
-        if: matrix.os != 'windows-latest'
-        run: |
-          /tmp/minio/minio server --quiet --certs-dir /tmp/minio-config/certs data1 data2 data3 data4 2>&1 > minio.log &
-          ghc --version
-          stack --version
-          stack test --system-ghc --flag minio-hs:live-test --flag minio-hs:dev
+    - name: Test (Non-Windows)
+      if: matrix.os != 'windows-latest'
+      run: |
+        /tmp/minio/minio server --quiet --certs-dir /tmp/minio-config/certs data1 data2 data3 data4 2>&1 > minio.log &
+        ghc --version
+        stack --version
+        stack test --system-ghc --flag minio-hs:live-test --flag minio-hs:dev
 
-      - name: Test (Windows)
-        if: matrix.os == 'windows-latest'
-        run: |
-          Start-Process -NoNewWindow -FilePath "$HOME/minio.exe" -ArgumentList "--certs-dir", "$env:temp/minio-config/certs", "server", "$env:temp/data1", "$env:temp/data2", "$env:temp/data3", "$env:temp/data4"
-          ghc --version
-          cabal --version
-          stack test --system-ghc --flag minio-hs:live-test --flag minio-hs:dev
+    - name: Test (Windows)
+      if: matrix.os == 'windows-latest'
+      run: |
+        Start-Process -NoNewWindow -FilePath "$HOME/minio.exe" -ArgumentList "--certs-dir", "$env:temp/minio-config/certs", "server", "$env:temp/data1", "$env:temp/data2", "$env:temp/data3", "$env:temp/data4"
+        ghc --version
+        cabal --version
+        stack test --system-ghc --flag minio-hs:live-test --flag minio-hs:dev

minio-hs.cabal

@@ -22,12 +22,12 @@ extra-doc-files:
 extra-source-files:
                    examples/*.hs
                    stack.yaml
-tested-with:  GHC == 8.10.7
+tested-with:         GHC == 8.6.5
+                   , GHC == 8.8.4
+                   , GHC == 8.10.7
                    , GHC == 9.0.2
-                   , GHC == 9.2.8
-                   , GHC == 9.4.8
-                   , GHC == 9.6.5
-                   , GHC == 9.8.2
+                   , GHC == 9.2.7
+                   , GHC == 9.4.5
 
 source-repository head
   type:                git
@@ -114,7 +114,7 @@ common base-settings
                      , case-insensitive >= 1.2
                      , conduit >= 1.3
                      , conduit-extra >= 1.3
-                     , crypton-connection
+                     , connection
                      , cryptonite >= 0.25
                      , cryptonite-conduit >= 0.2
                      , digest >= 0.0.1

src/Lib/Prelude.hs

@@ -37,13 +37,14 @@ import UnliftIO as Exports
     throwIO,
     try,
   )
+import qualified Data.Text.Encoding as T
 
 -- | Apply a function on both elements of a pair
 both :: (a -> b) -> (a, a) -> (b, b)
 both f (a, b) = (f a, f b)
 
-showBS :: (Show a) => a -> ByteString
-showBS a = encodeUtf8 (show a :: Text)
+showBS :: Show a => a -> ByteString
+showBS a = T.encodeUtf8 (show a :: Text)
 
 toStrictBS :: LByteString -> ByteString
 toStrictBS = LB.toStrict

src/Network/Minio.hs

@@ -41,13 +41,14 @@ module Network.Minio
     findFirst,
 
     -- * Connecting to object storage
-    ConnectInfo,
+    ConnectInfo(..),
     setRegion,
     setCreds,
     setCredsFrom,
     isConnectInfoSecure,
     disableTLSCertValidation,
     MinioConn,
+    connect,
     mkMinioConn,
 
     -- ** Connection helpers

src/Network/Minio/Data.hs

@@ -1068,7 +1068,7 @@ defaultS3ReqInfo =
 
 getS3Path :: Maybe Bucket -> Maybe Object -> ByteString
 getS3Path b o =
-  let segments = map encodeUtf8 $ catMaybes $ b : bool [] [o] (isJust b)
+  let segments = map TE.encodeUtf8 $ catMaybes $ b : bool [] [o] (isJust b)
    in B.concat ["/", B.intercalate "/" segments]
 
 type RegionMap = H.HashMap Bucket Region
@@ -1084,10 +1084,12 @@ newtype Minio a = Minio
       Monad,
       MonadIO,
       MonadReader MinioConn,
-      MonadResource,
-      MonadUnliftIO
+      MonadResource
     )
 
+instance MonadUnliftIO Minio where
+  withRunInIO inner = Minio $ U.askUnliftIO >>= \(U.UnliftIO unliftIO) -> liftIO (inner $ \(Minio f) -> unliftIO f)
+
 -- | MinioConn holds connection info and a connection pool to allow
 -- for efficient resource re-use.
 data MinioConn = MinioConn

src/Network/Minio/PresignedOperations.hs

@@ -41,6 +41,7 @@ import qualified Data.Aeson as Json
 import Data.ByteString.Builder (byteString, toLazyByteString)
 import qualified Data.HashMap.Strict as H
 import qualified Data.Text as T
+import qualified Data.Text.Encoding as TE
 import qualified Data.Time as Time
 import Lib.Prelude
 import qualified Network.HTTP.Client as NClient
@@ -334,7 +335,7 @@ presignedPostPolicy p = do
       mkPair (PPCEquals k v) = Just (k, v)
       mkPair _ = Nothing
       formFromPolicy =
-        H.map encodeUtf8 $
+        H.map TE.encodeUtf8 $
           H.fromList $
             mapMaybe
               mkPair

src/Network/Minio/S3API.hs

@@ -109,6 +109,7 @@ where
 
 import qualified Data.ByteString as BS
 import qualified Data.Text as T
+import qualified Data.Text.Encoding as TE
 import Lib.Prelude
 import qualified Network.HTTP.Conduit as NC
 import qualified Network.HTTP.Types as HT
@@ -389,7 +390,7 @@ putObjectPart bucket object uploadId partNumber headers payload = do
 srcInfoToHeaders :: SourceInfo -> [HT.Header]
 srcInfoToHeaders srcInfo =
   ( "x-amz-copy-source",
-    encodeUtf8 $
+    TE.encodeUtf8 $
       T.concat
         [ "/",
           srcBucket srcInfo,

src/Network/Minio/Sign/V4.hs

@@ -49,6 +49,8 @@ import Network.Minio.Data.Crypto
 import Network.Minio.Data.Time
 import Network.Minio.Errors
 import Text.Printf (printf)
+import qualified Data.Text.Encoding as TE
+import qualified Data.Text as T
 
 -- these headers are not included in the string to sign when signing a
 -- request
@@ -86,7 +88,7 @@ mkAuthHeader accessKey scope signedHeaderKeys sign =
   let authValue =
         B.concat
           [ "AWS4-HMAC-SHA256 Credential=",
-            encodeUtf8 accessKey,
+            TE.encodeUtf8 accessKey,
             "/",
             scope,
             ", SignedHeaders=",
@@ -317,7 +319,7 @@ getSigningKey :: SignParams -> ByteString
 getSigningKey sp =
   hmacSHA256RawBS "aws4_request"
     . hmacSHA256RawBS (toByteString $ spService sp)
-    . hmacSHA256RawBS (encodeUtf8 $ fromMaybe "" $ spRegion sp)
+    . hmacSHA256RawBS (TE.encodeUtf8 $ fromMaybe "" $ spRegion sp)
     . hmacSHA256RawBS (awsDateFormatBS $ spTimeStamp sp)
     $ B.concat ["AWS4", BA.convert $ spSecretKey sp]
 

src/Network/Minio/Utils.hs

@@ -184,10 +184,10 @@ httpLbs req mgr = do
   resp <- either throwIO return respE
   unless (isSuccessStatus $ NC.responseStatus resp) $
     case contentTypeMay resp of
-      Just "application/xml" -> do
+      Just "application/xml" | expectBody -> do
         sErr <- parseErrResponse $ NC.responseBody resp
         throwIO sErr
-      Just "application/json" -> do
+      Just "application/json" | expectBody -> do
         sErr <- parseErrResponseJSON $ NC.responseBody resp
         throwIO sErr
       _ ->
@@ -204,6 +204,7 @@ httpLbs req mgr = do
     contentTypeMay resp =
       lookupHeader Hdr.hContentType $
         NC.responseHeaders resp
+    expectBody = NC.method req /= HT.methodHead
 
 http ::
   (MonadUnliftIO m, R.MonadResource m) =>
@@ -215,7 +216,7 @@ http req mgr = do
   resp <- either throwIO return respE
   unless (isSuccessStatus $ NC.responseStatus resp) $
     case contentTypeMay resp of
-      Just "application/xml" -> do
+      Just "application/xml" | expectBody -> do
         respBody <- C.connect (NC.responseBody resp) CB.sinkLbs
         sErr <- parseErrResponse respBody
         throwIO sErr
@@ -235,6 +236,7 @@ http req mgr = do
     contentTypeMay resp =
       lookupHeader Hdr.hContentType $
         NC.responseHeaders resp
+    expectBody = NC.method req /= HT.methodHead
 
 -- Similar to mapConcurrently but limits the number of threads that
 -- can run using a quantity semaphore.

stack.yaml

@@ -15,7 +15,7 @@
 # resolver:
 #  name: custom-snapshot
 #  location: "./custom-snapshot.yaml"
-resolver: lts-22.19
+resolver: lts-19.7
 
 # User packages to be built.
 # Various formats can be used as shown in the example below.
@@ -36,17 +36,17 @@ resolver: lts-22.19
 # non-dependency (i.e. a user package), and its test suites and benchmarks
 # will not be run. This is useful for tweaking upstream packages.
 packages:
-  - "."
+- '.'
 # Dependency packages to be pulled from upstream that are not in the resolver
 # (e.g., acme-missiles-0.3)
-extra-deps:
-  - crypton-connection-0.3.2
+extra-deps: []
 
 # Override default flag values for local packages and extra-deps
 flags: {}
 
 # Extra package databases containing global packages
 extra-package-dbs: []
+
 # Control whether we use the GHC we find on the path
 # system-ghc: true
 #

stack.yaml.lock

@@ -3,17 +3,10 @@
 # For more information, please see the documentation at:
 #   https://docs.haskellstack.org/en/stable/lock_files
 
-packages:
-- completed:
-    hackage: crypton-connection-0.3.2@sha256:c7937edc25ab022bcf167703f2ec5ab73b62908e545bb587d2aa42b33cd6f6cc,1581
-    pantry-tree:
-      sha256: f986ad29b008cbe5732606e9cde1897191c486a2f1f169a4cb75fd915bce397c
-      size: 394
-  original:
-    hackage: crypton-connection-0.3.2
+packages: []
 snapshots:
 - completed:
-    sha256: e5cac927cf7ccbd52aa41476baa68b88c564ee6ddc3bc573dbf4210069287fe7
-    size: 713340
-    url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/22/19.yaml
-  original: lts-22.19
+    size: 618884
+    url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/19/7.yaml
+    sha256: 57d4ce67cc097fea2058446927987bc1f7408890e3a6df0da74e5e318f051c20
+  original: lts-19.7

test/LiveServer.hs

@@ -49,51 +49,6 @@ main = defaultMain tests
 tests :: TestTree
 tests = testGroup "Tests" [liveServerUnitTests]
 
-lookupTestEnv :: IO (Maybe ConnectInfo, (AccessKey, SecretKey))
-lookupTestEnv = do
-  val <- Env.lookupEnv "MINIO_LOCAL"
-  secure <- Env.lookupEnv "MINIO_SECURE"
-  let localServerMaybe = case (val, secure) of
-        (Just _, Just _) -> Just "https://localhost:9000"
-        (Just _, Nothing) -> Just "http://localhost:9000"
-        _ -> Nothing
-  accessKeyE <- Env.lookupEnv "MINIO_ACCESS_KEY"
-  let accessKey = maybe "minioadmin" fromString accessKeyE
-  secretKeyE <- Env.lookupEnv "MINIO_SECRET_KEY"
-  let secretKey = maybe "minioadmin" fromString secretKeyE
-  return (localServerMaybe, (accessKey, secretKey))
-
-loadTestServerConnInfo :: IO ConnectInfo
-loadTestServerConnInfo = do
-  (localServerMaybe, (ak, sk)) <- lookupTestEnv
-  return $ case localServerMaybe of
-    Just localServer -> do
-      setCreds (CredentialValue ak sk mempty) localServer
-    _ -> minioPlayCI
-
-loadTestServerConnInfoSTS :: IO ConnectInfo
-loadTestServerConnInfoSTS = do
-  (localServerMaybe, (ak, sk)) <- lookupTestEnv
-  case localServerMaybe of
-    Just localServer -> do
-      let creds = CredentialValue ak sk mempty
-          assumeRole =
-            STSAssumeRole
-              { sarCredentials = creds,
-                sarOptions = defaultSTSAssumeRoleOptions
-              }
-      setSTSCredential assumeRole localServer
-    Nothing -> do
-      let creds = case connectCreds minioPlayCI of
-            CredsStatic c -> c
-            _ -> error "unexpected play creds"
-          assumeRole =
-            STSAssumeRole
-              { sarCredentials = creds,
-                sarOptions = defaultSTSAssumeRoleOptions
-              }
-      setSTSCredential assumeRole minioPlayCI
-
 -- conduit that generates random binary stream of given length
 randomDataSrc :: (MonadIO m) => Int64 -> C.ConduitM () ByteString m ()
 randomDataSrc = genBS
@@ -121,24 +76,34 @@ mkRandFile size = do
 funTestBucketPrefix :: Text
 funTestBucketPrefix = "miniohstest-"
 
-funTestWithBucketNoSTS ::
-  TestName ->
-  (([Char] -> Minio ()) -> Bucket -> Minio ()) ->
-  TestTree
-funTestWithBucketNoSTS t minioTest = testCaseSteps t $ \step -> do
-  -- generate a random name for the bucket
-  bktSuffix <- liftIO $ generate $ Q.vectorOf 10 (Q.choose ('a', 'z'))
-  let b = T.concat [funTestBucketPrefix, T.pack bktSuffix]
-      liftStep = liftIO . step
-  connInfo <- loadTestServerConnInfo
-  ret <- runMinio connInfo $ do
-    liftStep $ "Creating bucket for test - " ++ t
-    foundBucket <- bucketExists b
-    liftIO $ foundBucket @?= False
-    makeBucket b Nothing
-    minioTest liftStep b
-    deleteBucket b
-  isRight ret @? ("Functional test " ++ t ++ " failed => " ++ show ret)
+loadTestServerConnInfo :: IO ConnectInfo
+loadTestServerConnInfo = do
+  val <- Env.lookupEnv "MINIO_LOCAL"
+  isSecure <- Env.lookupEnv "MINIO_SECURE"
+  return $ case (val, isSecure) of
+    (Just _, Just _) -> setCreds (CredentialValue "minio" "minio123" mempty) "https://localhost:9000"
+    (Just _, Nothing) -> setCreds (CredentialValue "minio" "minio123" mempty) "http://localhost:9000"
+    (Nothing, _) -> minioPlayCI
+
+loadTestServerConnInfoSTS :: IO ConnectInfo
+loadTestServerConnInfoSTS = do
+  val <- Env.lookupEnv "MINIO_LOCAL"
+  isSecure <- Env.lookupEnv "MINIO_SECURE"
+  let cv = CredentialValue "minio" "minio123" mempty
+      assumeRole =
+        STSAssumeRole
+          { sarCredentials = cv,
+            sarOptions = defaultSTSAssumeRoleOptions
+          }
+  case (val, isSecure) of
+    (Just _, Just _) -> setSTSCredential assumeRole "https://localhost:9000"
+    (Just _, Nothing) -> setSTSCredential assumeRole "http://localhost:9000"
+    (Nothing, _) -> do
+      cv' <- case connectCreds minioPlayCI of
+        CredsStatic c -> return c
+        _ -> error "unexpected play creds"
+      let assumeRole' = assumeRole {sarCredentials = cv'}
+      setSTSCredential assumeRole' minioPlayCI
 
 funTestWithBucket ::
   TestName ->
@@ -638,7 +603,7 @@ presignedUrlFunTest = funTestWithBucket "presigned Url tests" $
         []
         []
 
-    -- print putUrl
+    print putUrl
     let size1 = 1000 :: Int64
     inputFile <- mkRandFile size1
 
@@ -727,7 +692,7 @@ presignedUrlFunTest = funTestWithBucket "presigned Url tests" $
       NC.httpLbs req mgr
 
 presignedPostPolicyFunTest :: TestTree
-presignedPostPolicyFunTest = funTestWithBucketNoSTS "Presigned Post Policy tests" $
+presignedPostPolicyFunTest = funTestWithBucket "Presigned Post Policy tests" $
   \step bucket -> do
     step "presignedPostPolicy basic test"
     now <- liftIO Time.getCurrentTime
@@ -1257,10 +1222,9 @@ getNPutSSECTest =
 assumeRoleRequestTest :: TestTree
 assumeRoleRequestTest = testCaseSteps "Assume Role STS API" $ \step -> do
   step "Load credentials"
-  (_, (ak, sk)) <- lookupTestEnv
   val <- Env.lookupEnv "MINIO_LOCAL"
   isSecure <- Env.lookupEnv "MINIO_SECURE"
-  let localMinioCred = Just $ CredentialValue ak sk mempty
+  let localMinioCred = Just $ CredentialValue "minio" "minio123" mempty
       playCreds =
         case connectCreds minioPlayCI of
           CredsStatic c -> Just c