The highest tagged major version is
README
¶
condition
Contains interfaces and methods for evaluating data using success or failure criteria. Conditions combine inspectors (e.g. string equals "foo", string matches "^foo") and an operator (e.g., AND, OR) to verify the state of data before applying other functions. Each inspector defines its own data processing patterns, but there are a set of common patterns shared among most inspectors:
- evaluating unstructured data
- evaluating JSON objects
The package can be used like this (more examples are also available):
package main
import (
"fmt"
"github.com/brexhq/substation/condition"
)
func main() {
inspector := condition.Strings{
Key: "foo",
Function: "equals",
Expression: "bar",
}
data := []byte(`{"foo":"bar"}`)
ok, err := inspector.Inspect(data)
if err != nil {
panic(err)
}
if ok {
fmt.Println("data passed inspection")
} else {
fmt.Println("data failed inspection")
}
}
Information for each inspector and operator is available in the GoDoc.
Documentation
¶
Index ¶
Constants ¶
const IPInvalidType = errors.Error("IPInvalidType")
IPInvalidType is returned when the IP inspector is configured with an invalid type.
const InspectorInvalidFactoryConfig = errors.Error("InspectorInvalidFactoryConfig")
InspectorInvalidFactoryConfig is returned when an unsupported Inspector is referenced in InspectorFactory.
const InspectorInvalidSettings = errors.Error("InspectorInvalidSettings")
InspectorInvalidSettings is returned when an inspector is configured with invalid settings.
const LengthInvalidFunction = errors.Error("LengthInvalidFunction")
LengthInvalidFunction is returned when the Length inspector is configured with an invalid function.
const OperatorInvalidFactoryConfig = errors.Error("OperatorInvalidFactoryConfig")
OperatorInvalidFactoryConfig is returned when an unsupported Operator is referenced in OperatorFactory.
const OperatorMissingInspectors = errors.Error("OperatorMissingInspectors")
OperatorMissingInspectors is returned when an Operator that requres Inspectors is created with no inspectors.
const StringsInvalidFunction = errors.Error("StringsInvalidFunction")
StringsInvalidFunction is returned when the Strings inspector is configured with an invalid function.
Variables ¶
This section is empty.
Functions ¶
Types ¶
type AND ¶
type AND struct {
Inspectors []Inspector
}
AND implements the Operator interface and applies the boolean AND logic to configured inspectors.
type Config ¶ added in v0.4.0
Config is used with OperatorFactory to produce new Operators from JSON configurations.
type Content ¶ added in v0.2.0
Content evaluates data by its content type. This inspector uses the standard library's net/http package to identify the content type of data (more information is available here: https://pkg.go.dev/net/http#DetectContentType). When used in Substation pipelines, it is most effective when using processors that change the format of data (e.g., process/gzip). The inspector supports MIME types that follow this specification: https://mimesniff.spec.whatwg.org/.
The inspector has these settings:
Type: the MIME type used during inspection Negate (optional): if set to true, then the inspection is negated (i.e., true becomes false, false becomes true) defaults to false
The inspector supports these patterns:
data: [31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 74, 203, 207, 7, 4, 0, 0, 255, 255, 33, 101, 115, 140, 3, 0, 0, 0] == application/x-gzip
When loaded with a factory, the inspector uses this JSON configuration:
{
"type": "content",
"settings": {
"type": "application/x-gzip"
}
}
type IP ¶
IP evaluates IP addresses by their type and usage. This inspector uses the standard library's net package to identify the type and usage of the address (more information is available here: https://pkg.go.dev/net#IP).
The inspector has these settings:
Type: the IP address type used during inspection must be one of: loopback: valid loopback address multicast: valid multicast address multicast_link_local: valid link local multicast address private: valid private address unicast_global: valid global unicast address unicast_link_local: valid link local unicast address unspecified: valid "unspecified" address (e.g., 0.0.0.0, ::) Key (optional): the JSON key-value to retrieve for inspection Negate (optional): if set to true, then the inspection is negated (i.e., true becomes false, false becomes true) defaults to false
The inspector supports these patterns:
JSON:
{"ip_address":"10.0.0.1"} == private
data:
10.0.0.1 == private
When loaded with a factory, the inspector uses this JSON configuration:
{
"type": "ip",
"settings": {
"type": "private"
}
}
type Inspector ¶
Inspector is the interface shared by all inspector methods.
func InspectorFactory ¶
InspectorFactory returns a configured Inspector from a config. This is the recommended method for retrieving ready-to-use Inspectors.
type JSONSchema ¶
type JSONSchema struct {
Schema []struct {
Key string `json:"key"`
Type string `json:"type"`
} `json:"schema"`
Negate bool `json:"negate"`
}
JSONSchema evaluates JSON objects against a minimal schema parser.
The inspector has these settings:
Schema.Key: the JSON key-value to retrieve for inspection Schema.Type: the value type used during inspection of the Schema.Key must be one of: string number (float, int) boolean (true, false) json Negate (optional): if set to true, then the inspection is negated (i.e., true becomes false, false becomes true) defaults to false
The inspector supports these patterns:
JSON:
{"foo":"bar","baz":123} == string,number
When loaded with a factory, the inspector uses this JSON configuration:
{
"type": "json_schema",
"settings": {
"schema": [
{
"key": "foo",
"type": "string"
},
{
"key": "bar",
"type": "number"
}
]
}
}
type JSONValid ¶
type JSONValid struct {
Negate bool `json:"negate"`
}
JSONValid evaluates JSON objects for validity.
The inspector has these settings:
Negate (optional): if set to true, then the inspection is negated (i.e., true becomes false, false becomes true) defaults to false
The inspector supports these patterns:
data:
{"foo":"bar","baz":123} == valid
foo == invalid
When loaded with a factory, the inspector uses this JSON configuration:
{
"type": "json_valid"
}
type Length ¶ added in v0.4.0
type Length struct {
Function string `json:"function"`
Value int `json:"value"`
Type string `json:"type"`
Key string `json:"key"`
Negate bool `json:"negate"`
}
Length evaluates data using len functions. This inspector supports evaluating byte and rune (character) length of strings. If a JSON array is input, then the length is evaluated against the number of elements in the array.
The inspector has these settings:
Function: the length evaluation function used during inspection must be one of: equals greaterthan lessthan Value: the length value used during inspection Type (optional): the length type used during inpsection must be one of: byte (number of bytes) rune (number of characters) defaults to byte Key (optional): the JSON key-value to retrieve for inspection Negate (optional): if set to true, then the inspection is negated (i.e., true becomes false, false becomes true) defaults to false
The inspector supports these patterns:
JSON:
{"foo":"bar"} == 3
{"foo":["bar","baz","qux"]} == 3
data:
bar == 3
When loaded with a factory, the inspector uses this JSON configuration:
{
"type": "length",
"settings": {
"function": "equals",
"value": 3
}
}
type NAND ¶
type NAND struct {
Inspectors []Inspector
}
NAND implements the Operator interface and applies the boolean NAND logic to configured inspectors.
type NOR ¶
type NOR struct {
Inspectors []Inspector
}
NOR implements the Operator interface and applies the boolean NOR logic to configured inspectors.
type OR ¶
type OR struct {
Inspectors []Inspector
}
OR implements the Operator interface and applies the boolean OR logic to configured inspectors.
type Operator ¶
Operator is the interface shared by all operator methods. Operators apply a series of Inspectors to and verify the state (aka "condition") of data.
func OperatorFactory ¶
OperatorFactory returns a configured Operator from a config. This is the recommended method for retrieving ready-to-use Operators.
type Random ¶ added in v0.4.0
type Random struct{}
Random evaluates data based on a random choice. This inspector uses the standard library's rand package. This is best paired with the drop processor and can be used to integration test new configurations and deployments.
When loaded with a factory, the inspector uses this JSON configuration:
{
"type": "random"
}
type RegExp ¶
type RegExp struct {
Expression string `json:"expression"`
Key string `json:"key"`
Negate bool `json:"negate"`
}
RegExp evaluates data using a regular expression. This inspector uses a regexp cache provided by internal/regexp.
The inspector has these settings:
Expression: the regular expression to use during inspection Key (optional): the JSON key-value to retrieve for inspection Negate (optional): if set to true, then the inspection is negated (i.e., true becomes false, false becomes true) defaults to false
The inspector supports these patterns:
JSON:
{"foo":"bar"} == ^bar
data:
bar == ^bar
When loaded with a factory, the inspector uses this JSON configuration:
{
"type": "regexp",
"settings": {
"expression": "^bar"
},
}
type Strings ¶
type Strings struct {
Function string `json:"function"`
Expression string `json:"expression"`
Key string `json:"key"`
Negate bool `json:"negate"`
}
Strings evaluates data using string functions. This inspector uses the standard library's strings package.
The inspector has these settings:
Function: the string evaluation function to use during inspection must be one of: equals contains endswith startswith Expression: the substring expression to use during inspection Key (optional): the JSON key-value to retrieve for inspection Negate (optional): if set to true, then the inspection is negated (i.e., true becomes false, false becomes true) defaults to false
The inspector supports these patterns:
JSON:
{"foo":"bar"} == bar
data:
bar == bar
When loaded with a factory, the inspector uses this JSON configuration:
{
"type": "strings",
"settings": {
"function": "endswith",
"expression": "bar"
}
}
Source Files