sdk

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

type Error keptnv2.Error

type FailingResourceHandler struct {
}

type FakeKeptn struct {
	TestResourceHandler ResourceHandler
	SentEvents          []models.KeptnContextExtendedCE
	Keptn               *Keptn
}

type IKeptn interface {
	// Start starts the internal event handling logic and needs to be called by the user
	// after creating value of IKeptn
	Start() error
	// GetResourceHandler returns a handler to fetch data from the configuration service
	GetResourceHandler() ResourceHandler
	// SendStartedEvent sends a started event for the given input event to the Keptn API
	// The first parameter is the "parent" event from which common information like e.g.
	// the keptn context, task name, ... are taken and used for constructing the corresponding .started event
	SendStartedEvent(KeptnEvent) error
	// SendFinishedEvent sends a finished event for the given input event to the Keptn API.
	// The first parameter can be seen as the "parent" event from which common information like e.g.
	// the keptn context, task name, ... are taken and used for constructing the corresponding .finished event.
	// The second parameter is the new event data to be set on the newly constructed .finished event
	SendFinishedEvent(KeptnEvent, interface{}) error
	// Logger returns the logger used by the sdk
	// Per default DefaultLogger is used which internally just uses the go logging package
	// Another logger can be configured using the sdk.WithLogger function
	Logger() Logger
	// APIV1 returns API utils for all Keptn APIs
	APIV1() api.KeptnInterface
	// APIV2 returns API utils for all v2 Keptn APIs
	APIV2() apiv2.KeptnInterface
}

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

type KeptnEvent models.KeptnContextExtendedCE

type KeptnOption func(*Keptn)

type Logger interface {
	Debug(v ...interface{})
	Debugf(format string, v ...interface{})
	Info(v ...interface{})
	Infof(format string, v ...interface{})
	Warn(v ...interface{})
	Warnf(format string, v ...interface{})
	Error(v ...interface{})
	Errorf(format string, v ...interface{})
	Fatal(v ...interface{})
	Fatalf(format string, v ...interface{})
}

type ResourceHandler interface {
	GetResource(scope api.ResourceScope, options ...api.URIOption) (*models.Resource, error)
}

type StringResourceHandler struct {
	ResourceContent string
}

type TaskHandler interface {
	// Execute is called whenever the actual business-logic of the service shall be executed.
	// Thus, the core logic of the service shall be triggered/implemented in this method.
	//
	// Note, that the contract of the method is to return the payload of the .finished event to be sent out as well as a Error Pointer
	// or nil, if there was no error during execution.
	Execute(keptnHandle IKeptn, event KeptnEvent) (interface{}, *Error)
}

type TaskHandlerOptions struct {
	// Filters specifies functions that determine whether the event shall be handled or ignored
	Filters []func(IKeptn, KeptnEvent) bool
	// SkipAutomaticResponse determines whether automatic sending of .started/.finished events should be skipped
	SkipAutomaticResponse bool
}

type TestResourceHandler struct {
	Resource models.Resource
}