bbf-software-management

This module contains a collection of YANG definitions for supporting the Broadband Forum requirements on software management as ...

  • Version: 2023-12-15

    bbf-software-management@2023-12-15


    
      module bbf-software-management {
    
        yang-version 1.1;
    
        namespace
          "urn:bbf:yang:bbf-software-management";
    
        prefix bbf-swm;
    
        import ietf-inet-types {
          prefix inet;
        }
        import ietf-hardware {
          prefix hw;
        }
        import ietf-yang-types {
          prefix yang;
        }
        import bbf-yang-types {
          prefix bbf-yang;
        }
    
        organization
          "Broadband Forum <https://www.broadband-forum.org>
    Common YANG Work Area";
    
        contact
          "Comments or questions about this Broadband Forum YANG module
    should be directed to <mailto:help@broadband-forum.org>.
    
    Editor:      Nick Hancock, Adtran
    
    Editor:      Ludwig Pauwels, Nokia
    
    PS Leader:   Joey Boyd, Adtran
    
    WA Director: Joey Boyd, Adtran
    
    WA Director: Sven Ooghe, Nokia";
    
        description
          "This module contains a collection of YANG definitions for
    supporting the Broadband Forum requirements on software
    management as applicable to access network equipment. As such,
    this module is specific to access network equipment (e.g.,
    BBF-specified Access Nodes and FTTdp DPUs).
    
    This module augments ietf-hardware.
    
    Copyright (c) 2017-2023, Broadband Forum
    
    Redistribution and use in source and binary forms, with or
    without modification, are permitted provided that the following
    conditions are met:
    
    1. Redistributions of source code must retain the above copyright
       notice, this list of conditions and the following disclaimer.
    
    2. Redistributions in binary form must reproduce the above
       copyright notice, this list of conditions and the following
       disclaimer in the documentation and/or other materials
       provided with the distribution.
    
    3. Neither the name of the copyright holder nor the names of its
       contributors may be used to endorse or promote products
       derived from this software without specific prior written
       permission.
    
    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
    CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
    INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
    MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
    STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
    ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    
    The above license is used as a license under copyright only.
    Please reference the Forum IPR Policy for patent licensing terms
    <https://www.broadband-forum.org/ipr-policy>.
    
    Any moral rights which are necessary to exercise under the above
    license grant are also deemed granted under this license.
    
    This version of this YANG module is part of TR-383a7; see
    the TR itself for full legal notices.";
    
        revision "2023-12-15" {
          description
            "Amendment 7.
    * Approval Date:    2023-12-15.
    * Publication Date: 2023-12-15.";
          reference
            "TR-383a7: Common YANG Modules
            	  <https://www.broadband-forum.org/technical/download/
            		   TR-383_Amendment-7.pdf>";
    
        }
    
        revision "2022-03-01" {
          description
            "Amendment 5.
    * Approval Date:    2022-03-01.
    * Publication Date: 2022-03-01.";
          reference
            "TR-383a5: Common YANG Modules
            	  <https://www.broadband-forum.org/technical/download/
            		   TR-383_Amendment-5.pdf>";
    
        }
    
    
        feature software-management-actions {
          description
            "Indicates that a client may invoke actions on revisions of a
    software to execute activities to manage those revisions.
    
    Note that if a system does not support this feature, this YANG
    data model would nevertheless allow a client to monitor
    software that is managed via an alternative management
    interface.";
        }
    
        feature download-target-selection-by-user {
          description
            "Indicates support for allowing the user to select a specific
    entry in the revision list to use as a target when downloading
    revisions.
    
    If a system supports a capability derived from 'download' for
    software, the system must support at least one of the features
    'download-target-selection-by-user' or
    'download-target-selection-by-system'.";
        }
    
        feature download-target-selection-by-system {
          description
            "Indicates support for allowing the system to select an entry in
    the revision list to use as a target when downloading
    revisions.
    
    If a system supports a capability derived from 'download' for
    software, the system must support at least one of the features
    'download-target-selection-by-user' or
    'download-target-selection-by-system'.";
        }
    
        identity error-tag {
          description
            "Base identity for all error tags defined in this module.
    
    This identity is abstract and SHOULD NOT generally be used as a
    value referenced by a leaf when reporting errors. If used to
    define an error that was not known at design time, it SHOULD be
    qualified with a corresponding description provided as
    additional information suitable for human display.";
        }
    
        identity general-error {
          base error-tag;
          description
            "Base identity for all error tags reporting general errors.
    
    This identity is abstract and SHOULD NOT generally be used as a
    value referenced by a leaf when reporting errors. If used to
    define an error that was not known at design time, it SHOULD be
    qualified with a corresponding description provided as
    additional information suitable for human display.";
        }
    
        identity component-busy {
          base general-error;
          description
            "The associated action could not be processed, because the
    target component is busy.";
        }
    
        identity too-many-requests {
          base general-error;
          description
            "The device has too many requests in progress and cannot
    accept any more.";
        }
    
        identity request-not-supported {
          base general-error;
          description
            "The request is not supported by the component.";
        }
    
        identity unexpected-error {
          base general-error;
          description
            "An unexpected error has occurred that is not covered by the
    other errors.";
        }
    
        identity download-error {
          base error-tag;
          description
            "Base identity for all error tags reporting errors that occur
    during the downloading of a software revision from a file
    server.
    
    This identity is abstract and SHOULD NOT generally be used as a
    value referenced by a leaf when reporting errors. If used to
    define an error that was not known at design time, it SHOULD be
    qualified with a corresponding description provided as
    additional information suitable for human display.";
        }
    
        identity protocol-error {
          base download-error;
          description
            "Base identity for all error tags reporting protocol-related
    errors.
    
    This identity is abstract and SHOULD NOT generally be used as a
    value referenced by a leaf when reporting errors. If used to
    define an error that was not known at design time, it SHOULD be
    qualified with a corresponding description provided as
    additional information suitable for human display.";
        }
    
        identity protocol-not-supported-by-peer {
          base protocol-error;
          description
            "The protocol in the form requested by the device (possibly as
    a result of configuration) is not supported by the peer.";
        }
    
        identity protocol-execution-error {
          base protocol-error;
          description
            "An error was encountered in the execution of the protocol.";
        }
    
        identity connection-error {
          base download-error;
          description
            "Base identity for all error tags reporting errors relating to
    the connection to the remote peer.
    
    This identity is abstract and SHOULD NOT generally be used as a
    value referenced by a leaf when reporting errors. If used to
    define an error that was not known at design time, it SHOULD be
    qualified with a corresponding description provided as
    additional information suitable for human display.";
        }
    
        identity service-unavailable {
          base connection-error;
          description
            "A connection could not be established, because the peer could
    not handle the request, for example, because it may be
    overloaded or down for maintenance.";
        }
    
        identity bad-gateway {
          base connection-error;
          description
            "The peer was acting as a gateway or proxy and received an
    invalid response from the upstream peer.";
        }
    
        identity gateway-timeout {
          base connection-error;
          description
            "The peer was acting as a gateway or proxy and did not receive a
    timely response from the upstream peer.";
        }
    
        identity invalid-inet-address {
          base connection-error;
          description
            "The specified Internet address of the peer is invalid.";
        }
    
        identity network-authentication-required {
          base connection-error;
          description
            "The connection could not be completed, because authentication
    is required to access the network.";
        }
    
        identity remote-peer-not-reachable {
          base connection-error;
          description
            "No response was received from the remote peer.";
        }
    
        identity data-connection-cannot-be-opened {
          base connection-error;
          description
            "Although the peer could be reached, it was not possible to open
    a data connection.";
        }
    
        identity connection-refused-by-peer {
          base connection-error;
          description
            "The remote peer refused the connection.";
        }
    
        identity connection-reset-by-peer {
          base connection-error;
          description
            "The remote peer reset the connection.";
        }
    
        identity request-refused-by-peer {
          base connection-error;
          description
            "The remote peer refused the request made by the local
    device over an existing connection.";
        }
    
        identity request-aborted-by-peer {
          base connection-error;
          description
            "The remote peer has aborted the ongoing request made by the
    local device.";
        }
    
        identity connection-time-out {
          base connection-error;
          description
            "A response from the peer has taken too long and the device
    timed-out the connection.";
        }
    
        identity url-too-long {
          base connection-error;
          description
            "The specified URL is too long.";
        }
    
        identity authentication-error {
          base download-error;
          description
            "Base identity for all error tags reporting authentication
    errors.
    
    This identity is abstract and SHOULD NOT generally be used as a
    value referenced by a leaf when reporting errors. If used to
    define an error that was not known at design time, it SHOULD be
    qualified with a corresponding description provided as
    additional information suitable for human display.";
        }
    
        identity authentication-required {
          base authentication-error;
          description
            "Authentication is required by the peer, but was not
    configured.";
        }
    
        identity authentication-mode-not-supported {
          base authentication-error;
          description
            "The specified authentication mode is not supported by the
    peer.";
        }
    
        identity invalid-username-or-password {
          base authentication-error;
          description
            "The specified user and/or password is not valid.";
        }
    
        identity remote-file-system-error {
          base download-error;
          description
            "Base identity for all error tags reporting file system errors
    at the remote peer.
    
    This identity is abstract and SHOULD NOT generally be used as a
    value referenced by a leaf when reporting errors. If used to
    define an error that was not known at design time, it SHOULD be
    qualified with a corresponding description provided as
    additional information suitable for human display.";
        }
    
        identity access-denied {
          base remote-file-system-error;
          description
            "Access to the file referenced in the request was denied by
    the remote peer.";
        }
    
        identity file-not-found {
          base remote-file-system-error;
          description
            "The file referenced in the request was not found on the
    remote peer.";
        }
    
        identity invalid-file-name {
          base remote-file-system-error;
          description
            "The file name referenced in the request is not valid.";
        }
    
        identity invalid-path {
          base remote-file-system-error;
          description
            "The file path referenced in the request is not valid.";
        }
    
        identity file-locked {
          base remote-file-system-error;
          description
            "The file referenced in the request is locked on the remote
    peer.";
        }
    
        identity invalid-file-size {
          base remote-file-system-error;
          description
            "The size of the file referenced in the request is not valid.";
        }
    
        identity local-file-system-error {
          base download-error;
          description
            "Base identity for all error tags reporting file system errors
    at the device.
    
    This identity is abstract and SHOULD NOT generally be used as a
    value referenced by a leaf when reporting errors. If used to
    define an error that was not known at design time, it SHOULD be
    qualified with a corresponding description provided as
    additional information suitable for human display.";
        }
    
        identity insufficient-storage-space {
          base local-file-system-error;
          description
            "The available local storage is insufficient to download a
    revision.";
        }
    
        identity maximum-number-of-revisions-reached {
          base local-file-system-error;
          description
            "A new revision cannot be downloaded, because the maximum
    number of revisions supported by the device has been reached.";
        }
    
        identity processing-error {
          base error-tag;
          description
            "Base identity for all error tags reporting processing errors
    occurring at a component.
    
    This identity is abstract and SHOULD NOT generally be used as a
    value referenced by a leaf when reporting errors. If used to
    define an error that was not known at design time, it SHOULD be
    qualified with a corresponding description provided as
    additional information suitable for human display.";
        }
    
        identity action-aborted {
          base processing-error;
          description
            "The associated action was aborted by the client.";
        }
    
        identity cannot-overwrite-revision {
          base processing-error;
          description
            "The target revision could not be overwritten.";
        }
    
        identity revision-not-valid {
          base processing-error;
          description
            "Base identity for all error tags reporting that a revision is
    invalid following its download.
    
    This identity is abstract and SHOULD NOT generally be used as a
    value referenced by a leaf when reporting errors. If used to
    define an error that was not known at design time, it SHOULD be
    qualified with a corresponding description provided as
    additional information suitable for human display.";
        }
    
        identity incompatible-version {
          base revision-not-valid;
          description
            "The version of the revision that was downloaded is not
    compatible with the software.";
        }
    
        identity revision-corrupt {
          base revision-not-valid;
          description
            "The downloaded revision is corrupted.";
        }
    
        identity unsupported-format {
          base revision-not-valid;
          description
            "The downloaded revision is in a format the is not supported
    by the device.";
        }
    
        identity revision-cannot-be-extracted-from-archive {
          base revision-not-valid;
          description
            "The downloaded file was an archive, but a revision could not
    be extracted from the archive.";
        }
    
        identity incorrect-hash {
          base revision-not-valid;
          description
            "The hash associated with the revision is incorrect.";
        }
    
        identity unsupported-hash-algorithm {
          base revision-not-valid;
          description
            "The algorithm used to calculate the hash associated with a
    revision is not supported by the device.";
        }
    
        identity cannot-abort {
          base processing-error;
          description
            "The associated ongoing activity cannot be aborted.";
        }
    
        identity already-completed {
          base processing-error;
          description
            "The associated activity had already completed and cannot be
    aborted.";
        }
    
        identity install-error {
          base processing-error;
          description
            "Base identity for all error tags reporting errors during the
    installation of a revision.
    
    This identity is abstract and SHOULD NOT generally be used as a
    value referenced by a leaf when reporting errors. If used to
    define an error that was not known at design time, it SHOULD be
    qualified with a corresponding description provided as
    additional information suitable for human display.";
        }
    
        identity incompatible-upgrade-or-downgrade-path {
          base install-error;
          description
            "The revision cannot be activated or committed, because an
    upgrade or downgrade of the software from the currently
    committed revision is not supported as part of the
    upgrade/downgrade path for the software.";
        }
    
        identity invalid-product-license {
          base install-error;
          description
            "The revision is licensed, but the device does not possess a
    valid license for the revision to activate or commit it.
    
    Note that how the device obtains and manages a license for a
    revision is beyond the scope of this model.";
        }
    
        identity database-conversion-failed {
          base install-error;
          description
            "At an upgrade or downgrade, an existing database required
    conversion to be compatible with the newer or older software,
    but this conversion failed.";
        }
    
        identity cannot-delete-revision {
          base processing-error;
          description
            "The revision could not be deleted.";
        }
    
        identity metadata-mismatch {
          base processing-error;
          description
            "The metadata of the revisions listed for the software in the
    operational state datastore at the time the action was invoked
    by the client is not identical to the metadata retrieved from
    the component immediately prior to execution of the activity
    resulting from the invocation of the action, i.e., the state
    of the revisions on the component has changed.";
        }
    
        identity component-not-responding {
          base processing-error;
          description
            "The component is not responding to requests.";
        }
    
        identity capability {
          description
            "Base identity for defining capabilities available to a client
    to manage a given software.";
        }
    
        identity download {
          base capability;
          description
            "Base identity for defining capabilities indicating support for
    downloading revisions within this YANG data model.
    
    This identity is abstract and MUST NOT be used to advertise
    support for a capability.";
        }
    
        identity download-target-selection-by-user {
          base download;
          description
            "Indicates that for the given software, the specific target
    revision in the list of revisions for that software to be used
    to store the downloaded revision can be selected by the user
    when invoking the action 'download' for that software.";
        }
    
        identity download-target-selection-by-system {
          base download;
          description
            "Indicates that for the given software, the target revision in
    the list of revisions for that software to be used to store the
    downloaded revision can be selected automatically by the system
    based on specific selection criteria when invoking the action
    'download' for that software.";
        }
    
        identity validate {
          base capability;
          description
            "Indicates that the software supports validating revisions.";
        }
    
        identity activate {
          base capability;
          description
            "Indicates that the software supports activating revisions.
    
    Note that a system may advertise the support for activating
    revisions even if the feature 'software-management-actions' is
    not supported by the system. In this case activation may only
    be possible via an alternative management interface.";
        }
    
        identity commit {
          base capability;
          description
            "Indicates that the software supports committing revisions.
    
    Note that a system may advertise the support for committing
    revisions even if the feature 'software-management-actions' is
    not supported by the system. In this case committing a revision
    may only be possible via an alternative management interface.";
        }
    
        identity delete {
          base capability;
          description
            "Indicates that the software supports deleting revisions.";
        }
    
        identity alias {
          base capability;
          description
            "Indicates that the software supports assigning an alias to a
    revision.";
        }
    
        grouping error {
          description
            "Data nodes associated with an error.";
          leaf tag {
            type identityref {
              base error-tag;
            }
            config false;
            mandatory true;
            description
              "Identifies the error that occurred.";
          }
    
          leaf message {
            type string;
            config false;
            description
              "Identifies the error or provides additional information
    on the given error as a string suitable for human display.";
          }
        }  // grouping error
    
        grouping source-of-a-download {
          description
            "Data nodes defining the source of a download.";
          choice source {
            description
              "Information pertaining to the original source of the
    revision, including any information required to access that
    revision.";
            leaf url {
              type inet:uri;
              description
                "URL containing the information required to download the
    specified file including the protocol, IP address, file
    path, file name, etc.";
            }
          }  // choice source
        }  // grouping source-of-a-download
    
        grouping revision-metadata {
          description
            "Data nodes defining the metadata of a revision.";
          leaf version {
            type string;
            description
              "Reports the version of the software revision.";
          }
    
          leaf product-code {
            type string;
            description
              "Reports the product code information of the software
    revision, if applicable.
    
    Note that this leaf is not to be instantiated, if no valid
    product code for the revision is available.";
          }
    
          leaf hash {
            type string;
            description
              "Reports the hash value calculated by the corresponding hash
    function on completion of the download of the software
    revision, if applicable.
    
    Note that this leaf is not to be instantiated, if no valid
    hash for the revision is available.";
          }
    
          container source {
            description
              "Information regarding the original source of
    the revision, from which it was downloaded.";
            uses source-of-a-download;
          }  // container source
        }  // grouping revision-metadata
    
        augment /hw:hardware/hw:component {
          description
            "An augmentation of a hardware component to add support for the
    management of software. The usage of such software can be for
    a variety of purposes and this model makes no assumptions
    about what the 'software' actually is. Examples could be an
    executable application software image, a firmware image for an
    onboard chip, or even an executable script.";
          container software {
            presence
              "The component supports management of at least one software.";
            config false;
            description
              "Hardware component data nodes, actions and notifications
    associated with software.";
            list software {
              key "name";
              min-elements 1;
              description
                "A software that is manageable on this component.";
              leaf name {
                type bbf-yang:string-ascii64;
                description
                  "The name associated with this software. For a given
    component, there may be more than one type of software
    being managed, e.g. application software, firmware or
    FPGA firmware. The name should represent this
    association, e.g. 'firmware'.";
              }
    
              leaf-list capability {
                type identityref {
                  base capability;
                }
                description
                  "A capability supported by the server for this software.";
              }
    
              container revisions {
                must
                  "count(bbf-swm:revision[bbf-swm:is-active = 'true']) <= 1" {
                  error-message
                    "Only one active revision is allowed.";
                  description
                    "Ensure that there is only one active revision.";
                }
                must
                  "count(bbf-swm:revision[bbf-swm:is-committed = 'true']) <= 1" {
                  error-message
                    "Only one committed revision is allowed.";
                  description
                    "Ensure that there is only one committed revision.";
                }
                description
                  "Information and actions applicable to all revisions of
    the given software.";
                leaf maximum-number-of-revisions {
                  type uint16 {
                    range "1..max";
                  }
                  description
                    "If the device supports a known limited number of
    revisions, this node will report the maximum number of
    revisions supported by the device.";
                }
    
                container download {
                  when
                    "derived-from(../../bbf-swm:capability,'bbf-swm:download') and count(../bbf-swm:revision[bbf-swm:state='downloading'])=0" {
                    description
                      "Only applicable if downloading of revisions for this
    software is supported and no other download of a
    revision for this software is currently in
    progress.";
                  }
                  description
                    "Provides containment for the action 'download'.";
                  action download {
                    if-feature software-management-actions;
                    description
                      "Download the specified software revision to this
    component.
    
    Successful invocation of this action results in the
    immediate creation or reuse of the entry in the list
    'revision' referenced by the leaf 'id' in the output
    element of this action.
    
    No entry is created or reused in the list 'revision',
    if the invocation of this action is unsuccessful.
    
    If an implementation of the model limits the maximum
    number of entries in the list 'revision', the maximum
    number of supported entries should be reported in the
    leaf 'maximum-number-of-revisions'.
    
    Note that a download of a revision for the software
    is only possible, if no download of any revision for
    that software is in progress.
    
    If errors occur during the processing of this action,
    'error-app-tag' and 'error-message' in the
    error information returned by the server are to be
    populated as follows:
    
      error-app-tag: A string in the form
    		   <module-name>:<identity>
    		 where <identity> is a string version
    		 of an identity value based on the
    		 identity 'bbf-swm:error-tag' that
    		 describes the reason the error
    		 occurred and <module-name> is the
    		 name of the module in which the
    		 identity is defined; equivalent to
    		 the data nodes 'tag' defined within
    		 this model.
    
      error-message: A text string describing the cause
    		 of the error when either no defined
    		 reason exists or additional
    		 information is available beyond that
    		 defined by the tag itself;
    		 equivalent to the data nodes
    		 'message' defined within this
    		 model.";
                    input {
                      container source {
                        description
                          "The source of the download.";
                        uses source-of-a-download {
                          refine source {
                            mandatory true;
                          }
                        }
                      }  // container source
    
                      container target {
                        description
                          "The target of the download.";
                        choice target {
                          mandatory true;
                          description
                            "The target entry in the list 'revision' for
    the download, including how the entry is to be
    selected.";
                          case selected-by-user {
                            when
                              "../../../../bbf-swm:capability='bbf-swm:download-target-selection-by-user'" {
                              description
                                "Only applicable if the software
    supports the case 'selected-by-user'.";
                            }
                            if-feature download-target-selection-by-user;
                            container selected-by-user {
                              description
                                "Data nodes to allow the user to specify an
    entry in the list 'revision' to use as the
    target for the download.";
                              leaf operation {
                                type enumeration {
                                  enum "create" {
                                    value 0;
                                    description
                                      "Create a new entry in the list
    'revision'.
    
    If there are insufficient resources
    to create a new entry, the action
    will not download the revision, will
    not modify the list 'revision' and
    will report an error.";
                                  }
                                  enum "replace" {
                                    value 1;
                                    description
                                      "Replace an existing entry in the
    list 'revision' as defined by the
    selection criteria within the
    container '../replace'.
    
    If no entry satisfies the selection
    criteria, the action will not
    download the revision, will not
    modify the list 'revision' and will
    report an error.";
                                  }
                                }
                                mandatory true;
                                description
                                  "The operation to be performed on the list
    'revision' to download the revision.";
                              }
    
                              container replace {
                                when
                                  "../bbf-swm:operation='replace'" {
                                  description
                                    "This container is only applicable if
    the replace operation is selected.";
                                }
                                description
                                  "Defines criteria that are to apply when
    selecting an entry in the list 'revision'
    when replacing a revision.";
                                choice selection-criteria {
                                  mandatory
                                    true;
                                  description
                                    "Selects the criteria to identify which
    entry in the list 'revision' should
    be replaced.";
                                  case id {
                                    description
                                      "This case specifies that the action
    is to replace the entry within the
    list 'revision' with the specified
    'id'. The entry must be neither
    active nor committed, if
    applicable.";
                                    leaf id {
                                      type leafref {
                                        path "../../../../../../../bbf-swm:revisions/bbf-swm:revision/bbf-swm:id";
                                      }
                                      must
                                        "not(../../../../../../../bbf-swm:capability='bbf-swm:activate') or ((../../../../../../../bbf-swm:capability='bbf-swm:activate') and (../../../../../../../bbf-swm:revisions/bbf-swm:revision[bbf-swm:id=current()]/bbf-swm:is-active='false'))" {
                                        error-message
                                          "The revision specified to be replaced is active.";
                                        description
                                          "Ensure that the referenced
    revision is not currently
    active.";
                                      }
                                      must
                                        "not(../../../../../../../bbf-swm:capability='bbf-swm:commit') or ((../../../../../../../bbf-swm:capability='bbf-swm:commit') and (../../../../../../../bbf-swm:revisions/bbf-swm:revision[bbf-swm:id=current()]/bbf-swm:is-committed='false'))" {
                                        error-message
                                          "The revision specified to be replaced is committed.";
                                        description
                                          "Ensure that the referenced
    revision is not currently
    committed.";
                                      }
                                      mandatory
                                        true;
                                      description
                                        "The value of the leaf 'id' of an
    existing entry in the list
    'revision' that identifies the
    entry which is to be replaced.";
                                    }
                                  }  // case id
    
                                  case alias {
                                    when
                                      "boolean(../../../../../../bbf-swm:capability='bbf-swm:alias')" {
                                      description
                                        "Only applicable if the software
    supports the assignment of an
    alias to a revision.";
                                    }
                                    description
                                      "This case specifies that the action
    is to replace the entry in the list
    'revision' with the specified
    'alias'. The entry must be neither
    active nor committed, if
    applicable.";
                                    leaf alias {
                                      type leafref {
                                        path "../../../../../../../bbf-swm:revisions/bbf-swm:revision/bbf-swm:alias";
                                      }
                                      must
                                        "not(../../../../../../../bbf-swm:capability='bbf-swm:activate') or ((../../../../../../../bbf-swm:capability='bbf-swm:activate') and (../../../../../../../bbf-swm:revisions/bbf-swm:revision[bbf-swm:alias=current()]/bbf-swm:is-active='false'))" {
                                        error-message
                                          "The revision specified to be replaced is active.";
                                        description
                                          "Ensure that the referenced
    revision is not currently
    active.";
                                      }
                                      must
                                        "not(../../../../../../../bbf-swm:capability='bbf-swm:commit') or ((../../../../../../../bbf-swm:capability='bbf-swm:commit') and (../../../../../../../bbf-swm:revisions/bbf-swm:revision[bbf-swm:alias=current()]/bbf-swm:is-committed='false'))" {
                                        error-message
                                          "The revision specified to be replaced is committed.";
                                        description
                                          "Ensure that the referenced
    revision is not currently
    committed.";
                                      }
                                      mandatory
                                        true;
                                      description
                                        "The value of the leaf 'alias' of
    an existing entry in the list
    'revision' that identifies the
    entry which is to be replaced.";
                                    }
                                  }  // case alias
                                }  // choice selection-criteria
                              }  // container replace
                            }  // container selected-by-user
                          }  // case selected-by-user
    
                          case selected-by-system {
                            when
                              "../../../../bbf-swm:capability='bbf-swm:download-target-selection-by-system'" {
                              description
                                "Only applicable if the software
    supports the case 'selected-by-system'.";
                            }
                            if-feature download-target-selection-by-system;
                            container selected-by-system {
                              description
                                "Defines how the system is to select an
    entry in the list 'revision' to use as
    a target for the download.";
                              leaf operation {
                                type enumeration {
                                  enum
                                    "create-or-replace" {
                                    value 0;
                                    description
                                      "Preferably create a new entry in the
    list 'revision'.
    
    If there are insufficient resources
    to create a new entry, replace an
    existing entry, if and only if it
    fulfills the selection criteria
    defined within the container
    '../replace'.
    
    If no entry fulfills the selection
    criteria, the action will not
    download the revision, will not
    modify the list 'revision' and will
    report an error.";
                                  }
                                  enum
                                    "replace-or-create" {
                                    value 1;
                                    description
                                      "Preferably replace an existing entry
    in the list 'revision', if and only
    if it fulfills the selection criteria
    defined within the container
    '../replace'.
    
    If no entry satisfies the selection
    criteria, create a new entry.
    
    If sufficient resources are not
    available to create a new entry, the
    action will not download the
    revision, will not modify the list
    'revision' and will report an
    error.";
                                  }
                                  enum "replace" {
                                    value 2;
                                    description
                                      "Replace an existing entry in the list
    'revision' and then if and only if
    it fulfills the selection criteria
    defined within the container
    '../replace'.
    If no entry fulfills the selection
    criteria, the action will not
    download the revision, will not
    modify the list 'revision' and will
    report an error.";
                                  }
                                }
                                mandatory true;
                                description
                                  "The operation to be performed by the
    system on the list 'revision' to download
    the revision.";
                              }
    
                              container replace {
                                description
                                  "Defines criteria that are to apply when
    the system selects an entry in the list
    'revision' when replacing a revision.";
                                leaf not-available-only {
                                  type boolean;
                                  default "true";
                                  description
                                    "If 'true' this action may only replace
    an entry in the list 'revision' whose
    leaf 'state' is set to 'not-available'
    and which fulfills all other selection
    criteria.
    
    If 'false' this action may replace an
    entry in the list 'revision' whose
    leaf 'state' is set to 'not-available'
    or whose leaf 'state' is set to
    'available', but which is neither
    active nor committed, and which
    fulfills all other selection
    criteria.";
                                }
    
                                leaf oldest-only {
                                  type boolean;
                                  default "true";
                                  description
                                    "If 'true' this action may only replace
    the oldest entry in the list
    'revision', which is neither active
    nor committed, and which fulfills all
    other selection criteria.
    
    If 'false' this action may replace any
    entry in the revision list of any age,
    which is neither active nor committed,
    and which fulfills all other selection
    criteria. The selection algorithm in
    this case is implementation specific.";
                                }
                              }  // container replace
                            }  // container selected-by-system
                          }  // case selected-by-system
                        }  // choice target
    
                        leaf alias {
                          when
                            "boolean(../../../../../bbf-swm:capability='bbf-swm:alias')" {
                            description
                              "Only applicable if the software supports
    the assignment of an alias to a revision.";
                          }
                          type bbf-yang:string-ascii64;
                          must
                            "(../bbf-swm:selected-by-user/bbf-swm:replace/bbf-swm:alias=.) or (../../../../../bbf-swm:revisions/bbf-swm:revision[bbf-swm:id=current()/../selected-by-user/replace/id]/bbf-swm:alias=.) or (count(../../../../../bbf-swm:revisions/bbf-swm:revision[bbf-swm:alias=current()])=0)" {
                            error-message
                              "The specified alias to be assigned to the revision is already in use.";
                            description
                              "Ensure that the alias is does not already
    exist unless replacing a revision with that
    alias.";
                          }
                          description
                            "An optional 'alias' to be assigned to the
    revision.
    
    If the 'selected-by-user' option is selected,
    the value of this leaf may be identical to
    the value of the leaf 'alias' of the revision
    selected to be replaced, otherwise the value of
    this leaf must not be equal to the value of
    the leaf 'alias' of any existing revision.";
                        }
                      }  // container target
                    }
    
                    output {
                      container target {
                        presence
                          "A target entry in the revision list for the
    download was successfully selected.";
                        description
                          "The selected target for the download.";
                        leaf id {
                          type uint8;
                          mandatory true;
                          description
                            "The unique 'id' of the entry in the list
    'revision' which has been selected as the
    target for the download.";
                        }
    
                        container replaces {
                          presence
                            "Indicates that an existing entry referenced by
    '../id' in the list 'revision' has been
    replaced by this action.";
                          description
                            "Reports the metadata for the previous entry in
    the list 'revision' that is now being replaced
    by the revision being downloaded.";
                          leaf alias {
                            when
                              "boolean(../../../../../../bbf-swm:capability='bbf-swm:alias')" {
                              description
                                "Only applicable if the 'alias' capability
    is supported.";
                            }
                            type bbf-yang:string-ascii64;
                            description
                              "An 'alias' name for the revision.";
                          }
    
                          uses revision-metadata;
                        }  // container replaces
                      }  // container target
                    }
                  }  // rpc download
                }  // container download
    
                notification revision-deleted {
                  description
                    "Indicates that a particular software revision was
    deleted from the list of available revisions.";
                  leaf id {
                    type uint8;
                    mandatory true;
                    description
                      "The unique identifier of the software revision that
    was deleted.";
                  }
    
                  leaf alias {
                    when
                      "boolean(../../../bbf-swm:capability='bbf-swm:alias')" {
                      description
                        "Only applicable if the 'alias' capability is
    supported.";
                    }
                    type bbf-yang:string-ascii64;
                    description
                      "An 'alias' name for the revision.";
                  }
    
                  uses revision-metadata;
                }  // notification revision-deleted
    
                list revision {
                  key "id";
                  unique "alias";
                  description
                    "A revision available on the component for a given
    software managed on that component.";
                  leaf id {
                    type uint8;
                    description
                      "A unique identifier for the software revision.";
                  }
    
                  leaf alias {
                    when
                      "boolean(../../../bbf-swm:capability='bbf-swm:alias')" {
                      description
                        "Only applicable if the 'alias' capability is
    supported.";
                    }
                    type bbf-yang:string-ascii64;
                    description
                      "An 'alias' name for the revision.";
                  }
    
                  leaf state {
                    type enumeration {
                      enum "downloading" {
                        value 0;
                        description
                          "The revision is currently being downloaded.";
                      }
                      enum "not-available" {
                        value 1;
                        description
                          "The revision could not be successfully downloaded
    or has been downloaded, but could not be verified
    as a valid revision.";
                      }
                      enum "available" {
                        value 2;
                        description
                          "The revision has been successfully downloaded,
    if applicable, has been verified as valid, but
    is neither active nor committed.";
                      }
                      enum "in-use" {
                        value 3;
                        description
                          "The revision is currently reserved for use by the
    system, i.e., is either active or committed or
    both.";
                      }
                    }
                    mandatory true;
                    description
                      "The current operational state of the revision.";
                  }
    
                  leaf last-changed {
                    type yang:date-and-time;
                    mandatory true;
                    description
                      "The time of the last change to the 'state' of the
    revision or when the revision was created.";
                  }
    
                  leaf download-completed {
                    when
                      "derived-from(../../../capability,'bbf-swm:download') and ../bbf-swm:state != 'downloading'" {
                      description
                        "Only applicable if downloading of revisions for
    this software is supported and the revision is not
    currently being downloaded.";
                    }
                    type yang:date-and-time;
                    description
                      "The date and time when the download activity
    completed, whether successful or not.
    
    Note that this leaf is not to be instantiated, if no
    date and time is available. However, where possible
    an implementation could persist such information,
    for example, across a restart of the component or
    system.";
                  }
    
                  uses revision-metadata;
    
                  leaf is-valid {
                    when
                      "boolean(../../../bbf-swm:capability='bbf-swm:validate')" {
                      description
                        "Only applicable if the 'validate' capability is
    supported.";
                    }
                    type boolean;
                    mandatory true;
                    description
                      "Reports whether the software revision is valid
    ('true') or invalid ('false').";
                  }
    
                  leaf is-active {
                    when
                      "boolean(../../../bbf-swm:capability='bbf-swm:activate')" {
                      description
                        "Only applicable if the 'activate' capability is
    supported.";
                    }
                    type boolean;
                    mandatory true;
                    description
                      "Reports whether the software revision is active
    ('true') or inactive ('false').";
                  }
    
                  leaf is-committed {
                    when
                      "boolean(../../../bbf-swm:capability='bbf-swm:commit')" {
                      description
                        "Only applicable if the 'commit' capability is
    supported.";
                    }
                    type boolean;
                    mandatory true;
                    description
                      "Reports whether the software revision is committed
    ('true') or uncommitted ('false').";
                  }
    
                  container abort-download {
                    when
                      "derived-from(../../../capability,'bbf-swm:download') and ../bbf-swm:state='downloading'" {
                      description
                        "Action 'abort-revision' can only be invoked when a
    download is in progress.";
                    }
                    description
                      "Provides containment for the action 'abort-
    download'.";
                    action abort-download {
                      if-feature software-management-actions;
                      description
                        "Abort the download process.";
                    }  // rpc abort-download
    
                    notification download-revision-aborted {
                      description
                        "Indicates that the download of the specified
    software revision has been successfully aborted.";
                    }  // notification download-revision-aborted
    
                    notification abort-failed {
                      description
                        "Indicates that the system failed to abort an
    ongoing download activity.";
                      container error {
                        description
                          "Data nodes describing the error that caused the
    abort activity to fail.";
                        uses error;
                      }  // container error
                    }  // notification abort-failed
                  }  // container abort-download
    
                  container activate {
                    when
                      "boolean(../../../bbf-swm:capability='bbf-swm:activate') and (../bbf-swm:state='available' or ../bbf-swm:state='in-use')" {
                      description
                        "Only applicable if the 'activate' capability is
    supported and then only if the revision can be
    activated.";
                    }
                    description
                      "Actions and notifications associated with activating
    a software revision.";
                    leaf last-activated {
                      type yang:date-and-time;
                      description
                        "The date and time when this revision last became
    the active revision, that is, the leaf 'is-active'
    transitioned from 'false' to 'true', i.e., only
    a successful activation of the revision affects
    this date and time.
    
    Note that this revision itself may no longer be
    active, if another revision has been activated in
    the meantime. This does not affect the date and
    time reported here.
    
    Note that this leaf is not to be instantiated, if
    no date and time is available. However, where
    possible an implementation could persist such
    information, for example, across a restart of the
    component or system.";
                    }
    
                    action activate {
                      if-feature software-management-actions;
                      description
                        "Activate this revision.
    
    The system performs whatever steps are required to
    activate the revision. For example, this may
    include restarting the component or device, if this
    is necessary to activate the revision and would be
    performed as part of the activity initiated by a
    successful invocation of this action.
    
    Successful activation of this revision, will
    automatically deactivate any other revision of the
    software that was previously active, i.e., set the
    value of the leaf 'is-active' of the other revision
    to 'false').
    
    The leaf 'is-active' and 'last-activated', if
    supported, will only be set on successful
    completion of the activation activity.";
                    }  // rpc activate
    
                    notification revision-activated {
                      description
                        "Indicates that the specified revision has
    successfully activated on the target component.";
                    }  // notification revision-activated
    
                    notification activate-failed {
                      description
                        "Indicates that the specified revision failed to
    activate on its target component.";
                      container error {
                        description
                          "Data nodes describing the error that caused the
    activation to fail.";
                        uses error;
                      }  // container error
                    }  // notification activate-failed
                  }  // container activate
    
                  container commit {
                    when
                      "boolean(../../../bbf-swm:capability='bbf-swm:commit') and (../bbf-swm:state='available' or ../bbf-swm:state='in-use')" {
                      description
                        "Only applicable if the 'commit' capability is
    supported and then only if the revision can be
    committed.";
                    }
                    description
                      "Actions and notifications associated with committing
    a software revision.";
                    leaf last-committed {
                      type yang:date-and-time;
                      description
                        "The date and time when this revision last became
    the committed revision, that is, the leaf
    'is-committed' transitioned from 'false' to 'true',
    i.e., only a successful commit of the revision
    affects this date and time.
    
    Note that this revision itself may no longer be
    committed, if another revision has been committed
    in the meantime. This does not affect the date and
    time reported here.
    
    Note that this leaf is not to be instantiated, if
    no date and time is available. However, where
    possible an implementation could persist such
    information, for example, across a restart of the
    component or system.";
                    }
    
                    action commit {
                      if-feature software-management-actions;
                      description
                        "Commit this revision.
    
    A successful commit of this revision, will
    automatically un-commit any other revision of the
    software that was previously committed, i.e., set
    the value of the leaf 'is-committed' of the other
    revision to 'false').
    
    The leaf 'is-committed' and 'last-committed', if
    supported, will only be set on successful
    completion of the commit activity.
    
    Note that committing a non-active revision does not
    activate that revision.";
                    }  // rpc commit
    
                    notification revision-committed {
                      description
                        "Indicates that the specified revision has
    successfully committed on the target component.";
                    }  // notification revision-committed
    
                    notification commit-failed {
                      description
                        "Indicates that the revision software failed to
    commit on its target component.";
                      container error {
                        description
                          "Data nodes describing the error that caused the
    commit to fail.";
                        uses error;
                      }  // container error
                    }  // notification commit-failed
                  }  // container commit
    
                  container delete {
                    when
                      "boolean(../../../bbf-swm:capability='bbf-swm:delete') and (../bbf-swm:state != 'in-use')" {
                      description
                        "Only applicable if the 'delete' capability is
    supported and then only if the revision is not
    in-use (active or committed).";
                    }
                    description
                      "Action associated with deleting a software
    revision.";
                    action delete {
                      if-feature software-management-actions;
                      description
                        "Delete this revision.";
                    }  // rpc delete
    
                    notification delete-failed {
                      description
                        "Indicates that the system failed to delete this
    revision.";
                      container error {
                        description
                          "Data nodes describing the error that caused the
    delete activity to fail.";
                        uses error;
                      }  // container error
                    }  // notification delete-failed
                  }  // container delete
    
                  notification revision-downloaded {
                    description
                      "Indicates that the specified software revision has
    been successfully downloaded to the target
    component.";
                  }  // notification revision-downloaded
    
                  notification download-revision-failed {
                    description
                      "Indicates that the specified software revision
    failed to download to its target component.";
                    container error {
                      description
                        "Data nodes describing the error that caused the
    download to fail.";
                      uses error;
                    }  // container error
                  }  // notification download-revision-failed
                }  // list revision
              }  // container revisions
            }  // list software
          }  // container software
        }
      }  // module bbf-software-management
    

© 2023 YumaWorks, Inc. All rights reserved.