Skip to main content

Enc

ssh_browser::sftp::wire

Struct Enc 

Source 
pub struct Enc(/* private fields */);
Expand description

Big-endian encoder, chained by value so one request is one expression.

Implementations§

Source§

impl Enc

Source

pub fn new() -> Self

Examples found in repository?
examples/measure-roundtrips.rs (line 144)
139async fn measure_tau(s: &mut Session) -> Result<Duration> {
140    let mut samples = Vec::with_capacity(TAU_REPS);
141    for _ in 0..TAU_REPS {
142        let id = s.alloc_id();
143        let t = Instant::now();
144        s.queue(REALPATH, &Enc::new().u32(id).str(b".").done())
145            .await?;
146        s.flush().await?;
147        let r = s.recv().await?;
148        ensure!(r.id == id, "reply id {} does not match request {id}", r.id);
149        samples.push(t.elapsed());
150    }
151    samples.sort_unstable();
152    Ok(samples[samples.len() / 2])
153}
154
155/// One READDIR sweep carries every entry's attrs, which is what lets the origin
156/// layer skip per-file STAT entirely and keep invariant 1 within reach.
157async fn list(s: &mut Session, dir: &str) -> Result<Vec<(String, Attrs)>> {
158    let id = s.alloc_id();
159    s.queue(OPENDIR, &Enc::new().u32(id).str(dir.as_bytes()).done())
160        .await?;
161    s.flush().await?;
162    let r = s.recv().await?;
163    ensure!(
164        r.kind == HANDLE,
165        "opendir {dir} refused (reply type {})",
166        r.kind
167    );
168    let handle = Dec::new(r.payload())
169        .str()
170        .context("opendir handle")?
171        .to_vec();
172
173    let mut out = Vec::new();
174    loop {
175        let id = s.alloc_id();
176        s.queue(READDIR, &Enc::new().u32(id).str(&handle).done())
177            .await?;
178        s.flush().await?;
179        let r = s.recv().await?;
180        if r.kind == STATUS {
181            break;
182        }
183        ensure!(r.kind == NAME, "readdir gave reply type {}", r.kind);
184        let mut d = Dec::new(r.payload());
185        let count = d.u32().context("readdir count")?;
186        for _ in 0..count {
187            let name = String::from_utf8_lossy(d.str().context("filename")?).into_owned();
188            d.str().context("longname")?;
189            let attrs = Attrs::decode(&mut d).context("attrs")?;
190            out.push((name, attrs));
191        }
192    }
193
194    let id = s.alloc_id();
195    s.queue(CLOSE, &Enc::new().u32(id).str(&handle).done())
196        .await?;
197    s.flush().await?;
198    s.recv().await?;
199    Ok(out)
200}
201
202async fn batch_open(s: &mut Session, paths: &[String]) -> Result<(Duration, Vec<Vec<u8>>)> {
203    let t = Instant::now();
204    for p in paths {
205        let id = s.alloc_id();
206        s.queue(
207            OPEN,
208            &Enc::new()
209                .u32(id)
210                .str(p.as_bytes())
211                .u32(FXF_READ)
212                .u32(0)
213                .done(),
214        )
215        .await?;
216    }
217    s.flush().await?;
218
219    let mut handles = Vec::with_capacity(paths.len());
220    for _ in 0..paths.len() {
221        let r = s.recv().await?;
222        ensure!(r.kind == HANDLE, "open refused (reply type {})", r.kind);
223        handles.push(Dec::new(r.payload()).str().context("open handle")?.to_vec());
224    }
225    Ok((t.elapsed(), handles))
226}
227
228async fn batch_read(s: &mut Session, handles: &[Vec<u8>]) -> Result<(Duration, usize)> {
229    let t = Instant::now();
230    for h in handles {
231        let id = s.alloc_id();
232        s.queue(READ, &Enc::new().u32(id).str(h).u64(0).u32(READ_LEN).done())
233            .await?;
234    }
235    s.flush().await?;
236
237    let mut bytes = 0usize;
238    for _ in 0..handles.len() {
239        let r = s.recv().await?;
240        match r.kind {
241            DATA => bytes += Dec::new(r.payload()).str().map_or(0, |b| b.len()),
242            STATUS => {}
243            other => bail!("read gave reply type {other}"),
244        }
245    }
246    Ok((t.elapsed(), bytes))
247}
248
249async fn batch_close(s: &mut Session, handles: &[Vec<u8>]) -> Result<()> {
250    for h in handles {
251        let id = s.alloc_id();
252        s.queue(CLOSE, &Enc::new().u32(id).str(h).done()).await?;
253    }
254    s.flush().await?;
255    for _ in 0..handles.len() {
256        s.recv().await?;
257    }
258    Ok(())
259}
Source

pub fn u32(self, v: u32) -> Self

Examples found in repository?
examples/measure-roundtrips.rs (line 144)
139async fn measure_tau(s: &mut Session) -> Result<Duration> {
140    let mut samples = Vec::with_capacity(TAU_REPS);
141    for _ in 0..TAU_REPS {
142        let id = s.alloc_id();
143        let t = Instant::now();
144        s.queue(REALPATH, &Enc::new().u32(id).str(b".").done())
145            .await?;
146        s.flush().await?;
147        let r = s.recv().await?;
148        ensure!(r.id == id, "reply id {} does not match request {id}", r.id);
149        samples.push(t.elapsed());
150    }
151    samples.sort_unstable();
152    Ok(samples[samples.len() / 2])
153}
154
155/// One READDIR sweep carries every entry's attrs, which is what lets the origin
156/// layer skip per-file STAT entirely and keep invariant 1 within reach.
157async fn list(s: &mut Session, dir: &str) -> Result<Vec<(String, Attrs)>> {
158    let id = s.alloc_id();
159    s.queue(OPENDIR, &Enc::new().u32(id).str(dir.as_bytes()).done())
160        .await?;
161    s.flush().await?;
162    let r = s.recv().await?;
163    ensure!(
164        r.kind == HANDLE,
165        "opendir {dir} refused (reply type {})",
166        r.kind
167    );
168    let handle = Dec::new(r.payload())
169        .str()
170        .context("opendir handle")?
171        .to_vec();
172
173    let mut out = Vec::new();
174    loop {
175        let id = s.alloc_id();
176        s.queue(READDIR, &Enc::new().u32(id).str(&handle).done())
177            .await?;
178        s.flush().await?;
179        let r = s.recv().await?;
180        if r.kind == STATUS {
181            break;
182        }
183        ensure!(r.kind == NAME, "readdir gave reply type {}", r.kind);
184        let mut d = Dec::new(r.payload());
185        let count = d.u32().context("readdir count")?;
186        for _ in 0..count {
187            let name = String::from_utf8_lossy(d.str().context("filename")?).into_owned();
188            d.str().context("longname")?;
189            let attrs = Attrs::decode(&mut d).context("attrs")?;
190            out.push((name, attrs));
191        }
192    }
193
194    let id = s.alloc_id();
195    s.queue(CLOSE, &Enc::new().u32(id).str(&handle).done())
196        .await?;
197    s.flush().await?;
198    s.recv().await?;
199    Ok(out)
200}
201
202async fn batch_open(s: &mut Session, paths: &[String]) -> Result<(Duration, Vec<Vec<u8>>)> {
203    let t = Instant::now();
204    for p in paths {
205        let id = s.alloc_id();
206        s.queue(
207            OPEN,
208            &Enc::new()
209                .u32(id)
210                .str(p.as_bytes())
211                .u32(FXF_READ)
212                .u32(0)
213                .done(),
214        )
215        .await?;
216    }
217    s.flush().await?;
218
219    let mut handles = Vec::with_capacity(paths.len());
220    for _ in 0..paths.len() {
221        let r = s.recv().await?;
222        ensure!(r.kind == HANDLE, "open refused (reply type {})", r.kind);
223        handles.push(Dec::new(r.payload()).str().context("open handle")?.to_vec());
224    }
225    Ok((t.elapsed(), handles))
226}
227
228async fn batch_read(s: &mut Session, handles: &[Vec<u8>]) -> Result<(Duration, usize)> {
229    let t = Instant::now();
230    for h in handles {
231        let id = s.alloc_id();
232        s.queue(READ, &Enc::new().u32(id).str(h).u64(0).u32(READ_LEN).done())
233            .await?;
234    }
235    s.flush().await?;
236
237    let mut bytes = 0usize;
238    for _ in 0..handles.len() {
239        let r = s.recv().await?;
240        match r.kind {
241            DATA => bytes += Dec::new(r.payload()).str().map_or(0, |b| b.len()),
242            STATUS => {}
243            other => bail!("read gave reply type {other}"),
244        }
245    }
246    Ok((t.elapsed(), bytes))
247}
248
249async fn batch_close(s: &mut Session, handles: &[Vec<u8>]) -> Result<()> {
250    for h in handles {
251        let id = s.alloc_id();
252        s.queue(CLOSE, &Enc::new().u32(id).str(h).done()).await?;
253    }
254    s.flush().await?;
255    for _ in 0..handles.len() {
256        s.recv().await?;
257    }
258    Ok(())
259}
Source

pub fn u64(self, v: u64) -> Self

Examples found in repository?
examples/measure-roundtrips.rs (line 232)
228async fn batch_read(s: &mut Session, handles: &[Vec<u8>]) -> Result<(Duration, usize)> {
229    let t = Instant::now();
230    for h in handles {
231        let id = s.alloc_id();
232        s.queue(READ, &Enc::new().u32(id).str(h).u64(0).u32(READ_LEN).done())
233            .await?;
234    }
235    s.flush().await?;
236
237    let mut bytes = 0usize;
238    for _ in 0..handles.len() {
239        let r = s.recv().await?;
240        match r.kind {
241            DATA => bytes += Dec::new(r.payload()).str().map_or(0, |b| b.len()),
242            STATUS => {}
243            other => bail!("read gave reply type {other}"),
244        }
245    }
246    Ok((t.elapsed(), bytes))
247}
Source

pub fn str(self, v: &[u8]) -> Self

Examples found in repository?
examples/measure-roundtrips.rs (line 144)
139async fn measure_tau(s: &mut Session) -> Result<Duration> {
140    let mut samples = Vec::with_capacity(TAU_REPS);
141    for _ in 0..TAU_REPS {
142        let id = s.alloc_id();
143        let t = Instant::now();
144        s.queue(REALPATH, &Enc::new().u32(id).str(b".").done())
145            .await?;
146        s.flush().await?;
147        let r = s.recv().await?;
148        ensure!(r.id == id, "reply id {} does not match request {id}", r.id);
149        samples.push(t.elapsed());
150    }
151    samples.sort_unstable();
152    Ok(samples[samples.len() / 2])
153}
154
155/// One READDIR sweep carries every entry's attrs, which is what lets the origin
156/// layer skip per-file STAT entirely and keep invariant 1 within reach.
157async fn list(s: &mut Session, dir: &str) -> Result<Vec<(String, Attrs)>> {
158    let id = s.alloc_id();
159    s.queue(OPENDIR, &Enc::new().u32(id).str(dir.as_bytes()).done())
160        .await?;
161    s.flush().await?;
162    let r = s.recv().await?;
163    ensure!(
164        r.kind == HANDLE,
165        "opendir {dir} refused (reply type {})",
166        r.kind
167    );
168    let handle = Dec::new(r.payload())
169        .str()
170        .context("opendir handle")?
171        .to_vec();
172
173    let mut out = Vec::new();
174    loop {
175        let id = s.alloc_id();
176        s.queue(READDIR, &Enc::new().u32(id).str(&handle).done())
177            .await?;
178        s.flush().await?;
179        let r = s.recv().await?;
180        if r.kind == STATUS {
181            break;
182        }
183        ensure!(r.kind == NAME, "readdir gave reply type {}", r.kind);
184        let mut d = Dec::new(r.payload());
185        let count = d.u32().context("readdir count")?;
186        for _ in 0..count {
187            let name = String::from_utf8_lossy(d.str().context("filename")?).into_owned();
188            d.str().context("longname")?;
189            let attrs = Attrs::decode(&mut d).context("attrs")?;
190            out.push((name, attrs));
191        }
192    }
193
194    let id = s.alloc_id();
195    s.queue(CLOSE, &Enc::new().u32(id).str(&handle).done())
196        .await?;
197    s.flush().await?;
198    s.recv().await?;
199    Ok(out)
200}
201
202async fn batch_open(s: &mut Session, paths: &[String]) -> Result<(Duration, Vec<Vec<u8>>)> {
203    let t = Instant::now();
204    for p in paths {
205        let id = s.alloc_id();
206        s.queue(
207            OPEN,
208            &Enc::new()
209                .u32(id)
210                .str(p.as_bytes())
211                .u32(FXF_READ)
212                .u32(0)
213                .done(),
214        )
215        .await?;
216    }
217    s.flush().await?;
218
219    let mut handles = Vec::with_capacity(paths.len());
220    for _ in 0..paths.len() {
221        let r = s.recv().await?;
222        ensure!(r.kind == HANDLE, "open refused (reply type {})", r.kind);
223        handles.push(Dec::new(r.payload()).str().context("open handle")?.to_vec());
224    }
225    Ok((t.elapsed(), handles))
226}
227
228async fn batch_read(s: &mut Session, handles: &[Vec<u8>]) -> Result<(Duration, usize)> {
229    let t = Instant::now();
230    for h in handles {
231        let id = s.alloc_id();
232        s.queue(READ, &Enc::new().u32(id).str(h).u64(0).u32(READ_LEN).done())
233            .await?;
234    }
235    s.flush().await?;
236
237    let mut bytes = 0usize;
238    for _ in 0..handles.len() {
239        let r = s.recv().await?;
240        match r.kind {
241            DATA => bytes += Dec::new(r.payload()).str().map_or(0, |b| b.len()),
242            STATUS => {}
243            other => bail!("read gave reply type {other}"),
244        }
245    }
246    Ok((t.elapsed(), bytes))
247}
248
249async fn batch_close(s: &mut Session, handles: &[Vec<u8>]) -> Result<()> {
250    for h in handles {
251        let id = s.alloc_id();
252        s.queue(CLOSE, &Enc::new().u32(id).str(h).done()).await?;
253    }
254    s.flush().await?;
255    for _ in 0..handles.len() {
256        s.recv().await?;
257    }
258    Ok(())
259}
Source

pub fn done(self) -> Vec<u8> ⓘ

Examples found in repository?
examples/measure-roundtrips.rs (line 144)
139async fn measure_tau(s: &mut Session) -> Result<Duration> {
140    let mut samples = Vec::with_capacity(TAU_REPS);
141    for _ in 0..TAU_REPS {
142        let id = s.alloc_id();
143        let t = Instant::now();
144        s.queue(REALPATH, &Enc::new().u32(id).str(b".").done())
145            .await?;
146        s.flush().await?;
147        let r = s.recv().await?;
148        ensure!(r.id == id, "reply id {} does not match request {id}", r.id);
149        samples.push(t.elapsed());
150    }
151    samples.sort_unstable();
152    Ok(samples[samples.len() / 2])
153}
154
155/// One READDIR sweep carries every entry's attrs, which is what lets the origin
156/// layer skip per-file STAT entirely and keep invariant 1 within reach.
157async fn list(s: &mut Session, dir: &str) -> Result<Vec<(String, Attrs)>> {
158    let id = s.alloc_id();
159    s.queue(OPENDIR, &Enc::new().u32(id).str(dir.as_bytes()).done())
160        .await?;
161    s.flush().await?;
162    let r = s.recv().await?;
163    ensure!(
164        r.kind == HANDLE,
165        "opendir {dir} refused (reply type {})",
166        r.kind
167    );
168    let handle = Dec::new(r.payload())
169        .str()
170        .context("opendir handle")?
171        .to_vec();
172
173    let mut out = Vec::new();
174    loop {
175        let id = s.alloc_id();
176        s.queue(READDIR, &Enc::new().u32(id).str(&handle).done())
177            .await?;
178        s.flush().await?;
179        let r = s.recv().await?;
180        if r.kind == STATUS {
181            break;
182        }
183        ensure!(r.kind == NAME, "readdir gave reply type {}", r.kind);
184        let mut d = Dec::new(r.payload());
185        let count = d.u32().context("readdir count")?;
186        for _ in 0..count {
187            let name = String::from_utf8_lossy(d.str().context("filename")?).into_owned();
188            d.str().context("longname")?;
189            let attrs = Attrs::decode(&mut d).context("attrs")?;
190            out.push((name, attrs));
191        }
192    }
193
194    let id = s.alloc_id();
195    s.queue(CLOSE, &Enc::new().u32(id).str(&handle).done())
196        .await?;
197    s.flush().await?;
198    s.recv().await?;
199    Ok(out)
200}
201
202async fn batch_open(s: &mut Session, paths: &[String]) -> Result<(Duration, Vec<Vec<u8>>)> {
203    let t = Instant::now();
204    for p in paths {
205        let id = s.alloc_id();
206        s.queue(
207            OPEN,
208            &Enc::new()
209                .u32(id)
210                .str(p.as_bytes())
211                .u32(FXF_READ)
212                .u32(0)
213                .done(),
214        )
215        .await?;
216    }
217    s.flush().await?;
218
219    let mut handles = Vec::with_capacity(paths.len());
220    for _ in 0..paths.len() {
221        let r = s.recv().await?;
222        ensure!(r.kind == HANDLE, "open refused (reply type {})", r.kind);
223        handles.push(Dec::new(r.payload()).str().context("open handle")?.to_vec());
224    }
225    Ok((t.elapsed(), handles))
226}
227
228async fn batch_read(s: &mut Session, handles: &[Vec<u8>]) -> Result<(Duration, usize)> {
229    let t = Instant::now();
230    for h in handles {
231        let id = s.alloc_id();
232        s.queue(READ, &Enc::new().u32(id).str(h).u64(0).u32(READ_LEN).done())
233            .await?;
234    }
235    s.flush().await?;
236
237    let mut bytes = 0usize;
238    for _ in 0..handles.len() {
239        let r = s.recv().await?;
240        match r.kind {
241            DATA => bytes += Dec::new(r.payload()).str().map_or(0, |b| b.len()),
242            STATUS => {}
243            other => bail!("read gave reply type {other}"),
244        }
245    }
246    Ok((t.elapsed(), bytes))
247}
248
249async fn batch_close(s: &mut Session, handles: &[Vec<u8>]) -> Result<()> {
250    for h in handles {
251        let id = s.alloc_id();
252        s.queue(CLOSE, &Enc::new().u32(id).str(h).done()).await?;
253    }
254    s.flush().await?;
255    for _ in 0..handles.len() {
256        s.recv().await?;
257    }
258    Ok(())
259}

Trait Implementations§

Source§

impl Default for Enc

Source§

fn default() -> Enc

Returns the “default value” for a type. Read more

Auto Trait Implementations§

§

impl Freeze for Enc

§

impl RefUnwindSafe for Enc

§

impl Send for Enc

§

impl Sync for Enc

§

impl Unpin for Enc

§

impl UnsafeUnpin for Enc

§

impl UnwindSafe for Enc

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = !

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, !>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.