Work in progress

policies/resource-types/directory/README.md

@@ -1,4 +1,4 @@
-= Template
+# Template
 
 Template resource type.
 

policies/resource-types/template/README.md

@@ -1,3 +1,3 @@
-= Directory
+# Directory
 
 Directory resource type.

policies/rudderc/docs/examples/ntp.yml

@@ -26,3 +26,5 @@ resources:
           enforce: "true"
         reporting:
           enabled: true
+files:
+  - ntp.conf.tpl

policies/rudderc/src/ir/resource.rs

@@ -3,6 +3,8 @@
 
 use anyhow::{bail, Error};
 use std::collections::HashMap;
+use std::fmt;
+use std::path::PathBuf;
 use std::str::FromStr;
 
 use serde::{de, Deserialize, Deserializer, Serialize};
@@ -64,9 +66,28 @@ pub struct Policy {
     pub id: Id,
     pub name: String,
     pub version: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub category: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub description: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub documentation: Option<String>,
     pub resources: Vec<Resource>,
+    #[serde(default)]
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub parameters: Vec<Parameter>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    #[serde(default)]
+    pub files: Vec<PathBuf>,
+}
+
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Parameter {
+    id: Id,
+    name: String,
+    description: Option<String>,
+    // FIXME represent as constraint?
+    may_be_empty: bool,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
@@ -78,7 +99,7 @@ pub enum Resource {
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct BlockResource {
-    pub condition: String,
+    pub condition: ConditionExpr,
     pub name: String,
     pub params: HashMap<String, String>,
     #[serde(rename = "type")]
@@ -95,7 +116,6 @@ pub struct LeafResource {
     pub params: HashMap<String, String>,
     #[serde(rename = "type")]
     pub resource_type: String,
-    // contains either states or resources
     pub states: Vec<State>,
     pub id: Id,
     pub reporting: Option<ReportingPolicy>,
@@ -105,7 +125,7 @@ pub struct LeafResource {
 pub struct State {
     // TODO specific type with custom deserializer that check validity
     // class regex or variables
-    pub condition: String,
+    pub condition: ConditionExpr,
     pub id: Id,
     pub meta: Value,
     pub name: String,
@@ -150,3 +170,59 @@ impl Default for ReportingCompute {
         ReportingCompute::Weighted
     }
 }
+
+/// Valid condition expression
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
+#[serde(transparent)]
+pub struct ConditionExpr {
+    inner: String,
+}
+
+impl AsRef<String> for ConditionExpr {
+    fn as_ref(&self) -> &String {
+        &self.inner
+    }
+}
+
+impl fmt::Display for ConditionExpr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.inner)
+    }
+}
+
+impl From<ConditionExpr> for String {
+    fn from(c: ConditionExpr) -> Self {
+        c.inner
+    }
+}
+
+impl FromStr for ConditionExpr {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        fn valid_char(c: char) -> bool {
+            // Ideally, we could parse and validate condition expressions.
+            // For now, let's only check for disallowed chars instead.
+            let valid_chars = ['"', '$', '{', '}', '|', '&', ' '];
+            c.is_ascii_alphanumeric() || valid_chars.contains(&c)
+        }
+
+        if s.chars().all(valid_char) {
+            Ok(ConditionExpr {
+                inner: s.to_string(),
+            })
+        } else {
+            bail!("Invalid id: {}", s)
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ConditionExpr {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        FromStr::from_str(&s).map_err(de::Error::custom)
+    }
+}