proto

package
v3.7.5+incompatible Latest Latest
Warning

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

Go to latest
Published: Aug 9, 2019 License: Apache-2.0 Imports: 8 Imported by: 0

Documentation

Overview

The proto package defines the protocol between Felix's policy "calculation engine", which calculates the policy that should be active on a given host, and the "dataplane driver", which renders that policy into the dataplane.

     +-----------+
     | Datastore |
     +-----+-----+
           |
           | <etcd/k8s/etc API>
           |
+----------+---------------+
| libcalico-go "client"    |
+---------<go API>---------+
| Felix calculation engine |
+----------+---------------+
           |
           | <this API>
           |
+----------+---------------+
| Dataplane driver         |
+----------+---------------+
           |
           | <dataplane-specific API>
           |
======= Dataplane ==========

Data Model Overview

The data model used on the dataplane driver API uses similar concepts to the main "datastore" data model (such as host/workload endpoints, policies and profiles). However, the calculation engine does some pre-calculation that simplifies the job of the dataplane driver:

Rules in the datastore data model can contain selectors, such as "role == webserver", that refer to dynamic groups of endpoints. The calculation engine computes sets of IP addresses from those selectors. Only the sets of IPs are sent over the API so the dataplane driver doesn't need to compute selectors itself, it only needs a way to program a set of IP addresses into the dataplane.

Policies in the datastore data model need to be filtered and sorted. The calculation engine takes care of that too. When it sends an endpoint to the datastore driver, it adds the complete list of policies that apply to the endpoint (in the correct order). If the correct list changes, it sends an update for the endpoint.

If a resource fails validation, the calculation engine replaces it with a "safe" stub or it simulates a delete.

This means that the dataplane driver sees the following model, filtered to only the resources that are active on this host:

 +------------------+
+------------------+|
| Host/Workload    ||
| Endpoint         ||
|                  ||
| Policy ID list --------+ refers to policies by ID
| List of IPs      ||    |
| Interface name   |+    |
+------------------+     |
                         |
               +---------|---------+
              +----------+--------+|
              | Policy            ||
              |                   ||
              | Inbound rules --------+ (rules embedded in the policy object)
              | Outbound rules --------+
              +-------------------+    |
                                       |
                             +---------|---------+
                            +----------+--------+|
                            | Rule              ||
                            |                   ||
                            | Match criteria    ||
                            | - protocol        ||
                            | - port            ||
                            | - CIDR            ||
                            | - ...             ||
                            | - IP set ID list  -----+ refers to IP sets by ID
                            +-------------------+    |
                                                     |
                                           +---------|---------+
                                          +----------+--------+|
                                          | IP set            ||
                                          |                   ||
                                          | 10.0.0.1          ||
                                          | 10.0.0.21         ||
                                          | 10.0.0.53         ||
                                          +-------------------+

Protocol Overview

The protocol is defined as a series of protobuf messages. This allows for a dataplane driver to run either in-process or in another process.

An in-process dataplane driver (such as the default one in the "intdataplane" package) receives the protobuf messages as Go structs directly.

When running an external dataplane driver, the main process creates a pair of communication pipes, before forking to start the configured dataplane driver. The dataplane driver receives messages on file descriptor 3 and sends on descriptor 4. The wire format is described in a section below. The dataplane driver has the same lifetime as the main process.

In either case, the protocol (described in more detail below) starts with a handshake to exchange configuration. Then the calculation engine begins its resync with the datastore, emitting updates as it scans through the current state. Once complete, the calculation engine enters the "in-sync" state and starts sending only updates. Updates are asynchronous, with no explicit acknowledgement for each message.

The dataplane driver should send status updates for itself and the endpoints that it is controlling.

Handshake

Before sending its stream of updates, the calculation engine loads and resolves the configuration (from file, environment variables and the datastore) and then sends a ConfigUpdate message with the resolved configuration. This ensures that the driver has the configuration before it receives any updates.

Note: the calculation engine doesn't currently support any subsequent config updates. If the config is updated after the process is running, it will trigger a process exit, so that the init system can restart it.

Resync and updates

After the initial ConfigUpdate message, the protocol is in resync state. The calculation engine will send a stream of updates that merges the current state of the datastore along with any updates that occur later. The stream is guaranteed to be eventually consistent. I.e. if a resource is updated (or deleted) during the resync then the calculation engine is free to skip the intermediate value and send only one update with the most up-to-date value (or none if the object was deleted).

Updates are sent to the dataplane driver in dependency order. I.e. dependencies are sent before the objects that depend on them. Removes are sent in reverse dependency order so the dataplane driver will not receive a remove for an object that is still required.

Once the calculation engine has finished its initial datastore scan, it sends the InSync message.

For simplicity and robustness, most <Type>Update messages contain the complete current state of the resource that they refer to. However, for performance, IP set updates are communicated as an initial IPSetUpdate, followed by a sequence of IPSetDeltaUpdate messages.

Graceful restart

During the resync, the dataplane driver is likely to have an incomplete picture of the desired state of the dataplane. If it started programming the dataplane immediately, message-by-message after a restart then it may disrupt connectivity to already-configured workloads. To prevent this, the dataplane driver should delay programming of potentially incorrect state until after it receives the InSync message.

Driver status updates

The driver should send a ProcessStatusUpdate message every 10s to verify its liveness. That message flows through to the datastore and some orchestrators (such as OpenStack) rely on the status messages to make scheduling decisions.

Endpoint status updates

The driver should report the status for each endpoint that it is managing and update the status when it changes. The driver does not need to periodically refresh the endpoint statuses, the "main" process caches the values and keeps the datastore in sync.

Once an endpoint is removed, the dataplane driver should send an XXXEndpointStatusRemove message so the calculation engine can clear up its cache entry.

Special cases

Due to coalescing of updates in the calculation engine, the dataplane driver may receive Remove messages for resources that it didn't previously receive an Update for; it should ignore such Remove messages.

Illustration

The protocol flow is illustrated below.

+-----------+                                             +-------+
| dp_driver |                                             | main  |
+-----------+                                             +-------+
      |                                                       |
      |                                            **Create** |
      |<------------------------------------------------------|
      |               --------------------------------------\ |
      |               | Connects to datastore, loads config |-|
      |               |-------------------------------------| |
      |                                                       |
      |                         ConfigUpdate(resolved config) |
      |<------------------------------------------------------|
      | --------------------------------------------------\   |
      |-| Start graceful restart, avoid removing DP state |   |
      | |-------------------------------------------------|   |
      |                                                       |
      |                     DatastoreStatus("wait-for-ready") |
      |<------------------------------------------------------|
      |                   ----------------------------------\ |
      |                   | Starts  resync, sending updates |-|
      |                   |---------------------------------| |
      |                                                       |
      |                             DatastoreStatus("resync") |
      |<------------------------------------------------------|
      |                                                       |
      |                      IPSet(Update|DeltaUpdate|Remove) |
      |<------------------------------------------------------|
      |                                                       |
      |                 Active(Profile|Policy)(Update|Remove) |
      |<------------------------------------------------------|
      |                                                       |
      |                (Workload|Host)Endpoint(Update|Remove) |
      |<------------------------------------------------------|
      |                                     ----------------\ |
      |                                     | Finishes sync |-|
      |                                     |---------------| |
      |                                                       |
      |                            DatastoreStatus("in-sync") |
      |<------------------------------------------------------|
      | -----------------------------------------\            |
      |-| Finish graceful restart, do DP cleanup |            |
      | |----------------------------------------|            |
      |                                                       |
      |                      IPSet(Update|DeltaUpdate|Remove) |
      |<------------------------------------------------------|
      |                                                       |
      |                 Active(Profile|Policy)(Update|Remove) |
      |<------------------------------------------------------|
      |                                                       |
      |                (Workload|Host)Endpoint(Update|Remove) |
      |<------------------------------------------------------|
      |                                                       |
      |                           HostMetadata(Update|Remove) |
      |<------------------------------------------------------|
      |                                                       |
      |                               IPAMPool(Update|Remove) |
      |<------------------------------------------------------|
      | ------------------------------------\                 |
      |-| Status updates (sent at any time) |                 |
      | |-----------------------------------|                 |
      |                                                       |
      | ProcessStatusUpdate                                   |
      |------------------------------------------------------>|
      |                                                       |
      | (Workload|Host)EndpointStatus                         |
      |------------------------------------------------------>|
      |                                                       |

Example

The sequence diagram below illustrates a scenario where the initial resync finds one local endpoint, then a new endpoint is added, an IP set updated and the endpoints removed.

+-----------+                                                             +-------+
| dp_driver |                                                             | main  |
+-----------+                                                             +-------+
      |                                                                       |
      |                                                            **Create** |
      |<----------------------------------------------------------------------|
      |                                                 --------------------\ |
      |                                                 | Initial handshake |-|
      |                                                 |-------------------| |
      |                                                                       |
      |                                         ConfigUpdate(resolved config) |
      |<----------------------------------------------------------------------|
      |                                                                       |
      |                                     DatastoreStatus("wait-for-ready") |
      |<----------------------------------------------------------------------|
      |                                                                       |
      |                                             DatastoreStatus("resync") |
      |<----------------------------------------------------------------------|
      |       --------------------------------------------------------------\ |
      |       | Loads state: finds one active endpoint on host, one policy, |-|
      |       | using one IP set. Sends updates in dependency order:        | |
      |       |-------------------------------------------------------------| |
      |                             IPSetUpdate("setABCD", ["10.0.0.1", ...]) |
      |<----------------------------------------------------------------------|
      |                                                                       |
      |     ActivePolicyUpdate({inbound_rules: [...], outbound_rules: [...]}) |
      |<----------------------------------------------------------------------|
      |                                                                       |
      |                          WorkloadEndpointUpdate("endpoint1", { ... }) |
      |<----------------------------------------------------------------------|
      |                                      -------------------------------\ |
      |                                      | Finishes sync with datastore |-|
      |                                      |------------------------------| |
      |                                                                       |
      |                                            DatastoreStatus("in-sync") |
      |<----------------------------------------------------------------------|
      | ---------------------------------------------------\                  |
      |-| Now in sync, program dataplane for first time.   |                  |
      | | Do any cleanup of old state, send status updates |                  |
      | |--------------------------------------------------|                  |
      | WorkloadEndpointStatusUpdate("endpoint1", "up")                       |
      |---------------------------------------------------------------------->|
      | ---------------------------------------------\                        |
      |-| Every 10s, send a process status update... |                        |
      | |--------------------------------------------|                        |
      |                                                                       |
      | ProcessStatusUpdate({uptime=...})                                     |
      |---------------------------------------------------------------------->|
      |                        ---------------------------------------------\ |
      |                        | Told about new endpoint, using same policy |-|
      |                        |--------------------------------------------| |
      |                                                                       |
      |                          WorkloadEndpointUpdate("endpoint2", { ... }) |
      |<----------------------------------------------------------------------|
      | ---------------------\                                                |
      |-| Programs dataplane |                                                |
      | |--------------------|                                                |
      |                                                                       |
      | WorkloadEndpointStatusUpdate("endpoint2", "up")                       |
      |---------------------------------------------------------------------->|
      |                                              -----------------------\ |
      |                                              | New IP in the IP set |-|
      |                                              |----------------------| |
      |                                                                       |
      |                 IPSetDeltaUpdate("setABCD", {added_ips=["10.0.0.2"]}) |
      |<----------------------------------------------------------------------|
      | ---------------------\                                                |
      |-| Programs dataplane |                                                |
      | |--------------------|                                                |
      |                        ---------------------------------------------\ |
      |                        | Endpoints deleted, policy no longer active |-|
      |                        | Removes in reverse dependency order:       | |
      |                        |--------------------------------------------| |
      |                                   WorkloadEndpointRemove("endpoint1") |
      |<----------------------------------------------------------------------|
      |                                                                       |
      |                                   WorkloadEndpointRemove("endpoint2") |
      |<----------------------------------------------------------------------|
      |                                                                       |
      |                                            ActivePolicyRemove("polA") |
      |<----------------------------------------------------------------------|
      |                                                                       |
      |                                                IPSetRemove("setABCD") |
      |<----------------------------------------------------------------------|
      |                                                                       |
      | WorkloadEndpointStatusRemove("endpoint1")                             |
      |---------------------------------------------------------------------->|
      |                                                                       |
      | WorkloadEndpointStatusRemove("endpoint2")                             |
      |---------------------------------------------------------------------->|
      |                                                                       |

Wire format for external dataplane driver

The protocol between the driver and main process is protobuf based. On the wire, each message consists of an 8-byte, little-endian length, followed by a ToDataplane or FromDataplane protobuf envelope message. The length refers to the length of the protobuf data only, it doesn't include the 8-byte length header.

+---------------+--------------------------------------------+
| 8-byte length | Protobuf ToDataplane/FromDataplane message |
+---------------+--------------------------------------------+

Package proto is a generated protocol buffer package.

It is generated from these files:
	felixbackend.proto

It has these top-level messages:
	SyncRequest
	ToDataplane
	FromDataplane
	ConfigUpdate
	InSync
	IPSetUpdate
	IPSetDeltaUpdate
	IPSetRemove
	ActiveProfileUpdate
	ActiveProfileRemove
	ProfileID
	Profile
	ActivePolicyUpdate
	ActivePolicyRemove
	PolicyID
	Policy
	Rule
	ServiceAccountMatch
	HTTPMatch
	IcmpTypeAndCode
	Protocol
	PortRange
	WorkloadEndpointID
	WorkloadEndpointUpdate
	WorkloadEndpoint
	WorkloadEndpointRemove
	HostEndpointID
	HostEndpointUpdate
	HostEndpoint
	HostEndpointRemove
	TierInfo
	NatInfo
	ProcessStatusUpdate
	HostEndpointStatusUpdate
	EndpointStatus
	HostEndpointStatusRemove
	WorkloadEndpointStatusUpdate
	WorkloadEndpointStatusRemove
	HostMetadataUpdate
	HostMetadataRemove
	IPAMPoolUpdate
	IPAMPoolRemove
	IPAMPool
	ServiceAccountUpdate
	ServiceAccountRemove
	ServiceAccountID
	NamespaceUpdate
	NamespaceRemove
	NamespaceID
	RouteUpdate
	RouteRemove
	VXLANTunnelEndpointUpdate
	VXLANTunnelEndpointRemove

Index

Constants

This section is empty.

Variables

View Source
var (
	ErrInvalidLengthFelixbackend = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowFelixbackend   = fmt.Errorf("proto: integer overflow")
)
View Source
var IPSetUpdate_IPSetType_name = map[int32]string{
	0: "IP",
	1: "IP_AND_PORT",
	2: "NET",
}
View Source
var IPSetUpdate_IPSetType_value = map[string]int32{
	"IP":          0,
	"IP_AND_PORT": 1,
	"NET":         2,
}
View Source
var IPVersion_name = map[int32]string{
	0: "ANY",
	4: "IPV4",
	6: "IPV6",
}
View Source
var IPVersion_value = map[string]int32{
	"ANY":  0,
	"IPV4": 4,
	"IPV6": 6,
}
View Source
var RouteType_name = map[int32]string{
	0: "VXLAN",
}
View Source
var RouteType_value = map[string]int32{
	"VXLAN": 0,
}

Functions

func RegisterPolicySyncServer

func RegisterPolicySyncServer(s *grpc.Server, srv PolicySyncServer)

Types

type ActivePolicyRemove

type ActivePolicyRemove struct {
	Id *PolicyID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
}

func (*ActivePolicyRemove) Descriptor

func (*ActivePolicyRemove) Descriptor() ([]byte, []int)

func (*ActivePolicyRemove) GetId

func (m *ActivePolicyRemove) GetId() *PolicyID

func (*ActivePolicyRemove) Marshal

func (m *ActivePolicyRemove) Marshal() (dAtA []byte, err error)

func (*ActivePolicyRemove) MarshalTo

func (m *ActivePolicyRemove) MarshalTo(dAtA []byte) (int, error)

func (*ActivePolicyRemove) ProtoMessage

func (*ActivePolicyRemove) ProtoMessage()

func (*ActivePolicyRemove) Reset

func (m *ActivePolicyRemove) Reset()

func (*ActivePolicyRemove) Size

func (m *ActivePolicyRemove) Size() (n int)

func (*ActivePolicyRemove) String

func (m *ActivePolicyRemove) String() string

func (*ActivePolicyRemove) Unmarshal

func (m *ActivePolicyRemove) Unmarshal(dAtA []byte) error

type ActivePolicyUpdate

type ActivePolicyUpdate struct {
	Id     *PolicyID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
	Policy *Policy   `protobuf:"bytes,2,opt,name=policy" json:"policy,omitempty"`
}

func (*ActivePolicyUpdate) Descriptor

func (*ActivePolicyUpdate) Descriptor() ([]byte, []int)

func (*ActivePolicyUpdate) GetId

func (m *ActivePolicyUpdate) GetId() *PolicyID

func (*ActivePolicyUpdate) GetPolicy

func (m *ActivePolicyUpdate) GetPolicy() *Policy

func (*ActivePolicyUpdate) Marshal

func (m *ActivePolicyUpdate) Marshal() (dAtA []byte, err error)

func (*ActivePolicyUpdate) MarshalTo

func (m *ActivePolicyUpdate) MarshalTo(dAtA []byte) (int, error)

func (*ActivePolicyUpdate) ProtoMessage

func (*ActivePolicyUpdate) ProtoMessage()

func (*ActivePolicyUpdate) Reset

func (m *ActivePolicyUpdate) Reset()

func (*ActivePolicyUpdate) Size

func (m *ActivePolicyUpdate) Size() (n int)

func (*ActivePolicyUpdate) String

func (m *ActivePolicyUpdate) String() string

func (*ActivePolicyUpdate) Unmarshal

func (m *ActivePolicyUpdate) Unmarshal(dAtA []byte) error

type ActiveProfileRemove

type ActiveProfileRemove struct {
	Id *ProfileID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
}

func (*ActiveProfileRemove) Descriptor

func (*ActiveProfileRemove) Descriptor() ([]byte, []int)

func (*ActiveProfileRemove) GetId

func (m *ActiveProfileRemove) GetId() *ProfileID

func (*ActiveProfileRemove) Marshal

func (m *ActiveProfileRemove) Marshal() (dAtA []byte, err error)

func (*ActiveProfileRemove) MarshalTo

func (m *ActiveProfileRemove) MarshalTo(dAtA []byte) (int, error)

func (*ActiveProfileRemove) ProtoMessage

func (*ActiveProfileRemove) ProtoMessage()

func (*ActiveProfileRemove) Reset

func (m *ActiveProfileRemove) Reset()

func (*ActiveProfileRemove) Size

func (m *ActiveProfileRemove) Size() (n int)

func (*ActiveProfileRemove) String

func (m *ActiveProfileRemove) String() string

func (*ActiveProfileRemove) Unmarshal

func (m *ActiveProfileRemove) Unmarshal(dAtA []byte) error

type ActiveProfileUpdate

type ActiveProfileUpdate struct {
	Id      *ProfileID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
	Profile *Profile   `protobuf:"bytes,2,opt,name=profile" json:"profile,omitempty"`
}

func (*ActiveProfileUpdate) Descriptor

func (*ActiveProfileUpdate) Descriptor() ([]byte, []int)

func (*ActiveProfileUpdate) GetId

func (m *ActiveProfileUpdate) GetId() *ProfileID

func (*ActiveProfileUpdate) GetProfile

func (m *ActiveProfileUpdate) GetProfile() *Profile

func (*ActiveProfileUpdate) Marshal

func (m *ActiveProfileUpdate) Marshal() (dAtA []byte, err error)

func (*ActiveProfileUpdate) MarshalTo

func (m *ActiveProfileUpdate) MarshalTo(dAtA []byte) (int, error)

func (*ActiveProfileUpdate) ProtoMessage

func (*ActiveProfileUpdate) ProtoMessage()

func (*ActiveProfileUpdate) Reset

func (m *ActiveProfileUpdate) Reset()

func (*ActiveProfileUpdate) Size

func (m *ActiveProfileUpdate) Size() (n int)

func (*ActiveProfileUpdate) String

func (m *ActiveProfileUpdate) String() string

func (*ActiveProfileUpdate) Unmarshal

func (m *ActiveProfileUpdate) Unmarshal(dAtA []byte) error

type ConfigUpdate

type ConfigUpdate struct {
	Config map[string]string `` /* 146-byte string literal not displayed */
}

func (*ConfigUpdate) Descriptor

func (*ConfigUpdate) Descriptor() ([]byte, []int)

func (*ConfigUpdate) GetConfig

func (m *ConfigUpdate) GetConfig() map[string]string

func (*ConfigUpdate) Marshal

func (m *ConfigUpdate) Marshal() (dAtA []byte, err error)

func (*ConfigUpdate) MarshalTo

func (m *ConfigUpdate) MarshalTo(dAtA []byte) (int, error)

func (*ConfigUpdate) ProtoMessage

func (*ConfigUpdate) ProtoMessage()

func (*ConfigUpdate) Reset

func (m *ConfigUpdate) Reset()

func (*ConfigUpdate) Size

func (m *ConfigUpdate) Size() (n int)

func (*ConfigUpdate) String

func (m *ConfigUpdate) String() string

func (*ConfigUpdate) Unmarshal

func (m *ConfigUpdate) Unmarshal(dAtA []byte) error

type EndpointStatus

type EndpointStatus struct {
	Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
}

func (*EndpointStatus) Descriptor

func (*EndpointStatus) Descriptor() ([]byte, []int)

func (*EndpointStatus) GetStatus

func (m *EndpointStatus) GetStatus() string

func (*EndpointStatus) Marshal

func (m *EndpointStatus) Marshal() (dAtA []byte, err error)

func (*EndpointStatus) MarshalTo

func (m *EndpointStatus) MarshalTo(dAtA []byte) (int, error)

func (*EndpointStatus) ProtoMessage

func (*EndpointStatus) ProtoMessage()

func (*EndpointStatus) Reset

func (m *EndpointStatus) Reset()

func (*EndpointStatus) Size

func (m *EndpointStatus) Size() (n int)

func (*EndpointStatus) String

func (m *EndpointStatus) String() string

func (*EndpointStatus) Unmarshal

func (m *EndpointStatus) Unmarshal(dAtA []byte) error

type FromDataplane

type FromDataplane struct {
	SequenceNumber uint64 `protobuf:"varint,8,opt,name=sequence_number,json=sequenceNumber,proto3" json:"sequence_number,omitempty"`
	// Types that are valid to be assigned to Payload:
	//	*FromDataplane_ProcessStatusUpdate
	//	*FromDataplane_HostEndpointStatusUpdate
	//	*FromDataplane_HostEndpointStatusRemove
	//	*FromDataplane_WorkloadEndpointStatusUpdate
	//	*FromDataplane_WorkloadEndpointStatusRemove
	Payload isFromDataplane_Payload `protobuf_oneof:"payload"`
}

func (*FromDataplane) Descriptor

func (*FromDataplane) Descriptor() ([]byte, []int)

func (*FromDataplane) GetHostEndpointStatusRemove

func (m *FromDataplane) GetHostEndpointStatusRemove() *HostEndpointStatusRemove

func (*FromDataplane) GetHostEndpointStatusUpdate

func (m *FromDataplane) GetHostEndpointStatusUpdate() *HostEndpointStatusUpdate

func (*FromDataplane) GetPayload

func (m *FromDataplane) GetPayload() isFromDataplane_Payload

func (*FromDataplane) GetProcessStatusUpdate

func (m *FromDataplane) GetProcessStatusUpdate() *ProcessStatusUpdate

func (*FromDataplane) GetSequenceNumber

func (m *FromDataplane) GetSequenceNumber() uint64

func (*FromDataplane) GetWorkloadEndpointStatusRemove

func (m *FromDataplane) GetWorkloadEndpointStatusRemove() *WorkloadEndpointStatusRemove

func (*FromDataplane) GetWorkloadEndpointStatusUpdate

func (m *FromDataplane) GetWorkloadEndpointStatusUpdate() *WorkloadEndpointStatusUpdate

func (*FromDataplane) Marshal

func (m *FromDataplane) Marshal() (dAtA []byte, err error)

func (*FromDataplane) MarshalTo

func (m *FromDataplane) MarshalTo(dAtA []byte) (int, error)

func (*FromDataplane) ProtoMessage

func (*FromDataplane) ProtoMessage()

func (*FromDataplane) Reset

func (m *FromDataplane) Reset()

func (*FromDataplane) Size

func (m *FromDataplane) Size() (n int)

func (*FromDataplane) String

func (m *FromDataplane) String() string

func (*FromDataplane) Unmarshal

func (m *FromDataplane) Unmarshal(dAtA []byte) error

func (*FromDataplane) XXX_OneofFuncs

func (*FromDataplane) XXX_OneofFuncs() (func(msg proto1.Message, b *proto1.Buffer) error, func(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error), func(msg proto1.Message) (n int), []interface{})

XXX_OneofFuncs is for the internal use of the proto package.

type FromDataplane_HostEndpointStatusRemove

type FromDataplane_HostEndpointStatusRemove struct {
	HostEndpointStatusRemove *HostEndpointStatusRemove `protobuf:"bytes,5,opt,name=host_endpoint_status_remove,json=hostEndpointStatusRemove,oneof"`
}

func (*FromDataplane_HostEndpointStatusRemove) MarshalTo

func (m *FromDataplane_HostEndpointStatusRemove) MarshalTo(dAtA []byte) (int, error)

func (*FromDataplane_HostEndpointStatusRemove) Size

type FromDataplane_HostEndpointStatusUpdate

type FromDataplane_HostEndpointStatusUpdate struct {
	HostEndpointStatusUpdate *HostEndpointStatusUpdate `protobuf:"bytes,4,opt,name=host_endpoint_status_update,json=hostEndpointStatusUpdate,oneof"`
}

func (*FromDataplane_HostEndpointStatusUpdate) MarshalTo

func (m *FromDataplane_HostEndpointStatusUpdate) MarshalTo(dAtA []byte) (int, error)

func (*FromDataplane_HostEndpointStatusUpdate) Size

type FromDataplane_ProcessStatusUpdate

type FromDataplane_ProcessStatusUpdate struct {
	ProcessStatusUpdate *ProcessStatusUpdate `protobuf:"bytes,3,opt,name=process_status_update,json=processStatusUpdate,oneof"`
}

func (*FromDataplane_ProcessStatusUpdate) MarshalTo

func (m *FromDataplane_ProcessStatusUpdate) MarshalTo(dAtA []byte) (int, error)

func (*FromDataplane_ProcessStatusUpdate) Size

func (m *FromDataplane_ProcessStatusUpdate) Size() (n int)

type FromDataplane_WorkloadEndpointStatusRemove

type FromDataplane_WorkloadEndpointStatusRemove struct {
	WorkloadEndpointStatusRemove *WorkloadEndpointStatusRemove `protobuf:"bytes,7,opt,name=workload_endpoint_status_remove,json=workloadEndpointStatusRemove,oneof"`
}

func (*FromDataplane_WorkloadEndpointStatusRemove) MarshalTo

func (m *FromDataplane_WorkloadEndpointStatusRemove) MarshalTo(dAtA []byte) (int, error)

func (*FromDataplane_WorkloadEndpointStatusRemove) Size

type FromDataplane_WorkloadEndpointStatusUpdate

type FromDataplane_WorkloadEndpointStatusUpdate struct {
	WorkloadEndpointStatusUpdate *WorkloadEndpointStatusUpdate `protobuf:"bytes,6,opt,name=workload_endpoint_status_update,json=workloadEndpointStatusUpdate,oneof"`
}

func (*FromDataplane_WorkloadEndpointStatusUpdate) MarshalTo

func (m *FromDataplane_WorkloadEndpointStatusUpdate) MarshalTo(dAtA []byte) (int, error)

func (*FromDataplane_WorkloadEndpointStatusUpdate) Size

type HTTPMatch

type HTTPMatch struct {
	Methods []string               `protobuf:"bytes,1,rep,name=methods" json:"methods,omitempty"`
	Paths   []*HTTPMatch_PathMatch `protobuf:"bytes,2,rep,name=paths" json:"paths,omitempty"`
}

func (*HTTPMatch) Descriptor

func (*HTTPMatch) Descriptor() ([]byte, []int)

func (*HTTPMatch) GetMethods

func (m *HTTPMatch) GetMethods() []string

func (*HTTPMatch) GetPaths

func (m *HTTPMatch) GetPaths() []*HTTPMatch_PathMatch

func (*HTTPMatch) Marshal

func (m *HTTPMatch) Marshal() (dAtA []byte, err error)

func (*HTTPMatch) MarshalTo

func (m *HTTPMatch) MarshalTo(dAtA []byte) (int, error)

func (*HTTPMatch) ProtoMessage

func (*HTTPMatch) ProtoMessage()

func (*HTTPMatch) Reset

func (m *HTTPMatch) Reset()

func (*HTTPMatch) Size

func (m *HTTPMatch) Size() (n int)

func (*HTTPMatch) String

func (m *HTTPMatch) String() string

func (*HTTPMatch) Unmarshal

func (m *HTTPMatch) Unmarshal(dAtA []byte) error

type HTTPMatch_PathMatch

type HTTPMatch_PathMatch struct {
	// Types that are valid to be assigned to PathMatch:
	//	*HTTPMatch_PathMatch_Exact
	//	*HTTPMatch_PathMatch_Prefix
	PathMatch isHTTPMatch_PathMatch_PathMatch `protobuf_oneof:"path_match"`
}

func (*HTTPMatch_PathMatch) Descriptor

func (*HTTPMatch_PathMatch) Descriptor() ([]byte, []int)

func (*HTTPMatch_PathMatch) GetExact

func (m *HTTPMatch_PathMatch) GetExact() string

func (*HTTPMatch_PathMatch) GetPathMatch

func (m *HTTPMatch_PathMatch) GetPathMatch() isHTTPMatch_PathMatch_PathMatch

func (*HTTPMatch_PathMatch) GetPrefix

func (m *HTTPMatch_PathMatch) GetPrefix() string

func (*HTTPMatch_PathMatch) Marshal

func (m *HTTPMatch_PathMatch) Marshal() (dAtA []byte, err error)

func (*HTTPMatch_PathMatch) MarshalTo

func (m *HTTPMatch_PathMatch) MarshalTo(dAtA []byte) (int, error)

func (*HTTPMatch_PathMatch) ProtoMessage

func (*HTTPMatch_PathMatch) ProtoMessage()

func (*HTTPMatch_PathMatch) Reset

func (m *HTTPMatch_PathMatch) Reset()

func (*HTTPMatch_PathMatch) Size

func (m *HTTPMatch_PathMatch) Size() (n int)

func (*HTTPMatch_PathMatch) String

func (m *HTTPMatch_PathMatch) String() string

func (*HTTPMatch_PathMatch) Unmarshal

func (m *HTTPMatch_PathMatch) Unmarshal(dAtA []byte) error

func (*HTTPMatch_PathMatch) XXX_OneofFuncs

func (*HTTPMatch_PathMatch) XXX_OneofFuncs() (func(msg proto1.Message, b *proto1.Buffer) error, func(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error), func(msg proto1.Message) (n int), []interface{})

XXX_OneofFuncs is for the internal use of the proto package.

type HTTPMatch_PathMatch_Exact

type HTTPMatch_PathMatch_Exact struct {
	Exact string `protobuf:"bytes,1,opt,name=exact,proto3,oneof"`
}

func (*HTTPMatch_PathMatch_Exact) MarshalTo

func (m *HTTPMatch_PathMatch_Exact) MarshalTo(dAtA []byte) (int, error)

func (*HTTPMatch_PathMatch_Exact) Size

func (m *HTTPMatch_PathMatch_Exact) Size() (n int)

type HTTPMatch_PathMatch_Prefix

type HTTPMatch_PathMatch_Prefix struct {
	Prefix string `protobuf:"bytes,2,opt,name=prefix,proto3,oneof"`
}

func (*HTTPMatch_PathMatch_Prefix) MarshalTo

func (m *HTTPMatch_PathMatch_Prefix) MarshalTo(dAtA []byte) (int, error)

func (*HTTPMatch_PathMatch_Prefix) Size

func (m *HTTPMatch_PathMatch_Prefix) Size() (n int)

type HostEndpoint

type HostEndpoint struct {
	Name              string      `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	ProfileIds        []string    `protobuf:"bytes,2,rep,name=profile_ids,json=profileIds" json:"profile_ids,omitempty"`
	Tiers             []*TierInfo `protobuf:"bytes,3,rep,name=tiers" json:"tiers,omitempty"`
	UntrackedTiers    []*TierInfo `protobuf:"bytes,6,rep,name=untracked_tiers,json=untrackedTiers" json:"untracked_tiers,omitempty"`
	PreDnatTiers      []*TierInfo `protobuf:"bytes,7,rep,name=pre_dnat_tiers,json=preDnatTiers" json:"pre_dnat_tiers,omitempty"`
	ForwardTiers      []*TierInfo `protobuf:"bytes,8,rep,name=forward_tiers,json=forwardTiers" json:"forward_tiers,omitempty"`
	ExpectedIpv4Addrs []string    `protobuf:"bytes,4,rep,name=expected_ipv4_addrs,json=expectedIpv4Addrs" json:"expected_ipv4_addrs,omitempty"`
	ExpectedIpv6Addrs []string    `protobuf:"bytes,5,rep,name=expected_ipv6_addrs,json=expectedIpv6Addrs" json:"expected_ipv6_addrs,omitempty"`
}

func (*HostEndpoint) Descriptor

func (*HostEndpoint) Descriptor() ([]byte, []int)

func (*HostEndpoint) GetExpectedIpv4Addrs

func (m *HostEndpoint) GetExpectedIpv4Addrs() []string

func (*HostEndpoint) GetExpectedIpv6Addrs

func (m *HostEndpoint) GetExpectedIpv6Addrs() []string

func (*HostEndpoint) GetForwardTiers

func (m *HostEndpoint) GetForwardTiers() []*TierInfo

func (*HostEndpoint) GetName

func (m *HostEndpoint) GetName() string

func (*HostEndpoint) GetPreDnatTiers

func (m *HostEndpoint) GetPreDnatTiers() []*TierInfo

func (*HostEndpoint) GetProfileIds

func (m *HostEndpoint) GetProfileIds() []string

func (*HostEndpoint) GetTiers

func (m *HostEndpoint) GetTiers() []*TierInfo

func (*HostEndpoint) GetUntrackedTiers

func (m *HostEndpoint) GetUntrackedTiers() []*TierInfo

func (*HostEndpoint) Marshal

func (m *HostEndpoint) Marshal() (dAtA []byte, err error)

func (*HostEndpoint) MarshalTo

func (m *HostEndpoint) MarshalTo(dAtA []byte) (int, error)

func (*HostEndpoint) ProtoMessage

func (*HostEndpoint) ProtoMessage()

func (*HostEndpoint) Reset

func (m *HostEndpoint) Reset()

func (*HostEndpoint) Size

func (m *HostEndpoint) Size() (n int)

func (*HostEndpoint) String

func (m *HostEndpoint) String() string

func (*HostEndpoint) Unmarshal

func (m *HostEndpoint) Unmarshal(dAtA []byte) error

type HostEndpointID

type HostEndpointID struct {
	EndpointId string `protobuf:"bytes,2,opt,name=endpoint_id,json=endpointId,proto3" json:"endpoint_id,omitempty"`
}

func (*HostEndpointID) Descriptor

func (*HostEndpointID) Descriptor() ([]byte, []int)

func (*HostEndpointID) GetEndpointId

func (m *HostEndpointID) GetEndpointId() string

func (*HostEndpointID) Marshal

func (m *HostEndpointID) Marshal() (dAtA []byte, err error)

func (*HostEndpointID) MarshalTo

func (m *HostEndpointID) MarshalTo(dAtA []byte) (int, error)

func (*HostEndpointID) ProtoMessage

func (*HostEndpointID) ProtoMessage()

func (*HostEndpointID) Reset

func (m *HostEndpointID) Reset()

func (*HostEndpointID) Size

func (m *HostEndpointID) Size() (n int)

func (*HostEndpointID) String

func (m *HostEndpointID) String() string

func (*HostEndpointID) Unmarshal

func (m *HostEndpointID) Unmarshal(dAtA []byte) error

type HostEndpointRemove

type HostEndpointRemove struct {
	Id *HostEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
}

func (*HostEndpointRemove) Descriptor

func (*HostEndpointRemove) Descriptor() ([]byte, []int)

func (*HostEndpointRemove) GetId

func (m *HostEndpointRemove) GetId() *HostEndpointID

func (*HostEndpointRemove) Marshal

func (m *HostEndpointRemove) Marshal() (dAtA []byte, err error)

func (*HostEndpointRemove) MarshalTo

func (m *HostEndpointRemove) MarshalTo(dAtA []byte) (int, error)

func (*HostEndpointRemove) ProtoMessage

func (*HostEndpointRemove) ProtoMessage()

func (*HostEndpointRemove) Reset

func (m *HostEndpointRemove) Reset()

func (*HostEndpointRemove) Size

func (m *HostEndpointRemove) Size() (n int)

func (*HostEndpointRemove) String

func (m *HostEndpointRemove) String() string

func (*HostEndpointRemove) Unmarshal

func (m *HostEndpointRemove) Unmarshal(dAtA []byte) error

type HostEndpointStatusRemove

type HostEndpointStatusRemove struct {
	Id *HostEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
}

func (*HostEndpointStatusRemove) Descriptor

func (*HostEndpointStatusRemove) Descriptor() ([]byte, []int)

func (*HostEndpointStatusRemove) GetId

func (*HostEndpointStatusRemove) Marshal

func (m *HostEndpointStatusRemove) Marshal() (dAtA []byte, err error)

func (*HostEndpointStatusRemove) MarshalTo

func (m *HostEndpointStatusRemove) MarshalTo(dAtA []byte) (int, error)

func (*HostEndpointStatusRemove) ProtoMessage

func (*HostEndpointStatusRemove) ProtoMessage()

func (*HostEndpointStatusRemove) Reset

func (m *HostEndpointStatusRemove) Reset()

func (*HostEndpointStatusRemove) Size

func (m *HostEndpointStatusRemove) Size() (n int)

func (*HostEndpointStatusRemove) String

func (m *HostEndpointStatusRemove) String() string

func (*HostEndpointStatusRemove) Unmarshal

func (m *HostEndpointStatusRemove) Unmarshal(dAtA []byte) error

type HostEndpointStatusUpdate

type HostEndpointStatusUpdate struct {
	Id     *HostEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
	Status *EndpointStatus `protobuf:"bytes,2,opt,name=status" json:"status,omitempty"`
}

func (*HostEndpointStatusUpdate) Descriptor

func (*HostEndpointStatusUpdate) Descriptor() ([]byte, []int)

func (*HostEndpointStatusUpdate) GetId

func (*HostEndpointStatusUpdate) GetStatus

func (m *HostEndpointStatusUpdate) GetStatus() *EndpointStatus

func (*HostEndpointStatusUpdate) Marshal

func (m *HostEndpointStatusUpdate) Marshal() (dAtA []byte, err error)

func (*HostEndpointStatusUpdate) MarshalTo

func (m *HostEndpointStatusUpdate) MarshalTo(dAtA []byte) (int, error)

func (*HostEndpointStatusUpdate) ProtoMessage

func (*HostEndpointStatusUpdate) ProtoMessage()

func (*HostEndpointStatusUpdate) Reset

func (m *HostEndpointStatusUpdate) Reset()

func (*HostEndpointStatusUpdate) Size

func (m *HostEndpointStatusUpdate) Size() (n int)

func (*HostEndpointStatusUpdate) String

func (m *HostEndpointStatusUpdate) String() string

func (*HostEndpointStatusUpdate) Unmarshal

func (m *HostEndpointStatusUpdate) Unmarshal(dAtA []byte) error

type HostEndpointUpdate

type HostEndpointUpdate struct {
	Id       *HostEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
	Endpoint *HostEndpoint   `protobuf:"bytes,3,opt,name=endpoint" json:"endpoint,omitempty"`
}

func (*HostEndpointUpdate) Descriptor

func (*HostEndpointUpdate) Descriptor() ([]byte, []int)

func (*HostEndpointUpdate) GetEndpoint

func (m *HostEndpointUpdate) GetEndpoint() *HostEndpoint

func (*HostEndpointUpdate) GetId

func (m *HostEndpointUpdate) GetId() *HostEndpointID

func (*HostEndpointUpdate) Marshal

func (m *HostEndpointUpdate) Marshal() (dAtA []byte, err error)

func (*HostEndpointUpdate) MarshalTo

func (m *HostEndpointUpdate) MarshalTo(dAtA []byte) (int, error)

func (*HostEndpointUpdate) ProtoMessage

func (*HostEndpointUpdate) ProtoMessage()

func (*HostEndpointUpdate) Reset

func (m *HostEndpointUpdate) Reset()

func (*HostEndpointUpdate) Size

func (m *HostEndpointUpdate) Size() (n int)

func (*HostEndpointUpdate) String

func (m *HostEndpointUpdate) String() string

func (*HostEndpointUpdate) Unmarshal

func (m *HostEndpointUpdate) Unmarshal(dAtA []byte) error

type HostMetadataRemove

type HostMetadataRemove struct {
	Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"`
	Ipv4Addr string `protobuf:"bytes,2,opt,name=ipv4_addr,json=ipv4Addr,proto3" json:"ipv4_addr,omitempty"`
}

func (*HostMetadataRemove) Descriptor

func (*HostMetadataRemove) Descriptor() ([]byte, []int)

func (*HostMetadataRemove) GetHostname

func (m *HostMetadataRemove) GetHostname() string

func (*HostMetadataRemove) GetIpv4Addr

func (m *HostMetadataRemove) GetIpv4Addr() string

func (*HostMetadataRemove) Marshal

func (m *HostMetadataRemove) Marshal() (dAtA []byte, err error)

func (*HostMetadataRemove) MarshalTo

func (m *HostMetadataRemove) MarshalTo(dAtA []byte) (int, error)

func (*HostMetadataRemove) ProtoMessage

func (*HostMetadataRemove) ProtoMessage()

func (*HostMetadataRemove) Reset

func (m *HostMetadataRemove) Reset()

func (*HostMetadataRemove) Size

func (m *HostMetadataRemove) Size() (n int)

func (*HostMetadataRemove) String

func (m *HostMetadataRemove) String() string

func (*HostMetadataRemove) Unmarshal

func (m *HostMetadataRemove) Unmarshal(dAtA []byte) error

type HostMetadataUpdate

type HostMetadataUpdate struct {
	Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"`
	Ipv4Addr string `protobuf:"bytes,2,opt,name=ipv4_addr,json=ipv4Addr,proto3" json:"ipv4_addr,omitempty"`
}

func (*HostMetadataUpdate) Descriptor

func (*HostMetadataUpdate) Descriptor() ([]byte, []int)

func (*HostMetadataUpdate) GetHostname

func (m *HostMetadataUpdate) GetHostname() string

func (*HostMetadataUpdate) GetIpv4Addr

func (m *HostMetadataUpdate) GetIpv4Addr() string

func (*HostMetadataUpdate) Marshal

func (m *HostMetadataUpdate) Marshal() (dAtA []byte, err error)

func (*HostMetadataUpdate) MarshalTo

func (m *HostMetadataUpdate) MarshalTo(dAtA []byte) (int, error)

func (*HostMetadataUpdate) ProtoMessage

func (*HostMetadataUpdate) ProtoMessage()

func (*HostMetadataUpdate) Reset

func (m *HostMetadataUpdate) Reset()

func (*HostMetadataUpdate) Size

func (m *HostMetadataUpdate) Size() (n int)

func (*HostMetadataUpdate) String

func (m *HostMetadataUpdate) String() string

func (*HostMetadataUpdate) Unmarshal

func (m *HostMetadataUpdate) Unmarshal(dAtA []byte) error

type IPAMPool

type IPAMPool struct {
	Cidr       string `protobuf:"bytes,1,opt,name=cidr,proto3" json:"cidr,omitempty"`
	Masquerade bool   `protobuf:"varint,2,opt,name=masquerade,proto3" json:"masquerade,omitempty"`
}

func (*IPAMPool) Descriptor

func (*IPAMPool) Descriptor() ([]byte, []int)

func (*IPAMPool) GetCidr

func (m *IPAMPool) GetCidr() string

func (*IPAMPool) GetMasquerade

func (m *IPAMPool) GetMasquerade() bool

func (*IPAMPool) Marshal

func (m *IPAMPool) Marshal() (dAtA []byte, err error)

func (*IPAMPool) MarshalTo

func (m *IPAMPool) MarshalTo(dAtA []byte) (int, error)

func (*IPAMPool) ProtoMessage

func (*IPAMPool) ProtoMessage()

func (*IPAMPool) Reset

func (m *IPAMPool) Reset()

func (*IPAMPool) Size

func (m *IPAMPool) Size() (n int)

func (*IPAMPool) String

func (m *IPAMPool) String() string

func (*IPAMPool) Unmarshal

func (m *IPAMPool) Unmarshal(dAtA []byte) error

type IPAMPoolRemove

type IPAMPoolRemove struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
}

func (*IPAMPoolRemove) Descriptor

func (*IPAMPoolRemove) Descriptor() ([]byte, []int)

func (*IPAMPoolRemove) GetId

func (m *IPAMPoolRemove) GetId() string

func (*IPAMPoolRemove) Marshal

func (m *IPAMPoolRemove) Marshal() (dAtA []byte, err error)

func (*IPAMPoolRemove) MarshalTo

func (m *IPAMPoolRemove) MarshalTo(dAtA []byte) (int, error)

func (*IPAMPoolRemove) ProtoMessage

func (*IPAMPoolRemove) ProtoMessage()

func (*IPAMPoolRemove) Reset

func (m *IPAMPoolRemove) Reset()

func (*IPAMPoolRemove) Size

func (m *IPAMPoolRemove) Size() (n int)

func (*IPAMPoolRemove) String

func (m *IPAMPoolRemove) String() string

func (*IPAMPoolRemove) Unmarshal

func (m *IPAMPoolRemove) Unmarshal(dAtA []byte) error

type IPAMPoolUpdate

type IPAMPoolUpdate struct {
	Id   string    `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Pool *IPAMPool `protobuf:"bytes,2,opt,name=pool" json:"pool,omitempty"`
}

func (*IPAMPoolUpdate) Descriptor

func (*IPAMPoolUpdate) Descriptor() ([]byte, []int)

func (*IPAMPoolUpdate) GetId

func (m *IPAMPoolUpdate) GetId() string

func (*IPAMPoolUpdate) GetPool

func (m *IPAMPoolUpdate) GetPool() *IPAMPool

func (*IPAMPoolUpdate) Marshal

func (m *IPAMPoolUpdate) Marshal() (dAtA []byte, err error)

func (*IPAMPoolUpdate) MarshalTo

func (m *IPAMPoolUpdate) MarshalTo(dAtA []byte) (int, error)

func (*IPAMPoolUpdate) ProtoMessage

func (*IPAMPoolUpdate) ProtoMessage()

func (*IPAMPoolUpdate) Reset

func (m *IPAMPoolUpdate) Reset()

func (*IPAMPoolUpdate) Size

func (m *IPAMPoolUpdate) Size() (n int)

func (*IPAMPoolUpdate) String

func (m *IPAMPoolUpdate) String() string

func (*IPAMPoolUpdate) Unmarshal

func (m *IPAMPoolUpdate) Unmarshal(dAtA []byte) error

type IPSetDeltaUpdate

type IPSetDeltaUpdate struct {
	Id             string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	AddedMembers   []string `protobuf:"bytes,2,rep,name=added_members,json=addedMembers" json:"added_members,omitempty"`
	RemovedMembers []string `protobuf:"bytes,3,rep,name=removed_members,json=removedMembers" json:"removed_members,omitempty"`
}

func (*IPSetDeltaUpdate) Descriptor

func (*IPSetDeltaUpdate) Descriptor() ([]byte, []int)

func (*IPSetDeltaUpdate) GetAddedMembers

func (m *IPSetDeltaUpdate) GetAddedMembers() []string

func (*IPSetDeltaUpdate) GetId

func (m *IPSetDeltaUpdate) GetId() string

func (*IPSetDeltaUpdate) GetRemovedMembers

func (m *IPSetDeltaUpdate) GetRemovedMembers() []string

func (*IPSetDeltaUpdate) Marshal

func (m *IPSetDeltaUpdate) Marshal() (dAtA []byte, err error)

func (*IPSetDeltaUpdate) MarshalTo

func (m *IPSetDeltaUpdate) MarshalTo(dAtA []byte) (int, error)

func (*IPSetDeltaUpdate) ProtoMessage

func (*IPSetDeltaUpdate) ProtoMessage()

func (*IPSetDeltaUpdate) Reset

func (m *IPSetDeltaUpdate) Reset()

func (*IPSetDeltaUpdate) Size

func (m *IPSetDeltaUpdate) Size() (n int)

func (*IPSetDeltaUpdate) String

func (m *IPSetDeltaUpdate) String() string

func (*IPSetDeltaUpdate) Unmarshal

func (m *IPSetDeltaUpdate) Unmarshal(dAtA []byte) error

type IPSetRemove

type IPSetRemove struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
}

func (*IPSetRemove) Descriptor

func (*IPSetRemove) Descriptor() ([]byte, []int)

func (*IPSetRemove) GetId

func (m *IPSetRemove) GetId() string

func (*IPSetRemove) Marshal

func (m *IPSetRemove) Marshal() (dAtA []byte, err error)

func (*IPSetRemove) MarshalTo

func (m *IPSetRemove) MarshalTo(dAtA []byte) (int, error)

func (*IPSetRemove) ProtoMessage

func (*IPSetRemove) ProtoMessage()

func (*IPSetRemove) Reset

func (m *IPSetRemove) Reset()

func (*IPSetRemove) Size

func (m *IPSetRemove) Size() (n int)

func (*IPSetRemove) String

func (m *IPSetRemove) String() string

func (*IPSetRemove) Unmarshal

func (m *IPSetRemove) Unmarshal(dAtA []byte) error

type IPSetUpdate

type IPSetUpdate struct {
	Id      string                `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Members []string              `protobuf:"bytes,2,rep,name=members" json:"members,omitempty"`
	Type    IPSetUpdate_IPSetType `protobuf:"varint,3,opt,name=type,proto3,enum=felix.IPSetUpdate_IPSetType" json:"type,omitempty"`
}

func (*IPSetUpdate) Descriptor

func (*IPSetUpdate) Descriptor() ([]byte, []int)

func (*IPSetUpdate) GetId

func (m *IPSetUpdate) GetId() string

func (*IPSetUpdate) GetMembers

func (m *IPSetUpdate) GetMembers() []string

func (*IPSetUpdate) GetType

func (m *IPSetUpdate) GetType() IPSetUpdate_IPSetType

func (*IPSetUpdate) Marshal

func (m *IPSetUpdate) Marshal() (dAtA []byte, err error)

func (*IPSetUpdate) MarshalTo

func (m *IPSetUpdate) MarshalTo(dAtA []byte) (int, error)

func (*IPSetUpdate) ProtoMessage

func (*IPSetUpdate) ProtoMessage()

func (*IPSetUpdate) Reset

func (m *IPSetUpdate) Reset()

func (*IPSetUpdate) Size

func (m *IPSetUpdate) Size() (n int)

func (*IPSetUpdate) String

func (m *IPSetUpdate) String() string

func (*IPSetUpdate) Unmarshal

func (m *IPSetUpdate) Unmarshal(dAtA []byte) error

type IPSetUpdate_IPSetType

type IPSetUpdate_IPSetType int32
const (
	IPSetUpdate_IP          IPSetUpdate_IPSetType = 0
	IPSetUpdate_IP_AND_PORT IPSetUpdate_IPSetType = 1
	IPSetUpdate_NET         IPSetUpdate_IPSetType = 2
)

func (IPSetUpdate_IPSetType) EnumDescriptor

func (IPSetUpdate_IPSetType) EnumDescriptor() ([]byte, []int)

func (IPSetUpdate_IPSetType) String

func (x IPSetUpdate_IPSetType) String() string

type IPVersion

type IPVersion int32
const (
	IPVersion_ANY  IPVersion = 0
	IPVersion_IPV4 IPVersion = 4
	IPVersion_IPV6 IPVersion = 6
)

func (IPVersion) EnumDescriptor

func (IPVersion) EnumDescriptor() ([]byte, []int)

func (IPVersion) String

func (x IPVersion) String() string

type IcmpTypeAndCode

type IcmpTypeAndCode struct {
	Type int32 `protobuf:"varint,1,opt,name=type,proto3" json:"type,omitempty"`
	Code int32 `protobuf:"varint,2,opt,name=code,proto3" json:"code,omitempty"`
}

func (*IcmpTypeAndCode) Descriptor

func (*IcmpTypeAndCode) Descriptor() ([]byte, []int)

func (*IcmpTypeAndCode) GetCode

func (m *IcmpTypeAndCode) GetCode() int32

func (*IcmpTypeAndCode) GetType

func (m *IcmpTypeAndCode) GetType() int32

func (*IcmpTypeAndCode) Marshal

func (m *IcmpTypeAndCode) Marshal() (dAtA []byte, err error)

func (*IcmpTypeAndCode) MarshalTo

func (m *IcmpTypeAndCode) MarshalTo(dAtA []byte) (int, error)

func (*IcmpTypeAndCode) ProtoMessage

func (*IcmpTypeAndCode) ProtoMessage()

func (*IcmpTypeAndCode) Reset

func (m *IcmpTypeAndCode) Reset()

func (*IcmpTypeAndCode) Size

func (m *IcmpTypeAndCode) Size() (n int)

func (*IcmpTypeAndCode) String

func (m *IcmpTypeAndCode) String() string

func (*IcmpTypeAndCode) Unmarshal

func (m *IcmpTypeAndCode) Unmarshal(dAtA []byte) error

type InSync

type InSync struct {
}

func (*InSync) Descriptor

func (*InSync) Descriptor() ([]byte, []int)

func (*InSync) Marshal

func (m *InSync) Marshal() (dAtA []byte, err error)

func (*InSync) MarshalTo

func (m *InSync) MarshalTo(dAtA []byte) (int, error)

func (*InSync) ProtoMessage

func (*InSync) ProtoMessage()

func (*InSync) Reset

func (m *InSync) Reset()

func (*InSync) Size

func (m *InSync) Size() (n int)

func (*InSync) String

func (m *InSync) String() string

func (*InSync) Unmarshal

func (m *InSync) Unmarshal(dAtA []byte) error

type MsgStringer

type MsgStringer struct {
	Msg interface{}
}

msgStringer wraps an API message to customise how we stringify it. For example, it truncates the lists of members in the (potentially very large) IPSetsUpdate messages.

func (MsgStringer) String

func (m MsgStringer) String() string

type NamespaceID

type NamespaceID struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
}

func (*NamespaceID) Descriptor

func (*NamespaceID) Descriptor() ([]byte, []int)

func (*NamespaceID) GetName

func (m *NamespaceID) GetName() string

func (*NamespaceID) Marshal

func (m *NamespaceID) Marshal() (dAtA []byte, err error)

func (*NamespaceID) MarshalTo

func (m *NamespaceID) MarshalTo(dAtA []byte) (int, error)

func (*NamespaceID) ProtoMessage

func (*NamespaceID) ProtoMessage()

func (*NamespaceID) Reset

func (m *NamespaceID) Reset()

func (*NamespaceID) Size

func (m *NamespaceID) Size() (n int)

func (*NamespaceID) String

func (m *NamespaceID) String() string

func (*NamespaceID) Unmarshal

func (m *NamespaceID) Unmarshal(dAtA []byte) error

type NamespaceRemove

type NamespaceRemove struct {
	Id *NamespaceID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
}

func (*NamespaceRemove) Descriptor

func (*NamespaceRemove) Descriptor() ([]byte, []int)

func (*NamespaceRemove) GetId

func (m *NamespaceRemove) GetId() *NamespaceID

func (*NamespaceRemove) Marshal

func (m *NamespaceRemove) Marshal() (dAtA []byte, err error)

func (*NamespaceRemove) MarshalTo

func (m *NamespaceRemove) MarshalTo(dAtA []byte) (int, error)

func (*NamespaceRemove) ProtoMessage

func (*NamespaceRemove) ProtoMessage()

func (*NamespaceRemove) Reset

func (m *NamespaceRemove) Reset()

func (*NamespaceRemove) Size

func (m *NamespaceRemove) Size() (n int)

func (*NamespaceRemove) String

func (m *NamespaceRemove) String() string

func (*NamespaceRemove) Unmarshal

func (m *NamespaceRemove) Unmarshal(dAtA []byte) error

type NamespaceUpdate

type NamespaceUpdate struct {
	Id     *NamespaceID      `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
	Labels map[string]string `` /* 146-byte string literal not displayed */
}

func (*NamespaceUpdate) Descriptor

func (*NamespaceUpdate) Descriptor() ([]byte, []int)

func (*NamespaceUpdate) GetId

func (m *NamespaceUpdate) GetId() *NamespaceID

func (*NamespaceUpdate) GetLabels

func (m *NamespaceUpdate) GetLabels() map[string]string

func (*NamespaceUpdate) Marshal

func (m *NamespaceUpdate) Marshal() (dAtA []byte, err error)

func (*NamespaceUpdate) MarshalTo

func (m *NamespaceUpdate) MarshalTo(dAtA []byte) (int, error)

func (*NamespaceUpdate) ProtoMessage

func (*NamespaceUpdate) ProtoMessage()

func (*NamespaceUpdate) Reset

func (m *NamespaceUpdate) Reset()

func (*NamespaceUpdate) Size

func (m *NamespaceUpdate) Size() (n int)

func (*NamespaceUpdate) String

func (m *NamespaceUpdate) String() string

func (*NamespaceUpdate) Unmarshal

func (m *NamespaceUpdate) Unmarshal(dAtA []byte) error

type NatInfo

type NatInfo struct {
	ExtIp string `protobuf:"bytes,1,opt,name=ext_ip,json=extIp,proto3" json:"ext_ip,omitempty"`
	IntIp string `protobuf:"bytes,2,opt,name=int_ip,json=intIp,proto3" json:"int_ip,omitempty"`
}

func (*NatInfo) Descriptor

func (*NatInfo) Descriptor() ([]byte, []int)

func (*NatInfo) GetExtIp

func (m *NatInfo) GetExtIp() string

func (*NatInfo) GetIntIp

func (m *NatInfo) GetIntIp() string

func (*NatInfo) Marshal

func (m *NatInfo) Marshal() (dAtA []byte, err error)

func (*NatInfo) MarshalTo

func (m *NatInfo) MarshalTo(dAtA []byte) (int, error)

func (*NatInfo) ProtoMessage

func (*NatInfo) ProtoMessage()

func (*NatInfo) Reset

func (m *NatInfo) Reset()

func (*NatInfo) Size

func (m *NatInfo) Size() (n int)

func (*NatInfo) String

func (m *NatInfo) String() string

func (*NatInfo) Unmarshal

func (m *NatInfo) Unmarshal(dAtA []byte) error

type Policy

type Policy struct {
	// If the Policy represents a NetworkPolicy, this contains the namespace that the policy came
	// from.  Otherwise, empty.
	Namespace     string  `protobuf:"bytes,5,opt,name=namespace,proto3" json:"namespace,omitempty"`
	InboundRules  []*Rule `protobuf:"bytes,1,rep,name=inbound_rules,json=inboundRules" json:"inbound_rules,omitempty"`
	OutboundRules []*Rule `protobuf:"bytes,2,rep,name=outbound_rules,json=outboundRules" json:"outbound_rules,omitempty"`
	Untracked     bool    `protobuf:"varint,3,opt,name=untracked,proto3" json:"untracked,omitempty"`
	PreDnat       bool    `protobuf:"varint,4,opt,name=pre_dnat,json=preDnat,proto3" json:"pre_dnat,omitempty"`
}

func (*Policy) Descriptor

func (*Policy) Descriptor() ([]byte, []int)

func (*Policy) GetInboundRules

func (m *Policy) GetInboundRules() []*Rule

func (*Policy) GetNamespace

func (m *Policy) GetNamespace() string

func (*Policy) GetOutboundRules

func (m *Policy) GetOutboundRules() []*Rule

func (*Policy) GetPreDnat

func (m *Policy) GetPreDnat() bool

func (*Policy) GetUntracked

func (m *Policy) GetUntracked() bool

func (*Policy) Marshal

func (m *Policy) Marshal() (dAtA []byte, err error)

func (*Policy) MarshalTo

func (m *Policy) MarshalTo(dAtA []byte) (int, error)

func (*Policy) ProtoMessage

func (*Policy) ProtoMessage()

func (*Policy) Reset

func (m *Policy) Reset()

func (*Policy) Size

func (m *Policy) Size() (n int)

func (*Policy) String

func (m *Policy) String() string

func (*Policy) Unmarshal

func (m *Policy) Unmarshal(dAtA []byte) error

type PolicyID

type PolicyID struct {
	Tier string `protobuf:"bytes,1,opt,name=tier,proto3" json:"tier,omitempty"`
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
}

func (*PolicyID) Descriptor

func (*PolicyID) Descriptor() ([]byte, []int)

func (*PolicyID) GetName

func (m *PolicyID) GetName() string

func (*PolicyID) GetTier

func (m *PolicyID) GetTier() string

func (*PolicyID) Marshal

func (m *PolicyID) Marshal() (dAtA []byte, err error)

func (*PolicyID) MarshalTo

func (m *PolicyID) MarshalTo(dAtA []byte) (int, error)

func (*PolicyID) ProtoMessage

func (*PolicyID) ProtoMessage()

func (*PolicyID) Reset

func (m *PolicyID) Reset()

func (*PolicyID) Size

func (m *PolicyID) Size() (n int)

func (*PolicyID) String

func (m *PolicyID) String() string

func (*PolicyID) Unmarshal

func (m *PolicyID) Unmarshal(dAtA []byte) error

type PolicySyncClient

type PolicySyncClient interface {
	// On this API, only the following payloads will be sent:
	//  - InSync
	//  - IPSetUpdate
	//  - IPSetDeltaUpdate
	//  - IPSetRemove
	//  - ActiveProfileUpdate
	//  - ActiveProfileRemove
	//  - ActivePolicyUpdate
	//  - ActivePolicyRemove
	//  - WorkloadEndpointUpdate
	//  - WorkloadEndpointRemove
	//  - ServiceAccountUpdate
	//  - ServiceAccountRemove
	//  - NamespaceUpdate
	//  - NamespaceRemove
	//  - RouteUpdate
	//  - RouteRemove
	//  - VXLANTunnelEndpointUpdate
	//  - VXLANTunnelEndpointRemove
	Sync(ctx context.Context, in *SyncRequest, opts ...grpc.CallOption) (PolicySync_SyncClient, error)
}

func NewPolicySyncClient

func NewPolicySyncClient(cc *grpc.ClientConn) PolicySyncClient

type PolicySyncServer

type PolicySyncServer interface {
	// On this API, only the following payloads will be sent:
	//  - InSync
	//  - IPSetUpdate
	//  - IPSetDeltaUpdate
	//  - IPSetRemove
	//  - ActiveProfileUpdate
	//  - ActiveProfileRemove
	//  - ActivePolicyUpdate
	//  - ActivePolicyRemove
	//  - WorkloadEndpointUpdate
	//  - WorkloadEndpointRemove
	//  - ServiceAccountUpdate
	//  - ServiceAccountRemove
	//  - NamespaceUpdate
	//  - NamespaceRemove
	//  - RouteUpdate
	//  - RouteRemove
	//  - VXLANTunnelEndpointUpdate
	//  - VXLANTunnelEndpointRemove
	Sync(*SyncRequest, PolicySync_SyncServer) error
}

type PolicySync_SyncClient

type PolicySync_SyncClient interface {
	Recv() (*ToDataplane, error)
	grpc.ClientStream
}

type PolicySync_SyncServer

type PolicySync_SyncServer interface {
	Send(*ToDataplane) error
	grpc.ServerStream
}

type PortRange

type PortRange struct {
	First int32 `protobuf:"varint,1,opt,name=first,proto3" json:"first,omitempty"`
	Last  int32 `protobuf:"varint,2,opt,name=last,proto3" json:"last,omitempty"`
}

Individual ports are sent with first == last.

func (*PortRange) Descriptor

func (*PortRange) Descriptor() ([]byte, []int)

func (*PortRange) GetFirst

func (m *PortRange) GetFirst() int32

func (*PortRange) GetLast

func (m *PortRange) GetLast() int32

func (*PortRange) Marshal

func (m *PortRange) Marshal() (dAtA []byte, err error)

func (*PortRange) MarshalTo

func (m *PortRange) MarshalTo(dAtA []byte) (int, error)

func (*PortRange) ProtoMessage

func (*PortRange) ProtoMessage()

func (*PortRange) Reset

func (m *PortRange) Reset()

func (*PortRange) Size

func (m *PortRange) Size() (n int)

func (*PortRange) String

func (m *PortRange) String() string

func (*PortRange) Unmarshal

func (m *PortRange) Unmarshal(dAtA []byte) error

type ProcessStatusUpdate

type ProcessStatusUpdate struct {
	IsoTimestamp string  `protobuf:"bytes,1,opt,name=iso_timestamp,json=isoTimestamp,proto3" json:"iso_timestamp,omitempty"`
	Uptime       float64 `protobuf:"fixed64,2,opt,name=uptime,proto3" json:"uptime,omitempty"`
}

func (*ProcessStatusUpdate) Descriptor

func (*ProcessStatusUpdate) Descriptor() ([]byte, []int)

func (*ProcessStatusUpdate) GetIsoTimestamp

func (m *ProcessStatusUpdate) GetIsoTimestamp() string

func (*ProcessStatusUpdate) GetUptime

func (m *ProcessStatusUpdate) GetUptime() float64

func (*ProcessStatusUpdate) Marshal

func (m *ProcessStatusUpdate) Marshal() (dAtA []byte, err error)

func (*ProcessStatusUpdate) MarshalTo

func (m *ProcessStatusUpdate) MarshalTo(dAtA []byte) (int, error)

func (*ProcessStatusUpdate) ProtoMessage

func (*ProcessStatusUpdate) ProtoMessage()

func (*ProcessStatusUpdate) Reset

func (m *ProcessStatusUpdate) Reset()

func (*ProcessStatusUpdate) Size

func (m *ProcessStatusUpdate) Size() (n int)

func (*ProcessStatusUpdate) String

func (m *ProcessStatusUpdate) String() string

func (*ProcessStatusUpdate) Unmarshal

func (m *ProcessStatusUpdate) Unmarshal(dAtA []byte) error

type Profile

type Profile struct {
	InboundRules  []*Rule `protobuf:"bytes,1,rep,name=inbound_rules,json=inboundRules" json:"inbound_rules,omitempty"`
	OutboundRules []*Rule `protobuf:"bytes,2,rep,name=outbound_rules,json=outboundRules" json:"outbound_rules,omitempty"`
}

func (*Profile) Descriptor

func (*Profile) Descriptor() ([]byte, []int)

func (*Profile) GetInboundRules

func (m *Profile) GetInboundRules() []*Rule

func (*Profile) GetOutboundRules

func (m *Profile) GetOutboundRules() []*Rule

func (*Profile) Marshal

func (m *Profile) Marshal() (dAtA []byte, err error)

func (*Profile) MarshalTo

func (m *Profile) MarshalTo(dAtA []byte) (int, error)

func (*Profile) ProtoMessage

func (*Profile) ProtoMessage()

func (*Profile) Reset

func (m *Profile) Reset()

func (*Profile) Size

func (m *Profile) Size() (n int)

func (*Profile) String

func (m *Profile) String() string

func (*Profile) Unmarshal

func (m *Profile) Unmarshal(dAtA []byte) error

type ProfileID

type ProfileID struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
}

func (*ProfileID) Descriptor

func (*ProfileID) Descriptor() ([]byte, []int)

func (*ProfileID) GetName

func (m *ProfileID) GetName() string

func (*ProfileID) Marshal

func (m *ProfileID) Marshal() (dAtA []byte, err error)

func (*ProfileID) MarshalTo

func (m *ProfileID) MarshalTo(dAtA []byte) (int, error)

func (*ProfileID) ProtoMessage

func (*ProfileID) ProtoMessage()

func (*ProfileID) Reset

func (m *ProfileID) Reset()

func (*ProfileID) Size

func (m *ProfileID) Size() (n int)

func (*ProfileID) String

func (m *ProfileID) String() string

func (*ProfileID) Unmarshal

func (m *ProfileID) Unmarshal(dAtA []byte) error

type Protocol

type Protocol struct {
	// Types that are valid to be assigned to NumberOrName:
	//	*Protocol_Number
	//	*Protocol_Name
	NumberOrName isProtocol_NumberOrName `protobuf_oneof:"number_or_name"`
}

func (*Protocol) Descriptor

func (*Protocol) Descriptor() ([]byte, []int)

func (*Protocol) GetName

func (m *Protocol) GetName() string

func (*Protocol) GetNumber

func (m *Protocol) GetNumber() int32

func (*Protocol) GetNumberOrName

func (m *Protocol) GetNumberOrName() isProtocol_NumberOrName

func (*Protocol) Marshal

func (m *Protocol) Marshal() (dAtA []byte, err error)

func (*Protocol) MarshalTo

func (m *Protocol) MarshalTo(dAtA []byte) (int, error)

func (*Protocol) ProtoMessage

func (*Protocol) ProtoMessage()

func (*Protocol) Reset

func (m *Protocol) Reset()

func (*Protocol) Size

func (m *Protocol) Size() (n int)

func (*Protocol) String

func (m *Protocol) String() string

func (*Protocol) Unmarshal

func (m *Protocol) Unmarshal(dAtA []byte) error

func (*Protocol) XXX_OneofFuncs

func (*Protocol) XXX_OneofFuncs() (func(msg proto1.Message, b *proto1.Buffer) error, func(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error), func(msg proto1.Message) (n int), []interface{})

XXX_OneofFuncs is for the internal use of the proto package.

type Protocol_Name

type Protocol_Name struct {
	Name string `protobuf:"bytes,2,opt,name=name,proto3,oneof"`
}

func (*Protocol_Name) MarshalTo

func (m *Protocol_Name) MarshalTo(dAtA []byte) (int, error)

func (*Protocol_Name) Size

func (m *Protocol_Name) Size() (n int)

type Protocol_Number

type Protocol_Number struct {
	Number int32 `protobuf:"varint,1,opt,name=number,proto3,oneof"`
}

func (*Protocol_Number) MarshalTo

func (m *Protocol_Number) MarshalTo(dAtA []byte) (int, error)

func (*Protocol_Number) Size

func (m *Protocol_Number) Size() (n int)

type RouteRemove

type RouteRemove struct {
	Type RouteType `protobuf:"varint,1,opt,name=type,proto3,enum=felix.RouteType" json:"type,omitempty"`
	Dst  string    `protobuf:"bytes,2,opt,name=dst,proto3" json:"dst,omitempty"`
}

func (*RouteRemove) Descriptor

func (*RouteRemove) Descriptor() ([]byte, []int)

func (*RouteRemove) GetDst

func (m *RouteRemove) GetDst() string

func (*RouteRemove) GetType

func (m *RouteRemove) GetType() RouteType

func (*RouteRemove) Marshal

func (m *RouteRemove) Marshal() (dAtA []byte, err error)

func (*RouteRemove) MarshalTo

func (m *RouteRemove) MarshalTo(dAtA []byte) (int, error)

func (*RouteRemove) ProtoMessage

func (*RouteRemove) ProtoMessage()

func (*RouteRemove) Reset

func (m *RouteRemove) Reset()

func (*RouteRemove) Size

func (m *RouteRemove) Size() (n int)

func (*RouteRemove) String

func (m *RouteRemove) String() string

func (*RouteRemove) Unmarshal

func (m *RouteRemove) Unmarshal(dAtA []byte) error

type RouteType

type RouteType int32
const (
	RouteType_VXLAN RouteType = 0
)

func (RouteType) EnumDescriptor

func (RouteType) EnumDescriptor() ([]byte, []int)

func (RouteType) String

func (x RouteType) String() string

type RouteUpdate

type RouteUpdate struct {
	Type RouteType `protobuf:"varint,1,opt,name=type,proto3,enum=felix.RouteType" json:"type,omitempty"`
	Dst  string    `protobuf:"bytes,2,opt,name=dst,proto3" json:"dst,omitempty"`
	Node string    `protobuf:"bytes,3,opt,name=node,proto3" json:"node,omitempty"`
	Gw   string    `protobuf:"bytes,4,opt,name=gw,proto3" json:"gw,omitempty"`
}

func (*RouteUpdate) Descriptor

func (*RouteUpdate) Descriptor() ([]byte, []int)

func (*RouteUpdate) GetDst

func (m *RouteUpdate) GetDst() string

func (*RouteUpdate) GetGw

func (m *RouteUpdate) GetGw() string

func (*RouteUpdate) GetNode

func (m *RouteUpdate) GetNode() string

func (*RouteUpdate) GetType

func (m *RouteUpdate) GetType() RouteType

func (*RouteUpdate) Marshal

func (m *RouteUpdate) Marshal() (dAtA []byte, err error)

func (*RouteUpdate) MarshalTo

func (m *RouteUpdate) MarshalTo(dAtA []byte) (int, error)

func (*RouteUpdate) ProtoMessage

func (*RouteUpdate) ProtoMessage()

func (*RouteUpdate) Reset

func (m *RouteUpdate) Reset()

func (*RouteUpdate) Size

func (m *RouteUpdate) Size() (n int)

func (*RouteUpdate) String

func (m *RouteUpdate) String() string

func (*RouteUpdate) Unmarshal

func (m *RouteUpdate) Unmarshal(dAtA []byte) error

type Rule

type Rule struct {
	Action    string    `protobuf:"bytes,1,opt,name=action,proto3" json:"action,omitempty"`
	IpVersion IPVersion `protobuf:"varint,2,opt,name=ip_version,json=ipVersion,proto3,enum=felix.IPVersion" json:"ip_version,omitempty"`
	Protocol  *Protocol `protobuf:"bytes,3,opt,name=protocol" json:"protocol,omitempty"`
	SrcNet    []string  `protobuf:"bytes,4,rep,name=src_net,json=srcNet" json:"src_net,omitempty"`
	// The list of ports is split into numeric and named ports, where named ports are represented
	// by (IP, port) IP sets.  A packet matches this rule if it matches any numeric port range *or*
	// any listed named port IP set.
	SrcPorts             []*PortRange `protobuf:"bytes,5,rep,name=src_ports,json=srcPorts" json:"src_ports,omitempty"`
	SrcNamedPortIpSetIds []string     `protobuf:"bytes,12,rep,name=src_named_port_ip_set_ids,json=srcNamedPortIpSetIds" json:"src_named_port_ip_set_ids,omitempty"`
	DstNet               []string     `protobuf:"bytes,6,rep,name=dst_net,json=dstNet" json:"dst_net,omitempty"`
	DstPorts             []*PortRange `protobuf:"bytes,7,rep,name=dst_ports,json=dstPorts" json:"dst_ports,omitempty"`
	DstNamedPortIpSetIds []string     `protobuf:"bytes,13,rep,name=dst_named_port_ip_set_ids,json=dstNamedPortIpSetIds" json:"dst_named_port_ip_set_ids,omitempty"`
	// Types that are valid to be assigned to Icmp:
	//	*Rule_IcmpType
	//	*Rule_IcmpTypeCode
	Icmp        isRule_Icmp  `protobuf_oneof:"icmp"`
	SrcIpSetIds []string     `protobuf:"bytes,10,rep,name=src_ip_set_ids,json=srcIpSetIds" json:"src_ip_set_ids,omitempty"`
	DstIpSetIds []string     `protobuf:"bytes,11,rep,name=dst_ip_set_ids,json=dstIpSetIds" json:"dst_ip_set_ids,omitempty"`
	NotProtocol *Protocol    `protobuf:"bytes,102,opt,name=not_protocol,json=notProtocol" json:"not_protocol,omitempty"`
	NotSrcNet   []string     `protobuf:"bytes,103,rep,name=not_src_net,json=notSrcNet" json:"not_src_net,omitempty"`
	NotSrcPorts []*PortRange `protobuf:"bytes,104,rep,name=not_src_ports,json=notSrcPorts" json:"not_src_ports,omitempty"`
	NotDstNet   []string     `protobuf:"bytes,105,rep,name=not_dst_net,json=notDstNet" json:"not_dst_net,omitempty"`
	NotDstPorts []*PortRange `protobuf:"bytes,106,rep,name=not_dst_ports,json=notDstPorts" json:"not_dst_ports,omitempty"`
	// Types that are valid to be assigned to NotIcmp:
	//	*Rule_NotIcmpType
	//	*Rule_NotIcmpTypeCode
	NotIcmp                 isRule_NotIcmp `protobuf_oneof:"not_icmp"`
	NotSrcIpSetIds          []string       `protobuf:"bytes,109,rep,name=not_src_ip_set_ids,json=notSrcIpSetIds" json:"not_src_ip_set_ids,omitempty"`
	NotDstIpSetIds          []string       `protobuf:"bytes,110,rep,name=not_dst_ip_set_ids,json=notDstIpSetIds" json:"not_dst_ip_set_ids,omitempty"`
	NotSrcNamedPortIpSetIds []string       `` /* 135-byte string literal not displayed */
	NotDstNamedPortIpSetIds []string       `` /* 135-byte string literal not displayed */
	// These fields pass through the original selectors from the v3 datamodel unmodified as required
	// for the policy sync API.
	OriginalSrcSelector          string `protobuf:"bytes,114,opt,name=original_src_selector,json=originalSrcSelector,proto3" json:"original_src_selector,omitempty"`
	OriginalDstSelector          string `protobuf:"bytes,115,opt,name=original_dst_selector,json=originalDstSelector,proto3" json:"original_dst_selector,omitempty"`
	OriginalSrcNamespaceSelector string `` /* 151-byte string literal not displayed */
	OriginalDstNamespaceSelector string `` /* 151-byte string literal not displayed */
	OriginalNotSrcSelector       string `` /* 133-byte string literal not displayed */
	OriginalNotDstSelector       string `` /* 133-byte string literal not displayed */
	// Pass through of the v3 datamodel service account match criteria.
	SrcServiceAccountMatch *ServiceAccountMatch `` /* 126-byte string literal not displayed */
	DstServiceAccountMatch *ServiceAccountMatch `` /* 126-byte string literal not displayed */
	// Pass through of the v3 datamodel HTTP match criteria.
	HttpMatch *HTTPMatch `protobuf:"bytes,122,opt,name=http_match,json=httpMatch" json:"http_match,omitempty"`
	// An opaque ID/hash for the rule.
	RuleId string `protobuf:"bytes,201,opt,name=rule_id,json=ruleId,proto3" json:"rule_id,omitempty"`
}

func (*Rule) Descriptor

func (*Rule) Descriptor() ([]byte, []int)

func (*Rule) GetAction

func (m *Rule) GetAction() string

func (*Rule) GetDstIpSetIds

func (m *Rule) GetDstIpSetIds() []string

func (*Rule) GetDstNamedPortIpSetIds

func (m *Rule) GetDstNamedPortIpSetIds() []string

func (*Rule) GetDstNet

func (m *Rule) GetDstNet() []string

func (*Rule) GetDstPorts

func (m *Rule) GetDstPorts() []*PortRange

func (*Rule) GetDstServiceAccountMatch

func (m *Rule) GetDstServiceAccountMatch() *ServiceAccountMatch

func (*Rule) GetHttpMatch

func (m *Rule) GetHttpMatch() *HTTPMatch

func (*Rule) GetIcmp

func (m *Rule) GetIcmp() isRule_Icmp

func (*Rule) GetIcmpType

func (m *Rule) GetIcmpType() int32

func (*Rule) GetIcmpTypeCode

func (m *Rule) GetIcmpTypeCode() *IcmpTypeAndCode

func (*Rule) GetIpVersion

func (m *Rule) GetIpVersion() IPVersion

func (*Rule) GetNotDstIpSetIds

func (m *Rule) GetNotDstIpSetIds() []string

func (*Rule) GetNotDstNamedPortIpSetIds

func (m *Rule) GetNotDstNamedPortIpSetIds() []string

func (*Rule) GetNotDstNet

func (m *Rule) GetNotDstNet() []string

func (*Rule) GetNotDstPorts

func (m *Rule) GetNotDstPorts() []*PortRange

func (*Rule) GetNotIcmp

func (m *Rule) GetNotIcmp() isRule_NotIcmp

func (*Rule) GetNotIcmpType

func (m *Rule) GetNotIcmpType() int32

func (*Rule) GetNotIcmpTypeCode

func (m *Rule) GetNotIcmpTypeCode() *IcmpTypeAndCode

func (*Rule) GetNotProtocol

func (m *Rule) GetNotProtocol() *Protocol

func (*Rule) GetNotSrcIpSetIds

func (m *Rule) GetNotSrcIpSetIds() []string

func (*Rule) GetNotSrcNamedPortIpSetIds

func (m *Rule) GetNotSrcNamedPortIpSetIds() []string

func (*Rule) GetNotSrcNet

func (m *Rule) GetNotSrcNet() []string

func (*Rule) GetNotSrcPorts

func (m *Rule) GetNotSrcPorts() []*PortRange

func (*Rule) GetOriginalDstNamespaceSelector

func (m *Rule) GetOriginalDstNamespaceSelector() string

func (*Rule) GetOriginalDstSelector

func (m *Rule) GetOriginalDstSelector() string

func (*Rule) GetOriginalNotDstSelector

func (m *Rule) GetOriginalNotDstSelector() string

func (*Rule) GetOriginalNotSrcSelector

func (m *Rule) GetOriginalNotSrcSelector() string

func (*Rule) GetOriginalSrcNamespaceSelector

func (m *Rule) GetOriginalSrcNamespaceSelector() string

func (*Rule) GetOriginalSrcSelector

func (m *Rule) GetOriginalSrcSelector() string

func (*Rule) GetProtocol

func (m *Rule) GetProtocol() *Protocol

func (*Rule) GetRuleId

func (m *Rule) GetRuleId() string

func (*Rule) GetSrcIpSetIds

func (m *Rule) GetSrcIpSetIds() []string

func (*Rule) GetSrcNamedPortIpSetIds

func (m *Rule) GetSrcNamedPortIpSetIds() []string

func (*Rule) GetSrcNet

func (m *Rule) GetSrcNet() []string

func (*Rule) GetSrcPorts

func (m *Rule) GetSrcPorts() []*PortRange

func (*Rule) GetSrcServiceAccountMatch

func (m *Rule) GetSrcServiceAccountMatch() *ServiceAccountMatch

func (*Rule) Marshal

func (m *Rule) Marshal() (dAtA []byte, err error)

func (*Rule) MarshalTo

func (m *Rule) MarshalTo(dAtA []byte) (int, error)

func (*Rule) ProtoMessage

func (*Rule) ProtoMessage()

func (*Rule) Reset

func (m *Rule) Reset()

func (*Rule) Size

func (m *Rule) Size() (n int)

func (*Rule) String

func (m *Rule) String() string

func (*Rule) Unmarshal

func (m *Rule) Unmarshal(dAtA []byte) error

func (*Rule) XXX_OneofFuncs

func (*Rule) XXX_OneofFuncs() (func(msg proto1.Message, b *proto1.Buffer) error, func(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error), func(msg proto1.Message) (n int), []interface{})

XXX_OneofFuncs is for the internal use of the proto package.

type Rule_IcmpType

type Rule_IcmpType struct {
	IcmpType int32 `protobuf:"varint,8,opt,name=icmp_type,json=icmpType,proto3,oneof"`
}

func (*Rule_IcmpType) MarshalTo

func (m *Rule_IcmpType) MarshalTo(dAtA []byte) (int, error)

func (*Rule_IcmpType) Size

func (m *Rule_IcmpType) Size() (n int)

type Rule_IcmpTypeCode

type Rule_IcmpTypeCode struct {
	IcmpTypeCode *IcmpTypeAndCode `protobuf:"bytes,9,opt,name=icmp_type_code,json=icmpTypeCode,oneof"`
}

func (*Rule_IcmpTypeCode) MarshalTo

func (m *Rule_IcmpTypeCode) MarshalTo(dAtA []byte) (int, error)

func (*Rule_IcmpTypeCode) Size

func (m *Rule_IcmpTypeCode) Size() (n int)

type Rule_NotIcmpType

type Rule_NotIcmpType struct {
	NotIcmpType int32 `protobuf:"varint,107,opt,name=not_icmp_type,json=notIcmpType,proto3,oneof"`
}

func (*Rule_NotIcmpType) MarshalTo

func (m *Rule_NotIcmpType) MarshalTo(dAtA []byte) (int, error)

func (*Rule_NotIcmpType) Size

func (m *Rule_NotIcmpType) Size() (n int)

type Rule_NotIcmpTypeCode

type Rule_NotIcmpTypeCode struct {
	NotIcmpTypeCode *IcmpTypeAndCode `protobuf:"bytes,108,opt,name=not_icmp_type_code,json=notIcmpTypeCode,oneof"`
}

func (*Rule_NotIcmpTypeCode) MarshalTo

func (m *Rule_NotIcmpTypeCode) MarshalTo(dAtA []byte) (int, error)

func (*Rule_NotIcmpTypeCode) Size

func (m *Rule_NotIcmpTypeCode) Size() (n int)

type ServiceAccountID

type ServiceAccountID struct {
	Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Name      string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
}

func (*ServiceAccountID) Descriptor

func (*ServiceAccountID) Descriptor() ([]byte, []int)

func (*ServiceAccountID) GetName

func (m *ServiceAccountID) GetName() string

func (*ServiceAccountID) GetNamespace

func (m *ServiceAccountID) GetNamespace() string

func (*ServiceAccountID) Marshal

func (m *ServiceAccountID) Marshal() (dAtA []byte, err error)

func (*ServiceAccountID) MarshalTo

func (m *ServiceAccountID) MarshalTo(dAtA []byte) (int, error)

func (*ServiceAccountID) ProtoMessage

func (*ServiceAccountID) ProtoMessage()

func (*ServiceAccountID) Reset

func (m *ServiceAccountID) Reset()

func (*ServiceAccountID) Size

func (m *ServiceAccountID) Size() (n int)

func (*ServiceAccountID) String

func (m *ServiceAccountID) String() string

func (*ServiceAccountID) Unmarshal

func (m *ServiceAccountID) Unmarshal(dAtA []byte) error

type ServiceAccountMatch

type ServiceAccountMatch struct {
	Selector string   `protobuf:"bytes,1,opt,name=selector,proto3" json:"selector,omitempty"`
	Names    []string `protobuf:"bytes,2,rep,name=names" json:"names,omitempty"`
}

func (*ServiceAccountMatch) Descriptor

func (*ServiceAccountMatch) Descriptor() ([]byte, []int)

func (*ServiceAccountMatch) GetNames

func (m *ServiceAccountMatch) GetNames() []string

func (*ServiceAccountMatch) GetSelector

func (m *ServiceAccountMatch) GetSelector() string

func (*ServiceAccountMatch) Marshal

func (m *ServiceAccountMatch) Marshal() (dAtA []byte, err error)

func (*ServiceAccountMatch) MarshalTo

func (m *ServiceAccountMatch) MarshalTo(dAtA []byte) (int, error)

func (*ServiceAccountMatch) ProtoMessage

func (*ServiceAccountMatch) ProtoMessage()

func (*ServiceAccountMatch) Reset

func (m *ServiceAccountMatch) Reset()

func (*ServiceAccountMatch) Size

func (m *ServiceAccountMatch) Size() (n int)

func (*ServiceAccountMatch) String

func (m *ServiceAccountMatch) String() string

func (*ServiceAccountMatch) Unmarshal

func (m *ServiceAccountMatch) Unmarshal(dAtA []byte) error

type ServiceAccountRemove

type ServiceAccountRemove struct {
	Id *ServiceAccountID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
}

func (*ServiceAccountRemove) Descriptor

func (*ServiceAccountRemove) Descriptor() ([]byte, []int)

func (*ServiceAccountRemove) GetId

func (*ServiceAccountRemove) Marshal

func (m *ServiceAccountRemove) Marshal() (dAtA []byte, err error)

func (*ServiceAccountRemove) MarshalTo

func (m *ServiceAccountRemove) MarshalTo(dAtA []byte) (int, error)

func (*ServiceAccountRemove) ProtoMessage

func (*ServiceAccountRemove) ProtoMessage()

func (*ServiceAccountRemove) Reset

func (m *ServiceAccountRemove) Reset()

func (*ServiceAccountRemove) Size

func (m *ServiceAccountRemove) Size() (n int)

func (*ServiceAccountRemove) String

func (m *ServiceAccountRemove) String() string

func (*ServiceAccountRemove) Unmarshal

func (m *ServiceAccountRemove) Unmarshal(dAtA []byte) error

type ServiceAccountUpdate

type ServiceAccountUpdate struct {
	Id     *ServiceAccountID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
	Labels map[string]string `` /* 146-byte string literal not displayed */
}

func (*ServiceAccountUpdate) Descriptor

func (*ServiceAccountUpdate) Descriptor() ([]byte, []int)

func (*ServiceAccountUpdate) GetId

func (*ServiceAccountUpdate) GetLabels

func (m *ServiceAccountUpdate) GetLabels() map[string]string

func (*ServiceAccountUpdate) Marshal

func (m *ServiceAccountUpdate) Marshal() (dAtA []byte, err error)

func (*ServiceAccountUpdate) MarshalTo

func (m *ServiceAccountUpdate) MarshalTo(dAtA []byte) (int, error)

func (*ServiceAccountUpdate) ProtoMessage

func (*ServiceAccountUpdate) ProtoMessage()

func (*ServiceAccountUpdate) Reset

func (m *ServiceAccountUpdate) Reset()

func (*ServiceAccountUpdate) Size

func (m *ServiceAccountUpdate) Size() (n int)

func (*ServiceAccountUpdate) String

func (m *ServiceAccountUpdate) String() string

func (*ServiceAccountUpdate) Unmarshal

func (m *ServiceAccountUpdate) Unmarshal(dAtA []byte) error

type SyncRequest

type SyncRequest struct {
}

func (*SyncRequest) Descriptor

func (*SyncRequest) Descriptor() ([]byte, []int)

func (*SyncRequest) Marshal

func (m *SyncRequest) Marshal() (dAtA []byte, err error)

func (*SyncRequest) MarshalTo

func (m *SyncRequest) MarshalTo(dAtA []byte) (int, error)

func (*SyncRequest) ProtoMessage

func (*SyncRequest) ProtoMessage()

func (*SyncRequest) Reset

func (m *SyncRequest) Reset()

func (*SyncRequest) Size

func (m *SyncRequest) Size() (n int)

func (*SyncRequest) String

func (m *SyncRequest) String() string

func (*SyncRequest) Unmarshal

func (m *SyncRequest) Unmarshal(dAtA []byte) error

type TierInfo

type TierInfo struct {
	Name            string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	IngressPolicies []string `protobuf:"bytes,2,rep,name=ingress_policies,json=ingressPolicies" json:"ingress_policies,omitempty"`
	EgressPolicies  []string `protobuf:"bytes,3,rep,name=egress_policies,json=egressPolicies" json:"egress_policies,omitempty"`
}

func (*TierInfo) Descriptor

func (*TierInfo) Descriptor() ([]byte, []int)

func (*TierInfo) GetEgressPolicies

func (m *TierInfo) GetEgressPolicies() []string

func (*TierInfo) GetIngressPolicies

func (m *TierInfo) GetIngressPolicies() []string

func (*TierInfo) GetName

func (m *TierInfo) GetName() string

func (*TierInfo) Marshal

func (m *TierInfo) Marshal() (dAtA []byte, err error)

func (*TierInfo) MarshalTo

func (m *TierInfo) MarshalTo(dAtA []byte) (int, error)

func (*TierInfo) ProtoMessage

func (*TierInfo) ProtoMessage()

func (*TierInfo) Reset

func (m *TierInfo) Reset()

func (*TierInfo) Size

func (m *TierInfo) Size() (n int)

func (*TierInfo) String

func (m *TierInfo) String() string

func (*TierInfo) Unmarshal

func (m *TierInfo) Unmarshal(dAtA []byte) error

type ToDataplane

type ToDataplane struct {
	// Sequence number incremented with each message.  Useful for correlating
	// messages in logs.
	SequenceNumber uint64 `protobuf:"varint,15,opt,name=sequence_number,json=sequenceNumber,proto3" json:"sequence_number,omitempty"`
	// Types that are valid to be assigned to Payload:
	//	*ToDataplane_InSync
	//	*ToDataplane_IpsetUpdate
	//	*ToDataplane_IpsetDeltaUpdate
	//	*ToDataplane_IpsetRemove
	//	*ToDataplane_ActiveProfileUpdate
	//	*ToDataplane_ActiveProfileRemove
	//	*ToDataplane_ActivePolicyUpdate
	//	*ToDataplane_ActivePolicyRemove
	//	*ToDataplane_HostEndpointUpdate
	//	*ToDataplane_HostEndpointRemove
	//	*ToDataplane_WorkloadEndpointUpdate
	//	*ToDataplane_WorkloadEndpointRemove
	//	*ToDataplane_ConfigUpdate
	//	*ToDataplane_HostMetadataUpdate
	//	*ToDataplane_HostMetadataRemove
	//	*ToDataplane_IpamPoolUpdate
	//	*ToDataplane_IpamPoolRemove
	//	*ToDataplane_ServiceAccountUpdate
	//	*ToDataplane_ServiceAccountRemove
	//	*ToDataplane_NamespaceUpdate
	//	*ToDataplane_NamespaceRemove
	//	*ToDataplane_RouteUpdate
	//	*ToDataplane_RouteRemove
	//	*ToDataplane_VtepUpdate
	//	*ToDataplane_VtepRemove
	Payload isToDataplane_Payload `protobuf_oneof:"payload"`
}

func (*ToDataplane) Descriptor

func (*ToDataplane) Descriptor() ([]byte, []int)

func (*ToDataplane) GetActivePolicyRemove

func (m *ToDataplane) GetActivePolicyRemove() *ActivePolicyRemove

func (*ToDataplane) GetActivePolicyUpdate

func (m *ToDataplane) GetActivePolicyUpdate() *ActivePolicyUpdate

func (*ToDataplane) GetActiveProfileRemove

func (m *ToDataplane) GetActiveProfileRemove() *ActiveProfileRemove

func (*ToDataplane) GetActiveProfileUpdate

func (m *ToDataplane) GetActiveProfileUpdate() *ActiveProfileUpdate

func (*ToDataplane) GetConfigUpdate

func (m *ToDataplane) GetConfigUpdate() *ConfigUpdate

func (*ToDataplane) GetHostEndpointRemove

func (m *ToDataplane) GetHostEndpointRemove() *HostEndpointRemove

func (*ToDataplane) GetHostEndpointUpdate

func (m *ToDataplane) GetHostEndpointUpdate() *HostEndpointUpdate

func (*ToDataplane) GetHostMetadataRemove

func (m *ToDataplane) GetHostMetadataRemove() *HostMetadataRemove

func (*ToDataplane) GetHostMetadataUpdate

func (m *ToDataplane) GetHostMetadataUpdate() *HostMetadataUpdate

func (*ToDataplane) GetInSync

func (m *ToDataplane) GetInSync() *InSync

func (*ToDataplane) GetIpamPoolRemove

func (m *ToDataplane) GetIpamPoolRemove() *IPAMPoolRemove

func (*ToDataplane) GetIpamPoolUpdate

func (m *ToDataplane) GetIpamPoolUpdate() *IPAMPoolUpdate

func (*ToDataplane) GetIpsetDeltaUpdate

func (m *ToDataplane) GetIpsetDeltaUpdate() *IPSetDeltaUpdate

func (*ToDataplane) GetIpsetRemove

func (m *ToDataplane) GetIpsetRemove() *IPSetRemove

func (*ToDataplane) GetIpsetUpdate

func (m *ToDataplane) GetIpsetUpdate() *IPSetUpdate

func (*ToDataplane) GetNamespaceRemove

func (m *ToDataplane) GetNamespaceRemove() *NamespaceRemove

func (*ToDataplane) GetNamespaceUpdate

func (m *ToDataplane) GetNamespaceUpdate() *NamespaceUpdate

func (*ToDataplane) GetPayload

func (m *ToDataplane) GetPayload() isToDataplane_Payload

func (*ToDataplane) GetRouteRemove

func (m *ToDataplane) GetRouteRemove() *RouteRemove

func (*ToDataplane) GetRouteUpdate

func (m *ToDataplane) GetRouteUpdate() *RouteUpdate

func (*ToDataplane) GetSequenceNumber

func (m *ToDataplane) GetSequenceNumber() uint64

func (*ToDataplane) GetServiceAccountRemove

func (m *ToDataplane) GetServiceAccountRemove() *ServiceAccountRemove

func (*ToDataplane) GetServiceAccountUpdate

func (m *ToDataplane) GetServiceAccountUpdate() *ServiceAccountUpdate

func (*ToDataplane) GetVtepRemove

func (m *ToDataplane) GetVtepRemove() *VXLANTunnelEndpointRemove

func (*ToDataplane) GetVtepUpdate

func (m *ToDataplane) GetVtepUpdate() *VXLANTunnelEndpointUpdate

func (*ToDataplane) GetWorkloadEndpointRemove

func (m *ToDataplane) GetWorkloadEndpointRemove() *WorkloadEndpointRemove

func (*ToDataplane) GetWorkloadEndpointUpdate

func (m *ToDataplane) GetWorkloadEndpointUpdate() *WorkloadEndpointUpdate

func (*ToDataplane) Marshal

func (m *ToDataplane) Marshal() (dAtA []byte, err error)

func (*ToDataplane) MarshalTo

func (m *ToDataplane) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane) ProtoMessage

func (*ToDataplane) ProtoMessage()

func (*ToDataplane) Reset

func (m *ToDataplane) Reset()

func (*ToDataplane) Size

func (m *ToDataplane) Size() (n int)

func (*ToDataplane) String

func (m *ToDataplane) String() string

func (*ToDataplane) Unmarshal

func (m *ToDataplane) Unmarshal(dAtA []byte) error

func (*ToDataplane) XXX_OneofFuncs

func (*ToDataplane) XXX_OneofFuncs() (func(msg proto1.Message, b *proto1.Buffer) error, func(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error), func(msg proto1.Message) (n int), []interface{})

XXX_OneofFuncs is for the internal use of the proto package.

type ToDataplane_ActivePolicyRemove

type ToDataplane_ActivePolicyRemove struct {
	ActivePolicyRemove *ActivePolicyRemove `protobuf:"bytes,8,opt,name=active_policy_remove,json=activePolicyRemove,oneof"`
}

func (*ToDataplane_ActivePolicyRemove) MarshalTo

func (m *ToDataplane_ActivePolicyRemove) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_ActivePolicyRemove) Size

func (m *ToDataplane_ActivePolicyRemove) Size() (n int)

type ToDataplane_ActivePolicyUpdate

type ToDataplane_ActivePolicyUpdate struct {
	ActivePolicyUpdate *ActivePolicyUpdate `protobuf:"bytes,7,opt,name=active_policy_update,json=activePolicyUpdate,oneof"`
}

func (*ToDataplane_ActivePolicyUpdate) MarshalTo

func (m *ToDataplane_ActivePolicyUpdate) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_ActivePolicyUpdate) Size

func (m *ToDataplane_ActivePolicyUpdate) Size() (n int)

type ToDataplane_ActiveProfileRemove

type ToDataplane_ActiveProfileRemove struct {
	ActiveProfileRemove *ActiveProfileRemove `protobuf:"bytes,6,opt,name=active_profile_remove,json=activeProfileRemove,oneof"`
}

func (*ToDataplane_ActiveProfileRemove) MarshalTo

func (m *ToDataplane_ActiveProfileRemove) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_ActiveProfileRemove) Size

func (m *ToDataplane_ActiveProfileRemove) Size() (n int)

type ToDataplane_ActiveProfileUpdate

type ToDataplane_ActiveProfileUpdate struct {
	ActiveProfileUpdate *ActiveProfileUpdate `protobuf:"bytes,5,opt,name=active_profile_update,json=activeProfileUpdate,oneof"`
}

func (*ToDataplane_ActiveProfileUpdate) MarshalTo

func (m *ToDataplane_ActiveProfileUpdate) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_ActiveProfileUpdate) Size

func (m *ToDataplane_ActiveProfileUpdate) Size() (n int)

type ToDataplane_ConfigUpdate

type ToDataplane_ConfigUpdate struct {
	ConfigUpdate *ConfigUpdate `protobuf:"bytes,13,opt,name=config_update,json=configUpdate,oneof"`
}

func (*ToDataplane_ConfigUpdate) MarshalTo

func (m *ToDataplane_ConfigUpdate) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_ConfigUpdate) Size

func (m *ToDataplane_ConfigUpdate) Size() (n int)

type ToDataplane_HostEndpointRemove

type ToDataplane_HostEndpointRemove struct {
	HostEndpointRemove *HostEndpointRemove `protobuf:"bytes,10,opt,name=host_endpoint_remove,json=hostEndpointRemove,oneof"`
}

func (*ToDataplane_HostEndpointRemove) MarshalTo

func (m *ToDataplane_HostEndpointRemove) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_HostEndpointRemove) Size

func (m *ToDataplane_HostEndpointRemove) Size() (n int)

type ToDataplane_HostEndpointUpdate

type ToDataplane_HostEndpointUpdate struct {
	HostEndpointUpdate *HostEndpointUpdate `protobuf:"bytes,9,opt,name=host_endpoint_update,json=hostEndpointUpdate,oneof"`
}

func (*ToDataplane_HostEndpointUpdate) MarshalTo

func (m *ToDataplane_HostEndpointUpdate) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_HostEndpointUpdate) Size

func (m *ToDataplane_HostEndpointUpdate) Size() (n int)

type ToDataplane_HostMetadataRemove

type ToDataplane_HostMetadataRemove struct {
	HostMetadataRemove *HostMetadataRemove `protobuf:"bytes,18,opt,name=host_metadata_remove,json=hostMetadataRemove,oneof"`
}

func (*ToDataplane_HostMetadataRemove) MarshalTo

func (m *ToDataplane_HostMetadataRemove) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_HostMetadataRemove) Size

func (m *ToDataplane_HostMetadataRemove) Size() (n int)

type ToDataplane_HostMetadataUpdate

type ToDataplane_HostMetadataUpdate struct {
	HostMetadataUpdate *HostMetadataUpdate `protobuf:"bytes,14,opt,name=host_metadata_update,json=hostMetadataUpdate,oneof"`
}

func (*ToDataplane_HostMetadataUpdate) MarshalTo

func (m *ToDataplane_HostMetadataUpdate) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_HostMetadataUpdate) Size

func (m *ToDataplane_HostMetadataUpdate) Size() (n int)

type ToDataplane_InSync

type ToDataplane_InSync struct {
	InSync *InSync `protobuf:"bytes,1,opt,name=in_sync,json=inSync,oneof"`
}

func (*ToDataplane_InSync) MarshalTo

func (m *ToDataplane_InSync) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_InSync) Size

func (m *ToDataplane_InSync) Size() (n int)

type ToDataplane_IpamPoolRemove

type ToDataplane_IpamPoolRemove struct {
	IpamPoolRemove *IPAMPoolRemove `protobuf:"bytes,17,opt,name=ipam_pool_remove,json=ipamPoolRemove,oneof"`
}

func (*ToDataplane_IpamPoolRemove) MarshalTo

func (m *ToDataplane_IpamPoolRemove) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_IpamPoolRemove) Size

func (m *ToDataplane_IpamPoolRemove) Size() (n int)

type ToDataplane_IpamPoolUpdate

type ToDataplane_IpamPoolUpdate struct {
	IpamPoolUpdate *IPAMPoolUpdate `protobuf:"bytes,16,opt,name=ipam_pool_update,json=ipamPoolUpdate,oneof"`
}

func (*ToDataplane_IpamPoolUpdate) MarshalTo

func (m *ToDataplane_IpamPoolUpdate) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_IpamPoolUpdate) Size

func (m *ToDataplane_IpamPoolUpdate) Size() (n int)

type ToDataplane_IpsetDeltaUpdate

type ToDataplane_IpsetDeltaUpdate struct {
	IpsetDeltaUpdate *IPSetDeltaUpdate `protobuf:"bytes,3,opt,name=ipset_delta_update,json=ipsetDeltaUpdate,oneof"`
}

func (*ToDataplane_IpsetDeltaUpdate) MarshalTo

func (m *ToDataplane_IpsetDeltaUpdate) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_IpsetDeltaUpdate) Size

func (m *ToDataplane_IpsetDeltaUpdate) Size() (n int)

type ToDataplane_IpsetRemove

type ToDataplane_IpsetRemove struct {
	IpsetRemove *IPSetRemove `protobuf:"bytes,4,opt,name=ipset_remove,json=ipsetRemove,oneof"`
}

func (*ToDataplane_IpsetRemove) MarshalTo

func (m *ToDataplane_IpsetRemove) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_IpsetRemove) Size

func (m *ToDataplane_IpsetRemove) Size() (n int)

type ToDataplane_IpsetUpdate

type ToDataplane_IpsetUpdate struct {
	IpsetUpdate *IPSetUpdate `protobuf:"bytes,2,opt,name=ipset_update,json=ipsetUpdate,oneof"`
}

func (*ToDataplane_IpsetUpdate) MarshalTo

func (m *ToDataplane_IpsetUpdate) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_IpsetUpdate) Size

func (m *ToDataplane_IpsetUpdate) Size() (n int)

type ToDataplane_NamespaceRemove

type ToDataplane_NamespaceRemove struct {
	NamespaceRemove *NamespaceRemove `protobuf:"bytes,22,opt,name=namespace_remove,json=namespaceRemove,oneof"`
}

func (*ToDataplane_NamespaceRemove) MarshalTo

func (m *ToDataplane_NamespaceRemove) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_NamespaceRemove) Size

func (m *ToDataplane_NamespaceRemove) Size() (n int)

type ToDataplane_NamespaceUpdate

type ToDataplane_NamespaceUpdate struct {
	NamespaceUpdate *NamespaceUpdate `protobuf:"bytes,21,opt,name=namespace_update,json=namespaceUpdate,oneof"`
}

func (*ToDataplane_NamespaceUpdate) MarshalTo

func (m *ToDataplane_NamespaceUpdate) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_NamespaceUpdate) Size

func (m *ToDataplane_NamespaceUpdate) Size() (n int)

type ToDataplane_RouteRemove

type ToDataplane_RouteRemove struct {
	RouteRemove *RouteRemove `protobuf:"bytes,24,opt,name=route_remove,json=routeRemove,oneof"`
}

func (*ToDataplane_RouteRemove) MarshalTo

func (m *ToDataplane_RouteRemove) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_RouteRemove) Size

func (m *ToDataplane_RouteRemove) Size() (n int)

type ToDataplane_RouteUpdate

type ToDataplane_RouteUpdate struct {
	RouteUpdate *RouteUpdate `protobuf:"bytes,23,opt,name=route_update,json=routeUpdate,oneof"`
}

func (*ToDataplane_RouteUpdate) MarshalTo

func (m *ToDataplane_RouteUpdate) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_RouteUpdate) Size

func (m *ToDataplane_RouteUpdate) Size() (n int)

type ToDataplane_ServiceAccountRemove

type ToDataplane_ServiceAccountRemove struct {
	ServiceAccountRemove *ServiceAccountRemove `protobuf:"bytes,20,opt,name=service_account_remove,json=serviceAccountRemove,oneof"`
}

func (*ToDataplane_ServiceAccountRemove) MarshalTo

func (m *ToDataplane_ServiceAccountRemove) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_ServiceAccountRemove) Size

func (m *ToDataplane_ServiceAccountRemove) Size() (n int)

type ToDataplane_ServiceAccountUpdate

type ToDataplane_ServiceAccountUpdate struct {
	ServiceAccountUpdate *ServiceAccountUpdate `protobuf:"bytes,19,opt,name=service_account_update,json=serviceAccountUpdate,oneof"`
}

func (*ToDataplane_ServiceAccountUpdate) MarshalTo

func (m *ToDataplane_ServiceAccountUpdate) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_ServiceAccountUpdate) Size

func (m *ToDataplane_ServiceAccountUpdate) Size() (n int)

type ToDataplane_VtepRemove

type ToDataplane_VtepRemove struct {
	VtepRemove *VXLANTunnelEndpointRemove `protobuf:"bytes,26,opt,name=vtep_remove,json=vtepRemove,oneof"`
}

func (*ToDataplane_VtepRemove) MarshalTo

func (m *ToDataplane_VtepRemove) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_VtepRemove) Size

func (m *ToDataplane_VtepRemove) Size() (n int)

type ToDataplane_VtepUpdate

type ToDataplane_VtepUpdate struct {
	VtepUpdate *VXLANTunnelEndpointUpdate `protobuf:"bytes,25,opt,name=vtep_update,json=vtepUpdate,oneof"`
}

func (*ToDataplane_VtepUpdate) MarshalTo

func (m *ToDataplane_VtepUpdate) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_VtepUpdate) Size

func (m *ToDataplane_VtepUpdate) Size() (n int)

type ToDataplane_WorkloadEndpointRemove

type ToDataplane_WorkloadEndpointRemove struct {
	WorkloadEndpointRemove *WorkloadEndpointRemove `protobuf:"bytes,12,opt,name=workload_endpoint_remove,json=workloadEndpointRemove,oneof"`
}

func (*ToDataplane_WorkloadEndpointRemove) MarshalTo

func (m *ToDataplane_WorkloadEndpointRemove) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_WorkloadEndpointRemove) Size

type ToDataplane_WorkloadEndpointUpdate

type ToDataplane_WorkloadEndpointUpdate struct {
	WorkloadEndpointUpdate *WorkloadEndpointUpdate `protobuf:"bytes,11,opt,name=workload_endpoint_update,json=workloadEndpointUpdate,oneof"`
}

func (*ToDataplane_WorkloadEndpointUpdate) MarshalTo

func (m *ToDataplane_WorkloadEndpointUpdate) MarshalTo(dAtA []byte) (int, error)

func (*ToDataplane_WorkloadEndpointUpdate) Size

type VXLANTunnelEndpointRemove

type VXLANTunnelEndpointRemove struct {
	Node string `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
}

func (*VXLANTunnelEndpointRemove) Descriptor

func (*VXLANTunnelEndpointRemove) Descriptor() ([]byte, []int)

func (*VXLANTunnelEndpointRemove) GetNode

func (m *VXLANTunnelEndpointRemove) GetNode() string

func (*VXLANTunnelEndpointRemove) Marshal

func (m *VXLANTunnelEndpointRemove) Marshal() (dAtA []byte, err error)

func (*VXLANTunnelEndpointRemove) MarshalTo

func (m *VXLANTunnelEndpointRemove) MarshalTo(dAtA []byte) (int, error)

func (*VXLANTunnelEndpointRemove) ProtoMessage

func (*VXLANTunnelEndpointRemove) ProtoMessage()

func (*VXLANTunnelEndpointRemove) Reset

func (m *VXLANTunnelEndpointRemove) Reset()

func (*VXLANTunnelEndpointRemove) Size

func (m *VXLANTunnelEndpointRemove) Size() (n int)

func (*VXLANTunnelEndpointRemove) String

func (m *VXLANTunnelEndpointRemove) String() string

func (*VXLANTunnelEndpointRemove) Unmarshal

func (m *VXLANTunnelEndpointRemove) Unmarshal(dAtA []byte) error

type VXLANTunnelEndpointUpdate

type VXLANTunnelEndpointUpdate struct {
	Node           string `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
	Mac            string `protobuf:"bytes,2,opt,name=mac,proto3" json:"mac,omitempty"`
	Ipv4Addr       string `protobuf:"bytes,3,opt,name=ipv4_addr,json=ipv4Addr,proto3" json:"ipv4_addr,omitempty"`
	ParentDeviceIp string `protobuf:"bytes,4,opt,name=parent_device_ip,json=parentDeviceIp,proto3" json:"parent_device_ip,omitempty"`
}

func (*VXLANTunnelEndpointUpdate) Descriptor

func (*VXLANTunnelEndpointUpdate) Descriptor() ([]byte, []int)

func (*VXLANTunnelEndpointUpdate) GetIpv4Addr

func (m *VXLANTunnelEndpointUpdate) GetIpv4Addr() string

func (*VXLANTunnelEndpointUpdate) GetMac

func (m *VXLANTunnelEndpointUpdate) GetMac() string

func (*VXLANTunnelEndpointUpdate) GetNode

func (m *VXLANTunnelEndpointUpdate) GetNode() string

func (*VXLANTunnelEndpointUpdate) GetParentDeviceIp

func (m *VXLANTunnelEndpointUpdate) GetParentDeviceIp() string

func (*VXLANTunnelEndpointUpdate) Marshal

func (m *VXLANTunnelEndpointUpdate) Marshal() (dAtA []byte, err error)

func (*VXLANTunnelEndpointUpdate) MarshalTo

func (m *VXLANTunnelEndpointUpdate) MarshalTo(dAtA []byte) (int, error)

func (*VXLANTunnelEndpointUpdate) ProtoMessage

func (*VXLANTunnelEndpointUpdate) ProtoMessage()

func (*VXLANTunnelEndpointUpdate) Reset

func (m *VXLANTunnelEndpointUpdate) Reset()

func (*VXLANTunnelEndpointUpdate) Size

func (m *VXLANTunnelEndpointUpdate) Size() (n int)

func (*VXLANTunnelEndpointUpdate) String

func (m *VXLANTunnelEndpointUpdate) String() string

func (*VXLANTunnelEndpointUpdate) Unmarshal

func (m *VXLANTunnelEndpointUpdate) Unmarshal(dAtA []byte) error

type WorkloadEndpoint

type WorkloadEndpoint struct {
	State      string      `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
	Name       string      `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Mac        string      `protobuf:"bytes,3,opt,name=mac,proto3" json:"mac,omitempty"`
	ProfileIds []string    `protobuf:"bytes,4,rep,name=profile_ids,json=profileIds" json:"profile_ids,omitempty"`
	Ipv4Nets   []string    `protobuf:"bytes,5,rep,name=ipv4_nets,json=ipv4Nets" json:"ipv4_nets,omitempty"`
	Ipv6Nets   []string    `protobuf:"bytes,6,rep,name=ipv6_nets,json=ipv6Nets" json:"ipv6_nets,omitempty"`
	Tiers      []*TierInfo `protobuf:"bytes,7,rep,name=tiers" json:"tiers,omitempty"`
	Ipv4Nat    []*NatInfo  `protobuf:"bytes,8,rep,name=ipv4_nat,json=ipv4Nat" json:"ipv4_nat,omitempty"`
	Ipv6Nat    []*NatInfo  `protobuf:"bytes,9,rep,name=ipv6_nat,json=ipv6Nat" json:"ipv6_nat,omitempty"`
}

func (*WorkloadEndpoint) Descriptor

func (*WorkloadEndpoint) Descriptor() ([]byte, []int)

func (*WorkloadEndpoint) GetIpv4Nat

func (m *WorkloadEndpoint) GetIpv4Nat() []*NatInfo

func (*WorkloadEndpoint) GetIpv4Nets

func (m *WorkloadEndpoint) GetIpv4Nets() []string

func (*WorkloadEndpoint) GetIpv6Nat

func (m *WorkloadEndpoint) GetIpv6Nat() []*NatInfo

func (*WorkloadEndpoint) GetIpv6Nets

func (m *WorkloadEndpoint) GetIpv6Nets() []string

func (*WorkloadEndpoint) GetMac

func (m *WorkloadEndpoint) GetMac() string

func (*WorkloadEndpoint) GetName

func (m *WorkloadEndpoint) GetName() string

func (*WorkloadEndpoint) GetProfileIds

func (m *WorkloadEndpoint) GetProfileIds() []string

func (*WorkloadEndpoint) GetState

func (m *WorkloadEndpoint) GetState() string

func (*WorkloadEndpoint) GetTiers

func (m *WorkloadEndpoint) GetTiers() []*TierInfo

func (*WorkloadEndpoint) Marshal

func (m *WorkloadEndpoint) Marshal() (dAtA []byte, err error)

func (*WorkloadEndpoint) MarshalTo

func (m *WorkloadEndpoint) MarshalTo(dAtA []byte) (int, error)

func (*WorkloadEndpoint) ProtoMessage

func (*WorkloadEndpoint) ProtoMessage()

func (*WorkloadEndpoint) Reset

func (m *WorkloadEndpoint) Reset()

func (*WorkloadEndpoint) Size

func (m *WorkloadEndpoint) Size() (n int)

func (*WorkloadEndpoint) String

func (m *WorkloadEndpoint) String() string

func (*WorkloadEndpoint) Unmarshal

func (m *WorkloadEndpoint) Unmarshal(dAtA []byte) error

type WorkloadEndpointID

type WorkloadEndpointID struct {
	OrchestratorId string `protobuf:"bytes,2,opt,name=orchestrator_id,json=orchestratorId,proto3" json:"orchestrator_id,omitempty"`
	WorkloadId     string `protobuf:"bytes,3,opt,name=workload_id,json=workloadId,proto3" json:"workload_id,omitempty"`
	EndpointId     string `protobuf:"bytes,4,opt,name=endpoint_id,json=endpointId,proto3" json:"endpoint_id,omitempty"`
}

func (*WorkloadEndpointID) Descriptor

func (*WorkloadEndpointID) Descriptor() ([]byte, []int)

func (*WorkloadEndpointID) GetEndpointId

func (m *WorkloadEndpointID) GetEndpointId() string

func (*WorkloadEndpointID) GetOrchestratorId

func (m *WorkloadEndpointID) GetOrchestratorId() string

func (*WorkloadEndpointID) GetWorkloadId

func (m *WorkloadEndpointID) GetWorkloadId() string

func (*WorkloadEndpointID) Marshal

func (m *WorkloadEndpointID) Marshal() (dAtA []byte, err error)

func (*WorkloadEndpointID) MarshalTo

func (m *WorkloadEndpointID) MarshalTo(dAtA []byte) (int, error)

func (*WorkloadEndpointID) ProtoMessage

func (*WorkloadEndpointID) ProtoMessage()

func (*WorkloadEndpointID) Reset

func (m *WorkloadEndpointID) Reset()

func (*WorkloadEndpointID) Size

func (m *WorkloadEndpointID) Size() (n int)

func (*WorkloadEndpointID) String

func (m *WorkloadEndpointID) String() string

func (*WorkloadEndpointID) Unmarshal

func (m *WorkloadEndpointID) Unmarshal(dAtA []byte) error

type WorkloadEndpointRemove

type WorkloadEndpointRemove struct {
	Id *WorkloadEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
}

func (*WorkloadEndpointRemove) Descriptor

func (*WorkloadEndpointRemove) Descriptor() ([]byte, []int)

func (*WorkloadEndpointRemove) GetId

func (*WorkloadEndpointRemove) Marshal

func (m *WorkloadEndpointRemove) Marshal() (dAtA []byte, err error)

func (*WorkloadEndpointRemove) MarshalTo

func (m *WorkloadEndpointRemove) MarshalTo(dAtA []byte) (int, error)

func (*WorkloadEndpointRemove) ProtoMessage

func (*WorkloadEndpointRemove) ProtoMessage()

func (*WorkloadEndpointRemove) Reset

func (m *WorkloadEndpointRemove) Reset()

func (*WorkloadEndpointRemove) Size

func (m *WorkloadEndpointRemove) Size() (n int)

func (*WorkloadEndpointRemove) String

func (m *WorkloadEndpointRemove) String() string

func (*WorkloadEndpointRemove) Unmarshal

func (m *WorkloadEndpointRemove) Unmarshal(dAtA []byte) error

type WorkloadEndpointStatusRemove

type WorkloadEndpointStatusRemove struct {
	Id *WorkloadEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
}

func (*WorkloadEndpointStatusRemove) Descriptor

func (*WorkloadEndpointStatusRemove) Descriptor() ([]byte, []int)

func (*WorkloadEndpointStatusRemove) GetId

func (*WorkloadEndpointStatusRemove) Marshal

func (m *WorkloadEndpointStatusRemove) Marshal() (dAtA []byte, err error)

func (*WorkloadEndpointStatusRemove) MarshalTo

func (m *WorkloadEndpointStatusRemove) MarshalTo(dAtA []byte) (int, error)

func (*WorkloadEndpointStatusRemove) ProtoMessage

func (*WorkloadEndpointStatusRemove) ProtoMessage()

func (*WorkloadEndpointStatusRemove) Reset

func (m *WorkloadEndpointStatusRemove) Reset()

func (*WorkloadEndpointStatusRemove) Size

func (m *WorkloadEndpointStatusRemove) Size() (n int)

func (*WorkloadEndpointStatusRemove) String

func (*WorkloadEndpointStatusRemove) Unmarshal

func (m *WorkloadEndpointStatusRemove) Unmarshal(dAtA []byte) error

type WorkloadEndpointStatusUpdate

type WorkloadEndpointStatusUpdate struct {
	Id     *WorkloadEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
	Status *EndpointStatus     `protobuf:"bytes,2,opt,name=status" json:"status,omitempty"`
}

func (*WorkloadEndpointStatusUpdate) Descriptor

func (*WorkloadEndpointStatusUpdate) Descriptor() ([]byte, []int)

func (*WorkloadEndpointStatusUpdate) GetId

func (*WorkloadEndpointStatusUpdate) GetStatus

func (*WorkloadEndpointStatusUpdate) Marshal

func (m *WorkloadEndpointStatusUpdate) Marshal() (dAtA []byte, err error)

func (*WorkloadEndpointStatusUpdate) MarshalTo

func (m *WorkloadEndpointStatusUpdate) MarshalTo(dAtA []byte) (int, error)

func (*WorkloadEndpointStatusUpdate) ProtoMessage

func (*WorkloadEndpointStatusUpdate) ProtoMessage()

func (*WorkloadEndpointStatusUpdate) Reset

func (m *WorkloadEndpointStatusUpdate) Reset()

func (*WorkloadEndpointStatusUpdate) Size

func (m *WorkloadEndpointStatusUpdate) Size() (n int)

func (*WorkloadEndpointStatusUpdate) String

func (*WorkloadEndpointStatusUpdate) Unmarshal

func (m *WorkloadEndpointStatusUpdate) Unmarshal(dAtA []byte) error

type WorkloadEndpointUpdate

type WorkloadEndpointUpdate struct {
	Id       *WorkloadEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
	Endpoint *WorkloadEndpoint   `protobuf:"bytes,5,opt,name=endpoint" json:"endpoint,omitempty"`
}

func (*WorkloadEndpointUpdate) Descriptor

func (*WorkloadEndpointUpdate) Descriptor() ([]byte, []int)

func (*WorkloadEndpointUpdate) GetEndpoint

func (m *WorkloadEndpointUpdate) GetEndpoint() *WorkloadEndpoint

func (*WorkloadEndpointUpdate) GetId

func (*WorkloadEndpointUpdate) Marshal

func (m *WorkloadEndpointUpdate) Marshal() (dAtA []byte, err error)

func (*WorkloadEndpointUpdate) MarshalTo

func (m *WorkloadEndpointUpdate) MarshalTo(dAtA []byte) (int, error)

func (*WorkloadEndpointUpdate) ProtoMessage

func (*WorkloadEndpointUpdate) ProtoMessage()

func (*WorkloadEndpointUpdate) Reset

func (m *WorkloadEndpointUpdate) Reset()

func (*WorkloadEndpointUpdate) Size

func (m *WorkloadEndpointUpdate) Size() (n int)

func (*WorkloadEndpointUpdate) String

func (m *WorkloadEndpointUpdate) String() string

func (*WorkloadEndpointUpdate) Unmarshal

func (m *WorkloadEndpointUpdate) Unmarshal(dAtA []byte) error

Jump to

Keyboard shortcuts

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