steampipeconfig

type ConnectionPlugin struct {
	// map of connection data (name, config, options)
	// keyed by connection name
	ConnectionMap       map[string]*ConnectionPluginData
	PluginName          string
	PluginClient        *sdkgrpc.PluginClient
	SupportedOperations *proto.SupportedOperations
	PluginShortName     string
}

type ConnectionPluginData struct {
	Name   string
	Config string
	Type   string
	Schema *sdkproto.Schema
}

type ConnectionSchemaMap map[string][]string

type ConnectionState struct {
	// the connection name
	ConnectionName string `json:"connection"  db:"name"`
	// connection type (expected value: "aggregator")
	Type *string `json:"type,omitempty"  db:"type"`
	// should we create a postgres schema for the connection (expected values: "enable", "disable")
	ImportSchema string `json:"import_schema"  db:"import_schema"`
	// the fully qualified name of the plugin
	Plugin string `json:"plugin"  db:"plugin"`
	// the plugin instance
	PluginInstance *string `json:"plugin_instance" db:"plugin_instance"`
	// the connection state (pending, updating, deleting, error, ready)
	State string `json:"state"  db:"state"`
	// error (if there is one - make a pointer to support null)
	ConnectionError *string `json:"error,omitempty" db:"error"`
	// schema mode - static or dynamic
	SchemaMode string `json:"schema_mode" db:"schema_mode"`
	// the hash of the connection schema - this is used to determine if a dynamic schema has changed
	SchemaHash string `json:"schema_hash,omitempty" db:"schema_hash"`
	// are the comments set
	CommentsSet bool `json:"comments_set" db:"comments_set"`
	// the creation time of the plugin file
	PluginModTime time.Time `json:"plugin_mod_time" db:"plugin_mod_time"`
	// the update time of the connection
	ConnectionModTime time.Time `json:"connection_mod_time" db:"connection_mod_time"`
	// the matching patterns of child connections (for aggregators)
	Connections     []string `json:"connections" db:"connections"`
	FileName        string   `json:"file_name" db:"file_name"`
	StartLineNumber int      `json:"start_line_number" db:"start_line_number"`
	EndLineNumber   int      `json:"end_line_number" db:"end_line_number"`
}

type ConnectionStateMap map[string]*ConnectionState

type ConnectionStateSummary map[string]int

type ConnectionUpdates struct {
	Update          ConnectionStateMap
	Delete          map[string]struct{}
	Error           map[string]struct{}
	Disabled        map[string]struct{}
	MissingComments ConnectionStateMap
	// map of missing plugins, keyed by plugin ALIAS
	// NOTE: we key by alias so the error message refers to the string which was used to specify the plugin
	MissingPlugins map[string][]modconfig.SteampipeConnection
	// the connections which will exist after the update
	FinalConnectionState ConnectionStateMap
	// connection plugins required to perform the updates, keyed by connection name
	ConnectionPlugins map[string]*ConnectionPlugin

	CurrentConnectionState ConnectionStateMap
	InvalidConnections     map[string]*ValidationFailure
	// map of plugin to connection for which we must refetch the rate limiter definitions
	PluginsWithUpdatedBinary map[string]string
	// contains filtered or unexported fields
}

type ConnectionUpdatesOption func(opt *connectionUpdatesConfig)

type DependencyPathKey string

type ErrorsAndWarningsNotification struct {
	PostgresNotification
	Errors   []string
	Warnings []string
}

type LoadConnectionStateConfiguration struct {
	WaitMode    WaitModeValue
	Connections []string
	SearchPath  []string
}

type LoadConnectionStateOption = func(config *LoadConnectionStateConfiguration)

type PostgresNotification struct {
	StructVersion int
	Type          PostgresNotificationType
}

type PostgresNotificationType int

type RefreshConnectionResult struct {
	error_helpers.ErrorAndWarnings
	UpdatedConnections bool
	FailedConnections  map[string]string
}

type SteampipeConfig struct {
	// map of plugin configs, keyed by plugin image ref
	// (for each image ref we store an array of configs)
	Plugins map[string][]*plugin.Plugin
	// map of plugin configs, keyed by plugin instance
	PluginsInstances map[string]*plugin.Plugin
	// map of connection name to partially parsed connection config
	Connections map[string]*modconfig.SteampipeConnection

	// Steampipe options
	DatabaseOptions *options.Database
	GeneralOptions  *options.General
	PluginOptions   *options.Plugin
	// map of installed plugin versions, keyed by plugin image ref
	PluginVersions map[string]*versionfile.InstalledVersion
}

type ValidationFailure struct {
	Plugin             string
	ConnectionName     string
	Message            string
	ShouldDropIfExists bool
}

type WaitModeValue int