weavatrix-rust 2.1.1

Protocol-independent Rust repository intelligence: typed evidence graphs for impact, architecture, APIs, Git, search, and memory
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use super::{
    Bindings, Call, Certainty, Detection, Entity, ProviderHints, Role, Transport, first_value,
    non_empty_resources, positional_values, property, resource_values,
};

pub(super) fn detect_amqp(
    call: &Call<'_, '_>,
    name: &str,
    chain: &str,
    hints: ProviderHints,
    bindings: &Bindings,
) -> Option<Detection> {
    if !is_amqp_call(name, chain, hints) {
        return None;
    }
    let positional = |index| positional_values(call, index, bindings);
    let detection = match name {
        "assertqueue" | "queuedeclare" | "queue_declare" | "createqueue" => Detection {
            transport: Transport::Amqp,
            entity: Entity::Queue,
            role: Role::Declare,
            resources: non_empty_resources(resource_values(call, &["queue", "name"], 0, bindings)),
            exchange: None,
            routing_key: None,
            consumer_group: None,
            certainty: Certainty::Exact,
            uncertainty: None,
        },
        "assertexchange" | "exchangedeclare" | "exchange_declare" => Detection {
            transport: Transport::Amqp,
            entity: Entity::Exchange,
            role: Role::Declare,
            resources: non_empty_resources(resource_values(
                call,
                &["exchange", "name"],
                0,
                bindings,
            )),
            exchange: None,
            routing_key: None,
            consumer_group: None,
            certainty: Certainty::Exact,
            uncertainty: None,
        },
        "bindqueue" | "queuebind" | "queue_bind" => binding_detection(call, bindings),
        "sendtoqueue" | "send_to_queue" => Detection {
            transport: Transport::Amqp,
            entity: Entity::Queue,
            role: Role::Producer,
            resources: non_empty_resources(positional(0)),
            exchange: None,
            routing_key: None,
            consumer_group: None,
            certainty: Certainty::Exact,
            uncertainty: None,
        },
        "consume" | "basicconsume" | "basic_consume" | "rabbitlistener" => Detection {
            transport: Transport::Amqp,
            entity: Entity::Queue,
            role: Role::Consumer,
            resources: non_empty_resources(resource_values(
                call,
                &["queue", "queues"],
                0,
                bindings,
            )),
            exchange: None,
            routing_key: None,
            consumer_group: property(call, &["consumertag", "consumer_tag"]),
            certainty: Certainty::Exact,
            uncertainty: None,
        },
        "publish" | "basicpublish" | "basic_publish" | "publishwithcontext" | "convertandsend" => {
            let exchange = first_value(call, &["exchange"], 0, bindings);
            let routing_key = first_value(call, &["routingkey", "routing_key"], 1, bindings);
            Detection {
                transport: Transport::Amqp,
                entity: Entity::Exchange,
                role: Role::Producer,
                resources: vec![exchange.clone()],
                exchange,
                routing_key,
                consumer_group: None,
                certainty: Certainty::Exact,
                uncertainty: None,
            }
        }
        _ => return None,
    };
    Some(detection)
}

fn is_amqp_call(name: &str, chain: &str, hints: ProviderHints) -> bool {
    const EXPLICIT_CALLS: &[&str] = &[
        "assertqueue",
        "queuedeclare",
        "queue_declare",
        "assertexchange",
        "exchangedeclare",
        "exchange_declare",
        "bindqueue",
        "queuebind",
        "queue_bind",
        "sendtoqueue",
        "basicpublish",
        "basic_publish",
        "basicconsume",
        "basic_consume",
        "rabbitlistener",
    ];
    hints.amqp || hints.rabbitmq || EXPLICIT_CALLS.contains(&name) || chain.contains("amqp")
}

fn binding_detection(call: &Call<'_, '_>, bindings: &Bindings) -> Detection {
    let queue = first_value(call, &["queue"], 0, bindings);
    let go_order = call.name == "QueueBind";
    let exchange = first_value(call, &["exchange"], if go_order { 2 } else { 1 }, bindings);
    let routing_key = first_value(
        call,
        &["routingkey", "routing_key", "bindingkey"],
        if go_order { 1 } else { 2 },
        bindings,
    );
    Detection {
        transport: Transport::Amqp,
        entity: Entity::Binding,
        role: Role::Bind,
        resources: vec![queue],
        exchange,
        routing_key,
        consumer_group: None,
        certainty: Certainty::Exact,
        uncertainty: None,
    }
}