checksum = "05efc5cfd9110c8416e471df0e96702d58690178e206e61b7173706673c93706"

dependencies = [

 "memchr",

 "serde",

]

]

[[package]]

name = "equivalent"

version = "1.0.1"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "6e24cb5a94bcae1e5408b0effca5cd7172ea3c5755049c5f3af4cd283a165298"

dependencies = [

 "bit-set",

]

[[package]]

 "percent-encoding",

 "referencing",

 "regex",

 "serde",

 "serde_json",

 "uuid-simd",

checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"

[[package]]

name = "maybe-async"

version = "0.2.10"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be"

[[package]]

name = "num"

version = "0.4.3"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "1a80800c0488c3a21695ea981a54918fbb37abf04f4d0720c453632255e2ff0e"

[[package]]

name = "p256"

version = "0.13.2"

source = "registry+https://github.com/rust-lang/crates.io-index"

]

[[package]]

name = "pkcs1"

version = "0.7.5"

source = "registry+https://github.com/rust-lang/crates.io-index"

 "socket2",

 "sqlite",

 "tempfile",

 "thiserror 1.0.69",

]

name = "radicle-remote-helper"

version = "0.11.0"

dependencies = [

 "radicle",

 "radicle-cli",

 "radicle-crypto",

[[package]]

name = "radicle-systemd"

version = "0.9.0"

[[package]]

name = "radicle-term"

dependencies = [

 "aho-corasick",

 "memchr",

]

[[package]]

dependencies = [

 "aho-corasick",

 "memchr",

]

[[package]]

name = "regex-syntax"

version = "0.8.5"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"

]

[[package]]

name = "shell-words"

version = "1.1.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

]

[[package]]

name = "tar"

version = "0.4.40"

source = "registry+https://github.com/rust-lang/crates.io-index"

]

[[package]]

name = "thiserror"

version = "1.0.69"

source = "registry+https://github.com/rust-lang/crates.io-index"

]

[[package]]

name = "timeago"

version = "0.4.2"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"

[[package]]

name = "tree-sitter"

version = "0.24.4"

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

 "cc",

 "regex",

 "streaming-iterator",

 "tree-sitter-language",

]

]

[[package]]

name = "vcpkg"

version = "0.2.15"

source = "registry+https://github.com/rust-lang/crates.io-index"

        BUILD.call_once(|| {

            use escargot::format::Message;

            use radicle::logger::env_level;

            for (package, binary) in binaries {

                log::debug!(target: "test", "Building binaries for package `{package}`..");

fn main() {

    if let Some(lvl) = radicle::logger::env_level() {

    }

    if let Err(e) = radicle::io::set_file_limit(4096) {

        log::warn!(target: "cli", "Unable to set open file limit: {e}");

#[test]

fn rad_node_connect_without_address() {

    let mut environment = Environment::new();

    let mut alice = environment.node("alice");

    let bob = environment.node("bob");

#[test]

fn rad_patch_change_base() {

    Environment::alice(["rad-init", "rad-patch-change-base"]);

}

    let mut eve = environment.node("eve");

    let carol = NodeId::from_str("z6MksFqXN3Yhqk8pTJdUGLwBTkRfQvwZXPqR2qMEhbS9wzpT").unwrap();

    // Setup a test project.

    let acme = alice.project("heartwood", "Radicle Heartwood Protocol & Stack");

#[test]

fn rad_patch_open_explore() {

    let mut environment = Environment::new();

    let seed = environment

        .node_with(Config {

radicle = { workspace = true, features = ["test"] }

radicle-crypto = { workspace = true, features = ["test", "cyphernet"] }

snapbox = { workspace = true }

\ No newline at end of file

use anyhow::Context;

use crossbeam_channel as chan;

use radicle::node::device::Device;

use radicle::profile;

use radicle_node::crypto::ssh::keystore::{Keystore, MemorySigner};

    let config = options.config.unwrap_or_else(|| home.config());

    let mut config = profile::Config::load(&config)?;

    log::info!(target: "node", "Starting node..");

    log::info!(target: "node", "Version {} ({})", env!("RADICLE_VERSION"), env!("GIT_HEAD"));

    #[cfg(all(feature = "systemd", target_family = "unix"))]

    fn receive_listener() -> Option<UnixListener> {

        use std::os::fd::FromRawFd;

            Ok(Some(fd)) => {

                // NOTE: Here, we should make a call to [`fstat(2)`](man:fstat(2))

                // and make sure that the file descriptor we received actually

/// Even if Alice is not tracking Bob, Alice will fetch Bob's refs for a repo she doesn't have.

#[test]

fn test_refs_announcement_fetch_trusted_no_inventory() {

    let tmp = tempfile::tempdir().unwrap();

    let mut alice = Peer::with_storage(

        "alice",

/// Later Alice follows Bob, and will be able to fetch Bob's refs.

#[test]

fn test_refs_announcement_followed() {

    // Create MockStorage for Alice and Bob. Both will have repo with `rid`.

    let storage_alice = arbitrary::nonempty_storage(1);

    let rid = *storage_alice.repos.keys().next().unwrap();

#[test]

fn test_inventory_relay() {

    // Topology is eve <-> alice <-> bob

    let mut alice = Peer::new("alice", [7, 7, 7, 7]);

    let bob = Peer::new("bob", [8, 8, 8, 8]);

    let mut alice = Peer::with_storage("alice", [7, 7, 7, 7], storage);

    let bob = Peer::new("bob", [8, 8, 8, 8]);

    alice.connect_to(&bob);

    // Send the first fetch.

    let eve = Peer::new("eve", [9, 9, 9, 9]);

    let carol = Peer::new("carol", [10, 10, 10, 10]);

    alice.connect_to(&bob);

    alice.connect_to(&eve);

    alice.connect_to(&carol);

use std::{collections::HashSet, thread, time};

use radicle::node::device::Device;

use radicle::node::policy::Scope;

use radicle::node::Event;

use crate::node::{Config, ConnectOptions};

use crate::service;

use crate::storage::git::transport;

use crate::test::node::{converge, Node};

mod config {

//     alice -- bob

//

fn test_inventory_sync_basic() {

    let tmp = tempfile::tempdir().unwrap();

    let mut alice = Node::init(tmp.path(), config::relay("alice"));

//     alice -- bob -- eve

//

fn test_inventory_sync_bridge() {

    let tmp = tempfile::tempdir().unwrap();

    let mut alice = Node::init(tmp.path(), config::relay("alice"));

//     carol -- eve

//

fn test_inventory_sync_ring() {

    let tmp = tempfile::tempdir().unwrap();

    let mut alice = Node::init(tmp.path(), config::relay("alice"));

//            carol

//

fn test_inventory_sync_star() {

    let tmp = tempfile::tempdir().unwrap();

    let mut alice = Node::init(tmp.path(), config::relay("alice"));

#[test]

fn test_replication() {

    let tmp = tempfile::tempdir().unwrap();

    let alice = Node::init(tmp.path(), config::relay("alice"));

    let mut bob = Node::init(tmp.path(), config::relay("bob"));

#[test]

fn test_replication_ref_in_sigrefs() {

    let tmp = tempfile::tempdir().unwrap();

    let alice = Node::init(tmp.path(), config::relay("alice"));

    let mut bob = Node::init(tmp.path(), config::relay("bob"));

#[test]

fn test_migrated_clone() {

    let tmp = tempfile::tempdir().unwrap();

    let mut alice = Node::init(tmp.path(), config::relay("alice"));

    let bob = Node::init(tmp.path(), config::relay("bob"));

#[test]

fn test_dont_fetch_owned_refs() {

    let tmp = tempfile::tempdir().unwrap();

    let mut alice = Node::init(tmp.path(), config::relay("alice"));

    let bob = Node::init(tmp.path(), config::relay("bob"));

#[test]

fn test_fetch_followed_remotes() {

    let tmp = tempfile::tempdir().unwrap();

    let mut alice = Node::init(tmp.path(), config::relay("alice"));

    let bob = Node::init(tmp.path(), config::relay("bob"));

#[test]

fn test_missing_remote() {

    let tmp = tempfile::tempdir().unwrap();

    let mut alice = Node::init(tmp.path(), config::relay("alice"));

    let bob = Node::init(tmp.path(), config::relay("bob"));

#[test]

fn test_fetch_preserve_owned_refs() {

    let tmp = tempfile::tempdir().unwrap();

    let mut alice = Node::init(tmp.path(), config::relay("alice"));

    let bob = Node::init(tmp.path(), config::relay("bob"));

#[test]

fn test_clone() {

    let tmp = tempfile::tempdir().unwrap();

    let alice = Node::init(tmp.path(), config::relay("alice"));

    let mut bob = Node::init(tmp.path(), config::relay("bob"));

#[test]

fn test_fetch_up_to_date() {

    let tmp = tempfile::tempdir().unwrap();

    let alice = Node::init(tmp.path(), config::relay("alice"));

    let mut bob = Node::init(tmp.path(), config::relay("bob"));

#[test]

fn test_fetch_unseeded() {

    let tmp = tempfile::tempdir().unwrap();

    let alice = Node::init(tmp.path(), config::relay("alice"));

    let mut bob = Node::init(tmp.path(), config::relay("bob"));

#[test]

fn test_large_fetch() {

    let tmp = tempfile::tempdir().unwrap();

    let scale = config::scale();

    let mut alice = Node::init(tmp.path(), config::relay("alice"));

#[test]

fn test_concurrent_fetches() {

    let tmp = tempfile::tempdir().unwrap();

    let scale = config::scale();

    let repos = scale.max(4);

#[test]

fn test_connection_crossing() {

    let tmp = tempfile::tempdir().unwrap();

    let alice = Node::init(tmp.path(), config::relay("alice"));

    let bob = Node::init(tmp.path(), config::relay("bob"));

/// Alice is going to try to fetch outdated refs of Bob, from Eve. This is a non-fastfoward fetch

/// on the sigrefs branch.

fn test_non_fastforward_sigrefs() {

    let tmp = tempfile::tempdir().unwrap();

    let alice = Node::init(tmp.path(), config::relay("alice"));

#[test]

fn test_outdated_sigrefs() {

    let tmp = tempfile::tempdir().unwrap();

    let mut alice = Node::init(tmp.path(), config::relay("alice"));

#[test]

fn test_outdated_delegate_sigrefs() {

    let tmp = tempfile::tempdir().unwrap();

    let mut alice = Node::init(tmp.path(), config::relay("alice"));

#[test]

fn missing_default_branch() {

    let tmp = tempfile::tempdir().unwrap();

    let mut alice = Node::init(tmp.path(), config::relay("alice"));

    use radicle::git::raw;

    use radicle::identity::Identity;

    use radicle::storage::git::Repository;

    let tmp = tempfile::tempdir().unwrap();

    let mut alice = Node::init(tmp.path(), config::relay("alice"));

#[test]

fn test_background_foreground_fetch() {

    let tmp = tempfile::tempdir().unwrap();

    let mut alice = Node::init(tmp.path(), config::relay("alice"));

/// Alice is offline while Bob pushes some changes to the repo. When Alice reconnects,

/// she is made aware of the changes via the `subscribe` message, and fetches from the seed.

fn test_catchup_on_refs_announcements() {

    let tmp = tempfile::tempdir().unwrap();

    let mut alice = Node::init(tmp.path(), config::relay("alice"));

    let bob = Node::init(tmp.path(), config::relay("bob"));

#[test]

fn test_multiple_offline_inits() {

    let tmp = tempfile::tempdir().unwrap();

    let mut alice = Node::init(tmp.path(), config::relay("alice"));

#[test]

fn test_channel_reader_limit() {

    let tmp = tempfile::tempdir().unwrap();

    let mut alice = Node::init(tmp.path(), config::relay("alice"));

    let limits = radicle::node::config::Limits {

path = "src/git-remote-rad.rs"

[dependencies]

radicle = { workspace = true }

radicle-cli = { workspace = true }

radicle-crypto = { workspace = true }

    let mut args = env::args();

    if let Some(lvl) = radicle::logger::env_level() {

    }

    if args.nth(1).as_deref() == Some("--version") {

        if let Err(e) = VERSION.write(std::io::stdout()) {

edition.workspace = true

version = "0.9.0"

rust-version.workspace = true

\ No newline at end of file

//! Library for interaction with systemd, specialized for Radicle.

use chrono::prelude::*;

use colored::*;

/// A logger that logs to `stdout`.

pub struct Logger {

    level: Level,

}

impl Log for Logger {

    fn enabled(&self, metadata: &Metadata) -> bool {

        metadata.level() <= self.level

    fn flush(&self) {}

}

/// Get the level set by the environment variable `RUST_LOG`, if

/// present.

pub fn env_level() -> Option<Level> {

use localtime::LocalTime;

use log::*;

    level: Level,

}

impl Log for Logger {

    fn enabled(&self, metadata: &Metadata) -> bool {

        metadata.level() <= self.level

    fn flush(&self) {}

}