Struct git2::RemoteCallbacks

pub struct RemoteCallbacks<'a> { /* private fields */ }

A structure to contain the callbacks which are invoked when a repository is being updated or downloaded.

These callbacks are used to manage facilities such as authentication, transfer progress, etc.

Implementations

impl<'a> RemoteCallbacks<'a>

pub fn new() -> RemoteCallbacks<'a>

Creates a new set of empty callbacks

pub fn credentials<F>(&mut self, cb: F) -> &mut RemoteCallbacks<'a>

where F: FnMut(&str, Option<&str>, CredentialType) -> Result<Cred, Error> + 'a,

The callback through which to fetch credentials if required.

Example

Prepare a callback to authenticate using the $HOME/.ssh/id_rsa SSH key, and extracting the username from the URL (i.e. git@github.com:rust-lang/git2-rs.git):

use git2::{Cred, RemoteCallbacks};
use std::env;

let mut callbacks = RemoteCallbacks::new();
callbacks.credentials(|_url, username_from_url, _allowed_types| {
  Cred::ssh_key(
    username_from_url.unwrap(),
    None,
    std::path::Path::new(&format!("{}/.ssh/id_rsa", env::var("HOME").unwrap())),
    None,
  )
});

pub fn transfer_progress<F>(&mut self, cb: F) -> &mut RemoteCallbacks<'a>

where F: FnMut(Progress<'_>) -> bool + 'a,

The callback through which progress is monitored.

pub fn sideband_progress<F>(&mut self, cb: F) -> &mut RemoteCallbacks<'a>

where F: FnMut(&[u8]) -> bool + 'a,

Textual progress from the remote.

Text sent over the progress side-band will be passed to this function (this is the ‘counting objects’ output).

pub fn update_tips<F>(&mut self, cb: F) -> &mut RemoteCallbacks<'a>

where F: FnMut(&str, Oid, Oid) -> bool + 'a,

Each time a reference is updated locally, the callback will be called with information about it.

pub fn certificate_check<F>(&mut self, cb: F) -> &mut RemoteCallbacks<'a>

where F: FnMut(&Cert<'_>, &str) -> Result<CertificateCheckStatus, Error> + 'a,

If certificate verification fails, then this callback will be invoked to let the caller make the final decision of whether to allow the connection to proceed.

pub fn push_update_reference<F>(&mut self, cb: F) -> &mut RemoteCallbacks<'a>

where F: FnMut(&str, Option<&str>) -> Result<(), Error> + 'a,

Set a callback to get invoked for each updated reference on a push.

The first argument to the callback is the name of the reference and the second is a status message sent by the server. If the status is Some then the push was rejected.

pub fn push_transfer_progress<F>(&mut self, cb: F) -> &mut RemoteCallbacks<'a>

where F: FnMut(usize, usize, usize) + 'a,

The callback through which progress of push transfer is monitored

pub fn pack_progress<F>(&mut self, cb: F) -> &mut RemoteCallbacks<'a>

where F: FnMut(PackBuilderStage, usize, usize) + 'a,

Function to call with progress information during pack building. Be aware that this is called inline with pack building operations, so performance may be affected.

pub fn push_negotiation<F>(&mut self, cb: F) -> &mut RemoteCallbacks<'a>

where F: FnMut(&[PushUpdate<'_>]) -> Result<(), Error> + 'a,

The callback is called once between the negotiation step and the upload. It provides information about what updates will be performed.

Trait Implementations

impl<'a> Default for RemoteCallbacks<'a>

fn default() -> Self

Returns the “default value” for a type.