Network Element Drivers (NEDs)

module tailf-ncs-ned {
  namespace "http://tail-f.com/ns/ncs-ned";
  prefix ned;

  import tailf-common {
    prefix tailf;
  }

  organization "Tail-f Systems";

  description
    "This module defines the Tail-f NCS NED base identities.

     Copyright 2011-2021 Cisco Systems, Inc.
     All rights reserved.
     Permission is hereby granted to redistribute this file without
     modification.";

  revision 2021-09-02 {
    description
      "Released as part of NCS-5.6.

       Added identity 'generic-ned-notification-id'.

       Added idenity 'cli-ned-notification-id'.";
  }

  revision 2019-04-09 {
    description
      "Released as part of NCS-5.1.

       Added 'ned-id' as base to all protocol specific ned ids.";
  }

  revision 2016-11-24 {
    description
      "Released as part of NCS-4.3.

       Added base identity for NETCONF devices.
       Added identity lsa-netconf";
  }

  revision 2011-06-01 {
    description
      "Released as part of NCS-1.6.";
  }

  identity ned-id {
    description
      "Base identity for Tail-f NEDs.";
  }

  identity netconf-ned-id {
    base ned-id;
    tailf:abstract;
    description
      "Base identity for NETCONF NEDs.";
  }
  identity generic-ned-id {
    base ned-id;
    tailf:abstract;
    description
      "Base identity for generic NEDs.";
  }

  identity cli-ned-id {
    base ned-id;
    tailf:abstract;
    description
      "Base identity for CLI NEDs.";
  }
  identity snmp-ned-id {
    base ned-id;
    tailf:abstract;
    description
      "Base identity for SNMP NEDs.

       Note that currently there is no way to actually set a ned-id
       for SNMP devices.";
  }

  identity rfc5277-id {
    base netconf-ned-id;
    tailf:abstract;
    description
      "Special internal id for the data model in RFC 5277.";
  }

  identity generic-ned-notification-id {
    base generic-ned-id;
    tailf:abstract;
    description
      "Special internal id for generic NEDs with notification capability.";
  }

  identity cli-ned-notification-id {
    base cli-ned-id;
    tailf:abstract;
    description
      "Special internal id for CLI NEDs with notification capability.";
  }

  identity netconf {
    base netconf-ned-id;
    description
      "Default identity for a netconf device.";
  }

  identity lsa-netconf {
    base netconf-ned-id;
    description
      "Base identity for LSA nodes.";
  }

  identity snmp {
    base snmp-ned-id;
    description
      "Default identity for an SNMP device.";
  }

}

import tailf-ncs-ned {
    prefix ned;
}

identity cisco-ios {
 base ned:cli-ned-id;
}

admin@ncs# show running config devices device r1
    
address   127.0.0.1
port      2025
authgroup default
device-type cli ned-id cisco-ios
state admin-state unlocked
...

// should return "cli" or "generic"
String type();

// Which YANG modules are covered by the class
String [] modules();

// Which identity is implemented by the class
String identity();

/*    -*- Java -*-
 *
 *  Copyright 2010 Tail-F Systems AB. All rights reserved.
 *
 *  This software is the confidential and proprietary
 *  information of Tail-F Systems AB.
 *
 *  $Id$
 *
 */
package com.tailf.ned;

import java.io.InputStream;
import java.util.Calendar;

import javax.xml.XMLConstants;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import org.w3c.dom.Document;
import org.xml.sax.InputSource;

import com.tailf.conf.ConfPath;
import com.tailf.conf.ConfXMLParam;
import com.tailf.maapi.Maapi;
import com.tailf.maapi.MaapiSchemas.CSSchema;
import com.tailf.ned.NedWorker.TransactionIdMode;

/**
 * A NedConnection is the interface used by the NedMux for keeping
 * track of connections to different devices. One instance of each
 * type should be registered with the NedMux before the NedMux is
 * started. Specific sub-classes are defined for cli and generic
 * neds, see NedCli and NedGeneric.
 *
 * The life of a specific connection to a backend device is as
 * follows.
 *
 * 1 Initially an instance is created through the invocation of
 *   the create method, and a connection to the backend
 *   device is set up.
 * 2 a mix of prepare/abort/revert/commit/persist/show/getTransId/
 *   showStatsPath, etc
 * 3 possibly get invocations to the isAlive() method. This method
 *   is involved when the connection is pooled.
 * 4 possibly get an invocation to the reconnect method, and start
 *   over at 2
 * 5 finally one of the close() methods will be involved. The
 *   connection should close the connection to the device and
 *   release all resources.
 *
 * If the connection is poolable then it may live in the connection
 * pool. The state of the connection is polled by the connection
 * pool manager using the isAlive() method.
 *
 */

abstract public class NedConnectionBase {

    private static Logger LOGGER = LogManager.getLogger(
            NedConnectionBase.class);

    private NedCapability[] capas;
    private NedCapability[] statscapas;
    private boolean wantRevertDiff;
    private TransactionIdMode transMode = TransactionIdMode.NONE;
    private ConfXMLParam[] platformData;
    private int connectionId;
    private long poolTimestamp = Long.MAX_VALUE;
    private boolean useStoredCapas = false;
    // Holds reference to the new style SSH connection
    protected SSHClient sshClient = null;

    protected void setPoolTimestamp(long timestamp) {
        this.poolTimestamp = timestamp;
    }

    public long getTimeInPool() {
        return Calendar.getInstance().getTimeInMillis() - poolTimestamp;
    }

    /**
     * This function is used to set the parameters of NedConnection for
     * a specific NED.
     *
     * @param capas
     *  an array of capabilities for config data
     * @param statscapas
     *  an array of capabilities for stats data
     * @param wantRevertDiff
     *  Indicates if the NED should be provided with the edit operations
     *    needed to undo the configuration changes done in
     *    the prepare method when a transaction is aborted.
     * @param transMode
     *  Indicates the mode of Transaction ID supported by the NED.
     *    NONE if not supported. If supported, then getTransId()
     *    should be implemented. Support for Transaction IDs is required
     *    for check-sync action.
     */
    public void setConnectionData(NedCapability[] capas,
                                  NedCapability[] statscapas,
                                  boolean wantRevertDiff,
                                  TransactionIdMode transMode) {
        this.capas = capas;
        this.statscapas = statscapas;
        this.wantRevertDiff = wantRevertDiff;
        this.transMode = transMode;
    }

    /**
     * This function is used to set the capabilities for a specific NED.
     * It has the same functionality as setConnectionData, but only for
     * config capabilities. This is useful when initializing a NED instance
     * without establishing connection to the device because other connection
     * parameters such as stats capabilities, reverse diff and
     * transaction id mode are irrelevant in this case
     *
     * @param capas
     *  an array of capabilities for config data
     */
    public void setCapabilities(NedCapability[] capas) {
        this.capas = capas;
    }

    /**
     * This function is used to set the same capabilities as stored in
     * CDB for a particular device. This method can only be used when
     * initializing a NED instance without establishing connection to
     * the device.
     */
    public void useStoredCapabilities() {
        this.useStoredCapas = true;
    }

    /**
     * This function is used to set the platform operational data for
     * a specific NED. This is optional data that can be retrieved and
     * used for instance in service code.
     *
     * It is possible to augment NED specific data into the platform container
     * in the NCS device model. This method is then used to set both standard
     * and augmented data.
     *
     * The ConfXMLParam[] array is expected to start with the platform tag:
     *
     * The following is an example of how the platformData array would
     * be structured in an example with both the NCS standard name,
     * model and version leaves as well as a augmented inventory list
     * with three list elements:
     * <pre>
     * ConfXMLParam[] platformData =
     *     new ConfXMLParam[] {
     *         new ConfXMLParamStart("ncs", "platform"),
     *         new ConfXMLParamValue("ncs", "name",
     *                               new ConfBuf("ios")),
     *         new ConfXMLParamValue("ncs", "version",
     *                               new ConfBuf("15.0M")),
     *         new ConfXMLParamValue("ncs", "model",
     *                               new ConfBuf("7200")),
     *
     *         new ConfXMLParamStart("ginv", "inventory"),
     *         new ConfXMLParamValue("ginv", "name",
     *                               new ConfBuf("lx-345")),
     *         new ConfXMLParamValue("ginv", "value",
     *                               new ConfBuf("line-card")),
     *         new ConfXMLParamStop("ginv", "inventory"),
     *         new ConfXMLParamStart("ginv", "inventory"),
     *         new ConfXMLParamValue("ginv", nameStr,
     *                               new ConfBuf("lx-1001")),
     *         new ConfXMLParamValue("ginv", "value",
     *                               new ConfBuf("line-card")),
     *         new ConfXMLParamStop("ginv", "inventory"),
     *         new ConfXMLParamStart("ginv", "inventory"),
     *         new ConfXMLParamValue("ginv", "name",
     *                               new ConfBuf("FA1209A4E389")),
     *         new ConfXMLParamValue("ginv", "value",
     *                               new ConfBuf("licence")),
     *         new ConfXMLParamStop("ginv", "inventory"),
     *
     *         new ConfXMLParamStop("ncs", "platform")
     *     };
     *
     *      setPlatformData(platformData);
     *
     * </pre>
     *
     * @param platformData
     *  An ConfXMLParam array containing operational data to be set under
     *  the platform container in the device model. Expected to start with
     *  the platform tag. If the platform container is augmented with some user
     *  specific model such data should also be part of this array to be set at
     *  connection time.
     */
    public void setPlatformData(ConfXMLParam[] platformData) {
        this.platformData = platformData;
    }

    public int connection_id() {
        return getConnectionId();
    }

    protected void setConnectionId(int connectionId) {
        this.connectionId = connectionId;
    }

    public int getConnectionId() {
        return connectionId;
    }

    public NedCapability[] getCapas() {
        return capas;
    }

    public NedCapability[] getStatsCapas() {
        return statscapas;
    }

    public boolean getWantRevertDiff() {
        return wantRevertDiff;
    }

    public TransactionIdMode getTransactionIdMode() {
        return transMode;
    }

    public ConfXMLParam[] getSystemStateData() {
        return platformData;
    }

    public boolean getUseStoredCapas() {
        return useStoredCapas;
    }

    /**
     * The device_id is originally provided by NCS to properly identify
     * the device. It is the name used for the device by NCS in the
     * list of devices.
     */
    abstract public String device_id();

    /**
     * The type is one of "cli" and "generic". This information is sent to
     * NCS when the NedMux is started to let NCS know how to communicate
     * with each device.
     */
    abstract public String type();

    /**
     * Which YANG modules are covered by the class instance. This information
     * is defined by the setConnectionData() call and is sent to NCS after
     * initiating a new connection, or when re-establishing a connection.
     * The modules() method is not actually used.
     */
    abstract public String [] modules();

    /**
     * This should return the a unique (among registered NedConnection classes)
     * identity. It will be used by NCS when creating new connections to
     * control which of the registered NedConnection classes to use.
     */
    public String identity() {
        // obsolete since NSO 4.7
        return null;
    }

    /**
     * This indicates that the current set of operations should be
     * committed to the running configuration. When completed the
     * w.commitResponse() method should be invoked. Devices that does
     * not support commit() should invoke the w.commitResponse() method
     * without delay. On error invoke the w.error(NedCmd.COMMIT,
     * Error, Reason) method.
     *
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication between NCS and the device. This NedWorker
     *    instance should be used when communicating with NCS, i.e,
     *    for sending responses, errors, and trace messages. It is also
     *    implements the NedTracer API and can be used in, for example,
     *    the SSHSession as a tracer.
     * @param timeout
     *    If the commit operation does not complete within 'timeout' seconds
     *    the operation should be aborted.
     */
    abstract public void commit(NedWorker w, int timeout) throws Exception;

    /**
     * This method is invoked when the currently committed change set
     * should be made permanent. This corresponds to copying the
     * running configuration to the startup configuration, on a
     * running/startup device, or issuing the confirming commit operation
     * on a device that supports that. When completed the
     * w.persistResponse() should be invoked. On error invoke the
     * w.error(NedCmd.PERSIST,Error, Reason) method.
     *
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication between NCS and the device. This NedWorker
     *    instance should be used when communicating with NCS, i.e,
     *    for sending responses, errors, and trace messages. It is also
     *    implements the NedTracer API and can be used in, for example,
     *    the SSHSession as a tracer.
     */
    abstract public void persist(NedWorker w) throws Exception;

    /**
     * This method is invoked when the connection is terminated. It is
     * not invoked when placing the connection in the connection pool.
     * No response is required, but trace messages may be generated
     * during the close down.
     *
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication between NCS and the device. This NedWorker
     *    instance should be used when communicating with NCS, i.e,
     *    for sending responses, errors, and trace messages. It is also
     *    implements the NedTracer API and can be used in, for example,
     *    the SSHSession as a tracer.
     */
    abstract public void close(NedWorker w) throws Exception;

    /**
     * This method is invoked when a connection close is forced and no
     * NedWorker is involved. This typically occurs when a connection
     * is removed from the connection pool. No response or trace
     * messages can be sent during the operation.
     */
    abstract public void close();

    /**
     * @deprecated Use the method
     * {@link #isAlive(NedWorker)}
     * instead.
     *
     * If the {@link #isAlive(NedWorker)}
     * method is implemented in the NED, this method will not be
     * invoked. The NED must implement one of these methods.
     *
     */
    @Deprecated
    public boolean isAlive() {
        return false;
    }

    /**
     * This method is invoked to check if a connection is still
     * alive. When a connection is stored in the connection pool
     * it will periodically be polled to see if it is alive. If
     * false is returned the connection will be closed using the
     * close() method invocation.
     *
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication between NCS and the device. This NedWorker
     *    instance should be used when communicating with NCS, i.e,
     *    for sending responses, errors, and trace messages. It is also
     *    implements the NedTracer API and can be used in, for example,
     *    the SSHSession as a tracer.
     */
    public boolean isAlive(NedWorker w) {
        return this.isAlive();
    }

    protected void isSessionAlive(NedWorker w) throws Exception {
        boolean alive = false;
        try {
            alive = this.isAlive(w);
        } catch (Exception e) {
            alive = false;
        }
        w.isAliveResponse(alive);
    }

    /**
     * This method is invoked periodically to keep an connection
     * alive. If false is returned the connection will be closed using the
     * close() method invocation.
     *
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication between NCS and the device. This NedWorker
     *    instance should be used when communicating with NCS, i.e,
     *    for sending responses, errors, and trace messages. It is also
     *    implements the NedTracer API and can be used in, for example,
     *    the SSHSession as a tracer.
     */
    public boolean keepAlive(NedWorker w) {
        return true;
    }

    protected void keepSessionAlive(NedWorker w) throws Exception {
        boolean alive = true;
        try {
            alive = this.keepAlive(w);
        } catch (Exception e) {
            alive = false;
        }
        w.isAliveResponse(alive);
    }

    /**
     * This is for any optional commands on the device that are
     * not part of the yang files config data, but is modeled as
     * tailf:actions or rpcs in the device yang files.
     *
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication between NCS and the device. This NedWorker
     *    instance should be used when communicating with NCS, i.e,
     *    for sending responses, errors, and trace messages. It is also
     *    implements the NedTracer API and can be used in, for example,
     *    the SSHSession as a tracer.
     * @param cmdName
     *    Name of the command (path to action?)
     * @param params
     *
     */
    abstract public void command(NedWorker w, String cmdName,
                                 ConfXMLParam[] params) throws Exception;

    /**
     * This method is deprecated. New implementations should implement
     * showStatsPath() and announce
     * http://tail-f.com/ns/ncs-ned/show-stats-path capability.
     *
     * When this method is invoked the NED should write the value
     * of the leaf, indicated by the path, to the provided transaction
     * handler (th) using MAAPI. The worker is free to
     * write other values as well, for example, if a larger chunk of
     * data is read from the backend device. NCS will then not
     * request those paths but read them directly from the transaction.
     * Different timeouts can be provided for different paths. Note
     * however, that all data under a subtree will be removed from the
     * cache once the timeout triggers.
     *
     * The only drawback of this approach is that there is no way
     * for the NED to indicate that a leaf does not exist other than
     * not providing the value when directly asked for its path.
     * Consequently, if a NED writes a larger set of data then the path
     * requested in the method, NCS may still ask for leafs in
     * that data-set if no value has been provided for them (due to
     * them not existing).
     *
     * This method will not invoked if the NED announced capability
     * http://tail-f.com/ns/ncs-ned/show-stats-path
     *
     * The method should indicate its return status by invoking
     * the method w.error() or w.showStatsResponse()
     *
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication between NCS and the device. This NedWorker
     *    instance should be used when communicating with NCS, i.e,
     *    for sending responses, errors, and trace messages. It is also
     *    implements the NedTracer API and can be used in, for example,
     *    the SSHSession as a tracer.
     * @param th
     *    a transaction handler that can be used in Maapi
     * @param path
     *    a ConfPath indication which element is requested
     *
     */
    @Deprecated
    public void showStats(NedWorker w, int th, ConfPath path)
        throws Exception {
        w.error(NedCmd.SHOW_STATS, "not implemented");
    }

    /**
     * This method is deprecated. New implementations should implement
     * showStatsPath() and announce
     * http://tail-f.com/ns/ncs-ned/show-stats-path capability.
     *
     * When this method is invoked the NED should write the full
     * list to the transaction (th), but it is not required to write
     * any data for any of the the instances. It may, however, choose to write
     * more than the requested list, if that is convenient. Often
     * a larger chunk of data is provided by the backend and the NED
     * may then write that to the cache (the transaction th provided).
     *
     * Note that even if the data for a list is written during another
     * invocation, NCS will still invoke the showStatsList() method
     * to make sure that the list instances are written in full.
     * The NED may then just respond with a new timeout and does not
     * have to write the data again to the transaction (but it is
     * a good idea to make sure the data is still stored in the
     * cache (transaction th) using MAAPI.
     *
     * This method will not invoked if the NED announced capability
     * http://tail-f.com/ns/ncs-ned/show-stats-path
     *
     *    The method should indicate its return status by invoking
     *    the method w.error() or w.showStatsResponse()
     *
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication between NCS and the device. This NedWorker
     *    instance should be used when communicating with NCS, i.e,
     *    for sending responses, errors, and trace messages. It is also
     *    implements the NedTracer API and can be used in, for example,
     *    the SSHSession as a tracer.
     * @param th
     *    a transaction handler that can be used in Maapi
     * @param path
     *    a ConfPath indication which list is requested
     *
     */
    @Deprecated
    public void showStatsList(NedWorker w, int th, ConfPath path)
        throws Exception {
        w.error(NedCmd.SHOW_STATS_LIST, "not implemented");
    }

    /**
     * When this method is invoked depending on the node type the NED should:
     *  * If the path points to the list node or leaf-list node without
     *    specifying the key, then the NED should populate the list keys.
     *    The NED should also set the TTL on the list node or individual list
     *    instances. It may choose to write more data into the list instances
     *    in which case it may populate TTL values for this data as well.
     *  * If the path indicates a list entry, presence container, empty leaf or
     *    a leaf-list instance, then the NED should indicate the existence of
     *    this node in the data tree and return the corresponding TTL value. It
     *    may populate more data into the list instance or presence container in
     *    which case it may populate TTL values for this data as well.
     *  * If the path points to a leaf, then the NED should write the value of
     *    the leaf and indicate its TTL.
     *  * If the NED chooses to populate the entire subtree below the path and
     *    has nothing more to fetch, it should indicate so in the TTL value.
     *    The TTL value for this path will act as the default TTL.
     *
     * This method will only be invoked if the NED announced capability
     * http://tail-f.com/ns/ncs-ned/show-stats-path
     *
     * The abovementioned operations should be performed on the provided
     * transaction th.
     *
     * The method should indicate its return status by invoking
     * the method w.error() or w.showStatsPathResponse()
     *
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication between NCS and the device. This NedWorker
     *    instance should be used when communicating with NCS, i.e,
     *    for sending responses, errors, and trace messages. It is also
     *    implements the NedTracer API and can be used in, for example,
     *    the SSHSession as a tracer.
     * @param th
     *    a transaction handler that can be used in Maapi
     * @param path
     *    a ConfPath indication which list is requested
     *
     */
    public void showStatsPath(NedWorker w, int th, ConfPath path)
        throws Exception {
        w.error(NedCmd.SHOW_STATS_PATH, "not implemented");
    }

    /**
     * When this method is invoked the NED should produce a transaction
     * id that must be changed if any changes has been made to the
     * configuration since the last time the transaction id was requested.
     * The transaction id can either be requested from the system,
     * or calculated by the callback, for example by calculating an
     * MD5 checksum of the configuration text.
     *
     *    The method should indicate its return status by invoking
     *    the method w.error() or w.getTransIdResponse()
     *
     *    The method should be implemented if the NED claimed
     *    a NedWorker.TransactionIdMode which is not NONE
     *    in setConnectionData().
     *
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication between NCS and the device. This NedWorker
     *    instance should be used when communicating with NCS, i.e,
     *    for sending responses, errors, and trace messages. It is also
     *    implements the NedTracer API and can be used in, for example,
     *    the SSHSession as a tracer.
     */
    abstract public void getTransId(NedWorker w) throws Exception;

    /**
     * Used for resuming a connection found in the connection pool.
     *
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication between NCS and the device. This NedWorker
     *    instance should be used when communicating with NCS, i.e,
     *    for sending responses, errors, and trace messages. It is also
     *    implements the NedTracer API and can be used in, for example,
     *    the SSHSession as a tracer.
     */
    abstract public void reconnect(NedWorker w) throws Exception;

    /**
     * Used for initializing an transaction. For instance if locking
     * or other transaction preparations are necessary,
     * they should be performed here.
     * Note, that this method has a proper implementation in the base class
     * and is therefore not necessary to override if no NED specific
     * transaction preparations are needed.
     *
     *    The method should indicate its return status by invoking
     *    the method w.error() or w.initializeResponse()
     *
     *    If the NED has claimed a NedWorker.TransactionIdMode other than
     *    not NONE a transaction id must be produced in the response same
     *    as for the getTransId() call.
     *
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication
     *    between NCS and the device. This NedWorker instance should be
     *    used when communicating with NCS, ie for sending responses,
     *    errors, and trace messages. It is also implements the NedTracer
     *    API and can be used in, for example, the SSHSession as a tracer.
     */
    public void initialize(NedWorker w) throws Exception {
        if (transMode == TransactionIdMode.NONE || w.isSuppressTransId()) {
            w.initializeResponse("");
        } else {
            getTransId(w);
        }
    }

    /**
     * If the transaction is not completed and the NED has done initialize
     * this method is called to undo the transaction preparations.
     * That is restoring the NED to the state before initialize.
     * Note, that this method has a proper implementation in the base class
     * and is therefore not necessary to override if no NED specific operations
     * was performed in initialize.
     *
     *    The method should indicate its return status by invoking
     *    the method w.error() or w.uninitializeResponse()
     *
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication between NCS and the device. This NedWorker
     *    instance should be used when communicating with NCS, i.e,
     *    for sending responses, errors, and trace messages. It is also
     *    implements the NedTracer API and can be used in, for example,
     *    the SSHSession as a tracer.
     */
    public void uninitialize(NedWorker w) throws Exception {
        w.uninitializeResponse();
    }

    /**
     * This method is invoked to create a notification subscription.
     * After the subscription has been created the NedWorker can
     * send notifiction messages, in the NETCONF notification format,
     * with the w.notification() method.
     *
     *    The method should indicate its return status by invoking
     *    the method w.error() or w.createSubscriptionResponse()
     *
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication between NCS and the device. This NedWorker
     *    instance should be used when communicating with NCS, i.e,
     *    for sending responses, errors, and trace messages. It is also
     *    implements the NedTracer API and can be used in, for example,
     *    the SSHSession as a tracer.
     * @param stream
     *    The notification stream to establish the subscription on.
     * @param startTime
     *    Trigger the replay feature and indicate that the replay should
     *    start at the time specified. If null, this is not a replay
     *    subscription. It is not valid to specify start times that are
     *    later than the current time. If the time specified is
     *    earlier than the log can support, the replay will begin with
     *    the earliest available notification. This parameter is of
     *    dateTime XML schema type and compliant to RFC 3339.
     *    Implementations must support time zones.
     * @param filter
     *    Indicates which subset of all possible events is of interest.
     *    The format of this parameter is the same as that of the filter
     *    parameter in the NETCONF protocol operations. If not present,
     *    all events not precluded by other parameters will be sent.
     * @param filterType
     *    Indicates the type of filter if it is used:
     *    <ul>
     *    <li> {@link com.tailf.ned.NedCmd#FILTER_NONE}
     *    <li> {@link com.tailf.ned.NedCmd#FILTER_XPATH}
     *    <li> {@link com.tailf.ned.NedCmd#FILTER_SUBTREE}
     *    </ul>
     *
     * @see <a href="https://tools.ietf.org/html/rfc3339">RFC 3339</a>
     * @see <a href="https://tools.ietf.org/html/rfc5277">RFC 5277</a>
     * @see <a href="https://www.w3.org/TR/xmlschema-2/">
     *      XSD-TYPES: XML Schema Part 2: Datatypes Second Edition
     *      </a>
     */
    public void createSubscription(NedWorker w, String stream, String startTime,
                                   String filter, int filterType)
        throws Exception {
        w.error(NedCmd.CREATE_SUBSCRIPTION, "not implemented");
    }

    static protected String retrieveIdentity(NedConnectionBase ned)
        throws NedException {
        InputStream stream = ned.getClass().getClassLoader().
                                getResourceAsStream("package-meta-data.xml");
        if (stream == null) {
            // backward compatibility with old neds.
            String nedName = ned.getClass().getName();
            LOGGER.warn("Ned '" + nedName +
                        "' do not contain the package-meta-data.xml in any " +
                        "of its private jar files");
            return ned.identity();
        }
        // The Xalan/Xerces libraries have their own impl for this factory
        // and it doesn't support disabling external DTD/schema.
        // So, we have to force usage of JDK's built-in implementation here
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(
                "com.sun.org.apache.xerces.internal.jaxp." +
                "DocumentBuilderFactoryImpl",
                NedConnectionBase.class.getClassLoader());
        dbf.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD,
                ""); // SQ Rule java:S2755
        dbf.setAttribute(XMLConstants.ACCESS_EXTERNAL_SCHEMA,
                ""); // SQ Rule java:S2755
        dbf.setNamespaceAware(true);
        DocumentBuilder db;
        try {
            db = dbf.newDocumentBuilder();
            InputSource src = new InputSource(stream);
            Document doc = db.parse(src);

            org.w3c.dom.NodeList nlist = doc.getElementsByTagName("ned-id");
            org.w3c.dom.Node node = nlist.item(0);
            String[] sarr1 = node.getTextContent().split(":");
            String lprefix = sarr1[0].trim();
            String nedid = sarr1[1].trim();
            String attrname = "xmlns:"+lprefix;
            org.w3c.dom.Node nsnode =
                node.getAttributes().getNamedItem(attrname);
            String uri = nsnode.getNodeValue().trim();
            CSSchema schema = Maapi.getSchemas().findCSSchema(uri);
            String prefix = schema.getPrefix();
            String identity = prefix+":"+nedid;
            return identity;
        } catch (Exception e) {
            String nedName = ned.getClass().getName();
            throw new NedException(NedErrorCode.CONNECT_BADKEY,
                     "Could not retrieve ned-id from package-meta-data.xml " +
                      "for ned '" + nedName + "'.", e);
        }
    }
}

/*    -*- Java -*-
 *
 *  Copyright 2010 Tail-F Systems AB. All rights reserved.
 *
 *  This software is the confidential and proprietary
 *  information of Tail-F Systems AB.
 *
 *  $Id$
 *
 */
package com.tailf.ned;

import java.net.InetAddress;
import com.tailf.conf.ConfPath;

/**
 * This class is used for connections between the NCS and CLI based
 * NEDs. A NedCli instance must be combined with a YANG data model
 * that models the data and CLI commands used for talking to the device.
 */

abstract public class NedCliBase extends NedConnectionBase {
    // mangle output, we're invoked during prepare phase
    // of NCS

    /**
     * Is invoked by NCS to take the configuration to a new state. The Ned may
     * choose to apply the changes directly to the device, preferably to a
     * candidate
     * configuration, but if the device lacks candidate support it may choose
     * to apply the changes directly to the running config (typically the case
     * on IOS like boxes). If the configuration changes are later aborted, or
     * reverted, the NCS will provide the necessary commands for restoring the
     * configuration to its previous state. The device should invoke the
     * w.prepareResponse() when the operation is completed.
     *
     *        initialize (prepare transaction)
     *              / \
     *             /   uninitialize (undo preparations)
     *            v
     *        prepare (send data to device)
     *            /   \
     *           v     v
     *        abort | commit(send confirmed commit (ios would do noop))
     *                 /   \
     *                v     v
     *            revert | persist (send confirming commit)
     *
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication
     *    between NCS and the device. This NedWorker instance should be
     *    used when communicating with the NCS, ie for sending responses,
     *    errors, and trace messages. It is also implements the NedTracer
     *    API and can be used in, for example, the SSHSession as a tracer.
     *
     * @param data
     *    is the CLI commands for transforming the configuration to
     *    a new state. The commands are generated using the YANG data
     *    model in combination with the tailf: extensions to guide the
     *    mapping.
     */
    abstract public void prepare(NedWorker w, String data) throws Exception;

    /**
     * Is invoked by NCS to tell the NED what actions it should take towards
     * the device if it should do a prepare.
     *
     * The NED should invoke the method
     * {@link com.tailf.ned.NedWorker#prepareDryResponse(String)
     * prepareDryResponse()}
     * when the operation is completed. If no changes needs to be done
     * just answer <code>prepareDryResponse(data)</code>
     *
     * If an error is detected answer this through a call to
     * {@link com.tailf.ned.NedWorker#error(int,String,String) error()}
     * in <code>NedWorker w</code>.
     *
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication
     *    between NCS and the device. This NedWorker instance should be
     *    used when communicating with the NCS, ie for sending responses,
     *    errors, and trace messages. It is also implements the
     *    {@link NedTracer}
     *    API and can be used in, for example, the {@link SSHSession}
     *    as a tracer.
     *
     * @param data
     *    is the CLI commands for transforming the configuration to
     *    a new state. The commands are generated using the YANG data
     *    model in combination with the tailf: extensions to guide the
     *    mapping.
     */
    abstract public void prepareDry(NedWorker w, String data)
        throws Exception;

    /**
     * Is invoked by NCS to abort the configuration to the state before the
     * previous prepare() invocation. The NCS has calculated the commands needed
     * to reach that state from the current state. The instance may choose
     * to use there commands, or use some other mechanism to reach the same
     * state. When the operation is completed it should invoke the
     * w.abortResponse() method in the NedWorker.
     *
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication
     *    between NCS and the device. This NedWorker instance should be
     *    used when communicating with the NCS, ie for sending responses,
     *    errors, and trace messages. It is also implements the NedTracer
     *    API and can be used in, for example, the SSHSession as a tracer.
     *
     * @param data
     *    is the commands for taking the config back to the previous
     *    state. The commands are generated using the YANG data
     *    model in combination with the tailf: extensions to guide the
     *    mapping.
     */
    abstract public void abort(NedWorker w, String data) throws Exception;

    /**
     * Is invoked by NCS to undo the changes introduced in the last commit
     * operation (communicated to the NED in the prepare method invocation).
     * The difference between abort() and revert() is that revert() is invoked
     * after commit() (but before persist), whereas abort() is invoked before
     * commit(). Once the configuration has been made persistent by persist()
     * it can no longer be restored to any previous  (potentially saved) state.
     * When the revert operation has been completed the w.revertResponse()
     * method should be called.
     *
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication
     *    between NCS and the device. This NedWorker instance should be
     *    used when communicating with the NCS, ie for sending responses,
     *    errors, and trace messages. It is also implements the NedTracer
     *    API and can be used in, for example, the SSHSession as a tracer.
     *
     * @param data
     *    is the commands for taking the config back to the previous
     *    state.
     */
    abstract public void revert(NedWorker w, String data) throws Exception;

    /**
     * Extract parts of the configuration and send it to NCS. The response
     * is sent by invoking the w.showCliResponse() method in the provided
     * NedWorker.
     *
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication
     *    between NCS and the device. This NedWorker instance should be
     *    used when communicating with the NCS, ie for sending responses,
     *    errors, and trace messages. It is also implements the NedTracer
     *    API and can be used in, for example, the SSHSession as a tracer.
     *
     * @param toptag
     *    is the top level tag indicating which part of the config
     *    should be extracted.
     */
    abstract public void show(NedWorker w, String toptag) throws Exception;

    /**
     * @deprecated Use the method
     * {@link #showPartial(NedWorker,ConfPath[],String[])}
     * instead.
     *
     * Extract parts of the configuration and send it to NCS. The response
     * is sent by invoking the w.showCliResponse() method in the provided
     * NedWorker.
     *
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication
     *    between NCS and the device. This NedWorker instance should be
     *    used when communicating with the NCS, ie for sending responses,
     *    errors, and trace messages. It is also implements the NedTracer
     *    API and can be used in, for example, the SSHSession as a tracer.
     *
     * @param cmdpaths
     *    are cmd paths to filter the various parts of the configuration tree
     *    that should be extracted.
     */
    @Deprecated
    public void showPartial(NedWorker w, String[] cmdpaths)
        throws Exception {
        w.error(NedCmd.SHOW_PARTIAL_CLI, "not implemented");
    }

    /**
     * Extract parts of the configuration and send it to NCS. The response
     * is sent by invoking the w.showCliResponse() method in the provided
     * NedWorker.
     *
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication
     *    between NCS and the device. This NedWorker instance should be
     *    used when communicating with the NCS, ie for sending responses,
     *    errors, and trace messages. It is also implements the NedTracer
     *    API and can be used in, for example, the SSHSession as a tracer.
     *
     * @param paths
     *    are paths to filter the various parts of the configuration tree
     *    that should be extracted.
     */
    public void showPartial(NedWorker w, ConfPath[] paths)
        throws Exception {
        w.error(NedCmd.SHOW_PARTIAL_CLI, "not implemented");
    }

    /**
     * Extract parts of the configuration and send it to NCS. The response
     * is sent by invoking the w.showCliResponse() method in the provided
     * NedWorker.
     *
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication
     *    between NCS and the device. This NedWorker instance should be
     *    used when communicating with the NCS, ie for sending responses,
     *    errors, and trace messages. It is also implements the NedTracer
     *    API and can be used in, for example, the SSHSession as a tracer.
     *
     * @param paths
     *    are paths to filter the various parts of the configuration tree
     *    that should be extracted.
     *
     * @param cmdpaths
     *    are cmd paths to filter the various parts of the configuration tree
     *    that should be extracted.
     */
    public void showPartial(NedWorker w, ConfPath[] paths, String[] cmdpaths)
        throws Exception {
        throw new NedWorker.NotImplementedException();
    }

    /**
     * Extract parts of the configuration and send it to NCS. The response
     * is sent by invoking the w.showCliResponse() method in the provided
     * NedWorker.
     *
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication
     *    between NCS and the device. This NedWorker instance should be
     *    used when communicating with the NCS, ie for sending responses,
     *    errors, and trace messages. It is also implements the NedTracer
     *    API and can be used in, for example, the SSHSession as a tracer.
     *
     * @param toptag
     *    is the top level tag indicating which part of the config
     *    should be extracted.
     *
     * @param data
     *    is the CLI commands in native format.
     */
    public void showOffline(NedWorker w, String toptag, String data)
        throws Exception {
        w.error(NedCmd.SHOW_OFFLINE_CLI, "not implemented");
    }

    /**
     * Used by the connection pool to find a matching connection. If
     * the current connection is has the same parameters it should return
     * true, otherwise false.
     *
     * @param deviceId name of device
     * @param ip address to connect to device
     * @param port port to connect to
     * @param proto ssh or telnet
     * @param ruser name of user to connect as
     * @param pass password to use when connecting
     * @param secpass secondary password to use when entering config mode,
     *        set to empty string if not configured in the authgroup
     * @param trace indicates if raw trace messages should be generated or not
     * @param connectTimeout in milliseconds
     * @param readTimeout in milliseconds
     * @param writeTimeout in milliseconds
     */
    abstract public boolean isConnection(String deviceId,
                                         InetAddress ip,
                                         int port,
                                         String proto,  // ssh or telnet
                                         String ruser,
                                         String pass,
                                         String secpass,
                                         String keydir,
                                         boolean trace,
                                         int connectTimeout, // msecs
                                         int readTimeout,    // msecs
                                         int writeTimeout    // msecs
                                        );

    /**
     * Establish a new connection to a device and send response to
     * NCS with information about the device. This information is set by
     * using the setConnectionData() method.
     * A new instance representing the new connection should
     * be returned. That instance will then be used for further communication
     * with the device. Different worker instances may be used for that
     * communication and the instance cannot assume that the worker used in
     * this invocation will be the same used for the invocations of the
     * prepare, abort, revert, persist, show, etc methods.
     *
     * @return the connection instance
     * @param deviceId name of device
     * @param ip address to connect to device
     * @param port port to connect to
     * @param proto ssh or telnet
     * @param ruser name of user to connect as
     * @param pass password to use when connecting
     * @param secpass secondary password to use when entering config mode,
     *        set to empty string if not configured in the authgroup
     * @param publicKeyDir directory to read public keys. null if password is
     *        given
     * @param trace indicates if raw trace messages should be generated or not
     * @param connectTimeout in milliseconds
     * @param readTimeout in milliseconds
     * @param writeTimeout in milliseconds
     * @param mux
     * @param w
     *    The NedWorker instance currently responsible for driving the
     *    communication
     *    between NCS and the device. This NedWorker instance should be
     *    used when communicating with the NCS, ie for sending responses,
     *    errors, and trace messages. It is also implements the NedTracer
     *    API and can be used in, for example, the SSHSession as a tracer.
     */
    abstract public NedCliBase newConnection(String deviceId,
                                         InetAddress ip,
                                         int port,
                                         String proto,  // ssh or telnet
                                         String ruser,
                                         String pass,
                                         String secpass,
                                         String publicKeyDir,
                                         boolean trace,
                                         int connectTimeout, // msecs
                                         int readTimeout,    // msecs
                                         int writeTimeout,   // msecs
                                         NedMux mux,
                                         NedWorker w
                                        );

    /**
     * Make a new instance of Ned object without establishing a connection
     * towards the device. The NED should use previously stored information
     * about the device to initialize its state if needed or throw
     * NedWorker.NotEnoughDataException. It should then send the information
     * about the device using the setConnectionData() method.  A new instance
     * representing the new connection should be returned. That instance can
     * only be used for invoking prepareDry() callback and not for actual
     * communication with the device. close() callback will be invoked
     * before destroying the NED instance, so the implementation of the close()
     * callback should handle cleanup both for instances created with
     * newConnection() and instanced created with initNoConnect()
     *
     * @return the NED instance
     * @param device_id name of device
     * @param mux
     * @param worker
     *    The NedWorker instance currently responsible for driving the
     *    communication between NCS and the device. This NedWorker instance
     *    should be used when communicating with the NCS, ie for sending
     *    responses, errors, and trace messages.
     */
    public NedCliBase initNoConnect(String device_id,
                                    NedMux mux,
                                    NedWorker worker)
        throws NedWorker.NotEnoughDataException {
        throw new NedWorker.NotEnoughDataException();
    }
}

module tailf-ned-avaya-4k-stats {
  namespace 'http://tail-f.com/ned/avaya-4k-stats';
  prefix avaya4k-stats;

  import tailf-common {
    prefix tailf;
  }
  import ietf-inet-types {
    prefix inet;
  }

  import ietf-yang-types {
    prefix yang;
  }

  container stats {
    config false;
    container interface {
      list gigabitEthernet {
        key "num port";
        tailf:cli-key-format "$1/$2";

        leaf num {
          type uint16;
        }

        leaf port {
          type uint16;
        }

        leaf in-packets-per-second {
          type uint64;
        }

        leaf out-packets-per-second {
          type uint64;
        }

        leaf in-octets-per-second {
          type uint64;
        }

        leaf out-octets-per-second {
          type uint64;
        }

        leaf in-octets {
          type uint64;
        }

        leaf out-octets {
          type uint64;
        }

        leaf in-packets {
          type uint64;
        }

        leaf out-packets {
          type uint64;
        }
      }
    }
  }
}

admin@ncs# show devices device r1 live-status interfaces
        
live-status {
    interface gigabitEthernet1/1 {
        in-packets-per-second   234;
        out-packets-per-second  177;
        in-octets-per-second   4567;
        out-octets-per-second  3561;
        in-octets             12666;
        out-octets            16888;
        in-packets             7892;
        out-packets            2892;
     }
        ............

This is the typical behavior of a Cisco IOS device. The simple YANG code snippet below illustrates the behavior. A container with a boolean leaf. Its default value is true.

container aaa {
  leaf enabled {
    default true;
    type boolean;
  }
}

Try setting the leaf to true in NSO and commit. Then compare the configuration:

$ ncs_cli -C -u admin

admin@ncs# config

admin@ncs(config)# devices device a0 config aaa enabled true

admin@ncs(config)# commit

Commit complete.

admin@ncs(config)# top devices device a0 compare-config
      
diff
 devices {
     device a0 {
         config {
             aaa {
-                enabled;
             }
         }
     }
}

The result shows that the configurations differ. The reason is that the device does not display the value of the leaf 'enabled'. It has been trimmed since it has its default value. The NSO is now out of sync with the device.

To solve this issue, make the NED tell the NSO that the device is trimming default values. Register an extra NED Capability entry in the Java code.

NedCapability capas[] = new NedCapability[2];
capas[0] = new NedCapability(
         "",
         "urn:ios",
         "tailf-ned-cisco-ios",
         "",
         "2015-01-01",
         "");
capas[1] = new NedCapability(
        "urn:ietf:params:netconf:capability:" +
        "with-defaults:1.0?basic-mode=trim",    // Set mode to trim
        "urn:ietf:params:netconf:capability:" +
        "with-defaults:1.0",
        "",
        "",
        "",
        "");

Now, try the same operation again:

$ ncs_cli -C -u admin

admin@ncs# config

admin@ncs(config)# devices device a0 config aaa enabled true

admin@ncs(config)# commit

Commit complete.

admin@ncs(config)# top devices device a0 compare-config

admin@ncs(config)#

The NSO is now in sync with the device.

Some devices display default values for leafs even if they have not been explicitly set. The simple YANG code below will be used to illustrate this behavior. A list containing a key and a leaf with a default value.

list interface {
  key id;
  leaf id {
    type string;
  }
  leaf treshold {
    default 20;
    type uint8;
  }
}

Try creating a new list entry in NSO and commit. Then compare the configuration:

$ ncs_cli -C -u admin

admin@ncs# config

admin@ncs(config)# devices device a0 config interface myinterface

admin@ncs(config)# commit

admin@ncs(config)# top devices device a0 compare-config
    
diff
 devices {
     device a0 {
         config {
            interface myinterface {
+              treshold 20;
            }
         }
     }
  }

The result shows that the configurations differ. The NSO is out of sync. This is because the device displays the default value of the 'threshold' leaf even if it has not been explicitly set through the NSO.

To solve this issue, make the NED tell the NSO that the device is reporting all default values. Register an extra NED Capability entry in the Java code.

NedCapability capas[] = new NedCapability[2];
capas[0] = new NedCapability(
       "",
       "urn:abc",
       "tailf-ned-abc",
       "",
       "2015-01-01",
       "");
capas[1] = new NedCapability(
      "urn:ietf:params:netconf:capability:" +
      "with-defaults:1.0?basic-mode=report-all",  // Set mode to report-all
      "urn:ietf:params:netconf:capability:" +
      "with-defaults:1.0",
      "",
      "",
      "",
      "");

Now, try the same operation again:

$ ncs_cli -C -u admin

admin@ncs# config

admin@ncs(config)# devices device a0 config interface myinterface

admin@ncs(config)# commit

Commit complete.

admin@ncs(config)# top devices device a0 compare-config

admin@ncs(config)#

The NSO is now in sync with the device.

Assume a device that creates additional configuration as described above. The YANG code snippet below will be used to illustrate this.

list A {
  key a;
  leaf a {
    type string;
  }
  list B {
    key b;
    leaf b {
      type string;
    }
  }
}

Try creating a new list entry in NSO and commit. Then compare the configuration:

$ ncs_cli -C -u admin

admin@ncs# config

admin@ncs(config)# devices device a0 config A mylist

admin@ncs(config)# commit

admin@ncs(config)# commit dry-run outformat cli
cli  devices {
         device a0 {
             config {
    +            A mylist {
    +            }
             }
         }
     }

Commit complete.

admin@ncs(config)# top devices device a0 compare-config
  
diff
 devices {
     device a0 {
         config {
            A mylist {
+              B default {
+              }
            }
         }
     }
 }

The device has automatically created the sub list 'default' when it created the list 'mylist'. The result is that NSO is now out of sync with the device.

The solution is to implement a set hook in the NED that makes the NSO mimic the device properly. In this case it shall create an entry named 'default' in the sub list B each time it creates an entry in list A.

The Java implementation of the set hook would look something like this:

public class XYZDp {

    @Resource(type=ResourceType.MAAPI, scope=Scope.INSTANCE)
    public Maapi mm;

    /*
     * Set hook.
     * Called when a new entry in the A list is created.
     * The callpoint to be mapped in the YANG model is
     * "list-a-create-hook"
     */
    @DataCallback(callPoint="list-a-create-hook", callType=DataCBType.CREATE)
    public int createSublistBEntry(DpTrans trans, ConfObject[] keyPath)
        throws DpCallbackException {

        try {
            int tid = trans.getTransaction();
            ConfPath cp = new ConfPath(keyPath);

            // Create a sublist entry <path>/B{"default"}
            cp.append("/B{default}");
            mm.safeCreate(tid, cp);

            return Conf.REPLY_OK;
        }
        catch (Exception e) {
            throw new DpCallbackException("", e);
        }
    }

    // Init routine
    @TransCallback(callType=TransCBType.INIT)
    public void XYZDpInit(DpTrans trans) throws DpCallbackException {

        try {
            if (mm == null) {
                // Need a Maapi socket so that we can attach
                Socket s = new Socket("127.0.0.1", NcsMain.getInstance().
                                      getNcsPort());
                mm = new Maapi(s);
            }
            mm.attach(trans.getTransaction(),0,
                      trans.getUserInfo().getUserId());
            return;
        }
        catch (Exception e) {
            throw new DpCallbackException("Failed to attach", e);
        }
    }


    // Finish routine
    @TransCallback(callType=TransCBType.FINISH)
    public void XYZDpFinish(DpTrans trans) throws DpCallbackException {

        try {
            mm.detach(trans.getTransaction());
        }
        catch (Exception e) {
            ;
        }
    }
}

Finally the YANG model is extended with an extra annotation:

list A {
  tailf:callpoint list-a-create-hook { tailf:set-hook node; }
  key a;
  leaf a {
    type string;
  }
  list B {
    key b;
    leaf b {
      type string;
    }
  }
}

Now, try the same operation again. Create a new list entry in NSO and commit. Then compare the configuration:

$ ncs_cli -C -u admin

admin@ncs# config

admin@ncs(config)# devices device a0 config A mylist

admin@ncs(config)# commit

admin@ncs(config)# commit dry-run outformat cli
cli  devices {
         device a0 {
             config {
    +            A mylist {
    +                B default;
    +            }
             }
         }
     }

Commit complete.

admin@ncs(config)# top devices device a0 compare-config

admin@ncs(config)#

The NSO has now automatically created the "default" entry in sub list B the same way as the device does. The NSO will now be in sync with the device.