Jenkins.Rest

Jenkins REST API interface

This module is intended to be imported qualified.

Query Jenkins

run :: (MonadIO m, MonadBaseControl IO m) => Master -> JenkinsT m a -> m (Either JenkinsException a)

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.

data JenkinsT m a

The value of this type describes Jenkins REST API requests sequence

Instances

MonadTrans JenkinsT

MonadError e m => MonadError e (JenkinsT m)

MonadReader r m => MonadReader r (JenkinsT m)

MonadState s m => MonadState s (JenkinsT m)

MonadWriter w m => MonadWriter w (JenkinsT m)

Monad (JenkinsT m)

Functor (JenkinsT m)

Applicative (JenkinsT m)

MonadIO m => MonadIO (JenkinsT m)

type Jenkins = JenkinsT IO

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

data Master

Jenkins master node connection settings token

Constructors

Master

Fields

url :: String

Jenkins URL

user :: Text

Jenkins user

apiToken :: Text

Jenkins user API token or password

Instances

Eq Master

Data Master

Show Master

Typeable * Master

Combinators

get :: Formatter f -> (forall g. Method Complete g) -> JenkinsT m ByteString

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

stream :: MonadResource m => Formatter f -> (forall g. Method Complete g) -> JenkinsT m (ResumableSource m ByteString)

Perform a streaming GET request

stream, unlike get, is constant-space

post :: (forall f. Method Complete f) -> ByteString -> JenkinsT m ByteString

Perform a POST request

post_ :: (forall f. Method Complete f) -> JenkinsT m ByteString

Perform a POST request without a payload

orElse :: JenkinsT m a -> (JenkinsException -> JenkinsT m a) -> JenkinsT m a

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

orElse_ :: JenkinsT m a -> JenkinsT m a -> JenkinsT m a

A simpler exception handler

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

locally :: (Request -> Request) -> JenkinsT m a -> JenkinsT m a

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

Method

module Jenkins.Rest.Method

Concurrency

concurrently :: JenkinsT m a -> JenkinsT m b -> JenkinsT m (a, b)

Run two actions concurrently

traverse :: (a -> JenkinsT m b) -> [a] -> JenkinsT m [b]

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

traverse : traverse :: concurrently : liftA2 (,)

traverse_ :: Foldable f => (a -> JenkinsT m b) -> f a -> JenkinsT m ()

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

traverse_ : traverse_ :: concurrently : liftA2 (,)

Convenience

postXml :: (forall f. Method Complete f) -> ByteString -> JenkinsT m ByteString

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

groovy

Arguments

:: Text

Groovy source code

-> JenkinsT m Text

Perform a POST request to /scriptText

reload :: JenkinsT m ()

Reload jenkins configuration from disk

Performs /reload

restart :: JenkinsT m ()

Restart jenkins safely

Performs /safeRestart

/safeRestart allows all running jobs to complete

forceRestart :: JenkinsT m ()

Restart jenkins

Performs /restart

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

newtype JenkinsException

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

Constructors

JenkinsHttpException HttpException

Instances

Show JenkinsException

Exception JenkinsException

Typeable * JenkinsException

Reexports

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

Lift a computation from the IO monad.

data Request :: *

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 parseUrl.

The constructor for this data type is not exposed. Instead, you should use either the def method to retrieve a default instance, or parseUrl 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 <- parseUrl "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

Instances

Show Request

IsString Request

Default Request

Typeable * Request