interfaces

type Action interface {
	Initially() error
	Execute() error
	Verify() error
	Success() error
	Undo() error
	Finally() error
}

type ActionCreator interface {
	SetUp() error
	CleanUp()
	OnStart() error
	OnFinish(environment S.Environment, response io.ReadWriter, err error) DeployResponse
	Create(environment S.Environment, response io.ReadWriter, foundationURL string) (Action, error)
	InitiallyError(initiallyErrors []error) error
	ExecuteError(executeErrors []error) error
	UndoError(executeErrors, undoErrors []error) error
	SuccessError(successErrors []error) error
}

type Authorization struct {
	Username string
	Password string
}

type Binding interface {
	Accepts(event interface{}) bool
	Emit(event interface{}) error
}

type BlueGreener interface {
	Execute(
		actionCreator ActionCreator,
		environment S.Environment,
		response io.ReadWriter,
	) error
}

type CFContext struct {
	Environment  string
	Organization string
	Space        string
	Application  string
	UUID         string
	SkipSSL      bool
}

type Client interface {
	Get(url string) (*http.Response, error)
}

type Controller interface {
	RunDeployment(deployment *Deployment, response *bytes.Buffer) DeployResponse

	RunDeploymentViaHttp(g *gin.Context)

	PutRequestHandler(g *gin.Context)
}

type Courier interface {
	Login(foundationURL, username, password, org, space string, skipSSL bool) ([]byte, error)
	Delete(appName string) ([]byte, error)
	Push(appName, appLocation, hostname string, instances uint16) ([]byte, error)
	Rename(oldName, newName string) ([]byte, error)
	MapRoute(appName, domain, hostname string) ([]byte, error)
	MapRouteWithPath(appName, domain, hostname, path string) ([]byte, error)
	UnmapRoute(appName, domain, hostname string) ([]byte, error)
	UnmapRouteWithPath(appName, domain, hostname, path string) ([]byte, error)
	DeleteRoute(domain, hostname string) ([]byte, error)
	CreateService(service, plan, name string) ([]byte, error)
	BindService(appName, serviceName string) ([]byte, error)
	UnbindService(appName, serviceName string) ([]byte, error)
	DeleteService(serviceName string) ([]byte, error)
	Start(appName string) ([]byte, error)
	Stop(appName string) ([]byte, error)
	Restage(appName string) ([]byte, error)
	Logs(appName string) ([]byte, error)
	Exists(appName string) bool
	Cups(appName string, body string) ([]byte, error)
	Uups(appName string, body string) ([]byte, error)
	Domains() ([]string, error)
	CleanUp() error
}

type DeployResponse struct {
	StatusCode     int
	DeploymentInfo *structs.DeploymentInfo
	Error          error
}

type Deployer interface {
	Deploy(
		deploymentInfo *structs.DeploymentInfo,
		environment structs.Environment,
		actionCreator ActionCreator,
		response io.ReadWriter,
	) *DeployResponse
}

type Deployment struct {
	Body          *[]byte
	Type          DeploymentType
	Authorization Authorization
	CFContext     CFContext
}

type DeploymentError interface {
	Code() string
	Error() string
}

type DeploymentType struct {
	JSON bool
	ZIP  bool
}

type Endpoints interface {
	Deploy(c *gin.Context)
}

type ErrorFinder interface {
	FindErrors(responseString string) []LogMatchedError
}

type ErrorMatcher interface {
	Descriptor() string
	Match(matchTo []byte) LogMatchedError
}

type Event struct {
	Type  string
	Data  interface{}
	Error error
}

type EventManager interface {
	AddHandler(handler Handler, eventType string) error
	Emit(event Event) error
	EmitEvent(event IEvent) error
	AddBinding(binding Binding)
}

type Executor interface {
	Execute(args ...string) ([]byte, error)
	ExecuteInDirectory(directory string, args ...string) ([]byte, error)
	CleanUp() error
}

type Extractor interface {
	Unzip(source, destination, manifest string) error
}

type Fetcher interface {
	Fetch(url, manifest string) (string, error)
	FetchZipFromRequest(body io.Reader) (string, string, error)
}

type Handler interface {
	OnEvent(event Event) error
}

type HealthChecker interface {
	Check(endpoint, serverURL string) error
}

type IEvent interface {
	Name() string
}

type LogMatchedError interface {
	Code() string
	Error() string
	Details() []string
	Solution() string
}

type Logger interface {
	Error(...interface{})
	Errorf(string, ...interface{})
	Debug(...interface{})
	Debugf(string, ...interface{})
	Info(...interface{})
	Infof(string, ...interface{})
	Fatal(...interface{})
}

type Prechecker interface {
	AssertAllFoundationsUp(environment S.Environment) error
}

type PushController interface {
	RunDeployment(deployment *Deployment, response *bytes.Buffer) (deployResponse DeployResponse)
}

type PushManagerFactory interface {
	PushManager(deployEventData structs.DeployEventData, cfContext CFContext, auth Authorization, env structs.Environment, envVars map[string]string) ActionCreator
}

type Randomizer interface {
	StringRunes(length int) string
}

type StartController interface {
	StartDeployment(deployment *Deployment, data map[string]interface{}, response *bytes.Buffer) (deployResponse DeployResponse)
}

type StartManagerFactory interface {
	StartManager(deployEventData structs.DeployEventData) ActionCreator
}

type StartStopEventData struct {
	FoundationURL string
	Context       CFContext
	Courier       interface{}
	Response      io.ReadWriter
}

type StopController interface {
	StopDeployment(deployment *Deployment, data map[string]interface{}, response *bytes.Buffer) (deployResponse DeployResponse)
}

type StopManagerFactory interface {
	StopManager(deployEventData structs.DeployEventData) ActionCreator
}