plugin

type CanBeInitializedOptions struct {
	DeploymentEnv definition.ServiceDeploy
	Definitions   *definition.Definitions
}

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

type Feature interface {
	// CanBeInitialized is the method executed to check if the feature is
	// allowed to be used by the current service or not. Here the feature
	// should check everything that is needs to return this information.
	CanBeInitialized(options *CanBeInitializedOptions) bool

	// Initialize is the method that "creates" the feature, where all its
	// required initialization must be made.
	Initialize(ctx context.Context, options *InitializeOptions) error

	// Fields should return informative fields to be logged at the beginning
	// of the execution.
	Fields() []logger_api.Attribute

	// FeatureEntry is a set of methods that must provide information related
	// to the feature itself.
	FeatureEntry
}

type FeatureController interface {
	// Start is a method where the plugin receives the service main object to
	// initialize custom tasks.
	Start(ctx context.Context, srv interface{}) error

	// Cleanup should free all resources allocated by the plugin or stop any
	// internal process.
	Cleanup(ctx context.Context) error
}

type FeatureEntry interface {
	// UpdateInfo is an internal method that allows a feature to have its
	// information, such as its name, if it's enabled or not, internally.
	UpdateInfo(info UpdateInfoEntry)

	// IsEnabled returns true or false if the feature is currently enabled or not.
	IsEnabled() bool

	// Name returns the feature name.
	Name() string
}

type FeatureExternalAPI interface {
	ServiceAPI() interface{}
}

type FeatureInternalAPI interface {
	FrameworkAPI() interface{}
}

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

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

type FeatureSettings interface {
	// Definitions must return the feature definitions loaded from the
	// 'service.toml' file.
	//
	// To keep the framework standard, it's recommended that these custom
	// features settings reside inside a 'features' object inside the TOML
	// file. Like the example:
	//
	// [features.custom]
	//   custom_setting_a = 42
	//   custom_setting_b = "hello"
	//
	Definitions(path string) (definition.ExternalFeatureEntry, error)
}

type FeatureTester interface {
	// Setup is responsible for changing internal behaviors when running a
	// specific unit test.
	Setup(ctx context.Context, t *testing.Testing)

	// Teardown is responsible for cleaning up all resources allocated when
	// Setup was called before. It's important to notice here that after this
	// call, a new call to the Setup API must be made to run a new test.
	Teardown(ctx context.Context, t *testing.Testing)

	// DoTest is where the feature executes its specific tests previously
	// adjusted in the testing.Testing.Options.FeatureOptions.
	DoTest(ctx context.Context, t *testing.Testing, serviceName service.Name) error
}

type InitializeOptions struct {
	Logger          logger_api.LoggerAPI
	Errors          errors_api.ErrorAPI
	Env             env_api.EnvAPI
	Definitions     *definition.Definitions
	Tags            map[string]string
	ServiceContext  *mcontext.ServiceContext
	Dependencies    map[string]Feature
	RunTimeFeatures map[string]interface{}
}

type Service interface {
	// Name must return the implementation name. It's recommended to use a
	// kebab-case here.
	Name() string

	// Info should return some service informative fields to be logged while
	// the application is starting.
	Info() []logger_api.Attribute

	// Initialize must be the place to initialize everything that needs information
	// from the framework.
	Initialize(ctx context.Context, opt *ServiceOptions) error

	// Run must put the server in execution. It can block or not the call.
	Run(ctx context.Context, srv interface{}) error

	// Stop should stop the service with a graceful shutdown.
	Stop(ctx context.Context) error
}

type ServiceOptions struct {
	Port           service.ServerPort
	Type           definition.ServiceType
	Name           service.Name
	Product        string
	Logger         logger_api.LoggerAPI
	Errors         errors_api.ErrorAPI
	ServiceContext *mcontext.ServiceContext
	Tags           map[string]string
	Service        options.ServiceOptions
	Definitions    *definition.Definitions
	Features       *FeatureSet
	ServiceHandler interface{}
	Env            env_api.EnvAPI
}

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

type ServiceSettings interface {
	// Definitions must return the loaded service definitions from the
	// 'service.toml' file.
	//
	// To keep the framework standard, it's recommended that these custom
	// features settings use the service Name() as its main object inside
	// the TOML file. Like the example:
	//
	// [custom_service_name]
	//   custom_setting_a = 42
	//   custom_setting_b = "hello"
	//
	Definitions(path string) (definition.ExternalServiceEntry, error)
}

type UpdateInfoEntry struct {
	Enabled bool
	Name    string
	Logger  logger_api.LoggerAPI
	Errors  errors_api.ErrorAPI
}