external

type DockerProvider ¶

type DockerProvider struct {
	TimeOut time.Duration
}

DockerProvider is a status provider that uses docker

func (d *DockerProvider) Status(req Request) (*Response, error)

type HTTPProvider ¶

type HTTPProvider struct {
	http.Client
}

HTTPProvider is an external service that checks the status of a HTTP endpoint

func (h *HTTPProvider) Status(req Request) (*Response, error)

type MongoProvider ¶

type MongoProvider struct {
	TimeOut time.Duration
}

MongoProvider is a status provider that uses mongo

func (m *MongoProvider) Status(req Request) (*Response, error)

type Providers ¶

type Providers struct {
	HTTP   StatusProvider
	Mongo  StatusProvider
	Docker StatusProvider
}

Providers is a list of StatusProvider

type Request ¶

type Request struct {
	Name string
	URL  string
}

Request is a name and request to external service

type Response ¶

type Response struct {
	Name         string                 `json:"name"`
	StatusCode   int                    `json:"status_code"`
	ResponseTime int64                  `json:"response_time"` // milliseconds
	Body         map[string]interface{} `json:"body,omitempty"`
}

Response contains extended service information

type Service ¶

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

Service wraps multiple StatusProvider and multiplex their Status() calls

func NewService(providers Providers, concurrency int, reqs ...string) *Service

func (s *Service) Status() []Response

type StatusProvider ¶

type StatusProvider interface {
	Status(req Request) (*Response, error)
}

StatusProvider is an interface for getting status from external services

type StatusProviderMock ¶

type StatusProviderMock struct {
	// StatusFunc mocks the Status method.
	StatusFunc func(req Request) (*Response, error)
	// contains filtered or unexported fields
}

StatusProviderMock is a mock implementation of StatusProvider.

func TestSomethingThatUsesStatusProvider(t *testing.T) {

	// make and configure a mocked StatusProvider
	mockedStatusProvider := &StatusProviderMock{
		StatusFunc: func(req Request) (*Response, error) {
			panic("mock out the Status method")
		},
	}

	// use mockedStatusProvider in code that requires StatusProvider
	// and then make assertions.

}

func (mock *StatusProviderMock) Status(req Request) (*Response, error)

func (mock *StatusProviderMock) StatusCalls() []struct {
	Req Request
}

len(mockedStatusProvider.StatusCalls())