use crate::fastcdc::FASTCDC_MIN_SIZE;
use crate::format::{
check_name, ChunkRef, Chunking, Entry, FileList, FolderBranch, Kind, OpenFile, OpenFolder,
Record, Target, LIST_ITEM_BYTES, MAX_CARRIED_NODES, MAX_ENTRY_BYTES, MAX_FOLDER_DEPTH,
MAX_NAME_BYTES, MAX_RECORD_BYTES,
};
use crate::hash::{Hash, Root};
use crate::intake::{Arrived, ChunkFrames, Intake, Summary, TakingIn};
use crate::read::{file_of, folder_of, record_of};
use crate::store::{check_chunk, damaged, lent, ChunksAhead, Store, Stored};
use crate::wire::{
file_branch_frame, file_list_frame, folder_branch_frame, folder_list_frame, have_frame,
read_next, refused_frame, write_end, write_frame, write_framed, Frame, HaveMap, Next, Refusal,
Request, BUNDLE_MAGIC, FRAME_CHUNK, FRAME_FILE_LIST, FRAME_FOLDER_LIST, FRAME_REFUSED,
MAX_REQUEST_BYTES,
};
use crate::{Error, Result};
use std::collections::HashSet;
use std::io::{Read, Write};
use std::sync::{Arc, Mutex, TryLockError};
const REQUESTS_PER_ROUND: usize = 64;
const MAX_BRANCH_ITEMS: u64 = 16_384;
const MAX_CHUNKS_PER_ANSWER: u64 = 256;
fn invalid(detail: &str) -> Error {
Error::InvalidData {
detail: detail.to_owned(),
}
}
fn peer_error(detail: &str) -> Error {
Error::Peer {
detail: detail.to_owned(),
}
}
const OTHER_KIND: Error = Error::NotWanted {
what: "an answer of another kind than was asked for",
};
const TOO_MUCH: Error = Error::NotWanted {
what: "more than was asked for",
};
const BRANCH_FIXED_BYTES: usize = 23;
pub const REQUESTS_AHEAD_BYTES: usize = 2048;
fn within(limit: usize, frame: &[u8]) -> Result<()> {
if frame.len() > limit {
return Err(Error::LimitExceeded {
what: "a frame",
limit: limit as u64,
requested: frame.len() as u64,
});
}
Ok(())
}
fn folder_branch_limit(entries: u64) -> usize {
let carried = MAX_CARRIED_NODES * (42 + MAX_NAME_BYTES);
usize::try_from(entries)
.unwrap_or(usize::MAX)
.saturating_mul(MAX_ENTRY_BYTES)
.saturating_add(BRANCH_FIXED_BYTES + carried)
}
fn file_branch_limit(items: u64) -> usize {
usize::try_from(items)
.unwrap_or(usize::MAX)
.saturating_mul(LIST_ITEM_BYTES)
.saturating_add(BRANCH_FIXED_BYTES + MAX_CARRIED_NODES * 40)
}
fn most_chunks_in(chunking: Chunking, length: u64) -> u64 {
let shortest = match chunking {
Chunking::FastCdcV1 => FASTCDC_MIN_SIZE as u64 + 1,
Chunking::Fixed(chunk) => u64::from(chunk.get()),
};
length / shortest + 2
}
pub trait Peer {
fn ask(
&mut self,
request: &[u8],
limit: usize,
on_frame: &mut dyn FnMut(&[u8]) -> Result<()>,
) -> Result<()>;
fn ask_all(
&mut self,
requests: &[(Vec<u8>, usize)],
on_frame: &mut dyn FnMut(usize, &[u8]) -> Result<()>,
) -> Result<()> {
for (place, (request, limit)) in requests.iter().enumerate() {
self.ask(request, *limit, &mut |frame| on_frame(place, frame))?;
}
Ok(())
}
}
const RECENT_ITEMS: u64 = 1 << 18;
const RECENT_LISTS: usize = 64;
struct Recent<T> {
kept: Vec<(Hash, Arc<T>, u64)>,
}
impl<T> Recent<T> {
fn new() -> Self {
Self { kept: Vec::new() }
}
fn get(&mut self, hash: &Hash) -> Option<Arc<T>> {
let at = self.kept.iter().position(|(kept, _, _)| kept == hash)?;
let found = self.kept.remove(at);
let value = Arc::clone(&found.1);
self.kept.push(found);
Some(value)
}
fn keep(&mut self, hash: Hash, value: Arc<T>, items: u64, most: u64) {
self.kept.retain(|(kept, _, _)| *kept != hash);
self.kept.push((hash, value, items.max(1)));
let mut total: u64 = self.kept.iter().map(|(_, _, items)| *items).sum();
while self.kept.len() > 1 && (total > most || self.kept.len() > RECENT_LISTS) {
total -= self.kept.remove(0).2;
}
}
}
pub struct Responder<'s> {
store: &'s dyn Store,
lists: Mutex<Recent<FileList>>,
files: Mutex<Recent<OpenFile>>,
folders: Mutex<Recent<OpenFolder>>,
frame: Mutex<Vec<u8>>,
ahead: Mutex<ChunksAhead>,
threads: usize,
recent: u64,
have: bool,
}
fn lock<T>(mutex: &Mutex<T>) -> std::sync::MutexGuard<'_, T> {
mutex
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
}
fn refill(frame: &mut Vec<u8>, chunk: &[u8]) {
frame.clear();
frame.push(FRAME_CHUNK);
frame.extend_from_slice(chunk);
}
impl<'s> Responder<'s> {
pub fn new(store: &'s dyn Store) -> Self {
Self {
store,
lists: Mutex::new(Recent::new()),
files: Mutex::new(Recent::new()),
folders: Mutex::new(Recent::new()),
frame: Mutex::new(Vec::new()),
ahead: Mutex::new(ChunksAhead::new()),
threads: 0,
recent: RECENT_ITEMS,
have: true,
}
}
pub fn recent(mut self, items: u64) -> Self {
self.recent = items;
self
}
pub fn have(mut self, on: bool) -> Self {
self.have = on;
self
}
pub fn threads(mut self, threads: usize) -> Self {
self.threads = threads;
self.ahead = Mutex::new(ChunksAhead::with_threads(threads));
self
}
fn file_list(&self, file: &Hash) -> Result<Option<Arc<FileList>>> {
if let Some(list) = lock(&self.lists).get(file) {
return Ok(Some(list));
}
if let Some(open) = lock(&self.files).get(file) {
return Ok(Some(open.shared_list()));
}
let Some(bytes) = self.store.get(Stored::FileList, file)? else {
return Ok(None);
};
let list = FileList::decode(&bytes)
.ok()
.filter(|list| list.hash() == file)
.ok_or_else(|| damaged("a stored file's list", file))?;
let list = Arc::new(list);
lock(&self.lists).keep(*file, Arc::clone(&list), list.count(), self.recent);
Ok(Some(list))
}
fn open_file(&self, file: &Hash) -> Result<Option<Arc<OpenFile>>> {
if let Some(open) = lock(&self.files).get(file) {
return Ok(Some(open));
}
let listed = lock(&self.lists).get(file);
let open = match listed {
Some(list) => OpenFile::shared(list)?,
None => {
let Some(bytes) = self.store.get(Stored::FileList, file)? else {
return Ok(None);
};
OpenFile::decode(&bytes)
.ok()
.filter(|open| open.list().hash() == file)
.ok_or_else(|| damaged("a stored file's list", file))?
}
};
let open = Arc::new(open);
let items = open.list().count();
lock(&self.files).keep(*file, Arc::clone(&open), items, self.recent);
Ok(Some(open))
}
fn open_folder(&self, folder: &Hash) -> Result<Option<Arc<OpenFolder>>> {
if let Some(open) = lock(&self.folders).get(folder) {
return Ok(Some(open));
}
let Some(bytes) = self.store.get(Stored::FolderList, folder)? else {
return Ok(None);
};
let open = OpenFolder::decode(&bytes)
.ok()
.filter(|open| open.list().hash() == folder)
.ok_or_else(|| damaged("a stored folder's list", folder))?;
let open = Arc::new(open);
let items = open.list().count();
lock(&self.folders).keep(*folder, Arc::clone(&open), items, self.recent);
Ok(Some(open))
}
fn with_frame(&self, with: impl FnOnce(&mut Vec<u8>) -> Result<()>) -> Result<()> {
match self.frame.try_lock() {
Ok(mut kept) => with(&mut kept),
Err(TryLockError::Poisoned(poisoned)) => with(&mut poisoned.into_inner()),
Err(TryLockError::WouldBlock) => with(&mut Vec::new()),
}
}
fn with_ahead(&self, with: impl FnOnce(&mut ChunksAhead) -> Result<()>) -> Result<()> {
match self.ahead.try_lock() {
Ok(mut kept) => with(&mut kept),
Err(TryLockError::Poisoned(poisoned)) => with(&mut poisoned.into_inner()),
Err(TryLockError::WouldBlock) => with(&mut ChunksAhead::with_threads(self.threads)),
}
}
pub fn answer(
&self,
request: &[u8],
on_frame: &mut dyn FnMut(&[u8]) -> Result<()>,
) -> Result<()> {
let not_held = refused_frame(Refusal::NotHeld);
let out_of_range = refused_frame(Refusal::OutOfRange);
match Request::decode(request)? {
Request::Record(root) => match self.store.get(Stored::Record, root.as_hash())? {
Some(bytes) => on_frame(&bytes),
None => on_frame(¬_held),
},
Request::Folder(folder) => match self.store.get(Stored::FolderList, &folder)? {
Some(bytes) => on_frame(&folder_list_frame(&bytes)),
None => on_frame(¬_held),
},
Request::File(file) => match self.store.get(Stored::FileList, &file)? {
Some(bytes) => on_frame(&file_list_frame(&bytes)),
None => on_frame(¬_held),
},
Request::Chunk(chunk) => self.with_frame(|frame| {
let held = lent(self.store, Stored::Chunk, &chunk, &mut |bytes| {
refill(frame, bytes);
Ok(())
})?;
on_frame(if held {
frame.as_slice()
} else {
not_held.as_slice()
})
}),
Request::FolderBranch {
folder,
start,
count,
} => {
let Some(open) = self.open_folder(&folder)? else {
return on_frame(¬_held);
};
let total = open.list().count();
if total == 0 {
return on_frame(&folder_branch_frame(&FolderBranch::empty()));
}
if start >= total {
return on_frame(&out_of_range);
}
let end = total.min(start + u64::from(count).min(MAX_BRANCH_ITEMS));
on_frame(&folder_branch_frame(&open.open(start, end)?))
}
Request::FolderName { folder, name } => match self.open_folder(&folder)? {
Some(open) => on_frame(&folder_branch_frame(&open.open_name(&name)?)),
None => on_frame(¬_held),
},
Request::FileBranch { file, start, count } => {
let Some(open) = self.open_file(&file)? else {
return on_frame(¬_held);
};
let total = open.list().count();
if start >= total {
return on_frame(&out_of_range);
}
let end = total.min(start + u64::from(count).min(MAX_BRANCH_ITEMS));
on_frame(&file_branch_frame(&open.open(start, end)?))
}
Request::FileBytes {
file,
offset,
length,
} => {
let Some(open) = self.open_file(&file)? else {
return on_frame(¬_held);
};
let size = open.list().size();
if offset >= size {
return on_frame(&out_of_range);
}
let (first, after) = open.chunks_for(offset, length.min(size - offset))?;
let after = after.min(first + MAX_BRANCH_ITEMS);
on_frame(&file_branch_frame(&open.open(first, after)?))
}
Request::Chunks { file, start, count } => {
let Some(list) = self.file_list(&file)? else {
return on_frame(¬_held);
};
if start >= list.count() {
return on_frame(&out_of_range);
}
let count = u64::from(count).min(MAX_CHUNKS_PER_ANSWER) as usize;
let items = &list.items()[start as usize..];
let items = &items[..count.min(items.len())];
self.with_ahead(|ahead| {
ahead.frames(self.store, items, &mut |frame| {
on_frame(frame.unwrap_or(not_held.as_slice()))
})
})
}
Request::Have(file) => {
if !self.have {
return on_frame(¬_held);
}
let Some(list) = self.file_list(&file)? else {
return on_frame(¬_held);
};
let mut map = HaveMap::new(list.count())?;
for (number, item) in (0_u64..).zip(list.items()) {
if self.store.has(Stored::Chunk, &item.hash)? {
map.set(number)?;
}
}
on_frame(&have_frame(&map))
}
}
}
}
impl Peer for Responder<'_> {
fn ask(
&mut self,
request: &[u8],
limit: usize,
on_frame: &mut dyn FnMut(&[u8]) -> Result<()>,
) -> Result<()> {
self.answer(request, &mut |frame| {
within(limit, frame)?;
on_frame(frame)
})
}
}
fn ask_one(peer: &mut dyn Peer, request: &Request, limit: usize) -> Result<Vec<u8>> {
let mut answer: Option<Vec<u8>> = None;
peer.ask(&request.encode(), limit, &mut |frame| {
if answer.is_some() {
return Err(TOO_MUCH);
}
answer = Some(frame.to_vec());
Ok(())
})?;
let frame = answer.ok_or_else(|| peer_error("gave no answer"))?;
if frame.first() == Some(&FRAME_REFUSED) {
return Err(match Frame::decode(&frame)? {
Frame::Refused(Refusal::OutOfRange) => {
peer_error("says that what was asked for lies outside the list or the file")
}
_ => peer_error("does not hold what was asked for"),
});
}
Ok(frame)
}
pub fn fetch(store: &dyn Store, root: &Root, peer: &mut dyn Peer) -> Result<Summary> {
let mut intake = Intake::new(store, *root)?;
let mut frames = [ChunkFrames::new(), ChunkFrames::new()];
loop {
let requests = intake.requests(REQUESTS_PER_ROUND);
if requests.is_empty() {
break;
}
let expected: Vec<Vec<Arrived>> = requests
.iter()
.map(|request| intake.expected(request))
.collect();
let asks: Vec<(Vec<u8>, usize)> = requests
.iter()
.map(|request| (request.encode(), intake.answer_limit(request)))
.collect();
let mut taken = vec![0_usize; requests.len()];
let mut refused = vec![false; requests.len()];
std::thread::scope(|scope| {
let mut taking = TakingIn::new(scope, &mut intake, &mut frames);
let asked = peer.ask_all(&asks, &mut |place, frame| {
let (Some(expected), Some(taken), Some(refused)) = (
expected.get(place),
taken.get_mut(place),
refused.get_mut(place),
) else {
return Err(peer_error("answered a request that was not sent"));
};
if *refused {
return Err(peer_error("sent more after it refused"));
}
if frame.first() == Some(&FRAME_REFUSED) {
Frame::decode(frame)?;
*refused = true;
return Ok(());
}
let Some(expected) = expected.get(*taken) else {
return Err(TOO_MUCH);
};
if matches!(expected, Arrived::Chunk(_)) && frame.first() == Some(&FRAME_CHUNK) {
taking.hold_copy(frame, Some(*expected))?;
} else {
taking.intake()?.accept_expected(frame, *expected)?;
}
*taken += 1;
Ok(())
});
taking.finish().and(asked)
})?;
if taken.contains(&0) {
return Err(peer_error("does not hold what the tree needs"));
}
}
intake.finish()
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Entries {
pub total: u64,
pub start: u64,
pub entries: Vec<Entry>,
}
pub struct Remote<'p> {
peer: &'p mut dyn Peer,
root: Root,
record: Record,
}
impl<'p> Remote<'p> {
pub fn open(peer: &'p mut dyn Peer, root: &Root) -> Result<Self> {
let frame = ask_one(peer, &Request::Record(*root), MAX_RECORD_BYTES)?;
if Root::of_record(&frame) != *root {
return Err(Error::HashMismatch { what: "a record" });
}
let record = Record::decode(&frame)?;
Ok(Self {
peer,
root: *root,
record,
})
}
pub fn root(&self) -> &Root {
&self.root
}
pub fn record(&self) -> &Record {
&self.record
}
pub fn entry(&mut self, folder: &Target, name: &str) -> Result<Option<Entry>> {
check_name(name)?;
folder.require(Kind::Folder)?;
let frame = ask_one(
self.peer,
&Request::FolderName {
folder: folder.hash,
name: name.to_owned(),
},
folder_branch_limit(1),
)?;
let Frame::FolderBranch(branch) = Frame::decode(&frame)? else {
return Err(OTHER_KIND);
};
Ok(branch.check_name(folder, name)?.cloned())
}
pub fn lookup(&mut self, path: &str) -> Result<Option<Entry>> {
let mut current = self.record.top();
let mut found = None;
for (folders_passed, name) in path.split('/').enumerate() {
check_name(name)?;
if current.kind != Kind::Folder {
return Ok(None);
}
if folders_passed >= MAX_FOLDER_DEPTH {
return Err(Error::TooDeep {
limit: MAX_FOLDER_DEPTH,
});
}
let Some(entry) = self.entry(¤t, name)? else {
return Ok(None);
};
current = entry.target();
found = Some(entry);
}
Ok(found)
}
pub fn entries(&mut self, folder: &Target, start: u64, count: u32) -> Result<Entries> {
folder.require(Kind::Folder)?;
let request = Request::FolderBranch {
folder: folder.hash,
start,
count,
};
let frame = ask_one(self.peer, &request, folder_branch_limit(u64::from(count)))?;
let Frame::FolderBranch(branch) = Frame::decode(&frame)? else {
return Err(OTHER_KIND);
};
branch.check(folder)?;
if branch.count() != 0
&& (branch.start() != start || branch.entries().len() > count as usize)
{
return Err(Error::NotWanted {
what: "a branch that was not asked for",
});
}
Ok(Entries {
total: branch.count(),
start: branch.start(),
entries: branch.entries().to_vec(),
})
}
pub fn read(
&mut self,
file: &Target,
offset: u64,
length: u64,
out: &mut dyn Write,
) -> Result<()> {
file.require(Kind::File)?;
let end = offset
.checked_add(length)
.filter(|end| *end <= file.size)
.ok_or_else(|| invalid("a stretch of bytes is outside the file"))?;
let chunking = self.record.chunking();
let mut at = offset;
while at < end {
let request = Request::FileBytes {
file: file.hash,
offset: at,
length: end - at,
};
let branch_limit = file_branch_limit(most_chunks_in(chunking, end - at));
let frame = ask_one(self.peer, &request, branch_limit)?;
let Frame::FileBranch(branch) = Frame::decode(&frame)? else {
return Err(OTHER_KIND);
};
let branch_start = branch.check(file, Some(chunking))?;
let items = branch.items();
let before_last: u64 = items[..items.len() - 1]
.iter()
.map(|item| u64::from(item.length))
.sum();
let holds_first = branch_start <= at && at < branch_start + u64::from(items[0].length);
if !holds_first || branch_start + before_last >= end {
return Err(Error::NotWanted {
what: "a branch that does not hold the bytes asked for",
});
}
let chunks = Request::Chunks {
file: file.hash,
start: branch.start(),
count: items.len() as u32,
};
let longest = items
.iter()
.map(|item| item.length as usize)
.max()
.unwrap_or(0);
let mut taken = 0_usize;
let mut chunk_start = branch_start;
let mut refused = false;
self.peer.ask(&chunks.encode(), longest + 1, &mut |frame| {
if refused {
return Err(peer_error("sent more after it refused"));
}
match Frame::decode(frame)? {
Frame::Refused(_) => refused = true,
Frame::Chunk(bytes) => {
let item = items.get(taken).ok_or(TOO_MUCH)?;
check_chunk(item, bytes, "a chunk")?;
let chunk_end = chunk_start + u64::from(item.length);
let from = (at - chunk_start) as usize;
let to = (end.min(chunk_end) - chunk_start) as usize;
out.write_all(&bytes[from..to])
.map_err(|source| Error::Stream {
operation: "write a file's bytes",
source,
})?;
at = end.min(chunk_end);
chunk_start = chunk_end;
taken += 1;
}
_ => return Err(OTHER_KIND),
}
Ok(())
})?;
if taken == 0 {
return Err(peer_error("does not hold the chunks asked for"));
}
}
Ok(())
}
pub fn have(&mut self, file: &Target) -> Result<HaveMap> {
file.require(Kind::File)?;
let chunking = self.record.chunking();
let most = chunking.count_bounds(file.size).1;
let limit = usize::try_from(most.div_ceil(8))
.unwrap_or(usize::MAX)
.saturating_add(9);
let frame = ask_one(self.peer, &Request::Have(file.hash), limit)?;
let Frame::Have(map) = Frame::decode(&frame)? else {
return Err(OTHER_KIND);
};
chunking.check_count(file.size, map.count())?;
Ok(map)
}
}
pub fn export(store: &dyn Store, root: &Root, out: &mut dyn Write) -> Result<()> {
let record = record_of(store, root)?;
out.write_all(&BUNDLE_MAGIC)
.map_err(|source| Error::Stream {
operation: "write a bundle",
source,
})?;
write_frame(out, &record.encode())?;
let mut lists: HashSet<(Kind, Hash)> = HashSet::new();
let mut chunks: HashSet<Hash> = HashSet::new();
let mut ahead = ChunksAhead::new();
let mut pending = vec![record.top()];
while let Some(target) = pending.pop() {
if !lists.insert((target.kind, target.hash)) {
continue;
}
match target.kind {
Kind::Folder => {
let list = folder_of(store, &target)?;
write_framed(out, FRAME_FOLDER_LIST, &list.encode())?;
pending.extend(list.entries().iter().rev().map(Entry::target));
}
Kind::File => {
let list = file_of(store, &target)?;
write_framed(out, FRAME_FILE_LIST, &list.encode())?;
let new: Vec<ChunkRef> = list
.items()
.iter()
.filter(|item| chunks.insert(item.hash))
.copied()
.collect();
ahead.lend(store, &new, &mut |_, bytes| {
write_framed(out, FRAME_CHUNK, bytes)
})?;
}
}
}
Ok(())
}
pub fn import(store: &dyn Store, root: &Root, input: &mut dyn Read) -> Result<Summary> {
let mut magic = [0_u8; 8];
input
.read_exact(&mut magic)
.map_err(|source| Error::Stream {
operation: "read a bundle",
source,
})?;
if magic != BUNDLE_MAGIC {
return Err(invalid("a stream does not start as a bundle does"));
}
let mut intake = Intake::new(store, *root)?;
let mut frames = [ChunkFrames::new(), ChunkFrames::new()];
let mut frame = Vec::new();
let mut limit = intake.frame_limit();
let mut recorded = intake.record().is_some();
std::thread::scope(|scope| {
let mut taking = TakingIn::new(scope, &mut intake, &mut frames);
let read = loop {
let next = match taking.read_next(input, limit) {
Ok(next) => next,
Err(error) => break Err(error),
};
match next {
Next::Frame if recorded && taking.next_is_chunk() => {
if let Err(error) = taking.hold(None) {
break Err(error);
}
}
Next::Frame => {
taking.take_next(&mut frame);
let accepted = taking.intake().and_then(|intake| {
intake.accept(&frame)?;
limit = intake.frame_limit();
recorded = intake.record().is_some();
Ok(())
});
if let Err(error) = accepted {
break Err(error);
}
}
Next::End => break Err(invalid("a frame is empty")),
Next::Closed => break Ok(()),
}
};
taking.finish().and(read)
})?;
intake.finish()
}
pub fn serve(store: &dyn Store, input: &mut dyn Read, output: &mut dyn Write) -> Result<()> {
let responder = Responder::new(store);
let mut request = Vec::new();
loop {
match read_next(input, MAX_REQUEST_BYTES, &mut request)? {
Next::Frame => {}
Next::End => return Err(invalid("a request is empty")),
Next::Closed => return Ok(()),
}
responder.answer(&request, &mut |frame| write_frame(output, frame))?;
write_end(output)?;
output.flush().map_err(|source| Error::Stream {
operation: "send an answer",
source,
})?;
}
}
pub struct StreamPeer<R, W> {
input: R,
output: W,
broken: bool,
frame: Vec<u8>,
}
impl<R: Read, W: Write> StreamPeer<R, W> {
pub fn new(input: R, output: W) -> Self {
Self {
input,
output,
broken: false,
frame: Vec::new(),
}
}
}
impl<R: Read, W: Write> Peer for StreamPeer<R, W> {
fn ask(
&mut self,
request: &[u8],
limit: usize,
on_frame: &mut dyn FnMut(&[u8]) -> Result<()>,
) -> Result<()> {
self.ask_all(&[(request.to_vec(), limit)], &mut |_, frame| {
on_frame(frame)
})
}
fn ask_all(
&mut self,
requests: &[(Vec<u8>, usize)],
on_frame: &mut dyn FnMut(usize, &[u8]) -> Result<()>,
) -> Result<()> {
if self.broken {
return Err(peer_error(
"is on a connection that an earlier answer left half read",
));
}
self.broken = true;
let mut answered = 0;
while answered < requests.len() {
let mut sent = answered;
let mut ahead = 0;
while let Some((request, _)) = requests.get(sent) {
let bytes = request.len() + 4;
if sent > answered && ahead + bytes > REQUESTS_AHEAD_BYTES {
break;
}
write_frame(&mut self.output, request)?;
ahead += bytes;
sent += 1;
}
self.output.flush().map_err(|source| Error::Stream {
operation: "send a request",
source,
})?;
for (place, (_, limit)) in requests.iter().enumerate().take(sent).skip(answered) {
loop {
match read_next(&mut self.input, *limit, &mut self.frame)? {
Next::Frame => on_frame(place, &self.frame)?,
Next::End => break,
Next::Closed => {
return Err(peer_error("closed the connection inside an answer"));
}
}
}
}
answered = sent;
}
self.broken = false;
Ok(())
}
}