Language.Docker.Creator

Writting Dockerfiles (Language.Docker.EDSL)

toDockerfileText :: EDockerfileM a -> Text

runs the Dockerfile EDSL and returns a Lazy using PrettyPrint

import Language.Docker

main :: IO ()
main = print $ toDockerfileText $ do
    from (tagged "fpco/stack-build" "lts-6.9")
    add ["."] "applanguage-docker"
    workdir "applanguage-docker"
    run "stack build --test --only-dependencies"
    cmd "stack test"

toDockerfile :: EDockerfileM a -> Dockerfile

Runs the Dockerfile EDSL and returns a Dockerfile you can pretty print or manipulate

putDockerfileStr :: EDockerfileM a -> IO ()

Prints the dockerfile to stdout. Mainly used for debugging purposes

import Language.Docker

main :: IO ()
main = putDockerfileStr $ do
    from (tagged "fpco/stack-build" "lts-6.9")
    add ["."] "applanguage-docker"
    workdir "applanguage-docker"
    run "stack build --test --only-dependencies"
    cmd "stack test"

writeDockerFile :: Text -> Dockerfile -> IO ()

Writes the dockerfile to the given file path after pretty-printing it

import Language.Docker

main :: IO ()
main = writeDockerFile "build.Dockerfile" $ toDockerfile $ do
    from (tagged "fpco/stack-build" "lts-6.9")
    add ["."] "applanguage-docker"
    workdir "applanguage-docker"
    run "stack build --test --only-dependencies"
    cmd "stack test"

toDockerfileTextIO :: MonadIO m => EDockerfileTM m t -> m Text

A version of toDockerfileText which allows IO actions

toDockerfileIO :: MonadIO m => EDockerfileTM m t -> m Dockerfile

A version of toDockerfile which allows IO actions

runDockerfileIO :: MonadIO m => EDockerfileTM m t -> m (t, Dockerfile)

Just runs the EDSL's writer monad

runDockerfileTextIO :: MonadIO m => EDockerfileTM m t -> m (t, Text)

Runs the EDSL's writer monad and pretty-prints the result

liftIO :: MonadIO m => IO a -> m a

Lift a computation from the IO monad.

from :: forall m. MonadFree EInstruction m => EBaseImage -> m ()

Constructing base images

tagged :: Image -> Tag -> EBaseImage

Use a specific tag for a docker image. This function is meant to be used as an infix operator.

from $ "fpco/stack-build" tagged "lts-10.3"

untagged :: Text -> EBaseImage

Use a docker image in a FROM instruction without a tag

The following two examples are equivalent

from $ untagged "fpco/stack-build"

Is equivalent to, when having OverloadedStrings:

from "fpco/stack-build"

digested :: EBaseImage -> Digest -> EBaseImage

Adds a digest checksum so a FROM instruction This function is meant to be used as an infix operator.

from $ "fpco/stack-build" digested "sha256:abcdef123"

aliased :: EBaseImage -> ImageAlias -> EBaseImage

Alias a FROM instruction to be used as a build stage. This function is meant to be used as an infix operator.

from $ "fpco/stack-build" aliased "builder"

Syntax

add :: MonadFree EInstruction m => NonEmpty SourcePath -> TargetPath -> m ()

Create an ADD instruction. This is often used as a shorthand version of copy when no extra options are needed. Currently there is no way to pass extra options to ADD, so you are encouraged to use copy instead.

add ["foo.js", "bar.js"] "."

user :: forall m. MonadFree EInstruction m => Text -> m ()

label :: forall m. MonadFree EInstruction m => Pairs -> m ()

stopSignal :: forall m. MonadFree EInstruction m => Text -> m ()

copy :: MonadFree EInstruction m => CopyArgs -> m ()

Create a COPY instruction. This function is meant to be used with the compinators to, fromStage and ownedBy

copy $ ["foo.js", "bar.js"] to "."
copy $ ["some_file"] to "somepath" fromStage "builder"

copyFromStage :: MonadFree EInstruction m => CopySource -> NonEmpty SourcePath -> TargetPath -> m ()

Create a COPY instruction from a given build stage. This is a shorthand version of using copy with combinators.

copyFromStage "builder" ["foo.js", "bar.js"] "."

to :: NonEmpty SourcePath -> TargetPath -> CopyArgs

Usedto join source paths with atarget path as an arguments for copy

This function is meant to be used as an infix operator:

copy $ ["foo.js"] to "." ownedBy

fromStage :: CopyArgs -> CopySource -> CopyArgs

Adds the --from= option to a COPY instruction.

This function is meant to be used as an infix operator:

copy $ ["foo.js"] to "." fromStage "builder"

ownedBy :: CopyArgs -> Chown -> CopyArgs

Adds the --chown= option to a COPY instruction.

This function is meant to be used as an infix operator:

copy $ ["foo.js"] to "." ownedBy "www-data:www-data"

toSources :: NonEmpty Text -> NonEmpty SourcePath

Converts a NonEmpty list of strings to a NonEmpty list of SourcePath

This is a convenience function when you need to pass a non-static list of strings that you build somewhere as an argument for copy or add

someFiles <- glob "*.js"
copy $ (toSources someFiles) to "."

toTarget :: Text -> TargetPath

Converts a Text into a TargetPath

This is a convenience function when you need to pass a string variable as an argument for copy or add

let destination = buildSomePath pwd
add ["foo.js"] (toTarget destination)

run :: MonadFree EInstruction m => Arguments Text -> m ()

Create a RUN instruction with the given arguments.

run "apt-get install wget"

runArgs :: forall m. MonadFree EInstruction m => Arguments Text -> RunFlags -> m ()

cmd :: MonadFree EInstruction m => Arguments Text -> m ()

Create a CMD instruction with the given arguments.

cmd "my-program --some-flag"

cmdArgs :: forall m. MonadFree EInstruction m => Arguments Text -> m ()

healthcheck :: forall m. MonadFree EInstruction m => Check Text -> m ()

check :: Arguments args -> Check args

interval :: Check args -> Integer -> Check args

timeout :: Check args -> Integer -> Check args

startPeriod :: Check args -> Integer -> Check args

retries :: Check args -> Integer -> Check args

workdir :: forall m. MonadFree EInstruction m => Directory -> m ()

expose :: forall m. MonadFree EInstruction m => Ports -> m ()

ports :: [Port] -> Ports

tcpPort :: Int -> Port

udpPort :: Int -> Port

variablePort :: Text -> Port

portRange :: Int -> Int -> Port

udpPortRange :: Int -> Int -> Port

volume :: forall m. MonadFree EInstruction m => Text -> m ()

entrypoint :: MonadFree EInstruction m => Arguments Text -> m ()

Create an ENTRYPOINT instruction with the given arguments.

entrypoint "usrlocalbinprogram --some-flag"

entrypointArgs :: forall m. MonadFree EInstruction m => Arguments Text -> m ()

maintainer :: forall m. MonadFree EInstruction m => Text -> m ()

env :: forall m. MonadFree EInstruction m => Pairs -> m ()

arg :: forall m. MonadFree EInstruction m => Text -> Maybe Text -> m ()

comment :: forall m. MonadFree EInstruction m => Text -> m ()

onBuild :: MonadFree EInstruction m => EDockerfileM a -> m ()

ONBUILD Dockerfile instruction

Each nested instruction gets emitted as a separate ONBUILD block

toDockerfile $ do
    from "node"
    run "apt-get update"
    onBuild $ do
        run "echo more-stuff"
        run "echo here"

onBuildRaw :: forall m. MonadFree EInstruction m => Instruction Text -> m ()

embed :: forall m. MonadFree EInstruction m => [InstructionPos Text] -> m ()

edockerfile :: QuasiQuoter

Quasiquoter for embedding dockerfiles on the EDSL

putStr $ toDockerfile $ do
    from "node"
    run "apt-get update"
    [edockerfile|
    RUN apt-get update
    CMD node something.js
    |]

Support types for the EDSL

type EDockerfileM = Free EInstruction

The type of Identity based EDSL blocks

type EDockerfileTM = FreeT EInstruction

The type of free monad EDSL blocks

data EBaseImage

Constructors

EBaseImage Image (Maybe Tag) (Maybe Digest) (Maybe ImageAlias) (Maybe Platform)

Instances

Eq EBaseImage

Defined in Language.Docker.EDSL.Types

Methods

(==) :: EBaseImage -> EBaseImage -> Bool

(/=) :: EBaseImage -> EBaseImage -> Bool

Ord EBaseImage

Defined in Language.Docker.EDSL.Types

Methods

compare :: EBaseImage -> EBaseImage -> Ordering

(<) :: EBaseImage -> EBaseImage -> Bool

(<=) :: EBaseImage -> EBaseImage -> Bool

(>) :: EBaseImage -> EBaseImage -> Bool

(>=) :: EBaseImage -> EBaseImage -> Bool

max :: EBaseImage -> EBaseImage -> EBaseImage

min :: EBaseImage -> EBaseImage -> EBaseImage

Show EBaseImage

Defined in Language.Docker.EDSL.Types

Methods

showsPrec :: Int -> EBaseImage -> ShowS

show :: EBaseImage -> String

showList :: [EBaseImage] -> ShowS

IsString EBaseImage

Defined in Language.Docker.EDSL.Types

Methods

fromString :: String -> EBaseImage

QuasiQuoter (Language.Docker.EDSL.Quasi)

dockerfile :: QuasiQuoter

Instruction and InstructionPos helpers

instructionPos :: Instruction args -> InstructionPos args