gribi

type AFTEntry struct {

	// The network_instance for which the response is being returned.
	NetworkInstance string `protobuf:"bytes,1,opt,name=network_instance,json=networkInstance,proto3" json:"network_instance,omitempty"`
	// Types that are assignable to Entry:
	//	*AFTEntry_Ipv4
	//	*AFTEntry_Ipv6
	//	*AFTEntry_Mpls
	//	*AFTEntry_NextHopGroup
	//	*AFTEntry_NextHop
	//	*AFTEntry_MacEntry
	//	*AFTEntry_PolicyForwardingEntry
	Entry isAFTEntry_Entry `protobuf_oneof:"entry"`
	// RIB programming status of the entry.
	RibStatus AFTEntry_Status `protobuf:"varint,11,opt,name=rib_status,json=ribStatus,proto3,enum=gribi.AFTEntry_Status" json:"rib_status,omitempty"`
	// FIB programming status of the entry.
	FibStatus AFTEntry_Status `protobuf:"varint,12,opt,name=fib_status,json=fibStatus,proto3,enum=gribi.AFTEntry_Status" json:"fib_status,omitempty"`
	// contains filtered or unexported fields
}

type AFTEntry_Ipv4 struct {
	// Each openconfig.AFT.* message is a protobuf transformed
	// message corresponding to the OpenConfig AFT for that
	// schema. The auto-generated paths can be found in the definition
	// of the AFTOperation.
	Ipv4 *gribi_aft.Afts_Ipv4EntryKey `protobuf:"bytes,4,opt,name=ipv4,proto3,oneof"`
}

type AFTEntry_Ipv6 struct {
	Ipv6 *gribi_aft.Afts_Ipv6EntryKey `protobuf:"bytes,5,opt,name=ipv6,proto3,oneof"`
}

type AFTEntry_MacEntry struct {
	MacEntry *gribi_aft.Afts_MacEntryKey `protobuf:"bytes,9,opt,name=mac_entry,json=macEntry,proto3,oneof"`
}

type AFTEntry_Mpls struct {
	Mpls *gribi_aft.Afts_LabelEntryKey `protobuf:"bytes,6,opt,name=mpls,proto3,oneof"`
}

type AFTEntry_NextHop struct {
	NextHop *gribi_aft.Afts_NextHopKey `protobuf:"bytes,8,opt,name=next_hop,json=nextHop,proto3,oneof"`
}

type AFTEntry_NextHopGroup struct {
	NextHopGroup *gribi_aft.Afts_NextHopGroupKey `protobuf:"bytes,7,opt,name=next_hop_group,json=nextHopGroup,proto3,oneof"`
}

type AFTEntry_PolicyForwardingEntry struct {
	PolicyForwardingEntry *gribi_aft.Afts_PolicyForwardingEntryKey `protobuf:"bytes,10,opt,name=policy_forwarding_entry,json=policyForwardingEntry,proto3,oneof"`
}

type AFTEntry_Status int32

type AFTErrorDetails struct {

	// Human-readable error message in the case that status is FAILED
	// or FIB_FAILED.
	ErrorMessage string `protobuf:"bytes,1,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"`
	// contains filtered or unexported fields
}

type AFTOperation struct {

	// Associate an ID with this specific request since this allows the client
	// to determine exactly which modifications have been completed in the
	// case that are multiple operations within the AFT.
	Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	// Network Instance (aka vrf aka routing-instance) to apply to.
	// If it is not specified, or is the empty string "",
	// then the request is considered invalid and the server should
	// respond with the INVALID_ARGUMENT error code in the status.proto
	// carried along with the RPC response.
	NetworkInstance string                 `protobuf:"bytes,2,opt,name=network_instance,json=networkInstance,proto3" json:"network_instance,omitempty"`
	Op              AFTOperation_Operation `protobuf:"varint,3,opt,name=op,proto3,enum=gribi.AFTOperation_Operation" json:"op,omitempty"`
	// Types that are assignable to Entry:
	//	*AFTOperation_Ipv4
	//	*AFTOperation_Ipv6
	//	*AFTOperation_Mpls
	//	*AFTOperation_NextHopGroup
	//	*AFTOperation_NextHop
	//	*AFTOperation_MacEntry
	//	*AFTOperation_PolicyForwardingEntry
	Entry isAFTOperation_Entry `protobuf_oneof:"entry"`
	// Election ID of the client.
	// In SINGLE_PRIMARY redundancy model, used by the server to determine
	// whether to process the AFTOperation.
	// The server processes the AFTOperation if
	// 1. the election_id in the AFTOperation is equal to the election_id last
	//    advertised in a ModifyRequest by the client
	//    AND
	// 2. the election_id in the AFTOperation is the highest election_id
	//    amongst all the election IDs that the server knows about, ie.
	//    the client is the primary client
	// If the election_id in the AFTOperation does not meet these criteria
	// the server discards the AFTOperation and returns FAILED in AFTResult
	ElectionId *Uint128 `protobuf:"bytes,11,opt,name=election_id,json=electionId,proto3" json:"election_id,omitempty"`
	// contains filtered or unexported fields
}

type AFTOperation_Ipv4 struct {
	// Each openconfig.AFT.* message is a protobuf transformed
	// message corresponding to the OpenConfig AFT for that
	// schema.
	// Schema for IPv4UnicastEntry is generated from
	// /network-instances/network-instance/afts/ipv4-unicast/ipv4-entry
	Ipv4 *gribi_aft.Afts_Ipv4EntryKey `protobuf:"bytes,4,opt,name=ipv4,proto3,oneof"`
}

type AFTOperation_Ipv6 struct {
	// Schema for IPv6UnicastEntry is generated from
	// /network-instances/network-instance/afts/ipv6-unicast/ipv6-entry
	Ipv6 *gribi_aft.Afts_Ipv6EntryKey `protobuf:"bytes,5,opt,name=ipv6,proto3,oneof"`
}

type AFTOperation_MacEntry struct {
	// Schema for MacEntry is generated from
	// /network-instances/network-instance/afts/ethernet/mac-entry
	MacEntry *gribi_aft.Afts_MacEntryKey `protobuf:"bytes,9,opt,name=mac_entry,json=macEntry,proto3,oneof"`
}

type AFTOperation_Mpls struct {
	// Schema for MPLSLabelEntry is generated from
	// /network-instances/network-instance/afts/mpls/label-entry
	Mpls *gribi_aft.Afts_LabelEntryKey `protobuf:"bytes,6,opt,name=mpls,proto3,oneof"`
}

type AFTOperation_NextHop struct {
	// Schema for NextHop is generated from
	// /network-instances/network-instance/afts/next-hops/next-hop.
	NextHop *gribi_aft.Afts_NextHopKey `protobuf:"bytes,8,opt,name=next_hop,json=nextHop,proto3,oneof"`
}

type AFTOperation_NextHopGroup struct {
	// Schema for NextHopGroup is generated from
	// /network-instances/network-instance/afts/next-hop-groups/next-hop-group
	NextHopGroup *gribi_aft.Afts_NextHopGroupKey `protobuf:"bytes,7,opt,name=next_hop_group,json=nextHopGroup,proto3,oneof"`
}

type AFTOperation_Operation int32

type AFTOperation_PolicyForwardingEntry struct {
	// Schema for PolicyForwardingGroup is generated from
	// /network-instances/network-instance/afts/policy-forwarding/
	// policy-forwarding-entry
	PolicyForwardingEntry *gribi_aft.Afts_PolicyForwardingEntryKey `protobuf:"bytes,10,opt,name=policy_forwarding_entry,json=policyForwardingEntry,proto3,oneof"`
}

type AFTResult struct {

	// The ID corresponds to the operation ID that was
	// specified in the AFTOperation.
	Id     uint64           `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Status AFTResult_Status `protobuf:"varint,2,opt,name=status,proto3,enum=gribi.AFTResult_Status" json:"status,omitempty"`
	// Timestamp corresponding to the success or failure case being reported.
	// The timestamp reflects the time at which the gRIBI daemon received and
	// processed the acknowledgement that the entry was programmed. The typical
	// use for this timestamp is to provide tracking of programming SLIs at the
	// device.
	//
	// The timestamp is expressed as nanoseconds since the Unix Epoch in UTC.
	Timestamp int64 `protobuf:"varint,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// Contains error details if status is FAILED or FIB_FAILED.
	ErrorDetails *AFTErrorDetails `protobuf:"bytes,4,opt,name=error_details,json=errorDetails,proto3" json:"error_details,omitempty"`
	// contains filtered or unexported fields
}

type AFTResult_Status int32

type AFTType int32

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

type FlushRequest struct {

	// election specifies the election ID from a client. It is valid only
	// when the server has clients that are operating in the SINGLE_PRIMARY mode.
	// If the client does not supply one of the messages within election, the
	// server should respond with an error with canonical code
	// FAILED_PRECONDITION, and specifying UNSPECIFIED_ELECTION_BEHAVIOR in the
	// FlushResponseError in the details returned.
	//
	// Types that are assignable to Election:
	//	*FlushRequest_Id
	//	*FlushRequest_Override
	Election isFlushRequest_Election `protobuf_oneof:"election"`
	// network_instance specifies the Network Instance that should be flushed. If
	// the client specifies neither name nor all the server should respond with
	// an error specifying the INVALID_ARGUMENT canonical error code, and the
	// UNSPECIFIED_NETWORK_INSTANCE error code.
	//
	// Types that are assignable to NetworkInstance:
	//	*FlushRequest_Name
	//	*FlushRequest_All
	NetworkInstance isFlushRequest_NetworkInstance `protobuf_oneof:"network_instance"`
	// contains filtered or unexported fields
}

type FlushRequest_All struct {
	// all indicates that entries for all network instances should be
	// flushed.
	All *Empty `protobuf:"bytes,4,opt,name=all,proto3,oneof"`
}

type FlushRequest_Id struct {
	// id indicates that the Flush ID supplied should be compared to the
	// existing election ID on the server. The logic
	// for whether the Flush RPC is accepted is the same as that which is
	// implemented for Modify. In summary:
	//
	//   - if the election ID is equal to the previous highest known ID, the
	//     Flush is accepted.
	//   - if the election ID is greater than the previous highest known ID,
	//     the Flush is accepted.
	//   - if the election ID is less than the previous highest known ID, the
	//     Flush is rejected and an error with reason NOT_PRIMARY is returned.
	//     The canonical error code used should be FAILED_PRECONDITION.
	//
	// If the server is currently operating in ALL_PRIMARY mode the server
	// should return an error specifying ELECTION_ID_IN_ALL_PRIMARY reason. The
	// status (canonical error code) should be FAILED_PRECONDITION.
	Id *Uint128 `protobuf:"bytes,1,opt,name=id,proto3,oneof"`
}

type FlushRequest_Name struct {
	// The network instance from which the entries should be flushed.
	// If name is set to "", this is considered invalid, and an error specifying
	// the INVALID_ARGUMENT canonical error code, and the
	// INVALID_NETWORK_INSTANCE reason should be specified. If the network
	// instance specified does not exist the INVALID_ARGUMENT canonical error
	// code, with the NO_SUCH_NETWORK_INSTANCE code should be specified.
	Name string `protobuf:"bytes,3,opt,name=name,proto3,oneof"`
}

type FlushRequest_Override struct {
	// override indicates that the client explicitly requests that the election
	// ID should not be compared, regardless of whether there are SINGLE_PRIMARY
	// clients on the server.
	Override *Empty `protobuf:"bytes,2,opt,name=override,proto3,oneof"`
}

type FlushResponse struct {

	// The timestamp at which the Flush operation succeeded and was returned to
	// the client. It is specified in nanoseconds since the Unix epoch.
	Timestamp int64                `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	Result    FlushResponse_Result `protobuf:"varint,2,opt,name=result,proto3,enum=gribi.FlushResponse_Result" json:"result,omitempty"`
	// contains filtered or unexported fields
}

type FlushResponseError struct {
	Status FlushResponseError_Reason `protobuf:"varint,1,opt,name=status,proto3,enum=gribi.FlushResponseError_Reason" json:"status,omitempty"`
	// contains filtered or unexported fields
}

type FlushResponseError_Reason int32

type FlushResponse_Result int32

type GRIBIClient interface {
	// Modify provides a bidirectional streaming RPC that can be used to issue
	// modifications to the AFT in the form of ModifyRequest(s).
	// The network element responds (asynchronously) with a ModifyResponse
	// for each ModifyRequest indicating what action was taken, once each
	// Operation within the request has been completed.
	Modify(ctx context.Context, opts ...grpc.CallOption) (GRIBI_ModifyClient, error)
	// Get provides a client a means to retrieve the contents of the installed
	// AFTs from the gRIBI daemon. The client requests a Get, and the server
	// responds with the set of currently installed entries (that have been ACK'd
	// according to the underlying resource to be programmed to) via the
	// GetResponse stream. Once all entries have been sent, the server closes the
	// RPC.
	//
	// The Get RPC is typically used to allow reconcilation between a client and
	// a server or for periodical consistency checking.
	Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (GRIBI_GetClient, error)
	// Flush allows a client to remove all entries currently installed on the
	// server via gRIBI. The client requests a Flush, and the server removes all
	// entries that match the context described by the FlushRequest.
	Flush(ctx context.Context, in *FlushRequest, opts ...grpc.CallOption) (*FlushResponse, error)
}

type GRIBIServer interface {
	// Modify provides a bidirectional streaming RPC that can be used to issue
	// modifications to the AFT in the form of ModifyRequest(s).
	// The network element responds (asynchronously) with a ModifyResponse
	// for each ModifyRequest indicating what action was taken, once each
	// Operation within the request has been completed.
	Modify(GRIBI_ModifyServer) error
	// Get provides a client a means to retrieve the contents of the installed
	// AFTs from the gRIBI daemon. The client requests a Get, and the server
	// responds with the set of currently installed entries (that have been ACK'd
	// according to the underlying resource to be programmed to) via the
	// GetResponse stream. Once all entries have been sent, the server closes the
	// RPC.
	//
	// The Get RPC is typically used to allow reconcilation between a client and
	// a server or for periodical consistency checking.
	Get(*GetRequest, GRIBI_GetServer) error
	// Flush allows a client to remove all entries currently installed on the
	// server via gRIBI. The client requests a Flush, and the server removes all
	// entries that match the context described by the FlushRequest.
	Flush(context.Context, *FlushRequest) (*FlushResponse, error)
	// contains filtered or unexported methods
}

type GRIBI_GetClient interface {
	Recv() (*GetResponse, error)
	grpc.ClientStream
}

type GRIBI_GetServer interface {
	Send(*GetResponse) error
	grpc.ServerStream
}

type GRIBI_ModifyClient interface {
	Send(*ModifyRequest) error
	Recv() (*ModifyResponse, error)
	grpc.ClientStream
}

type GRIBI_ModifyServer interface {
	Send(*ModifyResponse) error
	Recv() (*ModifyRequest, error)
	grpc.ServerStream
}

type GetRequest struct {

	// Types that are assignable to NetworkInstance:
	//	*GetRequest_Name
	//	*GetRequest_All
	NetworkInstance isGetRequest_NetworkInstance `protobuf_oneof:"network_instance"`
	// The AFT for which entries should be retrieved. If the AFT is
	// invalid, the server should respond with the INVALID_ARGUMENT
	// error code. If the AFT is unsupported, it should respond with
	// UNIMPLEMENTED in the status.proto carried along with the RPC
	// response.
	Aft AFTType `protobuf:"varint,3,opt,name=aft,proto3,enum=gribi.AFTType" json:"aft,omitempty"`
	// contains filtered or unexported fields
}

type GetRequest_All struct {
	// all indicates that entries for all network instances for the
	// should be returned.
	All *Empty `protobuf:"bytes,2,opt,name=all,proto3,oneof"`
}

type GetRequest_Name struct {
	// The network instance from which the entries should be retrieved.
	// If `network_instance` is nil (`name` and `all` not specified),
	// or if `name` is specified and it is the empty string "",
	// then the request is considered invalid and the server should
	// respond with the INVALID_ARGUMENT error code in the status.proto
	// carried along with the RPC response.
	Name string `protobuf:"bytes,1,opt,name=name,proto3,oneof"`
}

type GetResponse struct {

	// A set of entries that are installed on the device.
	Entry []*AFTEntry `protobuf:"bytes,1,rep,name=entry,proto3" json:"entry,omitempty"`
	// contains filtered or unexported fields
}

type ModifyRPCErrorDetails struct {
	Reason ModifyRPCErrorDetails_Reason `protobuf:"varint,1,opt,name=reason,proto3,enum=gribi.ModifyRPCErrorDetails_Reason" json:"reason,omitempty"`
	// contains filtered or unexported fields
}

type ModifyRPCErrorDetails_Reason int32

type ModifyRequest struct {

	// A group of requests to add/modify/remove a single AFT entry.
	//
	// A gRIBI server :
	//  * Should process AFTOperations per the received order.
	//  * Should not close the RPC session due to errors encountered in an
	//    AFTOperation. Invalid AFTOperations should be responded to with
	//    failures within the stream.
	//  * May finish pending AFTOperations if existing RPC session is
	//    dropped/closed/cancelled.
	Operation []*AFTOperation `protobuf:"bytes,1,rep,name=operation,proto3" json:"operation,omitempty"`
	// Meta information that the external entity sends to the network
	// element. If a non default set of parameters is required, then
	// `params` MUST be sent by the external entity before
	// it sends the network element any AFTOperations.
	// It's possible that the default set of parameters isn't supported
	// by a network element. In such a case, if the client hasn't sent
	// any session parameters, then the network element closes the Modify RPC
	// stream when the first AFTOperation is received in a ModifyRequest and
	// sets status.code
	// (http://tinyurl.com/grpc-status-proto)
	// to `UNIMPLEMENTED` and reason to `UNSUPPORTED_PARAMS`
	// in ModifyRPCErrorDetails. ModifyRPCErrorDetails is filled in
	// status.details.
	//
	// `params` MUST be sent only once during the lifetime of the session.
	// All clients programming a network element's RIB,
	// MUST send the same values of all the attributes of `params`
	//
	// The network element responds with session_params_result.status = OK in
	// ModifyResponse if it processed `params` without any error.
	//
	// The network element does not respond with session_params_result if
	// there's an error while processing `params`, instead it disconnects
	// the session and sets the RPC error code based on status.proto
	// (http://tinyurl.com/grpc-status-proto)
	// status.code is set to
	//  - UNIMPLEMENTED when it encounters an unsupported `persistence`
	//    or `ack_type` or `redundancy`
	//  - FAILED_PRECONDITION for the other cases
	// status.details is filled with the ModifyRPCErrorDetails message with
	// an appropriate `reason`.
	//
	// If the client does not send session_parameters, then the network element
	// assumes the following defaults:
	//   - ALL_PRIMARY for client redundancy
	//   - A client disconnect is treated as if the client issued DELETE
	//     AFTOperation for all the AFT entries that client ADDed.
	//   - Each AFTOperation is acknowledged with OK or FAILED in
	//     in the AFTResult of the ModifyResponse.
	Params *SessionParameters `protobuf:"bytes,2,opt,name=params,proto3" json:"params,omitempty"`
	// election_id is used by the network element to
	// select a primary client when the client redundancy mode
	// is SINGLE_PRIMARY.
	//
	// A client sends a ModifyRequest with only the election_id
	// field populated after it connects to the network element,
	// and everytime its election_id is updated (usually as a
	// result of an election amongst clients). The network element
	// responds with a ModifyResponse that has only the election_id
	// field populated. The election_id in the ModifyResponse is the
	// highest election_id that the network element has learnt
	// from any client.
	//
	// The network element selects the client with the highest
	// election_id as the primary. If the election_id sent by the
	// client matches the previous highest value, the newer client is
	// considered primary, in order to allow for a client to reconnect
	// without an external election having taken place.
	//
	// Upon discovering a failover, the server:
	//  * SHOULD stop processing pending AFTOperations that were sent by
	//    the previous primary.
	//  * MUST not send responses for AFTOperations of the previous primary
	//    to the acquiring-primary.
	//
	// Only AFT operations from the primary client are acted upon by
	// the network element. AFT operations from non-primary clients
	// are not actioned, and a failure response is sent to the client.
	//
	// If the client redundancy mode is ALL_PRIMARY, but a client
	// sends election_id, the network element closes the Modify RPC
	// stream, sets FAILED_PRECONDITION in
	// status.proto's `code` and sets ModifyRPCErrorDetails.reason
	// to ELECTION_ID_IN_ALL_PRIMARY.
	//
	// The election_id MUST be non zero. When a network element receives
	// an election_id of 0, it closes the stream with status.code
	// set to INVALID_ARGUMENT.
	// The election_id can only be increased monotonically by a client
	// during a RPC session. This simplifies server implementation.
	ElectionId *Uint128 `protobuf:"bytes,3,opt,name=election_id,json=electionId,proto3" json:"election_id,omitempty"`
	// contains filtered or unexported fields
}

type ModifyResponse struct {

	// One or more responses to requests. Clients should expect that
	// the ModifyResponse *does not* correlate to the ModifyRequest’s
	// contents.
	Result []*AFTResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"`
	// Response to the session_parameters in a ModifyRequest
	// when there are no errors.
	// If there's an error then ModifyRPCErrorDetails is filled
	// in status.proto's `details` attribute.
	SessionParamsResult *SessionParametersResult `protobuf:"bytes,2,opt,name=session_params_result,json=sessionParamsResult,proto3" json:"session_params_result,omitempty"`
	// Response to a ModifyRequest that contains only the election_id field.
	// The network element sends a ModifyResponse with only the election_id
	// populated. The value populated is the highest election_id that the
	// network element has learnt from any client.
	ElectionId *Uint128 `protobuf:"bytes,3,opt,name=election_id,json=electionId,proto3" json:"election_id,omitempty"`
	// contains filtered or unexported fields
}

type SessionParameters struct {
	Redundancy  SessionParameters_ClientRedundancy    `protobuf:"varint,1,opt,name=redundancy,proto3,enum=gribi.SessionParameters_ClientRedundancy" json:"redundancy,omitempty"`
	Persistence SessionParameters_AFTPersistence      `protobuf:"varint,2,opt,name=persistence,proto3,enum=gribi.SessionParameters_AFTPersistence" json:"persistence,omitempty"`
	AckType     SessionParameters_AFTResultStatusType `` /* 132-byte string literal not displayed */
	// contains filtered or unexported fields
}

type SessionParametersResult struct {
	Status SessionParametersResult_Status `protobuf:"varint,1,opt,name=status,proto3,enum=gribi.SessionParametersResult_Status" json:"status,omitempty"`
	// contains filtered or unexported fields
}

type SessionParametersResult_Status int32

type SessionParameters_AFTPersistence int32

type SessionParameters_AFTResultStatusType int32

type SessionParameters_ClientRedundancy int32

type Uint128 struct {
	High uint64 `protobuf:"varint,1,opt,name=high,proto3" json:"high,omitempty"`
	Low  uint64 `protobuf:"varint,2,opt,name=low,proto3" json:"low,omitempty"`
	// contains filtered or unexported fields
}

type UnimplementedGRIBIServer struct {
}

type UnsafeGRIBIServer interface {
	// contains filtered or unexported methods
}