proto

package
v3.3.7+incompatible Latest Latest
Warning

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

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

Documentation

Overview

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

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

Data Model Overview

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

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

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

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

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

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

Protocol Overview

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

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

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

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

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

Handshake

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

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

Resync and updates

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

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

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

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

Graceful restart

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

Driver status updates

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

Endpoint status updates

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

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

Special cases

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

Illustration

The protocol flow is illustrated below. 

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

Example

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

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

Wire format for external dataplane driver

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

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

Package proto is a generated protocol buffer package.

It is generated from these files:
	felixbackend.proto

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

Index

Constants

This section is empty.

Variables

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

Functions

func RegisterPolicySyncServer 

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

Types

type ActivePolicyRemove 

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

func (*ActivePolicyRemove) Descriptor 

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

func (*ActivePolicyRemove) GetId 

func (m *ActivePolicyRemove) GetId() *PolicyID

func (*ActivePolicyRemove) Marshal 

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

func (*ActivePolicyRemove) MarshalTo 

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

func (*ActivePolicyRemove) ProtoMessage 

func (*ActivePolicyRemove) ProtoMessage()

func (*ActivePolicyRemove) Reset 

func (m *ActivePolicyRemove) Reset()

func (*ActivePolicyRemove) Size 

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

func (*ActivePolicyRemove) String 

func (m *ActivePolicyRemove) String() string

func (*ActivePolicyRemove) Unmarshal 

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

type ActivePolicyUpdate 

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

func (*ActivePolicyUpdate) Descriptor 

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

func (*ActivePolicyUpdate) GetId 

func (m *ActivePolicyUpdate) GetId() *PolicyID

func (*ActivePolicyUpdate) GetPolicy 

func (m *ActivePolicyUpdate) GetPolicy() *Policy

func (*ActivePolicyUpdate) Marshal 

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

func (*ActivePolicyUpdate) MarshalTo 

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

func (*ActivePolicyUpdate) ProtoMessage 

func (*ActivePolicyUpdate) ProtoMessage()

func (*ActivePolicyUpdate) Reset 

func (m *ActivePolicyUpdate) Reset()

func (*ActivePolicyUpdate) Size 

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

func (*ActivePolicyUpdate) String 

func (m *ActivePolicyUpdate) String() string

func (*ActivePolicyUpdate) Unmarshal 

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

type ActiveProfileRemove 

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

func (*ActiveProfileRemove) Descriptor 

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

func (*ActiveProfileRemove) GetId 

func (m *ActiveProfileRemove) GetId() *ProfileID

func (*ActiveProfileRemove) Marshal 

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

func (*ActiveProfileRemove) MarshalTo 

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

func (*ActiveProfileRemove) ProtoMessage 

func (*ActiveProfileRemove) ProtoMessage()

func (*ActiveProfileRemove) Reset 

func (m *ActiveProfileRemove) Reset()

func (*ActiveProfileRemove) Size 

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

func (*ActiveProfileRemove) String 

func (m *ActiveProfileRemove) String() string

func (*ActiveProfileRemove) Unmarshal 

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

type ActiveProfileUpdate 

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

func (*ActiveProfileUpdate) Descriptor 

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

func (*ActiveProfileUpdate) GetId 

func (m *ActiveProfileUpdate) GetId() *ProfileID

func (*ActiveProfileUpdate) GetProfile 

func (m *ActiveProfileUpdate) GetProfile() *Profile

func (*ActiveProfileUpdate) Marshal 

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

func (*ActiveProfileUpdate) MarshalTo 

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

func (*ActiveProfileUpdate) ProtoMessage 

func (*ActiveProfileUpdate) ProtoMessage()

func (*ActiveProfileUpdate) Reset 

func (m *ActiveProfileUpdate) Reset()

func (*ActiveProfileUpdate) Size 

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

func (*ActiveProfileUpdate) String 

func (m *ActiveProfileUpdate) String() string

func (*ActiveProfileUpdate) Unmarshal 

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

type ConfigUpdate 

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

func (*ConfigUpdate) Descriptor 

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

func (*ConfigUpdate) GetConfig 

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

func (*ConfigUpdate) Marshal 

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

func (*ConfigUpdate) MarshalTo 

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

func (*ConfigUpdate) ProtoMessage 

func (*ConfigUpdate) ProtoMessage()

func (*ConfigUpdate) Reset 

func (m *ConfigUpdate) Reset()

func (*ConfigUpdate) Size 

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

func (*ConfigUpdate) String 

func (m *ConfigUpdate) String() string

func (*ConfigUpdate) Unmarshal 

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

type EndpointStatus 

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

func (*EndpointStatus) Descriptor 

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

func (*EndpointStatus) GetStatus 

func (m *EndpointStatus) GetStatus() string

func (*EndpointStatus) Marshal 

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

func (*EndpointStatus) MarshalTo 

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

func (*EndpointStatus) ProtoMessage 

func (*EndpointStatus) ProtoMessage()

func (*EndpointStatus) Reset 

func (m *EndpointStatus) Reset()

func (*EndpointStatus) Size 

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

func (*EndpointStatus) String 

func (m *EndpointStatus) String() string

func (*EndpointStatus) Unmarshal 

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

type FromDataplane 

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

func (*FromDataplane) Descriptor 

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

func (*FromDataplane) GetHostEndpointStatusRemove 

func (m *FromDataplane) GetHostEndpointStatusRemove() *HostEndpointStatusRemove

func (*FromDataplane) GetHostEndpointStatusUpdate 

func (m *FromDataplane) GetHostEndpointStatusUpdate() *HostEndpointStatusUpdate

func (*FromDataplane) GetPayload 

func (m *FromDataplane) GetPayload() isFromDataplane_Payload

func (*FromDataplane) GetProcessStatusUpdate 

func (m *FromDataplane) GetProcessStatusUpdate() *ProcessStatusUpdate

func (*FromDataplane) GetSequenceNumber 

func (m *FromDataplane) GetSequenceNumber() uint64

func (*FromDataplane) GetWorkloadEndpointStatusRemove 

func (m *FromDataplane) GetWorkloadEndpointStatusRemove() *WorkloadEndpointStatusRemove

func (*FromDataplane) GetWorkloadEndpointStatusUpdate 

func (m *FromDataplane) GetWorkloadEndpointStatusUpdate() *WorkloadEndpointStatusUpdate

func (*FromDataplane) Marshal 

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

func (*FromDataplane) MarshalTo 

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

func (*FromDataplane) ProtoMessage 

func (*FromDataplane) ProtoMessage()

func (*FromDataplane) Reset 

func (m *FromDataplane) Reset()

func (*FromDataplane) Size 

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

func (*FromDataplane) String 

func (m *FromDataplane) String() string

func (*FromDataplane) Unmarshal 

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

func (*FromDataplane) XXX_OneofFuncs 

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

XXX_OneofFuncs is for the internal use of the proto package.

type FromDataplane_HostEndpointStatusRemove 

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

func (*FromDataplane_HostEndpointStatusRemove) MarshalTo 

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

func (*FromDataplane_HostEndpointStatusRemove) Size 

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_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 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 IPAMPool 

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

func (*IPAMPool) Descriptor 

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

func (*IPAMPool) GetCidr 

func (m *IPAMPool) GetCidr() string

func (*IPAMPool) GetMasquerade 

func (m *IPAMPool) GetMasquerade() bool

func (*IPAMPool) Marshal 

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

func (*IPAMPool) MarshalTo 

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

func (*IPAMPool) ProtoMessage 

func (*IPAMPool) ProtoMessage()

func (*IPAMPool) Reset 

func (m *IPAMPool) Reset()

func (*IPAMPool) Size 

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

func (*IPAMPool) String 

func (m *IPAMPool) String() string

func (*IPAMPool) Unmarshal 

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

type IPAMPoolRemove 

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

func (*IPAMPoolRemove) Descriptor 

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

func (*IPAMPoolRemove) GetId 

func (m *IPAMPoolRemove) GetId() string

func (*IPAMPoolRemove) Marshal 

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

func (*IPAMPoolRemove) MarshalTo 

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

func (*IPAMPoolRemove) ProtoMessage 

func (*IPAMPoolRemove) ProtoMessage()

func (*IPAMPoolRemove) Reset 

func (m *IPAMPoolRemove) Reset()

func (*IPAMPoolRemove) Size 

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

func (*IPAMPoolRemove) String 

func (m *IPAMPoolRemove) String() string

func (*IPAMPoolRemove) Unmarshal 

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

type IPAMPoolUpdate 

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

func (*IPAMPoolUpdate) Descriptor 

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

func (*IPAMPoolUpdate) GetId 

func (m *IPAMPoolUpdate) GetId() string

func (*IPAMPoolUpdate) GetPool 

func (m *IPAMPoolUpdate) GetPool() *IPAMPool

func (*IPAMPoolUpdate) Marshal 

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

func (*IPAMPoolUpdate) MarshalTo 

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

func (*IPAMPoolUpdate) ProtoMessage 

func (*IPAMPoolUpdate) ProtoMessage()

func (*IPAMPoolUpdate) Reset 

func (m *IPAMPoolUpdate) Reset()

func (*IPAMPoolUpdate) Size 

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

func (*IPAMPoolUpdate) String 

func (m *IPAMPoolUpdate) String() string

func (*IPAMPoolUpdate) Unmarshal 

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

type IPSetDeltaUpdate 

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

func (*IPSetDeltaUpdate) Descriptor 

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

func (*IPSetDeltaUpdate) GetAddedMembers 

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

func (*IPSetDeltaUpdate) GetId 

func (m *IPSetDeltaUpdate) GetId() string

func (*IPSetDeltaUpdate) GetRemovedMembers 

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

func (*IPSetDeltaUpdate) Marshal 

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

func (*IPSetDeltaUpdate) MarshalTo 

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

func (*IPSetDeltaUpdate) ProtoMessage 

func (*IPSetDeltaUpdate) ProtoMessage()

func (*IPSetDeltaUpdate) Reset 

func (m *IPSetDeltaUpdate) Reset()

func (*IPSetDeltaUpdate) Size 

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

func (*IPSetDeltaUpdate) String 

func (m *IPSetDeltaUpdate) String() string

func (*IPSetDeltaUpdate) Unmarshal 

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

type IPSetRemove 

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

func (*IPSetRemove) Descriptor 

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

func (*IPSetRemove) GetId 

func (m *IPSetRemove) GetId() string

func (*IPSetRemove) Marshal 

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

func (*IPSetRemove) MarshalTo 

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

func (*IPSetRemove) ProtoMessage 

func (*IPSetRemove) ProtoMessage()

func (*IPSetRemove) Reset 

func (m *IPSetRemove) Reset()

func (*IPSetRemove) Size 

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

func (*IPSetRemove) String 

func (m *IPSetRemove) String() string

func (*IPSetRemove) Unmarshal 

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

type IPSetUpdate 

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

func (*IPSetUpdate) Descriptor 

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

func (*IPSetUpdate) GetId 

func (m *IPSetUpdate) GetId() string

func (*IPSetUpdate) GetMembers 

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

func (*IPSetUpdate) GetType 

func (m *IPSetUpdate) GetType() IPSetUpdate_IPSetType

func (*IPSetUpdate) Marshal 

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

func (*IPSetUpdate) MarshalTo 

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

func (*IPSetUpdate) ProtoMessage 

func (*IPSetUpdate) ProtoMessage()

func (*IPSetUpdate) Reset 

func (m *IPSetUpdate) Reset()

func (*IPSetUpdate) Size 

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

func (*IPSetUpdate) String 

func (m *IPSetUpdate) String() string

func (*IPSetUpdate) Unmarshal 

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

type IPSetUpdate_IPSetType 

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

func (IPSetUpdate_IPSetType) EnumDescriptor 

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

func (IPSetUpdate_IPSetType) String 

func (x IPSetUpdate_IPSetType) String() string

type IPVersion 

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

func (IPVersion) EnumDescriptor 

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

func (IPVersion) String 

func (x IPVersion) String() string

type IcmpTypeAndCode 

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

func (*IcmpTypeAndCode) Descriptor 

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

func (*IcmpTypeAndCode) GetCode 

func (m *IcmpTypeAndCode) GetCode() int32

func (*IcmpTypeAndCode) GetType 

func (m *IcmpTypeAndCode) GetType() int32

func (*IcmpTypeAndCode) Marshal 

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

func (*IcmpTypeAndCode) MarshalTo 

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

func (*IcmpTypeAndCode) ProtoMessage 

func (*IcmpTypeAndCode) ProtoMessage()

func (*IcmpTypeAndCode) Reset 

func (m *IcmpTypeAndCode) Reset()

func (*IcmpTypeAndCode) Size 

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

func (*IcmpTypeAndCode) String 

func (m *IcmpTypeAndCode) String() string

func (*IcmpTypeAndCode) Unmarshal 

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

type InSync 

type InSync struct {
}

func (*InSync) Descriptor 

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

func (*InSync) Marshal 

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

func (*InSync) MarshalTo 

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

func (*InSync) ProtoMessage 

func (*InSync) ProtoMessage()

func (*InSync) Reset 

func (m *InSync) Reset()

func (*InSync) Size 

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

func (*InSync) String 

func (m *InSync) String() string

func (*InSync) Unmarshal 

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

type MsgStringer 

type MsgStringer struct {
	Msg interface{}
}

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

func (MsgStringer) String 

func (m MsgStringer) String() string

type NamespaceID 

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

func (*NamespaceID) Descriptor 

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

func (*NamespaceID) GetName 

func (m *NamespaceID) GetName() string

func (*NamespaceID) Marshal 

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

func (*NamespaceID) MarshalTo 

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

func (*NamespaceID) ProtoMessage 

func (*NamespaceID) ProtoMessage()

func (*NamespaceID) Reset 

func (m *NamespaceID) Reset()

func (*NamespaceID) Size 

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

func (*NamespaceID) String 

func (m *NamespaceID) String() string

func (*NamespaceID) Unmarshal 

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

type NamespaceRemove 

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

func (*NamespaceRemove) Descriptor 

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

func (*NamespaceRemove) GetId 

func (m *NamespaceRemove) GetId() *NamespaceID

func (*NamespaceRemove) Marshal 

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

func (*NamespaceRemove) MarshalTo 

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

func (*NamespaceRemove) ProtoMessage 

func (*NamespaceRemove) ProtoMessage()

func (*NamespaceRemove) Reset 

func (m *NamespaceRemove) Reset()

func (*NamespaceRemove) Size 

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

func (*NamespaceRemove) String 

func (m *NamespaceRemove) String() string

func (*NamespaceRemove) Unmarshal 

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

type NamespaceUpdate 

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

func (*NamespaceUpdate) Descriptor 

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

func (*NamespaceUpdate) GetId 

func (m *NamespaceUpdate) GetId() *NamespaceID

func (*NamespaceUpdate) GetLabels 

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

func (*NamespaceUpdate) Marshal 

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

func (*NamespaceUpdate) MarshalTo 

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

func (*NamespaceUpdate) ProtoMessage 

func (*NamespaceUpdate) ProtoMessage()

func (*NamespaceUpdate) Reset 

func (m *NamespaceUpdate) Reset()

func (*NamespaceUpdate) Size 

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

func (*NamespaceUpdate) String 

func (m *NamespaceUpdate) String() string

func (*NamespaceUpdate) Unmarshal 

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

type NatInfo 

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

func (*NatInfo) Descriptor 

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

func (*NatInfo) GetExtIp 

func (m *NatInfo) GetExtIp() string

func (*NatInfo) GetIntIp 

func (m *NatInfo) GetIntIp() string

func (*NatInfo) Marshal 

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

func (*NatInfo) MarshalTo 

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

func (*NatInfo) ProtoMessage 

func (*NatInfo) ProtoMessage()

func (*NatInfo) Reset 

func (m *NatInfo) Reset()

func (*NatInfo) Size 

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

func (*NatInfo) String 

func (m *NatInfo) String() string

func (*NatInfo) Unmarshal 

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

type Policy 

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

func (*Policy) Descriptor 

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

func (*Policy) GetInboundRules 

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

func (*Policy) GetNamespace 

func (m *Policy) GetNamespace() string

func (*Policy) GetOutboundRules 

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

func (*Policy) GetPreDnat 

func (m *Policy) GetPreDnat() bool

func (*Policy) GetUntracked 

func (m *Policy) GetUntracked() bool

func (*Policy) Marshal 

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

func (*Policy) MarshalTo 

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

func (*Policy) ProtoMessage 

func (*Policy) ProtoMessage()

func (*Policy) Reset 

func (m *Policy) Reset()

func (*Policy) Size 

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

func (*Policy) String 

func (m *Policy) String() string

func (*Policy) Unmarshal 

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

type PolicyID 

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

func (*PolicyID) Descriptor 

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

func (*PolicyID) GetName 

func (m *PolicyID) GetName() string

func (*PolicyID) GetTier 

func (m *PolicyID) GetTier() string

func (*PolicyID) Marshal 

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

func (*PolicyID) MarshalTo 

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

func (*PolicyID) ProtoMessage 

func (*PolicyID) ProtoMessage()

func (*PolicyID) Reset 

func (m *PolicyID) Reset()

func (*PolicyID) Size 

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

func (*PolicyID) String 

func (m *PolicyID) String() string

func (*PolicyID) Unmarshal 

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

type PolicySyncClient 

type PolicySyncClient interface {
	// On this API, only the following payloads will be sent:
	//  - InSync
	//  - IPSetUpdate
	//  - IPSetDeltaUpdate
	//  - IPSetRemove
	//  - ActiveProfileUpdate
	//  - ActiveProfileRemove
	//  - ActivePolicyUpdate
	//  - ActivePolicyRemove
	//  - WorkloadEndpointUpdate
	//  - WorkloadEndpointRemove
	//  - ServiceAccountUpdate
	//  - ServiceAccountRemove
	//  - NamespaceUpdate
	//  - NamespaceRemove
	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
	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 Rule 

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

func (*Rule) Descriptor 

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

func (*Rule) GetAction 

func (m *Rule) GetAction() string

func (*Rule) GetDstIpSetIds 

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

func (*Rule) GetDstNamedPortIpSetIds 

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

func (*Rule) GetDstNet 

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

func (*Rule) GetDstPorts 

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

func (*Rule) GetDstServiceAccountMatch 

func (m *Rule) GetDstServiceAccountMatch() *ServiceAccountMatch

func (*Rule) GetHttpMatch 

func (m *Rule) GetHttpMatch() *HTTPMatch

func (*Rule) GetIcmp 

func (m *Rule) GetIcmp() isRule_Icmp

func (*Rule) GetIcmpType 

func (m *Rule) GetIcmpType() int32

func (*Rule) GetIcmpTypeCode 

func (m *Rule) GetIcmpTypeCode() *IcmpTypeAndCode

func (*Rule) GetIpVersion 

func (m *Rule) GetIpVersion() IPVersion

func (*Rule) GetNotDstIpSetIds 

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

func (*Rule) GetNotDstNamedPortIpSetIds 

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

func (*Rule) GetNotDstNet 

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

func (*Rule) GetNotDstPorts 

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

func (*Rule) GetNotIcmp 

func (m *Rule) GetNotIcmp() isRule_NotIcmp

func (*Rule) GetNotIcmpType 

func (m *Rule) GetNotIcmpType() int32

func (*Rule) GetNotIcmpTypeCode 

func (m *Rule) GetNotIcmpTypeCode() *IcmpTypeAndCode

func (*Rule) GetNotProtocol 

func (m *Rule) GetNotProtocol() *Protocol

func (*Rule) GetNotSrcIpSetIds 

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

func (*Rule) GetNotSrcNamedPortIpSetIds 

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

func (*Rule) GetNotSrcNet 

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

func (*Rule) GetNotSrcPorts 

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

func (*Rule) GetOriginalDstNamespaceSelector 

func (m *Rule) GetOriginalDstNamespaceSelector() string

func (*Rule) GetOriginalDstSelector 

func (m *Rule) GetOriginalDstSelector() string

func (*Rule) GetOriginalNotDstSelector 

func (m *Rule) GetOriginalNotDstSelector() string

func (*Rule) GetOriginalNotSrcSelector 

func (m *Rule) GetOriginalNotSrcSelector() string

func (*Rule) GetOriginalSrcNamespaceSelector 

func (m *Rule) GetOriginalSrcNamespaceSelector() string

func (*Rule) GetOriginalSrcSelector 

func (m *Rule) GetOriginalSrcSelector() string

func (*Rule) GetProtocol 

func (m *Rule) GetProtocol() *Protocol

func (*Rule) GetRuleId 

func (m *Rule) GetRuleId() string

func (*Rule) GetSrcIpSetIds 

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

func (*Rule) GetSrcNamedPortIpSetIds 

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

func (*Rule) GetSrcNet 

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

func (*Rule) GetSrcPorts 

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

func (*Rule) GetSrcServiceAccountMatch 

func (m *Rule) GetSrcServiceAccountMatch() *ServiceAccountMatch

func (*Rule) Marshal 

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

func (*Rule) MarshalTo 

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

func (*Rule) ProtoMessage 

func (*Rule) ProtoMessage()

func (*Rule) Reset 

func (m *Rule) Reset()

func (*Rule) Size 

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

func (*Rule) String 

func (m *Rule) String() string

func (*Rule) Unmarshal 

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

func (*Rule) XXX_OneofFuncs 

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

XXX_OneofFuncs is for the internal use of the proto package.

type Rule_IcmpType 

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

func (*Rule_IcmpType) MarshalTo 

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

func (*Rule_IcmpType) Size 

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

type Rule_IcmpTypeCode 

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

func (*Rule_IcmpTypeCode) MarshalTo 

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

func (*Rule_IcmpTypeCode) Size 

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

type Rule_NotIcmpType 

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

func (*Rule_NotIcmpType) MarshalTo 

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

func (*Rule_NotIcmpType) Size 

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

type Rule_NotIcmpTypeCode 

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

func (*Rule_NotIcmpTypeCode) MarshalTo 

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

func (*Rule_NotIcmpTypeCode) Size 

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

type ServiceAccountID 

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

func (*ServiceAccountID) Descriptor 

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

func (*ServiceAccountID) GetName 

func (m *ServiceAccountID) GetName() string

func (*ServiceAccountID) GetNamespace 

func (m *ServiceAccountID) GetNamespace() string

func (*ServiceAccountID) Marshal 

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

func (*ServiceAccountID) MarshalTo 

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

func (*ServiceAccountID) ProtoMessage 

func (*ServiceAccountID) ProtoMessage()

func (*ServiceAccountID) Reset 

func (m *ServiceAccountID) Reset()

func (*ServiceAccountID) Size 

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

func (*ServiceAccountID) String 

func (m *ServiceAccountID) String() string

func (*ServiceAccountID) Unmarshal 

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

type ServiceAccountMatch 

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

func (*ServiceAccountMatch) Descriptor 

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

func (*ServiceAccountMatch) GetNames 

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

func (*ServiceAccountMatch) GetSelector 

func (m *ServiceAccountMatch) GetSelector() string

func (*ServiceAccountMatch) Marshal 

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

func (*ServiceAccountMatch) MarshalTo 

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

func (*ServiceAccountMatch) ProtoMessage 

func (*ServiceAccountMatch) ProtoMessage()

func (*ServiceAccountMatch) Reset 

func (m *ServiceAccountMatch) Reset()

func (*ServiceAccountMatch) Size 

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

func (*ServiceAccountMatch) String 

func (m *ServiceAccountMatch) String() string

func (*ServiceAccountMatch) Unmarshal 

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

type ServiceAccountRemove 

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

func (*ServiceAccountRemove) Descriptor 

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

func (*ServiceAccountRemove) GetId 

func (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 SyncRequest 

type SyncRequest struct {
}

func (*SyncRequest) Descriptor 

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

func (*SyncRequest) Marshal 

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

func (*SyncRequest) MarshalTo 

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

func (*SyncRequest) ProtoMessage 

func (*SyncRequest) ProtoMessage()

func (*SyncRequest) Reset 

func (m *SyncRequest) Reset()

func (*SyncRequest) Size 

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

func (*SyncRequest) String 

func (m *SyncRequest) String() string

func (*SyncRequest) Unmarshal 

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

type TierInfo 

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

func (*TierInfo) Descriptor 

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

func (*TierInfo) GetEgressPolicies 

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

func (*TierInfo) GetIngressPolicies 

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

func (*TierInfo) GetName 

func (m *TierInfo) GetName() string

func (*TierInfo) Marshal 

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

func (*TierInfo) MarshalTo 

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

func (*TierInfo) ProtoMessage 

func (*TierInfo) ProtoMessage()

func (*TierInfo) Reset 

func (m *TierInfo) Reset()

func (*TierInfo) Size 

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

func (*TierInfo) String 

func (m *TierInfo) String() string

func (*TierInfo) Unmarshal 

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

type ToDataplane 

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

func (*ToDataplane) Descriptor 

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

func (*ToDataplane) GetActivePolicyRemove 

func (m *ToDataplane) GetActivePolicyRemove() *ActivePolicyRemove

func (*ToDataplane) GetActivePolicyUpdate 

func (m *ToDataplane) GetActivePolicyUpdate() *ActivePolicyUpdate

func (*ToDataplane) GetActiveProfileRemove 

func (m *ToDataplane) GetActiveProfileRemove() *ActiveProfileRemove

func (*ToDataplane) GetActiveProfileUpdate 

func (m *ToDataplane) GetActiveProfileUpdate() *ActiveProfileUpdate

func (*ToDataplane) GetConfigUpdate 

func (m *ToDataplane) GetConfigUpdate() *ConfigUpdate

func (*ToDataplane) GetHostEndpointRemove 

func (m *ToDataplane) GetHostEndpointRemove() *HostEndpointRemove

func (*ToDataplane) GetHostEndpointUpdate 

func (m *ToDataplane) GetHostEndpointUpdate() *HostEndpointUpdate

func (*ToDataplane) GetHostMetadataRemove 

func (m *ToDataplane) GetHostMetadataRemove() *HostMetadataRemove

func (*ToDataplane) GetHostMetadataUpdate 

func (m *ToDataplane) GetHostMetadataUpdate() *HostMetadataUpdate

func (*ToDataplane) GetInSync 

func (m *ToDataplane) GetInSync() *InSync

func (*ToDataplane) GetIpamPoolRemove 

func (m *ToDataplane) GetIpamPoolRemove() *IPAMPoolRemove

func (*ToDataplane) GetIpamPoolUpdate 

func (m *ToDataplane) GetIpamPoolUpdate() *IPAMPoolUpdate

func (*ToDataplane) GetIpsetDeltaUpdate 

func (m *ToDataplane) GetIpsetDeltaUpdate() *IPSetDeltaUpdate

func (*ToDataplane) GetIpsetRemove 

func (m *ToDataplane) GetIpsetRemove() *IPSetRemove

func (*ToDataplane) GetIpsetUpdate 

func (m *ToDataplane) GetIpsetUpdate() *IPSetUpdate

func (*ToDataplane) GetNamespaceRemove 

func (m *ToDataplane) GetNamespaceRemove() *NamespaceRemove

func (*ToDataplane) GetNamespaceUpdate 

func (m *ToDataplane) GetNamespaceUpdate() *NamespaceUpdate

func (*ToDataplane) GetPayload 

func (m *ToDataplane) GetPayload() isToDataplane_Payload

func (*ToDataplane) GetSequenceNumber 

func (m *ToDataplane) GetSequenceNumber() uint64

func (*ToDataplane) GetServiceAccountRemove 

func (m *ToDataplane) GetServiceAccountRemove() *ServiceAccountRemove

func (*ToDataplane) GetServiceAccountUpdate 

func (m *ToDataplane) GetServiceAccountUpdate() *ServiceAccountUpdate

func (*ToDataplane) GetWorkloadEndpointRemove 

func (m *ToDataplane) GetWorkloadEndpointRemove() *WorkloadEndpointRemove

func (*ToDataplane) GetWorkloadEndpointUpdate 

func (m *ToDataplane) GetWorkloadEndpointUpdate() *WorkloadEndpointUpdate

func (*ToDataplane) Marshal 

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

func (*ToDataplane) MarshalTo 

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

func (*ToDataplane) ProtoMessage 

func (*ToDataplane) ProtoMessage()

func (*ToDataplane) Reset 

func (m *ToDataplane) Reset()

func (*ToDataplane) Size 

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

func (*ToDataplane) String 

func (m *ToDataplane) String() string

func (*ToDataplane) Unmarshal 

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

func (*ToDataplane) XXX_OneofFuncs 

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

XXX_OneofFuncs is for the internal use of the proto package.

type ToDataplane_ActivePolicyRemove 

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

func (*ToDataplane_ActivePolicyRemove) MarshalTo 

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

func (*ToDataplane_ActivePolicyRemove) Size 

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

type ToDataplane_ActivePolicyUpdate 

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

func (*ToDataplane_ActivePolicyUpdate) MarshalTo 

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

func (*ToDataplane_ActivePolicyUpdate) Size 

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

type ToDataplane_ActiveProfileRemove 

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

func (*ToDataplane_ActiveProfileRemove) MarshalTo 

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

func (*ToDataplane_ActiveProfileRemove) Size 

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

type ToDataplane_ActiveProfileUpdate 

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

func (*ToDataplane_ActiveProfileUpdate) MarshalTo 

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

func (*ToDataplane_ActiveProfileUpdate) Size 

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

type ToDataplane_ConfigUpdate 

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

func (*ToDataplane_ConfigUpdate) MarshalTo 

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

func (*ToDataplane_ConfigUpdate) Size 

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

type ToDataplane_HostEndpointRemove 

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

func (*ToDataplane_HostEndpointRemove) MarshalTo 

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

func (*ToDataplane_HostEndpointRemove) Size 

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

type ToDataplane_HostEndpointUpdate 

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

func (*ToDataplane_HostEndpointUpdate) MarshalTo 

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

func (*ToDataplane_HostEndpointUpdate) Size 

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

type ToDataplane_HostMetadataRemove 

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

func (*ToDataplane_HostMetadataRemove) MarshalTo 

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

func (*ToDataplane_HostMetadataRemove) Size 

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

type ToDataplane_HostMetadataUpdate 

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

func (*ToDataplane_HostMetadataUpdate) MarshalTo 

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

func (*ToDataplane_HostMetadataUpdate) Size 

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

type ToDataplane_InSync 

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

func (*ToDataplane_InSync) MarshalTo 

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

func (*ToDataplane_InSync) Size 

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

type ToDataplane_IpamPoolRemove 

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

func (*ToDataplane_IpamPoolRemove) MarshalTo 

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

func (*ToDataplane_IpamPoolRemove) Size 

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

type ToDataplane_IpamPoolUpdate 

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

func (*ToDataplane_IpamPoolUpdate) MarshalTo 

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

func (*ToDataplane_IpamPoolUpdate) Size 

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

type ToDataplane_IpsetDeltaUpdate 

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

func (*ToDataplane_IpsetDeltaUpdate) MarshalTo 

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

func (*ToDataplane_IpsetDeltaUpdate) Size 

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

type ToDataplane_IpsetRemove 

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

func (*ToDataplane_IpsetRemove) MarshalTo 

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

func (*ToDataplane_IpsetRemove) Size 

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

type ToDataplane_IpsetUpdate 

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

func (*ToDataplane_IpsetUpdate) MarshalTo 

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

func (*ToDataplane_IpsetUpdate) Size 

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

type ToDataplane_NamespaceRemove 

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

func (*ToDataplane_NamespaceRemove) MarshalTo 

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

func (*ToDataplane_NamespaceRemove) Size 

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

type ToDataplane_NamespaceUpdate 

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

func (*ToDataplane_NamespaceUpdate) MarshalTo 

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

func (*ToDataplane_NamespaceUpdate) Size 

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

type ToDataplane_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_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 WorkloadEndpoint 

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

func (*WorkloadEndpoint) Descriptor 

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

func (*WorkloadEndpoint) GetIpv4Nat 

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

func (*WorkloadEndpoint) GetIpv4Nets 

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

func (*WorkloadEndpoint) GetIpv6Nat 

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

func (*WorkloadEndpoint) GetIpv6Nets 

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

func (*WorkloadEndpoint) GetMac 

func (m *WorkloadEndpoint) GetMac() string

func (*WorkloadEndpoint) GetName 

func (m *WorkloadEndpoint) GetName() string

func (*WorkloadEndpoint) GetProfileIds 

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

func (*WorkloadEndpoint) GetState 

func (m *WorkloadEndpoint) GetState() string

func (*WorkloadEndpoint) GetTiers 

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

func (*WorkloadEndpoint) Marshal 

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

func (*WorkloadEndpoint) MarshalTo 

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

func (*WorkloadEndpoint) ProtoMessage 

func (*WorkloadEndpoint) ProtoMessage()

func (*WorkloadEndpoint) Reset 

func (m *WorkloadEndpoint) Reset()

func (*WorkloadEndpoint) Size 

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

func (*WorkloadEndpoint) String 

func (m *WorkloadEndpoint) String() string

func (*WorkloadEndpoint) Unmarshal 

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

type WorkloadEndpointID 

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

func (*WorkloadEndpointID) Descriptor 

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

func (*WorkloadEndpointID) GetEndpointId 

func (m *WorkloadEndpointID) GetEndpointId() string

func (*WorkloadEndpointID) GetOrchestratorId 

func (m *WorkloadEndpointID) GetOrchestratorId() string

func (*WorkloadEndpointID) GetWorkloadId 

func (m *WorkloadEndpointID) GetWorkloadId() string

func (*WorkloadEndpointID) Marshal 

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

func (*WorkloadEndpointID) MarshalTo 

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

func (*WorkloadEndpointID) ProtoMessage 

func (*WorkloadEndpointID) ProtoMessage()

func (*WorkloadEndpointID) Reset 

func (m *WorkloadEndpointID) Reset()

func (*WorkloadEndpointID) Size 

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

func (*WorkloadEndpointID) String 

func (m *WorkloadEndpointID) String() string

func (*WorkloadEndpointID) Unmarshal 

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

type WorkloadEndpointRemove 

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

func (*WorkloadEndpointRemove) Descriptor 

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

func (*WorkloadEndpointRemove) GetId 

func (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.