module itm-rpc {
    namespace "urn:opendaylight:vpnservice:itm:rpcs";
    prefix "itmrpcs";

    import ietf-inet-types {
        prefix inet;
        revision-date "2010-09-24";
    }

    import ietf-yang-types {
              prefix yang;
      }

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

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

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

        
    revision "2015-12-17" {
        description "ODL Specific Itm Manager Rpcs Module";
    }

    /* RPCs */

    rpc get-tunnel-interface-name {
        description "used to retrieve tunnel interface id between Dpns";
        input {
            leaf source-dpid {
                 type uint64;
            }
            leaf destination-dpid {
                 type uint64;
            }
        }
        output {
            leaf interface-name {
                type string;
            }
        }
    }

    rpc get-internal-or-external-interface-name {
        description "used to retrieve tunnel interface id with src Dpn and destination ip";
            input {
                leaf source-dpid {
                type uint64;
                }
                leaf destination-ip {
                type inet:ip-address;
                }
            }
            output {
                leaf interface-name {
                    type string;
                }
        }
    }

    rpc get-external-tunnel-interface-name {
        description "used to retrieve tunnel interface id between Dpns";
        input {
            leaf source-dpid {
            type uint64;
            }
            leaf destination-ip {
            type inet:ip-address;
            }
        }
        output {
            leaf interface-name {
                type string;
            }
        }
    }

    rpc build-external-tunnel-from-dpns {
        description "used for building tunnels between a Dpn and external node";
        input {
            leaf-list dpn-id {
                type uint64;
            }
            leaf destination-ip {
                type inet:ip-address;
            }
            leaf tunnel-type {
            type identityref {
                base odlif:tunnel-type-base;
            }
            }
        }
     }

     rpc add-external-tunnel-endpoint { 
        description "used for building tunnels between teps on all Dpns and external node";
        input {
            leaf destination-ip {
                 type inet:ip-address;
            }
            leaf tunnel-type {
            type identityref {
                base odlif:tunnel-type-base;
            }
            }
        }
     }
    rpc remove-external-tunnel-from-dpns {
        description "used for building tunnels between a Dpn and external node";
        input {
            leaf-list dpn-id {
                type uint64;
            }
            leaf destination-ip {
                type inet:ip-address;
            }
            leaf tunnel-type {
            type identityref {
                base odlif:tunnel-type-base;
            }
            }
        }
     }

     rpc remove-external-tunnel-endpoint {
        description "used for building tunnels between teps on all Dpns and external node";
        input {
            leaf destination-ip {
                 type inet:ip-address;
            }
            leaf tunnel-type {
            type identityref {
                base odlif:tunnel-type-base;
            }
            }
        }
     }

     rpc create-terminating-service-actions {
         description  "used for programming the terminating service actions";
         input {
             leaf dpn-id {
               type uint64;
             }
             leaf service-id {
                type uint16;
             }
             uses offlow:instruction-list;
         }
     }

     rpc remove-terminating-service-actions {
              description  "used for removing the terminating service actions";
              input {
                  leaf dpn-id {
                    type uint64;
                  }
                  leaf service-id {
                     type uint16;
                  }
              }
     }

}