mirror of
https://github.com/zed-industries/zed.git
synced 2025-02-06 10:42:08 +00:00
b9a53ffa0b
This is a first step towards allowing you to edit remote projects
directly over SSH. We'll start with a pretty bare-bones feature set, and
incrementally add further features.
### Todo
Distribution
* [x] Build nightly releases of `zed-remote-server` binaries
* [x] linux (arm + x86)
* [x] mac (arm + x86)
* [x] Build stable + preview releases of `zed-remote-server`
* [x] download and cache remote server binaries as needed when opening
ssh project
* [x] ensure server has the latest version of the binary
Auth
* [x] allow specifying password at the command line
* [x] auth via ssh keys
* [x] UI password prompt
Features
* [x] upload remote server binary to server automatically
* [x] opening directories
* [x] tracking file system updates
* [x] opening, editing, saving buffers
* [ ] file operations (rename, delete, create)
* [ ] git diffs
* [ ] project search
Release Notes:
- N/A
---------
Co-authored-by: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
51 lines
1.4 KiB
Rust
51 lines
1.4 KiB
Rust
use anyhow::Result;
|
|
use futures::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
|
|
use prost::Message as _;
|
|
use rpc::proto::Envelope;
|
|
use std::mem::size_of;
|
|
|
|
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
|
|
pub struct MessageId(pub u32);
|
|
|
|
pub type MessageLen = u32;
|
|
pub const MESSAGE_LEN_SIZE: usize = size_of::<MessageLen>();
|
|
|
|
pub fn message_len_from_buffer(buffer: &[u8]) -> MessageLen {
|
|
MessageLen::from_le_bytes(buffer.try_into().unwrap())
|
|
}
|
|
|
|
pub async fn read_message_with_len<S: AsyncRead + Unpin>(
|
|
stream: &mut S,
|
|
buffer: &mut Vec<u8>,
|
|
message_len: MessageLen,
|
|
) -> Result<Envelope> {
|
|
buffer.resize(message_len as usize, 0);
|
|
stream.read_exact(buffer).await?;
|
|
Ok(Envelope::decode(buffer.as_slice())?)
|
|
}
|
|
|
|
pub async fn read_message<S: AsyncRead + Unpin>(
|
|
stream: &mut S,
|
|
buffer: &mut Vec<u8>,
|
|
) -> Result<Envelope> {
|
|
buffer.resize(MESSAGE_LEN_SIZE, 0);
|
|
stream.read_exact(buffer).await?;
|
|
let len = message_len_from_buffer(buffer);
|
|
read_message_with_len(stream, buffer, len).await
|
|
}
|
|
|
|
pub async fn write_message<S: AsyncWrite + Unpin>(
|
|
stream: &mut S,
|
|
buffer: &mut Vec<u8>,
|
|
message: Envelope,
|
|
) -> Result<()> {
|
|
let message_len = message.encoded_len() as u32;
|
|
stream
|
|
.write_all(message_len.to_le_bytes().as_slice())
|
|
.await?;
|
|
buffer.clear();
|
|
buffer.reserve(message_len as usize);
|
|
message.encode(buffer)?;
|
|
stream.write_all(buffer).await?;
|
|
Ok(())
|
|
}
|