bgp_peer.sandesh

/*
 * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
 */

include "bgp/peer_info.sandesh"
include "db/db.sandesh"
include "io/io.sandesh"

struct address_family {
    1: u32 afi;            // address family identifier
    2: u32 safi;           // sub-address family
}

struct BgpPeerInfo {
    1: string domain
    2: string ip_address
    3: optional string packet_data; // Packet data byte string
}

traceobject sandesh BgpPeerObjectTrace {
    1: BgpPeerInfo peer;
}

struct BgpNeighborRoutingInstance {
    1: string name;
    2: string state;
    3: u32 index;
    4: list<string> import_targets;
}

struct BgpNeighborRoutingTable {
    1: string name;
    2: string current_state;
    3: string current_request;
    4: string pending_request;
}

struct ShowBgpNeighborFamily {
    1: string family;
    2: u32 loop_count;
    3: u32 prefix_limit;
    4: string gateway_address;
}

struct PeerCloseInfo {
    1: string state;
    17: string membership_state;
    2: bool close_again;
    16: bool non_graceful;
    3: u64 init;
    4: u64 close;
    5: u64 nested;
    6: u64 deletes;
    7: u64 stale;
    15: u64 llgr_stale;
    8: u64 sweep;
    9: u64 gr_timer;
    14: u64 llgr_timer;
}

struct BgpNeighborResp {
    53: string instance_name;
    1: string peer (link="BgpNeighborReq"); // Peer name
    36: bool deleted;           // Deletion in progress
    2: string peer_address (link="BgpNeighborReq");
    25: string peer_id;
    3: u32 peer_asn;
    6: string encoding;         // BGP/XMPP
    7: string peer_type         // internal/external
    8: string state;
    43: string closed_at;
    52: string router_type;     // bgp_schema.xsd:BgpRouterType
    47: bool admin_down;
    48: bool passive;
    55: bool as_override;
    50: u32 peer_port;
    51: string transport_address;
    4: string local_address;    // local ip address and port
    26: string local_id;
    5: u32 local_asn;
    56: u32 task_instance;
    54: optional PeerCloseInfo peer_close_info;
    9: optional string send_state;       // in sync/not in sync
    10: optional string last_event;
    11: optional string last_state;
    12: optional string last_state_at;
    13: optional string last_error;
    44: optional string auth_type;
    45: optional list<string> auth_keys;
    38: optional list<string> configured_address_families;
    39: optional list<string> negotiated_address_families;
    57: optional list<string> graceful_restart_address_families;
    58: optional list<string> long_lived_graceful_restart_address_families;
    49: optional list<ShowBgpNeighborFamily> family_attributes_list;
    59: optional u16 graceful_restart_time;
    60: optional u32 long_lived_graceful_restart_time;
    40: optional u32 configured_hold_time;
    41: u32 negotiated_hold_time;
    46: u32 primary_path_count;
    23: optional u64 flap_count;
    24: optional string flap_time;
    37: optional list<BgpNeighborRoutingInstance> routing_instances;
    29: optional list<BgpNeighborRoutingTable> routing_tables;
    30: optional peer_info.PeerProtoStats rx_proto_stats;
    31: optional peer_info.PeerProtoStats tx_proto_stats;
    32: optional peer_info.PeerUpdateStats rx_update_stats;
    33: optional peer_info.PeerUpdateStats tx_update_stats;
    34: optional peer_info.PeerSocketStats rx_socket_stats;
    35: optional peer_info.PeerSocketStats tx_socket_stats;
    42: optional peer_info.PeerRxErrorStats rx_error_stats;
}

response sandesh BgpNeighborListResp {
    1: list<BgpNeighborResp> neighbors;
    2: optional string next_batch (link="BgpNeighborReqIterate",
                                   link_title="next_batch");
}

request sandesh BgpNeighborReq {
    1: string search_string;
}

response sandesh ShowBgpNeighborSummaryResp {
    1: list<BgpNeighborResp> neighbors;
    2: optional string next_batch (link="ShowBgpNeighborSummaryReqIterate",
                                   link_title="next_batch");
}

request sandesh ShowBgpNeighborSummaryReq {
    1: string search_string;
}

struct ShowRoutePathBrief {
    1: string protocol;
    2: u32 local_preference;
    6: u32 med;
    3: string source;
    4: string next_hop;
    5: u32 label;
}

struct ShowRouteBrief {
    1: string prefix;
    2: list<ShowRoutePathBrief> paths;
}

struct ShowPmsiTunnel {
    1: string type;
    2: string ar_type;
    3: string identifier;
    4: u32 label;
    5: list<string> flags;
}

struct ShowLoadBalance {
    1: string decision_type;
    2: list<string> fields;
}

struct ShowRoutePath {
    1: string protocol;
    3: string last_modified;
    5: u32 local_preference;
    25: u32 med;
    6: u32 local_as;
    7: u32 peer_as;
    8: string peer_router_id;           // neighbor neighbor route id
    9: string source;                   // neighbor ip address
    10: string as_path;
    11: string next_hop;
    12: u32 label;
    13: bool replicated;
    14: string primary_table (link="ShowRouteReq");
    24: list<string> secondary_tables;
    15: list<string> communities;
    16: string origin_vn;
    17: list<string> flags;
    18: list<string> tunnel_encap;
    19: string sequence_no;
    20: list<string> origin_vn_path;
    21: ShowPmsiTunnel pmsi_tunnel;
    22: ShowLoadBalance load_balance;
    23: list<string> cluster_list;
}

struct ShowRoute {
    1: string prefix;
    2: string last_modified;
    3: list<ShowRoutePath> paths;
}

struct ShowRouteTable {
    1: string routing_instance (link="ShowRoutingInstanceReq");
    2: string routing_table_name (link="ShowRouteReq");
    9: bool deleted;
    11: string deleted_at;
    3: u64 prefixes;
    4: u64 paths;
    5: u64 primary_paths;
    6: u64 secondary_paths;
    7: u64 infeasible_paths;
    8: list<ShowRoute> routes;
    10: list<db.ShowTableListener> listeners;
}

response sandesh ShowRouteResp {
    1: list<ShowRouteTable> tables;
    2: optional string next_batch (link="ShowRouteReqIterate",
                                   link_title="next_batch");
}

request sandesh ShowRouteReq {
    // Show routes matching the fields below
    1: string routing_table;
    2: string routing_instance;
    3: string prefix;
    8: bool longer_match;
    // Only return this number of results, capped by an internal default max
    7: u32 count;

    // Start at the route below
    5: string start_routing_table;
    4: string start_routing_instance;
    6: string start_prefix;
}

struct ShowRouteTableSummary {
    1: string name (link="ShowRouteReq");
    3: u64 prefixes;
    4: u64 paths;
    5: u64 primary_paths;
    6: u64 secondary_paths;
    7: u64 infeasible_paths;
    8: u64 walk_requests;
    16: u64 walk_again_requests;
    9: u64 walk_completes;
    17: u64 actual_walks;
    10: u64 walk_cancels;
    11: u64 pending_updates;
    12: u64 markers;
    14: u64 listeners;
    15: u64 walkers;
    2: bool deleted;
    13: string deleted_at;
}

response sandesh ShowRouteSummaryResp {
    1: list<ShowRouteTableSummary> tables;
    2: optional string next_batch (link="ShowRouteSummaryReqIterate",
                                   link_title="next_batch");
}

request sandesh ShowRouteSummaryReq {
    1: string search_string;
}

struct ShowMembershipPeerInfo {
    1: string peer;
    2: bool ribout_registered;
    3: bool ribin_registered;
    4: u32 instance_id;
    5: u64 generation_id;
}

struct ShowTableMembershipInfo {
    1: u32 requests;
    2: u32 walks;
    3: list<ShowMembershipPeerInfo> peers;
}

struct ShowRoutingInstanceTable {
    1: string name (link="ShowRouteReq");
    13: bool deleted;
    3: u64 prefixes;
    4: u64 paths;
    5: u64 primary_paths;
    6: u64 secondary_paths;
    7: u64 infeasible_paths;
    8: u64 walk_requests;
    16: u64 walk_again_requests;
    17: u64 actual_walks;
    9: u64 walk_completes;
    10: u64 walk_cancels;
    11: u64 pending_updates;
    12: u64 markers;
    14: u64 listeners;
    15: u64 walkers;
    2: ShowTableMembershipInfo membership;
}

struct ShowInstanceRoutingPolicyInfo {
    1: string policy_name (link="ShowRoutingPolicyReq");
    2: u32 generation;
}

struct ShowRoutingInstance {
    1: string name (link="ShowRoutingInstanceReq"); // Routing instance name
    3: string virtual_network;                      // Virtual network
    6: i32 vn_index;                                // Virtual network index
    8: i32 vxlan_id;                                // VXLAN Identifier
    4: list<string> import_target;                  // Import Route targets
    5: list<string> export_target;                  // Export Route targets
    10: bool always_subscribe;                      // Always subscribe for RTF
    7: bool deleted;                                // Deletion in progress
    9: string deleted_at;                           // Delete timestamp
    2: optional list<ShowRoutingInstanceTable> tables;
    11: optional list<ShowInstanceRoutingPolicyInfo> routing_policies;
    14: optional list<string> neighbors;
}

response sandesh ShowRoutingInstanceResp {
    1: list<ShowRoutingInstance> instances;
    2: optional string next_batch (link="ShowRoutingInstanceReqIterate",
                                   link_title="next_batch");
}

request sandesh ShowRoutingInstanceReq {
    1: string search_string;
}

response sandesh ShowRoutingInstanceSummaryResp {
    1: list<ShowRoutingInstance> instances;
    2: optional string next_batch (link="ShowRoutingInstanceSummaryReqIterate",
                                   link_title="next_batch");
}

request sandesh ShowRoutingInstanceSummaryReq {
    1: string search_string;
}

struct ShowRtGroupMemberTableList {
    1: string family;
    2: list<string> tables;
}

struct ShowRtGroupInfo {
    1: string rtarget (link="ShowRtGroupReq");
    2: list<ShowRtGroupMemberTableList> import_members;
    3: list<ShowRtGroupMemberTableList> export_members;
    4: optional list<string> peers_interested;
    5: optional list<string> dep_route;
}

response sandesh ShowRtGroupResp {
    1: list<ShowRtGroupInfo> rtgroup_list;
    2: optional string next_batch (link="ShowRtGroupReqIterate",
                                   link_title="next_batch");
}

request sandesh ShowRtGroupReq {
    1: string search_string;
}

response sandesh ShowRtGroupSummaryResp {
    1: list<ShowRtGroupInfo> rtgroup_list;
    2: optional string next_batch (link="ShowRtGroupSummaryReqIterate",
                                   link_title="next_batch");
}

request sandesh ShowRtGroupSummaryReq {
    1: string search_string;
}

response sandesh ShowRtGroupPeerResp {
    1: list<ShowRtGroupInfo> rtgroup_list;
    2: optional string next_batch (link="ShowRtGroupPeerReqIterate",
                                   link_title="next_batch");
}

request sandesh ShowRtGroupPeerReq {
    1: string search_string;
}

struct ShowPathResolverPath {
    1: string prefix;
    2: string nexthop;
    3: u32 resolved_path_count;
}

struct ShowPathResolverNexthop {
    1: string address;
    2: string table;
    3: ShowRouteBrief nexthop_route;
}

struct ShowPathResolver {
    1: string name (link="ShowPathResolverReq");
    2: u32 path_count;
    3: u32 modified_path_count;
    4: u32 nexthop_count;
    5: u32 modified_nexthop_count;
    6: optional list<ShowPathResolverPath> paths;
    7: optional list<ShowPathResolverNexthop> nexthops;
}

response sandesh ShowPathResolverSummaryResp {
    1: list<ShowPathResolver> resolvers;
    2: optional string next_batch (link="ShowPathResolverSummaryReqIterate",
                                   link_title="next_batch");
}

request sandesh ShowPathResolverSummaryReq {
    1: string search_string;
}

response sandesh ShowPathResolverResp {
    1: list<ShowPathResolver> resolvers;
    2: optional string next_batch (link="ShowPathResolverReqIterate",
                                   link_title="next_batch");
}

request sandesh ShowPathResolverReq {
    1: string search_string;
}

struct ShowRibOutStatistics {
    1: string table;
    2: string encoding;
    3: string peer_type;
    4: u32 peer_as;
    5: string queue;
    6: u32 peers;
    7: u64 pending_updates;
    8: u64 markers;
    9: u64 messages_built;
    10: u64 messages_sent;
    11: u64 reach;
    12: u64 unreach;
    13: u64 tail_dequeues;
    14: u64 peer_dequeues;
    15: u64 marker_splits;
    16: u64 marker_merges;
    17: u64 marker_moves;
}

request sandesh ShowRibOutStatisticsReq {
    1: string search_string;
}

response sandesh ShowRibOutStatisticsResp {
    1: list<ShowRibOutStatistics> ribouts;
    2: optional string next_batch (link="ShowRibOutStatisticsReqIterate",
                                   link_title="next_batch");
}

struct ShowEvpnMcastLeaf {
    1: string address;
    2: string replicator;
}

struct ShowEvpnTable {
    1: string name (link="ShowRouteReq");
    2: u64 mac_routes;
    3: u64 unique_mac_routes;
    4: u64 im_routes;
    5: bool deleted;
    6: string deleted_at;
    7: optional list<string> regular_nves;
    8: optional list<string> ar_replicators;
    9: optional list<ShowEvpnMcastLeaf> ar_leafs;
}

response sandesh ShowEvpnTableResp {
    1: list<ShowEvpnTable> tables;
    2: optional string next_batch (link="ShowEvpnTableReqIterate",
                                   link_title="next_batch");
}

request sandesh ShowEvpnTableReq {
    1: string search_string;
}

response sandesh ShowEvpnTableSummaryResp {
    1: list<ShowEvpnTable> tables;
    2: optional string next_batch (link="ShowEvpnTableSummaryReqIterate",
                                   link_title="next_batch");
}

request sandesh ShowEvpnTableSummaryReq {
    1: string search_string;
}

struct ShowMulticastManager {
    1: string name (link="ShowMulticastManagerDetailReq");
    2: u32 total_trees;
    3: bool deleted;
    4: string deleted_at;
}

response sandesh ShowMulticastManagerResp {
    1: list<ShowMulticastManager> managers;
    2: optional string next_batch (link="ShowMulticastManagerReqIterate",
                                   link_title="next_batch");
}

request sandesh ShowMulticastManagerReq {
    1: string search_string;
}

struct ShowMulticastTreeLink {
    1: string address;
    2: u32 label;
}

struct ShowMulticastForwarder {
    1: string address;
    2: string label_block;
    3: u32 label;
    5: string router_id;
    4: list<ShowMulticastTreeLink> links;
}

struct ShowMulticastTree {
    1: string group;
    2: string source;
    3: list<ShowMulticastForwarder> level0_forwarders;
    4: list<ShowMulticastForwarder> level1_forwarders;
}

struct ShowBgpServiceChainConfig {
    5: string family;
    1: string routing_instance;
    2: string chain_address;
    3: list<string> prefixes;
    4: string service_instance;
}

struct ShowBgpStaticRouteConfig {
    1: string prefix;
    3: string nexthop;
    4: list<string> communities;
    2: list<string> targets;
}

struct ShowBgpInstanceRoutingPolicyConfig {
    1: string policy_name (link="ShowBgpRoutingPolicyConfigReq");
    2: string sequence;
}

struct ShowBgpRouteAggregateConfig {
    1: string prefix;
    2: string nexthop;
}

struct ShowBgpInstanceConfig {
    1: string name;
    2: string virtual_network;
    7: i32 virtual_network_index;
    8: i32 vxlan_id;
    3: list<string> import_target;
    4: list<string> export_target;
    10: bool has_pnf;
    9: string last_change_at;
    15: list<string> neighbors;
    5: list<ShowBgpServiceChainConfig> service_chain_infos;
    6: list<ShowBgpStaticRouteConfig> static_routes;
    11: list<ShowBgpRouteAggregateConfig> aggregate_routes;
    12: list<ShowBgpInstanceRoutingPolicyConfig> routing_policies;
}

response sandesh ShowBgpInstanceConfigResp {
    1: list<ShowBgpInstanceConfig> instances;
    2: optional string next_batch (link="ShowBgpInstanceConfigReqIterate",
                                   link_title="next_batch");
}

request sandesh ShowBgpInstanceConfigReq {
    1: string search_string;
}

struct ShowBgpSessionAttributesConfig {
    1: string bgp_router;
    2: list<string> address_families;
}

struct ShowBgpSessionConfig {
    1: string uuid;
    2: list<ShowBgpSessionAttributesConfig> attributes;
}

struct ShowBgpPeeringConfig {
    1: string instance_name;
    2: string name;
    3: u32 neighbor_count;
    4: list<ShowBgpSessionConfig> sessions;
}

response sandesh ShowBgpPeeringConfigResp {
    1: list<ShowBgpPeeringConfig> peerings;
    2: optional string next_batch (link="ShowBgpPeeringConfigReqIterate",
                                   link_title="next_batch");
}

request sandesh ShowBgpPeeringConfigReq {
    1: string search_string;
}

struct ShowBgpNeighborFamilyConfig {
    1: string family;
    2: i32 loop_count;
    3: i32 prefix_limit;
    4: string gateway_address;
}

struct ShowBgpNeighborConfig {
    1: string instance_name;
    2: string name;
    13: bool admin_down;
    15: bool passive;
    20: bool as_override;
    18: string router_type;
    8: string local_identifier;
    9: i32 local_as;
    3: string vendor;
    4: i32 autonomous_system;
    5: string identifier;
    6: string address;
    19: u32 source_port;
    14: i32 hold_time;
    16: i32 loop_count;
    10: string last_change_at;
    11: optional string auth_type;
    12: optional list<string> auth_keys;
    7: list<string> address_families;
    17: list<ShowBgpNeighborFamilyConfig> family_attributes_list;
}

response sandesh ShowBgpNeighborConfigResp {
    1: list<ShowBgpNeighborConfig> neighbors;
    2: optional string next_batch (link="ShowBgpNeighborConfigReqIterate",
                                   link_title="next_batch");
}

request sandesh ShowBgpNeighborConfigReq {
    1: string search_string;
}

struct ShowBgpRoutingPolicyTermConfig {
    1: optional string match;
    2: optional string action;
}

struct ShowBgpRoutingPolicyConfig {
    1: string name;
    2: list<ShowBgpRoutingPolicyTermConfig> terms;
}

response sandesh ShowBgpRoutingPolicyConfigResp {
    1: list<ShowBgpRoutingPolicyConfig> routing_policies;
    2: optional string next_batch (link="ShowBgpRoutingPolicyConfigReqIterate",
                                   link_title="next_batch");
}

request sandesh ShowBgpRoutingPolicyConfigReq {
    1: string search_string;
}

struct BgpPeerInfoData {
    1: string name (key="ObjectBgpPeer"); // RoutingInstance:RemoteEnd:LocalEnd
    2: optional bool deleted
    23: optional bool admin_down;
    24: optional bool passive;
    27: optional bool as_override;
    25: optional string router_type;      // bgp_schema.xsd:BgpRouterType
    3: optional string peer_type;         // internal/external
    20: optional string peer_address;
    4: optional u32 local_asn;
    5: optional u32 peer_asn;
    26: optional u32 peer_port;
    6: optional u32 hold_time;
    7: optional string notification_in;
    8: optional u64 notification_in_at;
    9: optional string notification_out;
   10: optional u64 notification_out_at;
   11: optional u32 local_id;
   12: optional u32 peer_id;
   13: optional string send_state;       // in sync/not in sync
   21: optional list<string> configured_families;
   14: optional list<string> families;
   22: optional list<string> negotiated_families;
   28: optional list<string> graceful_restart_families;
   29: optional list<string> long_lived_graceful_restart_families;
   30: optional u16 graceful_restart_time;
   31: optional u32 long_lived_graceful_restart_time;
   15: optional peer_info.PeerFlapInfo flap_info;
   16: optional peer_info.PeerStateInfo state_info;
   17: optional peer_info.PeerEventInfo event_info;
   18: optional string close_reason;
   19: optional peer_info.PeerStatsInfo peer_stats_info;
}

/**
 * @description: BGP Peer specific information
 * @severity: DEBUG
 * @cause: Normal operation
 */
uve sandesh BGPPeerInfo {
    1: BgpPeerInfoData data;
}

request sandesh ShowBgpServerReq {
}

response sandesh ShowBgpServerResp {
    1: io.SocketIOStats rx_socket_stats;
    2: io.SocketIOStats tx_socket_stats;
}