konveyor-core 0.0.2

Shared types, gRPC protocol, and provider SDK for the Konveyor migration ecosystem
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

//! Konveyor provider gRPC protocol and SDK.
//!
//! This module provides:
//! - Proto-generated types and service traits from `provider.proto`
//! - An ergonomic `Provider` trait that hides proto complexity
//! - `From` implementations for converting between ergonomic and proto types
//! - Generic server functions (`serve_tcp`, `serve_unix`) for any `Provider` impl

pub mod provider;
pub mod server;

/// Generated protobuf code from `provider.proto`.
///
/// Contains the raw tonic/prost types: `ProviderService` trait,
/// `ProviderCodeLocationService` trait, and all message types.
/// Prefer using the ergonomic `Provider` trait and `crate::incident` types
/// instead of these proto types directly.
pub mod proto {
    include!("generated/provider.rs");

    pub(crate) const FILE_DESCRIPTOR_SET: &[u8] =
        include_bytes!("generated/provider_service_descriptor.bin");
}

// ── Proto <-> Ergonomic type conversions ────────────────────────────────

use crate::incident;

/// Convert a `serde_json::Value` to a `prost_types::Value`.
fn json_to_prost_value(v: &serde_json::Value) -> prost_types::Value {
    match v {
        serde_json::Value::String(s) => prost_types::Value {
            kind: Some(prost_types::value::Kind::StringValue(s.clone())),
        },
        serde_json::Value::Number(n) => prost_types::Value {
            kind: Some(prost_types::value::Kind::NumberValue(
                n.as_f64().unwrap_or_default(),
            )),
        },
        serde_json::Value::Bool(b) => prost_types::Value {
            kind: Some(prost_types::value::Kind::BoolValue(*b)),
        },
        serde_json::Value::Null => prost_types::Value {
            kind: Some(prost_types::value::Kind::NullValue(0)),
        },
        _ => prost_types::Value {
            kind: Some(prost_types::value::Kind::StringValue(v.to_string())),
        },
    }
}

impl From<&incident::Incident> for proto::IncidentContext {
    fn from(incident: &incident::Incident) -> Self {
        let variables = if incident.variables.is_empty() {
            None
        } else {
            let fields = incident
                .variables
                .iter()
                .map(|(k, v)| {
                    let prost_value = json_to_prost_value(v);
                    (k.clone(), prost_value)
                })
                .collect();
            Some(prost_types::Struct { fields })
        };

        proto::IncidentContext {
            file_uri: incident.file_uri.clone(),
            effort: incident.effort,
            code_location: incident.code_location.as_ref().map(|loc| proto::Location {
                start_position: Some(proto::Position {
                    line: loc.start.line as f64,
                    character: loc.start.character as f64,
                }),
                end_position: Some(proto::Position {
                    line: loc.end.line as f64,
                    character: loc.end.character as f64,
                }),
            }),
            line_number: incident.line_number.map(|n| n as i64),
            variables,
            links: incident
                .links
                .iter()
                .map(|l| proto::ExternalLink {
                    url: l.url.clone(),
                    title: l.title.clone(),
                })
                .collect(),
            is_dependency_incident: incident.is_dependency_incident,
        }
    }
}

impl From<&incident::Position> for proto::Position {
    fn from(pos: &incident::Position) -> Self {
        proto::Position {
            line: pos.line as f64,
            character: pos.character as f64,
        }
    }
}

impl From<&incident::Location> for proto::Location {
    fn from(loc: &incident::Location) -> Self {
        proto::Location {
            start_position: Some(proto::Position::from(&loc.start)),
            end_position: Some(proto::Position::from(&loc.end)),
        }
    }
}

impl From<&incident::ExternalLink> for proto::ExternalLink {
    fn from(link: &incident::ExternalLink) -> Self {
        proto::ExternalLink {
            url: link.url.clone(),
            title: link.title.clone(),
        }
    }
}