agent.sandesh

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

enum AgentConsts {
    MAX_SANDESH_COUNT = 256
}

request sandesh PageReq {
    1: string key;
}

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 sandesh Pagination {
    1: PageReqData req;
}

struct ServiceVlanSandeshList {
   1: i16 tag;
   2: string vrf_name (link="VrfListReq"); // VRF name
   3: string ip_addr;
   4: i16 label;
   5: string installed;
}

struct FloatingIpSandeshList {
   1: string ip_addr;
   2: string vrf_name (link="VrfListReq"); // VRF name
   3: string installed;
}

struct StaticRouteSandesh {
   1: string vrf_name (link="VrfListReq"); // VRF name
   2: string ip_addr;
   3: i32    prefix;
   4: optional string mac_addr;
}

struct VmIntfSgUuid {
    1: string sg_uuid (link="SgListReq");
}

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;
}

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;
}

struct VnIpamHostRoutes {
    1: string ipam_name;
    2: list<string> host_routes;
}

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;
}

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");
}

struct VmSgUuid {
    1: string sg_uuid (link="SgListReq");
}

struct VmSandeshData {
    1: string uuid;                   // VM uuid
    2: optional list<VmSgUuid> sg_uuid_list;
}

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
}

struct FabricCompositeData {
    1: string type;
    2: optional string sip;
    3: optional string dip;
    4: optional list <McastData> mc_list;  //Multicast sub nh list
}

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
}

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
}

struct MulticastCompositeData {
    1: string type;
    2: optional string sip;
    3: optional string dip;
    4: optional list <McastData> mc_list;  //Multicast sub nh list
}

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
}

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;
}

struct NamespaceStateSandeshData {
    1: i32 pid;
    2: i32 status;
    3: string cmd; 
    4: i32 status_type;
    5: optional string errors;
}

struct PathPreferenceSandeshData {
    1: i32 sequence;
    2: i32 preference;
    3: bool ecmp;
    4: bool wait_for_traffic;
}

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: string dest_vn (link="VnListReq"); // destination VN
    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;
}

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;
}

struct RouteMcSandeshData {
    1: string src;                   // S
    2: string grp;                   // G
    3: NhSandeshData nh;                // The NH
}

struct RouteL2SandeshData {
    1: string mac;                   // MAC addr
    2: string src_vrf (link="VrfListReq"); // VRF
    4: list<PathSandeshData> path_list; // paths
}

struct RouteEvpnSandeshData {
    1: string mac;                   // MAC addr
    2: string src_vrf (link="VrfListReq"); // VRF
    3: string ip_addr;
    4: list<PathSandeshData> path_list; // paths
}

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
}

struct MplsSandeshData {
    1: i32 label;                     // mpls label
    2: string type;                   // type - invalid or vport_nh or mcast_nh
    3: NhSandeshData nh;              // next hop info
}

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 sandesh AgentInitStateReq {
}

response sandesh AgentInitState {
    1: string state;                   // Agent's state
}

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;
}

objectlog sandesh SgObjectLog {
    1: SgObjectLogInfo sg;
}

request sandesh SgListReq {
    1: string name;
}

response sandesh SgListResp {
    1: list<SgSandeshData> sg_list;
}

request sandesh VnListReq {
    1: string name;                   // send data for given name substring
}

response sandesh VnListResp {
    1: list<VnSandeshData> vn_list;
}

request sandesh VmListReq {
    1: string uuid;                   // send data for given name substring
}

response sandesh VmListResp {
    1: list<VmSandeshData> vm_list;
}

request sandesh NhListReq {
}

response sandesh NhListResp {
    1: list<NhSandeshData> nh_list;
}

request sandesh VrfListReq {
    1: string name;                   // send data for given name substring
}

response sandesh VrfListResp {
    1: list<VrfSandeshData> vrf_list;
}

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 sandesh Inet4UcRouteResp {
    1: list<RouteUcSandeshData> route_list; // routes
}

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 sandesh Inet6UcRouteResp {
    1: list<RouteUcSandeshData> route_list; // routes
}

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 sandesh Inet4McRouteResp {
    1: list<RouteMcSandeshData> route_list; // routes
}

request sandesh Layer2RouteReq {
    1: i32 vrf_index = 0;
    2: string mac;
    3: bool stale = 0;                // Display stale entries only if set
}

response sandesh Layer2RouteResp {
    1: list<RouteL2SandeshData> route_list; // routes
}

request sandesh BridgeRouteReq {
    1: i32 vrf_index = 0;
    2: string mac;
    3: bool stale = 0;                // Display stale entries only if set
}

response sandesh BridgeRouteResp {
    1: list<RouteL2SandeshData> route_list; // routes
}

request sandesh EvpnRouteReq {
    1: i32 vrf_index = 0;
    2: string mac;
    3: bool stale = 0;                // Display stale entries only if set
}

response sandesh EvpnRouteResp {
    1: list<RouteEvpnSandeshData> route_list; // routes
}

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 sandesh ItfResp {
    1: list<ItfSandeshData> itf_list;
}

request sandesh MplsReq {
}

response sandesh MplsResp {
    1: list<MplsSandeshData> mpls_list;
}

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

request sandesh VrfAssignReq {
    1: string uuid;                   // send data for given interface
}

response sandesh VrfAssignResp {
    1: list<VrfAssignSandeshData> vrf_assign_list;
}

request sandesh MirrorEntryReq {
}

response sandesh MirrorEntryResp {
    1: list<MirrorEntrySandeshData> mirror_entry_list;
}

response sandesh ErrorResp {
    1: string resp = "   Invalid Input !!!   ";
}

request sandesh LinkLocalServiceInfo {
}

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 sandesh LinkLocalServiceResponse {
    1: list<LinkLocalServiceData> service_list;
}

// ACL Sandesh
struct SandeshRange {
    1: i32 min;
    2: i32 max;   
}

struct ActionStr {
    1: string action;
}

struct AclAction {
    1: string acl_id;
    // 2: bool sg;
    3: list<ActionStr> action_l;
    4: string acl_type;
}

struct AceId {
    1: i32 id;
}

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;
}

// ACL to Flow mapping Sandesh
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;
}

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

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
}

struct LoadBalancerSandeshData {
    1: string uuid;
    2: string vip_address;
    4: i32 port;
    5: string mode;
    6: string balance;
    7: i32 inter;
    8: i32 fall;
    9: i32 rise;
   10: string expected_codes;
   11: string http_method;
   12: string url_path;
   13: list<string> member_list;
}

request sandesh LoadBalancerReq {
    1: string uuid;
}

response sandesh LoadBalancerResp {
    1: list<LoadBalancerSandeshData> load_balancer_list;
}

struct AceIdFlowCnt {
    1: i32 ace_id;
    2: i32 flow_cnt;
}

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

request sandesh AclReq {
    1: string uuid;
}

response sandesh AclResp {
    1: list<AclSandeshData> acl_list;
}

request sandesh AclFlowReq {
    1: string uuid;
}

request sandesh NextAclFlowReq {
    1: string iteration_key;
}

response sandesh AclFlowResp {
    1: i32 flow_count;
    2: i32 flow_miss;
    3: list <FlowSandeshData> flow_entries;
    4: string iteration_key (link="NextAclFlowReq");
}

request sandesh AclFlowCountReq {
    1: string uuid;
}

request sandesh NextAclFlowCountReq {
    1: string iteration_key;
}

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
trace sandesh AclErr {
    1: string err;
}

trace sandesh AclInfo {
    1: string str;
}

traceobject sandesh AclAclTrace {
    1: string info;
    2: string uuid;
    3: AclSandeshData acl;
}

traceobject sandesh AclEntryTrace {
    1: AclEntrySandeshData acl_entry;
}

traceobject sandesh PathPreferenceTrace {
    1: string vrf;
    2: string ip;
    3: i32 preference;
    4: i32 sequence;
    5: string state;
    6: i32 retry_timeout;
}

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 sandesh MirrorCfgResp {
    1: string resp = "  Success  ";
}

request sandesh MirrorDeleteReq {
    // Handle
    1: string handle;
}

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

request sandesh VxLanReq {
}

struct VxLanConfigEntry {
    1: u32 vxlan_id;
    2: string vn_uuid;
    3: string vrf;
    4: bool flood_unknown_unicast;
    5: bool active;
}

response sandesh VxLanConfigResp {
    1: list<VxLanConfigEntry> vxlan_config_entries;
}

request sandesh VxLanConfigReq {
    1: u32 vxlan_id;
    2: string vn;
    3: string active;
}

response sandesh VxLanResp {
    1: list<VxLanSandeshData> vxlan_list;
}

request sandesh ServiceInstanceReq {
    1: string uuid;
}

response sandesh ServiceInstanceResp {
    1: list<ServiceInstanceSandeshData> service_instance_list;
}

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 sandesh MirrorCfgDisplayResp {
    1: list<MirrorCfgSandesh> mcfg_l;
}

request sandesh MirrorCfgVnInfoReq {
    1: string vn_name;
}

struct VnAclInfo {
    1: string vn_name;
    2: string vn_uuid;
    3: string dyn_acl_uuid;
    4: i32 num_of_entries;
}

response sandesh MirrorCfgVnInfoResp {
    1: list <VnAclInfo> vn_acl_info_l;
}

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 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 sandesh IntfMirrorDeleteReq {
    1: string handle;
}

request sandesh IntfMirrorCfgDisplayReq {
    1: string handle;
}

response sandesh IntfMirrorCfgDisplayResp {
    1: list <IntfMirrorCfgSandesh> imcfg_l;
}

traceobject sandesh IntfMirror {
    1: string operation;
    2: IntfMirrorCfgSandesh ms;
}

response sandesh UnresolvedNHResp {
    1: list<NhSandeshData> nh_list;
}

response sandesh UnresolvedRouteResp {
    1: list<RouteUcSandeshData> route_list;
}

request sandesh UnresolvedNH {
}

request sandesh UnresolvedRoute {
}

enum AgentLogEvent {
    ADD,
    DELETE,
    CHANGE,
    DELETE_TRIGGER,
    RESYNC
}

struct VmObjectLogInfo {
    1: string event;
    2: string uuid;
    3: optional list<string> sg_uuid_list;
    4: i32 ref_count;
}

objectlog sandesh VmObjectLog {
    1: VmObjectLogInfo vm;
}

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;
}

struct VnObjectLogInfo {
    1: string event;
    2: string uuid;
    3: string name;
    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;
}

objectlog sandesh VnObjectLog {
    1: VnObjectLogInfo vn;
}

struct VrfObjectLogInfo {
    1: string event;
    2: string name;
    4: optional i32 index;
}

objectlog sandesh VrfObjectLog {
    1: VrfObjectLogInfo vrf;
}

struct FloatingIPInfo {
    1:string vrf_name;
    2:string ip_address;
}

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;
}

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;
}

traceobject sandesh OperInterface {
    1: InterfaceInfo intf_info;
}

struct OperConfigInfo {
    1: string name;
    2: string uuid;
    3: string message;
}

traceobject sandesh OperConfig {
    1: OperConfigInfo info;
}

traceobject sandesh OperRoute {
    1: RouteInfo route_info;
}

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;
}

traceobject sandesh OperMpls {
    1: MplsObjectLogInfo mpls;
}

struct ComponentNHLogInfo {
    1: string type;
    2: i32    label; 
    3: optional string intf_name;
    4: optional string server_ip;
    5: i32 component_nh_id;
}

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;
}

struct VxLanObjectLogInfo {
    1: string event;
    2: i32 vxlan_id;
    3: optional string nh_type;
    4: optional string vrf_name;
}

traceobject sandesh OperVxLan {
    1: VxLanObjectLogInfo VxLan;
}

traceobject sandesh OperNextHop {
    1: NextHopObjectLogInfo nh;
}

systemlog sandesh AgentRouteLog {
    1: string message;
    2: string ip;
    3: "in VRF";
    4: string vrf;
    5: string peer;
}

trace sandesh MulticastInfo {
    1: string message;
    2: string info;
}

trace sandesh MulticastLog {
    1: string message;
    2: string vrf_name;
    3: string dst_ip;
    4: i32 label;   
}

trace sandesh OperTrace {
    1: string message;
}

trace sandesh OperVrf {
    1: string message;
    2: string vrf_name;
}

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;
}

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;
}

systemlog sandesh InterfaceConfiguration {
    1: string f1;
    2: string interface_uuid;
    3: string f2
    4: string config_uuid;
    5: string f3
    6: string compute_uuid;
}

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;
}

systemlog sandesh FlowLog {
    1: u32 flow_id;
    2: string message;
}

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;
}

systemlog sandesh GlobalVrouterLog {
    1: string message;
}

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 sandesh SandeshDeviceListResp {
    1: list<SandeshDevice> device_list;
}

request sandesh SandeshDeviceReq {
    1: string name;
}

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;
}

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 sandesh SandeshPhysicalDeviceVnListResp {
    1: list<SandeshPhysicalDeviceVn> port_list;
}

request sandesh SandeshPhysicalDeviceVnReq {
    1: string device;
    2: string 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 sandesh SandeshConfigPhysicalDeviceVnListResp {
    1: list<SandeshConfigPhysicalDeviceVn> device_vn_list;
}

request sandesh SandeshConfigPhysicalDeviceVnReq {
    1: string device;
}

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

objectlog sandesh PhysicalDeviceVnObjectLog {
    1: PhysicalDeviceVnObjectLogInfo port;
}

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 sandesh VrouterObjectLimitsReq {
}

response sandesh VrouterObjectLimitsResp {
    1: VrouterObjectLimits vrouter_object_limit;
}