gix_protocol/fetch/arguments/mod.rs
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 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292
use std::fmt;
use bstr::{BStr, BString, ByteSlice, ByteVec};
/// The arguments passed to a server command.
#[derive(Debug)]
pub struct Arguments {
/// The active features/capabilities of the fetch invocation
#[cfg(any(feature = "async-client", feature = "blocking-client"))]
features: Vec<crate::command::Feature>,
args: Vec<BString>,
haves: Vec<BString>,
filter: bool,
shallow: bool,
deepen_since: bool,
deepen_not: bool,
deepen_relative: bool,
ref_in_want: bool,
supports_include_tag: bool,
features_for_first_want: Option<Vec<String>>,
#[cfg(any(feature = "async-client", feature = "blocking-client"))]
version: gix_transport::Protocol,
trace: bool,
}
impl Arguments {
/// Return true if there is no argument at all.
///
/// This can happen if callers assure that they won't add 'wants' if their 'have' is the same, i.e. if the remote has nothing
/// new for them.
pub fn is_empty(&self) -> bool {
self.haves.is_empty() && !self.args.iter().rev().any(|arg| arg.starts_with_str("want "))
}
/// Return true if ref filters is supported.
pub fn can_use_filter(&self) -> bool {
self.filter
}
/// Return true if shallow refs are supported.
///
/// This is relevant for partial clones when using `--depth X`.
pub fn can_use_shallow(&self) -> bool {
self.shallow
}
/// Return true if the 'deepen' capability is supported.
///
/// This is relevant for partial clones when using `--depth X` and retrieving additional history.
pub fn can_use_deepen(&self) -> bool {
self.shallow
}
/// Return true if the '`deepen_since`' capability is supported.
///
/// This is relevant for partial clones when using `--depth X` and retrieving additional history
/// based on a date beyond which all history should be present.
pub fn can_use_deepen_since(&self) -> bool {
self.deepen_since
}
/// Return true if the '`deepen_not`' capability is supported.
///
/// This is relevant for partial clones when using `--depth X`.
pub fn can_use_deepen_not(&self) -> bool {
self.deepen_not
}
/// Return true if the '`deepen_relative`' capability is supported.
///
/// This is relevant for partial clones when using `--depth X`.
pub fn can_use_deepen_relative(&self) -> bool {
self.deepen_relative
}
/// Return true if the 'ref-in-want' capability is supported.
///
/// This can be used to bypass 'ls-refs' entirely in protocol v2.
pub fn can_use_ref_in_want(&self) -> bool {
self.ref_in_want
}
/// Return true if the 'include-tag' capability is supported.
pub fn can_use_include_tag(&self) -> bool {
self.supports_include_tag
}
/// Return true if we will use a stateless mode of operation, which can be decided in conjunction with `transport_is_stateless`.
///
/// * we are always stateless if the transport is stateless, i.e. doesn't support multiple interactions with a single connection.
/// * we are always stateless if the protocol version is `2`
/// * otherwise we may be stateful.
pub fn is_stateless(&self, transport_is_stateless: bool) -> bool {
#[cfg(any(feature = "async-client", feature = "blocking-client"))]
let res = transport_is_stateless || self.version == gix_transport::Protocol::V2;
#[cfg(not(any(feature = "async-client", feature = "blocking-client")))]
let res = transport_is_stateless;
res
}
/// Add the given `id` pointing to a commit to the 'want' list.
///
/// As such it should be included in the server response as it's not present on the client.
pub fn want(&mut self, id: impl AsRef<gix_hash::oid>) {
match self.features_for_first_want.take() {
Some(features) => self.prefixed("want ", format!("{} {}", id.as_ref(), features.join(" "))),
None => self.prefixed("want ", id.as_ref()),
}
}
/// Add the given ref to the 'want-ref' list.
///
/// The server should respond with a corresponding 'wanted-refs' section if it will include the
/// wanted ref in the packfile response.
pub fn want_ref(&mut self, ref_path: &BStr) {
let mut arg = BString::from("want-ref ");
arg.push_str(ref_path);
self.args.push(arg);
}
/// Add the given `id` pointing to a commit to the 'have' list.
///
/// As such it should _not_ be included in the server response as it's already present on the client.
pub fn have(&mut self, id: impl AsRef<gix_hash::oid>) {
self.haves.push(format!("have {}", id.as_ref()).into());
}
/// Add the given `id` pointing to a commit to the 'shallow' list.
pub fn shallow(&mut self, id: impl AsRef<gix_hash::oid>) {
debug_assert!(self.shallow, "'shallow' feature required for 'shallow <id>'");
if self.shallow {
self.prefixed("shallow ", id.as_ref());
}
}
/// Deepen the commit history by `depth` amount of commits.
pub fn deepen(&mut self, depth: usize) {
debug_assert!(self.shallow, "'shallow' feature required for deepen");
if self.shallow {
self.prefixed("deepen ", depth);
}
}
/// Deepen the commit history to include all commits from now to (and including) `seconds` as passed since UNIX epoch.
pub fn deepen_since(&mut self, seconds: gix_date::SecondsSinceUnixEpoch) {
debug_assert!(self.deepen_since, "'deepen-since' feature required");
if self.deepen_since {
self.prefixed("deepen-since ", seconds);
}
}
/// Deepen the commit history in a relative instead of absolute fashion.
pub fn deepen_relative(&mut self) {
debug_assert!(self.deepen_relative, "'deepen-relative' feature required");
if self.deepen_relative {
self.args.push("deepen-relative".into());
}
}
/// Do not include commits reachable by the given `ref_path` when deepening the history.
pub fn deepen_not(&mut self, ref_path: &BStr) {
debug_assert!(self.deepen_not, "'deepen-not' feature required");
if self.deepen_not {
let mut line = BString::from("deepen-not ");
line.extend_from_slice(ref_path);
self.args.push(line);
}
}
/// Set the given filter `spec` when listing references.
pub fn filter(&mut self, spec: &str) {
debug_assert!(self.filter, "'filter' feature required");
if self.filter {
self.prefixed("filter ", spec);
}
}
/// Permanently allow the server to include tags that point to commits or objects it would return.
///
/// Needs to only be called once.
pub fn use_include_tag(&mut self) {
debug_assert!(self.supports_include_tag, "'include-tag' feature required");
if self.supports_include_tag {
self.add_feature("include-tag");
}
}
/// Add the given `feature`, unconditionally.
///
/// Note that sending an unknown or unsupported feature may cause the remote to terminate
/// the connection. Use this method if you know what you are doing *and* there is no specialized
/// method for this, e.g. [`Self::use_include_tag()`].
pub fn add_feature(&mut self, feature: &str) {
match self.version {
gix_transport::Protocol::V0 | gix_transport::Protocol::V1 => {
let features = self
.features_for_first_want
.as_mut()
.expect("call add_feature before first want()");
features.push(feature.into());
}
gix_transport::Protocol::V2 => {
self.args.push(feature.into());
}
}
}
fn prefixed(&mut self, prefix: &str, value: impl fmt::Display) {
self.args.push(format!("{prefix}{value}").into());
}
/// Create a new instance to help setting up arguments to send to the server as part of a `fetch` operation
/// for which `features` are the available and configured features to use.
/// If `trace` is `true`, all packetlines received or sent will be passed to the facilities of the `gix-trace` crate.
#[cfg(any(feature = "async-client", feature = "blocking-client"))]
pub fn new(version: gix_transport::Protocol, features: Vec<crate::command::Feature>, trace: bool) -> Self {
use crate::Command;
let has = |name: &str| features.iter().any(|f| f.0 == name);
let filter = has("filter");
let shallow = has("shallow");
let ref_in_want = has("ref-in-want");
let mut deepen_since = shallow;
let mut deepen_not = shallow;
let mut deepen_relative = shallow;
let supports_include_tag;
let (initial_arguments, features_for_first_want) = match version {
gix_transport::Protocol::V0 | gix_transport::Protocol::V1 => {
deepen_since = has("deepen-since");
deepen_not = has("deepen-not");
deepen_relative = has("deepen-relative");
supports_include_tag = has("include-tag");
let baked_features = features
.iter()
.filter(
|(f, _)| *f != "include-tag", /* not a capability in that sense, needs to be turned on by caller later */
)
.map(|(n, v)| match v {
Some(v) => format!("{n}={v}"),
None => n.to_string(),
})
.collect::<Vec<_>>();
(Vec::new(), Some(baked_features))
}
gix_transport::Protocol::V2 => {
supports_include_tag = true;
(Command::Fetch.initial_arguments(&features), None)
}
};
Arguments {
features,
version,
args: initial_arguments,
haves: Vec::new(),
filter,
shallow,
supports_include_tag,
deepen_not,
deepen_relative,
ref_in_want,
deepen_since,
features_for_first_want,
trace,
}
}
}
#[cfg(any(feature = "blocking-client", feature = "async-client"))]
mod shared {
use bstr::{BString, ByteSlice};
use gix_transport::{client, client::MessageKind};
use crate::fetch::Arguments;
impl Arguments {
pub(in crate::fetch::arguments) fn prepare_v1(
&mut self,
transport_is_stateful: bool,
add_done_argument: bool,
) -> Result<(MessageKind, Option<Vec<BString>>), client::Error> {
if self.haves.is_empty() {
assert!(add_done_argument, "If there are no haves, is_done must be true.");
}
let on_into_read = if add_done_argument {
client::MessageKind::Text(&b"done"[..])
} else {
client::MessageKind::Flush
};
let retained_state = if transport_is_stateful {
None
} else {
Some(self.args.clone())
};
if let Some(first_arg_position) = self.args.iter().position(|l| l.starts_with_str("want ")) {
self.args.swap(first_arg_position, 0);
}
Ok((on_into_read, retained_state))
}
}
}
#[cfg(feature = "async-client")]
mod async_io;
#[cfg(feature = "blocking-client")]
mod blocking_io;