catalog

type BuiltInPlugin struct {
	Log          logrus.FieldLogger
	Plugin       Plugin
	HostServices []HostServiceServer
}

type Catalog interface {
	// Fill fills up a "catalog" with client interfaces to interface with
	// the plugins and services offered by loaded plugins. The shape of the
	// "catalog" determines the constraints and requirements of the plugins.
	//
	// The "catalog" can be a pointer to an interface:
	//
	//   // Fill() will fail if there are no plugins that implement NodeAttestor
	//   var na nodeattestor.NodeAttestor
	//   cat, _ := catalog.Load(...)
	//   cat.Fill(&c)	//   catalog.Fill(&na)
	//
	// The "catalog" can also be a pointer to a struct:
	//
	//    type TheCatalog struct {
	//       // A required interface. Fill() fails if there is not exactly
	//       // one plugin matching this interface.
	//       RequiredPlugin nodeattestor.NodeAttestor
	//
	//       // An optional interface. Fill() fails if there are more than
	//       // one plugin that match this interface.
	//       OptionalPlugin *nodeattestor.NodeAttestor
	//
	//       // A slice of interfaces.
	//       Plugins []nodeattestor.NodeAttestor
	//
	//       // A map from string to interface. The key of the map is the name
	//       // of the plugin that matched.
	//       PluginsByName map[string]nodeattestor.NodeAttestor
	//
	//       // A struct of interfaces. A plugin must satisfy all interfaces //
	//       // within the struct to match. Fill() fails if there is not
	//       // exactly one plugin that matches.
	//       RequiredPluginStruct StructOfInterface
	//
	//       // A pointer to a struct of interfaces. A plugin must satisfy all
	//       // interfaces within the struct to meet the criteria. Fill() fails
	//       // if there are more than one plugin that matches.
	//       OptionalPluginStruct *StructOfInterface
	//
	//       // A slice of a struct of interfaces.
	//       PluginStructs []StructOfInterface
	//
	//       // A map from string to struct of interfaces. The key of the map
	//       // is the name of the plugin that matched.
	//       PluginStructsByName map[string]StructOfInterface
	//   }
	//
	//   type StructOfInterface struct {
	//       // The PluginInfo interface is special and is implemented on all
	//       // plugins.
	//       catalog.PluginInfo
	//
	//       nodeattestor.NodeAttestor
	//   }
	//
	//   var c TheCatalog
	//   cat, _ := catalog.Load(...)
	//   cat.Fill(&c)
	//
	//   In addition, the slice and map struct fields support imposing minimum
	//   and maximum constraints on the number of plugins to populate that
	//   field. For example:
	//
	//   struct {
	//       AtLeastTwo []nodeattestor.NodeAttestor `catalog:"min=2"`
	//       AtMostTwo []nodeattestor.NodeAttestor `catalog:"max=2"`
	//       BetweenThreeAndFive []nodeattestor.NodeAttestor `catalog:"min=3,max=5"`
	//   }
	//
	Fill(x interface{}) error

	// Close() closes the catalog, shutting down servers and killing external
	// plugin processes.
	Close()
}

type Closer interface {
	Close()
}

type Config struct {
	Log logrus.FieldLogger

	// GlobalConfig is passed to plugins during configuration.
	GlobalConfig GlobalConfig

	// PluginConfig is the configuration of plugins to load.
	PluginConfig []PluginConfig

	// KnownPlugins is the set of known external plugins.
	KnownPlugins []PluginClient

	// KnownServices is the set of known external services.
	KnownServices []ServiceClient

	// HostServices is a set of services offered by the host.
	HostServices []HostServiceServer

	// BuiltIns is the set of builtin plugins available to the host.
	BuiltIns []Plugin
}

type ExternalPlugin struct {
	Log           logrus.FieldLogger
	Name          string
	Path          string
	Checksum      string
	Data          string
	Plugin        PluginClient
	KnownServices []ServiceClient
	HostServices  []HostServiceServer
}

type GlobalConfig = spi.ConfigureRequest_GlobalConfig

type HCLPluginConfig struct {
	PluginCmd      string   `hcl:"plugin_cmd"`
	PluginChecksum string   `hcl:"plugin_checksum"`
	PluginData     ast.Node `hcl:"plugin_data"`
	Enabled        *bool    `hcl:"enabled"`
}

type HCLPluginConfigMap map[string]map[string]HCLPluginConfig

type HostServiceBroker interface {
	GetHostService(HostServiceClient) (has bool, err error)
}

type HostServiceClient interface {
	HostServiceType() string

	// InitHostServiceClient initializes the host service client.
	InitHostServiceClient(conn *grpc.ClientConn)
}

type HostServiceServer interface {
	// HostServiceType returns the host service type
	HostServiceType() string

	// RegisterHostServiceServer registers the host service server.
	RegisterHostServiceServer(*grpc.Server)
}

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

type NeedsHostServices interface {
	BrokerHostServices(HostServiceBroker) error
}

type NeedsLogger interface {
	SetLogger(hclog.Logger)
}

type PipeAddr struct {
}

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

type Plugin struct {
	Name     string
	Plugin   PluginServer
	Services []ServiceServer
}

type PluginClient interface {
	PluginType() string

	// NewPluginClient initializes and returns a service client.
	NewPluginClient(*grpc.ClientConn) interface{}
}

type PluginConfig struct {
	Name     string
	Type     string
	Path     string
	Checksum string
	Data     string
	Disabled bool
}

type PluginInfo interface {
	Name() string
	BuiltIn() bool
}

type PluginServer interface {
	// PluginType returns the plugin type
	PluginType() string

	// PluginClient returns the PluginClient interface for this server.
	PluginClient() PluginClient

	// Registers the implementation against the provided gRPC server and
	// returns the implementation. The implementation is used to wire up
	// logging and host services.
	RegisterPluginServer(server *grpc.Server) interface{}
}

type ServiceClient interface {
	// ServiceType returns the service type
	ServiceType() string

	// NewServiceClient initializes and returns a service client.
	NewServiceClient(*grpc.ClientConn) interface{}
}

type ServiceServer interface {
	// ServiceType returns the service type
	ServiceType() string

	// ServiceClient returns the PluginClient interface for this server.
	ServiceClient() ServiceClient

	// Registers the implementation against the provided gRPC server and
	// returns the implementation. The implementation is used to wire up
	// logging and host services.
	RegisterServiceServer(server *grpc.Server) interface{}
}