benjamin-bergia/karbon - Change 4MK5VE34SUDTEN2C2VVFBEONHGFY3P3EDTEK2WPU7RH5IWDAT3DQC

Before removing serde

Created by ITChap on February 14, 2022

4MK5VE34SUDTEN2C2VVFBEONHGFY3P3EDTEK2WPU7RH5IWDAT3DQC

Dependencies

In channels

main

Change contents

Replacement in testApp/overlays/web/karbon.yml at line 12 [2.264]

B:BD[2.445] → [2.445:503]

      kind: Deployment
      metadata:
        name: test

[2.445]

[2.503]

      /kind: Deployment
      /metadata/name: test

Replacement in testApp/overlays/web/karbon.yml at line 16 [2.264]

B:BD[2.579] → [2.579:726]

      .spec.revisionHistoryLimit: 3
      spec:
        strategy:
          rollingUpdate:
            maxUnavailable: 0
            maxSurge: 50%

[2.579]

      /spec/revisionHistoryLimit: 3
      /spec/strategy/rollingUpdate/maxUnavailable: 0
      /spec/strategy/rollingUpdate/maxSurge: 50%

Replacement in testApp/environments/prod/karbon.yml at line 9 [3.4413]
B:BD[3.4542] → [3.4542:4562]
```
  - namespace: prod
```
[3.4542]
```
  - add:
      /metadata/namespace: prod
```
Replacement in testApp/base/karbon.yml at line 7 [2.1300]
B:BD[2.1385] → [2.1385:1405]
```
transformations: []
```
[2.1385]
```
transformations:
  - labels:
      this-label-comes-from: base
```
Replacement in src/main.rs at line 2 [3.21]
B:BD[3.54] → [4.2:52]
```
use serde::{Deserialize};
use serde_yaml::{self};
```
[3.54]
[3.111]
```
use serde_yaml;
```

Replacement in src/main.rs at line 4 [3.21]

B:BD[3.131] → [3.131:157]

B:BD[3.157] → [2.1863:1927]

use std::path::{PathBuf};
use std::collections::{HashMap};
use std::hash::{Hash, Hasher};

[3.131]

[3.188]

use std::path::PathBuf;
mod karbonfile;
use karbonfile::*;

Deletion in src/main.rs at line 23 [3.21]
B:BD[3.372] → [2.1928:1965]
∅:D[2.1965] → [4.71:106]
B:BD[3.402] → [4.71:106]
B:BD[4.106] → [2.1966:1996]
∅:D[4.106] → [3.402:447]
∅:D[2.1996] → [3.402:447]
B:BD[3.402] → [3.402:447]
B:BD[3.447] → [4.107:125]
∅:D[4.125] → [3.465:487]
B:BD[3.465] → [3.465:487]
B:BD[3.487] → [2.1997:2035]
∅:D[2.2035] → [3.516:636]
B:BD[3.516] → [3.516:636]
```
#[derive(Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
#[serde(deny_unknown_fields)]
struct Karbonfile {
    api_version: String,
    kind: String,
    #[serde(default)]
    resources: HashMap<Resource, ()>,
    #[serde(default)]
    generators: Vec<Generator>,
    #[serde(default)]
    transformations: Vec<Transformation>,
}
```

Deletion in src/main.rs at line 24 [3.21]

B:BD[3.637] → [2.2036:2825]

∅:D[2.2825] → [3.667:767]

B:BD[3.667] → [3.667:767]

B:BD[3.767] → [2.2826:2863]

∅:D[2.2863] → [3.797:827]

B:BD[3.797] → [3.797:827]

B:BD[3.827] → [2.2864:2899]

∅:D[2.2899] → [3.827:851]

B:BD[3.827] → [3.827:851]

B:BD[3.938] → [3.938:960]

B:BD[3.960] → [2.2900:2939]

∅:D[2.2939] → [3.989:1011]

B:BD[3.989] → [3.989:1011]

B:BD[3.1011] → [2.2940:2971]

∅:D[2.2971] → [3.1029:1051]

B:BD[3.1029] → [3.1029:1051]

B:BD[3.1051] → [2.2972:2998]

∅:D[2.2998] → [3.1211:1233]

B:BD[3.1211] → [3.1211:1233]

B:BD[3.1233] → [2.2999:3044]

∅:D[2.3044] → [3.1256:1278]

B:BD[3.1256] → [3.1256:1278]

B:BD[3.1278] → [2.3045:3083]

∅:D[2.3083] → [3.1303:1325]

B:BD[3.1303] → [3.1303:1325]

B:BD[3.1325] → [2.3084:3126]

∅:D[2.3126] → [3.1343:1365]

B:BD[3.1343] → [3.1343:1365]

B:BD[3.1365] → [2.3127:3168]

∅:D[2.3168] → [3.1383:1405]

B:BD[3.1383] → [3.1383:1405]

B:BD[3.1405] → [2.3169:3202]

∅:D[2.3202] → [3.1428:1450]

B:BD[3.1428] → [3.1428:1450]

B:BD[3.1450] → [2.3203:3236]

∅:D[2.3236] → [3.1487:1490]

B:BD[3.1487] → [3.1487:1490]

#[derive(Deserialize, Clone, Debug)]
#[serde(rename_all = "lowercase")]
#[serde(deny_unknown_fields)]
enum Resource {
    Files(PathBuf),
    Karbonfile(PathBuf),
    //Git { path: PathBuf },
}
impl Resource {
    fn path(&self) -> PathBuf {
        use Resource::*;
        match self {
            Files(p) => { p.clone() }
            Karbonfile(p) => { p.clone() }
        }
    }
}
impl PartialEq for Resource {
    fn eq(&self, other: &Self) -> bool {
        self.path() == other.path()
    }
}
impl Eq for Resource {}
impl Hash for Resource {
    fn hash<H: Hasher>(&self, state: &mut H) {
        use Resource::*;
        match self {
            Files(p) => p.hash(state),
            Karbonfile(p) => p.hash(state),
        }
    }
}
#[derive(Deserialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
#[serde(rename_all = "camelCase")]
enum Generator {
    ConfigMap,
}
#[derive(Deserialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
#[serde(rename_all = "camelCase")]
struct Transformation {
    #[serde(default)]
    filter: Option<serde_yaml::Value>,
    #[serde(default)]
    namespace: Option<String>,
    #[serde(default)]
    replicas: Option<u8>,
    #[serde(default)]
    labels: Option<HashMap<String, String>>,
    #[serde(default)]
    add: Option<serde_yaml::Mapping>,
    #[serde(default)]
    replace: Option<serde_yaml::Mapping>,
    #[serde(default)]
    remove: Option<serde_yaml::Mapping>,
    #[serde(default)]
    name_prefix: Option<String>,
    #[serde(default)]
    name_suffix: Option<String>,
}

Deletion in src/main.rs at line 51 [3.21]

B:BD[4.853] → [2.3237:3274]

∅:D[2.3274] → [4.883:985]

B:BD[4.883] → [4.883:985]

#[derive(Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
struct ResourceType {
    api_version: String,
    kind: String,
}

Insertion in src/main.rs at line 74 [3.21]

[4.1470]

[3.2417]


fn parse_resource(path: &PathBuf) -> serde_yaml::Value {
    let file = fs::File::open(path)
        .expect("Failed to open the file.");

Insertion in src/main.rs at line 79 [3.21]

[3.2418]

[4.1471]

    return serde_yaml::from_reader(file)
        .expect("Failed to parse the file.");
}

Deletion in src/main.rs at line 111 [3.21]

B:BD[2.3334] → [2.3334:3482]

∅:D[2.3482] → [4.2589:2591]

B:BD[4.2589] → [4.2589:2591]

B:BD[4.2591] → [2.3483:3667]


#[derive(Clone, Debug)]
struct TransformationSet {
    resource_path: Option<PathBuf>,
    transformations: HashMap<PathBuf, Vec<Transformation>>,
}
impl TransformationSet {
    fn new() -> TransformationSet {
        TransformationSet {
            resource_path: None,
            transformations: HashMap::new(),
        }
    }

Deletion in src/main.rs at line 112 [3.21]

B:BD[3.2540] → [2.3668:3753]

    fn set_path(&mut self, p: PathBuf) {
        self.resource_path = Some(p);
    }

Replacement in src/main.rs at line 113 [3.21]

B:BD[2.3754] → [2.3754:3880]

    fn add_transformation(&mut self, p: PathBuf, t: Vec<Transformation>) {
        self.transformations.insert(p, t);
    }
}

[2.3754]

[3.2661]

fn build_tree(
    path: PathBuf,
    mut tset: TransformationSet,
    result: &mut Vec<TransformationSet>) {

Deletion in src/main.rs at line 118 [3.21]

B:BD[3.2662] → [2.3881:3978]

fn build_tree(path: PathBuf, mut tset: TransformationSet, result: &mut Vec<TransformationSet>) {

Replacement in src/main.rs at line 125 [3.21]

B:BD[2.4152] → [2.4152:4189]

            .map(|(k, v)| k.clone())

[2.4152]

[4.2974]

            .map(|(k, _)| k.clone())

Insertion in src/main.rs at line 133 [3.21]

[4.3126]

[2.4272]

            // Set the path and push the branch to result

Insertion in src/main.rs at line 135 [3.21]
[2.4318]
[4.3159]
```
            result.push(tset);
```
Deletion in src/main.rs at line 142 [3.21]
∅:D[4.3435] → [3.2973:2974]
∅:D[2.4390] → [3.2973:2974]
B:BD[3.2973] → [3.2973:2974]

Replacement in src/main.rs at line 147 [3.21]

B:BD[2.4498] → [2.4498:4544]

        // Add the path to the resource_path.

[2.4498]

[2.4544]

        // Set the path and push the branch to result
        tset.set_original(parse_resource(&canonical));

Insertion in src/main.rs at line 150 [3.21]

[2.4586]

[3.3252]

        tset.apply_transformations();
        result.push(tset);

Insertion in src/main.rs at line 153 [3.21]
[3.3258]
[2.4587]
```
}
```
Replacement in src/main.rs at line 155 [3.21]
B:BD[2.4588] → [2.4588:4611]
∅:D[2.4611] → [3.3258:3260]
B:BD[3.3258] → [3.3258:3260]
```
    result.push(tset);
}
```
[2.4588]
[3.3260]

Replacement in src/main.rs at line 167 [3.21]

B:BD[3.3425] → [2.4748:4788]

            println!("{:#?}", &result);

[3.3425]

[3.3579]

            for i in result {
                if let Ok(r) = serde_yaml::to_string(&i.transformed) {
                    println!("{}", &r);
                }
            }

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

[3.4]

use serde::Deserialize;
use serde_yaml::{self, Value, Mapping};
use std::path::PathBuf;
use std::collections::HashMap;
use std::hash::{Hash, Hasher};
#[derive(Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
#[serde(deny_unknown_fields)]
pub struct Karbonfile {
    pub api_version: String,
    pub kind: String,
    #[serde(default)]
    pub resources: HashMap<Resource, ()>,
    #[serde(default)]
    pub generators: Vec<Generator>,
    #[serde(default)]
    pub transformations: Vec<Transformation>,
}
#[derive(Deserialize, Clone, Debug)]
#[serde(rename_all = "lowercase")]
#[serde(deny_unknown_fields)]
pub enum Resource {
    Files(PathBuf),
    Karbonfile(PathBuf),
    //Git { path: PathBuf },
}
impl Resource {
    pub fn path(&self) -> PathBuf {
        use Resource::*;
        match self {
            Files(p) => { p.clone() }
            Karbonfile(p) => { p.clone() }
        }
    }
}
impl PartialEq for Resource {
    fn eq(&self, other: &Self) -> bool {
        self.path() == other.path()
    }
}
impl Eq for Resource {}
impl Hash for Resource {
    fn hash<H: Hasher>(&self, state: &mut H) {
        use Resource::*;
        match self {
            Files(p) => p.hash(state),
            Karbonfile(p) => p.hash(state),
        }
    }
}
#[derive(Deserialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
#[serde(rename_all = "camelCase")]
pub enum Generator {
    ConfigMap,
}
#[derive(Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct ResourceType {
    pub api_version: String,
    pub kind: String,
}
#[derive(Clone, Debug)]
pub struct TransformationSet {
    pub path: Option<PathBuf>,
    pub original: Option<Value>,
    pub transformed: Option<Value>,
    pub transformations: OrderedMap,
}
impl TransformationSet {
    pub fn new() -> TransformationSet {
        TransformationSet {
            path: None,
            original: None,
            transformed: None,
            transformations: OrderedMap::new(),
        }
    }
    pub fn set_path(&mut self, p: PathBuf) {
        self.path = Some(p);
    }
    pub fn set_original(&mut self, r: Value) {
        self.original = Some(r);
    }
    fn set_transformed(&mut self, r: Value) {
        self.transformed = Some(r);
    }
    pub fn add_transformation(&mut self, p: PathBuf, t: Vec<Transformation>) {
        self.transformations.push(p, t);
    }
    pub fn apply_transformations(&mut self) {
        if let Some(mut result) = self.original.to_owned() {
            for k in self.transformations.keys() {
                if let Some(ts) = self.transformations.get(&k) {
                    for t in ts {
                        if let Some(f) = t.filter {
                            if !is_filter_match(&result, &f) {
                                // if the filter is provided but doesn't match
                                // stop processing this transformation and
                                // move to the next one.
                                break;
                            }
                        }
                        // This will run unless the filter is provided and doesn't match
                        // labels: Option<HashMap<String, String>>,
                        // add: Option<serde_yaml::Mapping>,
                        // replace: Option<serde_yaml::Mapping>,
                        // remove: Option<serde_yaml::Mapping>,
                        // name_prefix: Option<String>,
                        // name_suffix: Option<String>,
                        if let Some(labels) = t.labels {
                            //for path in label_fields {
                            //    for (k, v) in labels.iter() {
                            //        *pointer_mut(&mut result, &format!("{path}/{k}")).unwrap() = Value::String(v.into());
                            //    }
                            //}
                        }
                        if let Some(add) = t.add {
                            for (k, v) in add.iter() {
                                let updated = pointer_mut(&mut result, k.as_str().unwrap()).unwrap();
                                *updated = v.to_owned();
                            }
                        }
                        if let Some(replace) = t.replace {
                        }
                        if let Some(remove) = t.remove {
                        }
                        if let Some(prefix) = t.name_prefix {
                            if let Value::String(current) = &result["metadata"]["name"] {
                                let new = format!("{prefix}{current}");
                                result["metadata"]["name"] = Value::String(new.into());
                            }
                        }
                        if let Some(suffix) = t.name_suffix {
                            if let Value::String(current) = &result["metadata"]["name"] {
                                let new = format!("{current}{suffix}");
                                result["metadata"]["name"] = Value::String(new.into());
                            }
                        }
                    }
                }
            }
            self.transformed = Some(result);
        }
    }
}
fn is_filter_match(doc: &Value, filter: &Mapping) -> bool {
    for (field, value) in filter.iter() {
        if let Value::String(f) = field {
            if pointer(doc, f).unwrap() != value {
                return false;
            }
        }
    }
    true
}
fn pointer<'a>(doc: &'a Value, pointer: &'a str) -> Option<&'a Value> {
    // Taken from serde JSON
    if pointer.is_empty() {
        return Some(doc);
    }
    if !pointer.starts_with('/') {
        return None;
    }
    pointer
        .split('/')
        .skip(1)
        .map(|x| x.replace("~1", "/").replace("~0", "~"))
        .try_fold(doc, |target, token| {
            match target {
                Value::Mapping(map) => {
                    let t: Value = serde_yaml::from_str(&token).unwrap();
                    map.get(&t)
                }
                Value::Sequence(seq) => {
                    let t: usize = token.parse().unwrap();
                    seq.get(t)
                }
                _ => None,
            }
        })
}
fn pointer_mut<'a>(doc: &'a mut Value, pointer: &'a str) -> Option<&'a mut Value> {
    // Taken from serde JSON
    if pointer.is_empty() {
        return Some(doc);
    }
    if !pointer.starts_with('/') {
        return None;
    }
    pointer
        .split('/')
        .skip(1)
        .map(|x| x.replace("~1", "/").replace("~0", "~"))
        .try_fold(doc, |target, token| {
            match target {
                Value::Mapping(map) => {
                    let t: Value = serde_yaml::from_str(&token).unwrap();
                    map.get_mut(&t)
                }
                Value::Sequence(seq) => {
                    let t: usize = token.parse().unwrap();
                    seq.get_mut(t)
                }
                _ => None,
            }
        })
}
#[derive(Clone, Debug)]
pub struct OrderedMap {
    index: Vec<PathBuf>,
    map: HashMap<PathBuf, Vec<Transformation>>,
}
impl OrderedMap {
    pub fn new() -> OrderedMap {
        OrderedMap {
            index: Vec::new(),
            map: HashMap::new(),
        }
    }
    pub fn push(&mut self, k: PathBuf, v: Vec<Transformation>) {
        self.map.entry(k.clone()).or_insert(v);
        self.index.push(k)
    }
    fn to_vec(&self) -> Vec<(PathBuf, Vec<Transformation>)> {
        self.index.iter()
            .map( |k| self.map.get_key_value(k).unwrap() )
            .map( |(k, v)| (k.to_owned(), v.to_owned()) )
            .collect()
    }
    fn keys(&self) -> Vec<PathBuf> {
        self.index.clone()
    }
    fn get(&self, k: &PathBuf) -> Option<Vec<Transformation>> {
        self.map.get(k).map(|v| v.to_owned())
    }
}
#[derive(Deserialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
#[serde(rename_all = "camelCase")]
pub struct Transformation {
    #[serde(default)]
    filter: Option<Mapping>,
    #[serde(default)]
    labels: Option<HashMap<String, String>>,
    #[serde(default)]
    add: Option<Mapping>,
    #[serde(default)]
    replace: Option<Mapping>,
    #[serde(default)]
    remove: Option<Mapping>,
    #[serde(default)]
    name_prefix: Option<String>,
    #[serde(default)]
    name_suffix: Option<String>,
}
const label_fields: [&'static str; 30] = [
    "/metadata/labels",
    "/spec/selector",
    "/spec/template/metadata/labels",
    "/spec/selector/matchLabels",
    "/spec/template/metadata/labels",
    "/spec/template/spec/affinity/podAffinity/preferredDuringSchedulingIgnoredDuringExecution/podAffinityTerm/labelSelector/matchLabels",
    "/spec/template/spec/affinity/podAffinity/requiredDuringSchedulingIgnoredDuringExecution/labelSelector/matchLabels",
    "/spec/template/spec/affinity/podAntiAffinity/preferredDuringSchedulingIgnoredDuringExecution/podAffinityTerm/labelSelector/matchLabels",
    "/spec/template/spec/affinity/podAntiAffinity/requiredDuringSchedulingIgnoredDuringExecution/labelSelector/matchLabels",
    "/spec/template/spec/topologySpreadConstraints/labelSelector/matchLabels",
    "/spec/selector/matchLabels",
    "/spec/template/metadata/labels",
    "/spec/selector/matchLabels",
    "/spec/template/metadata/labels",
    "/spec/selector/matchLabels",
    "/spec/template/metadata/labels",
    "/spec/template/spec/affinity/podAffinity/preferredDuringSchedulingIgnoredDuringExecution/podAffinityTerm/labelSelector/matchLabels",
    "/spec/template/spec/affinity/podAffinity/requiredDuringSchedulingIgnoredDuringExecution/labelSelector/matchLabels",
    "/spec/template/spec/affinity/podAntiAffinity/preferredDuringSchedulingIgnoredDuringExecution/podAffinityTerm/labelSelector/matchLabels",
    "/spec/template/spec/affinity/podAntiAffinity/requiredDuringSchedulingIgnoredDuringExecution/labelSelector/matchLabels",
    "/spec/template/spec/topologySpreadConstraints/labelSelector/matchLabels",
    //"/spec/volumeClaimTemplates[]/metadata/labels",
    "/spec/selector/matchLabels",
    "/spec/template/metadata/labels",
    "/spec/jobTemplate/spec/selector/matchLabels",
    "/spec/jobTemplate/metadata/labels",
    "/spec/jobTemplate/spec/template/metadata/labels",
    "/spec/selector/matchLabels",
    "/spec/podSelector/matchLabels",
    "/spec/ingress/from/podSelector/matchLabels",
    "/spec/egress/to/podSelector/matchLabels",
];