Jenkins.Rest

Jenkins REST API interface

Query Jenkins

runJenkins :: ConnectInfo -> Jenkins a -> IO (Result HttpException a)

Query Jenkins API using Jenkins description

Successful result is either Disconnect or Result v

If HttpException was thrown by http-conduit, runJenkins catches it and wraps in Error. Other exceptions are not catched

data ConnectInfo

Jenkins connection settings

_jenkinsApiToken may be user's password, Jenkins does not make any distinction between these concepts

Constructors

ConnectInfo

Fields

_jenkinsUrl :: String

Jenkins URL, e.g. http://example.com/jenkins

_jenkinsPort :: Int

Jenkins port, e.g. 8080

_jenkinsUser :: Text

Jenkins user, e.g. jenkins

_jenkinsApiToken :: Text

Jenkins user API token

Instances

Eq ConnectInfo

Data ConnectInfo

Show ConnectInfo

Typeable ConnectInfo

Generic ConnectInfo

defaultConnectInfo :: ConnectInfo

Default Jenkins connection settings

 defaultConnectInfo = ConnectInfo
   { _jenkinsUrl      = "http://example.com/jenkins"
   , _jenkinsPort     = 8080
   , _jenkinsUser     = "jenkins"
   , _jenkinsApiToken = ""
   }

data Jenkins a

Jenkins REST API query sequence description

Instances

Monad Jenkins

Functor Jenkins

Applicative Jenkins

MonadIO Jenkins

data Result e v

The result of Jenkins REST API queries

Constructors

Error e

Exception e was thrown while querying

Disconnect

The client was explicitly disconnected

Result v

Querying successfully finished the with value v

Instances

Typeable2 Result

(Eq e, Eq v) => Eq (Result e v)

(Data e, Data v) => Data (Result e v)

(Ord e, Ord v) => Ord (Result e v)

(Show e, Show v) => Show (Result e v)

Generic (Result e v)

Combinators

get :: Method Complete f -> Jenkins ByteString

GET query

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

POST query (with a payload)

post_ :: (forall f. Method Complete f) -> Jenkins ()

POST query (without payload)

concurrently :: Jenkins a -> Jenkins b -> Jenkins (a, b)

Do both queries concurrently

io :: IO a -> Jenkins a

Lift arbitrary IO action

disconnect :: Jenkins a

Disconnect from Jenkins

Any following queries won't be executed

with :: (Request -> Request) -> Jenkins a -> Jenkins a

Make local changes to the Request

Method

module Jenkins.Rest.Method

Convenience

postXML :: (forall f. Method Complete f) -> Document -> Jenkins ()

POST job's config.xml (or any other xml, really) in xml-conduit format

concurrentlys :: Foldable f => f (Jenkins a) -> Jenkins [a]

Send a list of queries concurrently

concurrentlys_ :: Foldable f => f (Jenkins a) -> Jenkins ()

Send a list of queries concurrently ignoring their results

Note: exceptions are still raised

reload :: Jenkins a

Reload jenkins configuration from disk

Calls /reload and disconnects

restart :: Jenkins a

Restart jenkins safely

Calls /safeRestart and disconnects

/safeRestart allows all running jobs to complete

forceRestart :: Jenkins a

Force jenkins to restart without waiting for running jobs to finish

Calls /restart and disconnects

Lensy things

jenkinsUrl :: Lens' ConnectInfo String

A lens into Jenkins URL

jenkinsPort :: Lens' ConnectInfo Int

A lens into Jenkins port

jenkinsUser :: Lens' ConnectInfo Text

A lens into Jenkins user

jenkinsApiToken :: Lens' ConnectInfo Text

A lens into Jenkins user API token

jenkinsPassword :: Lens' ConnectInfo Text

A lens into Jenkins password

 jenkinsPassword = jenkinsApiToken

_Error :: Prism (Result e a) (Result e' a) e e'

A prism into Jenkins error

_Disconnect :: Prism' (Result e a) ()

A prism into disconnect

_Result :: Prism (Result e a) (Result e b) a b

A prism into result

Type reexports

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

data HttpException

Instances

Show HttpException

Typeable HttpException

Exception HttpException

AsHttpException HttpException