control-tsn-uni.yang

module control-tsn-uni {
    yang-version 1.1;
    namespace "urn:isw:controltsn";
    prefix control-tsn-uni;

    import ieee802-dot1q-tsn-types {
        prefix tsn;
    }

    organization "Institute for Control Engineering of Machine Tools and Manufacturing Units - University of Stuttgart";

    description "YANG Module for storing Data in the ControlTSN Framework";

    //revision 2021-06-25 {
    //    description "Initial Revision for ControlTSN Framework";
    //}

    revision 2022-12-08 {
        description "Updated Revision for ControlTSN Framework";
    }


    // =============================================================
    // ===  Stream groupings
    // =============================================================
    grouping configuration {
        uses tsn:group-status-stream;
        container talker {
            uses tsn:group-status-talker-listener;
        }
        container listener-list {
            list listener {
                key "index";
                leaf index {
                    type uint16;
                }
                uses tsn:group-status-talker-listener;
            }
        }
    }

    grouping request {
        container talker {
            uses tsn:group-talker;
        }
        container listener-list {
            list listener {
                key "index";
                leaf index {
                    type uint16;
                }
                uses tsn:group-listener;
            }
        }
    }

    grouping stream {
        leaf stream-id {
            type tsn:stream-id-type;    // XX-XX-XX-XX-XX-XX:XX-XX
        }
        container request {
            uses request;
        }

        leaf configured {               // Added xoe: to simplify the check whether a stream is configured or not
            type uint8;
            default 0;
        }

        container configuration {
            uses configuration;
        }
    }

    // =============================================================
    // ===  Modules groupings
    // =============================================================
    grouping module-data-def {
        leaf data-name {
            type string;
        }

        leaf data-type {
            type enumeration {
                enum binary;
                //enum bits-type;
                enum boolean;
                enum decimal64;
                //enum enumeration-type;
                //enum identifyref-type;
                enum instance-identifier;
                enum int8;
                enum int16;
                enum int32;
                enum int64;
                enum string;
                enum uint8;
                enum uint16;
                enum uint32;
                enum uint64;
            }
        }

        leaf data-value {
            //type string;    // Maybe not the best solution. Should each module get a own yang file?
            type union {
                type binary;
                //type bits;                
                type boolean;
                //type enumeration;
                //type identifyref;
                type instance-identifier;
                type int8;
                type int16;
                type int32;
                type int64;
                type string;
                type uint8;
                type uint16;
                type uint32;
                type uint64;
                type decimal64              {fraction-digits 5;}
            }
        }
    }

    grouping module-def {
        leaf id {
            type uint16;
        }
        leaf name {
            type string;
        }
        leaf desc {
            type string;
        }
        leaf executable-path {
            type string;
        }
        leaf subscribed-events-mask {
            type uint64;
            default 0;
        }

        leaf registered {
            type uint8;
            default 0;
        }

        leaf pid {
            type uint32;
            default 0;
        }
        container data {
            list entry {
                key "data-name";
                uses module-data-def;
            }
        }
    }

    // =============================================================
    // ===  Topology groupings
    // =============================================================
    grouping enddevice {
        leaf mac {
            type string {
                pattern '[0-9a-fA-F]{2}(-[0-9a-fA-F]{2}){5}';
            }
        }

        leaf iface {
            type string;
            default "";
        }

        leaf name {
            type string;
        }

        leaf interface-uri {
            type string;
        }

        leaf has-app {
            type uint8;
            default 0;
        }

        container apps {
            list app {
                key "app-ref";
                leaf app-ref {
                    type leafref {
                        path "/control-tsn-uni:tsn-uni/application/apps/app/id";
                        require-instance "false";
                    }
                }
            }
        }

        leaf num-cores {
            type uint16;
            default 1;
        }
    }

    grouping switch {
        leaf mac {
            type string {
                pattern '[0-9a-fA-F]{2}(-[0-9a-fA-F]{2}){5}';
            }
        }
        leaf name {
            type string;
        }
        leaf ports-count {
            type uint8;
        }
    }

    grouping connection {
        leaf id {
            type uint16;
        }
        leaf from-mac {
            type string;
        }
        leaf from-port {
            type uint8;
        }
        leaf to-mac {
            type string;
        }
        leaf to-port {
            type uint8;
        }
    }

    // =============================================================
    // ===  Application groupings
    // =============================================================
    grouping app-parameter {
        leaf param-name {
            type string;
        }
        leaf param-type {
            type enumeration {
                enum binary;
                //enum bits-type;
                enum boolean;
                enum decimal64;
                //enum enumeration-type;
                //enum identifyref-type;
                enum instance-identifier;
                enum int8;
                enum int16;
                enum int32;
                enum int64;
                enum string;
                enum uint8;
                enum uint16;
                enum uint32;
                enum uint64;
            }
        }
        leaf param-value {
            type union {
                type binary;
                //type bits;                
                type boolean;
                //type enumeration;
                //type identifyref;
                type instance-identifier;
                type int8;
                type int16;
                type int32;
                type int64;
                type string;
                type uint8;
                type uint16;
                type uint32;
                type uint64;
                type decimal64              {fraction-digits 10;}
            }
        }
        leaf param-desc {
            type string;
        }
    }
    
    grouping app {
        leaf id {
            type string;
        }
        leaf name {
            type string;
        }
        leaf desc {
            type string;
        }
        leaf has-mac {
            type uint8;
            default 0;
        }
        leaf mac {
            type string {
                pattern '[0-9a-fA-F]{2}(-[0-9a-fA-F]{2}){5}';
            }
            description "The (virtual) MAC of this app or container in case multiple containers are running on one (physical) enddevice";
        }  
        leaf iface {
            type string;
            default "";
            description "The interface of enddevice this app should use";
        }      
        leaf version {
            type string;
        }
        leaf has-image {
            type uint8;
            default 0;
        }
        leaf image-ref {
            type leafref {
                path "/control-tsn-uni:tsn-uni/application/images/image/id";
                require-instance "true";
            }
        }
        container parameters {
            list parameter {
                key "param-name";
                uses app-parameter;
            }
        }
        container stream-mapping {
            leaf-list egress {
                type leafref {
                    path "/control-tsn-uni:tsn-uni/streams/stream/stream-id";
                    require-instance "true";
                }
            }
            leaf-list ingress {
                type leafref {
                    path "/control-tsn-uni:tsn-uni/streams/stream/stream-id";
                    require-instance "true";
                }
            }
        }
    }

    grouping image {
        leaf id {
            type string;
        }
        leaf name {
            type string;
        }
        leaf desc {
            type string;
        }
        leaf version {
            type string;
        }
    }

    // =============================================================
    // ===  Root
    // =============================================================
    container tsn-uni {
        description "The root of the yang module.";

        /*
        // Actions should be implemented and callable in the CNC!! 
        // === Actions
        // (Difference between compute and deploy is the status of the stream in the response)
        action compute-all-requests { }
        action deploy-all-configurations { }
        action undeploy-all-configurations { }
        action delete-all-configurations { }
        */

        leaf plugin-running {
            type boolean;
            default false;
        }
        
        container streams {
            list stream {
                key "stream-id";
                uses stream;
            }
        }

        container modules {

            list mod {
                key "id";
                uses module-def;
            }
        }

        container topology {
            container devices {
                container enddevices {
                    list enddevice {
                        key "mac";
                        uses enddevice;
                    }
                }
                
                container switches {
                    list switch {
                        key "mac";
                        uses switch;
                    }
                }
            }

            container graph {
                container connections {
                    list connection {
                        key "id";
                        uses connection;
                    }
                }
            }
        }

        container application {
            container apps {
                list app {
                    key "id";
                    uses app;
                }
            }

            container images {
                list image {
                    key "id";
                    uses image;
                }
            }
        }
    }

    // =============================================================
    // ===  RCPs
    // =============================================================
    // Topology Discovery Triggering
    //rpc rpc-trigger-topology-discovery {
    //    description "Triggers the discovery of the topology";
    //}
    //rpc rpc-generic {
    //    description "A generic RPC to use the plugin as a middleware";     
    //}

    // =============================================================
    // ===  Notifications
    // =============================================================
    //notification notif-topology-discovery-requested {
    //    description "The discovery of the topology was requested";
    //}

    notification notif-generic {
        description "A generic notification including the corresponding event ID";

        leaf event-id {
            type uint64;
            description "Describing the occured event (see 'events_definitions.h' for the list of events)";
        }
        leaf entry-id {
            type string;
            description "Can be used to describe the corresponding entry associated with this event";
        }
        leaf msg {
            type string;
            description "A generic message associated with this event";
        }
    }
}