Patchwork [5,of,6] rust-chg: spawn server process if not running

login
register
mail settings
Submitter Yuya Nishihara
Date Oct. 14, 2018, 8:18 a.m.
Message ID <389e082b48ba5a543a2c.1539505102@mimosa>
Download mbox | patch
Permalink /patch/35958/
State Accepted
Headers show

Comments

Yuya Nishihara - Oct. 14, 2018, 8:18 a.m.
# HG changeset patch
# User Yuya Nishihara <yuya@tcha.org>
# Date 1538824244 -32400
#      Sat Oct 06 20:10:44 2018 +0900
# Node ID 389e082b48ba5a543a2c0497963cca4231e22504
# Parent  83ae46b307d87085a0a0f8224f021adf7788050d
rust-chg: spawn server process if not running

This is the minimal reimplementation of gethgcmd(), execcmdserver(),
retryconnectcmdserver(), and connectcmdserver() in chg.c.

No config validation is yet implemented.

Patch

diff --git a/rust/chg/src/lib.rs b/rust/chg/src/lib.rs
--- a/rust/chg/src/lib.rs
+++ b/rust/chg/src/lib.rs
@@ -7,9 +7,12 @@  extern crate bytes;
 #[macro_use]
 extern crate futures;
 extern crate libc;
+#[macro_use]
+extern crate log;
 extern crate tokio;
 extern crate tokio_hglib;
 extern crate tokio_process;
+extern crate tokio_timer;
 
 mod attachio;
 mod clientext;
diff --git a/rust/chg/src/locator.rs b/rust/chg/src/locator.rs
--- a/rust/chg/src/locator.rs
+++ b/rust/chg/src/locator.rs
@@ -5,6 +5,7 @@ 
 
 //! Utility for locating command-server process.
 
+use futures::future::{self, Either, Loop};
 use std::env;
 use std::ffi::{OsStr, OsString};
 use std::fs::{self, DirBuilder};
@@ -12,8 +13,12 @@  use std::io;
 use std::os::unix::ffi::{OsStrExt, OsStringExt};
 use std::os::unix::fs::{DirBuilderExt, MetadataExt};
 use std::path::{Path, PathBuf};
-use std::process;
+use std::process::{self, Command};
 use std::time::Duration;
+use tokio::prelude::*;
+use tokio_hglib::UnixClient;
+use tokio_process::{Child, CommandExt};
+use tokio_timer;
 
 use super::procutil;
 
@@ -52,13 +57,106 @@  impl Locator {
         buf.extend_from_slice(format!(".{}", self.process_id).as_bytes());
         OsString::from_vec(buf).into()
     }
+
+    /// Connects to the server.
+    ///
+    /// The server process will be spawned if not running.
+    pub fn connect(self) -> impl Future<Item = (Self, UnixClient), Error = io::Error> {
+        self.try_connect()
+    }
+
+    /// Tries to connect to the existing server, or spawns new if not running.
+    fn try_connect(self) -> impl Future<Item = (Self, UnixClient), Error = io::Error> {
+        debug!("try connect to {}", self.base_sock_path.display());
+        UnixClient::connect(self.base_sock_path.clone())
+            .then(|res| {
+                match res {
+                    Ok(client) => Either::A(future::ok((self, client))),
+                    Err(_) => Either::B(self.spawn_connect()),
+                }
+            })
+    }
+
+    /// Spawns new server process and connects to it.
+    ///
+    /// The server will be spawned at the current working directory, then
+    /// chdir to "/", so that the server will load configs from the target
+    /// repository.
+    fn spawn_connect(self) -> impl Future<Item = (Self, UnixClient), Error = io::Error> {
+        let sock_path = self.temp_sock_path();
+        debug!("start cmdserver at {}", sock_path.display());
+        Command::new(&self.hg_command)
+            .arg("serve")
+            .arg("--cmdserver").arg("chgunix")
+            .arg("--address").arg(&sock_path)
+            .arg("--daemon-postexec").arg("chdir:/")
+            .current_dir(&self.current_dir)
+            .env_clear()
+            .envs(self.env_vars.iter().cloned())
+            .env("CHGINTERNALMARK", "")
+            .spawn_async()
+            .into_future()
+            .and_then(|server| self.connect_spawned(server, sock_path))
+            .and_then(|(loc, client, sock_path)| {
+                debug!("rename {} to {}", sock_path.display(), loc.base_sock_path.display());
+                fs::rename(&sock_path, &loc.base_sock_path)?;
+                Ok((loc, client))
+            })
+    }
+
+    /// Tries to connect to the just spawned server repeatedly until timeout
+    /// exceeded.
+    fn connect_spawned(self, server: Child, sock_path: PathBuf)
+                       -> impl Future<Item = (Self, UnixClient, PathBuf), Error = io::Error> {
+        debug!("try connect to {} repeatedly", sock_path.display());
+        let connect = future::loop_fn(sock_path, |sock_path| {
+            UnixClient::connect(sock_path.clone())
+                .then(|res| {
+                    match res {
+                        Ok(client) => {
+                            Either::A(future::ok(Loop::Break((client, sock_path))))
+                        }
+                        Err(_) => {
+                            // try again with slight delay
+                            let fut = tokio_timer::sleep(Duration::from_millis(10))
+                                .map(|()| Loop::Continue(sock_path))
+                                .map_err(|err| io::Error::new(io::ErrorKind::Other, err));
+                            Either::B(fut)
+                        }
+                    }
+                })
+        });
+
+        // waits for either connection established or server failed to start
+        connect.select2(server)
+            .map_err(|res| res.split().0)
+            .timeout(self.timeout)
+            .map_err(|err| {
+                err.into_inner().unwrap_or_else(|| {
+                    io::Error::new(io::ErrorKind::TimedOut,
+                                   "timed out while connecting to server")
+                })
+            })
+            .and_then(|res| {
+                match res {
+                    Either::A(((client, sock_path), server)) => {
+                        server.forget();  // continue to run in background
+                        Ok((self, client, sock_path))
+                    }
+                    Either::B((st, _)) => {
+                        Err(io::Error::new(io::ErrorKind::Other,
+                                           format!("server exited too early: {}", st)))
+                    }
+                }
+            })
+    }
 }
 
 /// Determines the server socket to connect to.
 ///
 /// If no `$CHGSOCKNAME` is specified, the socket directory will be created
 /// as necessary.
-pub fn prepare_server_socket_path() -> io::Result<PathBuf> {
+fn prepare_server_socket_path() -> io::Result<PathBuf> {
     if let Some(s) = env::var_os("CHGSOCKNAME") {
         Ok(PathBuf::from(s))
     } else {
diff --git a/rust/chg/src/main.rs b/rust/chg/src/main.rs
--- a/rust/chg/src/main.rs
+++ b/rust/chg/src/main.rs
@@ -10,7 +10,7 @@  extern crate tokio;
 extern crate tokio_hglib;
 
 use chg::{ChgClientExt, ChgUiHandler};
-use chg::locator;
+use chg::locator::Locator;
 use chg::procutil;
 use futures::sync::oneshot;
 use std::env;
@@ -18,7 +18,6 @@  use std::io;
 use std::process;
 use std::time::Instant;
 use tokio::prelude::*;
-use tokio_hglib::UnixClient;
 
 struct DebugLogger {
     start: Instant,
@@ -58,6 +57,8 @@  fn main() {
         log::set_max_level(log::LevelFilter::Debug);
     }
 
+    // TODO: add loop detection by $CHGINTERNALMARK
+
     let code = run().unwrap_or_else(|err| {
         writeln!(io::stderr(), "chg: abort: {}", err).unwrap_or(());
         255
@@ -67,11 +68,11 @@  fn main() {
 
 fn run() -> io::Result<i32> {
     let current_dir = env::current_dir()?;
-    let sock_path = locator::prepare_server_socket_path()?;
+    let loc = Locator::prepare_from_env()?;
     let handler = ChgUiHandler::new();
     let (result_tx, result_rx) = oneshot::channel();
-    let fut = UnixClient::connect(sock_path)
-        .and_then(|client| {
+    let fut = loc.connect()
+        .and_then(|(_, client)| {
             client.set_current_dir(current_dir)
         })
         .and_then(|client| {