model

package
v1.2.1-rc4 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Apr 20, 2017 License: Apache-2.0 Imports: 16 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source
var (

	// The BlockAffinity is stored as a raw string type.  It currently does
	// not contain any information since all required information is stored
	// in the key (hostname and block CIDR).  If we end up needing to store
	// data in the BlockAffinity then care will need to be taken to ensure
	// existing versions of the value (an empty string) can be successfully
	// unmarshalled.
	// - The Python version of IPAM wrote an empty string, but can handle
	//   any value written into the data.
	// - The original golang port of IPAM wrote "{}" into the data (the JSON
	//   value for an empty dict).  It was unable to handle reading of an
	//   empty string written out by the Python IPAM.
	// - The current version of the golang port now has the BlockAffinity
	//   as a raw-string type so that it can handle reading in any value.
	//   We write in a fixed value of "{}" so that we are compatible with
	//   both the Python and the original golang port.
	BlockAffinityValue = "{}"
)

Functions

func KeyToDefaultDeleteParentPaths

func KeyToDefaultDeleteParentPaths(key Key) ([]string, error)

KeyToDefaultDeleteParentPaths returns a slice of '/'-delimited paths which are used to delete parent entries that may be auto-created by directory-based KV stores (e.g. etcd v2). These paths should also be removed provided they have no more child entries.

The list of parent paths is ordered, and directories should be removed in the order supplied in the slice and only if the directory is empty.

For example,

KeyToDefaultDeletePaths(WorkloadEndpointKey{
	Hostname: "h",
	OrchestratorID: "o",
	WorkloadID: "w",
	EndpointID: "e",
})

returns

["/calico/v1/host/h/workload/o/w/endpoint",

"/calico/v1/host/h/workload/o/w"]

indicating that these paths should also be deleted when they are empty. In this example it is equivalent to deleting the workload when there are no more endpoints in the workload.

func KeyToDefaultDeletePath

func KeyToDefaultDeletePath(key Key) (string, error)

KeyToDefaultDeletePath converts one of the Keys from this package into a unique '/'-delimited path, which is suitable for use as the key when (recursively) deleting the value from a hierarchical (i.e. one with directories and leaves) key/value datastore such as etcd v2.

KeyToDefaultDeletePath returns a different path to KeyToDefaultPath when it is a passed a Key that represents a non-leaf which, for example, has its own metadata but also contains other resource types as children.

KeyToDefaultDeletePath returns the common prefix of the non-leaf key and its children so that a recursive delete of that key would delete the object itself and any children it has.

func KeyToDefaultPath

func KeyToDefaultPath(key Key) (string, error)

KeyToDefaultPath converts one of the Keys from this package into a unique '/'-delimited path, which is suitable for use as the key when storing the value in a hierarchical (i.e. one with directories and leaves) key/value datastore such as etcd v2.

Each unique key returns a unique path.

Keys with a hierarchical relationship share a common prefix. However, in order to support datastores that do not support storing data at non-leaf nodes in the hierarchy (such as etcd v2), the path returned for a "parent" key, is not a direct ancestor of its children.

func ListOptionsToDefaultPathRoot

func ListOptionsToDefaultPathRoot(listOptions ListInterface) string

ListOptionsToDefaultPathRoot converts list options struct into a common-prefix path suitable for querying a datastore that uses the paths returned by KeyToDefaultPath.

func ParseValue

func ParseValue(key Key, rawData []byte) (interface{}, error)

ParseValue parses the default JSON representation of our data into one of our value structs, according to the type of key. I.e. if passed a PolicyKey as the first parameter, it will try to parse rawData into a Policy struct.

func SerializeValue

func SerializeValue(d *KVPair) ([]byte, error)

Serialize a value in the model to a []byte to stored in the datastore. This performs the opposite processing to ParseValue()

Types

type ActiveStatusReportKey

type ActiveStatusReportKey struct {
	Hostname string `json:"-" validate:"required,hostname"`
}

func (ActiveStatusReportKey) String

func (key ActiveStatusReportKey) String() string

type ActiveStatusReportListOptions

type ActiveStatusReportListOptions struct {
	Hostname string
}

func (ActiveStatusReportListOptions) KeyFromDefaultPath

func (options ActiveStatusReportListOptions) KeyFromDefaultPath(ekey string) Key

type AllocationAttribute

type AllocationAttribute struct {
	AttrPrimary   *string           `json:"handle_id"`
	AttrSecondary map[string]string `json:"secondary"`
}

type AllocationBlock

type AllocationBlock struct {
	CIDR           net.IPNet             `json:"cidr"`
	Affinity       *string               `json:"affinity"`
	StrictAffinity bool                  `json:"strictAffinity"`
	Allocations    []*int                `json:"allocations"`
	Unallocated    []int                 `json:"unallocated"`
	Attributes     []AllocationAttribute `json:"attributes"`

	// HostAffinity is deprecated in favor of Affinity.
	// This is only to keep compatiblity with existing deployments.
	// The data format should be `Affinity: host:hostname` (not `hostAffinity: hostname`).
	HostAffinity *string `json:"hostAffinity,omitempty"`
}

type BGPPeer

type BGPPeer struct {
	// PeerIP is the IP address of the BGP peer.
	PeerIP net.IP `json:"ip"`

	// ASNum is the AS number of the peer.  Note that we write out the
	// value as a string in to the backend, because confd templating
	// converts large uints to float e notation which breaks the BIRD
	// configuration.
	ASNum numorstring.ASNumber `json:"as_num,string"`
}

type BGPPeerKey

type BGPPeerKey struct {
	Scope    scope.Scope `json:"-" validate:"omitempty"`
	Hostname string      `json:"-" validate:"omitempty"`
	PeerIP   net.IP      `json:"-" validate:"required"`
}

func (BGPPeerKey) String

func (key BGPPeerKey) String() string

type BGPPeerListOptions

type BGPPeerListOptions struct {
	Scope    scope.Scope `json:"-" validate:"omitempty"`
	Hostname string
	PeerIP   net.IP
}

func (BGPPeerListOptions) KeyFromDefaultPath

func (options BGPPeerListOptions) KeyFromDefaultPath(path string) Key

type BlockAffinityKey

type BlockAffinityKey struct {
	CIDR net.IPNet `json:"-" validate:"required,name"`
	Host string    `json:"-"`
}

func (BlockAffinityKey) String added in v1.0.1

func (key BlockAffinityKey) String() string

type BlockAffinityListOptions

type BlockAffinityListOptions struct {
	Host      string
	IPVersion int
}

func (BlockAffinityListOptions) KeyFromDefaultPath

func (options BlockAffinityListOptions) KeyFromDefaultPath(path string) Key

type BlockKey

type BlockKey struct {
	CIDR net.IPNet `json:"-" validate:"required,name"`
}

func (BlockKey) String added in v1.0.1

func (key BlockKey) String() string

type BlockListOptions

type BlockListOptions struct {
	IPVersion int `json:"-"`
}

func (BlockListOptions) KeyFromDefaultPath

func (options BlockListOptions) KeyFromDefaultPath(path string) Key

type GlobalBGPConfigKey

type GlobalBGPConfigKey struct {
	// The name of the global BGP config key.
	Name string `json:"-" validate:"required,name"`
}

func (GlobalBGPConfigKey) String

func (key GlobalBGPConfigKey) String() string

type GlobalConfigKey

type GlobalConfigKey struct {
	Name string `json:"-" validate:"required,name"`
}

func (GlobalConfigKey) String

func (key GlobalConfigKey) String() string

type GlobalConfigListOptions

type GlobalConfigListOptions struct {
	Name string
}

func (GlobalConfigListOptions) KeyFromDefaultPath

func (options GlobalConfigListOptions) KeyFromDefaultPath(path string) Key

type HostBGPConfigKey

type HostBGPConfigKey struct {
	// The hostname for the host specific BGP config
	Hostname string `json:"-" validate:"required,name"`

	// The name of the host specific BGP config key.
	Name string `json:"-" validate:"required,name"`
}

func (HostBGPConfigKey) String

func (key HostBGPConfigKey) String() string

type HostConfigKey

type HostConfigKey struct {
	Hostname string `json:"-" validate:"required,name"`
	Name     string `json:"-" validate:"required,name"`
}

func (HostConfigKey) String

func (key HostConfigKey) String() string

type HostConfigListOptions

type HostConfigListOptions struct {
	Hostname string
	Name     string
}

func (HostConfigListOptions) KeyFromDefaultPath

func (options HostConfigListOptions) KeyFromDefaultPath(path string) Key

type HostEndpoint

type HostEndpoint struct {
	Name              string            `json:"name,omitempty" validate:"omitempty,interface"`
	ExpectedIPv4Addrs []net.IP          `json:"expected_ipv4_addrs,omitempty" validate:"omitempty,dive,ipv4"`
	ExpectedIPv6Addrs []net.IP          `json:"expected_ipv6_addrs,omitempty" validate:"omitempty,dive,ipv6"`
	Labels            map[string]string `json:"labels,omitempty" validate:"omitempty,labels"`
	ProfileIDs        []string          `json:"profile_ids,omitempty" validate:"omitempty,dive,name"`
}

type HostEndpointKey

type HostEndpointKey struct {
	Hostname   string `json:"-" validate:"required,hostname"`
	EndpointID string `json:"-" validate:"required,namespacedName"`
}

func (HostEndpointKey) String

func (key HostEndpointKey) String() string

type HostEndpointListOptions

type HostEndpointListOptions struct {
	Hostname   string
	EndpointID string
}

func (HostEndpointListOptions) KeyFromDefaultPath

func (options HostEndpointListOptions) KeyFromDefaultPath(path string) Key

type HostEndpointStatus

type HostEndpointStatus struct {
	Status string `json:"status"`
}

type HostEndpointStatusKey

type HostEndpointStatusKey struct {
	Hostname   string `json:"-" validate:"required,hostname"`
	EndpointID string `json:"-" validate:"required,namespacedName"`
}

func (HostEndpointStatusKey) String

func (key HostEndpointStatusKey) String() string

type HostEndpointStatusListOptions

type HostEndpointStatusListOptions struct {
	Hostname   string
	EndpointID string
}

func (HostEndpointStatusListOptions) KeyFromDefaultPath

func (options HostEndpointStatusListOptions) KeyFromDefaultPath(ekey string) Key

type HostIPKey

type HostIPKey struct {
	Hostname string
}

The Felix Host IP Key.

func (HostIPKey) String

func (key HostIPKey) String() string

type HostMetadata

type HostMetadata struct {
}

type HostMetadataKey

type HostMetadataKey struct {
	Hostname string
}

func (HostMetadataKey) String

func (key HostMetadataKey) String() string

type HostMetadataListOptions

type HostMetadataListOptions struct {
	Hostname string
}

func (HostMetadataListOptions) KeyFromDefaultPath

func (options HostMetadataListOptions) KeyFromDefaultPath(path string) Key

type IPAMConfig

type IPAMConfig struct {
	StrictAffinity     bool `json:"strict_affinity,omitempty"`
	AutoAllocateBlocks bool `json:"auto_allocate_blocks,omitempty"`
}

type IPAMConfigKey

type IPAMConfigKey struct {
}

func (IPAMConfigKey) String added in v1.0.1

func (key IPAMConfigKey) String() string

type IPAMHandle

type IPAMHandle struct {
	HandleID string         `json:"-"`
	Block    map[string]int `json:"block"`
}

type IPAMHandleKey

type IPAMHandleKey struct {
	HandleID string `json:"id"`
}

func (IPAMHandleKey) String added in v1.0.1

func (key IPAMHandleKey) String() string

type IPAMHandleListOptions

type IPAMHandleListOptions struct {
}

func (IPAMHandleListOptions) KeyFromDefaultPath

func (options IPAMHandleListOptions) KeyFromDefaultPath(path string) Key

type IPAMHost

type IPAMHost struct {
}

type IPAMHostKey

type IPAMHostKey struct {
	Host string
}

func (IPAMHostKey) String added in v1.0.1

func (key IPAMHostKey) String() string

type IPNAT

type IPNAT struct {
	// The internal IP address which must be associated with the owning endpoint via the
	// configured IPNetworks for the endpoint.
	IntIP net.IP `json:"int_ip" validate:"ip"`

	// The external IP address.
	ExtIP net.IP `json:"ext_ip" validate:"ip"`
}

IPNat contains a single NAT mapping for a WorkloadEndpoint resource.

type IPPool

type IPPool struct {
	CIDR          net.IPNet `json:"cidr"`
	IPIPInterface string    `json:"ipip"`
	IPIPMode      ipip.Mode `json:"ipip_mode"`
	Masquerade    bool      `json:"masquerade"`
	IPAM          bool      `json:"ipam"`
	Disabled      bool      `json:"disabled"`
}

type IPPoolKey

type IPPoolKey struct {
	CIDR net.IPNet `json:"-" validate:"required,name"`
}

func (IPPoolKey) String

func (key IPPoolKey) String() string

type IPPoolListOptions

type IPPoolListOptions struct {
	CIDR net.IPNet
}

func (IPPoolListOptions) KeyFromDefaultPath

func (options IPPoolListOptions) KeyFromDefaultPath(path string) Key

type KVPair

type KVPair struct {
	Key      Key
	Value    interface{}
	Revision interface{}
	TTL      time.Duration // For writes, if non-zero, key has a TTL.
}

KVPair holds a typed key and value object as well as datastore specific revision information.

The Value is dependent on the Key, but in general will be on of the following types:

  • A pointer to a struct
  • A slice or map
  • A bare string, boolean value or IP address (i.e. without quotes, so not JSON format).

type Key

type Key interface {

	// String returns a unique string representation of this key.  The string
	// returned by this method must uniquely identify this Key.
	String() string
	// contains filtered or unexported methods
}

Key represents a parsed datastore key.

func KeyFromDefaultPath

func KeyFromDefaultPath(path string) Key

KeyFromDefaultPath parses the default path representation of a key into one of our <Type>Key structs. Returns nil if the string doesn't match one of our key types.

type LastStatusReportKey

type LastStatusReportKey struct {
	Hostname string `json:"-" validate:"required,hostname"`
}

func (LastStatusReportKey) String

func (key LastStatusReportKey) String() string

type LastStatusReportListOptions

type LastStatusReportListOptions struct {
	Hostname string
}

func (LastStatusReportListOptions) KeyFromDefaultPath

func (options LastStatusReportListOptions) KeyFromDefaultPath(ekey string) Key

type ListInterface

type ListInterface interface {

	// BUG(smc) I think we should remove this and use the package KeyFromDefaultPath function.
	// KeyFromDefaultPath parses the default path representation of the
	// Key type for this list.  It returns nil if passed a different kind
	// of path.
	KeyFromDefaultPath(key string) Key
	// contains filtered or unexported methods
}

Interface used to perform datastore lookups.

type Node

type Node struct {
	// Felix specific configuration
	FelixIPv4 *net.IP

	// Node specific labels
	Labels map[string]string `json:"labels,omitempty"`

	// BGP specific configuration
	BGPIPv4Addr *net.IP
	BGPIPv6Addr *net.IP
	BGPIPv4Net  *net.IPNet
	BGPIPv6Net  *net.IPNet
	BGPASNumber *numorstring.ASNumber
}

type NodeKey

type NodeKey struct {
	Hostname string
}

func (NodeKey) String

func (key NodeKey) String() string

type NodeListOptions

type NodeListOptions struct {
	Hostname string
}

func (NodeListOptions) KeyFromDefaultPath

func (options NodeListOptions) KeyFromDefaultPath(path string) Key

type Policy

type Policy struct {
	Order         *float64 `json:"order,omitempty" validate:"omitempty"`
	InboundRules  []Rule   `json:"inbound_rules,omitempty" validate:"omitempty,dive"`
	OutboundRules []Rule   `json:"outbound_rules,omitempty" validate:"omitempty,dive"`
	Selector      string   `json:"selector" validate:"selector"`
	DoNotTrack    bool     `json:"untracked,omitempty"`
}

func (Policy) String

func (p Policy) String() string

type PolicyKey

type PolicyKey struct {
	Name string `json:"-" validate:"required,name"`
}

func (PolicyKey) String

func (key PolicyKey) String() string

type PolicyListOptions

type PolicyListOptions struct {
	Name string
}

func (PolicyListOptions) KeyFromDefaultPath

func (options PolicyListOptions) KeyFromDefaultPath(path string) Key

type Profile

type Profile struct {
	Rules  ProfileRules
	Tags   []string
	Labels map[string]string
}

The profile structure is defined to allow the client to define a conversion interface to map between the API and backend profiles. However, in the actual underlying implementation the profile is written as three separate entries - rules, tags and labels.

type ProfileKey

type ProfileKey struct {
	Name string `json:"-" validate:"required,name"`
}

The profile key actually returns the common parent of the three separate entries. It is useful to define this to re-use some of the common machinery, and can be used for delete processing since delete needs to remove the common parent.

func (ProfileKey) String

func (key ProfileKey) String() string

type ProfileLabelsKey

type ProfileLabelsKey struct {
	ProfileKey
}

ProfileLabelsKey implements the KeyInterface for the profile labels

func (ProfileLabelsKey) String

func (key ProfileLabelsKey) String() string

type ProfileListOptions

type ProfileListOptions struct {
	Name string
}

func (ProfileListOptions) KeyFromDefaultPath

func (options ProfileListOptions) KeyFromDefaultPath(path string) Key

func (*ProfileListOptions) ListConvert

func (_ *ProfileListOptions) ListConvert(ds []*KVPair) []*KVPair

type ProfileRules

type ProfileRules struct {
	InboundRules  []Rule `json:"inbound_rules,omitempty" validate:"omitempty,dive"`
	OutboundRules []Rule `json:"outbound_rules,omitempty" validate:"omitempty,dive"`
}

type ProfileRulesKey

type ProfileRulesKey struct {
	ProfileKey
}

ProfileRulesKey implements the KeyInterface for the profile rules

func (ProfileRulesKey) String

func (key ProfileRulesKey) String() string

type ProfileTagsKey

type ProfileTagsKey struct {
	ProfileKey
}

ProfileTagsKey implements the KeyInterface for the profile tags

func (ProfileTagsKey) String

func (key ProfileTagsKey) String() string

type ReadyFlagKey

type ReadyFlagKey struct {
}

func (ReadyFlagKey) String added in v1.0.1

func (key ReadyFlagKey) String() string

type Rule

type Rule struct {
	Action string `json:"action,omitempty" validate:"backendaction"`

	IPVersion *int `json:"ip_version,omitempty" validate:"omitempty,ipversion"`

	Protocol    *numorstring.Protocol `json:"protocol,omitempty" validate:"omitempty"`
	NotProtocol *numorstring.Protocol `json:"!protocol,omitempty" validate:"omitempty"`

	ICMPType    *int `json:"icmp_type,omitempty" validate:"omitempty,gte=1,lte=255"`
	ICMPCode    *int `json:"icmp_code,omitempty" validate:"omitempty,gte=1,lte=255"`
	NotICMPType *int `json:"!icmp_type,omitempty" validate:"omitempty,gte=1,lte=255"`
	NotICMPCode *int `json:"!icmp_code,omitempty" validate:"omitempty,gte=1,lte=255"`

	SrcTag      string             `json:"src_tag,omitempty" validate:"omitempty,tag"`
	SrcNet      *net.IPNet         `json:"src_net,omitempty" validate:"omitempty"`
	SrcSelector string             `json:"src_selector,omitempty" validate:"omitempty,selector"`
	SrcPorts    []numorstring.Port `json:"src_ports,omitempty" validate:"omitempty"`
	DstTag      string             `json:"dst_tag,omitempty" validate:"omitempty,tag"`
	DstSelector string             `json:"dst_selector,omitempty" validate:"omitempty,selector"`
	DstNet      *net.IPNet         `json:"dst_net,omitempty" validate:"omitempty"`
	DstPorts    []numorstring.Port `json:"dst_ports,omitempty" validate:"omitempty"`

	NotSrcTag      string             `json:"!src_tag,omitempty" validate:"omitempty,tag"`
	NotSrcNet      *net.IPNet         `json:"!src_net,omitempty" validate:"omitempty"`
	NotSrcSelector string             `json:"!src_selector,omitempty" validate:"omitempty,selector"`
	NotSrcPorts    []numorstring.Port `json:"!src_ports,omitempty" validate:"omitempty"`
	NotDstTag      string             `json:"!dst_tag,omitempty" validate:"omitempty"`
	NotDstSelector string             `json:"!dst_selector,omitempty" validate:"omitempty,selector"`
	NotDstNet      *net.IPNet         `json:"!dst_net,omitempty" validate:"omitempty"`
	NotDstPorts    []numorstring.Port `json:"!dst_ports,omitempty" validate:"omitempty"`

	LogPrefix string `json:"log_prefix,omitempty" validate:"omitempty"`
}

func (Rule) String

func (r Rule) String() string

type StatusReport

type StatusReport struct {
	Timestamp     string  `json:"time"`
	UptimeSeconds float64 `json:"uptime"`
	FirstUpdate   bool    `json:"first_update"`
}

type WorkloadEndpoint

type WorkloadEndpoint struct {
	// TODO: Validation for workload endpoint.
	State            string            `json:"state"`
	Name             string            `json:"name"`
	ActiveInstanceID string            `json:"active_instance_id"`
	Mac              *net.MAC          `json:"mac"`
	ProfileIDs       []string          `json:"profile_ids"`
	IPv4Nets         []net.IPNet       `json:"ipv4_nets"`
	IPv6Nets         []net.IPNet       `json:"ipv6_nets"`
	IPv4NAT          []IPNAT           `json:"ipv4_nat,omitempty"`
	IPv6NAT          []IPNAT           `json:"ipv6_nat,omitempty"`
	Labels           map[string]string `json:"labels,omitempty"`
	IPv4Gateway      *net.IP           `json:"ipv4_gateway,omitempty" validate:"omitempty,ipv4"`
	IPv6Gateway      *net.IP           `json:"ipv6_gateway,omitempty" validate:"omitempty,ipv6"`
}

type WorkloadEndpointKey

type WorkloadEndpointKey struct {
	Hostname       string `json:"-"`
	OrchestratorID string `json:"-"`
	WorkloadID     string `json:"-"`
	EndpointID     string `json:"-"`
}

func (WorkloadEndpointKey) String

func (key WorkloadEndpointKey) String() string

type WorkloadEndpointListOptions

type WorkloadEndpointListOptions struct {
	Hostname       string
	OrchestratorID string
	WorkloadID     string
	EndpointID     string
}

func (WorkloadEndpointListOptions) KeyFromDefaultPath

func (options WorkloadEndpointListOptions) KeyFromDefaultPath(path string) Key

type WorkloadEndpointStatus

type WorkloadEndpointStatus struct {
	Status string `json:"status"`
}

type WorkloadEndpointStatusKey

type WorkloadEndpointStatusKey struct {
	Hostname       string `json:"-"`
	OrchestratorID string `json:"-"`
	WorkloadID     string `json:"-"`
	EndpointID     string `json:"-"`
}

func (WorkloadEndpointStatusKey) String

func (key WorkloadEndpointStatusKey) String() string

type WorkloadEndpointStatusListOptions

type WorkloadEndpointStatusListOptions struct {
	Hostname       string
	OrchestratorID string
	WorkloadID     string
	EndpointID     string
}

func (WorkloadEndpointStatusListOptions) KeyFromDefaultPath

func (options WorkloadEndpointStatusListOptions) KeyFromDefaultPath(ekey string) Key

Notes

Bugs

  • I think we should remove this and use the package KeyFromDefaultPath function. KeyFromDefaultPath parses the default path representation of the Key type for this list. It returns nil if passed a different kind of path.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL