Struct git_transport::client::http::Transport

pub struct Transport<H: Http> { /* private fields */ }

Available on crate features blocking-client and http-client only.

A transport for supporting arbitrary http clients by abstracting interactions with them into the Http trait.

Implementations

impl<H: Http> Transport<H>

pub fn new_http(http: H, url: &str, desired_version: Protocol) -> Self

Create a new instance with http as implementation to communicate to url using the given desired_version of the git protocol.

impl Transport<Impl>

pub fn new(url: &str, desired_version: Protocol) -> Self

Available on crate features http-client-curl or http-client-reqwest only.

Create a new instance to communicate to url using the given desired_version of the git protocol.

Note that the actual implementation depends on feature toggles.

Trait Implementations

impl<H: Http> Transport for Transport<H>

fn handshake<'a>(
    &mut self,
    service: Service,
    extra_parameters: &'a [(&'a str, Option<&'a str>)]
) -> Result<SetServiceResponse<'_>, Error>

Initiate connection to the given service and send the given extra_parameters along with it.

impl<H: Http> TransportWithoutIO for Transport<H>

fn set_identity(&mut self, identity: Account) -> Result<(), Error>

If the handshake or subsequent reads failed with std::io::ErrorKind::PermissionDenied, use this method to inform the transport layer about the identity to use for subsequent calls. If authentication continues to fail even with an identity set, consider communicating this to the provider of the identity in order to mark it as invalid. Otherwise the user might have difficulty updating obsolete credentials. Please note that most transport layers are unauthenticated and thus return an error here.

fn request(
    &mut self,
    write_mode: WriteMode,
    on_into_read: MessageKind
) -> Result<RequestWriter<'_>, Error>

Available on crate features blocking-client or async-client only.

Get a writer for sending data and obtaining the response. It can be configured in various ways to support the task at hand. write_mode determines how calls to the write(…) method are interpreted, and on_into_read determines which message to write when the writer is turned into the response reader using into_read().

fn to_url(&self) -> String

Returns the canonical URL pointing to the destination of this transport. Please note that local paths may not be represented correctly, as they will go through a potentially lossy unicode conversion.

fn supported_protocol_versions(&self) -> &[Protocol]

If the actually advertised server version is contained in the returned slice or empty, continue as normal, assume the server’s protocol version is desired or acceptable.

fn connection_persists_across_multiple_requests(&self) -> bool

Returns true if the transport provides persistent connections across multiple requests, or false otherwise. Not being persistent implies that certain information has to be resent on each ‘turn’ of the fetch negotiation or that the end of interaction (i.e. no further request will be made) has to be indicated to the server for most graceful termination of the connection.

fn configure(
    &mut self,
    config: &dyn Any
) -> Result<(), Box<dyn Error + Send + Sync + 'static>>

Pass config can be cast and interpreted by the implementation, as documented separately.