modconfig

package
v2.0.0-alpha.5 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: May 8, 2024 License: AGPL-3.0 Imports: 47 Imported by: 0

Documentation

Index

Constants

View Source
const (
	ConnectionTypePlugin     = "plugin"
	ConnectionTypeAggregator = "aggregator"
	ImportSchemaEnabled      = "enabled"
	ImportSchemaDisabled     = "disabled"
)
View Source
const (
	HttpMethodGet    = "get"
	HttpMethodPost   = "post"
	HttpMethodPut    = "put"
	HttpMethodDelete = "delete"
	HttpMethodPatch  = "patch"
)
View Source
const (
	DefaultMaxAttempts = 3
	DefaultStrategy    = "constant"
	DefaultMinInterval = 1000
	DefaultMaxInterval = 10000
)
View Source
const RuntimeDependencyDashboardScope = "self"
View Source
const SnapshotQueryTableName = "custom.table.results"

Variables

View Source
var IntegrationEmailBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name:     schema.AttributeTypeDescription,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeTitle,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeSmtpTls,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeSmtpHost,
			Required: true,
		},
		{
			Name:     schema.AttributeTypeSmtpPort,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeSmtpsPort,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeSmtpUsername,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeSmtpPassword,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeFrom,
			Required: true,
		},
		{
			Name:     schema.AttributeTypeTo,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeCc,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeBcc,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeSubject,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeResponseUrl,
			Required: false,
		},
	},
}
View Source
var IntegrationSlackBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name:     schema.AttributeTypeDescription,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeTitle,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeToken,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeSigningSecret,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeWebhookUrl,
			Required: false,
		},
	},
}
View Source
var IntegrationTeamsBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name:     schema.AttributeTypeDescription,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeTitle,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeWebhookUrl,
			Required: true,
		},
	},
}
View Source
var PipelineBasicAuthBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name:     schema.AttributeTypeUsername,
			Required: true,
		},
		{
			Name:     schema.AttributeTypePassword,
			Required: true,
		},
	},
}
View Source
var PipelineBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name:     schema.AttributeTypeDescription,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeTitle,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeDocumentation,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeTags,
			Required: false,
		},
		{
			Name: schema.AttributeTypeMaxConcurrency,
		},
	},
	Blocks: []hcl.BlockHeaderSchema{
		{
			Type:       schema.BlockTypeParam,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypePipelineStep,
			LabelNames: []string{schema.LabelType, schema.LabelName},
		},
		{
			Type:       schema.BlockTypePipelineOutput,
			LabelNames: []string{schema.LabelName},
		},
	},
}
View Source
var PipelineOutputBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name: schema.AttributeTypeDescription,
		},
		{
			Name:     schema.AttributeTypeValue,
			Required: true,
		},
	},
}
View Source
var PipelineParamBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name: schema.AttributeTypeType,
		},
		{
			Name: schema.AttributeTypeDefault,
		},
		{
			Name:     schema.AttributeTypeDescription,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeOptional,
			Required: false,
		},
	},
}
View Source
var PipelineStepContainerBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name: schema.AttributeTypeTitle,
		},
		{
			Name: schema.AttributeTypeDescription,
		},
		{
			Name: schema.AttributeTypeTimeout,
		},
		{
			Name: schema.AttributeTypeForEach,
		},
		{
			Name: schema.AttributeTypeDependsOn,
		},
		{
			Name: schema.AttributeTypeIf,
		},
		{
			Name: schema.AttributeTypeImage,
		},
		{
			Name: schema.AttributeTypeSource,
		},
		{
			Name: schema.AttributeTypeCmd,
		},
		{
			Name: schema.AttributeTypeEnv,
		},
		{
			Name: schema.AttributeTypeEntrypoint,
		},
		{
			Name: schema.AttributeTypeCpuShares,
		},
		{
			Name: schema.AttributeTypeMemory,
		},
		{
			Name: schema.AttributeTypeMemoryReservation,
		},
		{
			Name: schema.AttributeTypeMemorySwap,
		},
		{
			Name: schema.AttributeTypeMemorySwappiness,
		},
		{
			Name: schema.AttributeTypeReadOnly,
		},
		{
			Name: schema.AttributeTypeUser,
		},
		{
			Name: schema.AttributeTypeWorkdir,
		},
		{
			Name: schema.AttributeTypeMaxConcurrency,
		},
	},
	Blocks: []hcl.BlockHeaderSchema{
		{
			Type: schema.BlockTypeError,
		},
		{
			Type:       schema.BlockTypePipelineOutput,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type: schema.BlockTypeLoop,
		},
		{
			Type: schema.BlockTypeRetry,
		},
		{
			Type: schema.BlockTypeThrow,
		},
	},
}
View Source
var PipelineStepEmailBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name: schema.AttributeTypeTitle,
		},
		{
			Name: schema.AttributeTypeDescription,
		},
		{
			Name: schema.AttributeTypeForEach,
		},
		{
			Name: schema.AttributeTypeDependsOn,
		},
		{
			Name: schema.AttributeTypeIf,
		},
		{
			Name:     schema.AttributeTypeTo,
			Required: true,
		},
		{
			Name:     schema.AttributeTypeFrom,
			Required: true,
		},
		{
			Name:     schema.AttributeTypeSmtpUsername,
			Required: true,
		},
		{
			Name:     schema.AttributeTypeSmtpPassword,
			Required: true,
		},
		{
			Name:     schema.AttributeTypeHost,
			Required: true,
		},
		{
			Name:     schema.AttributeTypePort,
			Required: true,
		},
		{
			Name: schema.AttributeTypeSenderName,
		},
		{
			Name: schema.AttributeTypeCc,
		},
		{
			Name: schema.AttributeTypeBcc,
		},
		{
			Name: schema.AttributeTypeBody,
		},
		{
			Name: schema.AttributeTypeContentType,
		},
		{
			Name: schema.AttributeTypeSubject,
		},
		{
			Name: schema.AttributeTypeMaxConcurrency,
		},
	},
	Blocks: []hcl.BlockHeaderSchema{
		{
			Type: schema.BlockTypeError,
		},
		{
			Type:       schema.BlockTypePipelineOutput,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type: schema.BlockTypeLoop,
		},
		{
			Type: schema.BlockTypeRetry,
		},
		{
			Type: schema.BlockTypeThrow,
		},
	},
}
View Source
var PipelineStepFunctionBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name: schema.AttributeTypeTitle,
		},
		{
			Name: schema.AttributeTypeDescription,
		},
		{
			Name: schema.AttributeTypeTimeout,
		},
		{
			Name: schema.AttributeTypeForEach,
		},
		{
			Name: schema.AttributeTypeDependsOn,
		},
		{
			Name: schema.AttributeTypeIf,
		},
		{
			Name:     schema.AttributeTypeSource,
			Required: true,
		},
		{
			Name: schema.AttributeTypeHandler,
		},
		{
			Name: schema.AttributeTypeRuntime,
		},
		{
			Name: schema.AttributeTypeEnv,
		},
		{
			Name: schema.AttributeTypeEvent,
		},
		{
			Name: schema.AttributeTypeMaxConcurrency,
		},
	},
	Blocks: []hcl.BlockHeaderSchema{
		{
			Type: schema.BlockTypeError,
		},
		{
			Type:       schema.BlockTypePipelineOutput,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type: schema.BlockTypeLoop,
		},
		{
			Type: schema.BlockTypeRetry,
		},
		{
			Type: schema.BlockTypeThrow,
		},
		{
			Type: schema.BlockTypeLoop,
		},
	},
}
View Source
var PipelineStepHttpBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name: schema.AttributeTypeTitle,
		},
		{
			Name: schema.AttributeTypeDescription,
		},
		{
			Name: schema.AttributeTypeTimeout,
		},
		{
			Name: schema.AttributeTypeForEach,
		},
		{
			Name: schema.AttributeTypeDependsOn,
		},
		{
			Name: schema.AttributeTypeIf,
		},
		{
			Name:     schema.AttributeTypeUrl,
			Required: true,
		},
		{
			Name: schema.AttributeTypeMethod,
		},
		{
			Name: schema.AttributeTypeCaCertPem,
		},
		{
			Name: schema.AttributeTypeInsecure,
		},
		{
			Name: schema.AttributeTypeRequestBody,
		},
		{
			Name: schema.AttributeTypeRequestHeaders,
		},
		{
			Name: schema.AttributeTypeMaxConcurrency,
		},
	},
	Blocks: []hcl.BlockHeaderSchema{
		{
			Type: schema.BlockTypeError,
		},
		{
			Type:       schema.BlockTypePipelineOutput,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type: schema.BlockTypePipelineBasicAuth,
		},
		{
			Type: schema.BlockTypeLoop,
		},
		{
			Type: schema.BlockTypeRetry,
		},
		{
			Type: schema.BlockTypeThrow,
		},
	},
}
View Source
var PipelineStepInputBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name: schema.AttributeTypeTitle,
		},
		{
			Name: schema.AttributeTypeDescription,
		},
		{
			Name: schema.AttributeTypeForEach,
		},
		{
			Name: schema.AttributeTypeDependsOn,
		},
		{
			Name: schema.AttributeTypeIf,
		},
		{
			Name: schema.AttributeTypeOptions,
		},
		{
			Name: schema.AttributeTypePrompt,
		},
		{
			Name:     schema.AttributeTypeNotifier,
			Required: true,
		},
		{
			Name:     schema.AttributeTypeType,
			Required: true,
		},
		{
			Name:     schema.AttributeTypeTo,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeCc,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeBcc,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeSubject,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeChannel,
			Required: false,
		},
		{
			Name: schema.AttributeTypeMaxConcurrency,
		},
	},
	Blocks: []hcl.BlockHeaderSchema{
		{
			Type: schema.BlockTypeError,
		},
		{
			Type:       schema.BlockTypePipelineOutput,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type: schema.BlockTypeRetry,
		},
		{
			Type: schema.BlockTypeThrow,
		},
		{
			Type:       schema.BlockTypeOption,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type: schema.BlockTypeLoop,
		},
	},
}
View Source
var PipelineStepInputNotifyBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name: schema.AttributeTypeIntegration,
		},
		{
			Name: schema.AttributeTypeChannel,
		},
	},
}
View Source
var PipelineStepMessageBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name: schema.AttributeTypeTitle,
		},
		{
			Name: schema.AttributeTypeDescription,
		},
		{
			Name: schema.AttributeTypeForEach,
		},
		{
			Name: schema.AttributeTypeDependsOn,
		},
		{
			Name: schema.AttributeTypeIf,
		},
		{
			Name:     schema.AttributeTypeNotifier,
			Required: true,
		},
		{
			Name:     schema.AttributeTypeText,
			Required: true,
		},
		{
			Name:     schema.AttributeTypeTo,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeCc,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeBcc,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeSubject,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeChannel,
			Required: false,
		},
	},
	Blocks: []hcl.BlockHeaderSchema{
		{
			Type: schema.BlockTypeError,
		},
		{
			Type:       schema.BlockTypePipelineOutput,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type: schema.BlockTypeRetry,
		},
		{
			Type: schema.BlockTypeThrow,
		},
		{
			Type: schema.BlockTypeLoop,
		},
	},
}
View Source
var PipelineStepPipelineBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name: schema.AttributeTypeTitle,
		},
		{
			Name: schema.AttributeTypeDescription,
		},
		{
			Name: schema.AttributeTypeForEach,
		},
		{
			Name: schema.AttributeTypeDependsOn,
		},
		{
			Name: schema.AttributeTypeIf,
		},
		{
			Name: schema.AttributeTypePipeline,
		},
		{
			Name: schema.AttributeTypeArgs,
		},
		{
			Name: schema.AttributeTypeMaxConcurrency,
		},
	},
	Blocks: []hcl.BlockHeaderSchema{
		{
			Type: schema.BlockTypeError,
		},
		{
			Type:       schema.BlockTypePipelineOutput,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type: schema.BlockTypeLoop,
		},
		{
			Type: schema.BlockTypeRetry,
		},
		{
			Type: schema.BlockTypeThrow,
		},
	},
}
View Source
var PipelineStepQueryBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name: schema.AttributeTypeTitle,
		},
		{
			Name: schema.AttributeTypeDescription,
		},
		{
			Name: schema.AttributeTypeTimeout,
		},
		{
			Name: schema.AttributeTypeForEach,
		},
		{
			Name: schema.AttributeTypeDependsOn,
		},
		{
			Name: schema.AttributeTypeIf,
		},
		{
			Name: schema.AttributeTypeSql,
		},
		{
			Name: schema.AttributeTypeDatabase,
		},
		{
			Name: schema.AttributeTypeArgs,
		},
		{
			Name: schema.AttributeTypeMaxConcurrency,
		},
	},
	Blocks: []hcl.BlockHeaderSchema{
		{
			Type: schema.BlockTypeError,
		},
		{
			Type:       schema.BlockTypePipelineOutput,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type: schema.BlockTypeLoop,
		},
		{
			Type: schema.BlockTypeRetry,
		},
		{
			Type: schema.BlockTypeThrow,
		},
	},
}
View Source
var PipelineStepSleepBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name: schema.AttributeTypeTitle,
		},
		{
			Name: schema.AttributeTypeDescription,
		},
		{
			Name: schema.AttributeTypeForEach,
		},
		{
			Name: schema.AttributeTypeDependsOn,
		},
		{
			Name: schema.AttributeTypeIf,
		},
		{
			Name:     schema.AttributeTypeDuration,
			Required: true,
		},
		{
			Name: schema.AttributeTypeMaxConcurrency,
		},
	},
	Blocks: []hcl.BlockHeaderSchema{
		{
			Type: schema.BlockTypeError,
		},
		{
			Type:       schema.BlockTypePipelineOutput,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type: schema.BlockTypeLoop,
		},
		{
			Type: schema.BlockTypeRetry,
		},
		{
			Type: schema.BlockTypeThrow,
		},
	},
}
View Source
var PipelineStepTransformBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name: schema.AttributeTypeTitle,
		},
		{
			Name: schema.AttributeTypeDescription,
		},
		{
			Name: schema.AttributeTypeForEach,
		},
		{
			Name: schema.AttributeTypeDependsOn,
		},
		{
			Name: schema.AttributeTypeIf,
		},
		{
			Name: schema.AttributeTypeValue,
		},
		{
			Name: schema.AttributeTypeMaxConcurrency,
		},
	},
	Blocks: []hcl.BlockHeaderSchema{
		{
			Type: schema.BlockTypeError,
		},
		{
			Type:       schema.BlockTypePipelineOutput,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type: schema.BlockTypeLoop,
		},
		{
			Type: schema.BlockTypeRetry,
		},
		{
			Type: schema.BlockTypeThrow,
		},
	},
}
View Source
var TriggerHttpBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name:     schema.AttributeTypeDescription,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeTitle,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeDocumentation,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeTags,
			Required: false,
		},
		{
			Name: schema.AttributeTypePipeline,
		},
		{
			Name: schema.AttributeTypeExecutionMode,
		},
		{
			Name: schema.AttributeTypeArgs,
		},
		{
			Name: schema.AttributeTypeEnabled,
		},
	},
	Blocks: []hcl.BlockHeaderSchema{
		{
			Type:       schema.BlockTypeMethod,
			LabelNames: []string{schema.LabelName},
		},
	},
}
View Source
var TriggerIntervalBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name:     schema.AttributeTypeDescription,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeTitle,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeDocumentation,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeTags,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeSchedule,
			Required: true,
		},
		{
			Name:     schema.AttributeTypePipeline,
			Required: true,
		},
		{
			Name: schema.AttributeTypeArgs,
		},
		{
			Name: schema.AttributeTypeEnabled,
		},
	},
}
View Source
var TriggerQueryBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name:     schema.AttributeTypeDescription,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeTitle,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeDocumentation,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeTags,
			Required: false,
		},
		{

			Name: schema.AttributeTypeSchedule,
		},
		{
			Name:     schema.AttributeTypeSql,
			Required: true,
		},
		{
			Name: schema.AttributeTypePrimaryKey,
		},
		{
			Name:     schema.AttributeTypeDatabase,
			Required: true,
		},
		{
			Name: schema.AttributeTypeEnabled,
		},
	},
	Blocks: []hcl.BlockHeaderSchema{
		{
			Type:       schema.BlockTypeCapture,
			LabelNames: []string{schema.LabelName},
		},
	},
}
View Source
var TriggerScheduleBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name:     schema.AttributeTypeDescription,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeTitle,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeDocumentation,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeTags,
			Required: false,
		},
		{
			Name:     schema.AttributeTypeSchedule,
			Required: true,
		},
		{
			Name:     schema.AttributeTypePipeline,
			Required: true,
		},
		{
			Name: schema.AttributeTypeArgs,
		},
		{
			Name: schema.AttributeTypeEnabled,
		},
	},
}
View Source
var ValidDependsOnTypes = []string{
	schema.BlockTypePipelineStep,
}
View Source
var ValidImportSchemaValues = []string{ImportSchemaEnabled, ImportSchemaDisabled}

Functions

func BuildFullResourceName

func BuildFullResourceName(mod, blockType, name string) string

func BuildModBranchDependencyPath

func BuildModBranchDependencyPath(dependencyName string, branchName string) string

BuildModBranchDependencyPath converts a mod dependency name of form github.com/turbot/steampipe-mod-m2 and a branch into a dependency path of form github.com/turbot/steampipe-mod-m2#branch

func BuildModDependencyPath

func BuildModDependencyPath(dependencyName string, version *DependencyVersion) string

BuildModDependencyPath converts a mod dependency name of form github.com/turbot/steampipe-mod-m2 and a DependencyVersion into a dependency path of form: - github.com/turbot/steampipe-mod-m2@v1.0.0 - github.com/turbot/steampipe-mod-m2#branch - github.com/turbot/steampipe-mod-m2:filepath This represents the relative path the dependency will be installed at underneath the mods directory

func BuildModResourceName

func BuildModResourceName(blockType, name string) string

func DefaultIntegrations

func DefaultIntegrations() (map[string]Integration, error)

func DefaultNotifiers

func DefaultNotifiers(defaultHttpIntegration Integration) (map[string]Notifier, error)

func GenericTypeToBlockType

func GenericTypeToBlockType[T ModTreeItem]() string

GenericTypeToBlockType converts a resource type generic param into a block type NOTE special case handling for dashboard items

func GetCtyTypes

func GetCtyTypes(item interface{}) map[string]cty.Type

GetCtyTypes builds a map of cty types for all tagged properties. It is used to convert the struct to a cty value

func GetCtyValue

func GetCtyValue(item interface{}) (cty.Value, error)

GetCtyValue converts the item into a cty value

func GetTriggerTypeFromTriggerConfig

func GetTriggerTypeFromTriggerConfig(config TriggerConfig) string

GetTriggerTypeFromTriggerConfig returns the type of the trigger from the trigger config

func HclImplFromAttributes

func HclImplFromAttributes(hclResourceImpl *HclResourceImpl, hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func NewDefaultWorkspaceProfile

func NewDefaultWorkspaceProfile[T WorkspaceProfile]() (T, hcl.Diagnostics)

func NewWorkspaceProfile

func NewWorkspaceProfile[T WorkspaceProfile](block *hcl.Block) (T, hcl.Diagnostics)

func ResolveArgs

func ResolveArgs(qp QueryProvider, runtimeArgs *QueryArgs) ([]any, error)

ResolveArgs resolves the argument values, falling back on defaults from param definitions in the source (if present) it returns the arg values as a csv string which can be used in a query invocation (the arg values and param defaults will already have been converted to postgres format)

func SteampipeOptionsBlockMapping

func SteampipeOptionsBlockMapping(block *hcl.Block) (options.Options, hcl.Diagnostics)

SteampipeOptionsBlockMapping is an OptionsBlockFactory used to map global steampipe options TODO KAI look at deprecations

func UnqualifiedResourceName

func UnqualifiedResourceName(fullName string) string

UnqualifiedResourceName removes the mod prefix from the given name

Types

type BasicAuthConfig

type BasicAuthConfig struct {
	Username string `json:"username"`
	Password string `json:"password"`

	UnresolvedAttributes map[string]hcl.Expression `json:"-"`
}

func (*BasicAuthConfig) Equals

func (b *BasicAuthConfig) Equals(other *BasicAuthConfig) bool

func (*BasicAuthConfig) GetInputs

func (b *BasicAuthConfig) GetInputs(evalContext *hcl.EvalContext, unresolvedAttributes map[string]hcl.Expression) (*BasicAuthConfig, hcl.Diagnostics)

type Benchmark

type Benchmark struct {
	ResourceWithMetadataImpl
	ModTreeItemImpl

	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	// child names as NamedItem structs - used to allow setting children via the 'children' property
	ChildNames NamedItemList `cty:"child_names" json:"-"`
	// used for introspection tables
	ChildNameStrings []string `cty:"child_name_strings" column:"children,jsonb" json:"children,omitempty"`

	// dashboard specific properties
	Base    *Benchmark `hcl:"base" json:"-"`
	Width   *int       `cty:"width" hcl:"width" column:"width,string"  json:"width,omitempty"`
	Type    *string    `cty:"type" hcl:"type" column:"type,string"  json:"type,omitempty"`
	Display *string    `cty:"display" hcl:"display" json:"display,omitempty"`
}

Benchmark is a struct representing the Benchmark resource

func (*Benchmark) CtyValue

func (b *Benchmark) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*Benchmark) Diff

func (b *Benchmark) Diff(other *Benchmark) *DashboardTreeItemDiffs

func (*Benchmark) Equals

func (b *Benchmark) Equals(other *Benchmark) bool

func (*Benchmark) GetChildControls

func (b *Benchmark) GetChildControls() []*Control

GetChildControls return a flat list of controls underneath the benchmark in the tree

func (*Benchmark) GetDisplay

func (b *Benchmark) GetDisplay() string

GetDisplay implements DashboardLeafNode

func (*Benchmark) GetShowData

func (b *Benchmark) GetShowData() *printers.RowData

GetShowData implements printers.Showable

func (*Benchmark) GetType

func (b *Benchmark) GetType() string

GetType implements DashboardLeafNode

func (*Benchmark) GetUnqualifiedName

func (b *Benchmark) GetUnqualifiedName() string

GetUnqualifiedName implements DashboardLeafNode, ModTreeItem

func (*Benchmark) GetWidth

func (b *Benchmark) GetWidth() int

GetWidth implements DashboardLeafNode

func (*Benchmark) OnDecoded

func (b *Benchmark) OnDecoded(block *hcl.Block, _ ResourceMapsProvider) hcl.Diagnostics

OnDecoded implements HclResource

func (*Benchmark) SetChildren

func (b *Benchmark) SetChildren(children []ModTreeItem)

func (*Benchmark) String

func (b *Benchmark) String() string

func (*Benchmark) WalkResources

func (b *Benchmark) WalkResources(resourceFunc func(resource ModTreeItem) (bool, error)) error

type ConfigMap

type ConfigMap map[string]interface{}

func (ConfigMap) PopulateConfigMapForOptions

func (m ConfigMap) PopulateConfigMapForOptions(o options.Options)

PopulateConfigMapForOptions populates the config map for a given options object NOTE: this mutates configMap

func (ConfigMap) SetBoolItem

func (m ConfigMap) SetBoolItem(argValue *bool, argName string)

SetBoolItem checks is bool pointer is non-nil and if so, add to map with given key

func (ConfigMap) SetIntItem

func (m ConfigMap) SetIntItem(argValue *int, argName string)

SetIntItem checks is int pointer is non-nil and if so, add to map with given key

func (ConfigMap) SetStringItem

func (m ConfigMap) SetStringItem(argValue *string, argName string)

SetStringItem checks is string pointer is non-nil and if so, add to map with given key

func (ConfigMap) SetStringSliceItem

func (m ConfigMap) SetStringSliceItem(argValue []string, argName string)

SetStringSliceItem checks is string slice pointer is non-nil and if so, add to map with given key

type Connection

type Connection struct {
	// connection name
	Name string `json:"name"`
	// name of plugin as mentioned in config - this may be an alias to a plugin image ref
	// OR the label of a plugin config
	PluginAlias string `json:"plugin_short_name"`
	// image ref plugin.
	// we resolve this after loading all plugin configs
	Plugin string `json:"plugin"`
	// the label of the plugin config we are using
	PluginInstance *string `json:"plugin_instance"`
	// Path to the installed plugin (if it exists)
	PluginPath *string
	// connection type - supported values: "aggregator"
	Type string `json:"type,omitempty"`
	// should a schema be created for this connection - supported values: "enabled", "disabled"
	ImportSchema string `json:"import_schema"`
	// list of names or wildcards which are resolved to connections
	// (only valid for "aggregator" type)
	ConnectionNames []string `json:"connections,omitempty"`
	// a map of the resolved child connections
	// (only valid for "aggregator" type)
	Connections map[string]*Connection `json:"-"`
	// a list of the names resolved child connections
	// (only valid for "aggregator" type)
	ResolvedConnectionNames []string `json:"resolved_connections,omitempty"`
	// unparsed HCL of plugin specific connection config
	Config string `json:"config,omitempty"`

	Error error

	// options
	Options   *options.Connection `json:"options,omitempty"`
	DeclRange Range               `json:"decl_range"`
}

Connection is a struct representing the partially parsed connection

(Partial as the connection config, which is plugin specific, is stored as raw HCL. This will be parsed by the plugin) json tags needed as this is stored in the connection state file

func NewConnection

func NewConnection(block *hcl.Block) *Connection

func (*Connection) Equals

func (c *Connection) Equals(other *Connection) bool

func (*Connection) GetEmptyAggregatorError

func (c *Connection) GetEmptyAggregatorError() string

func (*Connection) GetResolveConnectionNames

func (c *Connection) GetResolveConnectionNames() []string

GetResolveConnectionNames return the names of all child connections (will only be non-empty for aggregator connections)

func (*Connection) ImportDisabled

func (c *Connection) ImportDisabled() bool

func (*Connection) PopulateChildren

func (c *Connection) PopulateChildren(connectionMap map[string]*Connection) []string

func (*Connection) SetOptions

func (c *Connection) SetOptions(opts options.Options, block *hcl.Block) hcl.Diagnostics

SetOptions sets the options on the connection verify the options object is a valid options type (only options.Connection currently supported)

func (*Connection) String

func (c *Connection) String() string

func (*Connection) Validate

func (c *Connection) Validate(map[string]*Connection) (warnings []string, errors []string)

Validate verifies the Type property is valid, if this is an aggregator connection, there must be at least one child, and no duplicates if this is NOT an aggregator, there must be no children

func (*Connection) ValidateAggregatorConnection

func (c *Connection) ValidateAggregatorConnection() (warnings, errors []string)

type Control

type Control struct {
	ResourceWithMetadataImpl
	QueryProviderImpl

	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	Severity *string `cty:"severity" hcl:"severity"  column:"severity,string" snapshot:"severity" json:"severity,omitempty"`

	// dashboard specific properties
	Base    *Control `hcl:"base" json:"-"`
	Width   *int     `cty:"width" hcl:"width" column:"width,string"  json:"width,omitempty"`
	Type    *string  `cty:"type" hcl:"type" column:"type,string"  json:"type,omitempty"`
	Display *string  `cty:"display" hcl:"display" json:"display,omitempty"`
	// contains filtered or unexported fields
}

Control is a struct representing the Control resource

func (*Control) CtyValue

func (c *Control) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*Control) Diff

func (c *Control) Diff(other *Control) *DashboardTreeItemDiffs

func (*Control) Equals

func (c *Control) Equals(other *Control) bool

func (*Control) GetDisplay

func (c *Control) GetDisplay() string

GetDisplay implements DashboardLeafNode

func (*Control) GetParentNames

func (c *Control) GetParentNames() []string

func (*Control) GetShowData

func (c *Control) GetShowData() *printers.RowData

GetShowData implements printers.Showable

func (*Control) GetType

func (c *Control) GetType() string

GetType implements DashboardLeafNode

func (*Control) GetWidth

func (c *Control) GetWidth() int

GetWidth implements DashboardLeafNode

func (*Control) OnDecoded

func (c *Control) OnDecoded(block *hcl.Block, resourceMapProvider ResourceMapsProvider) hcl.Diagnostics

OnDecoded implements HclResource

func (*Control) String

func (c *Control) String() string

type CtyValueProvider

type CtyValueProvider interface {
	CtyValue() (cty.Value, error)
}

type Dashboard

type Dashboard struct {
	ResourceWithMetadataImpl
	ModTreeItemImpl
	WithProviderImpl

	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	Width   *int              `cty:"width" hcl:"width"  column:"width,string" json:"width,omitempty"`
	Display *string           `cty:"display" hcl:"display" column:"display,string" json:"display,omitempty"`
	Inputs  []*DashboardInput `cty:"inputs" column:"inputs,jsonb" json:"inputs,omitempty"`
	UrlPath string            `cty:"url_path"  column:"url_path,jsonb" json:"url_path,omitempty"`
	Base    *Dashboard        `hcl:"base" json:"-"`
	// store children in a way which can be serialised via cty
	ChildNames []string `cty:"children" column:"children,jsonb" json:"children,omitempty"`
	// contains filtered or unexported fields
}

Dashboard is a struct representing the Dashboard resource

func NewQueryDashboard

func NewQueryDashboard(qp QueryProvider) (*Dashboard, error)

NewQueryDashboard creates a dashboard to wrap a query/control this is used for snapshot generation

func (*Dashboard) AddChild

func (d *Dashboard) AddChild(child ModTreeItem) hcl.Diagnostics

func (*Dashboard) CtyValue

func (d *Dashboard) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*Dashboard) Diff

func (d *Dashboard) Diff(other *Dashboard) *DashboardTreeItemDiffs

func (*Dashboard) Equals

func (d *Dashboard) Equals(other *Dashboard) bool

func (*Dashboard) GetDisplay

func (d *Dashboard) GetDisplay() string

GetDisplay implements DashboardLeafNode

func (*Dashboard) GetInput

func (d *Dashboard) GetInput(name string) (*DashboardInput, bool)

func (*Dashboard) GetInputs

func (d *Dashboard) GetInputs() map[string]*DashboardInput

func (*Dashboard) GetType

func (d *Dashboard) GetType() string

GetType implements DashboardLeafNode

func (*Dashboard) GetWidth

func (d *Dashboard) GetWidth() int

GetWidth implements DashboardLeafNode

func (*Dashboard) InitInputs

func (d *Dashboard) InitInputs() hcl.Diagnostics

func (*Dashboard) OnDecoded

func (d *Dashboard) OnDecoded(block *hcl.Block, _ ResourceMapsProvider) hcl.Diagnostics

OnDecoded implements HclResource

func (*Dashboard) SetChildren

func (d *Dashboard) SetChildren(children []ModTreeItem)

func (*Dashboard) ValidateRuntimeDependencies

func (d *Dashboard) ValidateRuntimeDependencies(workspace ResourceMapsProvider) error

func (*Dashboard) WalkResources

func (d *Dashboard) WalkResources(resourceFunc func(resource HclResource) (bool, error)) error

type DashboardCard

type DashboardCard struct {
	ResourceWithMetadataImpl
	QueryProviderImpl

	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	Label *string `cty:"label" hcl:"label" column:"label,string" snapshot:"label" json:"label,omitempty"`
	Value *string `cty:"value" hcl:"value" column:"value,string" snapshot:"value" json:"value,omitempty"`
	Icon  *string `cty:"icon" hcl:"icon" column:"icon,string" snapshot:"icon" json:"icon,omitempty"`
	HREF  *string `cty:"href" hcl:"href" snapshot:"href" json:"href,omitempty"`

	Width   *int           `cty:"width" hcl:"width" column:"width,string"  json:"width,omitempty"`
	Type    *string        `cty:"type" hcl:"type" column:"type,string"  json:"type,omitempty"`
	Display *string        `cty:"display" hcl:"display" json:"display,omitempty"`
	Base    *DashboardCard `hcl:"base" json:"-"`
}

DashboardCard is a struct representing a leaf dashboard node

func (*DashboardCard) CtyValue

func (c *DashboardCard) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*DashboardCard) Diff

func (*DashboardCard) Equals

func (c *DashboardCard) Equals(other *DashboardCard) bool

func (*DashboardCard) GetDisplay

func (c *DashboardCard) GetDisplay() string

GetDisplay implements DashboardLeafNode

func (*DashboardCard) GetDocumentation

func (c *DashboardCard) GetDocumentation() string

GetDocumentation implements DashboardLeafNode, ModTreeItem

func (*DashboardCard) GetShowData

func (c *DashboardCard) GetShowData() *printers.RowData

GetShowData implements printers.Showable

func (*DashboardCard) GetType

func (c *DashboardCard) GetType() string

GetType implements DashboardLeafNode

func (*DashboardCard) GetWidth

func (c *DashboardCard) GetWidth() int

GetWidth implements DashboardLeafNode

func (*DashboardCard) OnDecoded

func (c *DashboardCard) OnDecoded(block *hcl.Block, resourceMapProvider ResourceMapsProvider) hcl.Diagnostics

OnDecoded implements HclResource

func (*DashboardCard) ValidateQuery

func (c *DashboardCard) ValidateQuery() hcl.Diagnostics

ValidateQuery implements QueryProvider

type DashboardCategory

type DashboardCategory struct {
	ResourceWithMetadataImpl
	ModTreeItemImpl

	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	// TACTICAL: include a title property (with a different name to the property in HclResourceImpl  for clarity)
	// This is purely to ensure the title is included in the panel properties of snapshots
	// Note: this will be parsed from HCL, but we must set this explicitly in setBaseProperties if there is a base
	CategoryTitle *string                               `cty:"title" hcl:"title" snapshot:"title" json:"title,omitempty"`
	Color         *string                               `cty:"color" hcl:"color" snapshot:"color" json:"color,omitempty"`
	Depth         *int                                  `cty:"depth" hcl:"depth" snapshot:"depth" json:"depth,omitempty"`
	Icon          *string                               `cty:"icon" hcl:"icon" snapshot:"icon" json:"icon,omitempty"`
	HREF          *string                               `cty:"href" hcl:"href" snapshot:"href" json:"href,omitempty"`
	Fold          *DashboardCategoryFold                `cty:"fold" hcl:"fold,block" snapshot:"fold" json:"fold,omitempty"`
	PropertyList  DashboardCategoryPropertyList         `cty:"property_list" hcl:"property,block" column:"properties,jsonb" json:"-"`
	Properties    map[string]*DashboardCategoryProperty `cty:"properties" snapshot:"properties" json:"properties,omitempty"`
	PropertyOrder []string                              `cty:"property_order" hcl:"property_order,optional" snapshot:"property_order" json:"property_order,omitempty"`
	Base          *DashboardCategory                    `hcl:"base" json:"base,omitempty"`
}

func (*DashboardCategory) CtyValue

func (c *DashboardCategory) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*DashboardCategory) Diff

func (*DashboardCategory) Equals

func (c *DashboardCategory) Equals(other *DashboardCategory) bool

func (*DashboardCategory) OnDecoded

func (c *DashboardCategory) OnDecoded(block *hcl.Block, _ ResourceMapsProvider) hcl.Diagnostics

OnDecoded implements HclResource

type DashboardCategoryFold

type DashboardCategoryFold struct {
	Title     *string `cty:"title" hcl:"title" snapshot:"title" json:"title,omitempty"`
	Threshold *int    `cty:"threshold" hcl:"threshold" snapshot:"threshold" json:"threshold,omitempty"`
	Icon      *string `cty:"icon" hcl:"icon" snapshot:"icon" json:"icon,omitempty"`
}

func (DashboardCategoryFold) Equals

type DashboardCategoryList

type DashboardCategoryList []*DashboardCategory

func (*DashboardCategoryList) Merge

type DashboardCategoryProperty

type DashboardCategoryProperty struct {
	ShortName string  `hcl:"name,label" snapshot:"name" json:"name"`
	Display   *string `cty:"display" hcl:"display" snapshot:"display" json:"display,omitempty"`
	Wrap      *string `cty:"wrap" hcl:"wrap" snapshot:"wrap" json:"wrap,omitempty"`
	HREF      *string `cty:"href" hcl:"href" snapshot:"href" json:"href,omitempty"`
}

func (DashboardCategoryProperty) Equals

type DashboardCategoryPropertyList

type DashboardCategoryPropertyList []*DashboardCategoryProperty

func (*DashboardCategoryPropertyList) Merge

type DashboardChart

type DashboardChart struct {
	ResourceWithMetadataImpl
	QueryProviderImpl

	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	Width      *int                             `cty:"width" hcl:"width" column:"width,string" json:"width,omitempty"`
	Type       *string                          `cty:"type" hcl:"type" column:"type,string" json:"type,omitempty"`
	Display    *string                          `cty:"display" hcl:"display" json:"display,omitempty"`
	Legend     *DashboardChartLegend            `cty:"legend" hcl:"legend,block" column:"legend,jsonb" snapshot:"legend" json:"legend,omitempty"`
	SeriesList DashboardChartSeriesList         `cty:"series_list" hcl:"series,block" column:"series,jsonb" json:"series,omitempty"`
	Axes       *DashboardChartAxes              `cty:"axes" hcl:"axes,block" column:"axes,jsonb" snapshot:"axes" json:"axes,omitempty"`
	Grouping   *string                          `cty:"grouping" hcl:"grouping" snapshot:"grouping" json:"grouping,omitempty"`
	Transform  *string                          `cty:"transform" hcl:"transform" snapshot:"transform" json:"transform,omitempty"`
	Series     map[string]*DashboardChartSeries `cty:"series" snapshot:"series"`
	Base       *DashboardChart                  `hcl:"base" json:"-"`
}

DashboardChart is a struct representing a leaf dashboard node

func (*DashboardChart) CtyValue

func (c *DashboardChart) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*DashboardChart) Diff

func (*DashboardChart) Equals

func (c *DashboardChart) Equals(other *DashboardChart) bool

func (*DashboardChart) GetDisplay

func (c *DashboardChart) GetDisplay() string

GetDisplay implements DashboardLeafNode

func (*DashboardChart) GetShowData

func (c *DashboardChart) GetShowData() *printers.RowData

GetShowData implements printers.Showable

func (*DashboardChart) GetType

func (c *DashboardChart) GetType() string

GetType implements DashboardLeafNode

func (*DashboardChart) GetWidth

func (c *DashboardChart) GetWidth() int

GetWidth implements DashboardLeafNode

func (*DashboardChart) OnDecoded

func (c *DashboardChart) OnDecoded(block *hcl.Block, resourceMapProvider ResourceMapsProvider) hcl.Diagnostics

OnDecoded implements HclResource

type DashboardChartAxes

type DashboardChartAxes struct {
	X *DashboardChartAxesX `cty:"x" hcl:"x,block" json:"x,omitempty"`
	Y *DashboardChartAxesY `cty:"y" hcl:"y,block" json:"y,omitempty"`
}

func (*DashboardChartAxes) Equals

func (a *DashboardChartAxes) Equals(other *DashboardChartAxes) bool

func (*DashboardChartAxes) Merge

func (a *DashboardChartAxes) Merge(other *DashboardChartAxes)

type DashboardChartAxesX

type DashboardChartAxesX struct {
	Title  *DashboardChartAxisTitle `cty:"title" hcl:"title,block" json:"title,omitempty"`
	Labels *DashboardChartLabels    `cty:"labels" hcl:"labels,block" json:"labels,omitempty"`
	Min    *int                     `cty:"min" hcl:"min" json:"min,omitempty"`
	Max    *int                     `cty:"max" hcl:"max" json:"max,omitempty"`
}

func (*DashboardChartAxesX) Equals

func (x *DashboardChartAxesX) Equals(other *DashboardChartAxesX) bool

func (*DashboardChartAxesX) Merge

func (x *DashboardChartAxesX) Merge(other *DashboardChartAxesX)

type DashboardChartAxesY

type DashboardChartAxesY struct {
	Title  *DashboardChartAxisTitle `cty:"title" hcl:"title,block" json:"title,omitempty"`
	Labels *DashboardChartLabels    `cty:"labels" hcl:"labels,block" json:"labels,omitempty"`
	Min    *int                     `cty:"min" hcl:"min" json:"min,omitempty"`
	Max    *int                     `cty:"max" hcl:"max" json:"max,omitempty"`
}

func (*DashboardChartAxesY) Equals

func (y *DashboardChartAxesY) Equals(other *DashboardChartAxesY) bool

func (*DashboardChartAxesY) Merge

func (y *DashboardChartAxesY) Merge(other *DashboardChartAxesY)

type DashboardChartAxisTitle

type DashboardChartAxisTitle struct {
	Display *string `cty:"display" hcl:"display" json:"display,omitempty"`
	Align   *string `cty:"align" hcl:"align" json:"align,omitempty"`
	Value   *string `cty:"value" hcl:"value" json:"value,omitempty"`
}

func (*DashboardChartAxisTitle) Equals

func (*DashboardChartAxisTitle) Merge

type DashboardChartLabels

type DashboardChartLabels struct {
	Display *string `cty:"display" hcl:"display" json:"display,omitempty"`
	Format  *string `cty:"format" hcl:"format" json:"format,omitempty"`
}

func (*DashboardChartLabels) Equals

func (*DashboardChartLabels) Merge

func (l *DashboardChartLabels) Merge(other *DashboardChartLabels)

type DashboardChartLegend

type DashboardChartLegend struct {
	Display  *string `cty:"display" hcl:"display" json:"display,omitempty"`
	Position *string `cty:"position" hcl:"position" json:"position,omitempty"`
}

func (*DashboardChartLegend) Equals

func (*DashboardChartLegend) Merge

func (l *DashboardChartLegend) Merge(other *DashboardChartLegend)

type DashboardChartSeries

type DashboardChartSeries struct {
	Name       string                                `hcl:"name,label" json:"name"`
	Title      *string                               `cty:"title" hcl:"title" json:"title,omitempty"`
	Color      *string                               `cty:"color" hcl:"color" json:"color,omitempty"`
	Points     map[string]*DashboardChartSeriesPoint `cty:"points" json:"points,omitempty"`
	PointsList []*DashboardChartSeriesPoint          `hcl:"point,block" json:"-"`
}

func (*DashboardChartSeries) Equals

func (*DashboardChartSeries) OnDecoded

func (s *DashboardChartSeries) OnDecoded()

type DashboardChartSeriesList

type DashboardChartSeriesList []*DashboardChartSeries

func (*DashboardChartSeriesList) Merge

type DashboardChartSeriesPoint

type DashboardChartSeriesPoint struct {
	Name  string  `hcl:"name,label" json:"-"`
	Color *string `cty:"color" hcl:"color" json:"color,omitempty"`
}

func (DashboardChartSeriesPoint) Equals

type DashboardContainer

type DashboardContainer struct {
	ResourceWithMetadataImpl
	ModTreeItemImpl

	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	Width   *int              `cty:"width" hcl:"width"  column:"width,string" json:"width,omitempty"`
	Display *string           `cty:"display" hcl:"display" json:"display,omitempty"`
	Inputs  []*DashboardInput `cty:"inputs" column:"inputs,jsonb" json:"inputs,omitempty"`
	// store children in a way which can be serialised via cty
	ChildNames []string `cty:"children" column:"children,jsonb" json:"children,omitempty"`
	// contains filtered or unexported fields
}

DashboardContainer is a struct representing the Dashboard and Container resource

func (*DashboardContainer) AddChild

func (c *DashboardContainer) AddChild(child ModTreeItem)

func (*DashboardContainer) CtyValue

func (c *DashboardContainer) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*DashboardContainer) Diff

func (*DashboardContainer) Equals

func (c *DashboardContainer) Equals(other *DashboardContainer) bool

func (*DashboardContainer) GetDisplay

func (c *DashboardContainer) GetDisplay() string

GetDisplay implements DashboardLeafNode

func (*DashboardContainer) GetShowData

func (c *DashboardContainer) GetShowData() *printers.RowData

GetShowData implements printers.Showable

func (*DashboardContainer) GetType

func (c *DashboardContainer) GetType() string

GetType implements DashboardLeafNode

func (*DashboardContainer) GetWidth

func (c *DashboardContainer) GetWidth() int

GetWidth implements DashboardLeafNode

func (*DashboardContainer) OnDecoded

func (c *DashboardContainer) OnDecoded(block *hcl.Block, _ ResourceMapsProvider) hcl.Diagnostics

OnDecoded implements HclResource

func (*DashboardContainer) SetChildren

func (c *DashboardContainer) SetChildren(children []ModTreeItem)

func (*DashboardContainer) WalkResources

func (c *DashboardContainer) WalkResources(resourceFunc func(resource HclResource) (bool, error)) error

type DashboardEdge

type DashboardEdge struct {
	ResourceWithMetadataImpl
	QueryProviderImpl

	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	Category *DashboardCategory `cty:"category" hcl:"category" snapshot:"category" json:"category,omitempty"`
	Base     *DashboardEdge     `hcl:"base" json:"-"`
}

DashboardEdge is a struct representing a leaf dashboard node

func (*DashboardEdge) CtyValue

func (e *DashboardEdge) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*DashboardEdge) Diff

func (*DashboardEdge) Equals

func (e *DashboardEdge) Equals(other *DashboardEdge) bool

func (*DashboardEdge) GetDisplay

func (e *DashboardEdge) GetDisplay() string

GetDisplay implements DashboardLeafNode

func (*DashboardEdge) GetDocumentation

func (e *DashboardEdge) GetDocumentation() string

GetDocumentation implements DashboardLeafNode

func (*DashboardEdge) GetType

func (e *DashboardEdge) GetType() string

GetType implements DashboardLeafNode

func (*DashboardEdge) GetWidth

func (e *DashboardEdge) GetWidth() int

GetWidth implements DashboardLeafNode

func (*DashboardEdge) OnDecoded

func (e *DashboardEdge) OnDecoded(_ *hcl.Block, resourceMapProvider ResourceMapsProvider) hcl.Diagnostics

OnDecoded implements HclResource

type DashboardEdgeList

type DashboardEdgeList []*DashboardEdge

func (*DashboardEdgeList) Contains

func (l *DashboardEdgeList) Contains(other *DashboardEdge) bool

func (*DashboardEdgeList) Get

func (l *DashboardEdgeList) Get(name string) *DashboardEdge

func (*DashboardEdgeList) Merge

func (l *DashboardEdgeList) Merge(other DashboardEdgeList)

func (*DashboardEdgeList) Names

func (l *DashboardEdgeList) Names() []string

type DashboardFlow

type DashboardFlow struct {
	ResourceWithMetadataImpl
	QueryProviderImpl
	WithProviderImpl

	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	Nodes     DashboardNodeList `cty:"node_list"  column:"nodes,jsonb" json:"-"`
	Edges     DashboardEdgeList `cty:"edge_list" column:"edges,jsonb" json:"-"`
	NodeNames []string          `json:"nodes" snapshot:"nodes"`
	EdgeNames []string          `json:"edges" snapshot:"edges"`

	Categories map[string]*DashboardCategory `cty:"categories" json:"categories" snapshot:"categories"`

	Width   *int    `cty:"width" hcl:"width" column:"width,string"  json:"width,omitempty"`
	Type    *string `cty:"type" hcl:"type" column:"type,string"  json:"type,omitempty"`
	Display *string `cty:"display" hcl:"display" json:"display,omitempty"`

	Base *DashboardFlow `hcl:"base" json:"-"`
}

DashboardFlow is a struct representing a leaf dashboard node

func (*DashboardFlow) AddCategory

func (f *DashboardFlow) AddCategory(category *DashboardCategory) hcl.Diagnostics

AddCategory implements NodeAndEdgeProvider

func (*DashboardFlow) AddChild

func (f *DashboardFlow) AddChild(child HclResource) hcl.Diagnostics

AddChild implements NodeAndEdgeProvider

func (*DashboardFlow) CtyValue

func (f *DashboardFlow) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*DashboardFlow) Diff

func (*DashboardFlow) Equals

func (f *DashboardFlow) Equals(other *DashboardFlow) bool

func (*DashboardFlow) GetChildren

func (f *DashboardFlow) GetChildren() []ModTreeItem

TODO [node_reuse] Add DashboardLeafNodeImpl and move this there https://github.com/turbot/steampipe/issues/2926 GetChildren implements ModTreeItem

func (*DashboardFlow) GetDisplay

func (f *DashboardFlow) GetDisplay() string

GetDisplay implements DashboardLeafNode

func (*DashboardFlow) GetEdges

func (f *DashboardFlow) GetEdges() DashboardEdgeList

GetEdges implements NodeAndEdgeProvider

func (*DashboardFlow) GetNodes

func (f *DashboardFlow) GetNodes() DashboardNodeList

GetNodes implements NodeAndEdgeProvider

func (*DashboardFlow) GetShowData

func (f *DashboardFlow) GetShowData() *printers.RowData

GetShowData implements printers.Showable

func (*DashboardFlow) GetType

func (f *DashboardFlow) GetType() string

GetType implements DashboardLeafNode

func (*DashboardFlow) GetWidth

func (f *DashboardFlow) GetWidth() int

GetWidth implements DashboardLeafNode

func (*DashboardFlow) OnDecoded

func (f *DashboardFlow) OnDecoded(block *hcl.Block, resourceMapProvider ResourceMapsProvider) hcl.Diagnostics

OnDecoded implements HclResource

func (*DashboardFlow) SetEdges

func (f *DashboardFlow) SetEdges(edges DashboardEdgeList)

SetEdges implements NodeAndEdgeProvider

func (*DashboardFlow) SetNodes

func (f *DashboardFlow) SetNodes(nodes DashboardNodeList)

SetNodes implements NodeAndEdgeProvider

func (*DashboardFlow) ValidateQuery

func (*DashboardFlow) ValidateQuery() hcl.Diagnostics

ValidateQuery implements QueryProvider

type DashboardGraph

type DashboardGraph struct {
	ResourceWithMetadataImpl
	QueryProviderImpl
	WithProviderImpl

	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	Nodes     DashboardNodeList `cty:"node_list" column:"nodes,jsonb" json:"nodes,omitempty"`
	Edges     DashboardEdgeList `cty:"edge_list" column:"edges,jsonb" json:"edges,omitempty"`
	NodeNames []string          `snapshot:"nodes"`
	EdgeNames []string          `snapshot:"edges"`

	Categories map[string]*DashboardCategory `cty:"categories" json:"categories,omitempty" snapshot:"categories"`
	Direction  *string                       `cty:"direction" hcl:"direction" column:"direction,string" json:"direction,omitempty" snapshot:"direction"`

	// these properties are JSON serialised by the parent LeafRun
	Width   *int    `cty:"width" hcl:"width" column:"width,string"  json:"width,omitempty"`
	Type    *string `cty:"type" hcl:"type" column:"type,string"  json:"type,omitempty"`
	Display *string `cty:"display" hcl:"display" json:"display,omitempty"`

	Base *DashboardGraph `hcl:"base" json:"-"`
}

DashboardGraph is a struct representing a leaf dashboard node

func (*DashboardGraph) AddCategory

func (g *DashboardGraph) AddCategory(category *DashboardCategory) hcl.Diagnostics

AddCategory implements NodeAndEdgeProvider

func (*DashboardGraph) AddChild

func (g *DashboardGraph) AddChild(child HclResource) hcl.Diagnostics

AddChild implements NodeAndEdgeProvider

func (*DashboardGraph) CtyValue

func (g *DashboardGraph) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*DashboardGraph) Diff

func (*DashboardGraph) Equals

func (g *DashboardGraph) Equals(other *DashboardGraph) bool

func (*DashboardGraph) GetChildren

func (g *DashboardGraph) GetChildren() []ModTreeItem

GetChildren implements ModTreeItem

func (*DashboardGraph) GetDisplay

func (g *DashboardGraph) GetDisplay() string

GetDisplay implements DashboardLeafNode

func (*DashboardGraph) GetEdges

func (g *DashboardGraph) GetEdges() DashboardEdgeList

GetEdges implements NodeAndEdgeProvider

func (*DashboardGraph) GetNodes

func (g *DashboardGraph) GetNodes() DashboardNodeList

GetNodes implements NodeAndEdgeProvider

func (*DashboardGraph) GetShowData

func (g *DashboardGraph) GetShowData() *printers.RowData

GetShowData implements printers.Showable

func (*DashboardGraph) GetType

func (g *DashboardGraph) GetType() string

GetType implements DashboardLeafNode

func (*DashboardGraph) GetWidth

func (g *DashboardGraph) GetWidth() int

GetWidth implements DashboardLeafNode

func (*DashboardGraph) OnDecoded

func (g *DashboardGraph) OnDecoded(block *hcl.Block, resourceMapProvider ResourceMapsProvider) hcl.Diagnostics

OnDecoded implements HclResource

func (*DashboardGraph) SetEdges

func (g *DashboardGraph) SetEdges(edges DashboardEdgeList)

SetEdges implements NodeAndEdgeProvider

func (*DashboardGraph) SetNodes

func (g *DashboardGraph) SetNodes(nodes DashboardNodeList)

SetNodes implements NodeAndEdgeProvider

type DashboardHierarchy

type DashboardHierarchy struct {
	ResourceWithMetadataImpl
	QueryProviderImpl
	WithProviderImpl

	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	Nodes     DashboardNodeList `cty:"node_list" column:"nodes,jsonb" json:"nodes,omitempty"`
	Edges     DashboardEdgeList `cty:"edge_list" column:"edges,jsonb" json:"edges,omitempty"`
	NodeNames []string          `snapshot:"nodes"`
	EdgeNames []string          `snapshot:"edges"`

	Categories map[string]*DashboardCategory `cty:"categories" json:"categories,omitempty" snapshot:"categories"`
	Width      *int                          `cty:"width" hcl:"width" column:"width,string"  json:"width,omitempty"`
	Type       *string                       `cty:"type" hcl:"type" column:"type,string"  json:"type,omitempty"`
	Display    *string                       `cty:"display" hcl:"display" json:"display,omitempty"`

	Base *DashboardHierarchy `hcl:"base" json:"-"`
}

DashboardHierarchy is a struct representing a leaf dashboard node

func (*DashboardHierarchy) AddCategory

func (h *DashboardHierarchy) AddCategory(category *DashboardCategory) hcl.Diagnostics

AddCategory implements NodeAndEdgeProvider

func (*DashboardHierarchy) AddChild

func (h *DashboardHierarchy) AddChild(child HclResource) hcl.Diagnostics

AddChild implements NodeAndEdgeProvider

func (*DashboardHierarchy) CtyValue

func (h *DashboardHierarchy) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*DashboardHierarchy) Diff

func (*DashboardHierarchy) Equals

func (h *DashboardHierarchy) Equals(other *DashboardHierarchy) bool

func (*DashboardHierarchy) GetChildren

func (h *DashboardHierarchy) GetChildren() []ModTreeItem

GetChildren implements ModTreeItem

func (*DashboardHierarchy) GetDisplay

func (h *DashboardHierarchy) GetDisplay() string

GetDisplay implements DashboardLeafNode

func (*DashboardHierarchy) GetDocumentation

func (h *DashboardHierarchy) GetDocumentation() string

GetDocumentation implements DashboardLeafNode, ModTreeItem

func (*DashboardHierarchy) GetEdges

func (h *DashboardHierarchy) GetEdges() DashboardEdgeList

GetEdges implements NodeAndEdgeProvider

func (*DashboardHierarchy) GetNodes

func (h *DashboardHierarchy) GetNodes() DashboardNodeList

GetNodes implements NodeAndEdgeProvider

func (*DashboardHierarchy) GetShowData

func (h *DashboardHierarchy) GetShowData() *printers.RowData

GetShowData implements printers.Showable

func (*DashboardHierarchy) GetType

func (h *DashboardHierarchy) GetType() string

GetType implements DashboardLeafNode

func (*DashboardHierarchy) GetWidth

func (h *DashboardHierarchy) GetWidth() int

GetWidth implements DashboardLeafNode

func (*DashboardHierarchy) OnDecoded

func (h *DashboardHierarchy) OnDecoded(block *hcl.Block, resourceMapProvider ResourceMapsProvider) hcl.Diagnostics

OnDecoded implements HclResource

func (*DashboardHierarchy) SetEdges

func (h *DashboardHierarchy) SetEdges(edges DashboardEdgeList)

SetEdges implements NodeAndEdgeProvider

func (*DashboardHierarchy) SetNodes

func (h *DashboardHierarchy) SetNodes(nodes DashboardNodeList)

SetNodes implements NodeAndEdgeProvider

type DashboardImage

type DashboardImage struct {
	ResourceWithMetadataImpl
	QueryProviderImpl

	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	Src *string `cty:"src" hcl:"src" column:"src,string"  json:"src,omitempty" snapshot:"src"`
	Alt *string `cty:"alt" hcl:"alt" column:"alt,string"  json:"alt,omitempty" snapshot:"alt"`

	// these properties are JSON serialised by the parent LeafRun
	Width   *int    `cty:"width" hcl:"width" column:"width,string"  json:"width,omitempty" `
	Display *string `cty:"display" hcl:"display" json:"display,omitempty"`

	Base *DashboardImage `hcl:"base" json:"-"`
}

DashboardImage is a struct representing a leaf dashboard node

func (*DashboardImage) CtyValue

func (i *DashboardImage) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*DashboardImage) Diff

func (*DashboardImage) Equals

func (i *DashboardImage) Equals(other *DashboardImage) bool

func (*DashboardImage) GetDisplay

func (i *DashboardImage) GetDisplay() string

GetDisplay implements DashboardLeafNode

func (*DashboardImage) GetDocumentation

func (*DashboardImage) GetDocumentation() string

GetDocumentation implements DashboardLeafNode, ModTreeItem

func (*DashboardImage) GetShowData

func (i *DashboardImage) GetShowData() *printers.RowData

GetShowData implements printers.Showable

func (*DashboardImage) GetType

func (*DashboardImage) GetType() string

GetType implements DashboardLeafNode

func (*DashboardImage) GetWidth

func (i *DashboardImage) GetWidth() int

GetWidth implements DashboardLeafNode

func (*DashboardImage) OnDecoded

func (i *DashboardImage) OnDecoded(block *hcl.Block, resourceMapProvider ResourceMapsProvider) hcl.Diagnostics

OnDecoded implements HclResource

func (*DashboardImage) ValidateQuery

func (i *DashboardImage) ValidateQuery() hcl.Diagnostics

ValidateQuery implements QueryProvider

type DashboardInput

type DashboardInput struct {
	ResourceWithMetadataImpl
	QueryProviderImpl

	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	DashboardName string                  `column:"dashboard,string" json:"dashboard,omitempty"`
	Label         *string                 `cty:"label" hcl:"label" column:"label,string" json:"label,omitempty" snapshot:"label"`
	Placeholder   *string                 `cty:"placeholder" hcl:"placeholder" column:"placeholder,string" json:"placeholder,omitempty" snapshot:"placeholder"`
	Options       []*DashboardInputOption `cty:"options" hcl:"option,block" json:"options,omitempty" snapshot:"options"`
	// tactical - exists purely so we can put "unqualified_name" in the snbapshot panel for the input
	// TODO remove when input names are refactored https://github.com/turbot/steampipe/issues/2863
	InputName string `cty:"input_name" json:"unqualified_name" snapshot:"unqualified_name"`

	// these properties are JSON serialised by the parent LeafRun
	Width   *int            `cty:"width" hcl:"width" column:"width,string"  json:"width,omitempty"`
	Type    *string         `cty:"type" hcl:"type" column:"type,string"  json:"type,omitempty"`
	Display *string         `cty:"display" hcl:"display" json:"display,omitempty"`
	Base    *DashboardInput `hcl:"base" json:"-"`
	// contains filtered or unexported fields
}

DashboardInput is a struct representing a leaf dashboard node

func (*DashboardInput) Clone

func (i *DashboardInput) Clone() *DashboardInput

TODO remove https://github.com/turbot/steampipe/issues/2864

func (*DashboardInput) CtyValue

func (i *DashboardInput) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*DashboardInput) DependsOnInput

func (i *DashboardInput) DependsOnInput(changedInputName string) bool

DependsOnInput returns whether this input has a runtime dependency on the given input¬

func (*DashboardInput) Diff

func (*DashboardInput) Equals

func (i *DashboardInput) Equals(other *DashboardInput) bool

func (*DashboardInput) GetDisplay

func (i *DashboardInput) GetDisplay() string

GetDisplay implements DashboardLeafNode

func (*DashboardInput) GetShowData

func (i *DashboardInput) GetShowData() *printers.RowData

GetShowData implements printers.Showable

func (*DashboardInput) GetType

func (i *DashboardInput) GetType() string

GetType implements DashboardLeafNode

func (*DashboardInput) GetWidth

func (i *DashboardInput) GetWidth() int

GetWidth implements DashboardLeafNode

func (*DashboardInput) OnDecoded

func (i *DashboardInput) OnDecoded(block *hcl.Block, resourceMapProvider ResourceMapsProvider) hcl.Diagnostics

OnDecoded implements HclResource

func (*DashboardInput) SetDashboard

func (i *DashboardInput) SetDashboard(dashboard *Dashboard)

SetDashboard sets the parent dashboard container

func (*DashboardInput) ValidateQuery

func (i *DashboardInput) ValidateQuery() hcl.Diagnostics

ValidateQuery implements QueryProvider

type DashboardInputOption

type DashboardInputOption struct {
	Name  string  `hcl:"name,label" json:"name" snapshot:"name"`
	Label *string `cty:"label" hcl:"label" json:"label,omitempty" snapshot:"label"`
}

DashboardInputOption is a struct representing dashboard input option

func (DashboardInputOption) Equals

type DashboardLeafNode

type DashboardLeafNode interface {
	ModTreeItem
	ResourceWithMetadata
	GetDisplay() string
	GetType() string
	GetWidth() int
}

DashboardLeafNode must be implemented by resources may be a leaf node in the dashboard execution tree

type DashboardNode

type DashboardNode struct {
	ResourceWithMetadataImpl
	QueryProviderImpl

	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	Category *DashboardCategory `cty:"category" hcl:"category" column:"category,jsonb" json:"category,omitempty" snapshot:"category"`
	Base     *DashboardNode     `hcl:"base" json:"-"`
}

DashboardNode is a struct representing a leaf dashboard node

func (*DashboardNode) CtyValue

func (n *DashboardNode) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*DashboardNode) Diff

func (*DashboardNode) Equals

func (n *DashboardNode) Equals(other *DashboardNode) bool

func (*DashboardNode) GetDisplay

func (n *DashboardNode) GetDisplay() string

GetDisplay implements DashboardLeafNode

func (*DashboardNode) GetType

func (n *DashboardNode) GetType() string

GetType implements DashboardLeafNode

func (*DashboardNode) GetWidth

func (n *DashboardNode) GetWidth() int

GetWidth implements DashboardLeafNode

func (*DashboardNode) OnDecoded

func (n *DashboardNode) OnDecoded(_ *hcl.Block, resourceMapProvider ResourceMapsProvider) hcl.Diagnostics

OnDecoded implements HclResource—

type DashboardNodeList

type DashboardNodeList []*DashboardNode

func (*DashboardNodeList) Contains

func (l *DashboardNodeList) Contains(other *DashboardNode) bool

func (*DashboardNodeList) Get

func (l *DashboardNodeList) Get(name string) *DashboardNode

func (*DashboardNodeList) Merge

func (l *DashboardNodeList) Merge(other DashboardNodeList)

func (*DashboardNodeList) Names

func (l *DashboardNodeList) Names() []string

type DashboardTable

type DashboardTable struct {
	ResourceWithMetadataImpl
	QueryProviderImpl

	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	Width      *int                             `cty:"width" hcl:"width" column:"width,string"  json:"width,omitempty"`
	Type       *string                          `cty:"type" hcl:"type" column:"type,string"  json:"type,omitempty"`
	ColumnList DashboardTableColumnList         `cty:"column_list" hcl:"column,block" column:"columns,jsonb" json:"columns,omitempty"`
	Columns    map[string]*DashboardTableColumn `cty:"columns" snapshot:"columns"`
	Display    *string                          `cty:"display" hcl:"display" json:"display,omitempty" snapshot:"display"`
	Base       *DashboardTable                  `hcl:"base" json:"-"`
}

DashboardTable is a struct representing a leaf dashboard node

func NewQueryDashboardTable

func NewQueryDashboardTable(qp QueryProvider) (*DashboardTable, error)

NewQueryDashboardTable creates a Table to wrap a query. This is used in order to execute queries as dashboards

func (*DashboardTable) CtyValue

func (t *DashboardTable) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*DashboardTable) Diff

func (*DashboardTable) Equals

func (t *DashboardTable) Equals(other *DashboardTable) bool

func (*DashboardTable) GetDisplay

func (t *DashboardTable) GetDisplay() string

GetDisplay implements DashboardLeafNode

func (*DashboardTable) GetDocumentation

func (*DashboardTable) GetDocumentation() string

GetDocumentation implements DashboardLeafNode, ModTreeItem

func (*DashboardTable) GetShowData

func (t *DashboardTable) GetShowData() *printers.RowData

GetShowData implements printers.Showable

func (*DashboardTable) GetType

func (t *DashboardTable) GetType() string

GetType implements DashboardLeafNode

func (*DashboardTable) GetWidth

func (t *DashboardTable) GetWidth() int

GetWidth implements DashboardLeafNode

func (*DashboardTable) OnDecoded

func (t *DashboardTable) OnDecoded(block *hcl.Block, resourceMapProvider ResourceMapsProvider) hcl.Diagnostics

OnDecoded implements HclResource

type DashboardTableColumn

type DashboardTableColumn struct {
	Name    string  `hcl:"name,label" json:"name" snapshot:"name"`
	Display *string `cty:"display" hcl:"display" json:"display,omitempty" snapshot:"display"`
	Wrap    *string `cty:"wrap" hcl:"wrap" json:"wrap,omitempty" snapshot:"wrap"`
	HREF    *string `cty:"href" hcl:"href" json:"href,omitempty" snapshot:"href"`
}

func (DashboardTableColumn) Equals

type DashboardTableColumnList

type DashboardTableColumnList []*DashboardTableColumn

func (*DashboardTableColumnList) Merge

type DashboardText

type DashboardText struct {
	ResourceWithMetadataImpl
	ModTreeItemImpl

	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	Value   *string `cty:"value" hcl:"value" column:"value,string" snapshot:"value"  json:"value,omitempty"`
	Width   *int    `cty:"width" hcl:"width" column:"width,string"  json:"width,omitempty"`
	Type    *string `cty:"type" hcl:"type" column:"type,string"  json:"type,omitempty"`
	Display *string `cty:"display" hcl:"display" json:"display,omitempty"`

	Base *DashboardText `hcl:"base" json:"-"`
	Mod  *Mod           `cty:"mod" json:"-"`
}

DashboardText is a struct representing a leaf dashboard node

func (*DashboardText) CtyValue

func (t *DashboardText) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*DashboardText) Diff

func (*DashboardText) Equals

func (t *DashboardText) Equals(other *DashboardText) bool

func (*DashboardText) GetDisplay

func (t *DashboardText) GetDisplay() string

GetDisplay implements DashboardLeafNode

func (*DashboardText) GetDocumentation

func (*DashboardText) GetDocumentation() string

GetDocumentation implements DashboardLeafNode, ModTreeItem

func (*DashboardText) GetShowData

func (t *DashboardText) GetShowData() *printers.RowData

GetShowData implements printers.Showable

func (*DashboardText) GetType

func (t *DashboardText) GetType() string

GetType implements DashboardLeafNode

func (*DashboardText) GetWidth

func (t *DashboardText) GetWidth() int

GetWidth implements DashboardLeafNode

func (*DashboardText) OnDecoded

func (t *DashboardText) OnDecoded(*hcl.Block, ResourceMapsProvider) hcl.Diagnostics

OnDecoded implements HclResource

type DashboardTreeItemDiffs

type DashboardTreeItemDiffs struct {
	Name              string
	Item              ModTreeItem
	ChangedProperties []string
	AddedItems        []string
	RemovedItems      []string
}

DashboardTreeItemDiffs is a struct representing the differences between 2 DashboardTreeItems (of same type)

func (*DashboardTreeItemDiffs) AddAddedItem

func (d *DashboardTreeItemDiffs) AddAddedItem(name string)

func (*DashboardTreeItemDiffs) AddPropertyDiff

func (d *DashboardTreeItemDiffs) AddPropertyDiff(propertyName string)

func (*DashboardTreeItemDiffs) AddRemovedItem

func (d *DashboardTreeItemDiffs) AddRemovedItem(name string)

func (*DashboardTreeItemDiffs) HasChanges

func (d *DashboardTreeItemDiffs) HasChanges() bool

type DashboardWith

type DashboardWith struct {
	ResourceWithMetadataImpl
	QueryProviderImpl

	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`
}

DashboardWith is a struct representing a leaf dashboard node

func (*DashboardWith) CtyValue

func (w *DashboardWith) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*DashboardWith) Diff

func (*DashboardWith) Equals

func (w *DashboardWith) Equals(other *DashboardWith) bool

func (*DashboardWith) GetDisplay

func (*DashboardWith) GetDisplay() string

GetDisplay implements DashboardLeafNode

func (*DashboardWith) GetType

func (*DashboardWith) GetType() string

GetType implements DashboardLeafNode

func (*DashboardWith) GetWidth

func (*DashboardWith) GetWidth() int

GetWidth implements DashboardLeafNode

func (*DashboardWith) OnDecoded

func (w *DashboardWith) OnDecoded(_ *hcl.Block, _ ResourceMapsProvider) hcl.Diagnostics

OnDecoded implements HclResource

type DatabaseItem

type DatabaseItem interface {
	GetDatabase() *string
	GetSearchPath() []string
	GetSearchPathPrefix() []string
}

type DependencyVersion

type DependencyVersion struct {
	Version  *semver.Version `json:"version,omitempty"`
	Branch   string          `json:"branch,omitempty"`
	FilePath string          `json:"path,omitempty"`
	Tag      string          `json:"tag,omitempty"`
}

DependencyVersion is a struct that encapsulates the version of a mod dependency the version may be specified as a filepath, a branch or a semver version

func ParseModDependencyPath

func ParseModDependencyPath(fullName string) (string, *DependencyVersion, error)

ParseModDependencyPath converts a mod depdency path of form github.com/turbot/steampipe-mod-m2@v1.0.0 into the dependency name (github.com/turbot/steampipe-mod-m2) and version

func (DependencyVersion) Equal

func (v DependencyVersion) Equal(other *DependencyVersion) bool

func (DependencyVersion) GreaterThan

func (v DependencyVersion) GreaterThan(other *DependencyVersion) bool

func (DependencyVersion) LessThan

func (v DependencyVersion) LessThan(other *DependencyVersion) bool

type DependencyVersionList

type DependencyVersionList []*DependencyVersion

make a collection type for this

func (DependencyVersionList) Len

func (c DependencyVersionList) Len() int

Len returns the length of a collection. The number of Version instances on the slice.

func (DependencyVersionList) Less

func (c DependencyVersionList) Less(i, j int) bool

Less is needed for the sort interface to compare two Version objects on the slice. If checks if one is less than the other.

func (DependencyVersionList) Swap

func (c DependencyVersionList) Swap(i, j int)

Swap is needed for the sort interface to replace the Version objects at two different positions in the slice.

type EmailIntegration

type EmailIntegration struct {
	HclResourceImpl          `json:"-"`
	ResourceWithMetadataImpl `json:"-"`
	IntegrationImpl          `json:"-"`

	Type string `json:"type" cty:"type" hcl:"type,label"`

	// email
	SmtpHost     *string `json:"smtp_host,omitempty" cty:"smtp_host" hcl:"smtp_host"`
	SmtpTls      *string `json:"smtp_tls,omitempty" cty:"smtp_tls" hcl:"smtp_tls,optional"`
	SmtpPort     *int    `json:"smtp_port,omitempty" cty:"smtp_port" hcl:"smtp_port,optional"`
	SmtpsPort    *int    `json:"smtps_port,omitempty" cty:"smtps_port" hcl:"smtps_port,optional"`
	SmtpUsername *string `json:"smtp_username,omitempty" cty:"smtp_username" hcl:"smtp_username,optional"`
	SmtpPassword *string `json:"smtp_password,omitempty" cty:"smtp_password" hcl:"smtp_password,optional"`

	From    *string  `json:"from,omitempty" cty:"from" hcl:"from"`
	To      []string `json:"to,omitempty" cty:"to" hcl:"to,optional"`
	Cc      []string `json:"cc,omitempty" cty:"cc" hcl:"cc,optional"`
	Bcc     []string `json:"bcc,omitempty" cty:"bcc" hcl:"bcc,optional"`
	Subject *string  `json:"subject,omitempty" cty:"subject" hcl:"subject,optional"`
}

func EmailIntegrationFromCtyValue

func EmailIntegrationFromCtyValue(val cty.Value) (*EmailIntegration, error)

func (*EmailIntegration) CtyValue

func (i *EmailIntegration) CtyValue() (cty.Value, error)

func (*EmailIntegration) Equals

func (i *EmailIntegration) Equals(other Integration) bool

func (*EmailIntegration) GetIntegrationType

func (i *EmailIntegration) GetIntegrationType() string

func (*EmailIntegration) MapInterface

func (i *EmailIntegration) MapInterface() (map[string]interface{}, error)

func (*EmailIntegration) SetAttributes

func (i *EmailIntegration) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*EmailIntegration) Validate

func (i *EmailIntegration) Validate() hcl.Diagnostics

type ErrorConfig

type ErrorConfig struct {
	// circular link to its "parent"
	PipelineStepBase *PipelineStepBase `json:"-"`

	UnresolvedAttributes map[string]hcl.Expression `json:"-"`
	If                   *bool                     `json:"if"`
	Ignore               *bool                     `json:"ignore,omitempty" hcl:"ignore,optional" cty:"ignore"`
}

func NewErrorConfig

func NewErrorConfig(p *PipelineStepBase) *ErrorConfig

func (*ErrorConfig) AddUnresolvedAttribute

func (e *ErrorConfig) AddUnresolvedAttribute(name string, expr hcl.Expression)

func (*ErrorConfig) AppendCredentialDependsOn

func (e *ErrorConfig) AppendCredentialDependsOn(...string)

func (*ErrorConfig) AppendDependsOn

func (e *ErrorConfig) AppendDependsOn(dependsOn ...string)

func (*ErrorConfig) Equals

func (e *ErrorConfig) Equals(other *ErrorConfig) bool

func (*ErrorConfig) SetAttributes

func (e *ErrorConfig) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*ErrorConfig) Validate

func (e *ErrorConfig) Validate() bool

type FlowpipeRequire

type FlowpipeRequire struct {
	MinVersionString string `hcl:"min_version,optional"`
	Constraint       *semver.Constraints
	DeclRange        hcl.Range
}

type FlowpipeWorkspaceProfile

type FlowpipeWorkspaceProfile struct {
	ProfileName string                    `hcl:"name,label" cty:"name"`
	Base        *FlowpipeWorkspaceProfile `hcl:"base"`

	Host                    *string `hcl:"host" cty:"host"`
	Input                   *bool   `hcl:"input" cty:"input"`
	Insecure                *bool   `hcl:"insecure" cty:"insecure"`
	Listen                  *string `hcl:"listen" cty:"port"`
	LogLevel                *string `hcl:"log_level" cty:"log_level"`
	MemoryMaxMb             *int    `hcl:"memory_max_mb" cty:"memory_max_mb"`
	Output                  *string `hcl:"output" cty:"output"`
	Port                    *int    `hcl:"port" cty:"port"`
	Progress                *bool   `hcl:"progress" cty:"progress"`
	Telemetry               *string `hcl:"telemetry" cty:"telemetry"`
	UpdateCheck             *string `hcl:"update_check" cty:"update_check"`
	Watch                   *bool   `hcl:"watch" cty:"watch"`
	MaxConcurrencyHttp      *int    `hcl:"max_concurrency_http" cty:"max_concurrency_http"`
	MaxConcurrencyContainer *int    `hcl:"max_concurrency_container" cty:"max_concurrency_container"`
	MaxConcurrencyFunction  *int    `hcl:"max_concurrency_function" cty:"max_concurrency_function"`
	MaxConcurrencyQuery     *int    `hcl:"max_concurrency_query" cty:"max_concurrency_query"`
	ProcessRetention        *int    `hcl:"process_retention" cty:"process_retention"`
	BaseUrl                 *string `hcl:"base_url" cty:"base_url"`

	DeclRange hcl.Range
}

func (*FlowpipeWorkspaceProfile) ConfigMap

func (p *FlowpipeWorkspaceProfile) ConfigMap(cmd *cobra.Command) map[string]interface{}

ConfigMap creates a config map containing all options to pass to viper

func (*FlowpipeWorkspaceProfile) CtyValue

func (p *FlowpipeWorkspaceProfile) CtyValue() (cty.Value, error)

func (*FlowpipeWorkspaceProfile) GetDeclRange

func (p *FlowpipeWorkspaceProfile) GetDeclRange() *hcl.Range

func (*FlowpipeWorkspaceProfile) GetInstallDir

func (p *FlowpipeWorkspaceProfile) GetInstallDir() *string

TODO this is (currently) required by interface

func (*FlowpipeWorkspaceProfile) GetOptionsForBlock

func (p *FlowpipeWorkspaceProfile) GetOptionsForBlock(block *hcl.Block) (options.Options, hcl.Diagnostics)

func (*FlowpipeWorkspaceProfile) IsNil

func (p *FlowpipeWorkspaceProfile) IsNil() bool

func (*FlowpipeWorkspaceProfile) Name

func (p *FlowpipeWorkspaceProfile) Name() string

func (*FlowpipeWorkspaceProfile) OnDecoded

func (p *FlowpipeWorkspaceProfile) OnDecoded() hcl.Diagnostics

func (*FlowpipeWorkspaceProfile) SetOptions

func (p *FlowpipeWorkspaceProfile) SetOptions(opts options.Options, block *hcl.Block) hcl.Diagnostics

SetOptions sets the options on the connection verify the options object is a valid options type (only options.Connection currently supported)

func (*FlowpipeWorkspaceProfile) ShortName

func (p *FlowpipeWorkspaceProfile) ShortName() string

type HclResource

type HclResource interface {
	printers.Showable
	printers.Listable
	Name() string
	GetTitle() string
	GetUnqualifiedName() string
	GetShortName() string
	OnDecoded(*hcl.Block, ResourceMapsProvider) hcl.Diagnostics
	GetDeclRange() *hcl.Range
	BlockType() string
	GetDescription() string
	GetDocumentation() string
	GetTags() map[string]string
	SetTopLevel(bool)
	IsTopLevel() bool
	GetBase() HclResource
	GetHclResourceImpl() *HclResourceImpl
}

HclResource must be implemented by resources defined in HCL

func NewBenchmark

func NewBenchmark(block *hcl.Block, mod *Mod, shortName string) HclResource

func NewControl

func NewControl(block *hcl.Block, mod *Mod, shortName string) HclResource

func NewDashboard

func NewDashboard(block *hcl.Block, mod *Mod, shortName string) HclResource

func NewDashboardCard

func NewDashboardCard(block *hcl.Block, mod *Mod, shortName string) HclResource

func NewDashboardCategory

func NewDashboardCategory(block *hcl.Block, mod *Mod, shortName string) HclResource

func NewDashboardChart

func NewDashboardChart(block *hcl.Block, mod *Mod, shortName string) HclResource

func NewDashboardContainer

func NewDashboardContainer(block *hcl.Block, mod *Mod, shortName string) HclResource

func NewDashboardEdge

func NewDashboardEdge(block *hcl.Block, mod *Mod, shortName string) HclResource

func NewDashboardFlow

func NewDashboardFlow(block *hcl.Block, mod *Mod, shortName string) HclResource

func NewDashboardGraph

func NewDashboardGraph(block *hcl.Block, mod *Mod, shortName string) HclResource

func NewDashboardHierarchy

func NewDashboardHierarchy(block *hcl.Block, mod *Mod, shortName string) HclResource

func NewDashboardImage

func NewDashboardImage(block *hcl.Block, mod *Mod, shortName string) HclResource

func NewDashboardInput

func NewDashboardInput(block *hcl.Block, mod *Mod, shortName string) HclResource

func NewDashboardNode

func NewDashboardNode(block *hcl.Block, mod *Mod, shortName string) HclResource

func NewDashboardTable

func NewDashboardTable(block *hcl.Block, mod *Mod, shortName string) HclResource

func NewDashboardText

func NewDashboardText(block *hcl.Block, mod *Mod, shortName string) HclResource

func NewDashboardWith

func NewDashboardWith(block *hcl.Block, mod *Mod, shortName string) HclResource

func NewQuery

func NewQuery(block *hcl.Block, mod *Mod, shortName string) HclResource

func NewRootBenchmarkWithChildren

func NewRootBenchmarkWithChildren(mod *Mod, children []ModTreeItem) HclResource

type HclResourceImpl

type HclResourceImpl struct {
	// required to allow partial decoding
	HclResourceRemain hcl.Body `hcl:",remain" json:"-"`

	FullName        string            `cty:"name" column:"qualified_name,text" json:"qualified_name,omitempty"`
	Title           *string           `cty:"title" hcl:"title" column:"title,string"  json:"title,omitempty"`
	ShortName       string            `cty:"short_name" hcl:"name,label" json:"-"`
	UnqualifiedName string            `cty:"unqualified_name" json:"-"`
	Description     *string           `column:"description,string" cty:"description" hcl:"description" json:"description,omitempty"`
	Documentation   *string           `column:"documentation,string" cty:"documentation" hcl:"documentation" json:"documentation,omitempty"`
	DeclRange       hcl.Range         `json:"-"` // No corresponding cty tag, so using "-"
	Tags            map[string]string `column:"tags,jsonb" cty:"tags" hcl:"tags,optional" json:"tags,omitempty"`
	MaxConcurrency  *int              `cty:"max_concurrency" hcl:"max_concurrency,optional" json:"max_concurrency,omitempty"`
	// contains filtered or unexported fields
}

func NewHclResourceImpl

func NewHclResourceImpl(block *hcl.Block, mod *Mod, shortName string) HclResourceImpl

func NewHclResourceImplNoMod

func NewHclResourceImplNoMod(block *hcl.Block, resourceType, shortName string) HclResourceImpl

func (*HclResourceImpl) BlockType

func (b *HclResourceImpl) BlockType() string

BlockType implements HclResource

func (*HclResourceImpl) CtyValue

func (b *HclResourceImpl) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*HclResourceImpl) Equals

func (b *HclResourceImpl) Equals(other *HclResourceImpl) bool

func (*HclResourceImpl) GetBase

func (b *HclResourceImpl) GetBase() HclResource

GetBase implements HclResource

func (*HclResourceImpl) GetDeclRange

func (b *HclResourceImpl) GetDeclRange() *hcl.Range

GetDeclRange implements HclResource

func (*HclResourceImpl) GetDescription

func (b *HclResourceImpl) GetDescription() string

GetDescription implements HclResource

func (*HclResourceImpl) GetDocumentation

func (b *HclResourceImpl) GetDocumentation() string

GetDocumentation implements HclResource

func (*HclResourceImpl) GetHclResourceImpl

func (b *HclResourceImpl) GetHclResourceImpl() *HclResourceImpl

GetHclResourceImpl implements HclResource

func (*HclResourceImpl) GetListData

func (b *HclResourceImpl) GetListData() *printers.RowData

GetListData implements printers.Showable

func (*HclResourceImpl) GetShortName

func (b *HclResourceImpl) GetShortName() string

GetShortName implements HclResource

func (*HclResourceImpl) GetShowData

func (b *HclResourceImpl) GetShowData() *printers.RowData

GetShowData implements printers.Showable

func (*HclResourceImpl) GetTags

func (b *HclResourceImpl) GetTags() map[string]string

GetTags implements HclResource

func (*HclResourceImpl) GetTitle

func (b *HclResourceImpl) GetTitle() string

GetTitle implements HclResource

func (*HclResourceImpl) GetUnqualifiedName

func (b *HclResourceImpl) GetUnqualifiedName() string

GetUnqualifiedName implements DashboardLeafNode, ModTreeItem

func (*HclResourceImpl) IsTopLevel

func (b *HclResourceImpl) IsTopLevel() bool

IsTopLevel implements HclResource

func (*HclResourceImpl) Name

func (b *HclResourceImpl) Name() string

Name implements HclResource return name in format: '<blocktype>.<shortName>'

func (*HclResourceImpl) OnDecoded

func (b *HclResourceImpl) OnDecoded(block *hcl.Block, _ ResourceMapsProvider) hcl.Diagnostics

OnDecoded implements HclResource

func (*HclResourceImpl) SetTopLevel

func (b *HclResourceImpl) SetTopLevel(isTopLevel bool)

SetTopLevel implements HclResource

type HttpIntegration

type HttpIntegration struct {
	HclResourceImpl          `json:"-"`
	ResourceWithMetadataImpl `json:"-"`
	IntegrationImpl          `json:"-"`

	Type string `json:"type" cty:"type" hcl:"type,label"`
}

func HttpIntegrationFromCtyValue

func HttpIntegrationFromCtyValue(val cty.Value) (*HttpIntegration, error)

func (*HttpIntegration) CtyValue

func (i *HttpIntegration) CtyValue() (cty.Value, error)

func (*HttpIntegration) Equals

func (i *HttpIntegration) Equals(other Integration) bool

func (*HttpIntegration) GetIntegrationType

func (i *HttpIntegration) GetIntegrationType() string

func (*HttpIntegration) MapInterface

func (i *HttpIntegration) MapInterface() (map[string]interface{}, error)

func (*HttpIntegration) SetAttributes

func (i *HttpIntegration) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*HttpIntegration) Validate

func (i *HttpIntegration) Validate() hcl.Diagnostics

type Input

type Input map[string]interface{}

Input to the step or pipeline execution

func (*Input) AsCtyMap

func (i *Input) AsCtyMap() (map[string]cty.Value, error)

type Integration

type Integration interface {
	HclResource
	ResourceWithMetadata

	CtyValue() (cty.Value, error)
	GetIntegrationImpl() *IntegrationImpl
	GetIntegrationType() string
	MapInterface() (map[string]interface{}, error)
	SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics
	SetFileReference(fileName string, startLineNumber int, endLineNumber int)
	SetUrl(string)
	Validate() hcl.Diagnostics

	Equals(Integration) bool
}

func NewIntegrationFromBlock

func NewIntegrationFromBlock(block *hcl.Block) Integration

type IntegrationImpl

type IntegrationImpl struct {
	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	// Slack and Http has URL, Email integration does not it will be null
	Url *string `json:"url,omitempty" cty:"url" hcl:"url,optional"`

	FileName        string
	StartLineNumber int
	EndLineNumber   int
}

func (*IntegrationImpl) GetIntegrationImpl

func (i *IntegrationImpl) GetIntegrationImpl() *IntegrationImpl

func (*IntegrationImpl) SetFileReference

func (i *IntegrationImpl) SetFileReference(fileName string, startLineNumber int, endLineNumber int)

func (*IntegrationImpl) SetUrl

func (i *IntegrationImpl) SetUrl(url string)

type Local

type Local struct {
	ModTreeItemImpl

	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	Value cty.Value
	// contains filtered or unexported fields
}

Local is a struct representing a Local resource

func NewLocal

func NewLocal(name string, val cty.Value, declRange hcl.Range, mod *Mod) *Local

func (*Local) CtyValue

func (l *Local) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*Local) Diff

func (l *Local) Diff(other *Local) *DashboardTreeItemDiffs

type LoopContainerStep

type LoopContainerStep struct {
	LoopStep

	Image             *string            `json:"image,omitempty" hcl:"image,optional" cty:"image"`
	Source            *string            `json:"source,omitempty" hcl:"source,optional" cty:"source"`
	Cmd               *[]string          `json:"cmd,omitempty" hcl:"cmd,optional" cty:"cmd"`
	Env               *map[string]string `json:"env,omitempty" hcl:"env,optional" cty:"env"`
	Entrypoint        *[]string          `json:"entrypoint,omitempty" hcl:"entrypoint,optional" cty:"entrypoint"`
	CpuShares         *int64             `json:"cpu_shares,omitempty" hcl:"cpu_shares,optional" cty:"cpu_shares"`
	Memory            *int64             `json:"memory,omitempty" hcl:"memory,optional" cty:"memory"`
	MemoryReservation *int64             `json:"memory_reservation,omitempty" hcl:"memory_reservation,optional" cty:"memory_reservation"`
	MemorySwap        *int64             `json:"memory_swap,omitempty" hcl:"memory_swap,optional" cty:"memory_swap"`
	MemorySwappiness  *int64             `json:"memory_swappiness,omitempty" hcl:"memory_swappiness,optional" cty:"memory_swappiness"`
	ReadOnly          *bool              `json:"read_only,omitempty" hcl:"read_only,optional" cty:"read_only"`
	User              *string            `json:"user,omitempty" hcl:"user,optional" cty:"user"`
	Workdir           *string            `json:"workdir,omitempty" hcl:"workdir,optional" cty:"workdir"`
}

func (*LoopContainerStep) Equals

func (l *LoopContainerStep) Equals(other LoopDefn) bool

func (*LoopContainerStep) GetType

func (*LoopContainerStep) GetType() string

func (*LoopContainerStep) SetAttributes

func (l *LoopContainerStep) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*LoopContainerStep) UpdateInput

func (l *LoopContainerStep) UpdateInput(input Input, evalContext *hcl.EvalContext) (Input, error)

type LoopDefn

type LoopDefn interface {
	GetType() string
	UpdateInput(input Input, evalContext *hcl.EvalContext) (Input, error)
	SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics
	Equals(LoopDefn) bool
	AppendDependsOn(...string)
	AppendCredentialDependsOn(...string)
	AddUnresolvedAttribute(string, hcl.Expression)
	GetUnresolvedAttributes() map[string]hcl.Expression
	ResolveUntil(evalContext *hcl.EvalContext) (bool, hcl.Diagnostics)
}

func GetLoopDefn

func GetLoopDefn(stepType string, p *PipelineStepBase, hclRange *hcl.Range) LoopDefn

type LoopEmailStep

type LoopEmailStep struct {
	LoopStep

	To               *[]string `json:"to,omitempty" hcl:"to,optional" cty:"to"`
	From             *string   `json:"from,omitempty" hcl:"from,optional" cty:"from"`
	SenderCredential *string   `json:"sender_credential,omitempty" hcl:"sender_credential,optional" cty:"sender_credential"`
	Host             *string   `json:"host,omitempty" hcl:"host,optional" cty:"host"`
	Port             *int64    `json:"port,omitempty" hcl:"port,optional" cty:"port"`
	SenderName       *string   `json:"sender_name,omitempty" hcl:"sender_name,optional" cty:"sender_name"`
	Cc               *[]string `json:"cc,omitempty" hcl:"cc,optional" cty:"cc"`
	Bcc              *[]string `json:"bcc,omitempty" hcl:"bcc,optional" cty:"bcc"`
	Body             *string   `json:"body,omitempty" hcl:"body,optional" cty:"body"`
	ContentType      *string   `json:"content_type,omitempty" hcl:"content_type,optional" cty:"content_type"`
	Subject          *string   `json:"subject,omitempty" hcl:"subject,optional" cty:"subject"`
}

func (*LoopEmailStep) Equals

func (l *LoopEmailStep) Equals(other LoopDefn) bool

func (*LoopEmailStep) GetType

func (*LoopEmailStep) GetType() string

func (*LoopEmailStep) SetAttributes

func (l *LoopEmailStep) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*LoopEmailStep) UpdateInput

func (l *LoopEmailStep) UpdateInput(input Input, evalContext *hcl.EvalContext) (Input, error)

type LoopFunctionStep

type LoopFunctionStep struct {
	LoopStep

	Runtime *string                 `json:"runtime,omitempty"`
	Source  *string                 `json:"source,omitempty"`
	Handler *string                 `json:"handler,omitempty"`
	Event   *map[string]interface{} `json:"event,omitempty"`
	Env     *map[string]string      `json:"env,omitempty"`
}

func (*LoopFunctionStep) Equals

func (l *LoopFunctionStep) Equals(other LoopDefn) bool

func (*LoopFunctionStep) GetType

func (*LoopFunctionStep) GetType() string

func (*LoopFunctionStep) SetAttributes

func (l *LoopFunctionStep) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*LoopFunctionStep) UpdateInput

func (l *LoopFunctionStep) UpdateInput(input Input, evalContext *hcl.EvalContext) (Input, error)

type LoopHttpStep

type LoopHttpStep struct {
	LoopStep

	URL            *string                 `json:"url,omitempty" hcl:"url,optional" cty:"url"`
	Method         *string                 `json:"method,omitempty" hcl:"method,optional" cty:"method"`
	RequestBody    *string                 `json:"request_body,omitempty" hcl:"request_body,optional" cty:"request_body"`
	RequestHeaders *map[string]interface{} `json:"request_headers,omitempty" hcl:"request_headers,optional" cty:"request_headers"`
	CaCertPem      *string                 `json:"ca_cert_pem,omitempty" hcl:"ca_cert_pem,optional" cty:"ca_cert_pem"`
	Insecure       *bool                   `json:"insecure,omitempty" hcl:"insecure,optional" cty:"insecure"`
}

func (*LoopHttpStep) Equals

func (l *LoopHttpStep) Equals(other LoopDefn) bool

func (*LoopHttpStep) GetType

func (*LoopHttpStep) GetType() string

func (*LoopHttpStep) SetAttributes

func (l *LoopHttpStep) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*LoopHttpStep) UpdateInput

func (l *LoopHttpStep) UpdateInput(input Input, evalContext *hcl.EvalContext) (Input, error)

type LoopInputStep

type LoopInputStep struct {
	LoopStep

	Notifier *NotifierImpl `json:"notifier" cty:"-" hcl:"-"`

	Prompt  *string   `json:"prompt" cty:"prompt" hcl:"prompt,optional"`
	Cc      *[]string `json:"cc,omitempty" cty:"cc" hcl:"cc,optional"`
	Bcc     *[]string `json:"bcc,omitempty" cty:"bcc" hcl:"bcc,optional"`
	Channel *string   `json:"channel,omitempty" cty:"channel" hcl:"channel,optional"`
	Subject *string   `json:"subject,omitempty" cty:"subject" hcl:"subject,optional"`
	To      *[]string `json:"to,omitempty" cty:"to" hcl:"to,optional"`
}

func (*LoopInputStep) Equals

func (l *LoopInputStep) Equals(other LoopDefn) bool

func (*LoopInputStep) GetType

func (s *LoopInputStep) GetType() string

func (*LoopInputStep) SetAttributes

func (l *LoopInputStep) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*LoopInputStep) UpdateInput

func (l *LoopInputStep) UpdateInput(input Input, evalContext *hcl.EvalContext) (Input, error)

type LoopMessageStep

type LoopMessageStep struct {
	LoopStep

	Notifier *NotifierImpl `json:"notifier" cty:"-" hcl:"-"`

	Text    *string   `json:"text" cty:"prompt" hcl:"prompt,optional"`
	Cc      *[]string `json:"cc,omitempty" cty:"cc" hcl:"cc,optional"`
	Bcc     *[]string `json:"bcc,omitempty" cty:"bcc" hcl:"bcc,optional"`
	Channel *string   `json:"channel,omitempty" cty:"channel" hcl:"channel,optional"`
	Subject *string   `json:"subject,omitempty" cty:"subject" hcl:"subject,optional"`
	To      *[]string `json:"to,omitempty" cty:"to" hcl:"to,optional"`
}

func (*LoopMessageStep) Equals

func (l *LoopMessageStep) Equals(other LoopDefn) bool

func (*LoopMessageStep) GetType

func (s *LoopMessageStep) GetType() string

func (*LoopMessageStep) SetAttributes

func (l *LoopMessageStep) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*LoopMessageStep) UpdateInput

func (l *LoopMessageStep) UpdateInput(input Input, evalContext *hcl.EvalContext) (Input, error)

type LoopPipelineStep

type LoopPipelineStep struct {
	LoopStep

	Args interface{} `json:"args,omitempty" hcl:"args,optional" cty:"args"`
}

func (*LoopPipelineStep) Equals

func (l *LoopPipelineStep) Equals(other LoopDefn) bool

func (*LoopPipelineStep) GetType

func (*LoopPipelineStep) GetType() string

func (*LoopPipelineStep) SetAttributes

func (l *LoopPipelineStep) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*LoopPipelineStep) UpdateInput

func (l *LoopPipelineStep) UpdateInput(input Input, evalContext *hcl.EvalContext) (Input, error)

type LoopQueryStep

type LoopQueryStep struct {
	LoopStep

	Database *string        `json:"database,omitempty" hcl:"database,optional" cty:"database"`
	Sql      *string        `json:"sql,omitempty" hcl:"sql,optional" cty:"sql"`
	Args     *[]interface{} `json:"args,omitempty" hcl:"args,optional" cty:"args"`
}

func (*LoopQueryStep) Equals

func (l *LoopQueryStep) Equals(other LoopDefn) bool

func (*LoopQueryStep) GetType

func (*LoopQueryStep) GetType() string

func (*LoopQueryStep) SetAttributes

func (l *LoopQueryStep) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*LoopQueryStep) UpdateInput

func (l *LoopQueryStep) UpdateInput(input Input, evalContext *hcl.EvalContext) (Input, error)

type LoopSleepStep

type LoopSleepStep struct {
	LoopStep

	UnresolvedAttributes hcl.Attributes `json:"-"`
	Duration             *string        `json:"duration,omitempty"`
}

func (*LoopSleepStep) Equals

func (l *LoopSleepStep) Equals(other LoopDefn) bool

func (*LoopSleepStep) GetType

func (*LoopSleepStep) GetType() string

func (*LoopSleepStep) SetAttributes

func (s *LoopSleepStep) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*LoopSleepStep) UpdateInput

func (l *LoopSleepStep) UpdateInput(input Input, evalContext *hcl.EvalContext) (Input, error)

type LoopStep

type LoopStep struct {
	// circular link to its "parent"
	PipelineStepBase     *PipelineStepBase         `json:"-"`
	Range                *hcl.Range                `json:"-"`
	UnresolvedAttributes map[string]hcl.Expression `json:"-"`
	Until                *bool
}

func (*LoopStep) AddUnresolvedAttribute

func (l *LoopStep) AddUnresolvedAttribute(name string, expr hcl.Expression)

func (*LoopStep) AppendCredentialDependsOn

func (*LoopStep) AppendCredentialDependsOn(...string)

func (*LoopStep) AppendDependsOn

func (l *LoopStep) AppendDependsOn(dependsOn ...string)

func (LoopStep) Equals

func (l LoopStep) Equals(other LoopStep) bool

func (*LoopStep) GetUnresolvedAttributes

func (l *LoopStep) GetUnresolvedAttributes() map[string]hcl.Expression

func (*LoopStep) ResolveUntil

func (l *LoopStep) ResolveUntil(evalContext *hcl.EvalContext) (bool, hcl.Diagnostics)

func (*LoopStep) SetAttributes

func (l *LoopStep) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

type LoopTransformStep

type LoopTransformStep struct {
	LoopStep

	Value interface{} `json:"value,omitempty" hcl:"value,optional" cty:"value"`
}

func (*LoopTransformStep) Equals

func (l *LoopTransformStep) Equals(other LoopDefn) bool

func (*LoopTransformStep) GetType

func (*LoopTransformStep) GetType() string

func (*LoopTransformStep) SetAttributes

func (s *LoopTransformStep) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*LoopTransformStep) UpdateInput

func (l *LoopTransformStep) UpdateInput(input Input, evalContext *hcl.EvalContext) (Input, error)

type MissingVariableError

type MissingVariableError struct {
	MissingVariables []*Variable
}

func (MissingVariableError) Error

func (m MissingVariableError) Error() string

type Mod

type Mod struct {
	ResourceWithMetadataImpl
	ModTreeItemImpl

	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	// attributes
	Categories []string `cty:"categories" hcl:"categories,optional" json:"categories,omitempty"`
	Color      *string  `cty:"color" hcl:"color" json:"color,omitempty"`
	Icon       *string  `cty:"icon" hcl:"icon" json:"icon,omitempty"`

	// blocks
	Require       *Require   `hcl:"require,block"  json:"-"`
	LegacyRequire *Require   `hcl:"requires,block"  json:"-"`
	OpenGraph     *OpenGraph `hcl:"opengraph,block" json:"open_graph,omitempty"`

	// the mod version
	Version *DependencyVersion `json:"-"`
	// DependencyPath is the fully qualified mod name including version,
	// which will by the map key in the workspace lock file
	// NOTE: this is the relative path to the mod location from the dependency install dir (.steampipe/mods)
	// e.g. github.com/turbot/steampipe-mod-azure-thrifty@v1.0.0
	// It is populated for dependency mods as part of the mod loading process
	// NOTE: if this mod dependency is a local file dependency, the dependency path will be the file path
	DependencyPath *string `json:"dependency_path,omitempty"`
	// DependencyName return the name of the mod as a dependency, i.e. the mod dependency path, _without_ the version
	// e.g. github.com/turbot/steampipe-mod-azure-thrifty
	DependencyName string `json:"-"`

	// ModPath is the installation location of the mod
	ModPath string `json:"-"`

	// convenient aggregation of all resources
	ResourceMaps *ResourceMaps `json:"-"`
	// contains filtered or unexported fields
}

Mod is a struct representing a Mod resource

func CreateDefaultMod

func CreateDefaultMod(modPath string) *Mod

CreateDefaultMod creates a default mod created for a workspace with no mod definition

func NewMod

func NewMod(shortName, modPath string, defRange hcl.Range) *Mod

func (*Mod) AddModDependencies

func (m *Mod) AddModDependencies(modVersions map[string]*ModVersionConstraint)

func (*Mod) AddReference

func (m *Mod) AddReference(ref *ResourceReference)

AddReference implements ResourceWithMetadata (overridden from ResourceWithMetadataImpl)

func (*Mod) AddResource

func (m *Mod) AddResource(item HclResource) hcl.Diagnostics

func (*Mod) BuildResourceTree

func (m *Mod) BuildResourceTree(loadedDependencyMods ModMap) (err error)

BuildResourceTree builds the control tree structure by setting the parent property for each control and benchmark NOTE: this also builds the sorted benchmark list

func (*Mod) CtyValue

func (m *Mod) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*Mod) Equals

func (m *Mod) Equals(other *Mod) bool

func (*Mod) FilePath

func (m *Mod) FilePath() string

func (*Mod) GetInstallCacheKey

func (m *Mod) GetInstallCacheKey() string

GetInstallCacheKey returns the key used to find this mod in a workspace lock InstallCache

func (*Mod) GetModDependency

func (m *Mod) GetModDependency(modName string) *ModVersionConstraint

func (*Mod) GetPaths

func (m *Mod) GetPaths() []NodePath

GetPaths implements ModTreeItem (override base functionality)

func (*Mod) GetReferences

func (m *Mod) GetReferences() []*ResourceReference

GetReferences implements ResourceWithMetadata (overridden from ResourceWithMetadataImpl)

func (*Mod) GetResource

func (m *Mod) GetResource(parsedName *ParsedResourceName) (resource HclResource, found bool)

func (*Mod) GetResourceMaps

func (m *Mod) GetResourceMaps() *ResourceMaps

GetResourceMaps implements ResourceMapsProvider

func (*Mod) HasDependentMods

func (m *Mod) HasDependentMods() bool

func (*Mod) IsDefaultMod

func (m *Mod) IsDefaultMod() bool

IsDefaultMod returns whether this mod is a default mod created for a workspace with no mod definition

func (*Mod) OnDecoded

func (m *Mod) OnDecoded(block *hcl.Block, _ ResourceMapsProvider) hcl.Diagnostics

OnDecoded implements HclResource

func (*Mod) RemoveAllModDependencies

func (m *Mod) RemoveAllModDependencies()

func (*Mod) RemoveModDependencies

func (m *Mod) RemoveModDependencies(modVersions map[string]*ModVersionConstraint)

func (*Mod) RequireHasUnresolvedArgs

func (m *Mod) RequireHasUnresolvedArgs() bool

RequireHasUnresolvedArgs returns whether the mod has any mod requirements which have unresolved args (this could be because the arg refers to a variable, meanin gwe need an additional parse phase to resolve the arg values)

func (*Mod) Save

func (m *Mod) Save() error

func (*Mod) SetDependencyConfig

func (m *Mod) SetDependencyConfig(dependencyPath string) error

SetDependencyConfig sets DependencyPath, DependencyName and Version

func (*Mod) SetFilePath

func (m *Mod) SetFilePath(modFilePath string)

func (*Mod) SetPaths

func (m *Mod) SetPaths()

SetPaths implements ModTreeItem (override base functionality)

func (*Mod) ValidateRequirements

func (m *Mod) ValidateRequirements(pluginVersionMap *PluginVersionMap) []error

ValidateRequirements validates that the current steampipe CLI and the installed plugins is compatible with the mod

func (*Mod) WalkResources

func (m *Mod) WalkResources(resourceFunc func(item HclResource) (bool, error)) error

type ModItem

type ModItem interface {
	GetMod() *Mod
}

type ModMap

type ModMap map[string]*Mod

ModMap is a map of mod name to mod

type ModTreeItem

type ModTreeItem interface {
	HclResource
	ModItem
	DatabaseItem

	AddParent(ModTreeItem) error
	GetParents() []ModTreeItem
	GetChildren() []ModTreeItem
	// GetPaths returns an array resource paths
	GetPaths() []NodePath
	SetPaths()
	GetModTreeItemImpl() *ModTreeItemImpl
	IsDependencyResource() bool
}

ModTreeItem must be implemented by elements of the mod resource hierarchy i.e. Control, Benchmark, Dashboard

type ModTreeItemImpl

type ModTreeItemImpl struct {
	HclResourceImpl
	// required to allow partial decoding
	ModTreeItemRemain hcl.Body `hcl:",remain" json:"-"`

	Mod              *Mod     `cty:"mod" json:"-"`
	Database         *string  `cty:"database" hcl:"database" json:"database,omitempty"`
	SearchPath       []string `cty:"search_path" hcl:"search_path,optional" json:"search_path,omitempty"`
	SearchPathPrefix []string `cty:"search_path_prefix" hcl:"search_path_prefix,optional" json:"search_path_prefix,omitempty"`

	Paths []NodePath `column:"path,jsonb" json:"path,omitempty"`
	// contains filtered or unexported fields
}

func NewModTreeItemImpl

func NewModTreeItemImpl(block *hcl.Block, mod *Mod, shortName string) ModTreeItemImpl

func (*ModTreeItemImpl) AddParent

func (b *ModTreeItemImpl) AddParent(parent ModTreeItem) error

AddParent implements ModTreeItem

func (*ModTreeItemImpl) CtyValue

func (b *ModTreeItemImpl) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*ModTreeItemImpl) GetChildren

func (b *ModTreeItemImpl) GetChildren() []ModTreeItem

GetChildren implements ModTreeItem

func (*ModTreeItemImpl) GetDatabase

func (b *ModTreeItemImpl) GetDatabase() *string

GetDatabase implements DatabaseItem

func (*ModTreeItemImpl) GetListData

func (b *ModTreeItemImpl) GetListData() *printers.RowData

GetListData implements printers.Listable

func (*ModTreeItemImpl) GetMod

func (b *ModTreeItemImpl) GetMod() *Mod

GetMod implements ModItem, ModTreeItem

func (*ModTreeItemImpl) GetModTreeItemImpl

func (b *ModTreeItemImpl) GetModTreeItemImpl() *ModTreeItemImpl

GetModTreeItemImpl implements ModTreeItem

func (*ModTreeItemImpl) GetParents

func (b *ModTreeItemImpl) GetParents() []ModTreeItem

GetParents implements ModTreeItem

func (*ModTreeItemImpl) GetPaths

func (b *ModTreeItemImpl) GetPaths() []NodePath

func (*ModTreeItemImpl) GetSearchPath

func (b *ModTreeItemImpl) GetSearchPath() []string

GetSearchPath implements DatabaseItem

func (*ModTreeItemImpl) GetSearchPathPrefix

func (b *ModTreeItemImpl) GetSearchPathPrefix() []string

GetSearchPathPrefix implements DatabaseItem

func (*ModTreeItemImpl) GetShowData

func (b *ModTreeItemImpl) GetShowData() *printers.RowData

GetShowData implements printers.Showable

func (*ModTreeItemImpl) IsDependencyResource

func (b *ModTreeItemImpl) IsDependencyResource() bool

func (*ModTreeItemImpl) SetPaths

func (b *ModTreeItemImpl) SetPaths()

SetPaths implements ModTreeItem

type ModVariableMap

type ModVariableMap struct {
	// which mod have these variables been loaded for?
	Mod *Mod
	// top level variables, keyed by short name
	RootVariables map[string]*Variable
	// map of dependency variable maps, keyed by dependency NAME
	DependencyVariables map[string]*ModVariableMap

	// a list of the pointers to the variables whose values can be changed
	// NOTE: this refers to the SAME variable objects as exist in the RootVariables and DependencyVariables maps,
	// so when we set the value of public variables, we mutate the underlying variable
	PublicVariables map[string]*Variable
}

ModVariableMap is a struct containing maps of variable definitions

func NewModVariableMap

func NewModVariableMap(mod *Mod) (*ModVariableMap, error)

NewModVariableMap builds a ModVariableMap using the variables from a mod and its dependencies

func (*ModVariableMap) GetPublicVariableValues

func (m *ModVariableMap) GetPublicVariableValues() (map[string]string, error)

GetPublicVariableValues converts public variables into a map of string variable values

func (*ModVariableMap) PopulatePublicVariables

func (m *ModVariableMap) PopulatePublicVariables()

PopulatePublicVariables builds a map of top level and dependency variables (dependency variables are keyed by full (qualified) name

func (*ModVariableMap) ToArray

func (m *ModVariableMap) ToArray() []*Variable

type ModVersionConstraint

type ModVersionConstraint struct {
	// the fully qualified mod name, e.g. github.com/turbot/mod1
	Name string `cty:"name" hcl:"name,label"`
	// variable values to be set on the dependency mod
	Args map[string]cty.Value `cty:"args"  hcl:"args,optional"`

	// optionally override the database and search path
	Database         *string  `cty:"database" hcl:"database"`
	SearchPath       []string `cty:"search_path" hcl:"search_path,optional"`
	SearchPathPrefix []string `cty:"search_path_prefix" hcl:"search_path_prefix,optional"`
	// the version constraint string
	VersionString string `cty:"version" hcl:"version,optional"`
	// the local file location to use
	FilePath string `cty:"path" hcl:"path,optional"`
	// the branch name to use
	BranchName string `cty:"branch" hcl:"branch,optional"`
	// the (non-version) tag to use
	// populated only if a tag which is not a semver is used
	Tag string `cty:"tag" hcl:"tag,optional"`

	// contains the range of the definition of the mod block
	DefRange hcl.Range
	// contains the range of the body of the mod block
	BodyRange hcl.Range
	// contains the range of the version/branch/tag/path field
	VersionRange hcl.Range
	// contains filtered or unexported fields
}

ModVersionConstraint is a struct to represent a version as specified in a mod require block

func NewFilepathModVersionConstraint

func NewFilepathModVersionConstraint(mod *Mod) *ModVersionConstraint

func NewModVersionConstraint

func NewModVersionConstraint(modFullName string) (*ModVersionConstraint, error)

NewModVersionConstraint creates a new ModVersionConstraint - this is called when installing a mod

func (*ModVersionConstraint) DependencyPath

func (m *ModVersionConstraint) DependencyPath() string

func (*ModVersionConstraint) Equals

func (*ModVersionConstraint) HasVersion

func (m *ModVersionConstraint) HasVersion() bool

HasVersion returns whether the mod has a version specified, or is the latest if no version is specified, or the version is "latest", this is the latest version

func (*ModVersionConstraint) Initialise

func (m *ModVersionConstraint) Initialise(block *hcl.Block) hcl.Diagnostics

Initialise parses the version and name properties

func (*ModVersionConstraint) IsPrerelease

func (m *ModVersionConstraint) IsPrerelease() bool

func (*ModVersionConstraint) OriginalConstraint

func (m *ModVersionConstraint) OriginalConstraint() any

func (*ModVersionConstraint) String

func (m *ModVersionConstraint) String() string

func (*ModVersionConstraint) VersionConstraint

func (m *ModVersionConstraint) VersionConstraint() *versionhelpers.Constraints

type ModVersionConstraintCollection

type ModVersionConstraintCollection []*ModVersionConstraint

ModVersionConstraintCollection is a collection of ModVersionConstraint instances and implements the sort interface. See the sort package for more details. https://golang.org/pkg/sort/

func (ModVersionConstraintCollection) Len

Len returns the length of a collection. The number of Version instances on the slice.

func (ModVersionConstraintCollection) Less

Less is needed for the sort interface to compare two Version objects on the slice. If checks if one is less than the other.

func (ModVersionConstraintCollection) Swap

func (c ModVersionConstraintCollection) Swap(i, j int)

Swap is needed for the sort interface to replace the Version objects at two different positions in the slice.

type MsTeamsIntegration

type MsTeamsIntegration struct {
	// base
	HclResourceImpl          `json:"-"`
	ResourceWithMetadataImpl `json:"-"`
	IntegrationImpl          `json:"-"`
	Type                     string `json:"type" cty:"type" hcl:"type,label"`
	IntegrationName          string `json:"integration_name" cty:"integration_name"`

	// teams
	WebhookUrl *string `json:"webhook_url,omitempty" cty:"webhook_url" hcl:"webhook_url,optional"`
}

func MsTeamsIntegrationFromCtyValue

func MsTeamsIntegrationFromCtyValue(val cty.Value) (*MsTeamsIntegration, error)

func (*MsTeamsIntegration) CtyValue

func (i *MsTeamsIntegration) CtyValue() (cty.Value, error)

func (*MsTeamsIntegration) Equals

func (i *MsTeamsIntegration) Equals(other Integration) bool

func (*MsTeamsIntegration) GetIntegrationType

func (i *MsTeamsIntegration) GetIntegrationType() string

func (*MsTeamsIntegration) MapInterface

func (i *MsTeamsIntegration) MapInterface() (map[string]interface{}, error)

func (*MsTeamsIntegration) SetAttributes

func (i *MsTeamsIntegration) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*MsTeamsIntegration) Validate

func (i *MsTeamsIntegration) Validate() hcl.Diagnostics

type NamedItem

type NamedItem struct {
	Name string `cty:"name"`
}

NamedItem is a struct used by benchmark, container and dashboard to specify children of different types

func (NamedItem) String

func (c NamedItem) String() string

type NamedItemList

type NamedItemList []NamedItem

func (NamedItemList) StringList

func (l NamedItemList) StringList() []string

type NextStep

type NextStep struct {
	StepName    string         `json:"step_name"`
	Action      NextStepAction `json:"action"`
	StepForEach *StepForEach   `json:"step_for_each,omitempty"`
	StepLoop    *StepLoop      `json:"step_loop,omitempty"`
	Input       Input          `json:"input"`
}

type NextStepAction

type NextStepAction string
const (
	// Default Next Step action which is just to start them, note that
	// the step may yet be "skipped" if the IF clause is preventing the step
	// to actually start, but at the very least we can "start" the step.
	NextStepActionStart NextStepAction = "start"

	// This happens if the step can't be started because one of it's dependency as failed
	//
	// Q: So why would step failure does not mean pipeline fail straight away?
	// A: We can't raise the pipeline fail command if there's "ignore error" directive on the step.
	//    If there are steps that depend on the failed step, these steps becomes "inaccessible", they can't start
	//    because the dependend step has failed.
	//
	NextStepActionInaccessible NextStepAction = "inaccessible"

	NextStepActionSkip NextStepAction = "skip"
)

type NodeAndEdgeProvider

type NodeAndEdgeProvider interface {
	QueryProvider
	WithProvider
	GetEdges() DashboardEdgeList
	SetEdges(DashboardEdgeList)
	GetNodes() DashboardNodeList
	SetNodes(DashboardNodeList)
	AddCategory(category *DashboardCategory) hcl.Diagnostics
	AddChild(child HclResource) hcl.Diagnostics
}

NodeAndEdgeProvider must be implemented by any dashboard leaf node which supports edges and nodes (DashboardGraph, DashboardFlow, DashboardHierarchy) TODO [node_reuse] add NodeAndEdgeProviderImpl https://github.com/turbot/steampipe/issues/2918

type NodePath

type NodePath []string

NodePath is a string array representing the parentage of a ModTreeItem

type Notifier

type Notifier interface {
	HclResource
	ResourceWithMetadata

	CtyValue() (cty.Value, error)
	GetNotifierImpl() *NotifierImpl
	GetNotifies() []Notify
	SetFileReference(fileName string, startLineNumber int, endLineNumber int)

	Equals(Notifier) bool
}

type NotifierImpl

type NotifierImpl struct {
	HclResourceImpl          `json:"-"`
	ResourceWithMetadataImpl `json:"-"`

	Notifies []Notify `json:"notifies" cty:"notifies" hcl:"notifies"`

	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	FileName        string `json:"-" cty:"-" hcl:"-"`
	StartLineNumber int    `json:"-" cty:"-" hcl:"-"`
	EndLineNumber   int    `json:"-" cty:"-" hcl:"-"`
}

func (*NotifierImpl) CtyValue

func (c *NotifierImpl) CtyValue() (cty.Value, error)

func (*NotifierImpl) Equals

func (n *NotifierImpl) Equals(other Notifier) bool

func (*NotifierImpl) GetNotifierImpl

func (c *NotifierImpl) GetNotifierImpl() *NotifierImpl

func (*NotifierImpl) GetNotifies

func (c *NotifierImpl) GetNotifies() []Notify

func (*NotifierImpl) SetFileReference

func (n *NotifierImpl) SetFileReference(fileName string, startLineNumber int, endLineNumber int)

func (*NotifierImpl) Validate

func (c *NotifierImpl) Validate() hcl.Diagnostics

type Notify

type Notify struct {
	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	Integration Integration `json:"integration"`

	Cc          []string `json:"cc,omitempty" cty:"cc" hcl:"cc,optional"`
	Bcc         []string `json:"bcc,omitempty" cty:"bcc" hcl:"bcc,optional"`
	Channel     *string  `json:"channel,omitempty" cty:"channel" hcl:"channel,optional"`
	Description *string  `json:"description,omitempty" cty:"description" hcl:"description,optional"`
	Subject     *string  `json:"subject,omitempty" cty:"subject" hcl:"subject,optional"`
	Title       *string  `json:"title,omitempty" cty:"title" hcl:"title,optional"`
	To          []string `json:"to,omitempty" cty:"to" hcl:"to,optional"`
}

func (*Notify) CtyValue

func (n *Notify) CtyValue() (cty.Value, error)

func (*Notify) Equals

func (n *Notify) Equals(other *Notify) bool

func (*Notify) MapInterface

func (n *Notify) MapInterface() (map[string]interface{}, error)

func (*Notify) SetAttributes

func (n *Notify) SetAttributes(body hcl.Body, evalCtx *hcl.EvalContext) hcl.Diagnostics

func (*Notify) UnmarshalJSON

func (n *Notify) UnmarshalJSON(data []byte) error

UnmarshalJSON custom unmarshaller for Notify

func (*Notify) Validate

func (c *Notify) Validate() hcl.Diagnostics

type OpenGraph

type OpenGraph struct {
	// The opengraph description (og:description) of the mod, for use in social media applications
	Description *string `cty:"description" hcl:"description" json:"description"`
	// The opengraph display title (og:title) of the mod, for use in social media applications.
	Title     *string   `cty:"title" hcl:"title" json:"title"`
	Image     *string   `cty:"image" hcl:"image" json:"image"`
	DeclRange hcl.Range `json:"-"`
}

OpenGraph is a struct representing the OpenGraph group mod resource

type OptionsBlockFactory

type OptionsBlockFactory = func(*hcl.Block) (options.Options, hcl.Diagnostics)

type Output

type Output struct {
	Status      string      `json:"status,omitempty"`
	FailureMode string      `json:"failure_mode,omitempty"`
	Data        OutputData  `json:"data,omitempty"`
	Errors      []StepError `json:"errors,omitempty"`
	// Flowpipe metadata, contains started_at, finished_at
	Flowpipe map[string]interface{} `json:"flowpipe,omitempty"`
}

Output is the output from a step execution.

func (*Output) AsCtyMap

func (o *Output) AsCtyMap() (map[string]cty.Value, error)

func (*Output) Get

func (o *Output) Get(key string) interface{}

func (*Output) HasErrors

func (o *Output) HasErrors() bool

func (*Output) Set

func (o *Output) Set(key string, value interface{})

type OutputData

type OutputData map[string]interface{}

type ParamDef

type ParamDef struct {
	ShortName       string  `cty:"name" json:"name"`
	UnqualifiedName string  `cty:"full_name" json:"-"`
	Description     *string `cty:"description" json:"description"`
	Default         *string `cty:"default" json:"default"`
	// tactical - is the raw value a string
	IsString bool `cty:"is_string" json:"-"`

	// list of all blocks referenced by the resource
	References []*ResourceReference `json:"-"`
	DeclRange  hcl.Range            `json:"-"`
}

func NewParamDef

func NewParamDef(block *hcl.Block) *ParamDef

func (*ParamDef) Equals

func (p *ParamDef) Equals(other *ParamDef) bool

func (*ParamDef) GetDefault

func (p *ParamDef) GetDefault() (any, error)

GetDefault returns the default as an interface{}, unmarshalling json is the underlying value was NOT a string

func (*ParamDef) GetShowData

func (p *ParamDef) GetShowData() *printers.RowData

GetShowData implements printers.Showable

func (*ParamDef) SetDefault

func (p *ParamDef) SetDefault(value interface{}) error

SetDefault sets the default as a atring points, marshalling to json is the underlying value is NOT a string

func (*ParamDef) String

func (p *ParamDef) String() string

type ParsedPropertyPath

type ParsedPropertyPath struct {
	Mod          string
	ItemType     string
	Name         string
	PropertyPath []string
	// optional scope of this property path ("self")
	Scope    string
	Original string
}

func ParseResourcePropertyPath

func ParseResourcePropertyPath(propertyPath string) (*ParsedPropertyPath, error)

func PropertyPathFromExpression

func PropertyPathFromExpression(expr hcl.Expression) (bool, *ParsedPropertyPath, error)

func (*ParsedPropertyPath) PropertyPathString

func (p *ParsedPropertyPath) PropertyPathString() string

func (*ParsedPropertyPath) String

func (p *ParsedPropertyPath) String() string

func (*ParsedPropertyPath) ToParsedResourceName

func (p *ParsedPropertyPath) ToParsedResourceName() *ParsedResourceName

func (*ParsedPropertyPath) ToResourceName

func (p *ParsedPropertyPath) ToResourceName() string

type ParsedResourceName

type ParsedResourceName struct {
	Mod      string
	ItemType string
	Name     string
}

func ParseResourceName

func ParseResourceName(fullName string) (res *ParsedResourceName, err error)

func (*ParsedResourceName) ToFullName

func (p *ParsedResourceName) ToFullName() string

func (*ParsedResourceName) ToFullNameWithMod

func (p *ParsedResourceName) ToFullNameWithMod(mod string) string

func (*ParsedResourceName) ToResourceName

func (p *ParsedResourceName) ToResourceName() string

type Pipeline

type Pipeline struct {
	HclResourceImpl
	ResourceWithMetadataImpl

	// TODO: hack to serialise pipeline name because HclResourceImpl is not serialised
	PipelineName string `json:"pipeline_name"`

	// Unparsed HCL body, needed so we can de-code the step HCL into the correct struct
	RawBody hcl.Body `json:"-" hcl:",remain"`

	// Unparsed JSON raw message, needed so we can unmarshall the step JSON into the correct struct
	StepsRawJson json.RawMessage `json:"-"`

	Steps           []PipelineStep            `json:"steps,omitempty"`
	OutputConfig    []PipelineOutput          `json:"outputs,omitempty"`
	Params          map[string]*PipelineParam `json:"params"`
	FileName        string                    `json:"file_name"`
	StartLineNumber int                       `json:"start_line_number"`
	EndLineNumber   int                       `json:"end_line_number"`
	// contains filtered or unexported fields
}

Pipeline represents a "pipeline" block in an flowpipe HCL (*.fp) file

Note that this Pipeline definition is different that the pipeline that is running. This definition contains unresolved expressions (mostly in steps), how to handle errors etc but not the actual Pipeline execution data.

func NewPipeline

func NewPipeline(mod *Mod, block *hcl.Block) *Pipeline

func (*Pipeline) CoercePipelineParams

func (p *Pipeline) CoercePipelineParams(params map[string]string) (map[string]interface{}, []error)

This is inefficient because we are coercing the value from string -> Go using Cty (because that's how the pipeline is defined) and again we convert from Go -> Cty when we're executing the pipeline to build EvalContext when we're evaluating data are not resolved during parse time.

func (*Pipeline) CtyValue

func (p *Pipeline) CtyValue() (cty.Value, error)

func (*Pipeline) Equals

func (p *Pipeline) Equals(other *Pipeline) bool

func (*Pipeline) GetMod

func (p *Pipeline) GetMod() *Mod

func (*Pipeline) GetStep

func (p *Pipeline) GetStep(stepFullyQualifiedName string) PipelineStep

Pipeline functions

func (*Pipeline) OnDecoded

func (p *Pipeline) OnDecoded(*hcl.Block, ResourceMapsProvider) hcl.Diagnostics

func (*Pipeline) SetAttributes

func (p *Pipeline) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*Pipeline) SetFileReference

func (p *Pipeline) SetFileReference(fileName string, startLineNumber int, endLineNumber int)

func (*Pipeline) SetOptions

func (p *Pipeline) SetOptions(opts options.Options, block *hcl.Block) hcl.Diagnostics

SetOptions sets the options on the connection verify the options object is a valid options type (only options.Connection currently supported)

func (*Pipeline) UnmarshalJSON

func (ph *Pipeline) UnmarshalJSON(data []byte) error

func (*Pipeline) ValidatePipelineParam

func (p *Pipeline) ValidatePipelineParam(params map[string]interface{}) []error

type PipelineOutput

type PipelineOutput struct {
	Name                string         `json:"name"`
	Description         string         `json:"description,omitempty"`
	DependsOn           []string       `json:"depends_on,omitempty"`
	CredentialDependsOn []string       `json:"credential_depends_on,omitempty"`
	Resolved            bool           `json:"resolved,omitempty"`
	Value               interface{}    `json:"value,omitempty"`
	UnresolvedValue     hcl.Expression `json:"-"`
	Range               *hcl.Range     `json:"Range"`
}

func (*PipelineOutput) AppendCredentialDependsOn

func (o *PipelineOutput) AppendCredentialDependsOn(credentialDependsOn ...string)

func (*PipelineOutput) AppendDependsOn

func (o *PipelineOutput) AppendDependsOn(dependsOn ...string)

func (*PipelineOutput) Equals

func (o *PipelineOutput) Equals(other *PipelineOutput) bool

type PipelineParam

type PipelineParam struct {
	Name        string    `json:"name"`
	Description string    `json:"description"`
	Optional    bool      `json:"optional,omitempty"`
	Default     cty.Value `json:"-"`
	Type        cty.Type  `json:"-"`
}

func (*PipelineParam) Equals

func (p *PipelineParam) Equals(other *PipelineParam) bool

type PipelineStep

type PipelineStep interface {
	PipelineStepBaseInterface

	Initialize()
	GetFullyQualifiedName() string
	GetName() string
	SetName(string)
	GetType() string
	SetType(string)
	SetPipelineName(string)
	GetPipelineName() string
	IsResolved() bool
	AddUnresolvedBody(string, hcl.Body)
	GetInputs(*hcl.EvalContext) (map[string]interface{}, error)
	GetDependsOn() []string
	GetCredentialDependsOn() []string
	GetForEach() hcl.Expression
	SetAttributes(hcl.Attributes, *hcl.EvalContext) hcl.Diagnostics
	GetUnresolvedAttributes() map[string]hcl.Expression
	SetBlockConfig(hcl.Blocks, *hcl.EvalContext) hcl.Diagnostics
	GetErrorConfig(*hcl.EvalContext, bool) (*ErrorConfig, hcl.Diagnostics)
	GetRetryConfig(*hcl.EvalContext, bool) (*RetryConfig, hcl.Diagnostics)
	GetLoopConfig() LoopDefn
	GetThrowConfig() []*ThrowConfig
	SetOutputConfig(map[string]*PipelineOutput)
	GetOutputConfig() map[string]*PipelineOutput
	Equals(other PipelineStep) bool
	Validate() hcl.Diagnostics
	SetFileReference(fileName string, startLineNumber int, endLineNumber int)
	SetRange(*hcl.Range)
	GetRange() *hcl.Range
	GetMaxConcurrency(*hcl.EvalContext) *int
}

A common interface that all pipeline steps must implement

func NewPipelineStep

func NewPipelineStep(stepType, stepName string) PipelineStep

type PipelineStepBase

type PipelineStepBase struct {
	Title               *string        `json:"title,omitempty"`
	Description         *string        `json:"description,omitempty"`
	Name                string         `json:"name"`
	Type                string         `json:"step_type"`
	PipelineName        string         `json:"pipeline_name,omitempty"`
	Timeout             interface{}    `json:"timeout,omitempty"`
	DependsOn           []string       `json:"depends_on,omitempty"`
	CredentialDependsOn []string       `json:"credential_depends_on,omitempty"`
	Resolved            bool           `json:"resolved,omitempty"`
	ErrorConfig         *ErrorConfig   `json:"-"`
	RetryConfig         *RetryConfig   `json:"retry,omitempty"`
	ThrowConfig         []*ThrowConfig `json:"throw,omitempty"`
	// TODO: we should serialise this, it's used in PipelineLoaded event to have a record the exact pipeline config loaded. There's no further need apart from record keeping, so it's OK to have it unserializeable for now.
	LoopConfig      LoopDefn                   `json:"-"`
	OutputConfig    map[string]*PipelineOutput `json:"-"`
	FileName        string                     `json:"file_name"`
	StartLineNumber int                        `json:"start_line_number"`
	EndLineNumber   int                        `json:"end_line_number"`
	MaxConcurrency  *int                       `json:"max_concurrency,omitempty"`
	Range           *hcl.Range                 `json:"range"`

	// This cant' be serialised
	UnresolvedAttributes map[string]hcl.Expression `json:"-"`
	UnresolvedBodies     map[string]hcl.Body       `json:"-"`
	ForEach              hcl.Expression            `json:"-"`
}

A common base struct that all pipeline steps must embed

func (*PipelineStepBase) AddUnresolvedAttribute

func (p *PipelineStepBase) AddUnresolvedAttribute(name string, expr hcl.Expression)

func (*PipelineStepBase) AddUnresolvedBody

func (p *PipelineStepBase) AddUnresolvedBody(name string, body hcl.Body)

func (*PipelineStepBase) AppendCredentialDependsOn

func (p *PipelineStepBase) AppendCredentialDependsOn(credentialDependsOn ...string)

func (*PipelineStepBase) AppendDependsOn

func (p *PipelineStepBase) AppendDependsOn(dependsOn ...string)

func (*PipelineStepBase) Equals

func (p *PipelineStepBase) Equals(other *PipelineStepBase) bool

func (*PipelineStepBase) GetBaseInputs

func (p *PipelineStepBase) GetBaseInputs(evalContext *hcl.EvalContext) (map[string]interface{}, error)

func (*PipelineStepBase) GetCredentialDependsOn

func (p *PipelineStepBase) GetCredentialDependsOn() []string

func (*PipelineStepBase) GetDependsOn

func (p *PipelineStepBase) GetDependsOn() []string

func (*PipelineStepBase) GetErrorConfig

func (p *PipelineStepBase) GetErrorConfig(evalContext *hcl.EvalContext, ifResolution bool) (*ErrorConfig, hcl.Diagnostics)

func (*PipelineStepBase) GetForEach

func (p *PipelineStepBase) GetForEach() hcl.Expression

func (*PipelineStepBase) GetFullyQualifiedName

func (p *PipelineStepBase) GetFullyQualifiedName() string

func (*PipelineStepBase) GetLoopConfig

func (p *PipelineStepBase) GetLoopConfig() LoopDefn

func (*PipelineStepBase) GetMaxConcurrency

func (p *PipelineStepBase) GetMaxConcurrency(evalContext *hcl.EvalContext) *int

func (*PipelineStepBase) GetName

func (p *PipelineStepBase) GetName() string

func (*PipelineStepBase) GetOutputConfig

func (p *PipelineStepBase) GetOutputConfig() map[string]*PipelineOutput

func (*PipelineStepBase) GetPipelineName

func (p *PipelineStepBase) GetPipelineName() string

func (*PipelineStepBase) GetRange

func (p *PipelineStepBase) GetRange() *hcl.Range

func (*PipelineStepBase) GetRetryConfig

func (p *PipelineStepBase) GetRetryConfig(evalContext *hcl.EvalContext, ifResolution bool) (*RetryConfig, hcl.Diagnostics)

func (*PipelineStepBase) GetThrowConfig

func (p *PipelineStepBase) GetThrowConfig() []*ThrowConfig

For Throw config we want the client to resolve individual element. This to avoid failing on the subsequent throw if an earlier throw is executed.

For example: 3 throw configuration. If the first throw condition is met, then there's no reason we should evaluate the subsequent throw conditions, let alone failing their evaluation.

func (*PipelineStepBase) GetType

func (p *PipelineStepBase) GetType() string

func (*PipelineStepBase) GetUnresolvedAttributes

func (p *PipelineStepBase) GetUnresolvedAttributes() map[string]hcl.Expression

func (*PipelineStepBase) HandleDecodeBodyDiags

func (p *PipelineStepBase) HandleDecodeBodyDiags(diags hcl.Diagnostics, attributeName string, body hcl.Body) hcl.Diagnostics

func (*PipelineStepBase) Initialize

func (p *PipelineStepBase) Initialize()

func (*PipelineStepBase) IsBaseAttribute

func (p *PipelineStepBase) IsBaseAttribute(name string) bool

func (*PipelineStepBase) IsResolved

func (p *PipelineStepBase) IsResolved() bool

func (*PipelineStepBase) SetBaseAttributes

func (p *PipelineStepBase) SetBaseAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*PipelineStepBase) SetBlockConfig

func (p *PipelineStepBase) SetBlockConfig(blocks hcl.Blocks, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*PipelineStepBase) SetFileReference

func (p *PipelineStepBase) SetFileReference(fileName string, startLineNumber int, endLineNumber int)

func (*PipelineStepBase) SetName

func (p *PipelineStepBase) SetName(name string)

func (*PipelineStepBase) SetOutputConfig

func (p *PipelineStepBase) SetOutputConfig(output map[string]*PipelineOutput)

func (*PipelineStepBase) SetPipelineName

func (p *PipelineStepBase) SetPipelineName(pipelineName string)

func (*PipelineStepBase) SetRange

func (p *PipelineStepBase) SetRange(r *hcl.Range)

func (*PipelineStepBase) SetResolved

func (p *PipelineStepBase) SetResolved(resolved bool)

func (*PipelineStepBase) SetType

func (p *PipelineStepBase) SetType(stepType string)

func (*PipelineStepBase) Validate

func (p *PipelineStepBase) Validate() hcl.Diagnostics

func (*PipelineStepBase) ValidateBaseAttributes

func (p *PipelineStepBase) ValidateBaseAttributes() hcl.Diagnostics

type PipelineStepBaseInterface

type PipelineStepBaseInterface interface {
	AppendDependsOn(...string)
	AppendCredentialDependsOn(...string)
	AddUnresolvedAttribute(string, hcl.Expression)
}

type PipelineStepContainer

type PipelineStepContainer struct {
	PipelineStepBase

	Image             *string           `json:"image"`
	Source            *string           `json:"source"`
	Cmd               []string          `json:"cmd"`
	Env               map[string]string `json:"env"`
	Entrypoint        []string          `json:"entrypoint"`
	CpuShares         *int64            `json:"cpu_shares"`
	Memory            *int64            `json:"memory"`
	MemoryReservation *int64            `json:"memory_reservation"`
	MemorySwap        *int64            `json:"memory_swap"`
	MemorySwappiness  *int64            `json:"memory_swappiness"`
	ReadOnly          *bool             `json:"read_only"`
	User              *string           `json:"user"`
	Workdir           *string           `json:"workdir"`
}

func (*PipelineStepContainer) Equals

func (p *PipelineStepContainer) Equals(iOther PipelineStep) bool

func (*PipelineStepContainer) GetInputs

func (p *PipelineStepContainer) GetInputs(evalContext *hcl.EvalContext) (map[string]interface{}, error)

func (*PipelineStepContainer) SetAttributes

func (p *PipelineStepContainer) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*PipelineStepContainer) Validate

func (p *PipelineStepContainer) Validate() hcl.Diagnostics

type PipelineStepEmail

type PipelineStepEmail struct {
	PipelineStepBase
	To           []string `json:"to"`
	From         *string  `json:"from"`
	SmtpPassword *string  `json:"smtp_password"`
	SmtpUsername *string  `json:"smtp_username"`
	Host         *string  `json:"host"`
	Port         *int64   `json:"port"`
	SenderName   *string  `json:"sender_name"`
	Cc           []string `json:"cc"`
	Bcc          []string `json:"bcc"`
	Body         *string  `json:"body"`
	ContentType  *string  `json:"content_type"`
	Subject      *string  `json:"subject"`
}

func (*PipelineStepEmail) Equals

func (p *PipelineStepEmail) Equals(iOther PipelineStep) bool

func (*PipelineStepEmail) GetInputs

func (p *PipelineStepEmail) GetInputs(evalContext *hcl.EvalContext) (map[string]interface{}, error)

func (*PipelineStepEmail) SetAttributes

func (p *PipelineStepEmail) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

type PipelineStepFunction

type PipelineStepFunction struct {
	PipelineStepBase

	Runtime string `json:"runtime" cty:"runtime"`
	Source  string `json:"source" cty:"source"`
	Handler string `json:"handler" cty:"handler"`

	Event map[string]interface{} `json:"event"`
	Env   map[string]string      `json:"env"`
}

func (*PipelineStepFunction) Equals

func (p *PipelineStepFunction) Equals(iOther PipelineStep) bool

func (*PipelineStepFunction) GetInputs

func (p *PipelineStepFunction) GetInputs(evalContext *hcl.EvalContext) (map[string]interface{}, error)

func (*PipelineStepFunction) SetAttributes

func (p *PipelineStepFunction) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*PipelineStepFunction) Validate

func (p *PipelineStepFunction) Validate() hcl.Diagnostics

type PipelineStepHttp

type PipelineStepHttp struct {
	PipelineStepBase

	Url             *string                `json:"url" binding:"required"`
	Method          *string                `json:"method,omitempty"`
	CaCertPem       *string                `json:"ca_cert_pem,omitempty"`
	Insecure        *bool                  `json:"insecure,omitempty"`
	RequestBody     *string                `json:"request_body,omitempty"`
	RequestHeaders  map[string]interface{} `json:"request_headers,omitempty"`
	BasicAuthConfig *BasicAuthConfig       `json:"basic_auth,omitempty"`
}

func (*PipelineStepHttp) Equals

func (p *PipelineStepHttp) Equals(iOther PipelineStep) bool

func (*PipelineStepHttp) GetInputs

func (p *PipelineStepHttp) GetInputs(evalContext *hcl.EvalContext) (map[string]interface{}, error)

func (*PipelineStepHttp) SetAttributes

func (p *PipelineStepHttp) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*PipelineStepHttp) SetBlockConfig

func (p *PipelineStepHttp) SetBlockConfig(blocks hcl.Blocks, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*PipelineStepHttp) Validate

func (p *PipelineStepHttp) Validate() hcl.Diagnostics

type PipelineStepInput

type PipelineStepInput struct {
	PipelineStepBase

	InputType  string  `json:"type" cty:"type"`
	Prompt     *string `json:"prompt" cty:"prompt"`
	OptionList []PipelineStepInputOption

	// Notifier cty.Value `json:"-" cty:"notify"`
	Notifier NotifierImpl `json:"notify" cty:"-"`

	// overrides
	Cc      []string `json:"cc,omitempty" cty:"cc" hcl:"cc,optional"`
	Bcc     []string `json:"bcc,omitempty" cty:"bcc" hcl:"bcc,optional"`
	Channel *string  `json:"channel,omitempty" cty:"channel" hcl:"channel,optional"`
	Subject *string  `json:"subject,omitempty" cty:"subject" hcl:"subject,optional"`
	To      []string `json:"to,omitempty" cty:"to" hcl:"to,optional"`
}

func (*PipelineStepInput) Equals

func (p *PipelineStepInput) Equals(other PipelineStep) bool

func (*PipelineStepInput) GetInputs

func (p *PipelineStepInput) GetInputs(evalContext *hcl.EvalContext) (map[string]interface{}, error)

func (*PipelineStepInput) SetAttributes

func (p *PipelineStepInput) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*PipelineStepInput) SetBlockConfig

func (p *PipelineStepInput) SetBlockConfig(blocks hcl.Blocks, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*PipelineStepInput) Validate

func (p *PipelineStepInput) Validate() hcl.Diagnostics

type PipelineStepInputOption

type PipelineStepInputOption struct {
	// circular link to its "parent"
	PipelineStepBase *PipelineStepBase `json:"-"`

	UnresolvedAttributes map[string]hcl.Expression `json:"-"`

	OptionLabel *string `json:"-"` // the label on the option block
	Label       *string `json:"label,omitempty" hcl:"label,optional"`
	Value       *string `json:"value,omitempty" hcl:"value,optional"`
	Selected    *bool   `json:"selected,omitempty" hcl:"selected,optional"`
	Style       *string `json:"style,omitempty" hcl:"style,optional"`
}

func CtyValueToPipelineStepInputOptionList

func CtyValueToPipelineStepInputOptionList(value cty.Value) ([]PipelineStepInputOption, error)

func (*PipelineStepInputOption) AddUnresolvedAttribute

func (p *PipelineStepInputOption) AddUnresolvedAttribute(name string, expr hcl.Expression)

func (*PipelineStepInputOption) AppendCredentialDependsOn

func (p *PipelineStepInputOption) AppendCredentialDependsOn(...string)

func (*PipelineStepInputOption) AppendDependsOn

func (p *PipelineStepInputOption) AppendDependsOn(dependsOn ...string)

func (*PipelineStepInputOption) Equals

func (*PipelineStepInputOption) Resolve

func (p *PipelineStepInputOption) Resolve(evalContext *hcl.EvalContext) (*PipelineStepInputOption, hcl.Diagnostics)

func (*PipelineStepInputOption) SetAttributes

func (p *PipelineStepInputOption) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*PipelineStepInputOption) Validate

func (p *PipelineStepInputOption) Validate() hcl.Diagnostics

type PipelineStepMessage

type PipelineStepMessage struct {
	PipelineStepBase

	Text string `json:"text" hcl:"text" cty:"text"`

	// Notifier cty.Value `json:"-" cty:"notify"`
	Notifier NotifierImpl `json:"notify" cty:"-"`

	// overrides
	Cc      []string `json:"cc,omitempty" cty:"cc" hcl:"cc,optional"`
	Bcc     []string `json:"bcc,omitempty" cty:"bcc" hcl:"bcc,optional"`
	Channel *string  `json:"channel,omitempty" cty:"channel" hcl:"channel,optional"`
	Subject *string  `json:"subject,omitempty" cty:"subject" hcl:"subject,optional"`
	To      []string `json:"to,omitempty" cty:"to" hcl:"to,optional"`
}

func (*PipelineStepMessage) Equals

func (p *PipelineStepMessage) Equals(iOther PipelineStep) bool

func (*PipelineStepMessage) GetInputs

func (p *PipelineStepMessage) GetInputs(evalContext *hcl.EvalContext) (map[string]interface{}, error)

func (*PipelineStepMessage) SetAttributes

func (p *PipelineStepMessage) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

type PipelineStepPipeline

type PipelineStepPipeline struct {
	PipelineStepBase

	Pipeline cty.Value `json:"-"`
	Args     Input     `json:"args"`
}

func (*PipelineStepPipeline) Equals

func (p *PipelineStepPipeline) Equals(iOther PipelineStep) bool

func (*PipelineStepPipeline) GetInputs

func (p *PipelineStepPipeline) GetInputs(evalContext *hcl.EvalContext) (map[string]interface{}, error)

func (*PipelineStepPipeline) SetAttributes

func (p *PipelineStepPipeline) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

type PipelineStepQuery

type PipelineStepQuery struct {
	PipelineStepBase
	Database *string       `json:"database"`
	Sql      *string       `json:"sql"`
	Args     []interface{} `json:"args"`
}

func (*PipelineStepQuery) Equals

func (p *PipelineStepQuery) Equals(iOther PipelineStep) bool

func (*PipelineStepQuery) GetInputs

func (p *PipelineStepQuery) GetInputs(evalContext *hcl.EvalContext) (map[string]interface{}, error)

func (*PipelineStepQuery) SetAttributes

func (p *PipelineStepQuery) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*PipelineStepQuery) Validate

func (p *PipelineStepQuery) Validate() hcl.Diagnostics

type PipelineStepSleep

type PipelineStepSleep struct {
	PipelineStepBase
	Duration interface{} `json:"duration"`
}

func (*PipelineStepSleep) Equals

func (p *PipelineStepSleep) Equals(iOther PipelineStep) bool

func (*PipelineStepSleep) GetInputs

func (p *PipelineStepSleep) GetInputs(evalContext *hcl.EvalContext) (map[string]interface{}, error)

func (*PipelineStepSleep) SetAttributes

func (p *PipelineStepSleep) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*PipelineStepSleep) Validate

func (p *PipelineStepSleep) Validate() hcl.Diagnostics

type PipelineStepTransform

type PipelineStepTransform struct {
	PipelineStepBase
	Value any `json:"value"`
}

func (*PipelineStepTransform) Equals

func (p *PipelineStepTransform) Equals(iOther PipelineStep) bool

func (*PipelineStepTransform) GetInputs

func (p *PipelineStepTransform) GetInputs(evalContext *hcl.EvalContext) (map[string]interface{}, error)

func (*PipelineStepTransform) SetAttributes

func (p *PipelineStepTransform) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

type PluginVersion

type PluginVersion struct {
	// the plugin name, as specified in the mod requires block. , e.g. turbot/mod1, aws
	RawName string `cty:"name" hcl:"name,label"`
	// the minumum version which satisfies the requirement
	MinVersionString string `cty:"min_version" hcl:"min_version,optional"`
	Constraint       *semver.Constraints
	// the org and name which are parsed from the raw name
	Org       string
	Name      string
	DeclRange hcl.Range
}

func (*PluginVersion) FullName

func (p *PluginVersion) FullName() string

func (*PluginVersion) Initialise

func (p *PluginVersion) Initialise(block *hcl.Block) hcl.Diagnostics

Initialise parses the version and name properties

func (*PluginVersion) ShortName

func (p *PluginVersion) ShortName() string

func (*PluginVersion) String

func (p *PluginVersion) String() string

type PluginVersionMap

type PluginVersionMap struct {
	Backend          string
	Database         string
	AvailablePlugins map[string]*PluginVersionString
}

func NewPluginVersionMap

func NewPluginVersionMap(backend, database string, availablePlugins map[string]*PluginVersionString) *PluginVersionMap

type PluginVersionString

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

func LocalPluginVersionString

func LocalPluginVersionString() *PluginVersionString

func NewPluginVersionString

func NewPluginVersionString(version string) (*PluginVersionString, error)

func (*PluginVersionString) IsLocal

func (p *PluginVersionString) IsLocal() bool

func (*PluginVersionString) IsSemver

func (p *PluginVersionString) IsSemver() bool

func (*PluginVersionString) Semver

func (p *PluginVersionString) Semver() *semver.Version

func (*PluginVersionString) String

func (p *PluginVersionString) String() string

type Pos

type Pos struct {
	Line   int `json:"line"`
	Column int `json:"column"`
	Byte   int `json:"byte"`
}

Pos represents a single position in a source file This is a direct re-implementation of hcl.Pos, allowing us to control JSON serialization

func NewPos

func NewPos(sourcePos hcl.Pos) Pos

func (Pos) GetLegacy

func (r Pos) GetLegacy() hcl.Pos

type PowerpipeWorkspaceProfile

type PowerpipeWorkspaceProfile struct {
	ProfileName string `hcl:"name,label" cty:"name"`

	//  dashboard / api server options
	Host   *string `hcl:"string" cty:"string"`
	Port   *int    `hcl:"port" cty:"port"`
	Listen *string `hcl:"listen" cty:"port"`

	// general options
	UpdateCheck *string `hcl:"update_check" cty:"update_check"`
	Telemetry   *string `hcl:"telemetry" cty:"telemetry"`
	LogLevel    *string `hcl:"log_level" cty:"log_level"`
	MemoryMaxMb *int    `hcl:"memory_max_mb" cty:"memory_max_mb"`

	// execution timeouts
	BenchmarkTimeout *int `hcl:"benchmark_timeout" cty:"benchmark_timeout"`
	DashboardTimeout *int `hcl:"dashboard_timeout" cty:"dashboard_timeout"`

	// pipes integration options
	PipesHost        *string `hcl:"pipes_host,optional" cty:"pipes_host"`
	PipesToken       *string `hcl:"pipes_token,optional" cty:"pipes_token"`
	SnapshotLocation *string `hcl:"snapshot_location,optional" cty:"snapshot_location"`

	ModLocation *string `hcl:"mod_location,optional" cty:"mod_location"`

	Watch    *bool `hcl:"watch" cty:"watch"`
	Input    *bool `hcl:"input" cty:"input"`
	Progress *bool `hcl:"progress" cty:"progress"`

	// "default" db settings
	Database     *string `hcl:"database" cty:"database"`
	QueryTimeout *int    `hcl:"query_timeout,optional" cty:"query_timeout"`
	MaxParallel  *int    `hcl:"max_parallel" cty:"max-parallel"`

	// (postgres-specific) search path settings
	SearchPath       *string `hcl:"search_path" cty:"search_path"`
	SearchPathPrefix *string `hcl:"search_path_prefix" cty:"search_path_prefix"`

	// terminal options
	Header    *bool   `hcl:"header" cty:"header"`
	Output    *string `hcl:"output"`
	Separator *string `hcl:"separator"`
	Timing    *bool   `hcl:"timing"`

	Base      *PowerpipeWorkspaceProfile `hcl:"base"`
	DeclRange hcl.Range
}

func (*PowerpipeWorkspaceProfile) ConfigMap

func (p *PowerpipeWorkspaceProfile) ConfigMap(cmd *cobra.Command) map[string]interface{}

ConfigMap creates a config map containing all options to pass to viper

func (*PowerpipeWorkspaceProfile) CtyValue

func (p *PowerpipeWorkspaceProfile) CtyValue() (cty.Value, error)

func (*PowerpipeWorkspaceProfile) GetDeclRange

func (p *PowerpipeWorkspaceProfile) GetDeclRange() *hcl.Range

func (*PowerpipeWorkspaceProfile) GetInstallDir

func (p *PowerpipeWorkspaceProfile) GetInstallDir() *string

func (*PowerpipeWorkspaceProfile) GetOptionsForBlock

func (p *PowerpipeWorkspaceProfile) GetOptionsForBlock(block *hcl.Block) (options.Options, hcl.Diagnostics)

func (*PowerpipeWorkspaceProfile) IsNil

func (p *PowerpipeWorkspaceProfile) IsNil() bool

func (*PowerpipeWorkspaceProfile) Name

func (*PowerpipeWorkspaceProfile) OnDecoded

func (p *PowerpipeWorkspaceProfile) OnDecoded() hcl.Diagnostics

func (*PowerpipeWorkspaceProfile) SetOptions

func (p *PowerpipeWorkspaceProfile) SetOptions(opts options.Options, block *hcl.Block) hcl.Diagnostics

SetOptions sets the options on the connection verify the options object is a valid options type (only options.Connection currently supported)

func (*PowerpipeWorkspaceProfile) ShortName

func (p *PowerpipeWorkspaceProfile) ShortName() string

type Query

type Query struct {
	ResourceWithMetadataImpl
	QueryProviderImpl

	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	// only here as otherwise gocty.ImpliedType panics
	Unused string `cty:"unused" json:"-"`
}

Query is a struct representing the Query resource

func (*Query) CtyValue

func (q *Query) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*Query) Diff

func (q *Query) Diff(other *Query) *DashboardTreeItemDiffs

func (*Query) Equals

func (q *Query) Equals(other *Query) bool

func (*Query) OnDecoded

func (q *Query) OnDecoded(*hcl.Block, ResourceMapsProvider) hcl.Diagnostics

OnDecoded implements HclResource

func (*Query) String

func (q *Query) String() string

type QueryArgs

type QueryArgs struct {
	// NOTE: ArgMap and ArgList should not be set directly, but should be set using the
	// SetNamedArgVal and SetPositionalArgVal methods
	// This is so that stringNamedArgs and stringPositionalArgs can be set correctly
	ArgMap map[string]string `cty:"args" json:"args,omitempty"`
	// args list may be sparsely populated (in case of runtime dependencies)
	// so use *string
	ArgList    []*string            `cty:"args_list" json:"args_list,omitempty"`
	References []*ResourceReference `cty:"refs" json:"refs,omitempty"`
	// contains filtered or unexported fields
}

QueryArgs is a struct which contains the arguments used to invoke a query these may either be passed by name, in a map, or as a list of positional args NOTE: if both are present the named parameters are used

func MergeArgs

func MergeArgs(queryProvider QueryProvider, runtimeArgs *QueryArgs) (*QueryArgs, error)

MergeArgs ensures base and runtime args are non nil and merges them into single args

func NewQueryArgs

func NewQueryArgs() *QueryArgs

func (*QueryArgs) AddPositionalArgVal

func (q *QueryArgs) AddPositionalArgVal(value any) error

func (*QueryArgs) ArgsStringList

func (q *QueryArgs) ArgsStringList() []string

ArgsStringList convert ArgLists into list of strings

func (*QueryArgs) ConvertArgsList

func (q *QueryArgs) ConvertArgsList() ([]any, error)

ConvertArgsList convert ArgList into list of interface{} by unmarshalling

func (*QueryArgs) Empty

func (q *QueryArgs) Empty() bool

func (*QueryArgs) Equals

func (q *QueryArgs) Equals(other *QueryArgs) bool

func (*QueryArgs) GetNamedArg

func (q *QueryArgs) GetNamedArg(name string) (interface{}, bool, error)

func (*QueryArgs) GetPositionalArg

func (q *QueryArgs) GetPositionalArg(idx int) (interface{}, bool, error)

func (*QueryArgs) GetShowData

func (q *QueryArgs) GetShowData() *printers.RowData

GetShowData implements printers.Showable

func (*QueryArgs) Merge

func (q *QueryArgs) Merge(other *QueryArgs, source QueryProvider) (*QueryArgs, error)

Merge merges the other args with ourselves, creating and returning a new QueryArgs with the result NOTE: other has precedence

func (*QueryArgs) SetArgList

func (q *QueryArgs) SetArgList(argList []any) error

func (*QueryArgs) SetArgMap

func (q *QueryArgs) SetArgMap(argMap map[string]any) error

func (*QueryArgs) SetNamedArgVal

func (q *QueryArgs) SetNamedArgVal(name string, value any) (err error)

func (*QueryArgs) SetPositionalArgVal

func (q *QueryArgs) SetPositionalArgVal(value any, idx int) (err error)

SetPositionalArgVal sets the value of a positional arg NOTE: we add by index so we can populate stringPositionalArgs if needed

func (*QueryArgs) String

func (q *QueryArgs) String() string

func (*QueryArgs) ToString

func (q *QueryArgs) ToString(value any) (string, error)

func (*QueryArgs) Validate

func (q *QueryArgs) Validate() error

type QueryProvider

type QueryProvider interface {
	RuntimeDependencyProvider
	GetArgs() *QueryArgs
	GetParams() []*ParamDef
	GetSQL() *string
	GetQuery() *Query
	SetArgs(*QueryArgs)
	SetParams([]*ParamDef)
	GetResolvedQuery(*QueryArgs) (*ResolvedQuery, error)
	RequiresExecution(QueryProvider) bool
	ValidateQuery() hcl.Diagnostics
	MergeParentArgs(QueryProvider, QueryProvider) hcl.Diagnostics
	GetQueryProviderImpl() *QueryProviderImpl
	ParamsInheritedFromBase() bool
	ArgsInheritedFromBase() bool
}

QueryProvider must be implemented by resources which have query/sql

type QueryProviderImpl

type QueryProviderImpl struct {
	RuntimeDependencyProviderImpl
	QueryProviderRemain hcl.Body `hcl:",remain" json:"-"`

	SQL       *string     `cty:"sql" hcl:"sql" column:"sql,string" json:"sql,omitempty"`
	Query     *Query      `cty:"query" hcl:"query" json:"-"`
	Args      *QueryArgs  `cty:"args" column:"args,jsonb" json:"args,omitempty"`
	Params    []*ParamDef `cty:"params" column:"params,jsonb" json:"params,omitempty"`
	QueryName *string     `column:"query,string" json:"query,omitempty"`
	// contains filtered or unexported fields
}

func NewQueryProviderImpl

func NewQueryProviderImpl(block *hcl.Block, mod *Mod, shortName string) QueryProviderImpl

func (*QueryProviderImpl) ArgsInheritedFromBase

func (q *QueryProviderImpl) ArgsInheritedFromBase() bool

ArgsInheritedFromBase implements QueryProvider determine whether our args were inherited from base resource

func (*QueryProviderImpl) CtyValue

func (q *QueryProviderImpl) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*QueryProviderImpl) GetArgs

func (q *QueryProviderImpl) GetArgs() *QueryArgs

GetArgs implements QueryProvider

func (*QueryProviderImpl) GetParams

func (q *QueryProviderImpl) GetParams() []*ParamDef

GetParams implements QueryProvider

func (*QueryProviderImpl) GetQuery

func (q *QueryProviderImpl) GetQuery() *Query

GetQuery implements QueryProvider

func (*QueryProviderImpl) GetQueryProviderImpl

func (q *QueryProviderImpl) GetQueryProviderImpl() *QueryProviderImpl

GetQueryProviderImpl implements QueryProvider

func (*QueryProviderImpl) GetResolvedQuery

func (q *QueryProviderImpl) GetResolvedQuery(runtimeArgs *QueryArgs) (*ResolvedQuery, error)

GetResolvedQuery return the SQL and args to run the query

func (*QueryProviderImpl) GetSQL

func (q *QueryProviderImpl) GetSQL() *string

GetSQL implements QueryProvider

func (*QueryProviderImpl) GetShowData

func (q *QueryProviderImpl) GetShowData() *printers.RowData

GetShowData implements printers.Showable

func (*QueryProviderImpl) MergeParentArgs

func (q *QueryProviderImpl) MergeParentArgs(queryProvider QueryProvider, parent QueryProvider) (diags hcl.Diagnostics)

MergeParentArgs merges our args with our parent args (ours take precedence)

func (*QueryProviderImpl) OnDecoded

func (q *QueryProviderImpl) OnDecoded(block *hcl.Block, _ ResourceMapsProvider) hcl.Diagnostics

func (*QueryProviderImpl) ParamsInheritedFromBase

func (q *QueryProviderImpl) ParamsInheritedFromBase() bool

ParamsInheritedFromBase implements QueryProvider determine whether our params were inherited from base resource

func (*QueryProviderImpl) RequiresExecution

func (q *QueryProviderImpl) RequiresExecution(queryProvider QueryProvider) bool

RequiresExecution implements QueryProvider

func (*QueryProviderImpl) SetArgs

func (q *QueryProviderImpl) SetArgs(args *QueryArgs)

SetArgs implements QueryProvider

func (*QueryProviderImpl) SetParams

func (q *QueryProviderImpl) SetParams(params []*ParamDef)

SetParams implements QueryProvider

func (*QueryProviderImpl) ValidateQuery

func (q *QueryProviderImpl) ValidateQuery() hcl.Diagnostics

ValidateQuery implements QueryProvider returns an error if neither sql or query are set it is overridden by resource types for which sql is optional

type Range

type Range struct {
	// Filename is the name of the file into which this range's positions point.
	Filename string `json:"filename,omitempty"`

	// Start and End represent the bounds of this range. Start is inclusive and End is exclusive.
	Start Pos `json:"start,omitempty"`
	End   Pos `json:"end,omitempty"`
}

Range represents a span of characters between two positions in a source file. This is a direct re-implementation of hcl.Range, allowing us to control JSON serialization

func NewRange

func NewRange(sourceRange hcl.Range) Range

func (Range) GetLegacy

func (r Range) GetLegacy() hcl.Range

type Require

type Require struct {
	Plugins                          []*PluginVersion        `hcl:"plugin,block"`
	DeprecatedSteampipeVersionString string                  `hcl:"steampipe,optional"`
	Steampipe                        *SteampipeRequire       `hcl:"steampipe,block"`
	Flowpipe                         *FlowpipeRequire        `hcl:"flowpipe,block"`
	Mods                             []*ModVersionConstraint `hcl:"mod,block"`

	// range of the require block body
	DeclRange hcl.Range
	// range of the require block type
	TypeRange hcl.Range
	// contains filtered or unexported fields
}

Require is a struct representing mod dependencies

func NewRequire

func NewRequire() *Require

func (*Require) AddModDependencies

func (r *Require) AddModDependencies(newModVersions map[string]*ModVersionConstraint)

AddModDependencies adds all the mod in newModVersions to our list of mods, using the following logic - if a mod with same name, [alias] and constraint exists, it is not added - if a mod with same name [and alias] and different constraint exist, it is replaced

func (*Require) Clone

func (r *Require) Clone() *Require

func (*Require) ContainsMod

func (r *Require) ContainsMod(requiredModVersion *ModVersionConstraint) bool

func (*Require) Empty

func (r *Require) Empty() bool

func (*Require) FlowpipeVersionConstraint

func (r *Require) FlowpipeVersionConstraint() *semver.Constraints

func (*Require) GetModDependency

func (r *Require) GetModDependency(name string) *ModVersionConstraint

func (*Require) RemoveAllModDependencies

func (r *Require) RemoveAllModDependencies()

func (*Require) RemoveModDependencies

func (r *Require) RemoveModDependencies(versions map[string]*ModVersionConstraint)

func (*Require) SteampipeVersionConstraint

func (r *Require) SteampipeVersionConstraint() *semver.Constraints

type ResolvedQuery

type ResolvedQuery struct {
	Name       string
	ExecuteSQL string
	RawSQL     string
	Args       []any
}

ResolvedQuery contains the execute SQL, raw SQL and args string used to execute a query

func (ResolvedQuery) QueryArgs

func (r ResolvedQuery) QueryArgs() *QueryArgs

QueryArgs converts the ResolvedQuery into QueryArgs

type ResourceDependency

type ResourceDependency struct {
	Range      hcl.Range
	Traversals []hcl.Traversal
}

func (*ResourceDependency) IsRuntimeDependency

func (d *ResourceDependency) IsRuntimeDependency() bool

func (*ResourceDependency) String

func (d *ResourceDependency) String() string

type ResourceMaps

type ResourceMaps struct {
	// the parent mod
	Mod *Mod

	Benchmarks            map[string]*Benchmark
	Controls              map[string]*Control
	Dashboards            map[string]*Dashboard
	DashboardCategories   map[string]*DashboardCategory
	DashboardCards        map[string]*DashboardCard
	DashboardCharts       map[string]*DashboardChart
	DashboardContainers   map[string]*DashboardContainer
	DashboardEdges        map[string]*DashboardEdge
	DashboardFlows        map[string]*DashboardFlow
	DashboardGraphs       map[string]*DashboardGraph
	DashboardHierarchies  map[string]*DashboardHierarchy
	DashboardImages       map[string]*DashboardImage
	DashboardInputs       map[string]map[string]*DashboardInput
	DashboardTables       map[string]*DashboardTable
	DashboardTexts        map[string]*DashboardText
	DashboardNodes        map[string]*DashboardNode
	GlobalDashboardInputs map[string]*DashboardInput
	Locals                map[string]*Local
	Variables             map[string]*Variable
	// all mods (including deps)
	Mods       map[string]*Mod
	Queries    map[string]*Query
	References map[string]*ResourceReference
	// map of snapshot paths, keyed by snapshot name
	Snapshots map[string]string

	// flowpipe
	Pipelines map[string]*Pipeline
	Triggers  map[string]*Trigger
}

ResourceMaps is a struct containing maps of all mod resource types This is provided to avoid db needing to reference workspace package

func NewResourceMaps

func NewResourceMaps(mod *Mod, sourceMaps ...*ResourceMaps) *ResourceMaps

func NewSourceSnapshotModResources

func NewSourceSnapshotModResources(snapshotPaths []string) *ResourceMaps

func (*ResourceMaps) AddMaps

func (m *ResourceMaps) AddMaps(sourceMaps ...*ResourceMaps)

func (*ResourceMaps) AddResource

func (m *ResourceMaps) AddResource(item HclResource) hcl.Diagnostics

func (*ResourceMaps) AddSnapshots

func (m *ResourceMaps) AddSnapshots(snapshotPaths []string)

func (*ResourceMaps) Empty

func (m *ResourceMaps) Empty() bool

func (*ResourceMaps) Equals

func (m *ResourceMaps) Equals(other *ResourceMaps) bool

func (*ResourceMaps) GetResource

func (m *ResourceMaps) GetResource(parsedName *ParsedResourceName) (resource HclResource, found bool)

GetResource tries to find a resource with the given name in the ResourceMaps NOTE: this does NOT support inputs, which are NOT uniquely named in a mod

func (*ResourceMaps) PopulateReferences

func (m *ResourceMaps) PopulateReferences()

func (*ResourceMaps) QueryProviders

func (m *ResourceMaps) QueryProviders() []QueryProvider

QueryProviders returns a slice of all QueryProviders

func (*ResourceMaps) TopLevelResources

func (m *ResourceMaps) TopLevelResources() *ResourceMaps

TopLevelResources returns a new ResourceMaps containing only top level resources (i.e. no dependencies)

func (*ResourceMaps) WalkResources

func (m *ResourceMaps) WalkResources(resourceFunc func(item HclResource) (bool, error)) error

WalkResources calls resourceFunc for every resource in the mod if any resourceFunc returns false or an error, return immediately

type ResourceMapsProvider

type ResourceMapsProvider interface {
	GetResourceMaps() *ResourceMaps
	GetResource(parsedName *ParsedResourceName) (resource HclResource, found bool)
}

type ResourceMetadata

type ResourceMetadata struct {
	// required to allow partial decoding
	ResourceMetadataRemain hcl.Body `hcl:",remain" json:"-"`

	ResourceName string `column:"resource_name,text," json:"resource_name"`
	// mod short name
	ModName          string `column:"mod_name,text" json:"mod_name"`
	FileName         string `column:"file_name,text" json:"file_name"`
	StartLineNumber  int    `column:"start_line_number,integer" json:"start_line_number"`
	EndLineNumber    int    `column:"end_line_number,integer" json:"end_line_number"`
	IsAutoGenerated  bool   `column:"auto_generated,bool" json:"auto_generated"`
	SourceDefinition string `column:"source_definition,text" json:"source_definition"`
	Anonymous        bool   `column:"is_anonymous,bool" json:"is_anonymous"`
	ModFullName      string `json:"-"`
}

ResourceMetadata ius a struct containing additional data about each resource, used to populate the introspection tables

func (*ResourceMetadata) Clone

func (*ResourceMetadata) SetMod

func (m *ResourceMetadata) SetMod(mod *Mod)

SetMod sets the mod name and mod short name

type ResourceReference

type ResourceReference struct {
	ResourceWithMetadataImpl

	To        string `cty:"reference_to" column:"reference_to,string" json:"reference_to,omitempty"`
	From      string `cty:"reference_from" column:"reference_from,string" json:"reference_from,omitempty"`
	BlockType string `cty:"from_block_type" column:"from_block_type,string" json:"from_block_type,omitempty"`
	BlockName string `cty:"from_block_name" column:"from_block_name,string" json:"from_block_name,omitempty"`
	Attribute string `cty:"from_attribute" column:"from_attribute,string" json:"from_attribute,omitempty"`
	// contains filtered or unexported fields
}

func NewResourceReference

func NewResourceReference(resource HclResource, block *hcl.Block, referenceString string, blockName string, attr *hclsyntax.Attribute) *ResourceReference

func (*ResourceReference) CloneWithNewFrom

func (r *ResourceReference) CloneWithNewFrom(from string) *ResourceReference

func (*ResourceReference) Equals

func (r *ResourceReference) Equals(other *ResourceReference) bool

func (*ResourceReference) GetShowData

func (r *ResourceReference) GetShowData() *printers.RowData

GetShowData implements printers.Showable

func (*ResourceReference) Name

func (r *ResourceReference) Name() string

Name implements ResourceWithMetadata the name must start with the 'resource type' as we parse it and use just the 'name' segment

func (*ResourceReference) String

func (r *ResourceReference) String() string

type ResourceReferenceMap

type ResourceReferenceMap map[string][]*ResourceReference

ResourceReferenceMap is a map of references keyed by 'ref' This is to handle the same reference being made more than once by a resource for example the reference var.v1 might be referenced several times

func (ResourceReferenceMap) Add

func (m ResourceReferenceMap) Add(reference *ResourceReference)

type ResourceWithMetadata

type ResourceWithMetadata interface {
	Name() string
	GetMetadata() *ResourceMetadata
	SetMetadata(metadata *ResourceMetadata)
	SetAnonymous(block *hcl.Block)
	IsAnonymous() bool
	AddReference(ref *ResourceReference)
	GetReferences() []*ResourceReference
}

ResourceWithMetadata must be implemented by resources which supports reflection metadata

type ResourceWithMetadataImpl

type ResourceWithMetadataImpl struct {
	ResourceMetadata
	// required to allow partial decoding
	ResourceWithMetadataImplRemain hcl.Body             `hcl:",remain" json:"-"`
	References                     []*ResourceReference `json:"references,omitempty"`
	// contains filtered or unexported fields
}

func (*ResourceWithMetadataImpl) AddReference

func (b *ResourceWithMetadataImpl) AddReference(ref *ResourceReference)

AddReference implements ResourceWithMetadata

func (*ResourceWithMetadataImpl) GetMetadata

func (b *ResourceWithMetadataImpl) GetMetadata() *ResourceMetadata

GetMetadata implements ResourceWithMetadata

func (*ResourceWithMetadataImpl) GetReferences

func (b *ResourceWithMetadataImpl) GetReferences() []*ResourceReference

GetReferences implements ResourceWithMetadata

func (*ResourceWithMetadataImpl) IsAnonymous

func (b *ResourceWithMetadataImpl) IsAnonymous() bool

IsAnonymous implements ResourceWithMetadata

func (*ResourceWithMetadataImpl) SetAnonymous

func (b *ResourceWithMetadataImpl) SetAnonymous(block *hcl.Block)

SetAnonymous implements ResourceWithMetadata

func (*ResourceWithMetadataImpl) SetMetadata

func (b *ResourceWithMetadataImpl) SetMetadata(metadata *ResourceMetadata)

SetMetadata implements ResourceWithMetadata

type RetryConfig

type RetryConfig struct {
	// circular link to its "parent"
	PipelineStepBase *PipelineStepBase `json:"-"`

	UnresolvedAttributes map[string]hcl.Expression `json:"-"`

	If          *bool   `json:"if"`
	MaxAttempts *int64  `json:"max_attempts,omitempty" hcl:"max_attempts,optional" cty:"max_attempts"`
	Strategy    *string `json:"strategy,omitempty" hcl:"strategy,optional" cty:"strategy"`
	MinInterval *int64  `json:"min_interval,omitempty" hcl:"min_interval,optional" cty:"min_interval"`
	MaxInterval *int64  `json:"max_interval,omitempty" hcl:"max_interval,optional" cty:"max_interval"`
}

func NewRetryConfig

func NewRetryConfig(p *PipelineStepBase) *RetryConfig

func (*RetryConfig) AddUnresolvedAttribute

func (r *RetryConfig) AddUnresolvedAttribute(name string, expr hcl.Expression)

func (*RetryConfig) AppendCredentialDependsOn

func (r *RetryConfig) AppendCredentialDependsOn(...string)

func (*RetryConfig) AppendDependsOn

func (r *RetryConfig) AppendDependsOn(dependsOn ...string)

func (*RetryConfig) CalculateBackoff

func (r *RetryConfig) CalculateBackoff(attempt int) time.Duration

The first attempt is the first time the operation is tried, NOT the first retry.

The first retry is the 2nd attempt

func (*RetryConfig) Equals

func (r *RetryConfig) Equals(other *RetryConfig) bool

func (*RetryConfig) ResolveSettings

func (r *RetryConfig) ResolveSettings() (int, string, int, int)

func (*RetryConfig) SetAttributes

func (r *RetryConfig) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*RetryConfig) Validate

func (r *RetryConfig) Validate() hcl.Diagnostics

type RuntimeDependency

type RuntimeDependency struct {
	PropertyPath       *ParsedPropertyPath
	TargetPropertyName *string
	// TACTICAL the name of the parent property - either "args" or "param.<name>"
	ParentPropertyName  string
	TargetPropertyIndex *int

	// TACTICAL - if set, wrap the dependency value in an array
	// this provides support for args which convert a runtime dependency to an array, like:
	// arns = [input.arn]
	IsArray bool

	// resource which provides has the dependency
	Provider HclResource
}

func (*RuntimeDependency) Equals

func (d *RuntimeDependency) Equals(other *RuntimeDependency) bool

func (*RuntimeDependency) SourceResourceName

func (d *RuntimeDependency) SourceResourceName() string

func (*RuntimeDependency) String

func (d *RuntimeDependency) String() string

func (*RuntimeDependency) ValidateSource

func (d *RuntimeDependency) ValidateSource(dashboard *Dashboard, workspace ResourceMapsProvider) error

type RuntimeDependencyProvider

type RuntimeDependencyProvider interface {
	ModTreeItem
	AddRuntimeDependencies([]*RuntimeDependency)
	GetRuntimeDependencies() map[string]*RuntimeDependency
}

RuntimeDependencyProvider is implemented by all QueryProviders and Dashboard

type RuntimeDependencyProviderImpl

type RuntimeDependencyProviderImpl struct {
	ModTreeItemImpl
	// required to allow partial decoding
	RuntimeDependencyProviderRemain hcl.Body `hcl:",remain" json:"-"`
	// contains filtered or unexported fields
}

func (*RuntimeDependencyProviderImpl) AddRuntimeDependencies

func (b *RuntimeDependencyProviderImpl) AddRuntimeDependencies(dependencies []*RuntimeDependency)

func (*RuntimeDependencyProviderImpl) GetRuntimeDependencies

func (b *RuntimeDependencyProviderImpl) GetRuntimeDependencies() map[string]*RuntimeDependency

type SlackIntegration

type SlackIntegration struct {
	HclResourceImpl          `json:"-"`
	ResourceWithMetadataImpl `json:"-"`
	IntegrationImpl          `json:"-"`

	Type string `json:"type" cty:"type" hcl:"type,label"`

	// slack
	Token         *string `json:"token,omitempty" cty:"token" hcl:"token,optional"`
	SigningSecret *string `json:"signing_secret,omitempty" cty:"signing_secret" hcl:"signing_secret,optional"`
	WebhookUrl    *string `json:"webhook_url,omitempty" cty:"webhook_url" hcl:"webhook_url,optional"`
	Channel       *string `json:"channel,omitempty" cty:"channel" hcl:"channel,optional"`
}

func SlackIntegrationFromCtyValue

func SlackIntegrationFromCtyValue(val cty.Value) (*SlackIntegration, error)

func (*SlackIntegration) CtyValue

func (i *SlackIntegration) CtyValue() (cty.Value, error)

func (*SlackIntegration) Equals

func (i *SlackIntegration) Equals(other Integration) bool

func (*SlackIntegration) GetIntegrationType

func (i *SlackIntegration) GetIntegrationType() string

func (*SlackIntegration) MapInterface

func (i *SlackIntegration) MapInterface() (map[string]interface{}, error)

func (*SlackIntegration) SetAttributes

func (i *SlackIntegration) SetAttributes(hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*SlackIntegration) Validate

func (i *SlackIntegration) Validate() hcl.Diagnostics

type SteampipeRequire

type SteampipeRequire struct {
	MinVersionString string `hcl:"min_version,optional"`
	Constraint       *semver.Constraints
	DeclRange        hcl.Range
}

type StepError

type StepError struct {
	PipelineExecutionID string          `json:"pipeline_execution_id"`
	StepExecutionID     string          `json:"step_execution_id"`
	Pipeline            string          `json:"pipeline"`
	Step                string          `json:"step"`
	Error               perr.ErrorModel `json:"error"`
}

type StepForEach

type StepForEach struct {
	ForEachStep bool                 `json:"for_each_step"`
	Key         string               `json:"key"  binding:"required"`
	Output      *Output              `json:"output,omitempty"`
	TotalCount  int                  `json:"total_count" binding:"required"`
	Each        json.SimpleJSONValue `json:"each" swaggerignore:"true"`
}

type StepLoop

type StepLoop struct {
	Index         int    `json:"index" binding:"required"`
	Input         *Input `json:"input,omitempty"`
	LoopCompleted bool   `json:"loop_completed"`
}

type StepRetry

type StepRetry struct {
	Count          int    `json:"count" binding:"required"`
	Input          *Input `json:"input,omitempty"`
	RetryCompleted bool   `json:"retry_completed"`
}

type ThrowConfig

type ThrowConfig struct {
	// Circular reference to its parent
	PipelineStepBase     *PipelineStepBase         `json:"-"`
	UnresolvedAttributes map[string]hcl.Expression `json:"-"`

	If      *bool
	Message *string
}

func NewThrowConfig

func NewThrowConfig(p *PipelineStepBase) *ThrowConfig

func (*ThrowConfig) AddUnresolvedAttribute

func (t *ThrowConfig) AddUnresolvedAttribute(name string, expr hcl.Expression)

func (*ThrowConfig) AppendCredentialDependsOn

func (t *ThrowConfig) AppendCredentialDependsOn(...string)

func (*ThrowConfig) AppendDependsOn

func (t *ThrowConfig) AppendDependsOn(dependsOn ...string)

func (*ThrowConfig) Equals

func (t *ThrowConfig) Equals(other *ThrowConfig) bool

func (*ThrowConfig) Resolve

func (t *ThrowConfig) Resolve(evalContext *hcl.EvalContext) (*ThrowConfig, hcl.Diagnostics)

func (*ThrowConfig) SetAttributes

func (t *ThrowConfig) SetAttributes(throwBlock *hcl.Block, hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

type Trigger

type Trigger struct {
	HclResourceImpl
	ResourceWithMetadataImpl

	FileName        string `json:"file_name"`
	StartLineNumber int    `json:"start_line_number"`
	EndLineNumber   int    `json:"end_line_number"`

	// 27/09/23 - Args is introduces combination of both parse time and runtime arguments. "var" should be resolved
	// at parse time, the vars all should be supplied when we start the system. However, args can also contain
	// runtime variable, i.e. self.request_body, self.rows
	//
	ArgsRaw hcl.Expression `json:"-"`

	// TODO: 2024/01/09 - change of direction with Trigger schema, pipeline no longer "common" because Query Trigger no longer has a single pipeline for
	// all its events, similarly for HTTP trigger the pipeline is being moved down to the "method" block.
	Pipeline cty.Value     `json:"-"`
	RawBody  hcl.Body      `json:"-" hcl:",remain"`
	Config   TriggerConfig `json:"-"`
	Enabled  *bool         `json:"-"`
}

The definition of a single Flowpipe Trigger

func NewTrigger

func NewTrigger(block *hcl.Block, mod *Mod, triggerType, triggerName string) *Trigger

func (*Trigger) Equals

func (t *Trigger) Equals(other *Trigger) bool

func (*Trigger) GetArgs

func (t *Trigger) GetArgs(evalContext *hcl.EvalContext) (Input, hcl.Diagnostics)

func (*Trigger) GetPipeline

func (t *Trigger) GetPipeline() cty.Value

func (*Trigger) IsBaseAttribute

func (t *Trigger) IsBaseAttribute(name string) bool

func (*Trigger) SetBaseAttributes

func (t *Trigger) SetBaseAttributes(mod *Mod, hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*Trigger) SetFileReference

func (t *Trigger) SetFileReference(fileName string, startLineNumber int, endLineNumber int)

type TriggerConfig

type TriggerConfig interface {
	SetAttributes(*Mod, *Trigger, hcl.Attributes, *hcl.EvalContext) hcl.Diagnostics
	SetBlocks(*Mod, *Trigger, hcl.Blocks, *hcl.EvalContext) hcl.Diagnostics
}

type TriggerHTTPMethod

type TriggerHTTPMethod struct {
	Type          string
	ExecutionMode string
	Pipeline      cty.Value
	ArgsRaw       hcl.Expression
}

func (*TriggerHTTPMethod) GetArgs

func (c *TriggerHTTPMethod) GetArgs(evalContext *hcl.EvalContext) (Input, hcl.Diagnostics)

type TriggerHttp

type TriggerHttp struct {
	Url           string                        `json:"url"`
	ExecutionMode string                        `json:"execution_mode"`
	Methods       map[string]*TriggerHTTPMethod `json:"methods"`
}

func (*TriggerHttp) SetAttributes

func (t *TriggerHttp) SetAttributes(mod *Mod, trigger *Trigger, hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*TriggerHttp) SetBlocks

func (t *TriggerHttp) SetBlocks(mod *Mod, trigger *Trigger, hclBlocks hcl.Blocks, evalContext *hcl.EvalContext) hcl.Diagnostics

type TriggerQuery

type TriggerQuery struct {
	Sql        string                          `json:"sql"`
	Schedule   string                          `json:"schedule"`
	Database   string                          `json:"database"`
	PrimaryKey string                          `json:"primary_key"`
	Captures   map[string]*TriggerQueryCapture `json:"captures"`
}

func (*TriggerQuery) SetAttributes

func (t *TriggerQuery) SetAttributes(mod *Mod, trigger *Trigger, hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*TriggerQuery) SetBlocks

func (t *TriggerQuery) SetBlocks(mod *Mod, trigger *Trigger, hclBlocks hcl.Blocks, evalContext *hcl.EvalContext) hcl.Diagnostics

type TriggerQueryCapture

type TriggerQueryCapture struct {
	Type     string
	Pipeline cty.Value
	ArgsRaw  hcl.Expression
}

func (*TriggerQueryCapture) GetArgs

func (c *TriggerQueryCapture) GetArgs(evalContext *hcl.EvalContext) (Input, hcl.Diagnostics)

type TriggerSchedule

type TriggerSchedule struct {
	Schedule string `json:"schedule"`
}

func (*TriggerSchedule) SetAttributes

func (t *TriggerSchedule) SetAttributes(mod *Mod, trigger *Trigger, hclAttributes hcl.Attributes, evalContext *hcl.EvalContext) hcl.Diagnostics

func (*TriggerSchedule) SetBlocks

func (t *TriggerSchedule) SetBlocks(mod *Mod, trigger *Trigger, hclBlocks hcl.Blocks, evalContext *hcl.EvalContext) hcl.Diagnostics

type Variable

type Variable struct {
	ResourceWithMetadataImpl
	ModTreeItemImpl

	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	Default cty.Value `column:"default_value,jsonb" json:"-"`
	Type    cty.Type  `column:"var_type,string" json:"-"`

	TypeString string `json:"type"`
	DefaultGo  any    `json:"value_default"`
	ValueGo    any    `json:"value"`
	ModName    string `json:"mod_name"`

	// set after value resolution `column:"value,jsonb"`
	Value                      cty.Value                      `column:"value,jsonb" json:"-"`
	ValueSourceType            string                         `column:"value_source,string" json:"-"`
	ValueSourceFileName        string                         `column:"value_source_file_name,string" json:"-"`
	ValueSourceStartLineNumber int                            `column:"value_source_start_line_number,integer" json:"-"`
	ValueSourceEndLineNumber   int                            `column:"value_source_end_line_number,integer" json:"-"`
	ParsingMode                var_config.VariableParsingMode `json:"-"`
	// contains filtered or unexported fields
}

Variable is a struct representing a Variable resource

func NewVariable

func NewVariable(v *var_config.Variable, mod *Mod) *Variable

func (*Variable) CtyValue

func (v *Variable) CtyValue() (cty.Value, error)

CtyValue implements CtyValueProvider

func (*Variable) Diff

func (v *Variable) Diff(other *Variable) *DashboardTreeItemDiffs

func (*Variable) Equals

func (v *Variable) Equals(other *Variable) bool

func (*Variable) OnDecoded

func (v *Variable) OnDecoded(block *hcl.Block, _ ResourceMapsProvider) hcl.Diagnostics

OnDecoded implements HclResource

func (*Variable) Required

func (v *Variable) Required() bool

Required returns true if this variable is required to be set by the caller, or false if there is a default value that will be used when it isn't set.

func (*Variable) SetInputValue

func (v *Variable) SetInputValue(value cty.Value, sourceType string, sourceRange tfdiags.SourceRange) error

type VariableValidationFailedError

type VariableValidationFailedError struct {
}

func (VariableValidationFailedError) Error

type VersionConstrainCollection

type VersionConstrainCollection []*ModVersionConstraint

type WithProvider

type WithProvider interface {
	AddWith(with *DashboardWith) hcl.Diagnostics
	GetWiths() []*DashboardWith
	GetWith(string) (*DashboardWith, bool)
}

type WithProviderImpl

type WithProviderImpl struct {
	// required to allow partial decoding
	WithProviderRemain hcl.Body `hcl:",remain" json:"-"`
	// contains filtered or unexported fields
}

func (*WithProviderImpl) AddWith

func (b *WithProviderImpl) AddWith(with *DashboardWith) hcl.Diagnostics

func (*WithProviderImpl) GetWith

func (b *WithProviderImpl) GetWith(name string) (*DashboardWith, bool)

func (*WithProviderImpl) GetWiths

func (b *WithProviderImpl) GetWiths() []*DashboardWith

type WorkspaceProfile

type WorkspaceProfile interface {
	SetOptions(opts options.Options, block *hcl.Block) hcl.Diagnostics
	Name() string
	ShortName() string
	CtyValue() (cty.Value, error)
	OnDecoded() hcl.Diagnostics
	ConfigMap(cmd *cobra.Command) map[string]interface{}
	GetDeclRange() *hcl.Range

	GetOptionsForBlock(*hcl.Block) (options.Options, hcl.Diagnostics)

	GetInstallDir() *string
	// IsNil implements slightly hacky way of doing nil checks with generic types
	IsNil() bool
}

type WorkspaceResources

type WorkspaceResources struct {
	Query     map[string]bool
	Control   map[string]bool
	Benchmark map[string]bool
}

WorkspaceResources is used exclusively for the query/check command completion TODO to be refactored

func NewWorkspaceResources

func NewWorkspaceResources() *WorkspaceResources

func (*WorkspaceResources) GetSortedBenchmarksAndControlNames

func (w *WorkspaceResources) GetSortedBenchmarksAndControlNames() []string

GetSortedBenchmarksAndControlNames gives back a list of the benchmarks and controls in the current workspace. The list is sorted alphabetically - with the benchmarks first

func (*WorkspaceResources) GetSortedNamedQueryNames

func (w *WorkspaceResources) GetSortedNamedQueryNames() []string

func (*WorkspaceResources) Merge

Source Files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL