History

[git-protocol] refactor

Sebastian Thiel committed 5 years ago

Commit 0b4ff161 parent e99a03b3 files · +101 −106Browse files

Showing the changes to git-protocol/src (3 of 3 files). Show all

Unified · Split

3 files
  1. git-protocol/src/fetch/arguments/async_io.rs +50 −0
  2. git-protocol/src/fetch/arguments/blocking_io.rs +48 −0
  3. git-protocol/src/fetch/arguments/mod.rs +3 −106
git-protocol/src/fetch/arguments/async_io.rs+50−0
@@ -0,0 +1,50 @@
1+use crate::fetch::{Arguments, Command};
2+use futures_lite::io::AsyncWriteExt;
3+use git_transport::{client, client::TransportV2Ext};
4+
5+impl Arguments {
6+ pub(crate) async fn send<'a, T: client::Transport + Send + 'a>(
7+ &mut self,
8+ transport: &'a mut T,
9+ add_done_argument: bool,
10+ ) -> Result<Box<dyn client::ExtendedBufRead + Unpin + 'a>, client::Error> {
11+ if self.haves.is_empty() {
12+ assert!(add_done_argument, "If there are no haves, is_done must be true.");
13+ }
14+ match self.version {
15+ git_transport::Protocol::V1 => {
16+ let (on_into_read, retained_state) = self.send_shared_v1(transport.is_stateful(), add_done_argument)?;
17+ let mut line_writer =
18+ transport.request(client::WriteMode::OneLfTerminatedLinePerWriteCall, on_into_read)?;
19+ let had_args = !self.args.is_empty();
20+ for arg in self.args.drain(..) {
21+ line_writer.write_all(&arg).await?;
22+ }
23+ if had_args {
24+ line_writer.write_message(client::MessageKind::Flush).await?;
25+ }
26+ for line in self.haves.drain(..) {
27+ line_writer.write_all(&line).await?;
28+ }
29+ if let Some(next_args) = retained_state {
30+ self.args = next_args;
31+ }
32+ Ok(line_writer.into_read().await?)
33+ }
34+ git_transport::Protocol::V2 => {
35+ let retained_state = self.args.clone();
36+ self.args.extend(self.haves.drain(..));
37+ if add_done_argument {
38+ self.args.push("done".into());
39+ }
40+ transport
41+ .invoke(
42+ Command::Fetch.as_str(),
43+ self.features.iter().filter(|(_, v)| v.is_some()).cloned(),
44+ Some(std::mem::replace(&mut self.args, retained_state).into_iter()),
45+ )
46+ .await
47+ }
48+ }
49+ }
50+}
git-protocol/src/fetch/arguments/blocking_io.rs+48−0
@@ -0,0 +1,48 @@
1+use crate::fetch::{Arguments, Command};
2+use git_transport::{client, client::TransportV2Ext};
3+use std::io::Write;
4+
5+impl Arguments {
6+ pub(crate) fn send<'a, T: client::Transport + 'a>(
7+ &mut self,
8+ transport: &'a mut T,
9+ add_done_argument: bool,
10+ ) -> Result<Box<dyn client::ExtendedBufRead + 'a>, client::Error> {
11+ if self.haves.is_empty() {
12+ assert!(add_done_argument, "If there are no haves, is_done must be true.");
13+ }
14+ match self.version {
15+ git_transport::Protocol::V1 => {
16+ let (on_into_read, retained_state) = self.send_shared_v1(transport.is_stateful(), add_done_argument)?;
17+ let mut line_writer =
18+ transport.request(client::WriteMode::OneLfTerminatedLinePerWriteCall, on_into_read)?;
19+ let had_args = !self.args.is_empty();
20+ for arg in self.args.drain(..) {
21+ line_writer.write_all(&arg)?;
22+ }
23+ if had_args {
24+ line_writer.write_message(client::MessageKind::Flush)?;
25+ }
26+ for line in self.haves.drain(..) {
27+ line_writer.write_all(&line)?;
28+ }
29+ if let Some(next_args) = retained_state {
30+ self.args = next_args;
31+ }
32+ Ok(line_writer.into_read()?)
33+ }
34+ git_transport::Protocol::V2 => {
35+ let retained_state = self.args.clone();
36+ self.args.extend(self.haves.drain(..));
37+ if add_done_argument {
38+ self.args.push("done".into());
39+ }
40+ transport.invoke(
41+ Command::Fetch.as_str(),
42+ self.features.iter().filter(|(_, v)| v.is_some()).cloned(),
43+ Some(std::mem::replace(&mut self.args, retained_state).into_iter()),
44+ )
45+ }
46+ }
47+ }
48+}
git-protocol/src/fetch/arguments/mod.rsrenamed from git-protocol/src/fetch/arguments.rs+3−106
@@ -151,8 +151,7 @@ impl Arguments { · 150 unmodified lines
151151 mod shared {
152152 use crate::fetch::Arguments;
153153 use bstr::{BString, ByteSlice};
154− use git_transport::client;
155− use git_transport::client::MessageKind;
154+ use git_transport::{client, client::MessageKind};
156155
157156 impl Arguments {
158157 pub(in crate::fetch::arguments) fn send_shared_v1(
@@ -183,109 +182,7 @@ mod shared { · 24 unmodified lines
183182 }
184183
185184 #[cfg(all(not(feature = "blocking-client"), feature = "async-client"))]
186−mod async_io {
187− use crate::fetch::{Arguments, Command};
188− use futures_lite::io::AsyncWriteExt;
189− use git_transport::{client, client::TransportV2Ext};
190−
191− impl Arguments {
192− pub(crate) async fn send<'a, T: client::Transport + Send + 'a>(
193− &mut self,
194− transport: &'a mut T,
195− add_done_argument: bool,
196− ) -> Result<Box<dyn client::ExtendedBufRead + Unpin + 'a>, client::Error> {
197− if self.haves.is_empty() {
198− assert!(add_done_argument, "If there are no haves, is_done must be true.");
199− }
200− match self.version {
201− git_transport::Protocol::V1 => {
202− let (on_into_read, retained_state) =
203− self.send_shared_v1(transport.is_stateful(), add_done_argument)?;
204− let mut line_writer =
205− transport.request(client::WriteMode::OneLfTerminatedLinePerWriteCall, on_into_read)?;
206− let had_args = !self.args.is_empty();
207− for arg in self.args.drain(..) {
208− line_writer.write_all(&arg).await?;
209− }
210− if had_args {
211− line_writer.write_message(client::MessageKind::Flush).await?;
212− }
213− for line in self.haves.drain(..) {
214− line_writer.write_all(&line).await?;
215− }
216− if let Some(next_args) = retained_state {
217− self.args = next_args;
218− }
219− Ok(line_writer.into_read().await?)
220− }
221− git_transport::Protocol::V2 => {
222− let retained_state = self.args.clone();
223− self.args.extend(self.haves.drain(..));
224− if add_done_argument {
225− self.args.push("done".into());
226− }
227− transport
228− .invoke(
229− Command::Fetch.as_str(),
230− self.features.iter().filter(|(_, v)| v.is_some()).cloned(),
231− Some(std::mem::replace(&mut self.args, retained_state).into_iter()),
232− )
233− .await
234− }
235− }
236− }
237− }
238−}
185+mod async_io;
239186
240187 #[cfg(feature = "blocking-client")]
241−mod blocking_io {
242− use crate::fetch::{Arguments, Command};
243− use git_transport::{client, client::TransportV2Ext};
244− use std::io::Write;
245−
246− impl Arguments {
247− pub(crate) fn send<'a, T: client::Transport + 'a>(
248− &mut self,
249− transport: &'a mut T,
250− add_done_argument: bool,
251− ) -> Result<Box<dyn client::ExtendedBufRead + 'a>, client::Error> {
252− if self.haves.is_empty() {
253− assert!(add_done_argument, "If there are no haves, is_done must be true.");
254− }
255− match self.version {
256− git_transport::Protocol::V1 => {
257− let (on_into_read, retained_state) =
258− self.send_shared_v1(transport.is_stateful(), add_done_argument)?;
259− let mut line_writer =
260− transport.request(client::WriteMode::OneLfTerminatedLinePerWriteCall, on_into_read)?;
261− let had_args = !self.args.is_empty();
262− for arg in self.args.drain(..) {
263− line_writer.write_all(&arg)?;
264− }
265− if had_args {
266− line_writer.write_message(client::MessageKind::Flush)?;
267− }
268− for line in self.haves.drain(..) {
269− line_writer.write_all(&line)?;
270− }
271− if let Some(next_args) = retained_state {
272− self.args = next_args;
273− }
274− Ok(line_writer.into_read()?)
275− }
276− git_transport::Protocol::V2 => {
277− let retained_state = self.args.clone();
278− self.args.extend(self.haves.drain(..));
279− if add_done_argument {
280− self.args.push("done".into());
281− }
282− transport.invoke(
283− Command::Fetch.as_str(),
284− self.features.iter().filter(|(_, v)| v.is_some()).cloned(),
285− Some(std::mem::replace(&mut self.args, retained_state).into_iter()),
286− )
287− }
288− }
289− }
290− }
291−}
188+mod blocking_io;

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t