domain

Documentation

Overview

Package domain is a container of all of the domain types and interfaces that are used across multiple packages within the service.

Index

• type Diff
• type Differ
• type ErrInProgress
  • func (e ErrInProgress) Error() string
• type ErrNotFound
  • func (e ErrNotFound) Error() string
• type Grapher
• type LogFn
• type Logger
• type Marker
• type Queuer
• type Stat
• type StatFn
• type Storage

Types

type Diff

type Diff struct {
	ID            string
	PreviousStart time.Time
	PreviousStop  time.Time
	NextStart     time.Time
	NextStop      time.Time
}

Diff represents two time for which a network graph diff will be computed

type Differ

type Differ interface {
	Diff(ctx context.Context, d Diff) (io.ReadCloser, error)
}

Differ provides an interface for generating a Diff of two network graphs. The network graphs will be retrieved based on the time ranges specified by the provided Diff type.

type ErrInProgress

type ErrInProgress struct {
	Key string
}

ErrInProgress indicates that a diff is in the process of being created

func (ErrInProgress) Error

func (e ErrInProgress) Error() string

type ErrNotFound

type ErrNotFound struct {
	ID string
}

ErrNotFound represents a resource lookup that failed due to a missing record.

func (ErrNotFound) Error

func (e ErrNotFound) Error() string

type Grapher

type Grapher interface {
	Graph(ctx context.Context, start, stop time.Time) (io.ReadCloser, error)
}

Grapher provides an interface for fetching a generated network graph in a given time range

type LogFn

type LogFn = runhttp.LogFn

LogFn is the recommended way to extract a logger from the context.

var LoggerFromContext LogFn = runhttp.LoggerFromContext

LoggerFromContext is a concrete implementation of the LogFn interface.

type Logger

type Logger = runhttp.Logger

Logger is the project logger interface.

type Marker

type Marker interface {
	// Mark flags the diff identified by key as being "in progress"
	Mark(ctx context.Context, key string) error

	// Unmark flags the diff identified by key as not being "in progress"
	Unmark(ctx context.Context, key string) error
}

Marker is an interface for indicating that a diff is in progress of being created

type Queuer

type Queuer interface {
	Queue(ctx context.Context, d Diff) error
}

Queuer provides an interface for queuing diff jobs onto a streaming appliance

type Stat

type Stat = runhttp.Stat

Stat is the project metrics client interface.

type StatFn

type StatFn = runhttp.StatFn

StatFn is the recommended way to extract a metrics client from the context.

var StatFromContext StatFn = runhttp.StatFromContext

StatFromContext is a concrete implementation of the StatFn interface.

type Storage

type Storage interface {
	// Get returns the diff for the given key.
	Get(ctx context.Context, key string) (io.ReadCloser, error)

	// Exists returns true if the diff exists, but does not download the digest body.
	Exists(ctx context.Context, key string) (bool, error)

	// Store stores the diff
	Store(ctx context.Context, key string, data io.ReadCloser) error
}

Storage is an interface for accessing created diffs. It is the caller's responsibility to call Close on the Reader when done.