[genius.git] / itm / itm-api / src / main / yang / itm-rpc.yang

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

    import ietf-inet-types {
        prefix inet;
        revision-date "2013-07-15";
    }

    import odl-interface {
        prefix odlif;
        revision-date "2016-04-06";
    }

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


    revision "2016-04-06" {
        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;
            }
            leaf tunnel-type {
                type identityref {
                    base odlif:tunnel-type-base;
                }
            }
        }
        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/dpn";
        input {
            leaf source-dpid {
                type uint64;
            }
            leaf destination-ip {
                type inet:ip-address;
            }
            leaf destination-dpid {
                type uint64;
                description "Optional. if destination-dpid is abesnt,"
                    + "the destination-ip will be used to get the tunnel name";
            }
            leaf tunnel-type {
                type identityref {
                    base odlif:tunnel-type-base;
                }
            }
        }
        output {
            leaf interface-name {
                type string;
            }
        }
    }

    rpc get-external-tunnel-interface-name {
        description "used to retrieve external tunnel interface id between Dpns/TORs";
        input {
            leaf source-node {
                type string;
            }
            leaf destination-node {
                type string;
            }
            leaf tunnel-type {
                type identityref {
                    base odlif:tunnel-type-base;
                }
            }
        }

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

    rpc add-l2-gw-device {
        description "used for building tunnels between teps on all Dpns and hwVtep";
        input {
            leaf topology-id {
                type string;
            }
            leaf node-id {
                type string;
            }
            leaf ip-address {
                type inet:ip-address;
            }
        }
    }

    rpc add-l2-gw-mlag-device {
        description "used for building tunnels between teps on all Dpns and hwVtep";
        input {
            leaf topology-id {
                type string;
            }
            leaf-list node-id {
                type string;
            }
            leaf ip-address {
                type inet:ip-address;
            }
        }
    }

    rpc delete-l2-gw-device {
        description "used for deleting tunnels between teps on all Dpns and hwVtep";
        input {
            leaf topology-id {
                type string;
            }
            leaf node-id {
                type string;
            }
            leaf ip-address {
                type inet:ip-address;
            }
        }
    }

    rpc delete-l2-gw-mlag-device {
        description "used for deleting tunnels between teps on all Dpns and hwVtep";
        input {
            leaf topology-id {
                type string;
            }
            leaf-list node-id {
                type string;
            }
            leaf ip-address {
                type inet:ip-address;
            }
        }
    }

    rpc is-tunnel-internal-or-external {
        description "Used for determining whether tunnel is an internal or an external tunnel";
        input {
            leaf tunnel-interface-name {
                type string;
            }
        }
        output {
            leaf tunnel-type {
                type uint32;
            }
        }
    }

    rpc is-dcgw-present {
        description "Used for determining whether tunnel is an internal or an external tunnel";
        input {
            leaf dcgw-ip {
                type string;
            }
        }
        output {
            leaf retVal {
                type uint32;
            }
        }
    }

    rpc get-dpn-endpoint-ips {
        description "used to retrieve tunnel end point IPs of a Dpn";
        input {
            leaf source-dpid {
            type uint64;
            }
        }
        output {
            leaf-list nexthopip-list {
                type inet:ip-address;
            }
        }
    }

    rpc get-egress-actions-for-tunnel {
    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;
            }

            leaf action-key {
                description "By default action keys are incremented from zero, for custom initial value set action-key";
                type int32;
                mandatory false;
            }
        }
        output {
            uses action:action-list;
        }
    }

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

    rpc set-bfd-param-on-tunnel {
        description "used for turning ON/OFF to monitor individual tunnels";
        input {
            leaf source-node {
                type string;
                mandatory true;
            }
            leaf destination-node {
                type string;
                mandatory true;
            }
            leaf monitoring-enabled {
                type boolean;
                mandatory true;
            }
            leaf monitoring-interval {
                type uint16 {
                    range "1000..30000";
                }
            }
        }
    }


    rpc get-dpn-info {
        description "Gets the dpn id and tep ip information of compute nodes";
        input {
            leaf-list compute-names {
                type string;
            }
        }
        output {
            list computes {
                key "compute-name";
                leaf compute-name {
                    type string;
                }
                leaf zone-name {
                    type string;
                }
                leaf prefix {
                    type inet:ip-prefix;
                }
                leaf dpn-id {
                    type uint64;
                }
                leaf-list tep-ip {
                    type inet:ip-address;
                }
                leaf port-name {
                    type string;
                }
                leaf node-id {
                    type string;
                }
            }
        }
    }

    rpc get-watch-port-for-tunnel {
        description "retrieve the watch port for the BFD enabled point to point tunnel";
        input {
            leaf source-node {
                type string;
            }

            leaf destination-node {
                type string;
            }

        }
        output {
            leaf port-no {
                type uint32;
            }
            leaf portname {
                type string;
            }
        }
    }
}