kawasaki

Documentation

Index

• func AddPortMapping(logger lager.Logger, configStore ConfigStore, handle string, ...) error
• func New(specParser SpecParser, subnetPool subnets.Pool, configCreator ConfigCreator, ...) *networker
• func NewConfigurer(resolvConfigurer DnsResolvConfigurer, hostConfigurer HostConfigurer, ...) *configurer
• func ParseSpec(spec string) (subnets.SubnetSelector, subnets.IPSelector, error)
• type ConfigCreator
• type ConfigStore
• type Configurer
• type ContainerConfigurer
• type Creator
  • func NewConfigCreator(idGenerator IDGenerator, interfacePrefix, chainPrefix string, ...) *Creator
  • func (c *Creator) Create(log lager.Logger, handle string, subnet *net.IPNet, ip net.IP) (NetworkConfig, error)
• type DnsResolvConfigurer
• type FileWriter
• type FirewallOpener
• type HostConfigurer
• type HostFileCompiler
• type IDGenerator
  • func NewSequentialIDGenerator(seed int64) IDGenerator
• type IdMapReader
• type InstanceChainCreator
• type NetnsExecer
• type NetworkConfig
• type Networker
• type PortForwarder
• type PortForwarderSpec
• type PortPool
• type ResolvConfigurer
  • func (d *ResolvConfigurer) Configure(log lager.Logger, cfg NetworkConfig, pid int) error
• type ResolvFileCompiler
• type RootIdMapReader
  • func (r *RootIdMapReader) ReadRootId(path string) (int, error)
• type SpecParser
• type SpecParserFunc
  • func (fn SpecParserFunc) Parse(log lager.Logger, spec string) (subnets.SubnetSelector, subnets.IPSelector, error)

Functions

func AddPortMapping

func AddPortMapping(logger lager.Logger, configStore ConfigStore, handle string, newMapping garden.PortMapping) error

func New

func New(
	specParser SpecParser,
	subnetPool subnets.Pool,
	configCreator ConfigCreator,
	configStore ConfigStore,
	configurer Configurer,
	portPool PortPool,
	portForwarder PortForwarder,
	firewallOpener FirewallOpener,
) *networker

func NewConfigurer

func NewConfigurer(resolvConfigurer DnsResolvConfigurer, hostConfigurer HostConfigurer, containerConfigurer ContainerConfigurer, instanceChainCreator InstanceChainCreator) *configurer

func ParseSpec

func ParseSpec(spec string) (subnets.SubnetSelector, subnets.IPSelector, error)

Types

type ConfigCreator

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

type ConfigStore

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

type Configurer

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

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

type Creator

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

func NewConfigCreator

func NewConfigCreator(idGenerator IDGenerator, interfacePrefix, chainPrefix string, externalIP net.IP, dnsServers []net.IP, mtu int) *Creator

func (*Creator) Create

func (c *Creator) Create(log lager.Logger, handle string, subnet *net.IPNet, ip net.IP) (NetworkConfig, error)

type DnsResolvConfigurer

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

type FileWriter

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

type FirewallOpener

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

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

type HostFileCompiler

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

type IDGenerator

type IDGenerator interface {
	Generate() string
}

func NewSequentialIDGenerator

func NewSequentialIDGenerator(seed int64) IDGenerator

type IdMapReader

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

type InstanceChainCreator

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

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

type NetworkConfig

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

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

type PortForwarder interface {
	Forward(spec PortForwarderSpec) error
}

type PortForwarderSpec

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

type PortPool

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

type ResolvConfigurer

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

func (*ResolvConfigurer) Configure

func (d *ResolvConfigurer) Configure(log lager.Logger, cfg NetworkConfig, pid int) error

type ResolvFileCompiler

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

type RootIdMapReader

type RootIdMapReader struct{}

func (*RootIdMapReader) ReadRootId

func (r *RootIdMapReader) ReadRootId(path string) (int, error)

Reads /proc/<pid>/{uid_map|gid_map} and retrieves the mapped user id for the container root user. Map format is the following: containerId hostId mappingSize 0 1000 1

type SpecParser

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

type SpecParserFunc

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

func (SpecParserFunc) Parse

func (fn SpecParserFunc) Parse(log lager.Logger, spec string) (subnets.SubnetSelector, subnets.IPSelector, error)