refactor(policy): generalize route types in outbound index

Cargo.lock

@@ -1221,6 +1221,7 @@ dependencies = [
  "futures",
  "http",
  "hyper",
+ "itertools",
  "linkerd-policy-controller-core",
  "linkerd2-proxy-api",
  "maplit",
@@ -1258,7 +1259,6 @@ dependencies = [
  "chrono",
  "futures",
  "http",
- "k8s-gateway-api",
  "k8s-openapi",
  "kube",
  "kubert",

policy-controller/core/src/outbound.rs

@@ -1,5 +1,6 @@
 use crate::routes::{
-    GroupKindNamespaceName, HeaderModifierFilter, HostMatch, HttpRouteMatch, RequestRedirectFilter,
+    FailureInjectorFilter, GroupKindNamespaceName, HeaderModifierFilter, HostMatch, HttpRouteMatch,
+    RequestRedirectFilter,
 };
 use ahash::AHashMap as HashMap;
 use anyhow::Result;
@@ -26,9 +27,21 @@ pub struct OutboundDiscoverTarget {
     pub source_namespace: String,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum TypedOutboundRoute {
+    Http(OutboundRoute<HttpRouteMatch>),
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub enum OutboundRouteCollection {
+    #[default]
+    Empty,
+    Http(HashMap<GroupKindNamespaceName, OutboundRoute<HttpRouteMatch>>),
+}
+
 #[derive(Clone, Debug, PartialEq)]
 pub struct OutboundPolicy {
-    pub http_routes: HashMap<GroupKindNamespaceName, HttpRoute>,
+    pub routes: OutboundRouteCollection,
     pub authority: String,
     pub name: String,
     pub namespace: String,
@@ -38,18 +51,18 @@ pub struct OutboundPolicy {
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct HttpRoute {
+pub struct OutboundRoute<MatchType> {
     pub hostnames: Vec<HostMatch>,
-    pub rules: Vec<HttpRouteRule>,
+    pub rules: Vec<OutboundRouteRule<MatchType>>,
 
-    /// This is required for ordering returned `HttpRoute`s by their creation
-    /// timestamp.
+    /// This is required for ordering returned routes
+    /// by their creation timestamp.
     pub creation_timestamp: Option<DateTime<Utc>>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct HttpRouteRule {
-    pub matches: Vec<HttpRouteMatch>,
+pub struct OutboundRouteRule<MatchType> {
+    pub matches: Vec<MatchType>,
     pub backends: Vec<Backend>,
     pub request_timeout: Option<time::Duration>,
     pub backend_request_timeout: Option<time::Duration>,
@@ -98,4 +111,53 @@ pub enum Filter {
     RequestHeaderModifier(HeaderModifierFilter),
     ResponseHeaderModifier(HeaderModifierFilter),
     RequestRedirect(RequestRedirectFilter),
+    FailureInjector(FailureInjectorFilter),
+}
+
+// === impl TypedOutboundRoute ===
+
+impl From<OutboundRoute<HttpRouteMatch>> for TypedOutboundRoute {
+    fn from(route: OutboundRoute<HttpRouteMatch>) -> Self {
+        Self::Http(route)
+    }
+}
+
+// === impl OutboundRouteCollection ===
+
+impl OutboundRouteCollection {
+    pub fn is_empty(&self) -> bool {
+        matches!(self, Self::Empty)
+    }
+
+    pub fn remove(&mut self, key: &GroupKindNamespaceName) {
+        match self {
+            Self::Empty => {}
+            Self::Http(routes) => {
+                routes.remove(key);
+                if routes.is_empty() {
+                    *self = Self::Empty;
+                }
+            }
+        }
+    }
+
+    pub fn insert<Route: Into<TypedOutboundRoute>>(
+        &mut self,
+        key: GroupKindNamespaceName,
+        route: Route,
+    ) -> Result<Option<TypedOutboundRoute>> {
+        let route = route.into();
+
+        match (self, route) {
+            (this @ Self::Empty, TypedOutboundRoute::Http(route)) => {
+                let mut routes = HashMap::default();
+                let inserted = routes.insert(key, route).map(Into::into);
+                *this = Self::Http(routes);
+                Ok(inserted)
+            }
+            (Self::Http(routes), TypedOutboundRoute::Http(route)) => {
+                Ok(routes.insert(key, route).map(Into::into))
+            }
+        }
+    }
 }

policy-controller/core/src/routes.rs

@@ -1,4 +1,5 @@
 use anyhow::Result;
+
 pub use http::{
     header::{HeaderName, HeaderValue},
     uri::Scheme,
@@ -8,7 +9,6 @@ use regex::Regex;
 use std::{borrow::Cow, num::NonZeroU16};
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
-
 pub struct GroupKindName {
     pub group: Cow<'static, str>,
     pub kind: Cow<'static, str>,
@@ -126,6 +126,19 @@ impl GroupKindName {
     }
 }
 
+// === impl HttpRouteMatch ===
+
+impl Default for HttpRouteMatch {
+    fn default() -> Self {
+        Self {
+            method: None,
+            headers: vec![],
+            query_params: vec![],
+            path: Some(PathMatch::Prefix("/".to_string())),
+        }
+    }
+}
+
 // === impl PathMatch ===
 
 impl PartialEq for PathMatch {

policy-controller/grpc/Cargo.toml

@@ -10,8 +10,9 @@ async-stream = "0.3"
 async-trait = "0.1"
 http = "0.2"
 drain = "0.1"
-hyper = { version = "0.14", features = ["http2", "server", "tcp"] }
 futures = { version = "0.3", default-features = false }
+hyper = { version = "0.14", features = ["http2", "server", "tcp"] }
+itertools = "0.12"
 linkerd-policy-controller-core = { path = "../core" }
 maplit = "1"
 prost-types = "0.12.6"