content: {-# LANGUAGE ExplicitForAll      #-}
  {-# LANGUAGE ScopedTypeVariables #-}
  
  {-|
  Module      : Docker.Client
  Copyright   : (c) Deni Bertovic, 2014
  License     : BSD3
  Maintainer  : deni@denibertovic.com
  Stability   : experimental
  Portability : POSIX
  
  = Getting started
  
  Creating a container:
  
  We're going to create a nginx container and we're going to map port @80@ from within the container to port @8000@ on
  the host.
  
  @
  import           Docker.Client
  
  runNginxContainer :: IO ContainerID
  runNginxContainer = do
      h <- defaultHttpHandler
      runDockerT (defaultClientOpts, h) $ do
      let pb = PortBinding 80 TCP [HostPort "0.0.0.0" 8000]
      let myCreateOpts = addPortBinding pb $ defaultCreateOpts "nginx:latest"
      cid <- createContainer myCreateOpts
      case cid of
          Left err -> error $ show err
          Right i -> do
              _ <- startContainer defaultStartOpts i
              return i
  @
  
  Let's start out nginx container:
  
  >>> cid <- runNginxContainer
  
  
  Visit http://localhost:8000 and verify that nginx is running.
  
  Let's stop the container now:
  
  @
  stopNginxContainer :: ContainerID -> IO ()
  stopNginxContainer cid = do
      h <- defaultHttpHandler
      runDockerT (defaultClientOpts, h) $ do
      r <- stopContainer DefaultTimeout cid
      case r of
          Left err -> error "I failed to stop the container"
          Right _ -> return ()
  @
  
  >>> stopNginxContainer cid
  
  Let's start a Postgres container by mapping the \/tmp directory from within the container to the
  \/tmp directory on the host. That way we make sure that the data we write to \/tmp in the container will
  persist on the host file system.
  
  @
  runPostgresContainer :: IO ContainerID
  runPostgresContainer = do
      h <- defaultHttpHandler
      runDockerT (defaultClientOpts, h) $ do
      let pb = PortBinding 5432 TCP [HostPort "0.0.0.0" 5432]
      let myCreateOpts = addBinds [Bind "\/tmp" "\/tmp" Nothing] $ addPortBinding pb $ defaultCreateOpts "postgres:9.5"
      cid <- createContainer myCreateOpts
      case cid of
          Left err -> error $ show err
          Right i -> do
              _ <- startContainer defaultStartOpts i
              return i
  @
  
  = Get Docker API Version
  
  >>> h <- defaultHttpHandler
  >>> runDockerT (defaultClientOpts, h) $ getDockerVersion
  Right (DockerVersion {version = "1.12.0", apiVersion = "1.24", gitCommit = "8eab29e", goVersion = "go1.6.3", os = "linux", arch = "amd64", kernelVersion = "4.6.0-1-amd64", buildTime = "2016-07-28T21:46:40.664812891+00:00"})
  
  = Setup SSL Authentication
  
  Let's create a custom 'HttpHandler' that uses a client's certificate and private key for SSL authentication.
  It also accepts a self-signed CA certificate which is specified via 'clientParamsSetCA'.
  This handler can replace 'defaultHttpHandler' in the arguments to 'runDockerT'.
  
  @
  let host = "domain.name"
  let port = fromInteger 4000
  let privKey = "path\/to\/private\/key"
  let cert = "path\/to\/certificate"
  let ca = "path\/to\/CA"
  paramsE <- clientParamsWithClientAuthentication host port privKey cert
  case paramsE of
      Left err ->
          error err
      Right params' -> do
          params <- clientParamsSetCA params' ca
          settings <- HTTP.mkManagerSettings (TLSSettings params) Nothing
          manager <- newManager settings
          return $ httpHandler manager
  @
  
  
  -}
  module Docker.Client (
      -- * Client functions
        module Docker.Client.Api
      -- * Types
      , module Docker.Client.Types
      -- * Http
      , module Docker.Client.Http
      ) where
  
  import           Docker.Client.Api
  import           Docker.Client.Http
  import           Docker.Client.Types
  