How to run tests in parallel with multiple clients? about bake HOT 13 OPEN

type ImageId = String
type HostPort = Int

data Action = Compile
            | Dependencies
            | RunDocker ImageId HostPort
            | Deploy
            | IntegrationTest
            | UITest
            | EndToEndTest
            deriving (Show,Read)

instance Stringy Action where
  stringyTo = show
  stringyFrom = read

patchFile :: String
patchFile = ".bake.patch"

imageName :: String
imageName = "capitalmatch/app"

main :: IO ()
main = do
    putStrLn "Running CI"
    let err = "You need to set an environment variable named $REPO for the Git repo"
    repo <- fromMaybe (error err) `fmap` lookupEnv "REPO"
    bake $
      ovenNotifySlack "URI" "Channel" $
      ovenIncremental $
      -- what's this for ? Why the '=' sign...? looks like this is added to patch submitted
      ovenPretty $
      ovenStorePatch $
      ovenGitNotes repo $
      ovenGit repo "master" Nothing $
      ovenNotifyStdout $
      ovenTest (return allTests) execute
      defaultOven{ovenServer=("127.0.0.1",5000)}

-- | Extract latest patch from state or patches informaiont
-- this introduces a constraint for type of patch and state to be equals, which works well
-- for git but might fail for other systems... Anyway, we don't care for now.
ovenStorePatch :: (Stringy patch, state ~ patch) => Oven state patch test  -> Oven state patch test
ovenStorePatch oven@Oven{..}  = oven { ovenPrepare = \ s ps -> do
                                          let latest = extractLatestPatch s ps
                                          writeFile patchFile latest
                                          ovenPrepare s ps
                                     }


extractLatestPatch :: (Stringy s) => s -> [s] -> String
extractLatestPatch s [] = stringyTo s
extractLatestPatch _ ps = stringyTo $ last ps

-- |Add ''notes'' containing result of build and attach it to head patch
-- The idea is to leverage standard git's notes mechanism to attach meta information from
-- build to commits thus allowing anybody to retrieve information about commits' builds
-- and actions that affected it.
ovenGitNotes :: (Stringy patch, state ~ patch) => String -> Oven state patch test -> Oven state patch test
ovenGitNotes repo oven@Oven{..} = oven{ ovenUpdate = \ up ps -> do
                                           s <- ovenUpdate up ps
                                           pushNotes repo up ps
                                           return s
                                        }

pushNotes :: (Stringy s) => String -> s -> [s] -> IO ()
pushNotes repo s ps = do
  let latest = extractLatestPatch s ps
  () <-  cmd "git fetch" [repo] ["refs/notes/*:refs/notes/*"]
  () <-  cmd "git notes --ref=bake append" ["-m", "build successful", latest]
  () <-  cmd "git push" [repo] ["refs/notes/*"]
  return ()


allTests :: [Action]
allTests = [ Compile
           , Dependencies
           , IntegrationTest
           , UITest
           , EndToEndTest
           , Deploy
           , RunDocker "app" 8080
           , RunDocker "app-dev" 8081
           ]

execute :: Action -> TestInfo Action
execute Dependencies = run $ do
  opt <- addPath ["."] []
  () <- cmd opt "./build.sh images/ghc-clojure.uuid"
  sleep 1
  incrementalDone

execute Compile = depend [Dependencies] $ run $ do
  opt <- addPath ["."] []
  () <- cmd opt "./build.sh"
  sleep 1
  incrementalDone

execute IntegrationTest = depend [Compile] $ run $ do
  opt <- addPath ["."] []
  () <- cmd opt "./build.sh test"
  incrementalDone

execute UITest = depend [Compile] $ run $ do
  opt <- addPath ["."] []
  () <- cmd opt "./build.sh ui-test"
  incrementalDone

execute EndToEndTest = depend [Compile] $ run $ do
  opt <- addPath ["."] []
  () <- cmd opt "./build.sh end-to-end-tests"
  incrementalDone

execute Deploy  = depend [IntegrationTest, UITest, EndToEndTest] $ run $ do
  patch <- readFile patchFile
  -- we make sure that tag is not set to another image
  () <- cmd $ "docker tag -f " ++ latest imageName ++ " " ++ tagged imageName patch
  () <- cmd $ "docker push " ++ tagged imageName patch
  incrementalDone
    where
      tagged name patch = name ++ ":" ++ patch
      latest name       = tagged name "latest"

execute (RunDocker image port) = depend [UITest, IntegrationTest, EndToEndTest] $ run $ do
  Exit _ <- cmd $ "docker stop " ++ image
  Exit _ <- cmd $ "docker rm " ++ image
  () <- cmd "docker run" [ "--name=" ++ image
                         , "-d"
                         , "-p",  show port ++ ":8080"
                         , "-v", "/home/build/data-" ++ image ++ ":/data"
                         , "capitalmatch/" ++ image ++ ":latest"
                         ]
  incrementalDone