version = "0.2.20"

checksum = "45862d1c77f2228b9e10bc609d5bc203d86ebc9b87ad8d5d5167a6c9abf739d9"

version = "0.12.5"

checksum = "3ee79fb83c725eae67b55218870813d2fc39fd85e4f1583848ef9f4f823cfe7c"

version = "1.11.0"

checksum = "1a68f1f47cdf0ec8ee4b941b2eee2a80cb796db73118c0dd09ac63fbe405be22"

version = "1.2.2"

checksum = "f34d93e62b03caf570cccc334cbc6c2fceca82f39211051345108adcba3eebdc"

version = "4.5.21"

checksum = "fb3b4b9e5a7c7514dfa52869339ee98b3156b0bfb4e8a77c4ff4babb64b1604f"

version = "4.5.21"

checksum = "b17a95aa67cc7b5ebd32aa5370189aa0d79069ef1c64ce893bd30fb24bff20ec"

 "syn 2.0.89",

version = "0.7.3"

checksum = "afb84c814227b90d6895e01398aee0d8033c00e7466aca416fb6a8e0eb19d8a7"

version = "0.2.16"

checksum = "16b80225097f2e5ae4e7179dd2266824648f3e2f49d9134d584b76389d31c4c3"

version = "0.2.9"

checksum = "32a2785755761f3ddc1492979ce1e48d2c00d09311c39e4466429188f3dd6501"

 "syn 2.0.89",

 "syn 2.0.89",

 "syn 2.0.89",

 "syn 2.0.89",

 "syn 2.0.89",

 "syn 2.0.89",

version = "0.1.5"

checksum = "c8ede7d79366f419921e2e2f67889c12125726692a313bffb474bd5f37a581e9"

 "syn 2.0.89",

version = "0.11.3"

checksum = "f88959de2d447fd3eddcf1909d1f19fe084e27a056a6904203dc5d8b9e771c1e"

 "thiserror 2.0.3",

version = "0.3.10"

checksum = "33d852cb9b869c2a9b3df2f71a3074817f01e1844f839a144f5fcef059a4eb5d"

 "windows-sys 0.59.0",

version = "1.0.35"

checksum = "c936bfdafb507ebbf50b8074c54fa31c5be9a1e7e5f467dd659697041407d07c"

 "thiserror 1.0.69",

 "syn 2.0.89",

version = "0.2.6"

checksum = "5a74999c921479f919c87a9d2e6922a79a18683f18105344df8e067149232e51"

version = "0.2.1"

checksum = "bbeac967e71eb3dc1656742fc7521ec7cd3b6b88738face65bf1fddf702bc4c0"

 "syn 2.0.89",

 "regex-automata 0.4.9",

version = "0.15.2"

checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289"

 "syn 2.0.89",

 "regex-automata 0.4.9",

 "hashbrown 0.15.2",

version = "1.0.14"

checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674"

version = "0.2.167"

checksum = "09d6582e104315a817dff97f75133544b2e094ee22447d2acf4a74e189ba06fc"

version = "0.7.4"

checksum = "4ee93343901ab17bd981295f2cf0026d4ad018c7c31ba84549a4ddbb47a45104"

 "thiserror 1.0.69",

 "syn 2.0.89",

version = "1.0.92"

checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"

version = "0.37.1"

checksum = "f22f29bdff3987b4d8632ef95fd6424ec7e4e0a57e2f4fc63e489e75357f6a03"

version = "0.14.0"

checksum = "fd823aeed3ffe73eb82a213e62cb3811f9bdf453844d6e0b14684e0757fb389b"

 "thiserror 1.0.69",

 "thiserror 1.0.69",

version = "0.13.0"

checksum = "90581a9508ccc310998e991d7acf139d2991297d3fb37d30de07536e10256afb"

 "thiserror 1.0.69",

 "thiserror 1.0.69",

version = "0.10.0"

checksum = "cb41c7e10ada3a4df960190a96bfb4af56d33ada890f917acc8e3b122b614875"

 "thiserror 1.0.69",

 "thiserror 1.0.69",

 "thiserror 1.0.69",

 "regex-automata 0.4.9",

version = "0.4.9"

checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"

 "thiserror 1.0.69",

version = "0.9.7"

checksum = "47c75d7c5c6b673e58bf54d8544a9f432e3a925b0e80f7cd3602ab5c50c55519"

version = "2.0.11"

checksum = "531af70fce504d369cf42ac0a9645f5a62a8ea9265de71cfa25087e9f6080c7c"

version = "0.38.41"

checksum = "d7f649912bc1495e167a6edee79151c84b1bad49748cb4f1f1167f459f6224f6"

version = "1.0.215"

checksum = "6513c1ad0b11a9376da888e3e0baa0077f1aed55c17f50e7b2397136129fb88f"

version = "1.0.215"

checksum = "ad1e866f866923f252f05c889987993144fb74e722403468a4ebd70c3cd756c0"

 "syn 2.0.89",

version = "1.0.133"

checksum = "c7fceb2473b9166b2294ef05efcb65a3db80803f0b03ef86a5fc88a2b85ee377"

 "thiserror 1.0.69",

 "syn 2.0.89",

version = "2.0.89"

checksum = "44d46482f1c1c87acd84dea20c1bf5ebff4c757009ed6bf19cfd36fb10e92c4e"

 "syn 2.0.89",

version = "1.0.69"

checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"

 "thiserror-impl 1.0.69",

]

[[package]]

name = "thiserror"

version = "2.0.3"

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

checksum = "c006c85c7651b3cf2ada4584faa36773bd07bac24acfb39f3c431b36d7e667aa"

dependencies = [

 "thiserror-impl 2.0.3",

]

[[package]]

name = "thiserror-impl"

version = "1.0.69"

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

checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"

dependencies = [

 "proc-macro2",

 "quote",

 "syn 2.0.89",

version = "2.0.3"

checksum = "f077553d607adc1caf65430528a576c757a71ed73944b66ebb58ef2bbd243568"

 "syn 2.0.89",

version = "0.1.41"

checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"

version = "0.1.28"

checksum = "395ae124c09f9e6918a2310af6038fba074bcf474ac352496d5910dd59a2226d"

 "syn 2.0.89",

version = "0.1.33"

checksum = "e672c95779cf947c5311f83787af4fa8fffd12fb27e4993211a84bdfd9610f9c"

version = "1.0.14"

checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83"

version = "2.5.4"

checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60"

 "syn 2.0.89",

 "syn 2.0.89",

version = "0.7.5"

checksum = "120e6aef9aa629e3d4f52dc8cc43a015c7724194c97dfaf45180d2daf2b77f40"

version = "0.7.5"

checksum = "2380878cad4ac9aac1e2435f3eb4020e8374b5f13c296cb75b4620ff8e229154"

 "syn 2.0.89",

 "syn 2.0.89",

version = "0.1.5"

checksum = "cff3ee08c995dee1859d998dea82f7374f2826091dd9cd47def953cae446cd2e"

version = "0.1.5"

checksum = "595eed982f7d355beb85837f651fa22e90b3c044842dc7f2c2842c086f295808"

 "syn 2.0.89",

 "syn 2.0.89",

version = "0.14.0"

## Runs adapter on each type of event

_Want:_ CI broker runs the adapter for each type of CI event.

_Why:_ The adapter needs to handle each type of CI event.

_Who:_ `cib-devs`

We verify this by adding CI events to the event queue using `cibtool`

and checking that `cib` can process those. This is simpler and more

direct than emitting node events that result in the desired CI events.

We are here not concerned about whether `cib` handles node events or

turns those into the correct CI events: we verify that in other ways.

We first set things up, including creating a repository `xyzzy`, and a

Radicle patch in that repository. The id of the patch is in the file

`patch-id.txt` so that it can be used.

~~~scenario

given a Radicle node, with CI configured with broker.yaml and adapter dummy.sh

given a Git repository xyzzy in the Radicle node

given a directory reports

when I run ./env.sh env -C xyzzy git switch -c branchy

given file create-patch

when I run ./env.sh env -C xyzzy bash ../create-patch ../patch-id.txt

~~~

Verify that `cib` can process a branch creation event.

~~~

when I run rm -f ci-broker.db

when I run cibtool --db ci-broker.db event add --repo xyzzy --ref main --commit HEAD --kind branch-created --id-file id.txt

when I run ./env.sh cib --config broker.yaml queued

when I run cibtool --db ci-broker.db run list

then stdout has one line

~~~

Verify that `cib` can process a branch update event.

~~~

when I run rm -f ci-broker.db

when I run cibtool --db ci-broker.db event add --repo xyzzy --ref brancy --commit HEAD --base main --kind branch-updated --id-file id.txt

when I run ./env.sh cib --config broker.yaml queued

when I run cibtool --db ci-broker.db run list

then stdout has one line

~~~

Verify that `cib` can process a branch deletion event.

~~~

when I run rm -f ci-broker.db

when I run cibtool --db ci-broker.db event add --repo xyzzy --ref main --commit HEAD --kind branch-deleted --id-file id.txt

when I run ./env.sh cib --config broker.yaml queued

when I run cibtool --db ci-broker.db run list

then stdout has one line

~~~

Verify that `cib` can process a patch creation event.

~~~

when I run rm -f ci-broker.db

when I run cibtool --db ci-broker.db event add --repo xyzzy --ref main --commit HEAD --kind patch-created --patch-id-file patch-id.txt --id-file id.txt

when I run ./env.sh cib --config broker.yaml queued

when I run cibtool --db ci-broker.db run list

then stdout has one line

~~~

Verify that `cib` can process a patch update event.

~~~

when I run rm -f ci-broker.db

when I run cibtool --db ci-broker.db event add --repo xyzzy --ref main --commit HEAD --kind patch-updated --patch-id-file patch-id.txt --id-file id.txt

when I run ./env.sh cib --config broker.yaml queued

when I run cibtool --db ci-broker.db run list

then stdout has one line

~~~

~~~{#create-patch .file .sh}

#!/bin/bash

set -euo pipefail

touch foo

git add foo

git commit -m foo

EDITOR=/bin/true git push rad HEAD:refs/patches

rad patch list |

	awk 'NR == 4 { print $3 }' |

	xargs rad patch show |

	awk 'NR == 3 { print $3 }' >"$1"

~~~

when I run ./env.sh cibtool --db ci-broker.db event add --repo testy --ref main --commit HEAD --kind branch-updated --base main

when I run ./env.sh cibtool --db x.db event add --repo xyzzy --ref main --commit HEAD --base HEAD --id-file id.txt --kind branch-updated

when I run ./env.sh cibtool --db x.db event add --repo testy --ref main --commit HEAD --base HEAD --kind branch-updated

when I run ./env.sh cibtool --db x.db event add --repo testy --ref main --commit HEAD --base HEAD --kind branch-updated

when I run ./env.sh cibtool --db x.db event add --repo testy --ref main --commit HEAD --base HEAD --kind branch-updated

when I run ./env.sh cibtool --db x.db event add --repo testy --ref main --commit HEAD --base HEAD --kind branch-updated

when I run ./env.sh cibtool --db x.db event add --repo testy --ref main --commit HEAD --base HEAD --kind branch-updated

when I run ./env.sh cibtool --db x.db event add --repo testy --ref main --commit HEAD --base HEAD --kind branch-updated

## Can add a branch creation event to queue

_Want:_ `cibtool` can add an event for branch being created to the

queued events.

_Why:_ This is needed for testing.

_Who:_ `cib-devs`

~~~scenario

given a Radicle node, with CI configured with broker.yaml and adapter dummy.sh

given a Git repository xyzzy in the Radicle node

when I run ./env.sh env -C xyzzy git switch -c oksa

when I run ./env.sh cibtool --db x.db event add --repo xyzzy --ref oksa --commit HEAD --kind branch-created

when I run cibtool --db x.db event list --json

then stdout contains "BranchCreated"

~~~

## Can add a branch update event to queue

_Want:_ `cibtool` can add an event for branch being updated to the

queued events.

_Why:_ This is needed for testing.

_Who:_ `cib-devs`

~~~scenario

given a Radicle node, with CI configured with broker.yaml and adapter dummy.sh

given a Git repository xyzzy in the Radicle node

when I run ./env.sh env -C xyzzy git switch -c oksa

when I run ./env.sh cibtool --db x.db event add --repo xyzzy --ref oksa --commit HEAD --kind branch-updated --base HEAD

when I run cibtool --db x.db event list --json

then stdout contains "BranchUpdated"

~~~

## Can add a branch deletion event to queue

_Want:_ `cibtool` can add an event for branch being deleted to the

queued events.

_Why:_ This is needed for testing.

_Who:_ `cib-devs`

~~~scenario

given a Radicle node, with CI configured with broker.yaml and adapter dummy.sh

given a Git repository xyzzy in the Radicle node

when I run ./env.sh env -C xyzzy git switch -c oksa

when I run ./env.sh cibtool --db x.db event add --repo xyzzy --ref oksa --commit HEAD --kind branch-deleted

when I run cibtool --db x.db event list --json

then stdout contains "BranchDeleted"

~~~

## Can add a patch creation event to queue

_Want:_ `cibtool` can add an event for a branch being created to the

queued events.

_Why:_ This is needed for testing.

_Who:_ `cib-devs`

~~~scenario

given a Radicle node, with CI configured with broker.yaml and adapter dummy.sh

given a Git repository xyzzy in the Radicle node

when I run ./env.sh env -C xyzzy git switch -c oksa

when I run ./env.sh cibtool --db x.db event add --repo xyzzy --ref oksa --commit HEAD --kind patch-created --patch-id f863364f6774160607d90811b06a0e401c097466

when I run cibtool --db x.db event list --json

then stdout contains "PatchCreated"

~~~

## Can add a patch update event to queue

_Want:_ `cibtool` can add an event for a branch being updated to the

queued events.

_Why:_ This is needed for testing.

_Who:_ `cib-devs`

~~~scenario

given a Radicle node, with CI configured with broker.yaml and adapter dummy.sh

given a Git repository xyzzy in the Radicle node

when I run ./env.sh env -C xyzzy git switch -c oksa

when I run ./env.sh cibtool --db x.db event add --repo xyzzy --ref oksa --commit HEAD --kind patch-updated --patch-id f863364f6774160607d90811b06a0e401c097466

when I run cibtool --db x.db event list --json

then stdout contains "PatchUpdated"

~~~

when I try to run ./env.sh cibtool --db x.db event add --repo missing --ref main --commit HEAD --base c0ffee --kind branch-updated

when I try to run ./env.sh cibtool --db x.db event add --repo rad:z3byzFpcfbMJBp4tKYyuuTZiP8WUB --ref main --commit HEAD --base c0ffee --kind branch-updated

    #[error("when adding a branch-create event, the --base option is not allowed")]

    NoBaseAllowed,

    #[error("when adding a branch-update event, the --base option is required")]

    BaseRequired,

    #[error(

        "when adding a patch-create or patch--update event, the --patch-id option is required"

    )]

    PatchIdRequired,

    #[error("failed to construct a CI event")]

    CiEvent(#[source] CiEventError),

use clap::ValueEnum;

use radicle::patch::PatchId;

use radicle_ci_broker::{

    filter::EventFilter, node_event_source::NodeEventSource, util::read_file_as_objectid,

};

    /// Type of event to create.

    #[clap(long)]

    kind: EventKind,

    // The patch id to use for a patch event.

    #[clap(long)]

    patch_id: Option<PatchId>,

    // Read the patch id to use for a patch event from this file.

    #[clap(long)]

    patch_id_file: Option<PathBuf>,

        let event = match &self.kind {

            EventKind::BranchCreated => {

                if self.base.is_some() {

                    return Err(CibToolError::NoBaseAllowed);

                } else {

                    CiEvent::branch_created(nid, rid, &name, oid).map_err(CibToolError::CiEvent)?

                }

            }

            EventKind::BranchUpdated => {

                if let Some(base) = &self.base {

                    let base = if let Ok(base) = Oid::from_str(base) {

                        base

                    } else {

                        self.lookup_commit(rid, base)?

                    };

                    CiEvent::branch_updated(nid, rid, &name, oid, base)

                        .map_err(CibToolError::CiEvent)?

                } else {

                    return Err(CibToolError::BaseRequired);

                }

            }

            EventKind::BranchDeleted => {

                CiEvent::branch_deleted(nid, rid, &name, oid).map_err(CibToolError::CiEvent)?

            }

            EventKind::PatchCreated => {

                if let Some(patch_id) = &self.patch_id {

                    CiEvent::patch_created(nid, rid, *patch_id, oid)

                        .map_err(CibToolError::CiEvent)?

                } else if let Some(filename) = &self.patch_id_file {

                    let patch_id = read_file_as_objectid(filename)?;

                    CiEvent::patch_created(nid, rid, patch_id, oid)

                        .map_err(CibToolError::CiEvent)?

                } else {

                    return Err(CibToolError::PatchIdRequired);

                }

            }

            EventKind::PatchUpdated => {

                if let Some(patch_id) = &self.patch_id {

                    CiEvent::patch_updated(nid, rid, *patch_id, oid)

                        .map_err(CibToolError::CiEvent)?

                } else if let Some(filename) = &self.patch_id_file {

                    let patch_id = read_file_as_objectid(filename)?;

                    CiEvent::patch_created(nid, rid, patch_id, oid)

                        .map_err(CibToolError::CiEvent)?

                } else {

                    return Err(CibToolError::PatchIdRequired);

                }

            }

#[derive(Debug, Clone, ValueEnum)]

enum EventKind {

    BranchCreated,

    BranchUpdated,

    BranchDeleted,

    PatchCreated,

    PatchUpdated,

}

        let event =

            CiEvent::branch_updated(nid, rid, &name, oid, base).map_err(CibToolError::CiEvent)?;

    pub fn branch_deleted(

        node: NodeId,

        repo: RepoId,

        branch: &str,

        tip: Oid,

    ) -> Result<Self, CiEventError> {

        let branch =

            namespaced_branch(branch).map_err(|_| CiEventError::without_namespace2(branch))?;

        Ok(Self::V1(CiEventV1::BranchDeleted {

            from_node: node,

            repo,

            branch: RefString::try_from(branch.clone())

                .map_err(|e| CiEventError::RefString(branch.clone(), e))?,

            tip,

        }))

    }

    pub fn patch_created(

        node: NodeId,

        repo: RepoId,

        patch: PatchId,

        tip: Oid,

    ) -> Result<Self, CiEventError> {

        Ok(Self::V1(CiEventV1::PatchCreated {

            from_node: node,

            repo,

            patch,

            new_tip: tip,

        }))

    }

    pub fn patch_updated(

        node: NodeId,

        repo: RepoId,

        patch: PatchId,

        tip: Oid,

    ) -> Result<Self, CiEventError> {

        Ok(Self::V1(CiEventV1::PatchUpdated {

            from_node: node,

            repo,

            patch,

            new_tip: tip,

        }))

    }

use crate::{

    ci_event::{CiEvent, CiEventV1},

    logger,

};

                        private: !rad_repo.identity()?.visibility().is_public(),

                        private: !rad_repo.identity()?.visibility().is_public(),

            Some(CiEvent::V1(CiEventV1::BranchDeleted {

                from_node,

                repo,

                branch,

                tip,

            })) => {

                let rad_repo = profile.storage.repository(*repo)?;

                let project_info = rad_repo.project()?;

                let common = EventCommonFields {

                    version: PROTOCOL_VERSION,

                    event_type: EventType::Push,

                    repository: Repository {

                        id: *repo,

                        name: project_info.name().to_string(),

                        description: project_info.description().to_string(),

                        private: !rad_repo.identity()?.visibility().is_public(),

                        default_branch: project_info.default_branch().to_string(),

                        delegates: rad_repo.delegates()?.iter().copied().collect(),

                    },

                };

                let did = Did::from(*from_node);

                let pusher = did_to_author(profile, &did)?;

                let commits = vec![*tip];

                let push = PushEvent {

                    pusher,

                    before: *tip, // Branch created: we only use the tip

                    after: *tip,

                    branch: branch.as_str().to_string(),

                    commits,

                };

                Ok(Request::Trigger {

                    common,

                    push: Some(push),

                    patch: None,

                })

            }

                logger::debug("create Trigger from PatchCreated: open rad repository");

                logger::debug("open git repository");

                logger::debug("open project");

                logger::debug("create common fields");

                        private: !rad_repo.identity()?.visibility().is_public(),

                logger::debug("look up did and author");

                logger::debug("look up patch COB");

                logger::debug("look up revisions");

                logger::debug("look up author public key");

                logger::debug("look up latest revision");

                logger::debug("look up patch base");

                logger::debug("look up commits");

                logger::debug("construct Patch");

                logger::debug("construct Trigger");

                        private: !rad_repo.identity()?.visibility().is_public(),

                if id_doc.doc.visibility().is_public() {

            CiEvent::V1(CiEventV1::BranchDeleted {

                from_node: _,

                repo,

                branch: _,

                tip,

            }) => {

                logger::queueproc_action_run(repo, tip);

                let trigger = RequestBuilder::default()

                    .profile(&self.profile)

                    .ci_event(event)

                    .build_trigger_from_ci_event()

                    .map_err(|e| QueueError::build_trigger(event, e))?;

                self.broker

                    .execute_ci(&trigger, &self.run_tx)

                    .map_err(QueueError::execute_ci)?;

                Ok(false)

            }

            CiEvent::V1(CiEventV1::PatchCreated {

                from_node: _,

                repo,

                patch: _,

                new_tip,

            }) => {

                logger::queueproc_action_run(repo, new_tip);

                let trigger = RequestBuilder::default()

                    .profile(&self.profile)

                    .ci_event(event)

                    .build_trigger_from_ci_event()

                    .map_err(|e| QueueError::build_trigger(event, e))?;

                self.broker

                    .execute_ci(&trigger, &self.run_tx)

                    .map_err(QueueError::execute_ci)?;

                Ok(false)

            }

            CiEvent::V1(CiEventV1::PatchUpdated {

                from_node: _,

                repo,

                patch: _,

                new_tip,

            }) => {

                logger::queueproc_action_run(repo, new_tip);

                let trigger = RequestBuilder::default()

                    .profile(&self.profile)

                    .ci_event(event)

                    .build_trigger_from_ci_event()

                    .map_err(|e| QueueError::build_trigger(event, e))?;

                self.broker

                    .execute_ci(&trigger, &self.run_tx)

                    .map_err(QueueError::execute_ci)?;

                Ok(false)

            }

use std::{

    path::{Path, PathBuf},

    str::FromStr,

};

    cob::ObjectId,

pub fn read_file_as_string(filename: &Path) -> Result<String, UtilError> {

    String::from_utf8(

        std::fs::read(filename).map_err(|err| UtilError::Readfile(filename.into(), err))?,

    )

    .map_err(|err| UtilError::Utf8(filename.into(), err))

}

pub fn read_file_as_objectid(filename: &Path) -> Result<ObjectId, UtilError> {

    let s = read_file_as_string(filename)?;

    ObjectId::from_str(s.trim()).map_err(|err| UtilError::ReadObjectId(filename.into(), err))

}

    #[error("failed to read file {0}")]

    Readfile(PathBuf, #[source] std::io::Error),

    #[error("failed to convert file to UTF8: {0}")]

    Utf8(PathBuf, #[source] std::string::FromUtf8Error),

    #[error("failed to read object id from {0}")]

    ReadObjectId(PathBuf, #[source] radicle::cob::object::ParseObjectId),