agent.sandesh

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

/**
 *  Message definitions for oper module
 *
 * The Oper-DB module holds operational state of different objects in Agent.
 * operational state processes the configuration and creates different tables
 * appropriate for agent.
 *
 * Some of the important tables in Oper-DB are:
 * Virtual-Network: Table of all virtual networks with uuid as key.
 * Vrf: Vrf table entries represent routing instance for a vrf.
 * Virtual-machine: Table stores all virtual-machines spawned on the compute node.
 * Interface: Table containing all interfaces in agent.
 * Other Tables for routes, nexthops, mpls label, multicast routes, vxlan
 *
 */

/**
 * Max no of sandesh connections allowed
 */
enum AgentConsts {
    MAX_SANDESH_COUNT = 256
}

/**
 * Request for oper table
 */
request sandesh PageReq {
    1: string key;
}

/**
 * Sandesh definition for oper table entries in agent introspect
 */
struct PageReqData {
    1: string prev_page (link="PageReq");
    2: string next_page (link="PageReq");
    3: string first_page (link="PageReq");
    4: string all (link="PageReq");
    5: u32 table_size;
    6: string entries;
}

/**
 * Response message fetching oper table entries
 */
response sandesh Pagination {
    1: PageReqData req;
}

/**
 * Sandesh definition for vlan entry in oper db
 */
struct ServiceVlanSandeshList {
   1: i16 tag;
   2: string vrf_name (link="VrfListReq"); // VRF name
   3: string ip_addr;
   6: string ip6_addr;
   4: i16 label;
   5: string installed;
   7: string v4_route_installed;
   8: string v6_route_installed;
}

/**
 * Sandesh definition for floatingip entry in oper db
 */
struct FloatingIpSandeshList {
   1: string ip_addr;
   2: string vrf_name (link="VrfListReq"); // VRF name
   3: string installed;
   4: string fixed_ip;
}

/**
 * Sandesh defenition for static route entry in oper db
 */
struct StaticRouteSandesh {
   1: string vrf_name (link="VrfListReq"); // VRF name
   2: string ip_addr;
   3: i32    prefix;
   4: optional string mac_addr;
   5: optional list<string> communities;
}

/**
 * Sandesh definition for security group list on interface
 */
struct VmIntfSgUuid {
    1: string sg_uuid (link="SgListReq");
}

/**
 * Sandesh defenition for interface in oper db
 */
struct ItfSandeshData {
    1: i32 index;
    2: string name;                  // interface name
    3: string uuid;                  // intf uuid
    4: string vrf_name (link="VrfListReq"); // VRF name
    5: string active;
    6: string dhcp_service;
    7: string dns_service;
    8: string type;                  // interface type : eth / vport / host
    9: i32 label;                    // interface mpls label
   10: string vn_name (link="VnListReq");  // VN uuid
   11: string vm_uuid (link="VmListReq");  // VM uuid, in case of vport itf
   12: string vm_name;
   13: string ip_addr;      // interface ip address
   14: string mac_addr;     // interface mac address
   15: string policy;       // policy enabled?
   16: list<FloatingIpSandeshList> fip_list;// Floating IP List
   17: string mdata_ip_addr;// meta-data ip address for interface
   18: list<ServiceVlanSandeshList> service_vlan_list;// Service VLAN List
   19: i32 os_ifindex;
   20: string fabric_port;
   21: string alloc_linklocal_ip;
   22: string analyzer_name; 
   23: string config_name;
   24: list<VmIntfSgUuid> sg_uuid_list;
   25: i32 l2_label;
   26: i32 vxlan_id;
   27: list<StaticRouteSandesh> static_route_list; //Static route list
   28: string l2_active;
   30: string vm_project_uuid; // project uuid of the vm to which the interface belongs
   31: string admin_state;
   32: i32 flow_key_idx;
   33: optional list<StaticRouteSandesh> allowed_address_pair_list;
   34: optional string ip6_addr;
   35: optional string ip6_active;
   36: i32 local_preference;
   37: i16 tx_vlan_id;
   38: i16 rx_vlan_id;
   39: string parent_interface;
   40: optional string subnet;
   41: optional string sub_type;
   42: optional string vrf_assign_acl_uuid (link="AclReq"); //VRF assign acl
   43: optional string vmi_type;
   44: string transport;
   45: string logical_interface_uuid;
   46: optional bool flood_unknown_unicast;
   47: string physical_device;
   48: string physical_interface;
   49: optional string ipv4_active;
   50: list<string> fixed_ip4_list;
   51: list<string> fixed_ip6_list;
   52: list<string> fat_flow_list;
   53: optional string health_check_active;
   54: optional string metadata_ip_active;
   55: optional string service_health_check_ip;
}

/**
 * Sandesh defenition for vn ipam in oper db
 */
struct VnIpamData {
    1: string ip_prefix;
    2: i32 prefix_len;
    3: string gateway;
    4: string ipam_name;
    5: string dhcp_enable;
    6: string dns_server;
}

/**
 * Sandesh defenition for vn ipam host routes
 */
struct VnIpamHostRoutes {
    1: string ipam_name;
    2: list<string> host_routes;
}

/**
 * Sandesh defenition for virtual network in oper db
 */
struct VnSandeshData {
    1: string name;                   // vn name
    2: string uuid;                   // vn uuid
    3: string acl_uuid (link="AclReq"); // acl uuid
    4: string mirror_acl_uuid (link="AclReq"); // mirror acl uuid
    5: string mirror_cfg_acl_uuid (link="AclReq"); // mirror cfg acl uuid
    6: string vrf_name (link="VrfListReq"); // VRF name
    7: list<VnIpamData> ipam_data;
    8: list<VnIpamHostRoutes> ipam_host_routes;
    9: bool layer2_forwarding;
    10: bool ipv4_forwarding;
    11: bool admin_state;
    12: i32 vxlan_id;
    13: i32 config_vxlan_id;
    14: i32 vn_id;
    15: bool enable_rpf;
    16: bool bridging;
    17: bool flood_unknown_unicast;
}

/**
 * Sandesh defenition for security group
 */
struct SgSandeshData {
    1: i32 ref_count;
    2: i32 sg_id;
    3: string sg_uuid;
    4: string acl_uuid (link="AclReq");
    5: string egress_acl_uuid (link="AclReq");
    6: string ingress_acl_uuid (link="AclReq");
}

/**
 * Sandesh defenition for security group list for vm
 */
struct VmSgUuid {
    1: string sg_uuid (link="SgListReq");
}

/**
 * Sandesh defenition for virtual machine in oper db
 */
struct VmSandeshData {
    1: string uuid;                   // VM uuid
    2: optional list<VmSgUuid> sg_uuid_list;
}

/**
 * Sandesh defenition for multicast route in oper db
 */
struct McastData {
    1: string type;
    2: optional string sip;
    3: optional string dip;
    4: optional i32 label;
    5: optional string itf (link="ItfReq");
    6: optional i16 vlan_tag
}

/**
 * Sandesh definition for  FabricComposite next hop in oper db
 */
struct FabricCompositeData {
    1: string type;
    2: optional string sip;
    3: optional string dip;
    4: optional list <McastData> mc_list;  //Multicast sub nh list
}

/**
 * Sandesh definition for L2Composite next hop in oper db
 */
struct L2CompositeData {
    1: string type;
    2: optional string sip;
    3: optional string dip;
    4: optional FabricCompositeData fabric_comp; //Multicast sub nh list
    5: optional list <McastData> mc_list; //Multicast sub nh list
}

/**
 * Sandesh definition for L3Composite next hop in oper db
 */
struct L3CompositeData {
    1: string type;
    2: optional string sip;
    3: optional string dip;
    4: optional FabricCompositeData fabric_comp;  //Multicast sub nh list
    5: optional list <McastData> mc_list; //Multicast sub nh list
}

/**
 * Sandesh definition for MulticastComposite next hop in oper db
 */
struct MulticastCompositeData {
    1: string type;
    2: optional string sip;
    3: optional string dip;
    4: optional list <McastData> mc_list;  //Multicast sub nh list
}

/**
 * Sandesh definition for MulticastFamilyComposite next hop in oper db
 */
struct MulticastFamilyCompositeData {
    1: string type;
    2: optional string sip;
    3: optional string dip;
    4: optional MulticastCompositeData fabric_comp;  //Multicast sub nh list
    5: optional MulticastCompositeData evpn_comp;  //Multicast sub nh list
    6: optional MulticastCompositeData interface_comp;  //Multicast sub nh list
}

/**
 * Sandesh definition for next hop in oper db
 */
struct NhSandeshData {
    1: string type;                   // type : tunnel / interface / ...
    2: i32 ref_count;                 // count of NH references
    3: optional string valid;         // Is Nexthop valid ???
    4: optional string policy;        // Policy enabled/disabled
    5: optional string sip;           // source IP, in case of tunnel NH 
    6: optional string dip;           // dest IP, in case of tunnel NH 
    7: optional string vrf (link="VrfListReq"); // VRF, in case of tunnel NH
    8: optional string itf (link="ItfReq"); // interface name, in case of itf NH
    9: optional string mac;           // mac, in case of itf NH
   10: optional i32 sport;            // Source port for Mirror NH
   11: optional i32 dport;            // Destination port for Mirror NH    
   12: optional string mcast;      // Is multicast nh or not
   13: optional i32 label;
   14: optional list <McastData> mc_list;  //Multicast sub nh list
   15: optional i16 vlan_tag;         // VLAN Tag for the interface
   16: optional string tunnel_type;   // Tunnel type : MPLSoGRE, MPLSoUDP, ...
   17: optional string local_ecmp;    //Is Nexthop for local ecmp 
   18: optional FabricCompositeData fabric_comp;  //Multicast sub nh list
   19: optional L2CompositeData l2_comp;  //Multicast sub nh list
   20: optional L3CompositeData l3_comp;  //Multicast sub nh list
   21: i32 nh_index;
   22: optional MulticastCompositeData interface_comp;  //Multicast sub nh list
   23: optional MulticastCompositeData evpn_comp;  //Multicast sub nh list
   24: optional bool vxlan_flag;
   25: optional bool flood_unknown_unicast;
}

/**
 * Sandesh definition for NamespaceState in oper db
 */
struct NamespaceStateSandeshData {
    1: i32 pid;
    2: i32 status;
    3: string cmd; 
    4: i32 status_type;
    5: optional string errors;
}

/**
 * Sandesh definition for PathPreference
 */
struct PathPreferenceSandeshData {
    1: i32 sequence;
    2: i32 preference;
    3: bool ecmp;
    4: bool wait_for_traffic;
    5: optional string dependent_ip;
}

/**
 * Sandesh definition for Path
 */
struct PathSandeshData {
    1: NhSandeshData nh;              // next hop info
    2: i32 label;                     // mpls label
    3: i32 vxlan_id;                // VN ID/VXLAN
    4: string peer;                   // peer originating the path 
    5: list<string> dest_vn_list (link="VnListReq"); // destination VN list
    6: string unresolved;             // true or false
    7: optional string gw_ip;         // GW IP
    8: optional string vrf (link="VrfListReq"); // Vrf
   10: optional list<i32> sg_list;
   11: string supported_tunnel_type;
   12: string active_tunnel_type;
   13: bool stale;
   14: optional PathPreferenceSandeshData path_preference_data;
   15: optional string info;
   16: optional i32 active_label;
   17: optional string flood_dhcp;
   18: optional string vm_name;
   19: optional bool ecmp_suppressed;
   20: optional string ecmp_hashing_fields;
   21: optional list<string> communities;
}

/**
 * Sandesh definition for unicast route in oper db
 */
struct RouteUcSandeshData {
    1: string src_ip;                   // IP addr
    2: i32 src_plen;                    // prefix length
    3: string src_vrf (link="VrfListReq"); // VRF
    4: list<PathSandeshData> path_list; // paths
    5: optional bool ipam_subnet_route;   // associated IPAM subnet 
    6: optional bool proxy_arp;           // Proxy ARP
    7: bool multicast;
}

/**
 * Sandesh definition for multicast route in oper db
 */
struct RouteMcSandeshData {
    1: string src;                   // S
    2: string grp;                   // G
    3: NhSandeshData nh;                // The NH
}

/**
 * Sandesh definition for L2 route in oper db
 */
struct RouteL2SandeshData {
    1: string mac;                   // MAC addr
    2: string src_vrf (link="VrfListReq"); // VRF
    4: list<PathSandeshData> path_list; // paths
}

/**
 * Sandesh definition for evpn route in oper db
 */
struct RouteEvpnSandeshData {
    1: string mac;                   // MAC addr
    2: string src_vrf (link="VrfListReq"); // VRF
    3: string ip_addr;
    4: list<PathSandeshData> path_list; // paths
}

/**
 * Sandesh definition for Vrf in oper db
 */
struct VrfSandeshData {
    1: string name;                           // VRF name
    2: i32 ucindex  (link="Inet4UcRouteReq"); // VRF Index INET4 UC Table
    3: i32 mcindex  (link="Inet4McRouteReq"); // VRF Index INET4 MC Table
    4: i32 l2index  (link="Layer2RouteReq"); // VRF Index L2 Table, DEPRECATED
    5: string source;                        // config or gateway
    6: i32 uc6index (link="Inet6UcRouteReq"); // VRF Index INET6 UC Table
    7: string vn (link="VnListReq");          // VN-Name
    8: i32 table_label;                      //Label for route lookup on this vrf
    9: i32 vxlan_id;                         // VRF Label used for the VRF
   10: i32 evpnindex  (link="EvpnRouteReq"); // VRF Index evpn Table
   11: i32 brindex  (link="BridgeRouteReq"); // VRF Index L2 Table
}

/**
 * Sandesh definition for mpls label in oper db
 */
struct MplsSandeshData {
    1: i32 label;                     // mpls label
    2: string type;                   // type - invalid or vport_nh or mcast_nh
    3: NhSandeshData nh;              // next hop info
}

/**
 * Sandesh definition for mirror packet
 */
struct MirrorEntrySandeshData {
    1: i32 ref_count;                 // count of Flow's referring to Mirror entry
    2: string analyzer_name;          // Analyzer name
    3: optional string sip;           // source IP
    4: optional string dip;           // dest IP of Analytics server
    5: optional string vrf (link="VrfListReq"); // VRF
    6: optional i32 sport;            // Source port for Mirror NH
    7: optional i32 dport;            // Destination port for Mirror NH
    8: NhSandeshData nh;              // next hop info
}

/**
 * Request message for agent init state
 */
request sandesh AgentInitStateReq {
}

/**
 * Response message for agent init state
 */
response sandesh AgentInitState {
    1: string state;                   // Agent's state
}

/**
 * Sandessh definition for security group log
 */
struct SgObjectLogInfo {
    1: string event;
    2: string uuid;
    3: u32 id;
    4: string acl_uuid;
    5: u32 ref_count;
    6: string egress_acl_uuid;
    7: string ingress_acl_uuid;
}

/**
 * @description: Trace message for security group object
 * @type: Trace
 * @severity: DEBUG
 * @object: SgEntry
 */
objectlog sandesh SgObjectLog {
    1: SgObjectLogInfo sg;
}

/**
 * @description: Trace log for security group object in vrouter-agent oper DB
 * @type: Trace
 * @severity: DEBUG
 * @object: SgEntry
 */
traceobject sandesh SgObjectTrace {
    1: SgObjectLogInfo sg;
}

/**
 * Request message for security group request
 */
request sandesh SgListReq {
    1: string name;
}

/**
 * Response message for security group list from oper db
 */
response sandesh SgListResp {
    1: list<SgSandeshData> sg_list;
}

/**
 * Request message for virtual network list from oper db
 */
request sandesh VnListReq {
    1: string name;                   // send data for given name substring
    2: string uuid;
    3: string vxlan_id;
    4: string ipam_name;
}

/**
 * Response message for virtual network list
 */
response sandesh VnListResp {
    1: list<VnSandeshData> vn_list;
}

/**
 * Request message for virtual machine list from oper db
 */
request sandesh VmListReq {
    1: string uuid;                   // send data for given name substring
}

/**
 * Response message for virtual machine list
 */
response sandesh VmListResp {
    1: list<VmSandeshData> vm_list;
}

/**
 * Request message for next hop list from oper db
 */
request sandesh NhListReq {
    1: string type;
    2: string nh_index;
    3: string policy_enabled;
}

/**
 * Response message for virtual nh list
 */
response sandesh NhListResp {
    1: list<NhSandeshData> nh_list;
}

/**
 * Request message for vrf list from oper db
 */
request sandesh VrfListReq {
    1: string name;                   // send data for given name substring
}

/**
 * Response message for vrf list
 */
response sandesh VrfListResp {
    1: list<VrfSandeshData> vrf_list;
}

/**
 * Request message for Inet4 Unicast routes from oper db
 */
request sandesh Inet4UcRouteReq {
    1: i32 vrf_index = 0;             // send route entries for the VRF index
    2: string src_ip;
    3: u16 prefix_len;
    4: bool stale = 0;                // Display stale entries only if set
}

/**
 * Response message for Inet4 Unicast routes
 */
response sandesh Inet4UcRouteResp {
    1: list<RouteUcSandeshData> route_list; // routes
}

/**
 * Request message for Inet6 Unicast routes from oper db
 */
request sandesh Inet6UcRouteReq {
    1: i32 vrf_index = 0;             // send route entries for the VRF index
    2: string src_ip;
    3: u16 prefix_len;
    4: bool stale = 0;                // Display stale entries only if set
}

/**
 * Response message for Inet6 Unicast routes
 */
response sandesh Inet6UcRouteResp {
    1: list<RouteUcSandeshData> route_list; // routes
}

/**
 * Request message for Inet4 multicast routes from oper db
 */
request sandesh Inet4McRouteReq {
    1: i32 vrf_index = 0;             // send route entries for the VRF index
    2: bool stale = 0;                // Display stale entries only if set
}

/**
 * Response message for Inet4 multicast routes
 */
response sandesh Inet4McRouteResp {
    1: list<RouteMcSandeshData> route_list; // routes
}

/**
 * Request message for L2 routes from oper db
 */
request sandesh Layer2RouteReq {
    1: i32 vrf_index = 0;
    2: string mac;
    3: bool stale = 0;                // Display stale entries only if set
}

/**
 * Response message for L2 routes
 */
response sandesh Layer2RouteResp {
    1: list<RouteL2SandeshData> route_list; // routes
}

/**
 * Request message for bridge routes from oper db
 */
request sandesh BridgeRouteReq {
    1: i32 vrf_index = 0;
    2: string mac;
    3: bool stale = 0;                // Display stale entries only if set
}

/**
 * Response message for bridge routes
 */
response sandesh BridgeRouteResp {
    1: list<RouteL2SandeshData> route_list; // routes
}

/**
 * Request message for evpn routes from oper db
 */
request sandesh EvpnRouteReq {
    1: i32 vrf_index = 0;
    2: string mac;
    3: bool stale = 0;                // Display stale entries only if set
}

/**
 * Response message for evpn routes
 */
response sandesh EvpnRouteResp {
    1: list<RouteEvpnSandeshData> route_list; // routes
}

/**
 * Request message for interface details from oper db
 */
request sandesh ItfReq {
    1: string name;
    2: string type;
    3: string uuid;
    4: string vn;
    5: string mac;
    6: string ipv4_address;
    7: string ipv6_address;
    8: string parent_uuid;
    9: string ip_active;
    10: string ip6_active;
    11: string l2_active;
}

/**
 * Response message for interface details
 */
response sandesh ItfResp {
    1: list<ItfSandeshData> itf_list;
}

/**
 * Request message for mpls label list from oper db
 */
request sandesh MplsReq {
    1: string type;
    2: string label;
}

/**
 * Response message for mpls label
 */
response sandesh MplsResp {
    1: list<MplsSandeshData> mpls_list;
}

/**
 * Sandesh definition for vrf assignment
 */
struct VrfAssignSandeshData {
    1: string type;
    2: u16 vlan_tag;
    3: string itf (link="ItfReq"); // interface name
    4: string vrf (link="VrfListReq");  // VRF
}

/**
 * Request message for vrf assignment list
 */
request sandesh VrfAssignReq {
    1: string uuid;                   // send data for given interface
}

/**
 * Response message for vrf assignment
 */
response sandesh VrfAssignResp {
    1: list<VrfAssignSandeshData> vrf_assign_list;
}

/**
 * Request message for miror entry
 */
request sandesh MirrorEntryReq {
    1: string analyzer_name;
}

/**
 * Response message for miror entry
 */
response sandesh MirrorEntryResp {
    1: list<MirrorEntrySandeshData> mirror_entry_list;
}

/**
 * Response message for invalid input 
 */
response sandesh ErrorResp {
    1: string resp = "   Invalid Input !!!   ";
}

/**
 * Request message for LinkLocalServiceInfo
 */
request sandesh LinkLocalServiceInfo {
}

/**
 * Sandesh definition for Link Local Service
 */
struct LinkLocalServiceData {
    1: string linklocal_service_name;
    2: string linklocal_service_ip;
    3: i32    linklocal_service_port;
    4: string ipfabric_dns_name;
    5: list<string> ipfabric_ip;
    6: i32    ipfabric_port;
}

/**
 * Response message for LinkLocalServiceInfo
 */
response sandesh LinkLocalServiceResponse {
    1: list<LinkLocalServiceData> service_list;
}

/**
 *  Sandesh range for acl properties like protocol, port
 */
struct SandeshRange {
    1: i32 min;
    2: i32 max;   
}

/** 
 *  Sandesh definition of acl action string
 */
struct ActionStr {
    1: string action;
}

/**
 * Sandesh definition for acl action
 */
struct AclAction {
    1: string acl_id;
    // 2: bool sg;
    3: list<ActionStr> action_l;
    4: string acl_type;
}

/**
 * Id for AclEntry
 */
struct AceId {
    1: i32 id;
}

/**
 * Sandesh definition for AclEntry
 */
struct AclEntrySandeshData {
    1: string ace_id;
    2: string rule_type;
    3: string src;
    4: string dst;
    5: list <SandeshRange> src_port_l;
    6: list <SandeshRange> dst_port_l;
    7: list <SandeshRange> proto_l;
    8: list <ActionStr> action_l;
    9: string src_type;
    10: string dst_type;
    11: string uuid;
}

/**
 * Sandesh definition for flow
 */
struct FlowSandeshData {
    1: list <AceId> ace_l;
    // Flow Key
    2: string vrf;
    3: string src;
    4: string dst;
    5: i32 src_port;
    6: i32 dst_port;
    7: i16 protocol;

    // Flow Data
    8: bool ingress;
    9: list <ActionStr> action_l;
    10: list <AclAction> acl_action_l;
    11: string flow_uuid;
    12: string flow_handle;
    13: string dest_vrf;
    14: string source_vn;
    15: string dest_vn;
    16: list<u32> source_sg_id_l;
    17: list<u32> dest_sg_id_l;
    18: string bytes;
    19: string packets;
    20: string setup_time;
    21: string current_time;
    22: string teardown_time;
    23: string reverse_flow;
    24: string nat;
    25: string implicit_deny;
    26: optional string short_flow;
    27: optional u64 setup_time_utc;
    28: bool l3_flow;
    29: string smac;
    30: string dmac;
    31: list<string> source_vn_list;
    32: list<string> dest_vn_list;
}

/**
 * Sandesh definition for vxlan
 */
struct VxLanSandeshData {
    1: i32 vxlan_id;                  // vxlan label
    2: NhSandeshData nh;              // next hop info
    3: optional string vrf_name;      // vrf name from nh
}

/**
 * Sandesh definition for ServiceInstance
 */
struct ServiceInstanceSandeshData {
    1: string uuid;
    2: string service_type;
    3: string virtualization_type;
    4: string instance_id;
    5: string vmi_inside;
    6: string vmi_outside;
    7: NamespaceStateSandeshData ns_state;      // NamespaceState
}

/**
 * acl entry and associated flow count definition
 */
struct AceIdFlowCnt {
    1: i32 ace_id;
    2: i32 flow_cnt;
}

/**
 * Sandesh definition for Acl
 */
struct AclSandeshData {
    1: string uuid (link="AclFlowReq");
    2: bool dynamic_acl;
    3: list<AclEntrySandeshData> entries;
    4: string name;
}

/**
 * Request Acl object with given uuid
 */
request sandesh AclReq {
    1: string uuid;
}

/**
 * Response for Acl list
 */
response sandesh AclResp {
    1: list<AclSandeshData> acl_list;
}

/**
 * Request message for flow_entries per acl 
 */
request sandesh AclFlowReq {
    1: string uuid;
}

/**
 * Request message for next flow_entry with iteration_key 
 */
request sandesh NextAclFlowReq {
    1: string iteration_key;
}

/**
 * Response message for flow_entry for an acl
 */
response sandesh AclFlowResp {
    1: i32 flow_count;
    2: i32 flow_miss;
    3: list <FlowSandeshData> flow_entries;
    4: string iteration_key (link="NextAclFlowReq");
}

/**
 * Get flow count for an acl with given uuid
 */
request sandesh AclFlowCountReq {
    1: string uuid;
}

/**
 * Get next flow entry for an acl with given iteration_key
 */
request sandesh NextAclFlowCountReq {
    1: string iteration_key;
}

/**
 * Response message for flow count for an acl
 */
response sandesh AclFlowCountResp {
    1: i32 flow_count;
    2: i32 flow_miss;
    3: list<AceIdFlowCnt> aceid_cnt_list;
    4: string iteration_key (link="NextAclFlowCountReq");
}

// ACL Traces

/**
 * @description: Trace message for acl error
 * @type: Trace
 * @severity: DEBUG
 */
trace sandesh AclErr {
    1: string err;
}

/**
 * @description: Trace message for acl info
 * @type: Trace
 * @severity: DEBUG
 */
trace sandesh AclInfo {
    1: string str;
}

/**
 * @description: Trace message for acl statistics 
 * @type: Trace
 * @severity: DEBUG
 */
traceobject sandesh AclAclTrace {
    1: string info;
    2: string uuid;
    3: AclSandeshData acl;
}

/**
 * @description: Trace message for acl entry
 * @type: Trace
 * @severity: DEBUG
 */
traceobject sandesh AclEntryTrace {
    1: AclEntrySandeshData acl_entry;
}

/**
 * @description: Trace message for Path Preference
 * @type: Trace
 * @severity: DEBUG
 */
traceobject sandesh PathPreferenceTrace {
    1: string vrf;
    2: string ip;
    3: i32 preference;
    4: i32 sequence;
    5: string state;
    6: i32 retry_timeout;
    7: string dependent_ip;
}

/**
 * Request for mirror create from agent introspect
 */ 
request sandesh MirrorCreateReq {
    // Handle
    1: string handle;

    // Apply VN
    2: string apply_vn;

    // Source
    3: string src_vn;
    4: string src_ip_prefix;
    5: i32 src_ip_prefix_len;

    // Destination
    6: string dst_vn;
    7: string dst_ip_prefix;
    8: i32 dst_ip_prefix_len;

    // Source port, -1 means any
    // if there is no end_src_port, end_src_port will be same as start_src_port
    9: i32 start_src_port;
    10: i32 end_src_port;

    // Dest port, -1 means any
    // if there is no end_dst_port, end_dst_port will be same as start_dst_port
    11: i32 start_dst_port;
    12: i32 end_dst_port;

    // Protocol, -1 means any
    13: i32 protocol;

    // Mirror destination
    14: string ip;   
    15: i32 udp_port;
    // Time period for mirroring in seconds
    16: i32 time_period;
    17: string mirror_vrf;
}

/**
 * Response for mirror create
 */
response sandesh MirrorCfgResp {
    1: string resp = "  Success  ";
}

/**
 * Request mirror delete from agent introspect
 */
request sandesh MirrorDeleteReq {
    // Handle
    1: string handle;
}

/**
 * Mirror cfg display
 */
request sandesh MirrorCfgDisplayReq {
    // Handle
    1: string handle;
}

/**
 * Request for VxLan info
 */
request sandesh VxLanReq {
    1: string vxlan_id;
}

/**
 * Sandesh definition for VxLanConfigEntry
 */
struct VxLanConfigEntry {
    1: u32 vxlan_id;
    2: string vn_uuid;
    3: string vrf;
    4: bool flood_unknown_unicast;
    5: bool active;
}

/**
 * Response message for VxLan config list from oper db
 */
response sandesh VxLanConfigResp {
    1: list<VxLanConfigEntry> vxlan_config_entries;
}

/**
 * Response for VxLan config 
 */
request sandesh VxLanConfigReq {
    1: u32 vxlan_id;
    2: string vn;
    3: string active;
}

/**
 * Response for VxLan entry list from oper db
 */
response sandesh VxLanResp {
    1: list<VxLanSandeshData> vxlan_list;
}

/**
 * Request for ServiceInstance list with given uuid
 */
request sandesh ServiceInstanceReq {
    1: string uuid;
}

/**
 * Response for ServiceInstance list
 */
response sandesh ServiceInstanceResp {
    1: list<ServiceInstanceSandeshData> service_instance_list;
}

/**
 * Sandesh definition for mirror config
 */
struct MirrorCfgSandesh {
    // Handle
    1: string handle;

    // Apply VN
    2: string apply_vn (link="MirrorCfgVnInfoReq");

    // Source
    3: string src_vn;
    4: string src_ip_prefix;
    5: i32 src_ip_prefix_len;

    // Destination
    6: string dst_vn;
    7: string dst_ip_prefix;
    8: i32 dst_ip_prefix_len;

    // Source port, -1 means any
    // if there is no end_src_port, end_src_port will be same as start_src_port
    9: i32 start_src_port;
    10: i32 end_src_port;

    // Dest port, -1 means any
    // if there is no end_dst_port, end_dst_port will be same as start_dst_port
    11: i32 start_dst_port;
    12: i32 end_dst_port;

    // Protocol, -1 means any
    13: i32 protocol;

    // Mirror destination
    14: string ip;   
    15: i32 udp_port;
    // Time period for mirroring in seconds
    16: i32 time_period;
    17: string mirror_vrf;
}

/**
 * Response for mirror cfg display
 */
response sandesh MirrorCfgDisplayResp {
    1: list<MirrorCfgSandesh> mcfg_l;
}

/**
 * Request for mirror cfg vn info
 */
request sandesh MirrorCfgVnInfoReq {
    1: string vn_name;
}

/**
 * Sandesh definition for vn and attached acl
 */ 
struct VnAclInfo {
    1: string vn_name;
    2: string vn_uuid;
    3: string dyn_acl_uuid;
    4: i32 num_of_entries;
}

/**
 * Response for mirror cfg vn info
 */
response sandesh MirrorCfgVnInfoResp {
    1: list <VnAclInfo> vn_acl_info_l;
}

/**
 * Sandesh definition for interface mirror config
 */
struct IntfMirrorCfgSandesh {
    1: string handle;
    2: optional string intf_uuid;
    3: optional string intf_name;
    4: optional string ip;
    5: optional i32 udp_port;
    6: optional i32 time_period;
    7: optional string mirror_vrf;
}

/**
 * Request for Interface Mirror Create
 */
request sandesh IntfMirrorCreateReq {
    1: string handle;
    2: optional string intf_uuid;
    3: optional string intf_name;
    4: optional string ip;
    5: optional i32 udp_port;
    6: optional i32 time_period;
    7: optional string mirror_vrf;
}

/**
 * Request for Interface Mirror Delete
 */
request sandesh IntfMirrorDeleteReq {
    1: string handle;
}

/**
 * Request for Interface Mirror Config
 */
request sandesh IntfMirrorCfgDisplayReq {
    1: string handle;
}

/**
 * Response for Interface Mirror list
 */
response sandesh IntfMirrorCfgDisplayResp {
    1: list <IntfMirrorCfgSandesh> imcfg_l;
}

/**
 * @description: Trace message for interface mirror
 * @type: Trace
 * @severity: DEBUG
 */
traceobject sandesh IntfMirror {
    1: string operation;
    2: IntfMirrorCfgSandesh ms;
}

/**
 * @description: Trace message for unresolved next hop
 * @type: Trace
 * @severity: DEBUG
 */
response sandesh UnresolvedNHResp {
    1: list<NhSandeshData> nh_list;
}

/**
 * Response message for unresolved route list
 */
response sandesh UnresolvedRouteResp {
    1: list<RouteUcSandeshData> route_list;
}

/**
 * Request message for unresolved nexthop list
 */
request sandesh UnresolvedNH {
}

/**
 * Get unresolved routes
 */
request sandesh UnresolvedRoute {
}

/**
 * Definition for agent log level
 */
enum AgentLogEvent {
    ADD,
    DELETE,
    CHANGE,
    DELETE_TRIGGER,
    RESYNC
}

/**
 * Sandesh definition for vm object log
 */
struct VmObjectLogInfo {
    1: string event;
    2: string uuid (key="ObjectVMTable")
    3: optional list<string> sg_uuid_list;
    4: i32 ref_count;
}

/**
 * @description: log message for vm object
 * @type: Trace
 * @severity: DEBUG
 * @object: VmEntry
 */
objectlog sandesh VmObjectLog {
    1: VmObjectLogInfo vm;
}

/**
 * Sandesh definition for vn ipam log
 */
struct VnObjectLogIpam {
    1: string ip_prefix;
    2: i32    prefix_len;
    3: optional string gateway_ip;
    4: string ipam_name;
    5: string dhcp_enable;
    6: string dns_server;
}

/**
 * Sandesh definition for vn object log
 */
struct VnObjectLogInfo {
    1: string event;
    2: string uuid;
    3: string name (key="ObjectVNTable")
    4: optional string acl_uuid;
    5: optional string mirror_acl_uuid;
    6: optional string mirror_cfg_acl_uuid;
    7: optional string vrf;
    8: optional list <VnObjectLogIpam> ipam_list;
    9: optional bool ipv4_forwarding;
   10: optional bool bridging;
   11: optional bool admin_state;
}

/**
 * @description: Statistics for vn object log
 * @type: Trace
 * @severity: DEBUG
 * @object: VnEntry
 */
objectlog sandesh VnObjectLog {
    1: VnObjectLogInfo vn;
}

/**
 * Sandesh definition for vrf object log
 */
struct VrfObjectLogInfo {
    1: string event;
    2: string name (key="ObjectRoutingInstance")
    4: optional i32 index;
}

/**
 * @description: log for vrf
 * @type: Trace
 * @severity: DEBUG
 * @object: VrfEntry
 */
objectlog sandesh VrfObjectLog {
    1: VrfObjectLogInfo vrf;
}

/**
 * Sandesh definition for floating ip
 */
struct FloatingIPInfo {
    1:string vrf_name;
    2:string ip_address;
}

/**
 * Sandesh definition for interface
 */
struct InterfaceInfo {
    1: string name;
    2: i32 index;
    3: string op;
    4: optional string vm;
    5: optional string vn;
    6: optional string vrf;
    7: optional string ip_address;
    8: optional string mac;
    9: optional list<FloatingIPInfo> fip;
   10: optional i32 vxlan_id;
   11: string vm_project;
}

/**
 * Sandesh definition for route
 */
struct RouteInfo {
    1: string ip;
    2: string vrf;
    3: string op;
    4: optional string nh_type;
    5: optional string peer;
    6: optional string dest_server;
    7: optional string dest_server_vrf;
    8: optional string intf;
    9: optional string mac;
   10: bool ecmp;
}

/**
 * @description: log for interface
 * @type: Trace
 * @severity: DEBUG
 */
traceobject sandesh OperInterface {
    1: InterfaceInfo intf_info;
}

/**
 * Sandesh definition for oper config for an object
 */
struct OperConfigInfo {
    1: string name;
    2: string uuid;
    3: string message;
}

/**
 * @description: log for oper config
 * @type: Trace
 * @severity: DEBUG
 */
traceobject sandesh OperConfig {
    1: OperConfigInfo info;
}

/**
 * @description: log for oper route
 * @type: Trace
 * @severity: DEBUG
 */
traceobject sandesh OperRoute {
    1: RouteInfo route_info;
}

/**
 * Sandesh definition for mpls log
 */
struct MplsObjectLogInfo {
    1: string event;
    2: string type;
    3: i32 label;
    4: optional string nh_type;
    5: optional string intf_type;
    6: optional string intf_uuid;
    7: optional string intf_name;
    8: optional string policy;
    9: optional i16 vlan_tag;
}

/**
 * @description: log for mpls
 * @type: Trace
 * @severity: DEBUG
 */
traceobject sandesh OperMpls {
    1: MplsObjectLogInfo mpls;
}

/**
 * Sandesh definition for ComponentNHLog
 */
struct ComponentNHLogInfo {
    1: string type;
    2: i32    label; 
    3: optional string intf_name;
    4: optional string server_ip;
    5: i32 component_nh_id;
}

/**
 * Sandesh definition for next hop log
 */
struct NextHopObjectLogInfo {
    1: string event;
    2: string type;
    3: string policy;
    4: string valid;
    5: optional string source_ip;
    6: optional string dest_ip;
    7: optional string vrf;
    8: optional i16 source_port;
    9: optional i16 dest_port;
    10: optional string intf_type;
    11: optional string intf_uuid;
    12: optional string intf_name;
    13: optional i16 vlan_tag;
    14: optional string resolved;
    15: optional string mac;   //ArpNH MAC/VLAN NH DMAC/INTF NH DMAC
    16: optional list<ComponentNHLogInfo> nh_list;
    17: optional string tunnel_type;   // Tunnel type : MPLSoGRE, MPLSoUDP, ...
    18: i32 id;
}

/**
 * Sandesh definition for vxlan object log
 */
struct VxLanObjectLogInfo {
    1: string event;
    2: i32 vxlan_id;
    3: optional string nh_type;
    4: optional string vrf_name;
}

/**
 * @description: log for vxlan
 * @type: Trace
 * @severity: DEBUG
 */
traceobject sandesh OperVxLan {
    1: VxLanObjectLogInfo VxLan;
}

/**
 * @description: log for next hop
 * @type: Trace
 * @severity: DEBUG
 */
traceobject sandesh OperNextHop {
    1: NextHopObjectLogInfo nh;
}

/**
 * @description: Log for agent route
 * @type: systemlog
 * @severity: DEBUG
 * @cause: Normal operation
 */
trace sandesh AgentRouteLog {
    1: string message;
    2: string ip;
    3: "in VRF";
    4: string vrf;
    5: string peer;
}

/**
 * @description: log for multicast info 
 * @type: Trace
 * @severity: DEBUG
 */
trace sandesh MulticastInfo {
    1: string message;
    2: string info;
}

/**
 * @description: log for multicast
 * @type: Trace
 * @severity: DEBUG
 */
trace sandesh MulticastLog {
    1: string message;
    2: string vrf_name;
    3: string dst_ip;
    4: i32 label;   
}

/**
 * @description: Trace meassage for oper module
 * @type: Trace
 * @severity: DEBUG
 */
trace sandesh OperTrace {
    1: string message;
}

/**
 * @description: Trace meassage for vrf
 * @type: Trace
 * @severity: DEBUG
 */
trace sandesh OperVrf {
    1: string message;
    2: string vrf_name;
}

/**
 * @description: Trace meassage for agent route walk
 * @type: Trace
 * @severity: DEBUG
 */
trace sandesh AgentRouteWalkerTrace {
    1: string message;
    2: "Walk Type:";
    3: i32 walk_type;
    4: "Vrf name:";
    5: string vrf_name;
    6: "VRF walkid:";
    7: i32 vrf_walk_id;
    8: "Route table Type:";
    9: i32 route_table_type;
   10: "Route table name:";
   11: string route_table_name;
   12: "Route Walk Id:";
   13: i32 route_walk_id;
}

/**
 * @description: Trace meassage for agent db walk
 * @type: Trace
 * @severity: DEBUG
 */
trace sandesh AgentDBWalkLog {
    1: string message;
    2: string table_name;
    3: "walkid:";
    4: i32 walk_id;
    5: "peer:";
    6: string peer;
    7: string add_del_route; 
    8: "pending walks:"; 
    9: i32 pending_walks;
}

/**
 * @description: system log for interface configuration
 * @type: systemlog
 * @severity: DEBUG
 * @cause: Normal operation
 */
systemlog sandesh InterfaceConfiguration {
    1: string f1;
    2: string interface_uuid;
    3: string f2
    4: string config_uuid;
    5: string f3
    6: string compute_uuid;
}

/**
 * @description: system log for logical interface configuration
 * @type: systemlog
 * @severity: DEBUG
 * @cause: Normal operation
 */
systemlog sandesh LogicalInterfaceConfiguration {
    1: string msg1;
    2: string logical_interface_name;
    3: string msg2
    4: string physical_interface_name;
    5: string msg3
    6: string prouter_name;
}

/**
 * @description: system log for flow
 * @type: systemlog
 * @severity: DEBUG
 * @cause: Normal operation
 */
systemlog sandesh FlowLog {
    1: u32 flow_id;
    2: string message;
}

/**
 * @description: system log for agent route walk
 * @type: systemlog
 * @severity: DEBUG
 * @cause: Normal operation
 */
systemlog sandesh AgentRouteWalkerLog {
    1: "walkid:";
    2: u32 walk_id;
    3: "walktype:";
    4: u32 walk_type;
    5: string message;
    6: string vrf_name;
    7: u32 route_table_type;
}

/**
 * @description: system log for global vrouter config
 * @type: systemlog
 * @severity: DEBUG
 * @cause: Normal operation
 */
systemlog sandesh GlobalVrouterLog {
    1: string message;
}

/**
 * @description: Trace message for security group
 * @type: Trace
 * @severity: DEBUG
 */
trace sandesh OperSg {
    1: string message;
    2: string uuid;
}

/**
 * Sandesh definitions for PhysicalDevice
 */
struct SandeshDevice {
    1: string uuid;
    2: string fq_name;
    3: string name;
    4: string vendor;
    5: string ip_address;
    6: string management_protocol;
    7: bool master;
}

/**
 * Response message for physical device list
 */
response sandesh SandeshDeviceListResp {
    1: list<SandeshDevice> device_list;
}

/**
 * Request physical devie list
 */
request sandesh SandeshDeviceReq {
    1: string name;
}

/**
 * Sandesh definition for physical device object log
 */
struct DeviceObjectLogInfo {
    1: string event;
    2: string uuid;
    3: i32 ref_count;
    4: string fq_name;
    5: string name;
    6: string vendor;
    7: string ip_address;
    8: string management_protocol;
}

/**
 * @description: System log for physical device
 * @type: Trace
 * @severity: DEBUG
 * @object: PhysicalDevice
 */
objectlog sandesh DeviceObjectLog {
    1: DeviceObjectLogInfo device;
}

/**
 * Sandesh definitions for PhysicalDeviceVn
 * Oper table
 */
struct SandeshPhysicalDeviceVn {
    1: string device_uuid;
    2: string vn_uuid;
    3: string device;
    4: string vn;
    5: i32 vxlan_id;
}

/**
 * Response messdage for physical device vn list
 */
response sandesh SandeshPhysicalDeviceVnListResp {
    1: list<SandeshPhysicalDeviceVn> port_list;
}

/**
 * Request physical device vn list
 */
request sandesh SandeshPhysicalDeviceVnReq {
    1: string device;
    2: string vn;
}

/**
 * Sandesh definition for physical device vn config tree
 */
struct SandeshConfigPhysicalDeviceVn {
    1: string device_uuid;
    2: string vn_uuid;
    3: string vmi_uuid;
    4: i32 vxlan_id;
    5: i32 vn_id;
}

/**
 * Response for physical device vn config list
 */
response sandesh SandeshConfigPhysicalDeviceVnListResp {
    1: list<SandeshConfigPhysicalDeviceVn> device_vn_list;
}

/**
 * Request for physical device vn list config
 */
request sandesh SandeshConfigPhysicalDeviceVnReq {
    1: string device;
}

/**
 * Sandesh definition for physical device vn log
 */
struct PhysicalDeviceVnObjectLogInfo {
    1: string event;
    2: string device_uuid;
    3: string vn_uuid;
    4: i32 ref_count;
    5: string device;
    6: string vn;
}

/**
 * @description: log message for physical device vn
 * @type: Trace
 * @severity: DEBUG
 * @object: PhysicalDeviceVn
 */
objectlog sandesh PhysicalDeviceVnObjectLog {
    1: PhysicalDeviceVnObjectLogInfo port;
}

/**
 * Sandesh definition for vrouter limits
 */
struct VrouterObjectLimits {
    1: i32 max_labels;
    2: i32 max_nexthops;
    3: i32 max_interfaces;
    4: i32 max_vrfs;
    5: i32 max_mirror_entries;
    6: i32 vrouter_max_bridge_entries;
    7: i32 vrouter_max_oflow_bridge_entries;
    8: string vrouter_build_info;
}

/**
 * Request vrouter limit parameters
 */
request sandesh VrouterObjectLimitsReq {
}

/**
 * Response for vrouter limits
 */
response sandesh VrouterObjectLimitsResp {
    1: VrouterObjectLimits vrouter_object_limit;
}

/**
 * Sandesh definition for IFMapDependency NodeEvent policies
 */
struct IFMapReactEvent {
    1: string event;
    2: list<string> reactors;
}

/**
 * Sandesh definition for if map node policies
 */
struct IFMapNodePolicy {
    1: string node;
    2: list<IFMapReactEvent> events;
}

/**
 * Response for if map node policy list
 */
response sandesh IFMapNodePolicyResp {
    1: list<IFMapNodePolicy> policies;
}

/**
 * Request message for if map node policy list
 */
request sandesh IFMapNodePolicyReq {
    1: string node;
}

/**
 * @description: Trace message for health check
 * @type: Trace
 * @severity: DEBUG
 */
traceobject sandesh HealthCheckTrace {
    1: string log;
}

/**
 * Sandesh definition for health check instance
 */
struct HealthCheckInstanceSandeshData {
    1: string vm_interface (link="ItfReq");
    2: string metadata_ip;
    3: string service_ip;
    4: string health_check_ip;
    5: bool active;
    6: bool running;
    7: string last_update_time;
}

/**
 * Sandesh definition for health check service
 */
struct HealthCheckSandeshData {
    1: string uuid;
    2: string name;
    3: string monitor_type;
    4: string http_method;
    5: string url_path;
    6: string expected_codes;
    7: u32 delay;
    8: u32 timeout;
    9: u32 max_retries;
    10: list<HealthCheckInstanceSandeshData> inst_list;
}

/**
 * Request health check instances list
 */
request sandesh HealthCheckSandeshReq {
    1: string uuid;
}

/**
 * Health check list
 */
response sandesh HealthCheckSandeshResp {
    1: list<HealthCheckSandeshData> hc_list;
}

/**
 * Sandesh definition for bgp as a service
 */
struct BgpAsAServiceSandeshList {
   1: string vm_bgp_peer_ip;
   2: i32 vm_nat_source_port;
   3: string vmi_uuid (link="ItfReq"); // intf uuid
}

/**
 * Request bgp service list
 */
request sandesh BgpAsAServiceSandeshReq {
}

/**
 * bgp servie list response message
 */
response sandesh BgpAsAServiceSandeshResp {
    1: list<BgpAsAServiceSandeshList> bgp_as_a_service_list;
}

/**
 * @description: Trace message for bgp service
 * @type: Trace
 * @severity: DEBUG
 */
trace sandesh BgpAsAServiceTrace {
    1: string message;
}

/**
 * @description: Trace message for InstanceManager
 * @type: Trace
 * @severity: DEBUG
 */
trace sandesh InstanceManagerTrace {
    1: string message;
}