proto

package
v1.11.0-cni-plu...-6617031 Latest Latest
Warning

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

 Go to latest Published: Nov 28, 2024 License: Apache-2.0, 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
RawConfig
InSync
IPSetUpdate
IPSetDeltaUpdate
IPSetRemove
ActiveProfileUpdate
ActiveProfileRemove
ProfileID
Profile
ActivePolicyUpdate
ActivePolicyRemove
PolicyID
Policy
Rule
ServiceAccountMatch
HTTPMatch
RuleMetadata
IcmpTypeAndCode
Protocol
PortRange
WorkloadEndpointID
WorkloadEndpointUpdate
WorkloadEndpoint
WorkloadEndpointRemove
HostEndpointID
HostEndpointUpdate
HostEndpoint
HostEndpointRemove
TierInfo
NatInfo
ProcessStatusUpdate
HostEndpointStatusUpdate
EndpointStatus
HostEndpointStatusRemove
WorkloadEndpointStatusUpdate
WorkloadEndpointStatusRemove
WireguardStatusUpdate
DataplaneInSync
HostMetadataV4V6Update
HostMetadataV4V6Remove
HostMetadataUpdate
HostMetadataRemove
HostMetadataV6Update
HostMetadataV6Remove
IPAMPoolUpdate
IPAMPoolRemove
IPAMPool
Encapsulation
ServiceAccountUpdate
ServiceAccountRemove
ServiceAccountID
NamespaceUpdate
NamespaceRemove
NamespaceID
TunnelType
RouteUpdate
RouteRemove
VXLANTunnelEndpointUpdate
VXLANTunnelEndpointRemove
WireguardEndpointUpdate
WireguardEndpointRemove
WireguardEndpointV6Update
WireguardEndpointV6Remove
GlobalBGPConfigUpdate
ServicePort
ServiceUpdate
ServiceRemove

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 IPPoolType_name = map[int32]string{
	0: "NONE",
	1: "NO_ENCAP",
	2: "VXLAN",
	3: "IPIP",
}
View Source 
var IPPoolType_value = map[string]int32{
	"NONE":     0,
	"NO_ENCAP": 1,
	"VXLAN":    2,
	"IPIP":     3,
}
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: "CIDR_INFO",
	1: "REMOTE_WORKLOAD",
	2: "REMOTE_HOST",
	3: "LOCAL_WORKLOAD",
	4: "LOCAL_HOST",
	5: "REMOTE_TUNNEL",
	6: "LOCAL_TUNNEL",
}
View Source 
var RouteType_value = map[string]int32{
	"CIDR_INFO":       0,
	"REMOTE_WORKLOAD": 1,
	"REMOTE_HOST":     2,
	"LOCAL_WORKLOAD":  3,
	"LOCAL_HOST":      4,
	"REMOTE_TUNNEL":   5,
	"LOCAL_TUNNEL":    6,
}

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 {
	Message           string                `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
	Config            map[string]string     `` /* 146-byte string literal not displayed */
	SourceToRawConfig map[uint32]*RawConfig `` /* 191-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) GetMessage 

func (m *ConfigUpdate) GetMessage() string

func (*ConfigUpdate) GetSourceToRawConfig 

func (m *ConfigUpdate) GetSourceToRawConfig() map[uint32]*RawConfig

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 DataplaneInSync 

type DataplaneInSync struct {
}

func (*DataplaneInSync) Descriptor 

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

func (*DataplaneInSync) Marshal 

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

func (*DataplaneInSync) MarshalTo 

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

func (*DataplaneInSync) ProtoMessage 

func (*DataplaneInSync) ProtoMessage()

func (*DataplaneInSync) Reset 

func (m *DataplaneInSync) Reset()

func (*DataplaneInSync) Size 

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

func (*DataplaneInSync) String 

func (m *DataplaneInSync) String() string

func (*DataplaneInSync) Unmarshal 

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

type Encapsulation 

type Encapsulation struct {
	IpipEnabled    bool `protobuf:"varint,1,opt,name=ipip_enabled,json=ipipEnabled,proto3" json:"ipip_enabled,omitempty"`
	VxlanEnabled   bool `protobuf:"varint,2,opt,name=vxlan_enabled,json=vxlanEnabled,proto3" json:"vxlan_enabled,omitempty"`
	VxlanEnabledV6 bool `protobuf:"varint,3,opt,name=vxlan_enabled_v6,json=vxlanEnabledV6,proto3" json:"vxlan_enabled_v6,omitempty"`
}

func (*Encapsulation) Descriptor 

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

func (*Encapsulation) GetIpipEnabled 

func (m *Encapsulation) GetIpipEnabled() bool

func (*Encapsulation) GetVxlanEnabled 

func (m *Encapsulation) GetVxlanEnabled() bool

func (*Encapsulation) GetVxlanEnabledV6 

func (m *Encapsulation) GetVxlanEnabledV6() bool

func (*Encapsulation) Marshal 

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

func (*Encapsulation) MarshalTo 

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

func (*Encapsulation) ProtoMessage 

func (*Encapsulation) ProtoMessage()

func (*Encapsulation) Reset 

func (m *Encapsulation) Reset()

func (*Encapsulation) Size 

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

func (*Encapsulation) String 

func (m *Encapsulation) String() string

func (*Encapsulation) Unmarshal 

func (m *Encapsulation) 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
	//	*FromDataplane_WireguardStatusUpdate
	//	*FromDataplane_DataplaneInSync
	Payload isFromDataplane_Payload `protobuf_oneof:"payload"`
}

func (*FromDataplane) Descriptor 

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

func (*FromDataplane) GetDataplaneInSync 

func (m *FromDataplane) GetDataplaneInSync() *DataplaneInSync

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) GetWireguardStatusUpdate 

func (m *FromDataplane) GetWireguardStatusUpdate() *WireguardStatusUpdate

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_DataplaneInSync 

type FromDataplane_DataplaneInSync struct {
	DataplaneInSync *DataplaneInSync `protobuf:"bytes,10,opt,name=dataplane_in_sync,json=dataplaneInSync,oneof"`
}

func (*FromDataplane_DataplaneInSync) MarshalTo 

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

func (*FromDataplane_DataplaneInSync) Size 

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

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 

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

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 

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

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_WireguardStatusUpdate 

type FromDataplane_WireguardStatusUpdate struct {
	WireguardStatusUpdate *WireguardStatusUpdate `protobuf:"bytes,9,opt,name=wireguard_status_update,json=wireguardStatusUpdate,oneof"`
}

func (*FromDataplane_WireguardStatusUpdate) MarshalTo 

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

func (*FromDataplane_WireguardStatusUpdate) Size 

func (m *FromDataplane_WireguardStatusUpdate) 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 

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

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 

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

type GlobalBGPConfigUpdate 

type GlobalBGPConfigUpdate struct {
	ServiceClusterCidrs      []string `protobuf:"bytes,1,rep,name=service_cluster_cidrs,json=serviceClusterCidrs" json:"service_cluster_cidrs,omitempty"`
	ServiceExternalCidrs     []string `protobuf:"bytes,2,rep,name=service_external_cidrs,json=serviceExternalCidrs" json:"service_external_cidrs,omitempty"`
	ServiceLoadbalancerCidrs []string `` /* 128-byte string literal not displayed */
}

func (*GlobalBGPConfigUpdate) Descriptor 

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

func (*GlobalBGPConfigUpdate) GetServiceClusterCidrs 

func (m *GlobalBGPConfigUpdate) GetServiceClusterCidrs() []string

func (*GlobalBGPConfigUpdate) GetServiceExternalCidrs 

func (m *GlobalBGPConfigUpdate) GetServiceExternalCidrs() []string

func (*GlobalBGPConfigUpdate) GetServiceLoadbalancerCidrs 

func (m *GlobalBGPConfigUpdate) GetServiceLoadbalancerCidrs() []string

func (*GlobalBGPConfigUpdate) Marshal 

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

func (*GlobalBGPConfigUpdate) MarshalTo 

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

func (*GlobalBGPConfigUpdate) ProtoMessage 

func (*GlobalBGPConfigUpdate) ProtoMessage()

func (*GlobalBGPConfigUpdate) Reset 

func (m *GlobalBGPConfigUpdate) Reset()

func (*GlobalBGPConfigUpdate) Size 

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

func (*GlobalBGPConfigUpdate) String 

func (m *GlobalBGPConfigUpdate) String() string

func (*GlobalBGPConfigUpdate) Unmarshal 

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

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 (m *HostEndpointStatusRemove) GetId() *HostEndpointID

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 (m *HostEndpointStatusUpdate) GetId() *HostEndpointID

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 HostMetadataV4V6Remove 

type HostMetadataV4V6Remove 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 (*HostMetadataV4V6Remove) Descriptor 

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

func (*HostMetadataV4V6Remove) GetHostname 

func (m *HostMetadataV4V6Remove) GetHostname() string

func (*HostMetadataV4V6Remove) GetIpv4Addr 

func (m *HostMetadataV4V6Remove) GetIpv4Addr() string

func (*HostMetadataV4V6Remove) Marshal 

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

func (*HostMetadataV4V6Remove) MarshalTo 

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

func (*HostMetadataV4V6Remove) ProtoMessage 

func (*HostMetadataV4V6Remove) ProtoMessage()

func (*HostMetadataV4V6Remove) Reset 

func (m *HostMetadataV4V6Remove) Reset()

func (*HostMetadataV4V6Remove) Size 

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

func (*HostMetadataV4V6Remove) String 

func (m *HostMetadataV4V6Remove) String() string

func (*HostMetadataV4V6Remove) Unmarshal 

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

type HostMetadataV4V6Update 

type HostMetadataV4V6Update 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"`
	Ipv6Addr string            `protobuf:"bytes,3,opt,name=ipv6_addr,json=ipv6Addr,proto3" json:"ipv6_addr,omitempty"`
	Asnumber string            `protobuf:"bytes,4,opt,name=asnumber,proto3" json:"asnumber,omitempty"`
	Labels   map[string]string `` /* 146-byte string literal not displayed */
}

func (*HostMetadataV4V6Update) Descriptor 

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

func (*HostMetadataV4V6Update) GetAsnumber 

func (m *HostMetadataV4V6Update) GetAsnumber() string

func (*HostMetadataV4V6Update) GetHostname 

func (m *HostMetadataV4V6Update) GetHostname() string

func (*HostMetadataV4V6Update) GetIpv4Addr 

func (m *HostMetadataV4V6Update) GetIpv4Addr() string

func (*HostMetadataV4V6Update) GetIpv6Addr 

func (m *HostMetadataV4V6Update) GetIpv6Addr() string

func (*HostMetadataV4V6Update) GetLabels 

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

func (*HostMetadataV4V6Update) Marshal 

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

func (*HostMetadataV4V6Update) MarshalTo 

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

func (*HostMetadataV4V6Update) ProtoMessage 

func (*HostMetadataV4V6Update) ProtoMessage()

func (*HostMetadataV4V6Update) Reset 

func (m *HostMetadataV4V6Update) Reset()

func (*HostMetadataV4V6Update) Size 

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

func (*HostMetadataV4V6Update) String 

func (m *HostMetadataV4V6Update) String() string

func (*HostMetadataV4V6Update) Unmarshal 

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

type HostMetadataV6Remove 

type HostMetadataV6Remove struct {
	Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"`
	Ipv6Addr string `protobuf:"bytes,2,opt,name=ipv6_addr,json=ipv6Addr,proto3" json:"ipv6_addr,omitempty"`
}

func (*HostMetadataV6Remove) Descriptor 

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

func (*HostMetadataV6Remove) GetHostname 

func (m *HostMetadataV6Remove) GetHostname() string

func (*HostMetadataV6Remove) GetIpv6Addr 

func (m *HostMetadataV6Remove) GetIpv6Addr() string

func (*HostMetadataV6Remove) Marshal 

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

func (*HostMetadataV6Remove) MarshalTo 

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

func (*HostMetadataV6Remove) ProtoMessage 

func (*HostMetadataV6Remove) ProtoMessage()

func (*HostMetadataV6Remove) Reset 

func (m *HostMetadataV6Remove) Reset()

func (*HostMetadataV6Remove) Size 

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

func (*HostMetadataV6Remove) String 

func (m *HostMetadataV6Remove) String() string

func (*HostMetadataV6Remove) Unmarshal 

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

type HostMetadataV6Update 

type HostMetadataV6Update struct {
	Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"`
	Ipv6Addr string `protobuf:"bytes,2,opt,name=ipv6_addr,json=ipv6Addr,proto3" json:"ipv6_addr,omitempty"`
}

func (*HostMetadataV6Update) Descriptor 

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

func (*HostMetadataV6Update) GetHostname 

func (m *HostMetadataV6Update) GetHostname() string

func (*HostMetadataV6Update) GetIpv6Addr 

func (m *HostMetadataV6Update) GetIpv6Addr() string

func (*HostMetadataV6Update) Marshal 

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

func (*HostMetadataV6Update) MarshalTo 

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

func (*HostMetadataV6Update) ProtoMessage 

func (*HostMetadataV6Update) ProtoMessage()

func (*HostMetadataV6Update) Reset 

func (m *HostMetadataV6Update) Reset()

func (*HostMetadataV6Update) Size 

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

func (*HostMetadataV6Update) String 

func (m *HostMetadataV6Update) String() string

func (*HostMetadataV6Update) Unmarshal 

func (m *HostMetadataV6Update) 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"`
	IpipMode   string `protobuf:"bytes,3,opt,name=ipip_mode,json=ipipMode,proto3" json:"ipip_mode,omitempty"`
	VxlanMode  string `protobuf:"bytes,4,opt,name=vxlan_mode,json=vxlanMode,proto3" json:"vxlan_mode,omitempty"`
}

func (*IPAMPool) Descriptor 

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

func (*IPAMPool) GetCidr 

func (m *IPAMPool) GetCidr() string

func (*IPAMPool) GetIpipMode 

func (m *IPAMPool) GetIpipMode() string

func (*IPAMPool) GetMasquerade 

func (m *IPAMPool) GetMasquerade() bool

func (*IPAMPool) GetVxlanMode 

func (m *IPAMPool) GetVxlanMode() string

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 IPPoolType 

type IPPoolType int32
const (
	IPPoolType_NONE     IPPoolType = 0
	IPPoolType_NO_ENCAP IPPoolType = 1
	IPPoolType_VXLAN    IPPoolType = 2
	IPPoolType_IPIP     IPPoolType = 3
)

func (IPPoolType) EnumDescriptor 

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

func (IPPoolType) String 

func (x IPPoolType) String() string

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"`
	OriginalSelector string  `protobuf:"bytes,6,opt,name=original_selector,json=originalSelector,proto3" json:"original_selector,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) GetOriginalSelector 

func (m *Policy) GetOriginalSelector() 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 RawConfig 

type RawConfig struct {
	Source string            `protobuf:"bytes,1,opt,name=source,proto3" json:"source,omitempty"`
	Config map[string]string `` /* 146-byte string literal not displayed */
}

func (*RawConfig) Descriptor 

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

func (*RawConfig) GetConfig 

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

func (*RawConfig) GetSource 

func (m *RawConfig) GetSource() string

func (*RawConfig) Marshal 

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

func (*RawConfig) MarshalTo 

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

func (*RawConfig) ProtoMessage 

func (*RawConfig) ProtoMessage()

func (*RawConfig) Reset 

func (m *RawConfig) Reset()

func (*RawConfig) Size 

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

func (*RawConfig) String 

func (m *RawConfig) String() string

func (*RawConfig) Unmarshal 

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

type RouteRemove 

type RouteRemove struct {
	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) 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 (
	// CIDR_INFO gives information about a CIDR without establishing a route.  For example,
	// it is emitted for IP pools with no blocks.
	RouteType_CIDR_INFO       RouteType = 0
	RouteType_REMOTE_WORKLOAD RouteType = 1
	RouteType_REMOTE_HOST     RouteType = 2
	RouteType_LOCAL_WORKLOAD  RouteType = 3
	RouteType_LOCAL_HOST      RouteType = 4
	RouteType_REMOTE_TUNNEL   RouteType = 5
	RouteType_LOCAL_TUNNEL    RouteType = 6
)

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"`
	IpPoolType IPPoolType `protobuf:"varint,2,opt,name=ip_pool_type,json=ipPoolType,proto3,enum=felix.IPPoolType" json:"ip_pool_type,omitempty"`
	Dst        string     `protobuf:"bytes,3,opt,name=dst,proto3" json:"dst,omitempty"`
	// The name of the node holding this destination, if this route targets a calico node.
	DstNodeName string `protobuf:"bytes,4,opt,name=dst_node_name,json=dstNodeName,proto3" json:"dst_node_name,omitempty"`
	// IP of the node holding this destination.
	DstNodeIp     string      `protobuf:"bytes,5,opt,name=dst_node_ip,json=dstNodeIp,proto3" json:"dst_node_ip,omitempty"`
	SameSubnet    bool        `protobuf:"varint,7,opt,name=same_subnet,json=sameSubnet,proto3" json:"same_subnet,omitempty"`
	NatOutgoing   bool        `protobuf:"varint,8,opt,name=nat_outgoing,json=natOutgoing,proto3" json:"nat_outgoing,omitempty"`
	LocalWorkload bool        `protobuf:"varint,9,opt,name=local_workload,json=localWorkload,proto3" json:"local_workload,omitempty"`
	TunnelType    *TunnelType `protobuf:"bytes,10,opt,name=tunnel_type,json=tunnelType" json:"tunnel_type,omitempty"`
}

func (*RouteUpdate) Descriptor 

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

func (*RouteUpdate) GetDst 

func (m *RouteUpdate) GetDst() string

func (*RouteUpdate) GetDstNodeIp 

func (m *RouteUpdate) GetDstNodeIp() string

func (*RouteUpdate) GetDstNodeName 

func (m *RouteUpdate) GetDstNodeName() string

func (*RouteUpdate) GetIpPoolType 

func (m *RouteUpdate) GetIpPoolType() IPPoolType

func (*RouteUpdate) GetLocalWorkload 

func (m *RouteUpdate) GetLocalWorkload() bool

func (*RouteUpdate) GetNatOutgoing 

func (m *RouteUpdate) GetNatOutgoing() bool

func (*RouteUpdate) GetSameSubnet 

func (m *RouteUpdate) GetSameSubnet() bool

func (*RouteUpdate) GetTunnelType 

func (m *RouteUpdate) GetTunnelType() *TunnelType

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"`
	// IP sets on which we should match both IP and port.
	DstIpPortSetIds []string     `protobuf:"bytes,15,rep,name=dst_ip_port_set_ids,json=dstIpPortSetIds" json:"dst_ip_port_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 */
	// Original source service match criteria.
	OriginalSrcService          string `protobuf:"bytes,132,opt,name=original_src_service,json=originalSrcService,proto3" json:"original_src_service,omitempty"`
	OriginalSrcServiceNamespace string `` /* 148-byte string literal not displayed */
	// Original destination service match criteria.
	OriginalDstService          string `protobuf:"bytes,130,opt,name=original_dst_service,json=originalDstService,proto3" json:"original_dst_service,omitempty"`
	OriginalDstServiceNamespace string `` /* 148-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"`
	Metadata  *RuleMetadata `protobuf:"bytes,123,opt,name=metadata" json:"metadata,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) GetDstIpPortSetIds 

func (m *Rule) GetDstIpPortSetIds() []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) GetMetadata 

func (m *Rule) GetMetadata() *RuleMetadata

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) GetOriginalDstService 

func (m *Rule) GetOriginalDstService() string

func (*Rule) GetOriginalDstServiceNamespace 

func (m *Rule) GetOriginalDstServiceNamespace() 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) GetOriginalSrcService 

func (m *Rule) GetOriginalSrcService() string

func (*Rule) GetOriginalSrcServiceNamespace 

func (m *Rule) GetOriginalSrcServiceNamespace() 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 RuleMetadata 

type RuleMetadata struct {
	Annotations map[string]string `` /* 156-byte string literal not displayed */
}

func (*RuleMetadata) Descriptor 

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

func (*RuleMetadata) GetAnnotations 

func (m *RuleMetadata) GetAnnotations() map[string]string

func (*RuleMetadata) Marshal 

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

func (*RuleMetadata) MarshalTo 

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

func (*RuleMetadata) ProtoMessage 

func (*RuleMetadata) ProtoMessage()

func (*RuleMetadata) Reset 

func (m *RuleMetadata) Reset()

func (*RuleMetadata) Size 

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

func (*RuleMetadata) String 

func (m *RuleMetadata) String() string

func (*RuleMetadata) Unmarshal 

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

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 (m *ServiceAccountRemove) GetId() *ServiceAccountID

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 (m *ServiceAccountUpdate) GetId() *ServiceAccountID

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 ServicePort 

type ServicePort struct {
	Protocol string `protobuf:"bytes,1,opt,name=Protocol,proto3" json:"Protocol,omitempty"`
	Port     int32  `protobuf:"varint,2,opt,name=Port,proto3" json:"Port,omitempty"`
	NodePort int32  `protobuf:"varint,3,opt,name=NodePort,proto3" json:"NodePort,omitempty"`
}

func (*ServicePort) Descriptor 

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

func (*ServicePort) GetNodePort 

func (m *ServicePort) GetNodePort() int32

func (*ServicePort) GetPort 

func (m *ServicePort) GetPort() int32

func (*ServicePort) GetProtocol 

func (m *ServicePort) GetProtocol() string

func (*ServicePort) Marshal 

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

func (*ServicePort) MarshalTo 

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

func (*ServicePort) ProtoMessage 

func (*ServicePort) ProtoMessage()

func (*ServicePort) Reset 

func (m *ServicePort) Reset()

func (*ServicePort) Size 

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

func (*ServicePort) String 

func (m *ServicePort) String() string

func (*ServicePort) Unmarshal 

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

type ServiceRemove 

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

func (*ServiceRemove) Descriptor 

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

func (*ServiceRemove) GetName 

func (m *ServiceRemove) GetName() string

func (*ServiceRemove) GetNamespace 

func (m *ServiceRemove) GetNamespace() string

func (*ServiceRemove) Marshal 

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

func (*ServiceRemove) MarshalTo 

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

func (*ServiceRemove) ProtoMessage 

func (*ServiceRemove) ProtoMessage()

func (*ServiceRemove) Reset 

func (m *ServiceRemove) Reset()

func (*ServiceRemove) Size 

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

func (*ServiceRemove) String 

func (m *ServiceRemove) String() string

func (*ServiceRemove) Unmarshal 

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

type ServiceUpdate 

type ServiceUpdate struct {
	Name           string         `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace      string         `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Type           string         `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"`
	ClusterIps     []string       `protobuf:"bytes,4,rep,name=cluster_ips,json=clusterIps" json:"cluster_ips,omitempty"`
	LoadbalancerIp string         `protobuf:"bytes,5,opt,name=loadbalancer_ip,json=loadbalancerIp,proto3" json:"loadbalancer_ip,omitempty"`
	ExternalIps    []string       `protobuf:"bytes,6,rep,name=external_ips,json=externalIps" json:"external_ips,omitempty"`
	Ports          []*ServicePort `protobuf:"bytes,7,rep,name=ports" json:"ports,omitempty"`
}

func (*ServiceUpdate) Descriptor 

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

func (*ServiceUpdate) GetClusterIps 

func (m *ServiceUpdate) GetClusterIps() []string

func (*ServiceUpdate) GetExternalIps 

func (m *ServiceUpdate) GetExternalIps() []string

func (*ServiceUpdate) GetLoadbalancerIp 

func (m *ServiceUpdate) GetLoadbalancerIp() string

func (*ServiceUpdate) GetName 

func (m *ServiceUpdate) GetName() string

func (*ServiceUpdate) GetNamespace 

func (m *ServiceUpdate) GetNamespace() string

func (*ServiceUpdate) GetPorts 

func (m *ServiceUpdate) GetPorts() []*ServicePort

func (*ServiceUpdate) GetType 

func (m *ServiceUpdate) GetType() string

func (*ServiceUpdate) Marshal 

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

func (*ServiceUpdate) MarshalTo 

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

func (*ServiceUpdate) ProtoMessage 

func (*ServiceUpdate) ProtoMessage()

func (*ServiceUpdate) Reset 

func (m *ServiceUpdate) Reset()

func (*ServiceUpdate) Size 

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

func (*ServiceUpdate) String 

func (m *ServiceUpdate) String() string

func (*ServiceUpdate) Unmarshal 

func (m *ServiceUpdate) 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"`
	DefaultAction   string   `protobuf:"bytes,4,opt,name=default_action,json=defaultAction,proto3" json:"default_action,omitempty"`
}

func (*TierInfo) Descriptor 

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

func (*TierInfo) GetDefaultAction 

func (m *TierInfo) GetDefaultAction() string

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_HostMetadataV4V6Update
	//	*ToDataplane_HostMetadataV4V6Remove
	//	*ToDataplane_IpamPoolUpdate
	//	*ToDataplane_IpamPoolRemove
	//	*ToDataplane_ServiceAccountUpdate
	//	*ToDataplane_ServiceAccountRemove
	//	*ToDataplane_NamespaceUpdate
	//	*ToDataplane_NamespaceRemove
	//	*ToDataplane_RouteUpdate
	//	*ToDataplane_RouteRemove
	//	*ToDataplane_VtepUpdate
	//	*ToDataplane_VtepRemove
	//	*ToDataplane_WireguardEndpointUpdate
	//	*ToDataplane_WireguardEndpointRemove
	//	*ToDataplane_GlobalBgpConfigUpdate
	//	*ToDataplane_Encapsulation
	//	*ToDataplane_ServiceUpdate
	//	*ToDataplane_ServiceRemove
	//	*ToDataplane_WireguardEndpointV6Update
	//	*ToDataplane_WireguardEndpointV6Remove
	//	*ToDataplane_HostMetadataV6Update
	//	*ToDataplane_HostMetadataV6Remove
	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) GetEncapsulation 

func (m *ToDataplane) GetEncapsulation() *Encapsulation

func (*ToDataplane) GetGlobalBgpConfigUpdate 

func (m *ToDataplane) GetGlobalBgpConfigUpdate() *GlobalBGPConfigUpdate

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) GetHostMetadataV4V6Remove 

func (m *ToDataplane) GetHostMetadataV4V6Remove() *HostMetadataV4V6Remove

func (*ToDataplane) GetHostMetadataV4V6Update 

func (m *ToDataplane) GetHostMetadataV4V6Update() *HostMetadataV4V6Update

func (*ToDataplane) GetHostMetadataV6Remove 

func (m *ToDataplane) GetHostMetadataV6Remove() *HostMetadataV6Remove

func (*ToDataplane) GetHostMetadataV6Update 

func (m *ToDataplane) GetHostMetadataV6Update() *HostMetadataV6Update

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) GetServiceRemove 

func (m *ToDataplane) GetServiceRemove() *ServiceRemove

func (*ToDataplane) GetServiceUpdate 

func (m *ToDataplane) GetServiceUpdate() *ServiceUpdate

func (*ToDataplane) GetVtepRemove 

func (m *ToDataplane) GetVtepRemove() *VXLANTunnelEndpointRemove

func (*ToDataplane) GetVtepUpdate 

func (m *ToDataplane) GetVtepUpdate() *VXLANTunnelEndpointUpdate

func (*ToDataplane) GetWireguardEndpointRemove 

func (m *ToDataplane) GetWireguardEndpointRemove() *WireguardEndpointRemove

func (*ToDataplane) GetWireguardEndpointUpdate 

func (m *ToDataplane) GetWireguardEndpointUpdate() *WireguardEndpointUpdate

func (*ToDataplane) GetWireguardEndpointV6Remove 

func (m *ToDataplane) GetWireguardEndpointV6Remove() *WireguardEndpointV6Remove

func (*ToDataplane) GetWireguardEndpointV6Update 

func (m *ToDataplane) GetWireguardEndpointV6Update() *WireguardEndpointV6Update

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_Encapsulation 

type ToDataplane_Encapsulation struct {
	Encapsulation *Encapsulation `protobuf:"bytes,30,opt,name=encapsulation,oneof"`
}

func (*ToDataplane_Encapsulation) MarshalTo 

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

func (*ToDataplane_Encapsulation) Size 

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

type ToDataplane_GlobalBgpConfigUpdate 

type ToDataplane_GlobalBgpConfigUpdate struct {
	GlobalBgpConfigUpdate *GlobalBGPConfigUpdate `protobuf:"bytes,29,opt,name=global_bgp_config_update,json=globalBgpConfigUpdate,oneof"`
}

func (*ToDataplane_GlobalBgpConfigUpdate) MarshalTo 

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

func (*ToDataplane_GlobalBgpConfigUpdate) Size 

func (m *ToDataplane_GlobalBgpConfigUpdate) 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_HostMetadataV4V6Remove 

type ToDataplane_HostMetadataV4V6Remove struct {
	HostMetadataV4V6Remove *HostMetadataV4V6Remove `protobuf:"bytes,38,opt,name=host_metadata_v4v6_remove,json=hostMetadataV4v6Remove,oneof"`
}

func (*ToDataplane_HostMetadataV4V6Remove) MarshalTo 

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

func (*ToDataplane_HostMetadataV4V6Remove) Size 

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

type ToDataplane_HostMetadataV4V6Update 

type ToDataplane_HostMetadataV4V6Update struct {
	HostMetadataV4V6Update *HostMetadataV4V6Update `protobuf:"bytes,37,opt,name=host_metadata_v4v6_update,json=hostMetadataV4v6Update,oneof"`
}

func (*ToDataplane_HostMetadataV4V6Update) MarshalTo 

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

func (*ToDataplane_HostMetadataV4V6Update) Size 

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

type ToDataplane_HostMetadataV6Remove 

type ToDataplane_HostMetadataV6Remove struct {
	HostMetadataV6Remove *HostMetadataV6Remove `protobuf:"bytes,36,opt,name=host_metadata_v6_remove,json=hostMetadataV6Remove,oneof"`
}

func (*ToDataplane_HostMetadataV6Remove) MarshalTo 

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

func (*ToDataplane_HostMetadataV6Remove) Size 

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

type ToDataplane_HostMetadataV6Update 

type ToDataplane_HostMetadataV6Update struct {
	HostMetadataV6Update *HostMetadataV6Update `protobuf:"bytes,35,opt,name=host_metadata_v6_update,json=hostMetadataV6Update,oneof"`
}

func (*ToDataplane_HostMetadataV6Update) MarshalTo 

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

func (*ToDataplane_HostMetadataV6Update) Size 

func (m *ToDataplane_HostMetadataV6Update) 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_ServiceRemove 

type ToDataplane_ServiceRemove struct {
	ServiceRemove *ServiceRemove `protobuf:"bytes,32,opt,name=service_remove,json=serviceRemove,oneof"`
}

func (*ToDataplane_ServiceRemove) MarshalTo 

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

func (*ToDataplane_ServiceRemove) Size 

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

type ToDataplane_ServiceUpdate 

type ToDataplane_ServiceUpdate struct {
	ServiceUpdate *ServiceUpdate `protobuf:"bytes,31,opt,name=service_update,json=serviceUpdate,oneof"`
}

func (*ToDataplane_ServiceUpdate) MarshalTo 

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

func (*ToDataplane_ServiceUpdate) Size 

func (m *ToDataplane_ServiceUpdate) 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_WireguardEndpointRemove 

type ToDataplane_WireguardEndpointRemove struct {
	WireguardEndpointRemove *WireguardEndpointRemove `protobuf:"bytes,28,opt,name=wireguard_endpoint_remove,json=wireguardEndpointRemove,oneof"`
}

func (*ToDataplane_WireguardEndpointRemove) MarshalTo 

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

func (*ToDataplane_WireguardEndpointRemove) Size 

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

type ToDataplane_WireguardEndpointUpdate 

type ToDataplane_WireguardEndpointUpdate struct {
	WireguardEndpointUpdate *WireguardEndpointUpdate `protobuf:"bytes,27,opt,name=wireguard_endpoint_update,json=wireguardEndpointUpdate,oneof"`
}

func (*ToDataplane_WireguardEndpointUpdate) MarshalTo 

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

func (*ToDataplane_WireguardEndpointUpdate) Size 

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

type ToDataplane_WireguardEndpointV6Remove 

type ToDataplane_WireguardEndpointV6Remove struct {
	WireguardEndpointV6Remove *WireguardEndpointV6Remove `protobuf:"bytes,34,opt,name=wireguard_endpoint_v6_remove,json=wireguardEndpointV6Remove,oneof"`
}

func (*ToDataplane_WireguardEndpointV6Remove) MarshalTo 

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

func (*ToDataplane_WireguardEndpointV6Remove) Size 

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

type ToDataplane_WireguardEndpointV6Update 

type ToDataplane_WireguardEndpointV6Update struct {
	WireguardEndpointV6Update *WireguardEndpointV6Update `protobuf:"bytes,33,opt,name=wireguard_endpoint_v6_update,json=wireguardEndpointV6Update,oneof"`
}

func (*ToDataplane_WireguardEndpointV6Update) MarshalTo 

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

func (*ToDataplane_WireguardEndpointV6Update) Size 

func (m *ToDataplane_WireguardEndpointV6Update) 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 

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

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 

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

type TunnelType 

type TunnelType struct {
	Ipip      bool `protobuf:"varint,1,opt,name=ipip,proto3" json:"ipip,omitempty"`
	Vxlan     bool `protobuf:"varint,2,opt,name=vxlan,proto3" json:"vxlan,omitempty"`
	Wireguard bool `protobuf:"varint,3,opt,name=wireguard,proto3" json:"wireguard,omitempty"`
}

func (*TunnelType) Descriptor 

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

func (*TunnelType) GetIpip 

func (m *TunnelType) GetIpip() bool

func (*TunnelType) GetVxlan 

func (m *TunnelType) GetVxlan() bool

func (*TunnelType) GetWireguard 

func (m *TunnelType) GetWireguard() bool

func (*TunnelType) Marshal 

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

func (*TunnelType) MarshalTo 

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

func (*TunnelType) ProtoMessage 

func (*TunnelType) ProtoMessage()

func (*TunnelType) Reset 

func (m *TunnelType) Reset()

func (*TunnelType) Size 

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

func (*TunnelType) String 

func (m *TunnelType) String() string

func (*TunnelType) Unmarshal 

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

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"`
	MacV6            string `protobuf:"bytes,5,opt,name=mac_v6,json=macV6,proto3" json:"mac_v6,omitempty"`
	Ipv6Addr         string `protobuf:"bytes,6,opt,name=ipv6_addr,json=ipv6Addr,proto3" json:"ipv6_addr,omitempty"`
	ParentDeviceIpv6 string `protobuf:"bytes,7,opt,name=parent_device_ipv6,json=parentDeviceIpv6,proto3" json:"parent_device_ipv6,omitempty"`
}

func (*VXLANTunnelEndpointUpdate) Descriptor 

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

func (*VXLANTunnelEndpointUpdate) GetIpv4Addr 

func (m *VXLANTunnelEndpointUpdate) GetIpv4Addr() string

func (*VXLANTunnelEndpointUpdate) GetIpv6Addr 

func (m *VXLANTunnelEndpointUpdate) GetIpv6Addr() string

func (*VXLANTunnelEndpointUpdate) GetMac 

func (m *VXLANTunnelEndpointUpdate) GetMac() string

func (*VXLANTunnelEndpointUpdate) GetMacV6 

func (m *VXLANTunnelEndpointUpdate) GetMacV6() string

func (*VXLANTunnelEndpointUpdate) GetNode 

func (m *VXLANTunnelEndpointUpdate) GetNode() string

func (*VXLANTunnelEndpointUpdate) GetParentDeviceIp 

func (m *VXLANTunnelEndpointUpdate) GetParentDeviceIp() string

func (*VXLANTunnelEndpointUpdate) GetParentDeviceIpv6 

func (m *VXLANTunnelEndpointUpdate) GetParentDeviceIpv6() 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 WireguardEndpointRemove 

type WireguardEndpointRemove struct {
	// The name of the IPv4 wireguard host.
	Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"`
}

func (*WireguardEndpointRemove) Descriptor 

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

func (*WireguardEndpointRemove) GetHostname 

func (m *WireguardEndpointRemove) GetHostname() string

func (*WireguardEndpointRemove) Marshal 

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

func (*WireguardEndpointRemove) MarshalTo 

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

func (*WireguardEndpointRemove) ProtoMessage 

func (*WireguardEndpointRemove) ProtoMessage()

func (*WireguardEndpointRemove) Reset 

func (m *WireguardEndpointRemove) Reset()

func (*WireguardEndpointRemove) Size 

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

func (*WireguardEndpointRemove) String 

func (m *WireguardEndpointRemove) String() string

func (*WireguardEndpointRemove) Unmarshal 

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

type WireguardEndpointUpdate 

type WireguardEndpointUpdate struct {
	// The name of the IPv4 wireguard host.
	Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"`
	// The public key for IPv4 wireguard on this endpoint.
	PublicKey string `protobuf:"bytes,2,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
	// The IP address of the IPv4 wireguard interface.
	InterfaceIpv4Addr string `protobuf:"bytes,3,opt,name=interface_ipv4_addr,json=interfaceIpv4Addr,proto3" json:"interface_ipv4_addr,omitempty"`
}

func (*WireguardEndpointUpdate) Descriptor 

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

func (*WireguardEndpointUpdate) GetHostname 

func (m *WireguardEndpointUpdate) GetHostname() string

func (*WireguardEndpointUpdate) GetInterfaceIpv4Addr 

func (m *WireguardEndpointUpdate) GetInterfaceIpv4Addr() string

func (*WireguardEndpointUpdate) GetPublicKey 

func (m *WireguardEndpointUpdate) GetPublicKey() string

func (*WireguardEndpointUpdate) Marshal 

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

func (*WireguardEndpointUpdate) MarshalTo 

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

func (*WireguardEndpointUpdate) ProtoMessage 

func (*WireguardEndpointUpdate) ProtoMessage()

func (*WireguardEndpointUpdate) Reset 

func (m *WireguardEndpointUpdate) Reset()

func (*WireguardEndpointUpdate) Size 

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

func (*WireguardEndpointUpdate) String 

func (m *WireguardEndpointUpdate) String() string

func (*WireguardEndpointUpdate) Unmarshal 

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

type WireguardEndpointV6Remove 

type WireguardEndpointV6Remove struct {
	// The name of the IPv6 wireguard host.
	Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"`
}

func (*WireguardEndpointV6Remove) Descriptor 

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

func (*WireguardEndpointV6Remove) GetHostname 

func (m *WireguardEndpointV6Remove) GetHostname() string

func (*WireguardEndpointV6Remove) Marshal 

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

func (*WireguardEndpointV6Remove) MarshalTo 

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

func (*WireguardEndpointV6Remove) ProtoMessage 

func (*WireguardEndpointV6Remove) ProtoMessage()

func (*WireguardEndpointV6Remove) Reset 

func (m *WireguardEndpointV6Remove) Reset()

func (*WireguardEndpointV6Remove) Size 

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

func (*WireguardEndpointV6Remove) String 

func (m *WireguardEndpointV6Remove) String() string

func (*WireguardEndpointV6Remove) Unmarshal 

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

type WireguardEndpointV6Update 

type WireguardEndpointV6Update struct {
	// The name of the IPv6 wireguard host.
	Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"`
	// The public key for IPv6 wireguard on this endpoint.
	PublicKeyV6 string `protobuf:"bytes,2,opt,name=public_key_v6,json=publicKeyV6,proto3" json:"public_key_v6,omitempty"`
	// The IP address of the IPv6 wireguard interface.
	InterfaceIpv6Addr string `protobuf:"bytes,3,opt,name=interface_ipv6_addr,json=interfaceIpv6Addr,proto3" json:"interface_ipv6_addr,omitempty"`
}

func (*WireguardEndpointV6Update) Descriptor 

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

func (*WireguardEndpointV6Update) GetHostname 

func (m *WireguardEndpointV6Update) GetHostname() string

func (*WireguardEndpointV6Update) GetInterfaceIpv6Addr 

func (m *WireguardEndpointV6Update) GetInterfaceIpv6Addr() string

func (*WireguardEndpointV6Update) GetPublicKeyV6 

func (m *WireguardEndpointV6Update) GetPublicKeyV6() string

func (*WireguardEndpointV6Update) Marshal 

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

func (*WireguardEndpointV6Update) MarshalTo 

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

func (*WireguardEndpointV6Update) ProtoMessage 

func (*WireguardEndpointV6Update) ProtoMessage()

func (*WireguardEndpointV6Update) Reset 

func (m *WireguardEndpointV6Update) Reset()

func (*WireguardEndpointV6Update) Size 

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

func (*WireguardEndpointV6Update) String 

func (m *WireguardEndpointV6Update) String() string

func (*WireguardEndpointV6Update) Unmarshal 

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

type WireguardStatusUpdate 

type WireguardStatusUpdate struct {
	// Wireguard public-key set on the interface.
	PublicKey string `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
	// The IP version of this update
	IpVersion IPVersion `protobuf:"varint,2,opt,name=ip_version,json=ipVersion,proto3,enum=felix.IPVersion" json:"ip_version,omitempty"`
}

func (*WireguardStatusUpdate) Descriptor 

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

func (*WireguardStatusUpdate) GetIpVersion 

func (m *WireguardStatusUpdate) GetIpVersion() IPVersion

func (*WireguardStatusUpdate) GetPublicKey 

func (m *WireguardStatusUpdate) GetPublicKey() string

func (*WireguardStatusUpdate) Marshal 

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

func (*WireguardStatusUpdate) MarshalTo 

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

func (*WireguardStatusUpdate) ProtoMessage 

func (*WireguardStatusUpdate) ProtoMessage()

func (*WireguardStatusUpdate) Reset 

func (m *WireguardStatusUpdate) Reset()

func (*WireguardStatusUpdate) Size 

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

func (*WireguardStatusUpdate) String 

func (m *WireguardStatusUpdate) String() string

func (*WireguardStatusUpdate) Unmarshal 

func (m *WireguardStatusUpdate) 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"`
	AllowSpoofedSourcePrefixes []string          `` /* 137-byte string literal not displayed */
	Annotations                map[string]string `` /* 157-byte string literal not displayed */
}

func (*WorkloadEndpoint) Descriptor 

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

func (*WorkloadEndpoint) GetAllowSpoofedSourcePrefixes 

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

func (*WorkloadEndpoint) GetAnnotations 

func (m *WorkloadEndpoint) GetAnnotations() map[string]string

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 (m *WorkloadEndpointRemove) GetId() *WorkloadEndpointID

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 (m *WorkloadEndpointStatusRemove) GetId() *WorkloadEndpointID

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 (m *WorkloadEndpointStatusRemove) String() 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 (m *WorkloadEndpointStatusUpdate) GetId() *WorkloadEndpointID

func (*WorkloadEndpointStatusUpdate) GetStatus 

func (m *WorkloadEndpointStatusUpdate) GetStatus() *EndpointStatus

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 (m *WorkloadEndpointStatusUpdate) String() 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 (m *WorkloadEndpointUpdate) GetId() *WorkloadEndpointID

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

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.