1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110

extern crate failure;
extern crate regex;

extern crate jenkins_api;

use regex::Regex;

#[derive(Clone)]
pub struct JenkinsInformation {
    pub url: String,
    pub user: Option<String>,
    pub password: Option<String>,
    pub depth: u8,
}

fn build_jenkins_client(
    jenkins_info: &JenkinsInformation,
) -> Result<jenkins_api::Jenkins, failure::Error> {
    let mut jenkins_builder = jenkins_api::JenkinsBuilder::new(&jenkins_info.url);
    jenkins_builder = match (&jenkins_info.user, &jenkins_info.password) {
        (Some(ref user), None) => jenkins_builder.with_user(user, None),
        (Some(ref user), Some(ref password)) => jenkins_builder.with_user(user, Some(password)),
        (_, _) => jenkins_builder,
    };
    Ok(jenkins_builder.with_depth(jenkins_info.depth).build()?)
}

pub fn search_job(
    jenkins_info: &JenkinsInformation,
    pattern: &str,
) -> Result<impl Iterator<Item = jenkins_api::job::ShortJob>, failure::Error> {
    let jenkins = build_jenkins_client(jenkins_info)?;

    let re = Regex::new(pattern).unwrap();

    Ok(jenkins
        .get_home()?
        .jobs
        .into_iter()
        .filter(move |job| re.is_match(&job.name)))
}

pub fn get_job(
    jenkins_info: &JenkinsInformation,
    name: &str,
) -> Result<jenkins_api::job::CommonJob, failure::Error> {
    let jenkins = build_jenkins_client(jenkins_info)?;

    Ok(jenkins.get_job(name)?)
}

pub fn get_build(
    jenkins_info: &JenkinsInformation,
    name: &str,
    number: Option<u32>,
) -> Result<jenkins_api::build::CommonBuild, failure::Error> {
    let jenkins = build_jenkins_client(jenkins_info)?;

    match number {
        Some(n) => Ok(jenkins.get_build(name, n)?),
        None => Ok(jenkins.get_build(name, "lastBuild")?),
    }
}

pub fn list_views(
    jenkins_info: &JenkinsInformation,
    pattern: Option<String>,
) -> Result<impl Iterator<Item = jenkins_api::view::ShortView>, failure::Error> {
    let jenkins = build_jenkins_client(jenkins_info)?;

    let views = jenkins.get_home()?.views.into_iter();

    match pattern {
        Some(pattern) => {
            let re = Regex::new(&pattern).unwrap();
            Ok(views
                .filter(move |view| re.is_match(&view.name))
                .collect::<Vec<jenkins_api::view::ShortView>>()
                .into_iter())
        }
        None => Ok(views),
    }
}

pub fn list_jobs_of_view(
    jenkins_info: &JenkinsInformation,
    name: &str,
) -> Result<impl Iterator<Item = jenkins_api::job::ShortJob>, failure::Error> {
    let jenkins = build_jenkins_client(jenkins_info)?;

    Ok(jenkins.get_view(name)?.jobs.into_iter())
}

pub fn trigger_job(
    jenkins_info: &JenkinsInformation,
    name: &str,
) -> Result<jenkins_api::queue::ShortQueueItem, failure::Error> {
    let jenkins = build_jenkins_client(jenkins_info)?;

    Ok(jenkins.build_job(name)?)
}

pub fn get_queue_item(
    jenkins_info: &JenkinsInformation,
    queue_item: &jenkins_api::queue::ShortQueueItem,
) -> Result<jenkins_api::queue::QueueItem, failure::Error> {
    let jenkins = build_jenkins_client(jenkins_info)?;

    Ok(queue_item.get_full_queue_item(&jenkins)?)
}