Struct gitlab_runner::Runner

pub struct Runner { /* private fields */ }

Runner for gitlab

The runner is responsible for communicating with gitlab to request new job and spawn them.

Implementations

impl Runner

pub fn new(server: Url, token: String, build_dir: PathBuf) -> Self

Create a new Runner for the given server url and runner token, storing (temporary job files) in build_dir

The build_dir is used to store temporary files during a job run. This will also configure a default tracing subscriber if that’s not wanted use Runner::new_with_layer instead.

let dir = tempfile::tempdir().unwrap();
let runner = Runner::new(Url::parse("https://gitlab.com/").unwrap(),
    "RunnerToken".to_string(),
    dir.path().to_path_buf());

Panics

Panics if a default subscriber is already setup

pub fn new_with_layer(
    server: Url,
    token: String,
    build_dir: PathBuf
) -> (Self, GitlabLayer)

Creates a new runner as per Runner::new and logging layer

The logging layer should attached to the current tracing subscriber while further runner calls are made otherwise job logging to gitlab will not work

let dir = tempfile::tempdir().unwrap();
let (runner, layer) = Runner::new_with_layer(Url::parse("https://gitlab.com/").unwrap(),
    "RunnerToken".to_string(),
    dir.path().to_path_buf());
let subscriber = Registry::default().with(layer).init();

pub fn running(&self) -> usize

The number of jobs currently running

pub async fn request_job<F, J, Ret>(
    &mut self,
    process: F
) -> Result<bool, Error> where
    F: FnOnce(Job) -> Ret + Sync + Send + 'static,
    J: JobHandler + Send + 'static,
    Ret: Future<Output = Result<J, ()>> + Send + 'static, 

Try to request a single job from gitlab

This does a single poll of gitlab for a new job. If a new job received a new asynchronous task is spawned for processing the job. The passed process function is called to create a the actual job handler. Returns whether or not a job was received or an error if polling gitlab failed.

Note that this function is not cancel save. If the future gets cancelled gitlab might have provided a job for which processing didn’t start yet.

pub async fn wait_for_space(&mut self, max: usize)

Wait untill there are less then max jobs running

pub async fn drain(&mut self)

Wait untill there are no more jobs running

pub async fn run<F, J, Ret>(
    &mut self,
    process: F,
    maximum: usize
) -> Result<(), Error> where
    F: Fn(Job) -> Ret + Sync + Send + 'static + Clone,
    J: JobHandler + Send + 'static,
    Ret: Future<Output = Result<J, ()>> + Send + 'static, 

Run continously, processing at most maximum jobs concurrently

This essentially calls Runner::request_job requesting jobs until at most maximum jobs are running in parallel.

Trait Implementations

impl Debug for Runner

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.