module odl-interface-rpc {
    namespace "urn:opendaylight:vpnservice:interfacemgr:rpcs";
    prefix "odlifrpc";

    import ietf-inet-types {
        prefix inet;
    }

    import odl-interface {
        prefix odlif; revision-date 2015-03-31;
    }

    import opendaylight-inventory {
        prefix inv; revision-date 2013-08-19;
    }

    import ietf-interfaces {
        prefix if; revision-date 2014-05-08;
    }

    import opendaylight-action-types {prefix action;}
    import opendaylight-flow-types {prefix offlow;revision-date "2013-10-26";}

    revision "2015-10-03" {
        description "ODL Specific Interface Manager Rpcs Module";
    }

    /* RPCs */

    rpc get-dpid-from-interface {
        description "used to retrieve dpid from interface name";
        input {
            leaf intf-name {
                type string;
            }
        }
        output {
            leaf dpid {
                type uint64;
            }
        }
    }

    rpc get-port-from-interface {
        description "used to retrieve dpid from interface name";
        input {
            leaf intf-name {
                type string;
            }
        }
        output {
            leaf dpid {
                type uint64;
            }
            leaf portno {
                type uint32;
            }
            leaf portname {
                type string;
            }
        }
    }

    rpc get-egress-actions-for-interface {
        description "used to retrieve group actions to use from interface name";
        input {
            leaf intf-name {
                type string;
                mandatory true;
            }

            leaf tunnel-key {
                description "It can be VNI for VxLAN tunnel ifaces, Gre Key for GRE tunnels, etc.";
                type uint32;
                mandatory false;
            }
        }
        output {
            uses action:action-list;
        }
    }

    rpc get-egress-instructions-for-interface {
        description "used to retrieve flow instructions to use from interface name";
        input {
            leaf intf-name {
                type string;
                mandatory true;
            }

            leaf tunnel-key {
                description "It can be VNI for VxLAN tunnel ifaces, Gre Key for GRE tunnels, etc.";
                type uint32;
                mandatory false;
            }
        }
        output {
            uses offlow:instruction-list;
        }
    }

    rpc get-endpoint-ip-for-dpn {
        description "to get the local ip of the tunnel/trunk interface";
        input {
            leaf dpid {
                type uint64;
            }
        }
        output {
            leaf-list local-ips {
                type inet:ip-address;
            }
        }
    }

    rpc get-interface-type {
    description "to get the type of the interface(vlan/vxlan or gre)";
        input {
            leaf intf-name {
                type string;
            }
        }
        output {
            leaf interface-type {
                type identityref {
                    base if:interface-type;
                }
            }
        }
    }

    rpc get-tunnel-type {
    description "to get the type of the tunnel interface(vxlan or gre)";
        input {
            leaf intf-name {
                type string;
            }
        }
        output {
            leaf tunnel-type {
                type identityref {
                    base odlif:tunnel-type-base;
                }
            }
        }
    }


    rpc get-nodeconnector-id-from-interface {
    description "to get nodeconnector id associated with an interface";
        input {
            leaf intf-name {
                type string;
            }
        }
        output {
            leaf nodeconnector-id {
                type inv:node-connector-id;
            }
        }
    }

    rpc get-interface-from-if-index {
        description "to get interface associated with an if-index";
            input {
                leaf if-index {
                    type int32;
                }
            }
            output {
                leaf interface-name {
                    type string;
                }
            }
        }

    rpc create-terminating-service-actions {
    description "create the ingress terminating service table entries";
        input {
             leaf dpid {
                 type uint64;
             }
             leaf tunnel-key {
                 type uint64;
             }
             leaf interface-name {
                 type string;
             }
             uses offlow:instruction-list;
        }
    }

    rpc remove-terminating-service-actions {
    description "remove the ingress terminating service table entries";
        input {
             leaf dpid {
                 type uint64;
             }
             leaf interface-name {
                 type string;
             }
             leaf tunnel-key {
                 type uint64;
             }
        }
    }
}