Azubi

Example:

import Azubi

main :: IO ()
main = azubiMain $ []
       & installed (Ebuild "vim")
       & uptodate (Git "gitgithub.com:mrVanDalo/azubi.git" "/dev/shm/azubi")
       & installed (Git "gitgithub.com:mrVanDalo/azubi-config.git" "/dev/shm/azubi-config")
       & run (Always "touch" ["devshm/run.test"])
       & link "/dev/shm/azubi.link" "/dev/shm/azubi"

Documentation

data State

The low level element to formulate a state on a machine. If the check returns No the Commands will run. So the author should make sure the Command will result in a Yes the next time this state will run.

All Checks have to return Yes to avoid the Commands to be run.

If a Command returns a Failure the following commands will not be called. Same holdes for States if one of the states fail, the following States will not be run.

Constructors

State [Check] [Command] (Maybe Comment)

State contains checks and commands if one command failed the following commands will not be executed.

States [Check] [State] (Maybe Comment)

To create depended states which should stop being executed when a previous state fails

Instances

Eq State

Methods

(==) :: State -> State -> Bool

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

Show State

Methods

showsPrec :: Int -> State -> ShowS

show :: State -> String

showList :: [State] -> ShowS

data Ebuild

Ebuild is a Portage package (used by Gentoo and Funtoo).

http://gentoo.org

See installed.

Constructors

Ebuild String

Instances

Updatable Ebuild

Methods

uptodate :: Ebuild -> State

Installable Ebuild

Methods

installed :: Ebuild -> State

data Git

Git is a version control system.

http://git.scm.com

See installed.

Constructors

Git RepoUrl Path [GitOption]

Instances

Updatable Git

Methods

uptodate :: Git -> State

Installable Git

Methods

installed :: Git -> State

data GitOption

Constructors

Recursive

data RunCommand

The way a command should be run. See run

Constructors

Always String [Argument]

run command every time

Once String [Argument] Path

run command and creates a file to prevent to run again

installed :: Installable a => a -> State

install a piece of software on the system. The piece of software should be typed of course.

class Installable a where

To install Software you have to instance the Installable class.

Minimal complete definition

installed

Methods

installed :: a -> State

install a piece of software on the system. The piece of software should be typed of course.

Instances

Installable Git

Methods

installed :: Git -> State

Installable Ebuild

Methods

installed :: Ebuild -> State

uptodate :: Updatable a => a -> State

make sure something is installed and up to date.

class Updatable a where

Same like Installable but will also make sure there you have the newest version.

Minimal complete definition

uptodate

Methods

uptodate :: a -> State

make sure something is installed and up to date.

Instances

Updatable Git

Methods

uptodate :: Git -> State

Updatable Ebuild

Methods

uptodate :: Ebuild -> State

run :: RunCommand -> State

creates a State that will run a command of your choice.

link :: Path -> Path -> State

ensure there is a link file -> target

example:

link "~/file" "~/target"

will create a link at ~/file/ pointing to ~/target/

folderExists :: Path -> State

make sure a folder exists

content :: Path -> [String] -> State

Create a state that ensures that a file in Path will have the content of the String List.

Every String in the List will be a Line in the File.

requires :: State -> State -> State

Creates a state out of two states. When the first State fails the second State will not be checked nor enforced.

This can also be achieved using submodule:

stateA requires stateB == submodule [stateB, stateA]

submodule :: [State] -> State

Create a state containing of sub-states, which have to be fulfilled in order.

If one state is not fulfilled, the following will be ignored.

(&) :: [State] -> State -> [State]

State combinator.

[]
& folderExists "/tmp/foo"
& folderExists "/tmp/bar"

azubiMain :: [State] -> IO ()

The function you should use to get you commands running.

data Command

A command is something that will be run. In a normal case you put a Check before using a State

When a Command get executed, it will create a CommandResult.

 command -> exit code -> CommandResult

Constructors

Run String [Argument] (Maybe Comment)

FileContent Path [String]

CreateSymlink Path Target

CreateFolder Path

Remove Path

Instances

Eq Command

Methods

(==) :: Command -> Command -> Bool

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

Show Command

Methods

showsPrec :: Int -> Command -> ShowS

show :: Command -> String

showList :: [Command] -> ShowS

data Check

Gather information about a situation.

check -> success/failure
check -> exit code -> success/failure

Constructors

Check String [Argument] (Maybe Comment)

Check if command returns exit status

0 -> Yes
_ -> No

AlwaysYes

Not Check

Opposite result of a Check

HasFileContent Path [String]

Check if Path has content

SymlinkExists Path Target

Check if a Symbolic link exists to a specific target

FolderExists Path

Check if a folder exists

DoesExist Path

Check if something exists at path

Instances

Eq Check

Methods

(==) :: Check -> Check -> Bool

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

Show Check

Methods

showsPrec :: Int -> Check -> ShowS

show :: Check -> String

showList :: [Check] -> ShowS