core

type Accumulator struct {

	// Acc is the buffer.
	Acc []interface{}

	// Limit is the capacity.
	Limit int

	// Dumped is the number of entries that have been dumped to
	// make room for other entries.
	Dumped int
}

type Action struct {
	// Code is optional Javascript.
	//
	// Can either be an array of strings or a string.
	Code interface{} `json:"code,omitempty"`

	// Endpoint is the optional target action executor.
	Endpoint string `json:"endpoint,omitempty"`

	// Subvars controls whether bindings are injected directly
	// into the Javascript environment.
	//
	// For example, if the rule evaluation results in a binding
	// for "foo" and if Subvars is true, then the Javascript
	// variable 'foo' will be bound.
	Subvars bool `json:"subvars,omitempty"`

	// Opts is a map of generic options.
	//
	// For now, only "libraries" is used.  "libraries", if given,
	// should be an array of URLs that return Javascript.
	Opts map[string]interface{} `json:"opts,omitempty"`
}

type ActionInterpreter interface {
	// GetThunk returns a function that can be executed to
	// interpreter the given Action.
	GetThunk(ctx *Context, loc *Location, bs Bindings, a Action) (func() (interface{}, error), error)

	// GetName is used to find the ActionInterpreter based on an
	// Action's Endpoint (which is now a very bad name).
	GetName() string
}

type AddHookFn func(ctx *Context, state State, id string, fact Map, loading bool) error

type AndQuery struct {
	Conjuncts []Query
}

type App interface {
	GenerateHeaders(ctx *Context) map[string]string
	ProcessBindings(ctx *Context, bs Bindings) Bindings

	// UpdateJavascriptRuntime can be used to modify the
	// Javascript environment for actions and condition code.
	UpdateJavascriptRuntime(ctx *Context, runtime *otto.Otto) error

	// ProcessQuery can be used to replace or wrap queries when unmarshaling a
	// rule condition.  The method gets the raw generic query data along with
	// the query created by Rulio.
	ProcessQuery(ctx *Context, raw map[string]interface{}, query Query) Query
}

type Bindings map[string]interface{}

type Breaker interface {

	// Status report the breaker load (but where 100% is
	// represented by 1.0), whether the breaker is closed (good)
	// or open (bad), whether the breaker is disabled, and any
	// error encountered getting this status.
	Status() BreakerStatus

	// Disable does what you think.
	Disable(bool)

	// Do submits work to the breaker.  The work is attempted only
	// if the breaker is closed.  If the work is attempted, any
	// resulting error is returned.
	//
	// The given function can be nil.
	Do(func() error) (attempted bool, err error)
}

type BreakerStatus struct {

	// Load is the ratio of the current count to the limit.
	Load float64

	// Closed indicates if the breaker is closed (good) or open
	// (bad).
	Closed bool

	// Disabled means that the breaker will allow everything.
	Disabled bool

	// Error is the last error encountered internally (if any).
	Error error
}

type Cache struct {
	sync.Mutex

	TTL time.Duration
	// contains filtered or unexported fields
}

type CastMatcher struct {
	Matcher
}

type CleanAction Action

type CleanRule Rule

type CodeQuery struct {
	Code      string   `json:"code"`
	Language  string   `json:"language,omitempty"`
	Libraries []string `json:"libraries,omitempty"`
	// contains filtered or unexported fields
}

type ComboBreaker struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type CommandSpec struct {
	Path    string            `json:"path"`
	Args    []string          `json:"args"`
	Dir     string            `json:"dir"`
	CGroup  string            `json:"cgroup"`
	AddEnv  map[string]string `json:"addEnv"`
	Env     map[string]string `json:"env"`
	Stdin   string            `json:"stdin"`
	Stdout  string            `json:"stdout"`
	Stderr  string            `json:"stderr"`
	Error   string            `json:",omit"`
	Success bool              `json:",success"`
	*os.ProcessState
}

type Condition struct {
	Msg string `json:"msg,omitempty"`

	Hope string `json:"status,omitempty"`
}

type Config struct {
}

type Context struct {
	context.Context
	sync.RWMutex

	Verbosity LogLevel

	// If target location.Mode.ReadKey is not nil, then this
	// ReadKey must match it in order to a read API to be allowed.
	ReadKey string

	// If target location.Mode.WriteKey is not nil, then this
	// WriteKey must match it in order to a read API to be allowed.
	WriteKey string

	// LogAccumulator, if it exists, will collect log records.
	LogAccumulator *Accumulator

	// LogAccumulatorLimit determines LogAccumulator detail.
	LogAccumulatorLevel LogLevel

	// LogHook, if not nil, is called for every log record.
	LogHook LogHook

	// PointHook, if not nil, is called from 'Point()'.
	PointHook PointHook

	// App specific behavior modifiers
	App App

	// Custom application tracing
	Tracer Tracer

	Logger Logger
	// contains filtered or unexported fields
}

type Control struct {
	// Turn off timer logging.
	//
	// The property is "NoTiming" to make the natural default do
	// what we usually want.  Also see 'Control.Defaults()'.
	NoTiming bool

	// Control what's logged.
	//
	// Examples: 'ANYINFO', 'ANYWARN', 'EVERYTHING', 'NOTHING'.
	// See contants defined in this file.  Also see
	// 'ParseVerbosity()'.
	Verbosity LogLevel

	// Logging format: "CSV" (one-line JSON using external logger
	// -- not comma-separated values!), "pretty" (which spews
	// pretty-printed JSON), or "none" (which doesn't emit
	// anything).  Default is "CSV".
	//
	// The environment variable 'RULES_LOGS' overrides this
	// setting, which makes it easy to do quick performance tests
	// with no logging.
	Logging string

	// The maximum number of facts this Location will store.
	MaxFacts int

	// BindingsWarningLimit sets the threshold for a warning when
	// that many bindings are found during a fact search.
	BindingsWarningLimit int

	// Run fact expiration before every search.
	ExpireFactsDuringSearch bool

	// Before returning search results, check for fact expirations.
	CheckForFactExpiration bool

	// A directory of services used for finding action endpoints
	// and external fact service endpoints.  A value is an array
	// of URLs, one of which is picked at random for cheap load
	// balancing.
	//
	// Also see InternalFactServices.
	Services map[string][]string

	// ActionInterpreters maps an action endpoint (property) to an
	// interpreter.
	ActionInterpreters map[string]ActionInterpreter

	// InternalFactServices maps logical names to FactServices
	// (that are implemented within this process).
	//
	// Also see Services.
	InternalFactServices map[string]FactService `json:"-"`

	// Libraries of Javascript code made available to in-process
	// Javascript (both in conditions and in actions).  Each value
	// should be either a URL that returns Javascript code or a
	// string of Javascript code.
	Libraries map[string]string

	// Misc props that are available to in-process Javascript
	// (in conditions and actions).
	CodeProps map[string]interface{}

	// What it says.  Value is a string that can be parsed by Go's
	// http://golang.org/pkg/time/#ParseDuration.  This value can
	// be overridden during `ingest`.
	//
	// Note the type: a 'Duration', not a 'time.Duration'.  Why?
	// Because we want to parse JSON into this struct.  See
	// 'Duration' below.
	ExternalFactServiceTimeout Duration

	// ActionTimeout (nanoseconds) greater than zero will attempt
	// to terminate any action execution that lasts longer than
	// the timeout.  Not implemented yet.
	ActionTimeout Duration

	// JavascriptTimeout (nanoseconds) non-negative will attempt
	// to terminate any action execution that lasts longer than
	// the timeout.  Zero means to use
	// System.DefaultJavascriptTimeout.
	JavascriptTimeout Duration

	// DisableExecFunction removes the 'shell' function from the
	// Javascript environment.
	DisableExecFunction bool
	// UseDefaultVariableValue will give DefaultVariableValue to
	// unbound variables.  Otherwise and unbound variable will
	// (hopefully) result in an error.
	UseDefaultVariableValue bool

	// DefaultVariableValue will be assigned to any unbound
	// variables if 'UseDefaultVariableValue' is true.
	DefaultVariableValue interface{}
}

type Counter struct {
	sync.Mutex
	Count int
}

type Duration time.Duration

type EmptyQuery struct {
}

type EvalRule struct {
	// Rule is the target rule.
	Rule *CleanRule `json:"rule,omitempty"`

	Bindingss []Bindings `json:"bindingss,omitempty"`

	Disposition *Condition `json:"disposition,omitempty"`

	Children []*EvalRuleCondition `json:"children,omitempty"`

	DoneWork *RuleDone `json:",omitempty"`

	Parent *FindRules `json:"-"`
}

type EvalRuleCondition struct {
	// Bindingss from the event matched against the rule's 'when'
	// pattern.
	Bindings Bindings `json:"bindings,omitempty"`

	Disposition *Condition `json:"disposition,omitempty"`

	// Children are the ExecRuleActions for each Bindings.
	Children []*ExecRuleAction `json:"children,omitempty"`

	Parent *EvalRule `json:"-"`
}

type ExecRuleAction struct {
	// Bindings from the combined event patching and condition
	// evaluation.
	//
	// Not "Bindingss" because we execute the action for each
	// bindings in Bindingss that resulted from the rule condition
	// evaluation.
	Bindings map[string]interface{} `json:"bindings,omitempty"`

	// Act is the action to execute.
	Act Action `json:"action,omitempty"`

	Disposition *Condition `json:"disposition,omitempty"`

	Parent *EvalRuleCondition `json:"-"`

	// Value is the result of the action execution.
	Value interface{} `json:"value,omitempty"`
}

type ExpiredError struct {
}

type FactService interface {
	Search(ctx *Context, pattern Map) (*SearchResults, error)
}

type FactServiceFromURI struct {
	URI     string
	Timeout time.Duration
}

type FindRules struct {
	// Event is the input event.
	Event map[string]interface{} `json:"event,omitempty"`

	// Disposition reports how things went.
	Disposition *Condition `json:"disposition,omitempty"`

	// Children are the EvalRuleConditions for each found rule.
	Children []*EvalRule `json:"children,omitempty"`

	Values []interface{} `json:"values"`
}

type GenericQuery struct {
	// contains filtered or unexported fields
}

type HTTPClientSpec struct {
	Timeout            Duration `json:"timeout,omitempty"`
	InsecureSkipVerify bool     `json:"insecureSkipVerify,omitempty"`

	DisableKeepAlives     bool     `json:"disableKeepAlives,omitempty"`
	ResponseHeaderTimeout Duration `json:"responseHeaderTimeout,omitempty"`
	MaxIdleConnsPerHost   int      `json:"maxIdleConnsPerHost,omitempty"`
}

type HTTPRequest struct {
	// Method is the HTTP request method (e.g., "POST").
	Method string `json:"method,omitempty"`

	// URI is what you expect.
	URI string `json:"uri"`

	// Values to be add to Header for the request
	//
	// ToDo: Probably support proper []string values.
	Headers map[string]string `json:"headers,omitempty"`

	// Body is the request body.
	Body string `json:"body,omitempty"`

	// ContentType is what you expect.
	ContentType string `json:"contentType,omitempty"`

	// Env (if given) provides and receives cookies.
	Env map[string]interface{} `json:"env,omitempty"`

	// ClientSpec controls lower-level aspects of the HTTP request.
	ClientSpec *HTTPClientSpec `json:"client,omitempty"`
}

type HTTPResult struct {
	// Status is the last HTTP status code received.
	Status int

	// Body is the last body (if any) received.
	Body string

	// Attempts is the number of attempts made.
	Attempts int

	// Error is the most recent error message.
	//
	// We use a string here for the convenience of Javascript
	// callers.  Might be a bad idea.
	Error string

	// Headers are the response headers.
	Headers map[string][]string
}

type IndexedState struct {
	sync.RWMutex

	// Name should probably the name of the location for this state.
	Name string

	// FactIndex is the in-memory term index that allows us to
	// search facts.
	FactIndex *TermIndex

	// RuleIndex is the in-memory pattern index that allows us to
	// find rules for an incoming event.
	RuleIndex *PatternIndex

	// Map from IDs to facts.
	IdToFact map[string]Map

	// Store is how we persist and load data.
	Store Storage

	// Loaded indicates whether we have loaded data from Store.
	Loaded bool
	// contains filtered or unexported fields
}

type LinearState struct {
	sync.RWMutex

	// Name should probably the name of the location for this state.
	Name string

	Facts map[string]RawFact
	// contains filtered or unexported fields
}

type Location struct {
	sync.RWMutex
	Name     string
	ReadOnly bool
	Config   *Config

	// Provider is required when using parent locations.  Must be
	// set when the Location is created and then left unchanged.
	//
	// sys.System should be a good Provider.
	Provider LocationProvider
	// contains filtered or unexported fields
}

type LocationProvider interface {
	GetLocation(ctx *Context, name string) (*Location, error)
}

type LogHook func(level LogLevel, args ...interface{})

type LogLevel uint64

type Logger interface {
	Log(level LogLevel, args ...interface{})
	Metric(name string, args ...interface{})
}

type Map map[string]interface{}

type Matcher interface {
	// Match takes a pattern and a fact built from map[string]interface{} and
	// []interface{} structures, along with an initial set of bindings (may be
	// empty), and returns a slice of sets of bindings representing the sets of
	// matches.
	Match(pattern, fact interface{}, bs Bindings) ([]Bindings, error)
}

type MemStorage struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type NoStorage struct {
}

type NoopLogger struct {
}

type NotFoundError struct {
	Msg string
}

type NotQuery struct {
	Negated Query
}

type OrQuery struct {
	Disjuncts    []Query
	ShortCircuit bool
}

type OttoActionInterpreter struct {
}

type OutboundBreaker struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type Pair struct {
	K []byte
	V []byte
}

type Parameters struct {

	// SlurpCacheSize is the maximum number of cached Slurp results
	SlurpCacheSize int

	// SlurpTimeout is that.
	SlurpTimeout time.Duration

	// SlurpCacheTTL is the TTL for SlurpCache entries.
	SlurpCacheTTL time.Duration

	// Timeout enables Javascript timeouts.
	JavascriptTimeouts bool

	// LogAccumulatorSize is the size of log accumulator buffers.
	LogAccumulatorSize int

	// HTTPClientCacheSize is the maximum number of HTTPClients to
	// cache.
	HTTPClientCacheSize int

	// HTTPClientCacheTTL is the TTL for a HTTPClientCache entry.
	HTTPClientCacheTTL time.Duration

	// IdLengthLimit is the maximum size for an id.
	IdLengthLimit int

	// IdInjectionTime determines the id injection mode.
	IdInjectionTime int

	// TimerHistorySize limits how many entries are stored for a given timer.
	TimerHistorySize int

	// TimerWarningLimit, when exceeded, generates a log warning.
	TimerWarningLimit time.Duration

	// MaxTimers limits the number of timers we track so bad data doesn't kill us.
	// This limit is not currently enforced!
	MaxTimers int

	// LogRecordValueLimit is the maximum value length in a LogRecord.
	// See MakeLogRecord() below
	LogRecordValueLimit int

	// LogCallerLine adds the line number of the callers to log records.
	LogCallerLine bool

	// ConcurrentWalks turns concurrent EventWorkWalking on or off.
	ConcurrentWalks bool

	// DefaultControl is the default Location.Control
	DefaultControl *Control

	// StringLengthTermLimit is the maximum length of a string that gets indexed.
	// If your string (in an FDS) is longer that this limit, it won't get
	// indexed.
	StringLengthTermLimit int

	// DefaultJavascriptTimeout does what you'd think.
	//
	// A Location's control can override this value (if
	// SystemParameters.Timeout is true).
	DefaultJavascriptTimeout time.Duration

	// MaxIdleConnsPerHost is that parameter for HTTP clients.
	MaxIdleConnsPerHost int

	// HTTPTimeout
	HTTPTimeout time.Duration

	// InsecureSkipVerify
	InsecureSkipVerify bool

	// DisableKeepAlives
	DisableKeepAlives bool

	// ResponseHeaderTimeout
	ResponseHeaderTimeout time.Duration

	// HTTPRetryInterval
	HTTPRetryInterval time.Duration

	// HTTPRetryOn
	HTTPRetryOn StringSet

	// CopyEvents will copy the binding for "?event" before giving
	// that data to condition javascript or a javascript action.
	CopyEvents bool
}

type PatternIndex struct {
	String map[string]*PatternIndex
	Var    *PatternIndex
	Map    *PatternIndex
	Ids    StringSet
}

type PatternQuery struct {
	Pattern   map[string]interface{} `json:"pattern"`
	Locations []string               `json:"locations,omitempty"`
}

type PointHook func(ctx *Context, namespace string, metric string, val interface{}, unit string, more ...string)

type Problem interface {
	IsFatal() bool
	Error() string
}

type Query interface {
	Exec(*Context, *Location, QueryContext, QueryResult) (*QueryResult, error)
}

type QueryContext struct {
	// Or maybe map[string]interface{} ...
	Locations []string
}

type QueryResult struct {
	Bss     []Bindings
	Checked int
	Elapsed int64
}

type RawFact struct {
	M  map[string]interface{}
	JS []byte
}

type RemHookFn func(ctx *Context, state State, id string) error

type Rule struct {
	// The id for the rule.  The SHA1 has of the JSON is a good
	// 'id'.  That way the same rule added twice will not create
	// duplicate rules.
	Id string `json:"id,omitempty"`

	// Optional (but typical) pattern that will be matched against
	// incoming events.
	When *PatternQuery `json:"when,omitempty"`

	// Schedule is a crontab entry string or a duration starting with a "+".
	Schedule string `json:"schedule,omitempty"`

	// Optional query against facts (local or remote).
	Condition GenericQuery `json:"condition,omitempty"`

	// Actions: should have at least one.
	Actions []CleanAction `json:"actions,omitempty"`

	// Action just helps with unmarshalling.
	//
	// Will be stuck into Actions.
	Action *CleanAction `json:"action,omitempty"`

	Policies *RulePolicies `json:"policies,omitempty"`

	// Once specifies that the rule should be deleted after
	// exactly one evaluation.
	//
	// We didn't generalize to a count because we'd have to update
	// the rule state with each count decrement.
	Once bool `json:"once"`

	// Generic properties that are not currently used.
	Props map[string]interface{} `json:"props"`

	// Expires is an expiration time in UNIX seconds.
	//
	// 0 for no expiration.  This value is here to allow any
	// 'FindRules()' implementation drop expired rules.  Not all
	// implementations will need to consult this value.
	//
	// The type is float64 to deal with JSON serialization (and
	// since JSON only really has floats).
	Expires float64 `json:"expires"`
}

type RuleDone struct {
	Parent      *EvalRule  `json:"-"`
	Disposition *Condition `json:"disposition,omitempty"`
}

type RulePolicies struct {
	// RetryFromCondition will mark a rule's 'EvalRuleCondition'
	// as incomplete if any of that rule's actions fail.
	//
	// So if you submit that work again, the entire rule will be
	// re-evaluated starting the the rule's condition.
	//
	// NOT CURRENTLY IMPLEMENTED.
	RetryFromCondition bool `json:"retryFromCondition,omitempty"`

	// VerifyEnabled will demand that 'EventWorkStep' (and,
	// therefore, 'EventWorkWalk') will verify each rule is
	// enabled (and exists) before re-evaluating any part of the
	// rule.
	//
	// NOT CURRENTLY IMPLEMENTED.
	VerifyEnabled bool `json:"verifyEnabled,omitempty"`

	// SerialActions, if true, will cause rule processing
	// components to be executed sequentially.  Otherwise a rule's
	// actions will be executed concurrently.
	SerialActions bool `json:"serialActions,omitempty"`
}

type SearchResult struct {
	Js        string
	Id        string
	Bindingss []Bindings
}

type SearchResults struct {
	Found   []SearchResult
	Checked int
	Elapsed int64
	Expired int
}

type ServiceStats struct {
	TotalCalls       uint64
	ErrorCount       uint64
	TotalTime        uint64
	NewLocations     uint64
	ListLocations    uint64
	AddRules         uint64
	UpdateRules      uint64
	RemRules         uint64
	GetRules         uint64
	AddFacts         uint64
	RemFacts         uint64
	GetFacts         uint64
	SearchRules      uint64
	SearchFacts      uint64
	ListRules        uint64
	ProcessEvents    uint64
	GetEventHistorys uint64
	ActionExecs      uint64
}

type SheensMatcher struct {
	*match.Matcher
}

type SimpleBreaker struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type SimpleLocationProvider struct {
	Registry map[string]*Location
}

type SimpleLogger struct {
	// contains filtered or unexported fields
}

type State interface {
	Count(ctx *Context) int
	AddHook(hook AddHookFn)
	RemHook(hook RemHookFn)
	Load(ctx *Context) error
	Add(ctx *Context, id string, x Map) (string, error)
	Rem(ctx *Context, id string) (bool, error)
	Delete(ctx *Context) error
	Get(ctx *Context, id string) (Map, error)

	Search(ctx *Context, pattern Map) (*SearchResults, error)
	FindRules(ctx *Context, event Map) (map[string]Map, error)
	FindCachedRules(ctx *Context, event Map) (map[string]*Rule, error)
	Clear(ctx *Context) error
	// contains filtered or unexported methods
}

type Storage interface {
	Load(ctx *Context, loc string) ([]Pair, error)

	Add(ctx *Context, loc string, data *Pair) error

	Remove(ctx *Context, loc string, k []byte) (int64, error)

	Clear(ctx *Context, loc string) (int64, error)

	Delete(ctx *Context, loc string) error

	GetStats(ctx *Context, loc string) (StorageStats, error)

	Close(ctx *Context) error

	Health(ctx *Context) error
}

type StorageStats struct {
	NumRecords       int
	DateOfLastRecord string
}

type StringSet map[string]struct{}

type SyntaxError struct {
	Msg string
}

type TermIndex struct {
	Index map[string]StringSet
}

type TermIndexMetrics struct {
	TermCount  int
	EntryCount int
	IdCount    int // Slow
	IdDups     int // Slow
}

type ThingSlice []interface{}

type Throttle struct {
	sync.Mutex

	Breaker
	// contains filtered or unexported fields
}

type Timer struct {
	Ctx     *Context
	Id      int64
	S       string
	Then    int64
	Elapsed int64
	Paused  bool
}

type TimerHistory struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type TimerHistoryEntry struct {
	// Monotonically increase sequence number.
	Seq int

	// 2014-07-03T16:12:19.902Z.  Truncated to millis because so
	// many external systems don't automatically deal with
	// nanoseconds.
	Timestamp string

	// Nanoseconds.
	Elapsed int64
}

type Tracer interface {
	// StartSpan is given a new subcontext and the name of the operation that
	// the context is for.  The function is expected to modify the context with
	// any span information that is needed to pass on to child spans as well as
	// to stop the span.
	StartSpan(ctx *Context, opName string)

	// StopSpan is given a context previously given to StartSpan in order to
	// finalize the trace for the given span.
	StopSpan(ctx *Context)
}