engine

Documentation

Index

• Constants
• type AndCondition
  • func (a AndCondition) Evaluate(ctx context.Context, log logr.Logger, condCtx ConditionContext) (ConditionResponse, error)
• type ChainTemplate
• type CodeSnip
• type ConditionContext
• type ConditionEntry
  • func (ce ConditionEntry) Evaluate(ctx context.Context, log logr.Logger, condCtx ConditionContext) (ConditionResponse, error)
• type ConditionResponse
• type Conditional
• type CustomVariable
• type IncidentContext
• type Location
• type Message
• type Option
  • func WithCodeSnipLimit(i int) Option
  • func WithIncidentLimit(i int) Option
• type OrCondition
  • func (o OrCondition) Evaluate(ctx context.Context, log logr.Logger, condCtx ConditionContext) (ConditionResponse, error)
• type Perform
  • func (p *Perform) Validate() error
• type Position
• type Rule
• type RuleEngine
  • func CreateRuleEngine(ctx context.Context, workers int, log logr.Logger, options ...Option) RuleEngine
• type RuleMeta
  • func (r *RuleMeta) GetLabels() []string
• type RuleSelector
• type RuleSet

Constants

const (
	// TODO: make this configurable in the future
	// We may or may not need to do this so holding off for now.
	CONTEXT_LINES = 10
)

Types

type AndCondition

type AndCondition struct {
	Conditions []ConditionEntry `yaml:"and"`
}

func (AndCondition) Evaluate

func (a AndCondition) Evaluate(ctx context.Context, log logr.Logger, condCtx ConditionContext) (ConditionResponse, error)

type ChainTemplate

type ChainTemplate struct {
	Filepaths []string               `yaml:"filepaths"`
	Extras    map[string]interface{} `yaml:"extras"`
}

Chain Templates are used by rules and providers to pass context around during rule execution.

type CodeSnip

type CodeSnip interface {
	GetCodeSnip(uri.URI, Location) (string, error)
}

type ConditionContext

type ConditionContext struct {
	Tags     map[string]interface{}   `yaml:"tags"`
	Template map[string]ChainTemplate `yaml:"template"`
}

type ConditionEntry

type ConditionEntry struct {
	From                   string
	As                     string
	Ignorable              bool
	Not                    bool
	ProviderSpecificConfig Conditional
}

func (ConditionEntry) Evaluate

func (ce ConditionEntry) Evaluate(ctx context.Context, log logr.Logger, condCtx ConditionContext) (ConditionResponse, error)

type ConditionResponse

type ConditionResponse struct {
	Matched bool `yaml:"matched"`
	// For each time the condition is hit, add all of the context.
	// keys here, will be used in the message.
	Incidents       []IncidentContext      `yaml:"incidents"`
	TemplateContext map[string]interface{} `yaml:",inline"`
}

type Conditional

type Conditional interface {
	Evaluate(ctx context.Context, log logr.Logger, condCtx ConditionContext) (ConditionResponse, error)
}

type CustomVariable

type CustomVariable struct {
	Pattern            *regexp.Regexp `yaml:"pattern"`
	Name               string         `yaml:"name"`
	DefaultValue       string         `yaml:"defaultValue"`
	NameOfCaptureGroup string         `yaml:"nameOfCaptureGroup"`
}

type IncidentContext

type IncidentContext struct {
	FileURI      uri.URI                `yaml:"fileURI"`
	Effort       *int                   `yaml:"effort"`
	LineNumber   *int                   `yaml:"lineNumber,omitempty"`
	Variables    map[string]interface{} `yaml:"variables"`
	Links        []konveyor.Link        `yaml:"externalLink"`
	CodeLocation *Location              `yaml:"location,omitempty"`
}

type Location

type Location struct {
	StartPosition Position `yaml:"startPosition"`
	EndPosition   Position `yaml:"endPosition"`
}

type Message

type Message struct {
	Text  *string         `yaml:"message,omitempty"`
	Links []konveyor.Link `yaml:"links,omitempty"`
}

type Option

type Option func(engine *ruleEngine)

func WithCodeSnipLimit

func WithCodeSnipLimit(i int) Option

func WithIncidentLimit

func WithIncidentLimit(i int) Option

type OrCondition

type OrCondition struct {
	Conditions []ConditionEntry `yaml:"or"`
}

func (OrCondition) Evaluate

func (o OrCondition) Evaluate(ctx context.Context, log logr.Logger, condCtx ConditionContext) (ConditionResponse, error)

type Perform

type Perform struct {
	Message Message  `yaml:",inline"`
	Tag     []string `yaml:"tag,omitempty"`
}

func (*Perform) Validate

func (p *Perform) Validate() error

type Position

type Position struct {
	/*Line defined:
	 * Line position in a document (zero-based).
	 * If a line number is greater than the number of lines in a document, it defaults back to the number of lines in the document.
	 * If a line number is negative, it defaults to 0.
	 */
	Line int `yaml:"line"`

	/*Character defined:
	 * Character offset on a line in a document (zero-based). Assuming that the line is
	 * represented as a string, the `character` value represents the gap between the
	 * `character` and `character + 1`.
	 *
	 * If the character value is greater than the line length it defaults back to the
	 * line length.
	 * If a line number is negative, it defaults to 0.
	 */
	Character int `yaml:"character"`
}

type Rule

type Rule struct {
	RuleMeta        `yaml:",inline" json:",inline"`
	Perform         Perform          `yaml:",inline" json:"perform,omitempty"`
	When            Conditional      `yaml:"when,omitempty" json:"when,omitempty"`
	Snipper         CodeSnip         `yaml:"-" json:"-"`
	CustomVariables []CustomVariable `yaml:"customVariables,omitempty" json:"customVariables,omitempty"`
}

type RuleEngine

type RuleEngine interface {
	RunRules(context context.Context, rules []RuleSet, selectors ...RuleSelector) []konveyor.RuleSet
	Stop()
}

func CreateRuleEngine

func CreateRuleEngine(ctx context.Context, workers int, log logr.Logger, options ...Option) RuleEngine

type RuleMeta

type RuleMeta struct {
	RuleID      string             `yaml:"ruleID,omitempty" json:"ruleID,omitempty"`
	Description string             `yaml:"description,omitempty" json:"description,omitempty"`
	Category    *konveyor.Category `yaml:"category,omitempty" json:"category,omitempty"`
	Labels      []string           `yaml:"labels,omitempty" json:"labels,omitempty"`
	Effort      *int               `json:"effort,omitempty"`
}

func (*RuleMeta) GetLabels

func (r *RuleMeta) GetLabels() []string

type RuleSelector

type RuleSelector interface {
	Matches(*RuleMeta) (bool, error)
}

RuleSelector selects rules based on rule metadata

type RuleSet

type RuleSet struct {
	Name        string   `json:"name,omitempty" yaml:"name,omitempty"`
	Description string   `json:"description,omitempty" yaml:"description,omitempty"`
	Labels      []string `json:"labels,omitempty" yaml:"labels,omitempty"`
	Tags        []string `json:"tags,omitempty" yaml:"tags,omitempty"`
	Rules       []Rule   `json:"rules,omitempty" yaml:"rules,omitempty"`
}