Add Pass & Drop filters

build.rs

@@ -32,8 +32,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         "proto/quilkin/extensions/filters/capture_bytes/v1alpha1/capture_bytes.proto",
         "proto/quilkin/extensions/filters/compress/v1alpha1/compress.proto",
         "proto/quilkin/extensions/filters/concatenate_bytes/v1alpha1/concatenate_bytes.proto",
+        "proto/quilkin/extensions/filters/drop/v1alpha1/drop.proto",
         "proto/quilkin/extensions/filters/load_balancer/v1alpha1/load_balancer.proto",
         "proto/quilkin/extensions/filters/local_rate_limit/v1alpha1/local_rate_limit.proto",
+        "proto/quilkin/extensions/filters/pass/v1alpha1/pass.proto",
         "proto/quilkin/extensions/filters/token_router/v1alpha1/token_router.proto",
         "proto/quilkin/extensions/filters/firewall/v1alpha1/firewall.proto",
     ]

proto/quilkin/extensions/filters/drop/v1alpha1/drop.proto

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+syntax = "proto3";
+
+package quilkin.extensions.filters.drop.v1alpha1;
+
+import "google/protobuf/wrappers.proto";
+
+message Drop {
+}
+

proto/quilkin/extensions/filters/pass/v1alpha1/pass.proto

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+syntax = "proto3";
+
+package quilkin.extensions.filters.pass.v1alpha1;
+
+import "google/protobuf/wrappers.proto";
+
+message Pass {
+}
+

src/filters.rs

@@ -30,10 +30,12 @@ pub mod capture_bytes;
 pub mod compress;
 pub mod concatenate_bytes;
 pub mod debug;
+pub mod drop;
 pub mod firewall;
 pub mod load_balancer;
 pub mod local_rate_limit;
 pub mod metadata;
+pub mod pass;
 pub mod token_router;
 
 /// Prelude containing all types and traits required to implement [`Filter`] and

src/filters/drop.rs

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use std::convert::TryFrom;
+
+use crate::filters::prelude::*;
+use serde::{Deserialize, Serialize};
+
+crate::include_proto!("quilkin.extensions.filters.drop.v1alpha1");
+use self::quilkin::extensions::filters::drop::v1alpha1 as proto;
+
+/// Always drops a packet, mostly useful in combination with other filters.
+struct Drop;
+
+pub const NAME: &str = "quilkin.extensions.filters.drop.v1alpha1.Drop";
+
+/// Creates a new factory for generating debug filters.
+pub fn factory() -> DynFilterFactory {
+    Box::from(DropFactory::new())
+}
+
+impl Drop {
+    fn new() -> Self {
+        Self
+    }
+}
+
+impl Filter for Drop {
+    #[cfg_attr(feature = "instrument", tracing::instrument(skip(self, ctx)))]
+    fn read(&self, _: ReadContext) -> Option<ReadResponse> {
+        None
+    }
+
+    #[cfg_attr(feature = "instrument", tracing::instrument(skip(self, ctx)))]
+    fn write(&self, _: WriteContext) -> Option<WriteResponse> {
+        None
+    }
+}
+
+/// Factory for the Debug
+struct DropFactory;
+
+impl DropFactory {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl FilterFactory for DropFactory {
+    fn name(&self) -> &'static str {
+        NAME
+    }
+
+    fn create_filter(&self, args: CreateFilterArgs) -> Result<FilterInstance, Error> {
+        let config: Option<(_, Config)> = args
+            .config
+            .map(|config| config.deserialize::<Config, proto::Drop>(self.name()))
+            .transpose()?;
+
+        let (config_json, _) = config
+            .map(|(config_json, config)| (config_json, Some(config)))
+            .unwrap_or_else(|| (serde_json::Value::Null, None));
+
+        Ok(FilterInstance::new(
+            config_json,
+            Box::new(Drop::new()) as Box<dyn Filter>,
+        ))
+    }
+}
+
+/// `pass` filter's configuration.
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Config;
+
+impl TryFrom<proto::Drop> for Config {
+    type Error = ConvertProtoConfigError;
+
+    fn try_from(_: proto::Drop) -> Result<Self, Self::Error> {
+        Ok(Config)
+    }
+}

src/filters/pass.rs

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use std::convert::TryFrom;
+
+use crate::filters::prelude::*;
+use serde::{Deserialize, Serialize};
+
+crate::include_proto!("quilkin.extensions.filters.pass.v1alpha1");
+use self::quilkin::extensions::filters::pass::v1alpha1 as proto;
+
+/// Allows a packet to pass through, mostly useful in combination with
+/// other filters.
+struct Pass;
+
+pub const NAME: &str = "quilkin.extensions.filters.pass.v1alpha1.Pass";
+
+/// Creates a new factory for generating debug filters.
+pub fn factory() -> DynFilterFactory {
+    Box::from(PassFactory::new())
+}
+
+impl Pass {
+    fn new() -> Self {
+        Self
+    }
+}
+
+impl Filter for Pass {
+    #[cfg_attr(feature = "instrument", tracing::instrument(skip(self, ctx)))]
+    fn read(&self, ctx: ReadContext) -> Option<ReadResponse> {
+        Some(ctx.into())
+    }
+
+    #[cfg_attr(feature = "instrument", tracing::instrument(skip(self, ctx)))]
+    fn write(&self, ctx: WriteContext) -> Option<WriteResponse> {
+        Some(ctx.into())
+    }
+}
+
+/// Factory for the Debug
+struct PassFactory;
+
+impl PassFactory {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl FilterFactory for PassFactory {
+    fn name(&self) -> &'static str {
+        NAME
+    }
+
+    fn create_filter(&self, args: CreateFilterArgs) -> Result<FilterInstance, Error> {
+        let config: Option<(_, Config)> = args
+            .config
+            .map(|config| config.deserialize::<Config, proto::Pass>(self.name()))
+            .transpose()?;
+
+        let (config_json, _) = config
+            .map(|(config_json, config)| (config_json, Some(config)))
+            .unwrap_or_else(|| (serde_json::Value::Null, None));
+
+        Ok(FilterInstance::new(
+            config_json,
+            Box::new(Pass::new()) as Box<dyn Filter>,
+        ))
+    }
+}
+
+/// `pass` filter's configuration.
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Config;
+
+impl TryFrom<proto::Pass> for Config {
+    type Error = ConvertProtoConfigError;
+
+    fn try_from(_: proto::Pass) -> Result<Self, Self::Error> {
+        Ok(Config)
+    }
+}

src/filters/set.rs

@@ -60,6 +60,8 @@ impl FilterSet {
                 filters::token_router::factory(),
                 filters::compress::factory(),
                 filters::firewall::factory(),
+                filters::pass::factory(),
+                filters::drop::factory(),
             ])
             .chain(filters),
         )