executor

type AddressManager interface {
	AddAddress(interfaceName string, address *net.IPNet) error
}

type Command interface {
	Execute(context Context) error
	String() string
}

type Condition interface {
	Satisfied(context Context) (bool, error)
	String() string
}

type Context interface {
	Logger() lager.Logger
	AddressManager() AddressManager
	LinkFactory() LinkFactory
	RouteManager() RouteManager
	SandboxNamespaceRepository() namespace.Repository
	SandboxRepository() SandboxRepository
	ListenerFactory() ListenerFactory
	DNSServerFactory() DNSServerFactory
}

type DNSFactory struct {
	Logger           lager.Logger
	ExternalServer   string
	DucatiAPI        string
	Suffix           string
	DecoratorFactory writerDecoratorFactory
}

type DNSServerFactory interface {
	New(listener net.PacketConn, ns namespace.Namespace) ifrit.Runner
}

type Executor interface {
	Execute(Command) error
}

type LinkFactory interface {
	CreateBridge(name string) error
	CreateDummy(name string) error
	CreateVeth(name, peerName string, mtu int) error
	CreateVxlan(name string, vni int) error
	DeleteLinkByName(name string) error
	Exists(name string) bool
	HardwareAddress(linkName string) (net.HardwareAddr, error)
	SetMaster(slave, master string) error
	SetNamespace(intefaceName string, fd uintptr) error
	SetUp(name string) error
	VethDeviceCount() (int, error)
}

type ListenUDPFunc func(network string, address *net.UDPAddr) (*net.UDPConn, error)

type ListenerFactory interface {
	ListenUDP(network string, address *net.UDPAddr) (*net.UDPConn, error)
}

type NamespaceWriter struct {
	Logger    lager.Logger
	Namespace namespace.Namespace
	Writer    writer
}

type RouteManager interface {
	AddRoute(interfaceName string, destination *net.IPNet, gateway net.IP) error
}

type SandboxRepository interface {
	Create(sandboxName string) (sandbox.Sandbox, error)
	Get(sandboxName string) (sandbox.Sandbox, error)
	Destroy(sandboxName string) error
}

type WriterDecoratorFactoryFunc func(logger lager.Logger, ns namespace.Namespace) dns.DecorateWriter