{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
module Network.Mattermost.Util
( ConnectionType(..)
, assertE
, noteE
, hoistE
, (~=)
, withConnection
, mkConnection
, connectionGetExact
, buildPath
) where
import Control.Exception (finally, onException)
import Data.Char ( toUpper )
import qualified Data.ByteString.Char8 as B
import qualified Data.Text as T
import qualified Text.URI as URI
import Data.Monoid ((<>))
import Control.Exception ( Exception
, throwIO )
import Data.Pool (takeResource, putResource, destroyResource)
import Network.Connection ( Connection
, ConnectionContext
, ConnectionParams(..)
, ProxySettings(..)
, TLSSettings(..)
, connectionGet
, connectTo )
import Network.Mattermost.Types.Base
import Network.Mattermost.Types.Internal
import Network.Mattermost.Proxy
noteE :: Exception e => Maybe r -> e -> IO r
noteE Nothing e = throwIO e
noteE (Just r) _ = pure r
hoistE :: Exception e => Either e r -> IO r
hoistE (Left e) = throwIO e
hoistE (Right r) = pure r
assertE :: Exception e => Bool -> e -> IO ()
assertE True _ = pure ()
assertE False e = throwIO e
(~=) :: String -> String -> Bool
a ~= b = map toUpper a == map toUpper b
withConnection :: ConnectionData -> (MMConn -> IO a) -> IO a
withConnection cd action = do
(conn, lp) <- takeResource (cdConnectionPool cd)
(action conn `onException` closeMMConn conn) `finally` do
c <- isConnected conn
if c then
putResource lp conn else
destroyResource (cdConnectionPool cd) lp conn
mkConnection :: ConnectionContext -> Hostname -> Port -> ConnectionType -> IO Connection
mkConnection ctx host port connTy = do
proxy' <- case connTy of
ConnectHTTPS _ -> proxyForScheme HTTPS
ConnectHTTP -> return Nothing
canUseProxy <- proxyHostPermitted (T.unpack host)
let proxy = if canUseProxy then proxy' else Nothing
connectTo ctx $ ConnectionParams
{ connectionHostname = T.unpack host
, connectionPort = fromIntegral port
, connectionUseSecure = case connTy of
ConnectHTTP -> Nothing
ConnectHTTPS requireTrustedCert ->
Just (TLSSettingsSimple (not requireTrustedCert) False False)
, connectionUseSocks = do
(ty, cHost, cPort) <- proxy
case ty of
Socks -> return $ SockSettingsSimple cHost (toEnum cPort)
}
connectionGetExact :: Connection -> Int -> IO B.ByteString
connectionGetExact con n = loop B.empty 0
where loop bs y
| y == n = return bs
| otherwise = do
next <- connectionGet con (n - y)
loop (B.append bs next) (y + (B.length next))
buildPath :: ConnectionData -> T.Text -> IO T.Text
buildPath cd endpoint = do
let rawPath = "/" <> (T.dropWhile (=='/') $ cdUrlPath cd <> "/api/v4/" <> endpoint)
uri <- URI.mkURI rawPath
return $ URI.render uri