Run a JenkinsT action

If a JenkinsException is thrown by performing a request to Jenkins, runJenkins will catch and wrap it in Exception. Other exceptions will propagate further untouched.

The value of this type describes Jenkins REST API requests sequence

A handy type synonym for the kind of JenkinsT actions that's used the most

Jenkins master node connection settings token

Perform a GET request

While the return type is lazy Bytestring, the entire response sits in memory anyway: lazy I/O is not used at the least

Perform a streaming GET request

stream, unlike get, is constant-space

Perform a POST request

Perform a POST request without a payload

A simple exception handler. If an exception is raised while the action is executed the handler is executed with it as an argument

A simpler exception handler

orElse_ a b = orElse a (\_ -> b)

locally f x modifies the base Request with f for the execution of x (think local)

This is useful for setting the appropriate headers, response timeouts and the like

Run two actions concurrently

Map every list element to an action, run them concurrently and collect the results

traverse : traverse :: concurrently : liftA2 (,)

Map every list element to an action and run them concurrently ignoring the results

traverse_ : traverse_ :: concurrently : liftA2 (,)

Perform a POST request to Jenkins with the XML document

Sets up the correct Content-Type header. Mostly useful for updating config.xml files for jobs, views, etc

Perform a POST request to /scriptText

Reload jenkins configuration from disk

Performs /reload

Restart jenkins safely

Performs /safeRestart

/safeRestart allows all running jobs to complete

Restart jenkins

Performs /restart

/restart restart Jenkins immediately, without waiting for the completion of the building and/or waiting jobs

The kind of exceptions that can be thrown by performing requests to the Jenkins REST API

Lift a computation from the IO monad. This allows us to run IO computations in any monadic stack, so long as it supports these kinds of operations (i.e. IO is the base monad for the stack).

Example

import Control.Monad.Trans.State -- from the "transformers" library

printState :: Show s => StateT s IO ()
printState = do
  state <- get
  liftIO $ print state

• Couldn't match type ‘IO’ with ‘StateT s IO’
 Expected type: StateT s IO ()
   Actual type: IO ()

> evalStateT printState "hello"
"hello"

> evalStateT printState 3
3

All information on how to connect to a host and what should be sent in the HTTP request.

If you simply wish to download from a URL, see parseRequest.

The constructor for this data type is not exposed. Instead, you should use either the defaultRequest value, or parseRequest to construct from a URL, and then use the records below to make modifications. This approach allows http-client to add configuration options without breaking backwards compatibility.

For example, to construct a POST request, you could do something like:

initReq <- parseRequest "http://www.example.com/path"
let req = initReq
            { method = "POST"
            }

For more information, please see http://www.yesodweb.com/book/settings-types.

Since 0.1.0