Network WIP.

src/client_side_sync.rs

@@ -0,0 +1,94 @@
+struct ClientSideSync {
+    state_send: mpsc::Sender<(StateChange, oneshot::Sender<()>)>,
+    new_version_source: NewVersionSource,
+}
+
+// TODO: Parametrize the server protocol!
+// TODO: Can one directory be synchronized to multiple servers? Cycles are then possible!
+impl ClientSideSync {
+    // TODO: Restrict the size of the files downloaded by the synchronization client?
+    pub async fn new(
+        file_tree: Arc<Mutex<FileTree>>,
+        errors: mpsc::Sender<SynchronizationError>,
+    ) -> Result<ClientSideSync, Error> {
+        let new_version_source = file_tree.lock().await.new_version_source();
+        // Spawn the task that connects to the server as soon as unpause() is called.
+        let (state_send, pause_receive) = mpsc::channel(1);
+        tokio::spawn(async move {
+            let mut sync_task = ClientSideSyncTask {
+                file_tree,
+                errors,
+                new_version_source,
+            };
+            sync_task.task_paused(pause_receive).await;
+        });
+
+        Ok(ClientSideSync{
+            state_send,
+            new_version_source,
+        })
+    }
+
+    // TODO: Deduplicate this code.
+    pub async fn pause(&mut self) {
+        let (send, receive) = oneshot::channel();
+        self.state_send
+            .send((StateChange::Pause, send))
+            .await
+            .unwrap();
+        receive.await.unwrap();
+    }
+
+    pub async fn unpause(&mut self) {
+        let (send, receive) = oneshot::channel();
+        self.state_send
+            .send((StateChange::Unpause, send))
+            .await
+            .unwrap();
+        receive.await.unwrap();
+    }
+}
+
+struct ClientSideSyncTask {
+    file_tree: Arc<Mutex<FileTree>>,
+    errors: mpsc::Sender<SynchronizationError>,
+    new_version_source: NewVersionSource,
+}
+
+impl ClientSideSyncTask {
+    async fn task_paused(
+        &mut self,
+        mut state_receive: mpsc::Receiver<(StateChange, oneshot::Sender<()>)>,
+    ) {
+        let mut paused = true;
+
+        loop {
+            if paused {
+                // If we are paused, we only need to wait for state changes.
+                let (new_state, send) = state_receive.recv().await.unwrap();
+                match new_state {
+                    StateChange::Pause => paused = true,
+                    StateChange::Unpause => paused = false,
+                    StateChange::Terminate => break, // No reply, see drop().
+                }
+                send.send(()).unwrap();
+            } else {
+                // We were unpaused, initialize the file system watcher and start waiting for
+                // that as well.
+                let next_state = self.task_unpaused(&mut state_receive).await;
+                match next_state {
+                    StateChange::Pause => paused = true,
+                    StateChange::Unpause => paused = false,
+                    StateChange::Terminate => break,
+                }
+            }
+        }
+    }
+
+    async fn task_unpaused(
+        &mut self,
+        state_receive: &mut mpsc::Receiver<(StateChange, oneshot::Sender<()>)>,
+    ) -> StateChange {
+        // TODO
+    }
+}

src/lib.rs

@@ -3,6 +3,7 @@ use std::io;
 mod database;
 mod file_system_watcher;
 mod file_tree;
+pub mod network;
 
 pub use database::Database;
 pub use file_system_watcher::FileSystemWatcher;

src/network/client.rs

@@ -0,0 +1,21 @@
+use futures::Future;
+use serde::de::DeserializeOwned;
+use serde::Serialize;
+
+use std::time::Duration;
+
+trait Connection {
+    type Request: Serialize;
+    type Response: DeserializeOwned; // TODO: Better lifetime for zero-copy deserialization of large amounts of data?
+    type Call: RemoteCall<Output = Self::Response>;
+
+    fn call(call: Self::Request) -> Self::Call;
+
+    // TODO: Server-client events.
+}
+
+trait RemoteCall: Future {
+    // TODO
+
+    fn with_timeout(self, timeout: Duration) -> Self;
+}

src/network/mod.rs

@@ -0,0 +1,2 @@
+mod client;
+mod server;

src/network/packet_connection.rs

@@ -0,0 +1,8 @@
+use serde::de::DeserializeOwned;
+use serde::Serialize;
+
+trait PacketConnection {
+    type Payload: Serialize + DeserializeOwned;
+
+    // TODO
+}

src/network/server.rs

@@ -0,0 +1 @@
+

src/online_test.rs

@@ -0,0 +1,12 @@
+trait OnlineTest {
+    // TODO
+}
+
+/// Tests whether the system is online by connecting the specified address.
+struct GenericOnlineTest {
+    // TODO
+}
+
+impl OnlineTest for GenericOnlineTest {
+    // TODO
+}

src/protocol.rs

@@ -0,0 +1,123 @@
+/*pub trait Protocol {
+    fn login_password(&mut self, user: &str, password: &str) -> Result<String, Error>;
+    fn login_app_key(&mut self, user: &str, key: &str) -> Result<(), Error>;
+
+    fn register_interest(&mut self, path: &str) -> Result<(), Error>;
+    fn unregister_interest(&mut self, path: &str) -> Result<(), Error>;
+    fn get_file_update_stream() ->
+
+    fn list_directory(path: &str) -> Result<DirectoryListing, Error>;
+    fn get_file_metadata(path: &str) -> Result<FileMetadata, Error>;
+    // TODO
+}*/
+
+pub struct DirectoryListing {
+    own_version: u64,
+    entries: Vec<FileMetadata>,
+    // TODO
+}
+
+pub struct FileMetadata {
+    name: String,
+    version: u64,
+    size: u64,
+    type_: DirectoryEntryType,
+}
+
+pub enum DirectoryEntryType {
+    Directory,
+    File,
+    SymbolicLink,
+}
+
+pub struct Packet {
+    pub serial_number: u32,
+    pub type_: PacketContent,
+}
+
+pub enum PacketContent {
+    Keepalive,
+    Error(Error),
+    ServerInfo,
+    ServerInfoResponse(ServerInfoResponse,
+    PasswordLogin(PasswordLogin),
+    PasswordLoginResponse(PasswordLoginResponse),
+    AppKeyLogin(AppKeyLogin),
+    AppKeyLoginResponse(AppKeyLoginResponse),
+    RegisterInterest(RegisterInterest),
+    RegisterInterestResponse(RegisterInterestResponse),
+    UnregisterInterest(UnregisterInterest),
+    UnregisterInterestResponse(UnregisterInterestResponse),
+    ListDirectory(ListDirectory),
+    ListDirectoryResponse(ListDirectoryResponse),
+    GetFileMetadata(GetFileMetadata),
+    GetFileMetadataResponse(GetFileMetadataResponse),
+    GetFileContent(GetFileContent),
+    GetFileContentResponse(GetFileContentResponse),
+    StartFileUpdate,
+    UpdateFileContent,
+    FinishFileUpdate,
+}
+
+pub enum Error {
+    // TODO
+}
+
+pub struct ServerInfoResponse {
+    // TODO: Version of the protocol, type of the server (encrypted/unencrypted).
+}
+
+pub struct PasswordLogin {
+    // TODO
+}
+
+pub struct PasswordLoginResponse {
+    // TODO
+}
+
+pub struct AppKeyLogin {
+    // TODO
+}
+pub struct AppKeyLoginResponse {
+    // TODO
+}
+
+pub struct RegisterInterest {
+    // TODO
+}
+
+pub struct RegisterInterestResponse {
+    // TODO
+}
+
+pub struct UnregisterInterest {
+    // TODO
+}
+
+pub struct UnregisterInterestResponse {
+    // TODO
+}
+
+pub struct ListDirectory {
+    // TODO
+}
+
+pub struct ListDirectoryResponse {
+    // TODO
+}
+
+pub struct GetFileMetadata {
+    // TODO
+}
+
+pub struct GetFileMetadataResponse {
+    // TODO
+}
+
+pub struct GetFileContent {
+    // TODO
+}
+
+pub struct GetFileContentResponse {
+    // TODO
+}