kawasaki

type ConfigCreator interface {
	Create(log lager.Logger, handle string, subnet *net.IPNet, ip net.IP) (NetworkConfig, error)
}

type ConfigStore interface {
	Set(handle string, name string, value string)
	Get(handle string, name string) (string, bool)
}

type Configurer interface {
	Apply(log lager.Logger, cfg NetworkConfig, pid int) error
	DestroyBridge(log lager.Logger, cfg NetworkConfig) error
	DestroyIPTablesRules(log lager.Logger, cfg NetworkConfig) error
}

type ContainerConfigurer interface {
	Apply(logger lager.Logger, cfg NetworkConfig, pid int) error
}

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

type DnsResolvConfigurer interface {
	Configure(log lager.Logger, cfg NetworkConfig, pid int) error
}

type FileWriter interface {
	WriteFile(log lager.Logger, filePath string, contents []byte, rootfsPath string, rootUid, rootGid int) error
}

type FirewallOpener interface {
	Open(log lager.Logger, instance, handle string, rule garden.NetOutRule) error
	BulkOpen(log lager.Logger, instance, handle string, rule []garden.NetOutRule) error
}

type HostConfigurer interface {
	Apply(logger lager.Logger, cfg NetworkConfig, pid int) error
	Destroy(cfg NetworkConfig) error
}

type HostFileCompiler interface {
	Compile(log lager.Logger, containerIp net.IP, handle string) ([]byte, error)
}

type IDGenerator interface {
	Generate() string
}

type IdMapReader interface {
	ReadRootId(path string) (int, error)
}

type InstanceChainCreator interface {
	Create(logger lager.Logger, handle, instanceChain, bridgeName string, ip net.IP, network *net.IPNet) error
	Destroy(logger lager.Logger, instanceChain string) error
}

type NetnsExecer interface {
	Exec(netnsFD *os.File, cb func() error) error
}

type NetworkConfig struct {
	ContainerHandle string
	HostIntf        string
	ContainerIntf   string
	IPTablePrefix   string
	IPTableInstance string
	BridgeName      string
	BridgeIP        net.IP
	ContainerIP     net.IP
	ExternalIP      net.IP
	Subnet          *net.IPNet
	Mtu             int
	DNSServers      []net.IP
}

type Networker interface {
	Capacity() uint64
	Network(log lager.Logger, spec garden.ContainerSpec, pid int) error
	Destroy(log lager.Logger, handle string) error
	NetIn(log lager.Logger, handle string, externalPort, containerPort uint32) (uint32, uint32, error)
	NetOut(log lager.Logger, handle string, rule garden.NetOutRule) error
	BulkNetOut(log lager.Logger, handle string, rules []garden.NetOutRule) error
	Restore(log lager.Logger, handle string) error
}

type PortForwarder interface {
	Forward(spec PortForwarderSpec) error
}

type PortForwarderSpec struct {
	InstanceID  string
	Handle      string
	FromPort    uint32
	ToPort      uint32
	ContainerIP net.IP
	ExternalIP  net.IP
}

type PortPool interface {
	Acquire() (uint32, error)
	Release(uint32)
	Remove(uint32) error
}

type ResolvConfigurer struct {
	HostsFileCompiler  HostFileCompiler
	ResolvFileCompiler ResolvFileCompiler
	FileWriter         FileWriter
	IDMapReader        IdMapReader
}

type ResolvFileCompiler interface {
	Compile(log lager.Logger, resolvConfPath string, containerIp net.IP, overrideServers []net.IP) ([]byte, error)
}

type RootIdMapReader struct{}

type SpecParser interface {
	Parse(log lager.Logger, spec string) (subnets.SubnetSelector, subnets.IPSelector, error)
}

type SpecParserFunc func(spec string) (subnets.SubnetSelector, subnets.IPSelector, error)