"crossbeam-channel",

crossbeam-channel = { version = "0.5.6" }

    use std::io::{Read, Write};

    use std::{io, net, process, thread};

    use crate::rad;

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

        let signer = MockSigner::default();

        let remote = *signer.public_key();

        let storage = Storage::open(tmp.path().join("storage")).unwrap();

        let (source, _) = fixtures::repository(&source_path);

        let (proj, _) = rad::init(

            &source,

            "radicle",

            "radicle",

            BranchName::from("master"),

            signer,

            &storage,

        )

        .unwrap();

            let repo = storage.repository(proj).unwrap();

            // NOTE: `GIT_PROTOCOL=version=2` doesn't work.

                .current_dir(repo.path())

                .arg("--strict") // The path to the git repo must be exact.

            let stream = net::TcpStream::connect(addr).unwrap();

            let mut stream_r = stream.try_clone().unwrap();

            let mut stream_w = stream.try_clone().unwrap();

            let (stream_r_send, stream_r_recv) = crossbeam_channel::unbounded::<Vec<u8>>();

            let (stream_w_send, stream_w_recv) = crossbeam_channel::unbounded::<Vec<u8>>();

            let smart = transport::smart();

            smart.insert(proj, transport::Stream::new(stream_w_send, stream_r_recv));

            let rt = thread::spawn(move || {

                let mut buf = vec![0u8; 1024];

                while let Ok(n) = stream_r.read(&mut buf) {

                    if n == 0 {

                        break;

                    }

                    stream_r_send.send(buf[..n].to_vec()).unwrap();

                }

            });

            let wt = thread::spawn(move || {

                for buf in stream_w_recv.iter() {

                    stream_w.write_all(&buf).unwrap();

                }

            });

                .remote_anonymous(&format!("rad://{}", proj))

            smart.remove(&proj);

            stream.shutdown(net::Shutdown::Both).unwrap();

            wt.join().unwrap();

            rt.join().unwrap();

        assert_eq!(

            updates,

            vec![

                format!("refs/remotes/{remote}/heads/master"),

                format!("refs/remotes/{remote}/heads/radicle/id"),

                format!("refs/remotes/{remote}/radicle/signature")

            ]

        );

//! Git sub-transport used for fetching radicle data.

//!

//! To have control over the communication, and to allow git streams to be multiplexed over

//! existing TCP connections, we implement the [`git2::transport::SmartSubtransport`] trait.

//!

//! We choose `rad` as the URL scheme for this custom transport, and include only the identity

//! of the repository we're looking to fetch, eg. `rad://zP1GztjSdYNHK7jpdrXbaJ6Ki2Ke`, since

//! we expect a connection to a host to already be established.

//!

//! We then maintain a map from identifier to stream, for all active streams, ie. streams that

//! are associated with an underlying TCP connection. When a URL is requested, we lookup

//! the stream and return it to the [`git2`] smart-protocol implementation, so that it can carry

//! out the git smart protocol.

//!

//! This module is meant to be used by first registering our transport with [`register`] and then

//! adding or removing streams through [`Smart`], which can be obtained by calling [`smart`].

use std::collections::HashMap;

use std::io;

use std::sync::{Arc, Mutex};

use crossbeam_channel as chan;

use once_cell::sync::Lazy;

use crate::identity::Id;

/// The map of git smart sub-transport streams. We keep a global map because we have

/// no control over how [`git2::transport::register`] instantiates our [`Smart`] transport

/// or its underlying streams.

static STREAMS: Lazy<Arc<Mutex<HashMap<Id, Stream>>>> = Lazy::new(Default::default);

/// Git transport protocol over an I/O stream.

#[derive(Clone)]

pub struct Smart {

    /// The underlying active streams, keyed by repository identifier.

    streams: Arc<Mutex<HashMap<Id, Stream>>>,

}

impl Smart {

    pub fn get(&self, id: &Id) -> Option<Stream> {

        self.streams.lock().unwrap().get(id).cloned()

    }

    pub fn insert(&self, id: Id, stream: Stream) {

        self.streams.lock().unwrap().insert(id, stream);

    }

    pub fn remove(&self, id: &Id) {

        self.streams.lock().unwrap().remove(id);

    }

}

    /// Run a git service on this transport.

    ///

    /// Based on the URL, which must be of the form `rad://zP1GztjSdYNHK7jpdrXbaJ6Ki2Ke`,

    /// we retrieve an underlying stream and return it.

    ///

    /// We only support the upload-pack service, since only fetches are authorized by the

    /// remote.

        let id = Id::from_str(url.host.unwrap_or_default().as_str())

            .map_err(|_| git2::Error::from_str("Git URL does not contain a valid project id"))?;

        if url.scheme != git::url::Scheme::Radicle {

            return Err(git2::Error::from_str("Git URL scheme must be `rad`"));

        }

        if let Some(stream) = self.get(&id) {

            match action {

                git2::transport::Service::UploadPackLs => {}

                git2::transport::Service::UploadPack => {}

                git2::transport::Service::ReceivePack => {

                    return Err(git2::Error::from_str(

                        "git-receive-pack is not supported with the custom transport",

                    ));

                }

                git2::transport::Service::ReceivePackLs => {

                    return Err(git2::Error::from_str(

                        "git-receive-pack is not supported with the custom transport",

                    ));

                }

            Ok(Box::new(stream))

        } else {

            Err(git2::Error::from_str(&format!(

                "repository {id} does not have an associated stream"

            )))

/// A byte stream connected to some I/O source.

/// One of these is created for every git operation, eg. `fetch`.

#[derive(Clone)]

pub struct Stream {

    /// Send bytes to the network.

    send: chan::Sender<Vec<u8>>,

    /// Receive bytes from the network.

    recv: chan::Receiver<Vec<u8>>,

    /// Bytes read from the receive channel that didn't fit in the read buffer.

    pending: Vec<u8>,

}

impl Stream {

    /// Create a new stream from a sender and receiver.

    pub fn new(send: chan::Sender<Vec<u8>>, recv: chan::Receiver<Vec<u8>>) -> Self {

        Self {

            send,

            recv,

            pending: Vec::new(),

        }

    }

        self.send

            .send(buf.to_owned())

            .map_err(|e| io::Error::new(io::ErrorKind::BrokenPipe, e))?;

        Ok(buf.len())

    fn flush(&mut self) -> io::Result<()> {

        Ok(())

        let bytes = self

            .recv

            .recv()

            .map_err(|e| io::Error::new(io::ErrorKind::BrokenPipe, e))?;

        self.pending.extend(&bytes);

        // There must be a nicer way to do this...

        let count = buf.len().min(self.pending.len());

        buf[..count].copy_from_slice(&self.pending[..count]);

        self.pending.drain(..count);

        Ok(count)

/// Register the radicle transport with `git`.

///

/// Returns an error if called more than once.

///

    // Registration is not thread-safe, so make sure we prevent re-entrancy.

                git2::transport::Transport::smart(remote, false, self::smart())

/// Get access to the radicle smart transport protocol.

///

/// The returned object has mutable access to the underlying stream map, and is safe to clone.

///

pub fn smart() -> Smart {

    Smart {

        streams: STREAMS.clone(),

    }

}