Devops.Cli

Building-block methods to build a command-line tool able to inspect and turnup/turndown DevOps.

Documentation

data Method

Constructors

TurnUp Concurrency

TurnDown Concurrency

Upkeep

Print

Dot

CheckDot

List

data Concurrency

Constructors

Concurrently

Sequentially

applyMethod :: [Forest PreOp -> Forest PreOp] -> Forest PreOp -> Method -> IO ()

Building main programs

simpleMain

Arguments

:: DevOp env a

an operation

-> [Forest PreOp -> Forest PreOp]

forest transformations to optimize the resulting graph

-> [String]

args

-> env

environment

-> IO ()

Simple main function for a single operation.

You should use this simpleMain for simple configuration binaries, more involved architectures shoul almost need a App or appMain.

type SelfPath = FilePath

A FilePath corresponding to the file with the currently-executing binary.

type ForestOptimization = Forest PreOp -> Forest PreOp

An optimization on PreOp forests.

data App env node

A builder for app that can be useful for defining an infrastructure as a recursive structure where the "main entry point" of the recursion is the binary itself.

Constructors

App

Fields

• _parseArgs :: [String] -> (node, Method)

  Parses arguments, returns a parsed architecture and a set of args for the real defaulMain.

• _revParse :: node -> Method -> [String]

  Reverse parse arguments, for instance when building a callback.

• _target :: node -> SelfPath -> (node -> Method -> [String]) -> DevOp env ()

  Generates a target from the argument and the selfPath

• _opts :: [ForestOptimization]

  Optimizations to run.

• _retrieveEnv :: node -> IO env

  IO to retrieve the current environment.

appMain :: App env a -> IO ()

DefaultMain for App.

appMethod :: String -> Method

Unsafely parse a Method from what could be a command line argument.

(NB. unsafe means this function is partial, you should use this function in conjunction with methodArg for the reverse parse and you will be fine).

methodArg :: Method -> String

Serializes a Method to what should be a command-line argument later parsed via appMethod.

Utilities

getDependenciesOnly :: env -> DevOp env a -> Forest PreOp

Evaluates the dependencies of a DevOp, discarding any result.

graphize :: Forest PreOp -> GraphData PreOp OpUniqueId

Builds a Graph from dependencies represented as a Forest.

Nodes with a same hash in the Forest will correspond to the same node in the graph, hence, it's possible to create cycles by mistake if two nodes have a same hash by mistake (this is possible if the hash does not depend on all arguments to a DevOp).

opClosureFromB64 :: (Typeable env, Typeable a) => ByteString -> Closure (DevOp env a)

Helper to deal with App when you want to use Closures as a serialization/deserialization mechanism.

You will likely add opClosureFromB64 in the _parseArgs field of your App and opClosureToB64 in the _revParse field.

opClosureToB64 :: (Typeable env, Typeable a) => Closure (DevOp env a) -> ByteString

Dual to opClosureFromB64.