pmeunier/elpe - Change LIMIMBOUN3DCIKKTHOK4TAXAWQXNVQXBTMNZYN22DJX4L4FZQH4AC

Bootstrapping the Rust part

Created by pmeunier on July 26, 2025

LIMIMBOUN3DCIKKTHOK4TAXAWQXNVQXBTMNZYN22DJX4L4FZQH4AC

Dependencies

In channels

main

Change contents

File addition: server.rs (----------)

[7.15]

use elpe::extract::*;
use elpe::*;
use std::sync::Arc;
use tokio::io::AsyncWriteExt;
use tokio_stream::wrappers::ReceiverStream;
use tokio_util::sync::PollSender;
use tonic::codegen::tokio_stream::StreamExt;
use tracing::*;
pub struct Elpe {
    deb_client: elpe::Client,
    sender: tokio::sync::mpsc::UnboundedSender<(
        crate::container::BuildRequest,
        tokio::sync::mpsc::Sender<crate::container::Msg>,
    )>,
    t: Option<tokio::task::JoinHandle<Result<(), elpe::Error>>>,
}
pub mod proto {
    tonic::include_proto!("elpe");
}
impl Elpe {
    pub fn new(
        deb_client: elpe::Client,
        container_channel: elpe::container::ContainerChannel,
    ) -> Self {
        let (sender, receiver) = tokio::sync::mpsc::unbounded_channel::<(
            crate::container::BuildRequest,
            tokio::sync::mpsc::Sender<crate::container::Msg>,
        )>();
        let t = tokio::spawn(crate::container::forward(receiver, container_channel));
        Elpe {
            deb_client,
            sender,
            t: Some(t),
        }
    }
    pub async fn serve(mut self, addr: std::net::SocketAddr) {
        let t = self.t.take().unwrap();
        tokio::select! {
        _ =         tonic::transport::Server::builder()
            .add_service(proto::elpe_server::ElpeServer::new(self))
            .serve(addr)
            => {}
        _ = t => {}
           }
    }
}
use std::pin::Pin;
type ResponseStream =
    Pin<Box<dyn tokio_stream::Stream<Item = Result<proto::DerivationReply, tonic::Status>> + Send>>;
#[tonic::async_trait]
impl proto::elpe_server::Elpe for Elpe {
    async fn add_path(
        &self,
        request: tonic::Request<tonic::Streaming<proto::AddPathRequest>>,
    ) -> Result<tonic::Response<proto::DerivationReply>, tonic::Status> {
        let mut r = request.into_inner();
        debug!("add_path");
        let mut current_file = None;
        let ref store = self.deb_client.store_path();
        debug!("store");
        let tmp_dir = tempfile::tempdir_in(store).unwrap();
        debug!("store {:?}", tmp_dir);
        let mut hasher = blake3::Hasher::new();
        debug!("loop");
        loop {
            trace!("waiting for next in stream");
            let Some(r) = r.next().await else { break };
            let r = r.unwrap();
            match r.request {
                Some(proto::add_path_request::Request::File(f)) => {
                    info!("Adding file {:?}", f.name);
                    hasher.update(b"\0f");
                    hasher.update(f.name.as_bytes());
                    hasher.update(b"\0");
                    let p = tmp_dir.path().join(&f.name);
                    tokio::fs::create_dir_all(p.parent().unwrap()).await?;
                    current_file = Some(tokio::fs::File::create(&p).await?)
                }
                Some(proto::add_path_request::Request::Directory(d)) => {
                    info!("Adding file {:?}", d.name);
                    hasher.update(b"\0d");
                    hasher.update(d.name.as_bytes());
                    hasher.update(b"\0");
                    let p = tmp_dir.path().join(&d.name);
                    tokio::fs::create_dir_all(&p).await.unwrap();
                }
                Some(proto::add_path_request::Request::Contents(c)) => {
                    hasher.update(&c.content);
                    current_file.as_mut().unwrap().write_all(&c.content).await?;
                }
                None => break,
            }
        }
        debug!("loop done");
        let path = store.join(data_encoding::HEXLOWER.encode(hasher.finalize().as_bytes()));
        use tokio::io::ErrorKind;
        let new = tmp_dir.into_path();
        match tokio::fs::rename(&new, &path).await {
            Ok(()) => (),
            Err(e) if e.kind() == ErrorKind::DirectoryNotEmpty => (),
            Err(e) => {
                tokio::fs::remove_dir_all(&new).await?;
                return Err(e.into());
            }
        }
        info!("add_path extracted to {:?}", path);
        Ok(tonic::Response::new(proto::DerivationReply {
            result: Some(proto::derivation_reply::Result::Ok(
                proto::DerivationResult {
                    destdir: vec![path.to_str().unwrap().to_string()],
                    paths: Vec::new(),
                    path_patterns: Vec::new(),
                },
            )),
        }))
    }
    type DerivationStream = ResponseStream;
    async fn derivation(
        &self,
        request: tonic::Request<proto::DerivationRequest>,
    ) -> Result<tonic::Response<ResponseStream>, tonic::Status> {
        debug!("derivation request");
        let now = std::time::Instant::now();
        let r = request.into_inner();
        let (tx, rx) = tokio::sync::mpsc::channel(200);
        debug!("derivation request: {:?} {:?}", r.name, r.paths);
        self.sender
            .send((
                crate::container::BuildRequest {
                    name: r.name.clone(),
                    paths: r.paths,
                    script: r.builder,
                    target: r.target,
                    output_hash: r.output_hash,
                },
                tx,
            ))
            .unwrap();
        use crate::container::Msg;
        let output_stream = ReceiverStream::new(rx).map(|x| {
            Ok(match x {
                Msg::Ok(out) => proto::DerivationReply {
                    result: Some(proto::derivation_reply::Result::Ok(
                        proto::DerivationResult {
                            destdir: out
                                .into_iter()
                                .map(|x| x.to_str().unwrap().to_string())
                                .collect(),
                            paths: Vec::new(),
                            path_patterns: Vec::new(),
                        },
                    )),
                },
                Msg::Error(p) => proto::DerivationReply {
                    result: Some(proto::derivation_reply::Result::Error(p)),
                },
                Msg::Stdout(p) => proto::DerivationReply {
                    result: Some(proto::derivation_reply::Result::Stdout(p)),
                },
                Msg::Stderr(p) => proto::DerivationReply {
                    result: Some(proto::derivation_reply::Result::Stderr(p)),
                },
            })
        });
        info!("request {:?}: {:?}", r.name, now.elapsed());
        Ok(tonic::Response::new(Box::pin(output_stream)))
    }
    async fn add_url(
        &self,
        request: tonic::Request<proto::AddUrlRequest>,
    ) -> Result<tonic::Response<proto::DerivationReply>, tonic::Status> {
        let r = request.into_inner();
        debug!("add_url request {:?}", r);
        let p = self
            .deb_client
            .http_download(
                &r.url,
                match r.hash_algorithm {
                    0 => {
                        let mut h = [0; 32];
                        h.clone_from_slice(&r.hash);
                        Hash::Blake3(h)
                    }
                    1 => {
                        let mut h = [0; 32];
                        h.clone_from_slice(&r.hash);
                        Hash::Sha256(h)
                    }
                    2 => {
                        let mut h = [0; 64];
                        h.clone_from_slice(&r.hash);
                        Hash::Sha512(h)
                    }
                    _ => unreachable!(),
                },
            )
            .await
            .unwrap();
        Ok(tonic::Response::new(proto::DerivationReply {
            result: Some(proto::derivation_reply::Result::Ok(
                proto::DerivationResult {
                    destdir: vec![p.to_str().unwrap().to_string()],
                    paths: Vec::new(),
                    path_patterns: Vec::new(),
                },
            )),
        }))
    }
    async fn ubuntu_release(
        &self,
        request: tonic::Request<proto::UbuntuReleaseRequest>,
    ) -> Result<tonic::Response<proto::DerivationReply>, tonic::Status> {
        debug!("ubuntu release {:?}", request);
        let now = std::time::Instant::now();
        let r = request.into_inner();
        let h = self.deb_client.in_release(r.release.clone()).await.unwrap();
        let arch = match r.arch {
            0 => "amd64",
            1 => "aarch64",
            _ => unreachable!(),
        };
        let p = self
            .deb_client
            .packages(&h, &r.repository, arch)
            .await
            .unwrap();
        info!(
            "ubuntu release request {:?}: {:?}",
            r.release,
            now.elapsed()
        );
        Ok(tonic::Response::new(proto::DerivationReply {
            result: Some(proto::derivation_reply::Result::Ok(
                proto::DerivationResult {
                    destdir: vec![p.to_str().unwrap().to_string()],
                    paths: Vec::new(),
                    path_patterns: Vec::new(),
                },
            )),
        }))
    }
    type UbuntuPackageStream = ResponseStream;
    async fn ubuntu_package(
        &self,
        request: tonic::Request<proto::UbuntuPackageRequest>,
    ) -> Result<tonic::Response<Self::UbuntuPackageStream>, tonic::Status> {
        let now = std::time::Instant::now();
        let r = request.into_inner();
        let index: Result<Vec<_>, _> = r
            .index
            .into_iter()
            .map(|index| deb::Index::open(&index))
            .collect();
        let index = index.unwrap();
        let link_extra: Vec<_> = r
            .link_extra
            .into_iter()
            .map(|l| {
                (
                    regex::Regex::new(&l.pkg).unwrap(),
                    regex::Regex::new(&l.dep).unwrap(),
                )
            })
            .collect();
        let (tx, rx) = tokio::sync::mpsc::channel(200);
        use crate::extract::Msg;
        let output_stream = ReceiverStream::new(rx).map(|x| {
            Ok(match x {
                Msg::Downloading(p) => proto::DerivationReply {
                    result: Some(proto::derivation_reply::Result::Loading(p)),
                },
                Msg::Ok(p) => proto::DerivationReply {
                    result: Some(proto::derivation_reply::Result::Ok(
                        proto::DerivationResult {
                            destdir: p
                                .result
                                .iter()
                                .rev()
                                .map(|x| x.to_str().unwrap().to_string())
                                .collect(),
                            paths: p.paths.into_iter().filter_map(Arc::into_inner).collect(),
                            path_patterns: Vec::new(),
                        },
                    )),
                },
                Msg::Error(e) => proto::DerivationReply {
                    result: Some(proto::derivation_reply::Result::Error(e.to_string())),
                },
            })
        });
        match download_extract_deps(
            &index,
            &self.deb_client,
            &r.name,
            &link_extra,
            PollSender::new(tx.clone()),
        )
        .await
        {
            Ok(p) => {
                info!("path {:?} {:#?}", r.name, p);
                tx.send(Msg::Ok(p)).await.unwrap();
            }
            Err(e) => tx.send(Msg::Error(e)).await.unwrap(),
        }
        info!("ubuntu package request {:?}: {:?}", r.name, now.elapsed());
        Ok(tonic::Response::new(Box::pin(output_stream)))
    }
}

Deletion in src/main.rs at line 2 [7.1363]
∅:D[8.286] → [9.1489:1511]
B:BD[7.1363] → [9.1489:1511]
```
use elpe::extract::*;
```
Deletion in src/main.rs at line 5 [7.1363]
∅:D[8.332] → [7.1421:1441]
∅:D[9.1556] → [7.1421:1441]
B:BD[7.1421] → [7.1421:1441]
B:BD[7.1441] → [9.1557:1587]
B:BD[9.1587] → [10.0:44]
B:BD[10.44] → [4.0:34]
∅:D[4.34] → [9.1587:1632]
∅:D[10.44] → [9.1587:1632]
B:BD[9.1587] → [9.1587:1632]
∅:D[9.1632] → [7.1441:1457]
B:BD[7.1441] → [7.1441:1457]
```
use std::sync::Arc;
use tokio::io::AsyncWriteExt;
use tokio_stream::wrappers::ReceiverStream;
use tokio_util::sync::PollSender;
use tonic::codegen::tokio_stream::StreamExt;
use tracing::*;
```
Deletion in src/main.rs at line 6 [7.1363]
B:BD[7.1586] → [7.1586:1640]
```
pub mod proto {
    tonic::include_proto!("elpe");
}
```
Replacement in src/main.rs at line 7 [7.1363]
B:BD[7.1641] → [7.1641:1659]
B:BD[7.1659] → [9.1633:1752]
B:BD[9.1752] → [10.45:103]
∅:D[10.103] → [9.1815:1823]
B:BD[9.1815] → [9.1815:1823]
∅:D[9.1823] → [7.1694:1696]
B:BD[7.1694] → [7.1694:1696]
```
pub struct Elpe {
    deb_client: elpe::Client,
    sender: tokio::sync::mpsc::UnboundedSender<(
        crate::container::BuildRequest,
        tokio::sync::mpsc::Sender<crate::container::Msg>,
    )>,
}
```
[7.1641]
[10.104]
```
mod server;
```

Deletion in src/main.rs at line 9 [7.1363]

B:BD[10.105] → [10.105:248]

∅:D[10.248] → [7.1711:1775]

B:BD[7.1711] → [7.1711:1775]

B:BD[7.1775] → [9.1824:1847]

∅:D[9.1847] → [7.1800:1815]

B:BD[7.1800] → [7.1800:1815]

B:BD[7.1815] → [9.1848:2038]

B:BD[9.2038] → [4.35:63]

∅:D[4.63] → [9.2038:2075]

B:BD[9.2038] → [9.2038:2075]

B:BD[9.2075] → [8.333:387]

B:BD[8.387] → [4.64:188]

∅:D[4.188] → [9.2179:2228]

B:BD[9.2179] → [9.2179:2228]

B:BD[9.2228] → [4.189:213]

∅:D[4.213] → [9.2229:2482]

B:BD[7.2001] → [9.2229:2482]

B:BD[9.2482] → [4.214:269]

∅:D[4.269] → [9.2482:2922]

B:BD[9.2482] → [9.2482:2922]

B:BD[9.2922] → [4.270:325]

∅:D[4.325] → [9.2922:3477]

B:BD[9.2922] → [9.2922:3477]

B:BD[9.3477] → [4.326:355]

∅:D[4.355] → [9.3477:4356]

B:BD[9.3477] → [9.3477:4356]

B:BD[9.4356] → [10.249:294]

∅:D[10.294] → [9.4356:4456]

B:BD[9.4356] → [9.4356:4456]

B:BD[9.4456] → [10.295:361]

∅:D[10.361] → [9.4530:4606]

B:BD[9.4530] → [9.4530:4606]

B:BD[9.4606] → [10.362:418]

∅:D[10.418] → [9.4662:4898]

B:BD[9.4662] → [9.4662:4898]

B:BD[9.4898] → [11.0:48]

∅:D[11.48] → [9.4898:4975]

B:BD[9.4898] → [9.4898:4975]

B:BD[9.4975] → [10.419:718]

B:BD[10.718] → [2.0:204]

∅:D[2.204] → [10.796:1519]

B:BD[10.796] → [10.796:1519]

∅:D[10.1519] → [7.2198:2205]

∅:D[9.5566] → [7.2198:2205]

B:BD[7.2198] → [7.2198:2205]

B:BD[7.2205] → [2.205:1636]

∅:D[2.1636] → [7.2205:2249]

B:BD[7.2205] → [7.2205:2249]

B:BD[7.2249] → [9.5567:5703]

∅:D[9.5703] → [7.2371:2850]

B:BD[7.2371] → [7.2371:2850]

B:BD[7.2850] → [9.5704:5997]

∅:D[9.5997] → [7.2932:2951]

B:BD[7.2932] → [7.2932:2951]

B:BD[7.2951] → [4.356:404]

∅:D[4.404] → [7.2951:2995]

B:BD[7.2951] → [7.2951:2995]

B:BD[7.2995] → [9.5998:6060]

B:BD[9.6060] → [4.405:482]

∅:D[4.482] → [7.3117:3392]

∅:D[9.6134] → [7.3117:3392]

B:BD[7.3117] → [7.3117:3392]

B:BD[7.3392] → [12.0:1]

B:BD[12.1] → [13.0:294]

B:BD[13.294] → [4.483:803]

∅:D[4.803] → [9.6646:6665]

B:BD[9.6646] → [9.6646:6665]

B:BD[9.6665] → [4.804:2149]

∅:D[4.2149] → [7.4845:4851]

B:BD[7.4845] → [7.4845:4851]

B:BD[7.4851] → [8.388:391]

use std::pin::Pin;
type ResponseStream =
    Pin<Box<dyn tokio_stream::Stream<Item = Result<proto::DerivationReply, tonic::Status>> + Send>>;
#[tonic::async_trait]
impl proto::elpe_server::Elpe for Elpe {
    async fn add_path(
        &self,
        request: tonic::Request<tonic::Streaming<proto::AddPathRequest>>,
    ) -> Result<tonic::Response<proto::DerivationReply>, tonic::Status> {
        let mut r = request.into_inner();
        debug!("add_path");
        let mut current_file = None;
        let ref store = self.deb_client.store_path();
        debug!("store");
        let tmp_dir = tempfile::tempdir_in(store).unwrap();
        debug!("store {:?}", tmp_dir);
        let mut hasher = blake3::Hasher::new();
        debug!("loop");
        loop {
            trace!("waiting for next in stream");
            let Some(r) = r.next().await else { break };
            let r = r.unwrap();
            match r.request {
                Some(proto::add_path_request::Request::File(f)) => {
                    info!("Adding file {:?}", f.name);
                    hasher.update(b"\0f");
                    hasher.update(f.name.as_bytes());
                    hasher.update(b"\0");
                    let p = tmp_dir.path().join(&f.name);
                    tokio::fs::create_dir_all(p.parent().unwrap()).await?;
                    current_file = Some(tokio::fs::File::create(&p).await?)
                }
                Some(proto::add_path_request::Request::Directory(d)) => {
                    info!("Adding file {:?}", d.name);
                    hasher.update(b"\0d");
                    hasher.update(d.name.as_bytes());
                    hasher.update(b"\0");
                    let p = tmp_dir.path().join(&d.name);
                    tokio::fs::create_dir_all(&p).await.unwrap();
                }
                Some(proto::add_path_request::Request::Contents(c)) => {
                    hasher.update(&c.content);
                    current_file.as_mut().unwrap().write_all(&c.content).await?;
                }
                None => break,
            }
        }
        debug!("loop done");
        let path = store.join(data_encoding::HEXLOWER.encode(hasher.finalize().as_bytes()));
        use tokio::io::ErrorKind;
        let new = tmp_dir.into_path();
        match tokio::fs::rename(&new, &path).await {
            Ok(()) => (),
            Err(e) if e.kind() == ErrorKind::DirectoryNotEmpty => (),
            Err(e) => {
                tokio::fs::remove_dir_all(&new).await?;
                return Err(e.into());
            }
        }
        info!("add_path extracted to {:?}", path);
        Ok(tonic::Response::new(proto::DerivationReply {
            result: Some(proto::derivation_reply::Result::Ok(
                proto::DerivationResult {
                    destdir: vec![path.to_str().unwrap().to_string()],
                    paths: Vec::new(),
                    path_patterns: Vec::new(),
                },
            )),
        }))
    }
    type DerivationStream = ResponseStream;
    async fn derivation(
        &self,
        request: tonic::Request<proto::DerivationRequest>,
    ) -> Result<tonic::Response<ResponseStream>, tonic::Status> {
        debug!("derivation request");
        let r = request.into_inner();
        let (tx, rx) = tokio::sync::mpsc::channel(200);
        self.sender
            .send((
                crate::container::BuildRequest {
                    name: r.name,
                    paths: r.paths,
                    script: r.builder,
                    target: r.target,
                    output_hash: r.output_hash,
                },
                tx,
            ))
            .unwrap();
        use crate::container::Msg;
        let output_stream = ReceiverStream::new(rx).map(|x| {
            Ok(match x {
                Msg::Ok(out) => proto::DerivationReply {
                    result: Some(proto::derivation_reply::Result::Ok(
                        proto::DerivationResult {
                            destdir: out
                                .into_iter()
                                .map(|x| x.to_str().unwrap().to_string())
                                .collect(),
                            paths: Vec::new(),
                            path_patterns: Vec::new(),
                        },
                    )),
                },
                Msg::Error(p) => proto::DerivationReply {
                    result: Some(proto::derivation_reply::Result::Error(p)),
                },
                Msg::Stdout(p) => proto::DerivationReply {
                    result: Some(proto::derivation_reply::Result::Stdout(p)),
                },
                Msg::Stderr(p) => proto::DerivationReply {
                    result: Some(proto::derivation_reply::Result::Stderr(p)),
                },
            })
        });
        Ok(tonic::Response::new(Box::pin(output_stream)))
    }
    async fn add_url(
        &self,
        request: tonic::Request<proto::AddUrlRequest>,
    ) -> Result<tonic::Response<proto::DerivationReply>, tonic::Status> {
        let r = request.into_inner();
        debug!("add_url request {:?}", r);
        let p = self
            .deb_client
            .http_download(
                &r.url,
                match r.hash_algorithm {
                    0 => {
                        let mut h = [0; 32];
                        h.clone_from_slice(&r.hash);
                        Hash::Blake3(h)
                    }
                    1 => {
                        let mut h = [0; 32];
                        h.clone_from_slice(&r.hash);
                        Hash::Sha256(h)
                    }
                    2 => {
                        let mut h = [0; 64];
                        h.clone_from_slice(&r.hash);
                        Hash::Sha512(h)
                    }
                    _ => unreachable!(),
                },
            )
            .await
            .unwrap();
        Ok(tonic::Response::new(proto::DerivationReply {
            result: Some(proto::derivation_reply::Result::Ok(
                proto::DerivationResult {
                    destdir: vec![p.to_str().unwrap().to_string()],
                    paths: Vec::new(),
                    path_patterns: Vec::new(),
                },
            )),
        }))
    }
    async fn ubuntu_release(
        &self,
        request: tonic::Request<proto::UbuntuReleaseRequest>,
    ) -> Result<tonic::Response<proto::DerivationReply>, tonic::Status> {
        debug!("ubuntu release {:?}", request);
        let r = request.into_inner();
        let h = self.deb_client.in_release(r.release).await.unwrap();
        let arch = match r.arch {
            0 => "amd64",
            1 => "aarch64",
            _ => unreachable!(),
        };
        let p = self
            .deb_client
            .packages(&h, &r.repository, arch)
            .await
            .unwrap();
        Ok(tonic::Response::new(proto::DerivationReply {
            result: Some(proto::derivation_reply::Result::Ok(
                proto::DerivationResult {
                    destdir: vec![p.to_str().unwrap().to_string()],
                    paths: Vec::new(),
                    path_patterns: Vec::new(),
                },
            )),
        }))
    }
    type UbuntuPackageStream = ResponseStream;
    async fn ubuntu_package(
        &self,
        request: tonic::Request<proto::UbuntuPackageRequest>,
    ) -> Result<tonic::Response<Self::UbuntuPackageStream>, tonic::Status> {
        debug!("request {:?}", request);
        let r = request.into_inner();
        let index: Result<Vec<_>, _> = r
            .index
            .into_iter()
            .map(|index| deb::Index::open(&index))
            .collect();
        let index = index.unwrap();
        let link_extra: Vec<_> = r
            .link_extra
            .into_iter()
            .map(|l| {
                (
                    regex::Regex::new(&l.pkg).unwrap(),
                    regex::Regex::new(&l.dep).unwrap(),
                )
            })
            .collect();
        let (tx, rx) = tokio::sync::mpsc::channel(200);
        use crate::extract::Msg;
        let output_stream = ReceiverStream::new(rx).map(|x| {
            Ok(match x {
                Msg::Downloading(p) => proto::DerivationReply {
                    result: Some(proto::derivation_reply::Result::Loading(p)),
                },
                Msg::Ok(p) => proto::DerivationReply {
                    result: Some(proto::derivation_reply::Result::Ok(
                        proto::DerivationResult {
                            destdir: p
                                .result
                                .iter()
                                .rev()
                                .map(|x| x.to_str().unwrap().to_string())
                                .collect(),
                            paths: p.paths.into_iter().filter_map(Arc::into_inner).collect(),
                            path_patterns: Vec::new(),
                        },
                    )),
                },
                Msg::Error(e) => proto::DerivationReply {
                    result: Some(proto::derivation_reply::Result::Error(e.to_string())),
                },
            })
        });
        match download_extract_deps(
            &index,
            &self.deb_client,
            &r.name,
            &link_extra,
            PollSender::new(tx.clone()),
        )
        .await
        {
            Ok(p) => {
                info!("path {:?} {:#?}", r.name, p);
                tx.send(Msg::Ok(p)).await.unwrap();
            }
            Err(e) => tx.send(Msg::Error(e)).await.unwrap(),
        }
        Ok(tonic::Response::new(Box::pin(output_stream)))
    }
}

Deletion in src/main.rs at line 47 [7.1363]

B:BD[8.1043] → [8.1043:1044]

∅:D[8.1044] → [9.7101:7219]

B:BD[9.7101] → [9.7101:7219]

B:BD[9.7219] → [10.1520:1582]

∅:D[10.1582] → [9.7286:7300]

B:BD[9.7286] → [9.7286:7300]


        let (sender, receiver) = tokio::sync::mpsc::unbounded_channel::<(
            crate::container::BuildRequest,
            tokio::sync::mpsc::Sender<crate::container::Msg>,
        )>();

Replacement in src/main.rs at line 48 [7.1363]

B:BD[7.8639] → [9.7301:7387]

        let t = tokio::spawn(crate::container::forward(receiver, container_channel));

[7.8639]

[7.8830]

        let elpe = server::Elpe::new(
            Client::new(&config.pgp_home, &config.store_path, &config.package_index),
            container_channel,
        );

Deletion in src/main.rs at line 53 [7.1363]
B:BD[7.8831] → [9.7388:7414]
B:BD[9.7414] → [8.1045:1143]
∅:D[8.1143] → [9.7502:7533]
B:BD[9.7502] → [9.7502:7533]
∅:D[9.7533] → [7.9063:9064]
B:BD[7.9063] → [7.9063:9064]
```
        let elpe = Elpe {
            deb_client: Client::new(&config.pgp_home, &config.store_path, &config.package_index),
            sender,
        };
```

Replacement in src/main.rs at line 54 [7.1363]

B:BD[9.7792] → [9.7792:8026]

        tokio::select! {
            _ = tonic::transport::Server::builder()
                .add_service(proto::elpe_server::ElpeServer::new(elpe))
                .serve(addr)
                => {}
            _ = t => {}
        }

[9.7792]

[9.8026]

        elpe.serve(addr).await

Insertion in src/container.rs at line 5 [9.44692]
[9.44835]
[10.1669]
```
use std::os::fd::OwnedFd;
```

Replacement in src/container.rs at line 80 [9.44692]

B:BD[9.46666] → [9.46666:46727]

                debug!("received process response {:?}", x);

[9.46666]

[9.46727]

                info!("received process response {:?}", x);

Replacement in src/container.rs at line 86 [9.44692]

B:BD[10.2385] → [10.2385:2450]

                            chan.send(resp).await.unwrap_or(());

[10.2385]

[10.2450]

                            chan.send(resp).await.unwrap();

Replacement in src/container.rs at line 90 [9.44692]

B:BD[10.2573] → [10.2573:2638]

                            chan.send(resp).await.unwrap_or(());

[10.2573]

[10.2638]

                            chan.send(resp).await.unwrap();

Insertion in src/container.rs at line 141 [9.44692]
[9.48764]
[9.48764]
```
    let mut n = 0;
```

Replacement in src/container.rs at line 153 [9.44692]

B:BD[9.49250] → [10.2687:2863]

            let (writer_out, mut reader_out) = tokio::net::unix::pipe::pipe().unwrap();
            let (writer_err, mut reader_err) = tokio::net::unix::pipe::pipe().unwrap();

[9.49250]

            let m = n;
            n += 1;

Insertion in src/container.rs at line 156 [9.44692]

[9.49288]

[10.2864]

                let (reader_out, writer_out) = std::io::pipe().unwrap();
                let (reader_err, writer_err) = std::io::pipe().unwrap();
                let reader_out_fd = reader_out.as_raw_fd();
                let reader_err_fd = reader_err.as_raw_fd();
                let writer_out_fd = writer_out.as_raw_fd();
                let writer_err_fd = writer_err.as_raw_fd();

Replacement in src/container.rs at line 163 [9.44692]

B:BD[10.2929] → [10.2929:2967]

                    run_in_container(

[10.2929]

[10.2967]

                    let writer_out_fd: OwnedFd = writer_out.into();
                    let writer_err_fd: OwnedFd = writer_err.into();
                    info!("run_in_container {}: {}", m, rec_msg.script);
                    let result = run_in_container(
                        m,

Replacement in src/container.rs at line 171 [9.44692]

B:BD[10.3063] → [10.3063:3159]

                        writer_out.as_raw_fd(),
                        writer_err.as_raw_fd(),

[10.3063]

[10.3159]

                        reader_out_fd,
                        writer_out_fd,
                        reader_err_fd,
                        writer_err_fd,

Replacement in src/container.rs at line 176 [9.44692]

B:BD[10.3181] → [10.3181:3234]

                    .map_err(|e| format!("{:?}", e))

[10.3181]

[10.3234]

                    .map_err(|e| format!("{:?}", e));
                    info!("run_in_container {}: done", m);
                    result

Insertion in src/container.rs at line 182 [9.44692]

[10.3290]

                let mut reader_out =
                    tokio::net::unix::pipe::Receiver::from_owned_fd(reader_out.into()).unwrap();
                let mut reader_err =
                    tokio::net::unix::pipe::Receiver::from_owned_fd(reader_err.into()).unwrap();

Insertion in src/container.rs at line 193 [9.44692]

[10.3590]

                    info!(
                        "waiting for run_in_container {} {:?} {:?}",
                        m, stdout_closed, stderr_closed
                    );

Insertion in src/container.rs at line 217 [9.44692]

[10.4882]

                            } else {
                                stdout_closed = true

Insertion in src/container.rs at line 233 [9.44692]

[10.5827]

                            } else {
                                stderr_closed = true

Insertion in src/container.rs at line 237 [9.44692]

[10.5883]

                        _ = tokio::time::sleep(std::time::Duration::from_secs(10)) => {info!("Still waiting for {}", m)}

Replacement in src/container.rs at line 243 [9.44692]

B:BD[9.49630] → [9.49630:49692]

                debug!("drv_process replying {:?}", v.len());

[9.49630]

[9.49692]

                info!("drv_process {} replying {:?}", m, v.len());

Insertion in src/container.rs at line 246 [9.44692]
[10.6126]
[9.49807]
```
                info!("sent {}", m);
```
Insertion in src/container.rs at line 254 [9.44692]
[10.6148]
[10.6148]
```
    m: usize,
```

Replacement in src/container.rs at line 258 [9.44692]

B:BD[10.6203] → [10.6203:6241]

    stdout: RawFd,
    stderr: RawFd,

[10.6203]

[14.75]

    stdout_r: RawFd,
    stdout: OwnedFd,
    stderr_r: RawFd,
    stderr: OwnedFd,

Insertion in src/container.rs at line 272 [9.44692]
[5.105]
[9.50195]
```
    debug!("{}", r.script);
```
Insertion in src/container.rs at line 285 [9.44692]
[9.50538]
[9.50538]
```
        drop(stdout);
        drop(stderr);
```
Insertion in src/container.rs at line 297 [9.44692]
[9.50931]
[14.114]
```
        info!("{} returning early", m);
```
Insertion in src/container.rs at line 321 [9.44692]
[15.171]
[9.51447]
```
    info!("clone {}", m);
```

Insertion in src/container.rs at line 342 [9.44692]

[9.52049]

        unsafe {
            if libc::close(stdout_r) != 0 {
                error!("couldn't close");
                return Err(std::io::Error::last_os_error().into());
            }
            if libc::close(stderr_r) != 0 {
                error!("couldn't close");
                return Err(std::io::Error::last_os_error().into());
            }
        }

Replacement in src/container.rs at line 354 [9.44692]

B:BD[10.6299] → [10.6299:6385]

                user, &r, &tmp_dir, &dest, &store, &tmp_store, &name, stdout, stderr,

[10.6299]

[10.6385]

                user,
                &r,
                &tmp_dir,
                &dest,
                &store,
                &tmp_store,
                &name,
                stdout.as_raw_fd(),
                stderr.as_raw_fd(),

Replacement in src/container.rs at line 376 [9.44692]

B:BD[9.52411] → [9.52411:52438]

        debug!("waitpid");

[9.52411]

[9.52438]

        drop(stdout);
        drop(stderr);
        info!("waitpid {}", m);

Replacement in src/container.rs at line 381 [9.44692]

B:BD[9.52528] → [9.52528:52573]

        info!("return status {:?}", status);

[9.52528]

[9.52702]

        info!("{} return status {:?}", m, status);

Insertion in src/container.rs at line 395 [9.44692]

[3.174]

            std::fs::remove_dir_all(&dest).unwrap_or(());

Replacement in src/container.rs at line 540 [9.44692]
B:BD[9.57164] → [10.6400:6438]
```
    stdout: RawFd,
    stderr: RawFd,
```
[9.57164]
[9.57164]
```
    stdout_w: RawFd,
    stderr_w: RawFd,
```

Replacement in src/container.rs at line 662 [9.44692]

B:BD[10.6456] → [14.467:520]

            if libc::dup2(stdout, this_stdout) < 0 {

[10.6456]

[14.520]

            if libc::dup2(stdout_w, this_stdout) < 0 {

Replacement in src/container.rs at line 665 [9.44692]

B:BD[14.602] → [14.602:655]

            if libc::dup2(stderr, this_stderr) < 0 {

[14.602]

[14.655]

            if libc::dup2(stderr_w, this_stderr) < 0 {

Deletion in src/container.rs at line 668 [9.44692]
B:BD[14.737] → [14.737:775]
∅:D[14.775] → [10.6491:6526]
B:BD[10.6491] → [10.6491:6526]
```
            // libc::dup2(stdout, 1);
            libc::dup2(stderr, 2);
```

Insertion in shell.nix at line 101 [17.34]

[16.70]

[17.2728]

    ocamlPackages.ppx_string
    ocamlPackages.ppx_blob

File addition: semantic_versions.ml (----------)

[7.55449]

let of_string input =
  try
    Scanf.sscanf input "%u.%u.%u-%s" (fun v1 v2 v3 v4 -> (v1, v2, v3, Some v4))
  with _ -> Scanf.sscanf input "%u.%u.%u" (fun v1 v2 v3 -> (v1, v2, v3, None))
let to_string (v1, v2, v3, v4) =
  match v4 with
  | None -> Printf.sprintf "%u.%u.%u" v1 v2 v3
  | Some s -> Printf.sprintf "%u.%u.%u-%s" v1 v2 v3 s

File addition: rust (d--x------)
[7.55449]
File move: rust.ml → rust.ml
BF:BFD[7.55449] → [18.0:31]
BF:BF[18.31] → [18.32:32]
[0.15691]
[18.32]
Replacement in elpe/lib/rust/rust.ml at line 14 [18.32]
B:BD[18.292] → [18.292:299]
```
  http
```
[18.292]
[18.299]
```
  http ~name:crate
```
Replacement in elpe/lib/rust/rust.ml at line 30 [18.32]
B:BD[18.677] → [18.677:702]
```
    method name = "rust"
```
[18.677]
[18.702]
```
    method name = "rust-unzip-" ^ pkg#name
```

Replacement in elpe/lib/rust/rust.ml at line 39 [18.32]

B:BD[18.1068] → [6.475:1069]

        ("mkdir -p $DESTDIR; tar -xf " ^ List.hd zipped.destdir
       ^ " -C $DESTDIR; cd $DESTDIR/*; echo -n \\{\\\"files\\\":\\{ \
          >.cargo-checksum.json\n\
          n=0\n\
          for f in $(find . -type f -printf '%P\\n'); do\n\
          if [[ $n -gt 0 ]]; then\n\
          echo -n , >>.cargo-checksum.json\n\
          fi\n\
          echo -n \\\"$f\\\":\\\"$(sha256sum $f | cut -d\" \" -f 1)\\\" >> \
          .cargo-checksum.json;\n\
          n=$((n+1))\n\
          done\n\
          echo -n \\},\\\"package\\\":\\\"" ^ hash
       ^ "\\\"\\} >> .cargo-checksum.json")

[18.1068]

[18.1150]

        [%string
          {|mkdir -p $DESTDIR
           tar -xf %{List.hd zipped.destdir} -C $DESTDIR
           cd $DESTDIR/*
           echo -n \{\"files\":\{ >.cargo-checksum.json
           n=0
           for f in $(find . -type f -printf '%P\n'); do
           if [[ $n -gt 0 ]]; then
           echo -n , >>.cargo-checksum.json
           fi
           echo -n \"$f\":\"$(sha256sum $f | cut -d" " -f 1)\" >> .cargo-checksum.json
           n=$((n+1))
           done
           echo -n \},\"package\":\"%{hash}\"\} >> .cargo-checksum.json
           |}]
    method! install_phase = Lwt.return ""

Insertion in elpe/lib/rust/rust.ml at line 57 [18.32]

[18.1156]

[19.186]


let extra_crate_dependencies name version =
  match (name, version) with
  | "openssl", _ | "openssl-sys", _ ->
      [ ubuntu "libssl-dev"; ubuntu "pkg-config" ]
  | _ -> []

Replacement in elpe/lib/rust/rust.ml at line 83 [18.32]

B:BD[19.466] → [19.466:845]

B:BD[19.845] → [6.1457:1525]

∅:D[6.1525] → [19.895:1110]

B:BD[19.895] → [19.895:1110]

    Lwt.all
      (List.map
         (fun pkg ->
           try
             let source = str_from_toml_table "source" pkg in
             let checksum = str_from_toml_table "checksum" pkg in
             let name = str_from_toml_table "name" pkg in
             let version = str_from_toml_table "version" pkg in
             let h = fetch_crate source checksum name version in
             let drv = (unzip_checksum h checksum :> derivation) in
             let* built = drv#build in
             n_packages := !n_packages + 1;
             Lwt.return (Some (name, version, source, drv, built))
           with Not_found -> Lwt.return None)
         packages)

[19.466]

[19.1110]

    Lwt_list.map_s
      (fun pkg ->
        try
          let source = str_from_toml_table "source" pkg in
          let checksum = str_from_toml_table "checksum" pkg in
          let name = str_from_toml_table "name" pkg in
          let version = str_from_toml_table "version" pkg in
          let h = fetch_crate source checksum name version in
          let drv = (unzip_checksum h checksum :> derivation) in
          let* built = drv#build in
          n_packages := !n_packages + 1;
          Lwt.return (Some (name, version, source, drv, built))
        with Not_found -> Lwt.return None)
      packages

Replacement in elpe/lib/rust/rust.ml at line 123 [18.32]

B:BD[19.1673] → [19.1673:1780]

      let platform =
        match platform with Some s -> " --filter-platform " ^ s | None -> ""
      in

[19.1673]

[18.1398]

      let platform = " --filter-platform " ^ platform in

Replacement in elpe/lib/rust/rust.ml at line 126 [18.32]

B:BD[19.1826] → [19.1826:1984]

B:BD[19.1984] → [6.1783:1979]

∅:D[6.1979] → [19.2128:2147]

B:BD[19.2128] → [19.2128:2147]

B:BD[19.2147] → [6.1980:2035]

∅:D[6.2035] → [19.2147:2331]

B:BD[19.2147] → [19.2147:2331]

        List.fold_left
          (fun acc x ->
            match x with
            | Some (crate_name, version, _, _, built) ->
                let target =
                  if Hashtbl.find_opt h crate_name = None then (
                    Hashtbl.add h crate_name ();
                    crate_name)
                  else crate_name ^ "-" ^ version
                in
                List.iter self#add_path built.destdir;
                acc ^ "ln -s " ^ List.hd built.destdir ^ "/" ^ crate_name ^ "-"
                ^ version ^ " vendor/" ^ target ^ "\n"
            | None -> acc)
          "" packages

[19.1826]

[19.2331]

        let package_list =
          List.fold_left
            (fun acc x ->
              match x with
              | Some (crate_name, version, _, _, built) ->
                  let target =
                    if Hashtbl.find_opt h crate_name = None then (
                      Hashtbl.add h crate_name ();
                      crate_name)
                    else crate_name ^ "-" ^ version
                  in
                  List.iter self#add_path built.destdir;
                  [
                    "ln -s ";
                    List.hd built.destdir;
                    "/";
                    crate_name;
                    "-";
                    version;
                    " vendor/";
                    target;
                    "\n";
                  ]
                  @ acc
              | None -> acc)
            [] packages
        in
        String.concat "" package_list

Replacement in elpe/lib/rust/rust.ml at line 156 [18.32]

B:BD[19.2358] → [19.2358:2913]

        "export HOME=/home/me\nmkdir -p $HOME\nexport PATH=" ^ List.hd rustc
        ^ "/usr/lib/rust-" ^ rust_version ^ "/bin:" ^ List.hd cargo
        ^ "/usr/lib/rust-" ^ rust_version
        ^ "/bin:$PATH\nmkdir -p vendor .cargo\n" ^ packages
        ^ "\n\
           cat <<EOF >> .cargo/config.toml\n\
           [source.crates-io]\n\
           replace-with = \"vendored-sources\"\n\n\
           [source.vendored-sources]\n\
           directory = \"vendor\"\n\
           EOF\n\
           cargo metadata --offline --format-version 1" ^ platform

[19.2358]

[18.1630]

        [%string
          {|export HOME=/home/me
mkdir -p $HOME
export PATH=%{List.hd rustc}/usr/lib/rust-%{rust_version}/bin:%{List.hd cargo}/usr/lib/rust-%{rust_version}/bin:$PATH
mkdir -p vendor .cargo
%{packages}
cat <<EOF >> .cargo/config.toml
[source.crates-io]
replace-with = "vendored-sources"
[source.vendored-sources]
directory = "vendor"
EOF
cargo metadata --offline --format-version 1 %{platform}
|}]

Replacement in elpe/lib/rust/rust.ml at line 178 [18.32]

B:BD[6.2167] → [6.2167:2234]

type deps = { build_dependencies : string; dependencies : string }

[6.2167]

[6.2234]

type deps = {
  build_dependencies : (string * string * string * bool * build_result) list;
  dependencies : (string * string * string * bool * build_result) list;
  transitive_build_dependencies : (string, build_result) Hashtbl.t;
  transitive_dependencies : (string, build_result) Hashtbl.t;
}

Replacement in elpe/lib/rust/rust.ml at line 187 [18.32]

B:BD[6.2322] → [6.2322:2403]

class compiled_crate rust_version rustc cc platform package path deps features =

[6.2322]

[19.3151]

class compiled_crate ~rust_version ~rustc ~cc ~host ~target ~package ~path
  ~dependencies ~features ~opt_level ~is_top_level =
  let package_deps =
    let d = package |> member "dependencies" |> to_list in
    let h = Hashtbl.create (List.length d) in
    List.iter (fun d -> Hashtbl.add h (d |> member "name" |> to_string) d) d;
    h
  in

Insertion in elpe/lib/rust/rust.ml at line 199 [18.32]

[6.2503]

[19.3250]

    method semantic_version = Semantic_versions.of_string self#version

Replacement in elpe/lib/rust/rust.ml at line 201 [18.32]
B:BD[19.3284] → [6.2504:2539]
```
    val target_platform = platform
```
[19.3284]
[19.3284]
```
    method targets = package |> member "targets" |> to_list
```

Insertion in elpe/lib/rust/rust.ml at line 208 [18.32]

[6.2672]

[18.2324]

      let* deps = self#dependencies in
      let dependencies =
        String.concat " "
          (List.map
             (fun (_, _, _, _, r) -> List.hd r.destdir)
             deps.dependencies)
      in
      let build_dependencies =
        String.concat " "
          (List.map
             (fun (_, _, _, _, r) -> List.hd r.destdir)
             deps.build_dependencies)
      in

Replacement in elpe/lib/rust/rust.ml at line 222 [18.32]

B:BD[18.2341] → [6.2673:2814]

        (s ^ "export HOME=/home/me\nmkdir -p $HOME\nexport PATH="
       ^ List.hd rustc ^ "/usr/lib/rust-" ^ rust_version ^ "/bin:$PATH\n")

[18.2341]

[18.2913]

        [%string
          {|%{s}
           for i in %{dependencies} %{build_dependencies}; do
           if [[ -s $i/lib/env ]]; then
           source $i/lib/env
           fi
           done
           export HOME=/home/me
           mkdir -p $HOME
           export PATH=%{List.hd rustc}/usr/lib/rust-%{rust_version}/bin:$PATH
           |}]

Replacement in elpe/lib/rust/rust.ml at line 242 [18.32]

B:BD[6.3090] → [6.3090:3154]

          (fun acc x -> acc ^ " --cfg 'feature=\"" ^ x ^ "\"'")

[6.3090]

[6.3154]

          (fun acc x -> [%string {|%{acc} --cfg 'feature="%{x}"'|}])

Replacement in elpe/lib/rust/rust.ml at line 272 [18.32]

B:BD[19.4203] → [6.4189:4342]

    method private compile_target setup platform target kind dependencies out =
      let initial_src_path = target |> member "src_path" |> to_string in

[19.4203]

[6.4342]

    method private compile_target setup target build_target kind
        transitive_dependencies dependencies out =
      let initial_src_path = build_target |> member "src_path" |> to_string in

Replacement in elpe/lib/rust/rust.ml at line 276 [18.32]

B:BD[6.4403] → [6.4403:4460]

      let name = target |> member "name" |> to_string in

[6.4403]

[6.4460]

      let name = build_target |> member "name" |> to_string in

Replacement in elpe/lib/rust/rust.ml at line 279 [18.32]

B:BD[6.4519] → [6.4519:4595]

        try " --edition=" ^ (target |> member "edition" |> to_string) ^ " "

[6.4519]

[6.4595]

        try
          " --edition=" ^ (build_target |> member "edition" |> to_string) ^ " "

Replacement in elpe/lib/rust/rust.ml at line 285 [18.32]

B:BD[6.4744] → [6.4744:4833]

      let platform =
        match platform with Some p -> " --target " ^ p | None -> ""

[6.4744]

[6.4833]


      let dependencies_str =
        List.fold_left
          (fun acc (rename, name, h, is_proc_macro, b) ->
            acc ^ " --extern " ^ underscorize rename ^ "=" ^ List.hd b.destdir
            ^ "/lib/lib" ^ underscorize name ^ "-" ^ h
            ^
            if is_proc_macro then ".so"
            else if kind = "lib" then ".rmeta"
            else ".rlib")
          "" dependencies
      in
      let dependencies_str =
        Hashtbl.fold
          (fun _ v acc -> acc ^ " -L dependency=" ^ List.hd v.destdir ^ "/lib")
          transitive_dependencies dependencies_str

Insertion in elpe/lib/rust/rust.ml at line 303 [18.32]
[6.4842]
[6.4842]
```
      let target = " --target " ^ Platform.triple target in
```

Replacement in elpe/lib/rust/rust.ml at line 306 [18.32]

B:BD[19.4220] → [6.4870:5110]

          !setup ^ "rustc --crate-name " ^ under ^ edition ^ src_path ^ platform
          ^ " --crate-type bin -C linker=gcc" ^ features_args ^ " -C metadata="
          ^ hash ^ " --out-dir " ^ out ^ dependencies ^ " --cap-lints allow\n"

[19.4220]

[6.5110]

          [%string
            {|
             %{!setup}
             set -x
             rustc --crate-name %{under} %{edition} %{src_path} %{target} --crate-type bin -C linker=gcc $RUSTC_FLAGS %{features_args} -C metadata=%{hash} --out-dir %{out} %{dependencies_str} -L dependency=../lib --cap-lints allow
             { set +x; } 2>/dev/null
             |}]

Replacement in elpe/lib/rust/rust.ml at line 315 [18.32]

B:BD[6.5138] → [6.5138:5501]

          !setup ^ "rustc --crate-name " ^ under ^ edition ^ src_path
          ^ " --crate-type " ^ kind ^ platform
          ^ " --emit=dep-info,metadata,link -C embed-bitcode=no -C debuginfo=2"
          ^ features_args ^ " -C metadata=" ^ hash ^ " --out-dir " ^ out
          ^ " -C extra-filename=-" ^ hash ^ dependencies
          ^ " --cap-lints allow\n";

[6.5138]

[6.5501]

          [%string
            {|
             %{!setup}
             set -x
             rustc --crate-name %{under} %{edition} %{src_path} --crate-type %{kind} %{target} --emit=dep-info,metadata,link -C linker=gcc -C embed-bitcode=no -C debuginfo=2 $RUSTC_FLAGS %{if kind = "proc-macro" then " -C prefer-dynamic" else ""} %{features_args} -C metadata=%{hash} --out-dir %{out} -C extra-filename=-%{hash} %{dependencies_str} %{if kind = "proc-macro" then " --extern proc_macro" else ""} --cap-lints allow
             { set +x; } 2>/dev/null
             |}];

Insertion in elpe/lib/rust/rust.ml at line 325 [18.32]

[6.5515]

    val accumulated_deps : (string, compiled_crate) Hashtbl.t option ref =
      ref None
    method accumulated_deps =
      match !accumulated_deps with
      | Some acc -> Lwt.return acc
      | None ->
          let h = Hashtbl.create 256 in
          let* _ =
            Lwt_list.iter_s
              (fun d ->
                let dd = Hashtbl.find package_deps d#name in
                let is_build =
                  dd |> member "kind" |> to_option to_string = Some "build"
                in
                Hashtbl.add h d#name d;
                let* acc = d#accumulated_deps in
                Lwt.return
                  (if not is_build then
                     Hashtbl.iter (fun k v -> Hashtbl.add h k v) acc
                   else ()))
              dependencies
          in
          accumulated_deps := Some h;
          Lwt.return h

Replacement in elpe/lib/rust/rust.ml at line 360 [18.32]

B:BD[6.5840] → [6.5840:6195]

          let package_deps =
            let d = package |> member "dependencies" |> to_list in
            let h = Hashtbl.create (List.length d) in
            List.iter
              (fun d -> Hashtbl.add h (d |> member "name" |> to_string) d)
              d;
            h
          in
          let de = ref "" in
          let build_de = ref "" in

[6.5840]

[6.6195]

          let de = ref [] in
          let h = Hashtbl.create 256 in
          let build_h = Hashtbl.create 256 in
          let build_de = ref [] in

Replacement in elpe/lib/rust/rust.ml at line 365 [18.32]
B:BD[6.6217] → [6.6217:6244]
```
            Lwt_list.map_p
```
[6.6217]
[6.6244]
```
            Lwt_list.map_s
```

Replacement in elpe/lib/rust/rust.ml at line 368 [18.32]

B:BD[6.6304] → [6.6304:6352]

                Lwt.return (x#name, x#hash, b))

[6.6304]

[6.6352]

                Lwt.return (x, x#name, x#hash, b))
              dependencies
          in
          let* _ =
            Lwt_list.iter_s
              (fun (x, x_name, x_hash, b) ->
                let d = Hashtbl.find package_deps x_name in
                let is_build =
                  d |> member "kind" |> to_option to_string = Some "build"
                in
                List.iter self#add_path b.destdir;
                let name =
                  match d |> member "rename" |> to_option to_string with
                  | Some rename -> rename
                  | None -> x_name
                in
                let r, h = if is_build then (build_de, build_h) else (de, h) in
                let* acc = x#accumulated_deps in
                let* _ =
                  Hashtbl.fold
                    (fun name v acc ->
                      if Hashtbl.find_opt h name = None then (
                        let* _ = acc in
                        let* b = v#build in
                        List.iter self#add_path b.destdir;
                        Hashtbl.add h name b;
                        Lwt.return ())
                      else Lwt.return ())
                    acc (Lwt.return ())
                in
                let is_proc_macro =
                  List.exists
                    (fun t ->
                      List.exists
                        (fun k -> k = "proc-macro")
                        (t |> member "kind" |> to_list |> filter_string))
                    x#targets
                in
                r := (name, x_name, x_hash, is_proc_macro, b) :: !r;
                Lwt.return ())

Deletion in elpe/lib/rust/rust.ml at line 410 [18.32]

B:BD[6.6384] → [6.6384:7125]

          List.iter
            (fun (x_name, x_hash, b) ->
              let d = Hashtbl.find package_deps x_name in
              let is_build =
                d |> member "kind" |> to_option to_string = Some "build"
              in
              List.iter self#add_path b.destdir;
              let name =
                match d |> member "rename" |> to_option to_string with
                | Some rename -> rename
                | None -> x_name
              in
              let r = if is_build then build_de else de in
              r :=
                !r ^ " -L dependency=target/deps --extern " ^ name ^ "="
                ^ List.hd b.destdir ^ "/lib/lib" ^ x_name ^ "-" ^ x_hash
                ^ ".rlib")
            deps;

Replacement in elpe/lib/rust/rust.ml at line 411 [18.32]

B:BD[6.7126] → [6.7126:7207]

          let result = { build_dependencies = !build_de; dependencies = !de } in

[6.7126]

[6.7207]

          let result =
            {
              build_dependencies = !build_de;
              transitive_build_dependencies = build_h;
              dependencies = !de;
              transitive_dependencies = h;
            }
          in

Replacement in elpe/lib/rust/rust.ml at line 422 [18.32]

B:BD[6.7284] → [6.7284:7349]

    method! build_inputs = Lwt.return [ ubuntu "coreutils"; cc ]

[6.7284]

[6.7349]

    method! build_inputs =
      Lwt.return
        ([
           ubuntu "coreutils";
           ubuntu "sed";
           ubuntu "gcc";
           ubuntu "grep";
           ubuntu "gawk";
           cc;
         ]
        @ extra_crate_dependencies self#name self#version)

Replacement in elpe/lib/rust/rust.ml at line 438 [18.32]

B:BD[6.7481] → [6.7481:7562]

        ref ("set -x\nmkdir -p target/build-" ^ hash ^ "\nexport RUSTC=rustc\n")

[6.7481]

[6.7562]

        ref ("mkdir -p target/build-" ^ hash ^ "\nexport RUSTC=rustc\n")

Insertion in elpe/lib/rust/rust.ml at line 448 [18.32]

[6.7793]

      let v0, v1, v2, v4 = self#semantic_version in
      let name = self#name in
      let version = self#version in

Insertion in elpe/lib/rust/rust.ml at line 452 [18.32]

[6.7853]

      setup :=
        !setup
        ^ [%string
            {|export OUT_DIR=$DESTDIR/lib
             export CARGO_PKG_VERSION="%{version}"
             export CARGO_PKG_NAME="%{name}"
             export CARGO_PKG_VERSION_MAJOR=%{v0#Int}
             export CARGO_PKG_VERSION_MINOR=%{v1#Int}
             export CARGO_PKG_VERSION_PATCH=%{v2#Int}
             export CARGO_PKG_VERSION_PATCH=%{Option.value v4 ~default:""}
             export TARGET="%{Platform.triple target}"
             export HOST="%{Platform.triple host}"
             export OPT_LEVEL=%{opt_level}
             export CARGO_CFG_UNIX=1
             export CARGO_CFG_TARGET_ABI=""
             export CARGO_CFG_TARGET_OS=linux
             export CARGO_CFG_TARGET_ENDIAN="%{Platform.string_of_endianness (Platform.endianness target)}"
             export CARGO_CFG_TARGET_POINTER_WIDTH=%{(Platform.pointer_width target)#Int}
             export CARGO_CFG_TARGET_ENV="%{Platform.env target}"
             export CARGO_CFG_TARGET_ARCH="%{Platform.string_of_arch target.arch}"
             |}];

Replacement in elpe/lib/rust/rust.ml at line 487 [18.32]

B:BD[6.8408] → [6.8408:8551]

                        (self#compile_target setup None target "bin"
                           d.build_dependencies ("target/build-" ^ hash))

[6.8408]

[6.8551]

                        (self#compile_target setup host target "bin"
                           d.transitive_build_dependencies d.build_dependencies
                           ("target/build-" ^ hash))

Replacement in elpe/lib/rust/rust.ml at line 493 [18.32]

B:BD[6.8686] → [6.8686:8760]

          (true, None)
          (package |> member "targets" |> to_list)

[6.8686]

[6.8760]

          (true, None) self#targets

Replacement in elpe/lib/rust/rust.ml at line 495 [18.32]

B:BD[6.8769] → [6.8769:8818]

      (* If there is a build script, call it. *)

[6.8769]

[6.8818]

      setup := !setup ^ "mkdir -p $OUT_DIR || true\n";

Replacement in elpe/lib/rust/rust.ml at line 500 [18.32]

B:BD[6.8890] → [6.8890:8966]

            setup := !setup ^ "target/build-" ^ hash ^ "/" ^ bs_name ^ "\n"

[6.8890]

[6.8966]

            setup :=
              !setup
              ^ [%string
                  {|CRATENAME=$(echo %{name} | sed -e "s/\(.*\)-sys$/\U\1/" -e "s/-/_/g")
                   CRATEVERSION=$(echo %{version} | sed -e "s/[\.\+-]/_/g")
                   |}]
              ^ String.trim [%blob "run_build_script.sh"]
              ^ [%string "<<< $(target/build-%{hash}/%{bs_name})\n"]

Replacement in elpe/lib/rust/rust.ml at line 521 [18.32]
B:BD[19.4771] → [19.4771:4794]
```
        (fun target ->
```
[19.4771]
[19.4794]
```
        (fun build_target ->
```

Replacement in elpe/lib/rust/rust.ml at line 524 [18.32]

B:BD[19.4839] → [6.9257:9449]

              if kind = "bin" then
                if !has_bin then ()
                else (
                  has_bin := true;
                  setup := !setup ^ "mkdir -p $DESTDIR/bin\n")

[19.4839]

[6.9449]

              if kind = "bin" then if !has_bin then () else has_bin := true

Replacement in elpe/lib/rust/rust.ml at line 526 [18.32]

B:BD[6.9488] → [6.9488:9604]

              else (
                has_lib := true;
                setup := !setup ^ "mkdir -p $DESTDIR/lib\n");

[6.9488]

[19.4839]

              else has_lib := true;

Replacement in elpe/lib/rust/rust.ml at line 531 [18.32]

B:BD[6.9650] → [6.9650:9776]

                    self#compile_target setup target_platform target kind
                      d.dependencies "$DESTDIR/lib"

[6.9650]

[6.9776]

                    self#compile_target setup target build_target kind
                      d.transitive_dependencies d.dependencies "$OUT_DIR"

Replacement in elpe/lib/rust/rust.ml at line 536 [18.32]

B:BD[19.4975] → [6.9819:10013]

                  let _ =
                    self#compile_target setup target_platform target kind
                      d.dependencies "$DESTDIR/bin"
                  in
                  ()

[19.4975]

[19.5020]

                  if is_top_level then
                    let _ =
                      self#compile_target setup target build_target kind
                        d.transitive_dependencies d.dependencies
                        "$OUT_DIR/../bin"
                    in
                    ()
                  else ()

Replacement in elpe/lib/rust/rust.ml at line 545 [18.32]

B:BD[19.5045] → [19.5045:5162]

            (target |> member "kind" |> to_list |> filter_string))
        (package |> member "targets" |> to_list);

[19.5045]

[19.5162]

            (build_target |> member "kind" |> to_list |> filter_string))
        self#targets;

Insertion in elpe/lib/rust/rust.ml at line 548 [18.32]

[19.5186]

[19.5264]


    method! install_phase =
      Lwt.return
        {|
         if [[ -s target/env ]]; then
         mkdir -p $DESTDIR/lib
         cp target/env $DESTDIR/lib
         fi
         |}

Replacement in elpe/lib/rust/rust.ml at line 559 [18.32]

B:BD[18.4399] → [6.10014:10073]

let rust ?(rust_version = "1.84") ?(platform = None) src =

[18.4399]

[19.5346]

let rec dfs nodes seen result n =
  match Hashtbl.find_opt seen n with
  | Some () -> result
  | None ->
      let _ = Hashtbl.add seen n () in
      let node = Hashtbl.find nodes n in
      let deps = node |> member "dependencies" |> to_list |> filter_string in
      let result = List.fold_left (dfs nodes seen) result deps in
      node :: result
let topo_sort n_nodes nodes =
  let h = Hashtbl.create n_nodes in
  let nodes_list =
    List.fold_left
      (fun list node ->
        let id = node |> member "id" |> to_string in
        Hashtbl.add h id node;
        id :: list)
      [] nodes
  in
  let seen = Hashtbl.create n_nodes in
  List.fold_left (dfs h seen) [] nodes_list
let rust ?(rust_version = "1.84") ?(target = !Platform.target)
    ?(host = !Platform.host) src =

Deletion in elpe/lib/rust/rust.ml at line 593 [18.32]
B:BD[19.5896] → [6.10155:10194]
```
  let cc = ubuntu "build-essential" in
```

Replacement in elpe/lib/rust/rust.ml at line 595 [18.32]

B:BD[19.5914] → [6.10195:10270]

    new metadata rust_version cargo rustc platform src n_packages packages

[19.5914]

[19.5985]

    new metadata
      rust_version cargo rustc (Platform.triple target) src n_packages packages

Replacement in elpe/lib/rust/rust.ml at line 609 [18.32]

B:BD[19.6439] → [19.6439:6440]

[19.6439]

[19.6440]

  let workspace_members =
    meta_json |> member "workspace_members" |> to_list |> filter_string
  in

Deletion in elpe/lib/rust/rust.ml at line 627 [18.32]
B:BD[18.4515] → [18.4515:4516]

Replacement in elpe/lib/rust/rust.ml at line 633 [18.32]

B:BD[19.7236] → [19.7236:7237]

[19.7236]

[19.7237]

      let is_top_level = List.exists (fun w -> w = name) workspace_members in
      let cc = (cc :> derivation) in

Replacement in elpe/lib/rust/rust.ml at line 637 [18.32]

B:BD[6.10298] → [6.10298:10370]

          rust_version rustc cc platform meta drv dependencies features

[6.10298]

[18.4792]

          ~rust_version ~rustc ~cc ~target ~host ~package:meta ~path:drv
          ~dependencies ~features ~opt_level:"3" ~is_top_level

Replacement in elpe/lib/rust/rust.ml at line 641 [18.32]
B:BD[19.7372] → [19.7372:7383]
```
    nodes;
```
[19.7372]
[18.4862]
```
    (List.rev (topo_sort n_packages nodes));
```

Replacement in elpe/lib/rust/rust.ml at line 643 [18.32]

B:BD[18.4863] → [19.7384:7513]

  Lwt.return
    (List.map (Hashtbl.find resolved)
       (meta_json |> member "workspace_members" |> to_list |> filter_string))

[18.4863]

  Lwt.return (List.map (Hashtbl.find resolved) workspace_members)

File addition: run_build_script.sh (----------)

[0.15691]

while read cargo; do
    eval $(echo $cargo | sed -ne 's/cargo:rustc-link-arg=\(.*\)/RUSTC_FLAGS="-C link_arg=\1 $RUSTC_FLAGS"/p')
    eval $(echo $cargo | sed -ne 's/cargo:rustc-link-lib=\(.*\)/RUSTC_FLAGS="-l\1 $RUSTC_FLAGS"/p')
    eval $(echo $cargo | sed -ne 's/cargo:rustc-link-search=\(.*\)/RUSTC_FLAGS="-L\1 $RUSTC_FLAGS"/p')
    eval $(echo $cargo | sed -ne "s/cargo:rustc-cfg=\(.*\)/RUSTC_FLAGS='--cfg \1 $RUSTC_FLAGS'/p")
    eval $(echo $cargo | sed -ne 's/cargo:rustc-flags=\(.*\)/RUSTC_FLAGS="\1 $RUSTC_FLAGS"/p')
    echo $cargo | grep -P "^cargo:(?!:?(rustc-|warning=|rerun-if-changed=|rerun-if-env-changed))" \
        | gawk -F= "/^cargo::metadata=/ {  gsub(/-/, \"_\", \$2); print \"export \" toupper(\"DEP_$(echo $CRATENAME)_\" \$2) \"=\" \"\\\"\"\$3\"\\\"\"; next }
         /^cargo:/ { sub(/^cargo::?/, \"\", \$1); gsub(/-/, \"_\", \$1); print \"export \" toupper(\"DEP_$(echo $CRATENAME)_\" \$1) \"=\" \"\\\"\"\$2\"\\\"\"; print \"export \" toupper(\"DEP_$(echo $CRATENAME)_$(echo $CRATEVERSION)_\" \$1) \"=\" \"\\\"\"\$2\"\\\"\"; next }" >> target/env
done

File addition: platform.ml (----------)

[7.55449]

type arch = Amd64 | Aarch64
type endianness = Little | Big
type platform = { arch : arch; env : string }
let default = { arch = Amd64; env = "gnu" }
let endianness p = match p.arch with Amd64 | Aarch64 -> Little
let env p = p.env
let string_of_endianness = function Little -> "little" | Big -> "big"
let string_of_arch = function Amd64 -> "x86_64" | Aarch64 -> "aarch64"
let pointer_width _ = 64
let triple p =
  match p.arch with
  | Amd64 -> "x86_64-unknown-linux-gnu"
  | Aarch64 -> "aarch64-unknown-linux-gnu"
let host = ref default
let target = ref default

Insertion in elpe/lib/elpegrpc.proto at line 73 [7.55490]
[7.55726]
[7.55726]
```
enum Endianness {
  big = 0;
  little = 1;
}
```

Insertion in elpe/lib/elpegrpc.proto at line 93 [7.55490]

[13.16524]

[7.55903]

}
message PlatformReply {
  Arch arch = 1;
  Endianness endianness = 2;
  int32 pointer_width = 3;

Insertion in elpe/lib/elpegrpc.proto at line 101 [7.55490]
[7.55906]
[7.55906]
```
message Empty {}
```
Insertion in elpe/lib/elpegrpc.proto at line 104 [7.55490]
[7.55921]
[10.6582]
```
  rpc Handshake (Empty) returns (PlatformReply);
```

Replacement in elpe/lib/elpe.ml at line 11 [7.56160]

B:BD[7.58601] → [9.64972:65023]

let rec walk_dir_rec encode f buf path path_name =

[7.58601]

[9.65023]

let rec is_ignored ignored dir path current =
  match ignored with
  | [] -> current
  | (negated, dir_only, h) :: t ->
      is_ignored t dir path
        (if negated && current then not (Str.string_match h path 0)
         else if (dir_only && dir) || not dir_only then
           current || Str.string_match h path 0
         else current)
let is_ignored_dir ignored path = is_ignored ignored true path false
let is_ignored_file ignored path = is_ignored ignored false path false
let rec walk_dir_rec encode f buf ignored path path_name =

Replacement in elpe/lib/elpe.ml at line 43 [7.56160]

B:BD[9.65607] → [9.65607:66091]

                    let req =
                      AddPathRequest.make
                        ~request:
                          (`Directory
                             (AddPathRequest.Directory.make ~name:path_name
                                ~permissions:0o644 ()))
                        ()
                    in
                    let enc = encode req |> Writer.contents in
                    f (Some enc);
                    walk_dir_rec encode f buf path path_name

[9.65607]

[9.66091]

                    if not (is_ignored_dir ignored path_name) then (
                      let req =
                        AddPathRequest.make
                          ~request:
                            (`Directory
                               (AddPathRequest.Directory.make ~name:path_name
                                  ~permissions:0o644 ()))
                          ()
                      in
                      let enc = encode req |> Writer.contents in
                      f (Some enc);
                      walk_dir_rec encode f buf ignored path path_name)
                    else Lwt.return ()

Replacement in elpe/lib/elpe.ml at line 57 [7.56160]

B:BD[9.66123] → [9.66123:67319]

                    let* file = Lwt_unix.openfile path [ O_RDONLY ] 0 in
                    let ff =
                      AddPathRequest.File.make ~name:path_name
                        ~length:stat.st_size ~permissions:0o644 ()
                    in
                    let req = AddPathRequest.make ~request:(`File ff) () in
                    let enc = encode req |> Writer.contents in
                    let () = f (Some enc) in
                    let rec read_all n =
                      let* r = Lwt_unix.read file buf 0 4096 in
                      if r != 0 then
                        let req =
                          AddPathRequest.make
                            ~request:
                              (`Contents
                                 (AddPathRequest.FileContents.make ~start:n
                                    ~content:(Bytes.sub buf 0 r) ()))
                            ()
                        in
                        let enc = encode req |> Writer.contents in
                        let () = f (Some enc) in
                        read_all (n + r)
                      else Lwt.return ()
                    in
                    read_all 0

[9.66123]

[9.67319]

                    if not (is_ignored_file ignored path_name) then
                      let* file = Lwt_unix.openfile path [ O_RDONLY ] 0 in
                      let ff =
                        AddPathRequest.File.make ~name:path_name
                          ~length:stat.st_size ~permissions:0o644 ()
                      in
                      let req = AddPathRequest.make ~request:(`File ff) () in
                      let enc = encode req |> Writer.contents in
                      let () = f (Some enc) in
                      let rec read_all n =
                        let* r = Lwt_unix.read file buf 0 4096 in
                        if r != 0 then
                          let req =
                            AddPathRequest.make
                              ~request:
                                (`Contents
                                   (AddPathRequest.FileContents.make ~start:n
                                      ~content:(Bytes.sub buf 0 r) ()))
                              ()
                          in
                          let enc = encode req |> Writer.contents in
                          let () = f (Some enc) in
                          read_all (n + r)
                        else Lwt.return ()
                      in
                      read_all 0
                    else Lwt.return ()

Replacement in elpe/lib/elpe.ml at line 92 [7.56160]
B:BD[9.67527] → [9.67527:67559]
```
let add_path connection path0 =
```
[9.67527]
[9.67559]
```
let add_path connection ignored path0 =
```

Replacement in elpe/lib/elpe.ml at line 104 [7.56160]

B:BD[9.67971] → [9.67971:68029]

           let* _ = walk_dir_rec encode f buf path0 "" in

[9.67971]

[9.68029]

           let* _ = walk_dir_rec encode f buf ignored path0 "" in

Insertion in elpe/lib/elpe.ml at line 118 [7.56160]

[9.68469]


let rec read_ignore ign =
  try
    let line = input_line ign in
    let rest = read_ignore ign in
    let regexp = Str.regexp {|\(\\#\)\|\(^#\)\|\(^!\)\|\(\*\*\)\|\*|} in
    let result = ref "" in
    let i = ref 0 in
    let negated = ref false in
    let _ =
      try
        let ended = ref false in
        while not !ended do
          let next = Str.search_forward regexp line !i in
          let _ =
            if next - !i > 0 then
              result := !result ^ Str.quote (String.sub line !i (next - !i))
            else ()
          in
          let m = Str.matched_string line in
          let _ =
            match m with
            | "!" -> negated := true
            | "#" -> ended := true
            | "**" -> result := !result ^ ".*"
            | "*" -> result := !result ^ "[^/]*"
            | "\\#" -> result := !result ^ "#"
            | m -> result := !result ^ Str.quote m
          in
          i := next + String.length m
        done
      with Not_found ->
        result :=
          !result ^ Str.quote (String.sub line !i (String.length line - !i))
    in
    if String.length !result > 0 then
      let dir_only = !result.[String.length !result - 1] = '/' in
      let result =
        if dir_only then String.sub !result 0 (String.length !result - 1)
        else !result
      in
      if String.contains result '/' then
        (!negated, dir_only, Str.regexp result) :: rest
      else
        (!negated, dir_only, Str.regexp ({|\(\(.+/\)\|^\)|} ^ result)) :: rest
    else rest
  with End_of_file -> []

Insertion in elpe/lib/elpe.ml at line 171 [7.56160]
[16.279]
[7.58889]
```
    val cached = ref None
```

Replacement in elpe/lib/elpe.ml at line 174 [7.56160]

B:BD[7.58910] → [7.58910:58998]

B:BD[7.59300] → [7.59300:59309]

B:BD[7.59309] → [16.280:313]

∅:D[16.313] → [7.59399:59439]

B:BD[7.59399] → [7.59399:59439]

B:BD[7.59439] → [9.68948:68969]

∅:D[10.7630] → [9.72562:72631]

B:BD[9.72562] → [9.72562:72631]

B:BD[9.72631] → [4.4737:4783]

∅:D[4.4783] → [9.72662:72688]

B:BD[9.72662] → [9.72662:72688]

      let c =
        match !backend_conn with None -> failwith "no conn" | Some c -> c
      in
      let* res = add_path c p in
      let res, _ = Result.get_ok res in
      match res with
      | `Ok r -> Lwt.return { destdir = r.destdir; paths = r.paths }
      | `Error e -> raise (DerivationError e)
      | _ -> assert false

[7.58910]

[9.72688]

      match !cached with
      | None ->
          let c =
            match !backend_conn with None -> failwith "no conn" | Some c -> c
          in
          let ignored =
            try read_ignore (open_in ".ignore") with Sys_error _ -> []
          in
          let* res = add_path c ignored p in
          let res, _ = Result.get_ok res in
          let result =
            match res with
            | `Ok r -> { destdir = r.destdir; paths = r.paths }
            | `Error e -> raise (DerivationError e)
            | _ -> assert false
          in
          cached := Some result;
          Lwt.return result
      | Some cached -> Lwt.return cached

Insertion in elpe/lib/dune at line 1 [7.62377]
[7.62377]
[7.62378]
```
(include_subdirs unqualified)
```

Replacement in elpe/lib/dune at line 3 [7.62377]

B:BD[7.62387] → [7.62387:62434]

B:BD[7.62434] → [16.314:406]

 (name elpe)
 (public_name elpe)
 (modes byte)
 (libraries grpc-lwt lwt lwt.unix h2 h2-lwt-unix ocaml-protoc-plugin core yojson toml hex))

[7.62387]

[19.7727]

(name elpe)
(public_name elpe)
(modes byte)
(preprocess (pps ppx_blob ppx_string))
(preprocessor_deps (file run_build_script.sh))
(libraries grpc-lwt lwt lwt.unix h2 h2-lwt-unix ocaml-protoc-plugin core yojson toml hex))

Replacement in elpe/lib/dune at line 12 [7.62377]

B:BD[7.62517] → [7.62517:62611]

B:BD[7.62611] → [9.72941:73010]

∅:D[9.73010] → [7.62676:62691]

B:BD[7.62676] → [7.62676:62691]

 (targets elpegrpc.ml)
 (deps
  (:proto elpegrpc.proto))
 (action
  (run
   protoc
   -I
   .
   "--ocaml_out=annot=[@@deriving show { with_path = false }, eq]:."
   %{proto})))

[7.62517]

(targets elpegrpc.ml)
(deps
(:proto elpegrpc.proto))
(action
(run
protoc
-I
.
"--ocaml_out=annot=[@@deriving show { with_path = false }, eq]:."
%{proto})))

Insertion in elpe/lib/derivation.ml at line 36 [16.445]

[16.1296]


let ubuntu_releases = Hashtbl.create 8
let ubuntu_release_lock = Lwt_mutex.create ()

Replacement in elpe/lib/derivation.ml at line 41 [16.445]

B:BD[16.1356] → [16.1356:2288]

  let req =
    Elpegrpc.Elpe.UbuntuReleaseRequest.make ~release ~arch ~repository ()
  in
  let open Ocaml_protoc_plugin in
  let encode, decode =
    Service.make_client_functions Elpegrpc.Elpe.Elpe.ubuntuRelease
  in
  let enc = encode req |> Writer.contents in
  Client.call ~service:"elpe.Elpe" ~rpc:"UbuntuRelease"
    ~do_request:
      (H2_lwt_unix.Client.request connection ~error_handler:(fun _ ->
           failwith "Error"))
    ~handler:
      (Client.Rpc.unary enc ~f:(fun decoder ->
           let+ decoder = decoder in
           match decoder with
           | Some decoder -> (
               Reader.create decoder |> decode |> function
               | Ok v -> v
               | Error e ->
                   failwith
                     (Printf.sprintf "Could not decode request: %s"
                        (Result.show_error e)))
           | None -> Elpegrpc.Elpe.Elpe.Derivation.Response.make ()))
    ()

[16.1356]

[13.16525]

  Lwt_mutex.with_lock ubuntu_release_lock (fun () ->
      match Hashtbl.find_opt ubuntu_releases (release, arch, repository) with
      | None ->
          let req =
            Elpegrpc.Elpe.UbuntuReleaseRequest.make ~release ~arch ~repository
              ()
          in
          let open Ocaml_protoc_plugin in
          let encode, decode =
            Service.make_client_functions Elpegrpc.Elpe.Elpe.ubuntuRelease
          in
          let enc = encode req |> Writer.contents in
          let* r =
            Client.call ~service:"elpe.Elpe" ~rpc:"UbuntuRelease"
              ~do_request:
                (H2_lwt_unix.Client.request connection ~error_handler:(fun _ ->
                     failwith "Error"))
              ~handler:
                (Client.Rpc.unary enc ~f:(fun decoder ->
                     let+ decoder = decoder in
                     match decoder with
                     | Some decoder -> (
                         Reader.create decoder |> decode |> function
                         | Ok v -> v
                         | Error e ->
                             failwith
                               (Printf.sprintf "Could not decode request: %s"
                                  (Result.show_error e)))
                     | None -> Elpegrpc.Elpe.Elpe.Derivation.Response.make ()))
              ()
          in
          Hashtbl.add ubuntu_releases (release, arch, repository) r;
          Lwt.return r
      | Some x -> Lwt.return x)

Insertion in elpe/lib/derivation.ml at line 77 [16.445]

[13.16587]

[16.2288]

let ubuntu_packages = Hashtbl.create 64
let ubuntu_packages_locks = Hashtbl.create 64

Replacement in elpe/lib/derivation.ml at line 81 [16.445]

B:BD[16.2334] → [13.16588:16705]

  let link_extra =
    List.map
      (fun (pkg, dep) -> Elpegrpc.Elpe.LinkExtra.make ~pkg ~dep ())
      link_extra

[16.2334]

[13.16705]

  let lock =
    try Hashtbl.find ubuntu_packages_locks (index, name)
    with Not_found ->
      let lock = Lwt_mutex.create () in
      Hashtbl.add ubuntu_packages_locks (index, name) lock;
      lock

Replacement in elpe/lib/derivation.ml at line 88 [16.445]

B:BD[13.16710] → [13.16710:16799]

∅:D[13.16799] → [16.2405:2579]

B:BD[16.2405] → [16.2405:2579]

B:BD[16.2579] → [4.4822:5909]

  let req =
    Elpegrpc.Elpe.UbuntuPackageRequest.make ~index ~name ~link_extra ()
  in
  let open Ocaml_protoc_plugin in
  let encode, decode =
    Service.make_client_functions Elpegrpc.Elpe.Elpe.ubuntuPackage
  in
  let enc = encode req |> Writer.contents in
  let result = ref None in
  let* x =
    Client.call ~service:"elpe.Elpe" ~rpc:"UbuntuPackage"
      ~do_request:
        (H2_lwt_unix.Client.request connection ~error_handler:(fun _ ->
             failwith "Error"))
      ~handler:
        (Client.Rpc.server_streaming enc ~f:(fun responses ->
             Lwt_stream.iter_s
               (fun str ->
                 Reader.create str |> decode |> function
                 | Ok (`Ok v) ->
                     result := Some v;
                     Lwt.return ()
                 | Ok (`Loading v) ->
                     Printf.eprintf "Downloading %s\n" v;
                     Stdlib.flush Stdlib.stderr;
                     Lwt.return ()
                 | Error e ->
                     failwith
                       (Printf.sprintf "Could not decode request: %s"
                          (Result.show_error e))
                 | _ -> Lwt.return ())
               responses))
      ()
  in
  match x with
  | Ok _ -> Lwt.return (Ok (Option.get !result))
  | Error e -> Lwt.return (Error e)
type arch = Amd64 | Aarch64

[13.16710]

[16.3246]

  Lwt_mutex.with_lock lock (fun () ->
      match Hashtbl.find_opt ubuntu_packages (index, name) with
      | Some x -> Lwt.return x
      | None ->
          let link_extra =
            List.map
              (fun (pkg, dep) -> Elpegrpc.Elpe.LinkExtra.make ~pkg ~dep ())
              link_extra
          in
          let req =
            Elpegrpc.Elpe.UbuntuPackageRequest.make ~index ~name ~link_extra ()
          in
          let open Ocaml_protoc_plugin in
          let encode, decode =
            Service.make_client_functions Elpegrpc.Elpe.Elpe.ubuntuPackage
          in
          let enc = encode req |> Writer.contents in
          let result = ref None in
          let* x =
            Client.call ~service:"elpe.Elpe" ~rpc:"UbuntuPackage"
              ~do_request:
                (H2_lwt_unix.Client.request connection ~error_handler:(fun _ ->
                     failwith "Error"))
              ~handler:
                (Client.Rpc.server_streaming enc ~f:(fun responses ->
                     Lwt_stream.iter_s
                       (fun str ->
                         Reader.create str |> decode |> function
                         | Ok (`Ok v) ->
                             result := Some v;
                             Lwt.return ()
                         | Ok (`Loading v) ->
                             Printf.eprintf "Downloading %s\n%!" v;
                             Lwt.return ()
                         | Error e ->
                             failwith
                               (Printf.sprintf "Could not decode request: %s"
                                  (Result.show_error e))
                         | _ -> Lwt.return ())
                       responses))
              ()
          in
          let result =
            match x with Ok _ -> Ok (Option.get !result) | Error e -> Error e
          in
          Hashtbl.add ubuntu_packages (index, name) result;
          Lwt.return result)

Replacement in elpe/lib/derivation.ml at line 136 [16.445]

B:BD[16.3247] → [4.5910:5966]

let ubuntu ?(release = "plucky") ?(arch = Amd64) name =

[16.3247]

[16.3287]

let ubuntu ?(release = "plucky") ?(platform = !Platform.target) name =

Replacement in elpe/lib/derivation.ml at line 157 [16.445]

B:BD[6.10856] → [6.10856:10894]

                      match arch with

[6.10856]

[6.10894]

                      match platform.arch with

Replacement in elpe/lib/derivation.ml at line 215 [16.445]

B:BD[16.5575] → [4.5967:6072]

                           Printf.printf "%s" buf;
                           Stdlib.flush Stdlib.stdout

[16.5575]

[16.5625]

                           Printf.printf "%s%!" buf

Replacement in elpe/lib/derivation.ml at line 224 [16.445]

B:BD[16.5944] → [4.6073:6179]

                           Printf.eprintf "%s" buf;
                           Stdlib.flush Stdlib.stderr

[16.5944]

[16.5994]

                           Printf.eprintf "%s%!" buf

Replacement in elpe/lib/derivation.ml at line 364 [16.445]
B:BD[16.10411] → [16.10411:10449]
```
let http ~url ~hash_algorithm ~hash =
```
[16.10411]
[16.10449]
```
let http ~name ~url ~hash_algorithm ~hash =
```
Replacement in elpe/lib/derivation.ml at line 367 [16.445]
B:BD[16.10481] → [16.10481:10506]
```
    method name = "http"
```
[16.10481]
[16.10506]
```
    method name = "http" ^ if name = "" then "" else "-" ^ name
```
Replacement in elpe/lib/derivation.ml at line 407 [16.445]
B:BD[6.13973] → [6.13973:13989]
```
let unzip pkg =
```
[6.13973]
[6.13989]
```
let unzip ?(name = "") pkg =
```
Replacement in elpe/lib/derivation.ml at line 410 [16.445]
B:BD[6.14032] → [6.14032:14057]
```
    method name = "rust"
```
[6.14032]
[6.14057]
```
    method name = "unzip" ^ if name = "" then "" else "-" ^ name
```

Replacement in elpe/lib/derivation.ml at line 414 [16.445]

B:BD[6.14126] → [6.14126:14336]

      Lwt.return
        [
          (ubuntu "libc6-dev" :> derivation);
          (ubuntu "coreutils" :> derivation);
          (ubuntu "tar" :> derivation);
          (ubuntu "gzip" :> derivation);
        ]

[6.14126]

[6.14336]

      Lwt.return [ ubuntu "coreutils"; ubuntu "tar"; ubuntu "gzip" ]

Insertion in elpe/lib/derivation.ml at line 421 [16.445]

[6.14511]


let cc =
  object (self)
    inherit std_derivation
    method name = "cc"
    method! build_inputs = Lwt.return [ ubuntu "coreutils"; ubuntu "gcc" ]
    method! unpack_phase = Lwt.return ""
    method! build_phase =
      let* gcc = (ubuntu "gcc")#build in
      List.iter self#add_path gcc.destdir;
      Lwt.return
        ("mkdir -p $DESTDIR/usr/bin; ln -s " ^ List.hd gcc.destdir
       ^ "/usr/bin/gcc $DESTDIR/usr/bin/cc")
  end

Insertion in default.nix at line 122 [7.64932]

[16.11934]

[7.69968]

        ocamlPackages.ppx_string
        ocamlPackages.ppx_blob