upstream/mercurial-mirror Files · rust/chg/src/main.rs

rust: pure Rust lazyancestors iterator...

rust: pure Rust lazyancestors iterator This is the first of a patch series aiming to provide an alternative implementation in the Rust programming language of the _lazyancestorsiter from the ancestor module. This iterator has been brought to our attention by the people at Octobus, as a potential good candidate for incremental "oxydation" (rewriting in Rust), because it has shown performance issues lately and it merely deals with ints (revision numbers) obtained by calling the index, whih should be directly callable from Rust code, being itself implemented as a C extension. The idea behind this series is to provide a minimal example of Rust code collaborating with existing C and Python code. To open the way to gradually rewriting more of Mercurial's Python code in Rust, without being forced to pay a large initial cost of rewriting the existing fast core into Rust. This patch does not introduce any bindings to other Mercurial code yet. Instead, it introduces the necessary abstractions to address the problem independently, and unit-test it. Since this is the first use of Rust as a Python module within Mercurial, the hg-core crate gets created within this patch. See its Cargo.toml for more details. Someone with a rustc/cargo installation may chdir into rust/hg-core and run the tests by issuing: cargo test --lib The algorithm is a bit simplified (see details in docstrings), and at its simplest becomes rather trivial, showcasing that Rust has batteries included too: BinaryHeap, the Rust analog of Python's heapq does actually all the work. The implementation can be further optimized and probably be made more idiomatic Rust.

Yuya Nishihara - - Load All Authors

File last commit:

r40156:89742f1f default


                r40307:dbc28c91

default

Download file

             main.rs
        
                    59 lines
            
             | 1.8 KiB
            
                | application/rls-services+xml
            
             |
                RustLexer
            
             / rust / chg / src / main.rs
          
                    History
                
                 |
                  Annotation
                 | Raw
                 |Copy content
                 |Copy permalink

      // Copyright 2018 Yuya Nishihara <yuya@tcha.org>

      //

      // This software may be used and distributed according to the terms of the

      // GNU General Public License version 2 or any later version.

      extern crate chg;

      extern crate futures;

      extern crate tokio;

      extern crate tokio_hglib;

      use chg::{ChgClientExt, ChgUiHandler};

      use chg::locator;

      use chg::procutil;

      use futures::sync::oneshot;

      use std::env;

      use std::io;

      use std::process;

      use tokio::prelude::*;

      use tokio_hglib::UnixClient;

      fn main() {

          let code = run().unwrap_or_else(|err| {

              eprintln!("chg: abort: {}", err);

              255

          });

          process::exit(code);

      }

      fn run() -> io::Result<i32> {

          let current_dir = env::current_dir()?;

          let sock_path = locator::prepare_server_socket_path()?;

          let handler = ChgUiHandler::new();

          let (result_tx, result_rx) = oneshot::channel();

          let fut = UnixClient::connect(sock_path)

              .and_then(|client| {

                  client.set_current_dir(current_dir)

              })

              .and_then(|client| {

                  client.attach_io(io::stdin(), io::stdout(), io::stderr())

              })

              .and_then(|client| {

                  let pid = client.server_spec().process_id.unwrap();

                  let pgid = client.server_spec().process_group_id;

                  procutil::setup_signal_handler_once(pid, pgid)?;

                  Ok(client)

              })

              .and_then(|client| {

                  client.run_command_chg(handler, env::args_os().skip(1))

              })

              .map(|(_client, _handler, code)| {

                  procutil::restore_signal_handler_once()?;

                  Ok(code)

              })

              .or_else(|err| Ok(Err(err)))  // pass back error to caller

              .map(|res| result_tx.send(res).unwrap());

          tokio::run(fut);

          result_rx.wait().unwrap_or(Err(io::Error::new(io::ErrorKind::Other,

                                                        "no exit code set")))

      }

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages

				// Copyright 2018 Yuya Nishihara <yuya@tcha.org>
				//
				// This software may be used and distributed according to the terms of the
				// GNU General Public License version 2 or any later version.

				extern crate chg;
				extern crate futures;
				extern crate tokio;
				extern crate tokio_hglib;

				use chg::{ChgClientExt, ChgUiHandler};
				use chg::locator;
				use chg::procutil;
				use futures::sync::oneshot;
				use std::env;
				use std::io;
				use std::process;
				use tokio::prelude::*;
				use tokio_hglib::UnixClient;

				fn main() {
				let code = run().unwrap_or_else(\|err\| {
				eprintln!("chg: abort: {}", err);
				255
				});
				process::exit(code);
				}

				fn run() -> io::Result<i32> {
				let current_dir = env::current_dir()?;
				let sock_path = locator::prepare_server_socket_path()?;
				let handler = ChgUiHandler::new();
				let (result_tx, result_rx) = oneshot::channel();
				let fut = UnixClient::connect(sock_path)
				.and_then(\|client\| {
				client.set_current_dir(current_dir)
				})
				.and_then(\|client\| {
				client.attach_io(io::stdin(), io::stdout(), io::stderr())
				})
				.and_then(\|client\| {
				let pid = client.server_spec().process_id.unwrap();
				let pgid = client.server_spec().process_group_id;
				procutil::setup_signal_handler_once(pid, pgid)?;
				Ok(client)
				})
				.and_then(\|client\| {
				client.run_command_chg(handler, env::args_os().skip(1))
				})
				.map(\|(_client, _handler, code)\| {
				procutil::restore_signal_handler_once()?;
				Ok(code)
				})
				.or_else(\|err\| Ok(Err(err))) // pass back error to caller
				.map(\|res\| result_tx.send(res).unwrap());
				tokio::run(fut);
				result_rx.wait().unwrap_or(Err(io::Error::new(io::ErrorKind::Other,
				"no exit code set")))
				}